RubyGems - roda - Versions diffs - 1.1.0 → 1.2.0 - Mend

roda 1.1.0 → 1.2.0

Files changed (63) hide show

checksums.yaml +4 -4
data/CHANGELOG +70 -0
data/README.rdoc +261 -302
data/Rakefile +1 -1
data/doc/release_notes/1.2.0.txt +406 -0
data/lib/roda.rb +206 -124
data/lib/roda/plugins/all_verbs.rb +11 -10
data/lib/roda/plugins/assets.rb +5 -5
data/lib/roda/plugins/backtracking_array.rb +12 -5
data/lib/roda/plugins/caching.rb +10 -8
data/lib/roda/plugins/class_level_routing.rb +94 -0
data/lib/roda/plugins/content_for.rb +6 -0
data/lib/roda/plugins/default_headers.rb +4 -11
data/lib/roda/plugins/delay_build.rb +42 -0
data/lib/roda/plugins/delegate.rb +64 -0
data/lib/roda/plugins/drop_body.rb +33 -0
data/lib/roda/plugins/empty_root.rb +48 -0
data/lib/roda/plugins/environments.rb +68 -0
data/lib/roda/plugins/error_email.rb +1 -2
data/lib/roda/plugins/error_handler.rb +1 -1
data/lib/roda/plugins/halt.rb +7 -5
data/lib/roda/plugins/head.rb +4 -2
data/lib/roda/plugins/header_matchers.rb +17 -9
data/lib/roda/plugins/hooks.rb +16 -32
data/lib/roda/plugins/json.rb +4 -10
data/lib/roda/plugins/mailer.rb +233 -0
data/lib/roda/plugins/match_affix.rb +48 -0
data/lib/roda/plugins/multi_route.rb +9 -11
data/lib/roda/plugins/multi_run.rb +81 -0
data/lib/roda/plugins/named_templates.rb +93 -0
data/lib/roda/plugins/not_allowed.rb +43 -48
data/lib/roda/plugins/path.rb +63 -2
data/lib/roda/plugins/render.rb +79 -48
data/lib/roda/plugins/render_each.rb +6 -0
data/lib/roda/plugins/sinatra_helpers.rb +523 -0
data/lib/roda/plugins/slash_path_empty.rb +25 -0
data/lib/roda/plugins/static_path_info.rb +64 -0
data/lib/roda/plugins/streaming.rb +1 -1
data/lib/roda/plugins/view_subdirs.rb +12 -8
data/lib/roda/version.rb +1 -1
data/spec/integration_spec.rb +33 -0
data/spec/plugin/backtracking_array_spec.rb +24 -18
data/spec/plugin/class_level_routing_spec.rb +138 -0
data/spec/plugin/delay_build_spec.rb +23 -0
data/spec/plugin/delegate_spec.rb +20 -0
data/spec/plugin/drop_body_spec.rb +20 -0
data/spec/plugin/empty_root_spec.rb +14 -0
data/spec/plugin/environments_spec.rb +31 -0
data/spec/plugin/h_spec.rb +1 -3
data/spec/plugin/header_matchers_spec.rb +14 -0
data/spec/plugin/hooks_spec.rb +3 -5
data/spec/plugin/mailer_spec.rb +191 -0
data/spec/plugin/match_affix_spec.rb +22 -0
data/spec/plugin/multi_run_spec.rb +31 -0
data/spec/plugin/named_templates_spec.rb +65 -0
data/spec/plugin/path_spec.rb +66 -2
data/spec/plugin/render_spec.rb +46 -1
data/spec/plugin/sinatra_helpers_spec.rb +534 -0
data/spec/plugin/slash_path_empty_spec.rb +22 -0
data/spec/plugin/static_path_info_spec.rb +50 -0
data/spec/request_spec.rb +23 -0
data/spec/response_spec.rb +12 -1
metadata +48 -6

data/Rakefile CHANGED

@@ -17,7 +17,7 @@ end
 ### RDoc
-RDOC_DEFAULT_OPTS = ["--line-numbers", "--inline-source", '--title', 'Roda: Routing tree web framework']
+RDOC_DEFAULT_OPTS = ["--line-numbers", "--inline-source", '--title', 'Roda: Routing tree web framework toolkit']
 begin
   gem 'hanna-nouveau'

data/doc/release_notes/1.2.0.txt ADDED

@@ -0,0 +1,406 @@
+= New Plugins
+* A static_path_info plugin has been added, which doesn't modify
+  SCRIPT_NAME/PATH_INFO during routing, only before dispatching
+  the request to another rack application via r.run.  This is
+  faster and avoids problems caused by changing SCRIPT_NAME/PATH_INFO
+  during routing, such as methods that return paths that depend on
+  SCRIPT_NAME.  This behavior will become Roda's default starting
+  in Roda 2, and it is recommended that all Roda apps use it.
+* A mailer plugin has been added, which allows you to use Roda's
+  render plugin to create email bodies, and allows you to use Roda's
+  routing tree features to DRY up your mailing code similar to how it
+  DRYs up your web code.
+  Here is an example routing tree using the mailer plugin:
+    class Mailer < Roda
+      plugin :render
+      plugin :mailer
+      route do |r|
+        r.on "user/:d" do |user_id|
+          # DRY up code by setting shared behavior in higher level
+          # branches, instead of duplicating it inside each subtree.
+          @user = User[user_id]
+          from 'notifications@example.com'
+          to @user.email
+          r.mail "open_account" do
+            subject 'Welcome to example.com'
+            render(:open_account)
+          end
+          r.mail "close_account" do
+            subject 'Thank you for using example.com'
+            render(:close_account)
+          end
+        end
+      end
+    end
+  With your routing tree setup, you can use the sendmail method to
+  send email:
+    Mailer.sendmail("/user/1/open_account")
+  If you want a Mail::Message object returned for further modification
+  before sending, you can use mail instead of of sendmail:
+    Mailer.mail("/user/2/close_account").deliver
+* A delegate plugin has been added, allowing you to easily create
+  methods in the route block scope that delegate to the request or
+  response.  While Roda does not pollute your namespaces by default,
+  this allows you to choose to do so yourself if you find it offers
+  a nicer API.  Example:
+    class App < Roda
+      plugin :delegate
+      request_delegate :root, :on, :is, :get, :post, :redirect
+      route do |r|
+        root do
+          redirect "/hello"
+        end
+        on "hello" do
+          get "world" do
+            "Hello world!"
+          end
+          is do
+            get do
+              "Hello!"
+            end
+            post do
+              puts "Someone said hello!"
+              redirect
+            end
+          end
+        end
+      end
+    end
+* A class_level_routing plugin has been added, allowing you to define
+  your routes at the class level if desired.  The routes defined at
+  the class level can still use a routing tree for further routing.
+  Example:
+    class App < Roda
+      plugin :class_level_routing
+      root do
+        request.redirect "/hello"
+      end
+      get "hello/world" do
+        "Hello world!"
+      end
+      is "hello" do
+        request.get do
+          "Hello!"
+        end
+        request.post do
+          puts "Someone said hello!"
+          request.redirect
+        end
+      end
+    end
+* A named_templates plugin has been added, for creating inline
+  templates associated with a given name, that are used by
+  the render plugin's render/view method in preference to
+  templates stored in the filesystem.  This makes it simpler to
+  ship single-file Roda applications that use templates. Example:
+    class App < Roda
+      plugin :named_templates
+      template :layout do
+        "<html><body><%= yield %></body></html>"
+      end
+      template :index do
+        "<p>Hello <%= @user %>!</p>"
+      end
+      route do |r|
+        @user = 'You'
+        render(:index)
+      end
+      # => "<html><body><p>Hello You!</p></body></html>"
+    end
+* A multi_run plugin has been added, for dispatching to multiple
+  rack applications based on the request path prefix.  This
+  provides a similar API as the multi_route plugin, but allows
+  you to separate your applications per routing subtree, as
+  opposed to multi_route which uses the same application for
+  all routing subtrees.
+  With the multi_run plugin, you call the class level run method
+  with the routing prefix and the rack application to use, and
+  you call r.multi_run to dispatch to all of the applications
+  based on the prefix.
+    class App < Roda
+      plugin :multi_run
+      run "foo", Foo
+      run "bar", Bar
+      run "baz", Baz
+      route do |r|
+        r.multi_run
+      end
+    end
+  In this case, Foo, Bar, and Baz, can be subclasses of App, which
+  allows them to share methods that should be shared, but still
+  define methods themselves that are not shared by the other
+  applications.
+* A sinatra_helpers plugin has been added, that ports over most
+  of the Sinatra::Helpers methods that haven't already been added
+  by other plugins.  All of the methods are added either to the
+  request or response class as appropriate.  By default, delegate
+  methods are also added to the route block scope, but you can
+  turn this off by passing a :delegate=>false option when loading
+  the plugin, which avoids polluting the route block namespace.
+  The sinatra_helpers plugin adds the following request methods:
+  * back
+  * error
+  * not_found
+  * uri
+  * send_file
+  And the following response methods:
+  * body
+  * body=
+  * status
+  * headers
+  * mime_type
+  * content_type
+  * attachment
+  * informational?
+  * success?
+  * redirect?
+  * client_error?
+  * not_found?
+  * server_error?
+* A slash_path_empty plugin has been added, which changes Roda
+  so that "/" is considered an empty path when doing a
+  terminal match via r.is or r.get/r.post with a path.
+    class App < Roda
+      plugin :slash_path_empty
+      route do |r|
+        r.get "albums" do
+          # matches both GET /albums and GET /albums/
+        end
+      end
+    end
+* An empty_root plugin has been added, which makes r.root match
+  the empty string, in addition to /.  This can be useful in
+  cases where a partial match on the patch has been completed.
+    class App < Roda
+      plugin :empty_root
+      route do |r|
+        r.on "albums" do
+          r.root do
+            # matches both GET /albums and GET /albums/
+          end
+        end
+      end
+    end
+* A match_affix plugin has been added, for overriding the default
+  prefix/suffix used in match patterns.  For example, if you want
+  to require that a leading / be specified in your routes. and
+  you want to consume any trailing slash:
+    class App < Roda
+      plugin :match_affix, "", /(\/|\z)/
+      route do |r|
+        r.on "/albums" do |s|
+          # GET /albums # s => ""
+          # GET /albums/ # s => "/"
+        end
+      end
+    end
+* An environments plugin has been added, giving some simple
+  helpers for executing code in different environments.  Example:
+    class App < Roda
+     plugin :environments
+     environment  # => :development
+     development? # => true
+     test?        # => false
+     production?  # => false
+     # Set the environment for the application
+     self.environment = :test
+     test?        # => true
+     configure do
+       # called, as no environments given
+     end
+     configure :development, :production do
+       # not called, as no environments match
+     end
+     configure :test do
+       # called, as environment given matches current environment
+     end
+    end
+* A drop_body plugin has been added, which automatically drops the
+  body, Content-Type header, and Content-Length header when the
+  response status indicates no body (100-102, 204, 205, 304).
+* A delay_build plugin has been added, which delays building the
+  rack application until Roda.app is called, and only rebuilds the
+  rack application if build! is called.  This removes O(n^2)
+  performance in the pathological case of adding a route block
+  and then calling Roda.use many times to add middlewares, though
+  you have to add a few hundred middlewares for the difference
+  to be noticeable.
+= New Features
+* r.remaining_path and r.matched_path have been added for returning
+  the remaining path that will be used for matching, and for
+  returning the path already matched.  Currently, these just provide
+  the PATH_INFO and SCRIPT_NAME, but starting in Roda 2 PATH_INFO
+  and SCRIPT_NAME will not be modified during routing, and you'll
+  need to use these methods if you want to find out the remaining
+  or already matched paths.
+* The render plugin now supports a :template option to render/view
+  to specify the template to use, instead of requiring a separate
+  argument.
+* The render plugin now supports a :template_class option, allowing
+  you to override the default template class that Roda would use.
+* The render plugin now supports a :template_block option, specifying
+  the block to pass when creating a template.
+* The path class method added by the path plugin now accepts :name,
+  :url, :url_only, and :add_script_name options:
+  :name :: Specifies name for method
+  :url :: Creates a url method in addition to a path method
+  :url_only :: Only creates a url method, not a path method
+  :add_script_name :: prefixes the path with SCRIPT_NAME
+  Note that if you plan to use :add_script_name, you should use
+  the static_path_info plugin so that the method created does not
+  return different results depending on where you are in the
+  routing tree.
+* A :user_agent hash matcher has been added to the header_matchers
+  plugin.
+* An inherit_middleware class accessor has been added.  This can
+  be set to false if you do not want subclasses to inherit
+  middleware from the superclass.  This is useful if the
+  superclass dispatches to the subclass via r.run, as otherwise
+  it would have to run the the same middleware stack twice.
+* A clear_middleware! class accessor has been added, allowing
+  you to clear the current middleware stack.
+* RodaRequest#default_redirect_status has been added, allowing
+  plugins to override the default status used for redirect if
+  a status is not given.
+* Roda{Request,Response}#roda_class has been added, which
+  returns the Roda class related to the given request/response.
+= Other Improvements
+* The render plugin no longer caches templates by default if
+  RACK_ENV is development.
+* When subclassing a Roda app, unfrozen Array/Hash entries in the
+  opts hash are now duped into the subclass, so the subclass
+  no longer needs to dup them manually.  Note that plugins that
+  use nested arrays/hashes in the opts hash still need to dup
+  manually inside ClassMethods#inherited.  For the plugins where
+  it is possible, it is recommended to store plugin options in a
+  frozen object in the opts hash, and require loading the plugin
+  again to modify the plugin options.
+* Caching of templates is now fixed when the render/view :opts is
+  used to specify template options per-call.
+* An explicit :default_encoding of nil in the render plugin's
+  :opts hash is no longer overwritten with
+  Encoding.default_external.
+* Roda#session now returns the same object as RodaRequest#session.
+* The view_subdirs, content_for, and render_each plugins now all
+  depend on the render plugin.
+* The not_allowed plugin now depends on the all_verbs plugin.
+* Local/instance variables are now used in more places instead of
+  method calls, improving performance.
+= Backwards Compatibility
+* The render plugin's render/view methods no longer pass the given
+  hash directly to the underlying template.  To pass options to the
+  template engine, use a separate hash under the :opts key:
+    render :file, :opts=>{:foo=>'bar'}
+  This is more consistent with the class-level render plugin options,
+  which also uses :opts to pass options to the template engine.
+  The :js_opts and :css_opts options to the assets plugin are now
+  passed as the :opts hash, so they continue to affect the template
+  engine, so they no longer specify general render method options.
+* Modifying render_opts :layout after loading the render plugin
+  now has no effect.  You need to use plugin :render, :layout=>'...'
+  to set the layout to use now.
+* Default headers are not set on a response until the response is
+  finished.  This allows you to check for header presence during
+  routing to detect whether the header was specifically set for the
+  current request.
+* RodaRequest.consume_pattern no longer captures anything by default.
+  Previously, it did so in order to update SCRIPT_NAME, but that is
+  now handled differently.  This should only affect external plugins
+  that attempt to override RodaRequest#consume.
+* RodaRequest.def_verb_method has been removed.
+* The hooks, default_headers, json, and multi_route plugins all store
+  their class-level metadata in the opts hash instead of separate
+  class instance variables.  This should have no affect unless you
+  were accessing the class instance variables directly.
+* The render plugin internals changed significantly, it now passes
+  internal data using a hash.  This should only affect users that
+  were overriding render plugin methods.

data/lib/roda.rb CHANGED

@@ -54,6 +54,7 @@ class Roda
   end
   @app = nil
+  @inherit_middleware = true
   @middleware = []
   @opts = {}
   @route_block = nil
@@ -89,13 +90,16 @@ class Roda
     # Methods are put into a plugin so future plugins can easily override
     # them and call super to get the default behavior.
     module Base
-      SESSION_KEY = 'rack.session'.freeze
       # Class methods for the Roda class.
       module ClassMethods
         # The rack application that this class uses.
         attr_reader :app
+        # Whether middleware from the current class should be inherited by subclasses.
+        # True by default, should be set to false when using a design where the parent
+        # class accepts requests and uses run to dispatch the request to a subclass.
+        attr_accessor :inherit_middleware
         # The settings/options hash for the current class.
         attr_reader :opts
@@ -110,6 +114,12 @@ class Roda
           app.call(env)
         end
+        # Clear the middleware stack
+        def clear_middleware!
+          @middleware.clear
+          build_rack_app
+        end
         # Create a match_#{key} method in the request class using the given
         # block, so that using a hash key in a request match method will
         # call the block.  The block should return nil or false to not
@@ -134,8 +144,14 @@ class Roda
         # and setup the request and response subclasses.
         def inherited(subclass)
           super
-          subclass.instance_variable_set(:@middleware, @middleware.dup)
+          subclass.instance_variable_set(:@inherit_middleware, @inherit_middleware)
+          subclass.instance_variable_set(:@middleware, @inherit_middleware ? @middleware.dup : [])
           subclass.instance_variable_set(:@opts, opts.dup)
+          subclass.opts.to_a.each do |k,v|
+            if (v.is_a?(Array) || v.is_a?(Hash)) && !v.frozen?
+              subclass.opts[k] = v.dup
+            end
+          end
           subclass.instance_variable_set(:@route_block, @route_block)
           subclass.send(:build_rack_app)
@@ -155,36 +171,36 @@ class Roda
         #
         #   Roda.plugin PluginModule
         #   Roda.plugin :csrf
-        def plugin(mixin, *args, &block)
-          if mixin.is_a?(Symbol)
-            mixin = RodaPlugins.load_plugin(mixin)
+        def plugin(plugin, *args, &block)
+          if plugin.is_a?(Symbol)
+            plugin = RodaPlugins.load_plugin(plugin)
           end
-          if mixin.respond_to?(:load_dependencies)
-            mixin.load_dependencies(self, *args, &block)
+          if plugin.respond_to?(:load_dependencies)
+            plugin.load_dependencies(self, *args, &block)
           end
-          if defined?(mixin::InstanceMethods)
-            include mixin::InstanceMethods
+          if defined?(plugin::InstanceMethods)
+            include(plugin::InstanceMethods)
           end
-          if defined?(mixin::ClassMethods)
-            extend mixin::ClassMethods
+          if defined?(plugin::ClassMethods)
+            extend(plugin::ClassMethods)
           end
-          if defined?(mixin::RequestMethods)
-            self::RodaRequest.send(:include, mixin::RequestMethods)
+          if defined?(plugin::RequestMethods)
+            self::RodaRequest.send(:include, plugin::RequestMethods)
           end
-          if defined?(mixin::RequestClassMethods)
-            self::RodaRequest.extend mixin::RequestClassMethods
+          if defined?(plugin::RequestClassMethods)
+            self::RodaRequest.extend(plugin::RequestClassMethods)
           end
-          if defined?(mixin::ResponseMethods)
-            self::RodaResponse.send(:include, mixin::ResponseMethods)
+          if defined?(plugin::ResponseMethods)
+            self::RodaResponse.send(:include, plugin::ResponseMethods)
           end
-          if defined?(mixin::ResponseClassMethods)
-            self::RodaResponse.extend mixin::ResponseClassMethods
+          if defined?(plugin::ResponseClassMethods)
+            self::RodaResponse.extend(plugin::ResponseClassMethods)
           end
-          if mixin.respond_to?(:configure)
-            mixin.configure(self, *args, &block)
+          if plugin.respond_to?(:configure)
+            plugin.configure(self, *args, &block)
           end
         end
@@ -315,7 +331,7 @@ class Roda
         #
         #   env['REQUEST_METHOD'] # => 'GET'
         def env
-          request.env
+          @_request.env
         end
         # The class-level options hash.  This should probably not be
@@ -340,10 +356,12 @@ class Roda
           @_response
         end
-        # The session for the current request.  Raises a RodaError if
-        # a session handler has not been loaded.
+        # The session hash for the current request. Raises RodaError
+        # if no session existsExample:
+        #
+        #   session # => {}
         def session
-          env[SESSION_KEY] || raise(RodaError, "You're missing a session handler. You can get started by adding use Rack::Session::Cookie")
+          @_request.session
         end
         private
@@ -352,8 +370,9 @@ class Roda
         # behavior after the request and response have been setup.
         def _route(&block)
           catch(:halt) do
-            request.block_result(instance_exec(@_request, &block))
-            response.finish
+            r = @_request
+            r.block_result(instance_exec(r, &block))
+            @_response.finish
           end
         end
       end
@@ -379,17 +398,6 @@ class Roda
           pattern
         end
-        # Define a verb method in the given that will yield to the match block
-        # if the request method matches and there are either no arguments or
-        # there is a successful terminal match on the arguments.
-        def def_verb_method(mod, verb)
-          mod.class_eval(<<-END, __FILE__, __LINE__+1)
-            def #{verb}(*args, &block)
-              _verb(args, &block) if #{verb == :get ? :is_get : verb}?
-            end
-          END
-        end
         # Since RodaRequest is anonymously subclassed when Roda is subclassed,
         # and then assigned to a constant of the Roda subclass, make inspect
         # reflect the likely name for the class.
@@ -403,7 +411,7 @@ class Roda
         # pattern requires the path starts with a string and does not match partial
         # segments.
         def consume_pattern(pattern)
-          /\A(\/(?:#{pattern}))(?=\/|\z)/
+          /\A\/(?:#{pattern})(?=\/|\z)/
         end
       end
@@ -418,6 +426,7 @@ class Roda
         SEGMENT = "([^\\/]+)".freeze
         TERM_INSPECT = "TERM".freeze
         GET_REQUEST_METHOD = 'GET'.freeze
+        SESSION_KEY = 'rack.session'.freeze
         TERM = Object.new
         def TERM.inspect
@@ -440,15 +449,20 @@ class Roda
           super(env)
         end
-        # As request routing modifies SCRIPT_NAME and PATH_INFO, this exists
-        # as a helper method to get the full path of the request.
-        #
-        #   r.env['SCRIPT_NAME'] = '/foo'
-        #   r.env['PATH_INFO'] = '/bar'
-        #   r.full_path_info
-        #   # => '/foo/bar'
-        def full_path_info
-          "#{@env[SCRIPT_NAME]}#{@env[PATH_INFO]}"
+        # Handle match block return values.  By default, if a string is given
+        # and the response is empty, use the string as the response body.
+        def block_result(result)
+          res = response
+          if res.empty? && (body = block_result_body(result))
+            res.write(body)
+          end
+        end
+        # Match GET requests.  If no arguments are provided, matches all GET
+        # requests, otherwise, matches only GET requests where the arguments
+        # given fully consume the path.
+        def get(*args, &block)
+          _verb(args, &block) if is_get?
         end
         # Immediately stop execution of the route block and return the given
@@ -465,29 +479,13 @@ class Roda
           throw :halt, res
         end
-        # Optimized method for whether this request is a +GET+ request.
-        # Similar to the default Rack::Request get? method, but can be
-        # overridden without changing rack's behavior.
-        def is_get?
-          @env[REQUEST_METHOD] == GET_REQUEST_METHOD
-        end
-        # Handle match block return values.  By default, if a string is given
-        # and the response is empty, use the string as the response body.
-        def block_result(result)
-          res = response
-          if res.empty? && (body = block_result_body(result))
-            res.write(body)
-          end
-        end
         # Show information about current request, including request class,
         # request method and full path.
         #
         #   r.inspect
         #   # => '#<Roda::RodaRequest GET /foo/bar>'
         def inspect
-          "#<#{self.class.inspect} #{@env[REQUEST_METHOD]} #{full_path_info}>"
+          "#<#{self.class.inspect} #{@env[REQUEST_METHOD]} #{path}>"
         end
         # Does a terminal match on the current path, matching only if the arguments
@@ -535,7 +533,7 @@ class Roda
         #   end
         def is(*args, &block)
           if args.empty?
-            if @env[PATH_INFO] == EMPTY_STRING
+            if empty_path?
               always(&block)
             end
           else
@@ -544,6 +542,13 @@ class Roda
           end
         end
+        # Optimized method for whether this request is a +GET+ request.
+        # Similar to the default Rack::Request get? method, but can be
+        # overridden without changing rack's behavior.
+        def is_get?
+          @env[REQUEST_METHOD] == GET_REQUEST_METHOD
+        end
         # Does a match on the path, matching only if the arguments
         # have matched the path.  Because this doesn't fully match the
         # path, this is usually used to setup branches of the routing tree,
@@ -579,14 +584,34 @@ class Roda
           end
         end
-        # The response related to the current request.  See ResponseMethods for
-        # instance methods for the response, but in general the most common usage
-        # is to override the response status and headers:
+        # The already matched part of the path, including the original SCRIPT_NAME.
+        def matched_path
+          @env[SCRIPT_NAME]
+        end
+        # This an an optimized version of Rack::Request#path.
         #
-        #   response.status = 200
-        #   response['Header-Name'] = 'Header value'
-        def response
-          scope.response
+        #   r.env['SCRIPT_NAME'] = '/foo'
+        #   r.env['PATH_INFO'] = '/bar'
+        #   r.path
+        #   # => '/foo/bar'
+        def path
+          e = @env
+          "#{e[SCRIPT_NAME]}#{e[PATH_INFO]}"
+        end
+        alias full_path_info path
+        # The current path to match requests against.  This is the same as PATH_INFO
+        # in the environment, which gets updated as the request is being routed.
+        def remaining_path
+          @env[PATH_INFO]
+        end
+        # Match POST requests.  If no arguments are provided, matches all POST
+        # requests, otherwise, matches only POST requests where the arguments
+        # given fully consume the path.
+        def post(*args, &block)
+          _verb(args, &block) if post?
         end
         # Immediately redirect to the path using the status code.  This ends
@@ -612,11 +637,26 @@ class Roda
         #       r.redirect
         #     end
         #   end
-        def redirect(path=default_redirect_path, status=302)
+        def redirect(path=default_redirect_path, status=default_redirect_status)
           response.redirect(path, status)
           throw :halt, response.finish
         end
+        # The response related to the current request.  See ResponseMethods for
+        # instance methods for the response, but in general the most common usage
+        # is to override the response status and headers:
+        #
+        #   response.status = 200
+        #   response['Header-Name'] = 'Header value'
+        def response
+          scope.response
+        end
+        # Return the Roda class related to this request.
+        def roda_class
+          self.class.roda_class
+        end
         # Routing matches that only matches +GET+ requests where the current
         # path is +/+.  If it matches, the match block is executed, and when
         # the match block returns, the rack response is returned.
@@ -665,7 +705,7 @@ class Roda
         # Use <tt>r.get true</tt> to handle +GET+ requests where the current
         # path is empty.
         def root(&block)
-          if @env[PATH_INFO] == SLASH && is_get?
+          if remaining_path == SLASH && is_get?
             always(&block)
           end
         end
@@ -681,6 +721,12 @@ class Roda
           throw :halt, app.call(@env)
         end
+        # The session for the current request.  Raises a RodaError if
+        # a session handler has not been loaded.
+        def session
+          @env[SESSION_KEY] || raise(RodaError, "You're missing a session handler. You can get started by adding use Rack::Session::Cookie")
+        end
         private
         # Match any of the elements in the given array.  Return at the
@@ -690,7 +736,7 @@ class Roda
           matcher.any? do |m|
             if matched = match(m)
               if m.is_a?(String)
-                captures.push(m)
+                @captures.push(m)
               end
             end
@@ -698,16 +744,16 @@ class Roda
           end
         end
-        # Match the given regexp exactly if it matches a full segment.
-        def _match_regexp(re)
-          consume(self.class.cached_matcher(re){re})
-        end
         # Match the given hash if all hash matchers match.
         def _match_hash(hash)
           hash.all?{|k,v| send("match_#{k}", v)}
         end
+        # Match the given regexp exactly if it matches a full segment.
+        def _match_regexp(re)
+          consume(self.class.cached_matcher(re){re})
+        end
         # Match the given string to the request path.  Regexp escapes the
         # string so that regexp metacharacters are not matched, and recognizes
         # colon tokens for placeholders.
@@ -757,16 +803,10 @@ class Roda
         # SCRIPT_NAME to include the matched path, removes the matched
         # path from PATH_INFO, and updates captures with any regex captures.
         def consume(pattern)
-          env = @env
-          return unless matchdata = env[PATH_INFO].match(pattern)
-          vars = matchdata.captures
-          # Don't mutate SCRIPT_NAME, breaks try
-          env[SCRIPT_NAME] += vars.shift
-          env[PATH_INFO] = matchdata.post_match
-          captures.concat(vars)
+          if matchdata = remaining_path.match(pattern)
+            update_remaining_path(matchdata.post_match)
+            @captures.concat(matchdata.captures)
+          end
         end
         # The default path to use for redirects when a path is not given.
@@ -779,29 +819,47 @@ class Roda
         # it is easy to create an infinite redirect.
         def default_redirect_path
           raise RodaError, "must provide path argument to redirect for get requests" if is_get?
-          full_path_info
+          path
+        end
+        # The default status to use for redirects if a status is not provided,
+        # 302 by default.
+        def default_redirect_status
+          302
+        end
+        # Whether the current path is considered empty.
+        def empty_path?
+          remaining_path == EMPTY_STRING
         end
         # If all of the arguments match, yields to the match block and
         # returns the rack response when the block returns.  If any of
         # the match arguments doesn't match, does nothing.
         def if_match(args)
+          keep_remaining_path do
+            # For every block, we make sure to reset captures so that
+            # nesting matchers won't mess with each other's captures.
+            @captures.clear
+            return unless match_all(args)
+            block_result(yield(*captures))
+            throw :halt, response.finish
+          end
+        end
+        # Yield to the block, restoring SCRIPT_NAME and PATH_INFO to
+        # their initial values before returning from the block.
+        def keep_remaining_path
           env = @env
-          script = env[SCRIPT_NAME]
-          path = env[PATH_INFO]
-          # For every block, we make sure to reset captures so that
-          # nesting matchers won't mess with each other's captures.
-          captures.clear
-          return unless match_all(args)
-          block_result(yield(*captures))
-          throw :halt, response.finish
+          script = env[sn = SCRIPT_NAME]
+          path = env[pi = PATH_INFO]
+          yield
         ensure
-          env[SCRIPT_NAME] = script
-          env[PATH_INFO] = path
+          env[sn] = script
+          env[pi] = path
         end
         # Attempt to match the argument to the given request, handling
         # common ruby types.
         def match(matcher)
@@ -813,7 +871,7 @@ class Roda
           when Symbol
             _match_symbol(matcher)
           when TERM
-            @env[PATH_INFO] == EMPTY_STRING
+            empty_path?
           when Hash
             _match_hash(matcher)
           when Array
@@ -850,7 +908,7 @@ class Roda
         # Adds any match to the captures.
         def match_param(key)
           if v = self[key]
-            captures << v
+            @captures << v
           end
         end
@@ -858,9 +916,18 @@ class Roda
         # Adds any match to the captures.
         def match_param!(key)
           if (v = self[key]) && !v.empty?
-            captures << v
+            @captures << v
           end
         end
+        # Update PATH_INFO and SCRIPT_NAME based on the matchend and remaining variables.
+        def update_remaining_path(remaining)
+          e = @env
+          # Don't mutate SCRIPT_NAME, breaks try
+          e[SCRIPT_NAME] += e[pi = PATH_INFO].chomp(remaining)
+          e[pi] = remaining
+        end
       end
       # Class methods for RodaResponse
@@ -879,21 +946,20 @@ class Roda
       # Instance methods for RodaResponse
       module ResponseMethods
         CONTENT_LENGTH = "Content-Length".freeze
-        CONTENT_TYPE = "Content-Type".freeze
-        DEFAULT_CONTENT_TYPE = "text/html".freeze
+        DEFAULT_HEADERS = {"Content-Type" => "text/html".freeze}.freeze
         LOCATION = "Location".freeze
+        # The hash of response headers for the current response.
+        attr_reader :headers
         # The status code to use for the response.  If none is given, will use 200
         # code for non-empty responses and a 404 code for empty responses.
         attr_accessor :status
-        # The hash of response headers for the current response.
-        attr_reader :headers
         # Set the default headers when creating a response.
         def initialize
           @status  = nil
-          @headers = default_headers
+          @headers = {}
           @body    = []
           @length  = 0
         end
@@ -912,14 +978,9 @@ class Roda
           @headers[key] = value
         end
-        # Show response class, status code, response headers, and response body
-        def inspect
-          "#<#{self.class.inspect} #{@status.inspect} #{@headers.inspect} #{@body.inspect}>"
-        end
         # The default headers to use for responses.
         def default_headers
-          {CONTENT_TYPE => DEFAULT_CONTENT_TYPE}
+          DEFAULT_HEADERS
         end
         # Modify the headers to include a Set-Cookie value that
@@ -959,8 +1020,9 @@ class Roda
         def finish
           b = @body
           s = (@status ||= b.empty? ? 404 : 200)
+          set_default_headers
           h = @headers
-          h[CONTENT_LENGTH] = @length.to_s
+          h[CONTENT_LENGTH] ||= @length.to_s
           [s, h, b]
         end
@@ -969,9 +1031,15 @@ class Roda
         # and doesn't add the Content-Length header or use the existing
         # body.
         def finish_with_body(body)
+          set_default_headers
           [@status || 200, @headers, body]
         end
+        # Show response class, status code, response headers, and response body
+        def inspect
+          "#<#{self.class.inspect} #{@status.inspect} #{@headers.inspect} #{@body.inspect}>"
+        end
         # Set the Location header to the given path, and the status
         # to the given status.  Example:
         #
@@ -982,6 +1050,11 @@ class Roda
           @status  = status
         end
+        # Return the Roda class related to this response.
+        def roda_class
+          self.class.roda_class
+        end
         # Set the cookie with the given key in the headers.
         #
         #   response.set_cookie('foo', 'bar')
@@ -999,12 +1072,21 @@ class Roda
           @body << s
           nil
         end
+        private
+        # For each default header, if a header has not already been set for the
+        # response, set the header in the response.
+        def set_default_headers
+          h = @headers
+          default_headers.each do |k,v|
+            h[k] ||= v
+          end
+        end
       end
     end
   end
   extend RodaPlugins::Base::ClassMethods
   plugin RodaPlugins::Base
-  RodaRequest.def_verb_method(RodaPlugins::Base::RequestMethods, :get)
-  RodaRequest.def_verb_method(RodaPlugins::Base::RequestMethods, :post)
 end