= New Plugins

* A json_parser plugin has been added, for parsing request bodies in
  JSON format.  This is faster than using a middleware to perform
  the same task.  This plugin supports a :parser option to use a
  custom JSON parser, an :include_request option to include the
  request when calling the parser, and a :error_handler option for
  a proc to call with the request if there is an error when parsing.
  Example:

    plugin :json_parser,
      :parser=>JSON.method(:parse),
      :include_request=>false,
      :error_handler=>proc{|r| r.halt [400, {}, []]} 

* A path_rewriter plugin has been added, allowing for the rewriting
  of paths before routing.  This allows you to rewrite just the
  routing path (the default), or PATH_INFO as well as the routing
  path (if the :path_info option is used).  This is useful if you
  want to internally treat one path exactly the same as another
  path.

  By default, path rewriting is done on prefixes, so any path that
  starts with the prefix will be rewritten.  You can pass a
  Regexp when rewriting the path for more complete control.

  Examples:

    plugin :path_rewriter
    rewrite_path '/a', '/b'
    # GET /a treated as GET /b
    # GET /a/c treated as GET /b/c

    rewrite_path /\A\/c\z/, '/d'
    # GET /c treated as GET /d
    # GET /c/e no change

* A precompiled_templates plugin has been added, for precompiling
  templates before starting the application.  This can save a
  substantial amount of memory if you are using large templates or
  a large number of small templates in conjunction when using
  application preloading with a forking webserver.  Example:

    plugin :precompile_templates
    precompile_templates "views/\*\*/*.erb"
    precompile_templates "views/users/_*.erb", :locals=>[:user]

* A heartbeat plugin has been added, for easily handling
  heartbeat/status requests.  If a heartbeat/status request comes in,
  it will get a 200 response with a body of "OK".  This is designed
  for automated systems that check if the application is functioning.
  The default heartbeat path is /heartbeat, but you can choose a
  different one using the :path option.

    plugin :heartbeat, :path=>'/heartbeat'

= Other New Features

* The json plugin now supports a :serializer option to use a custom
  serializer.  Additionally, it now supports a :include_request
  option to include the request when calling the serializer.

* In the render plugin, the render/view methods now support a
  :cache=>false option to not cache the template.  This can be useful
  for large but rarely used templates, or where a new template object
  is created for every render/view call.

* In the render plugin, the render/view methods now support a
  :cache_key option to force a specific cache key.  Manually setting
  cache keys can result in improved performance, as automatically
  determining the cache key can be a relatively expensive operation.

* The render plugin now supports a :engine_opts option, to specify
  per-template engine options.  :engine options should be a hash
  keyed by render engine strings, with values being hashes of
  template options.

* In the mailer plugin, a no_mail! method is now supported when
  mailing, which will skip the current mail.  This makes it easier
  to delay the decision about actually sending the email till it is
  time to send the email, which makes it easier to avoid race
  conditions if you are using a job queue for mailing.

= Other Improvements

* Roda avoids rehashing hashes at runtime in some places, for a minor
  speedup.

* If the :template_block is given to render/view, default to not
  caching the template, since it is likely the template block is
  specific to the request.  Allow for the :cache=>true option to be
  used to force the caching of the template.

* Roda now returns a 404 response for unmatched GET requests when
  using the assets and json plugins where r.assets is the last
  method called in a route block.

= Backwards Compatibility

* In the render plugin, the :ext option to the plugin and to the
  render/view methods is now replaced by the :engine option.
  Previously, :engine was used by default if :ext was not given. In
  general, there is no need for two separate options, the engine is
  used as the extension by Tilt.

  In general, this is a backwards compatible change, except when
  both :ext and :engine were specified differently as plugin options,
  and an inline template is used with render or view without either
  the :ext or :engine options being specified.