Well my friends, fear not. If you enjoy the sweet freedom of RESTful urls, I’m here to help. Since this is all built on top of WSGI, we can create a some new Middleware to sit before the application to resolve this little issue.

MockHTTPMethodMiddleware

from google.appengine.ext import webapp

class MockHTTPMethodMiddleware(object):
  def __init__(self, app):
    self.app = app

  def __call__(self, environ, start_response):
    method = webapp.Request(environ).get('_method')
    if method:
      environ['REQUEST_METHOD'] = method.upper()
    return self.app(environ, start_response)

The code is pretty simple. So when this middleware is called, it processes the environ into a Request object. From there, I just inspect the params for a key called _method. If that param exists, then it overwrites the REQUEST_METHOD and bam…we have mocked the HTTP method of our choosing.

Putting that code to good use

Let’s pretend that this is our class is something inane like this:

from google.appengine.ext import webapp

class MethodTest(webapp.RequestHandler):
  def get(self):
    self.response.headers["Content-Type"] = 'text/text'
    self.response.out.write("Get")

  def put(self):
    self.response.headers["Content-Type"] = 'text/text'
    self.response.out.write("Put")

So now when you are writing your main method that creates the WSGI application, you would write it something like:

import wsgiref.handlers

def main():
  app = webapp.WSGIApplication(
      [('/', MethodTest)],
      debug=True)
  wsgiref.handlers.CGIHandler().run(MockHTTPMethodMiddleware(app))

if __name__ == "__main__":
  main()

Notice that in the run method arguments, MockHTTPMethodMiddleware takes app as a parameter, thus MockHTTPMethodMiddleware will run before it runs app.

Conclusion

While there wasn’t support out of the box for mocking HTTP methods for browsers, with a little help from a WSGI Middleware class, it’s not too hard to add that functionality in, nor is it hard to add anything else you would want to use.

Why Rack

Well for one, it’s light weight. So if you want to deploy your ruby script using CGI, you can do that with Rack.

But let’s say, you want to your script to Mongrel, or WEBRick, or FCGI; you can do that too, and with very few changes to your script. That’s because Rack abstracts all the boilerplate code you would need to work with those servers and bundles it up into a nice interface for you to use.

Oh, and the code to use Rack is very easy. Here’s an example of a Rack app for you:

Examples

%w(rubygems rack haml).each { |dep| require dep }

class IndexPage
  def call(env)
    haml_engine = Haml::Engine.new(File.read('../templates/index.haml'))
    [
      200,
      { "Content-Type" => "text/html" },
      haml_engine.render(Object.new, {})
    ]
  end
end

Rack::Handler::CGI.run(IndexPage.new)

The secret behind Rack is that it will run any ruby object that has a call method and pass in the environment variables to it. In that environment variable, you will find things like HTTP_HOST, or QUERY_STRING, and the like.

If you wanted to have this script now work with WEBRick, no problem.

# Same code as above, with just a little tweak to the last line

Rack::Handler::WEBRick.run(IndexPage.new, :Port => 3000)

Tada! So now you can run a test server without worrying about setting up Apache or Lighttpd.

More Goodness

To make your life easier, Rack also comes with a set of middleware for you to use. Say you have an error in your application. Perhaps you would like to see that error formatted nicely in your browser. You can enable Rack::ShowExceptions. Perhaps you would like the code you have to be reloaded from the server whenever it changes, like when you’re developing your application, then you can use Rack::Reloader.

To use those options, you can write your Rack handler like

app = Rack::Builder.new do
  use Rack::CommonLogger  # apache-like logger
  use Rack::ShowExceptions
  use Rack::Reloader
  use Rack::ShowStatus  # create default pages for common HTTP error codes
  use Rack::Lint  #ensures all applications behave validly
  run Index.new
end
Rack::Handler::WEBRick.run(app, :Port => 3000)

There’s plenty of magic going on with Rack; A magic that does not sacrifice speed and/or flexibility. I would highly recommend giving Rack a look into the next time you want to write a simple web page.