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

roda 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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