roda-cj 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5360a34504fec1081e28143f1f2ce25c69747061
-  data.tar.gz: a593de99e0868ce9478922e9fc1a775fd28afaf7
+  metadata.gz: 0381614904fadaf43af33f351a4edfc17d054c4d
+  data.tar.gz: a1f3866849f764552a2de2f987c636d20cf33099
 SHA512:
-  metadata.gz: 7bf78f056f2b0d1e034e7fab2be1a9dfaad92261c72e692da8c9bcdae895fefa10c348cb8a950445c769b7f7e944e110481e8d066d7a517043a175e647e952be
-  data.tar.gz: d963a3e7c9d02a9077d7f77678d7292b427b8d55ee21b614b7ebd1a401dccd83e9e4d037dd58d319b0490748cf3c33935206437e54ea908365ed8058d6892081
+  metadata.gz: d2930467e112ec168fd41c4f9005e21984b028ff45aa8fb58d843e4343bb098f888774c94b989b70ce0aea4f6f69e8eae2b2a62fc5c6626816f78eea9257fd58
+  data.tar.gz: 1f506448329172d622492c22167f39b8690ca812c50f734c3dec306fd537855b0d4767a8507c555471963a4f053e4b65874d277cc9d53e44fabe2471c3e9374e

data/CHANGELOG

@@ -1,5 +1,17 @@
 = HEAD
 
+* Add head plugin, for handling HEAD requests like GET requests with an empty body (jeremyevans)
+
+* Optimize consuming patterns by using a positive lookahead assertion (jeremyevans)
+
+* Add not_allowed plugin, for automatically returning 405 Method Not Allowed responses (jeremyevans)
+
+* Optimize match blocks with no arguments (jeremyevans)
+
+* Add content_for plugin, for storing content in one template and retrieving it in another (jeremyevans)
+
+* Add render_each plugin, for rendering a template for each value in an enumerable (jeremyevans)
+
 * Add backtracking_array plugin, allowing array matchers to backtrack if later matchers do not match (jeremyevans)
 
 * Add :all hash matcher, allowing array matchers to include conditions where you want to match multiple conditions (jeremyevans)
@@ -28,7 +40,7 @@
 
 * Optimize matching by caching consume regexp for strings, regexp, symbol, and :extension matchers (jeremyevans)
 
-* Add r.root for matching root (path "/"), for easier to read version of r.is "" (jeremyevans)
+* Add r.root for GET / requests, for easier to read version of r.get "" (jeremyevans)
 
 * Optimize r.is terminal matcher, remove :term hash matcher (jeremyevans)
 

data/README.rdoc

@@ -434,18 +434,17 @@ hash matcher:
 == Root Method
 
 As displayed above, you can also use +r.root+ as a match method.  This
-method matches only if the path at that point is exactly +/+.  +r.root+
-is similar to <tt>r.is ""</tt>, except that it does not
-consume the +/+ from the path.
-
-Unlike the other matching methods, +r.root+ does not take multiple
-arguments and pass them to +r.on+.  It only accepts an optional request
-method symbol, so <tt>r.root :get</tt> is similar to <tt>r.get ""</tt>,
+method matches <tt>GET /</tt> requests.  +r.root+ is similar to <tt>r.get ""</tt>,
 except that it does not consume the +/+ from the path.
 
+Unlike the other matching methods, +r.root+ takes no arguments.
+
 Note that +r.root+ does not match if the path is empty, you should use
-+r.is+ with no arguments for that.  If you want to match either the
-the empty path or +/+, you can use <tt>r.is ["", true]</tt>.
+<tt>r.get true</tt> for that.  If you want to match either the
+the empty path or +/+, you can use <tt>r.get ["", true]</tt>.
+
+Note that +r.root+ does not match non-GET requests, so to handle
+<tt>POST /</tt> requests, use <tt>r.post ''</tt>.
 
 == Request and Response
 
@@ -638,6 +637,8 @@ These plugins ship with roda:
 all_verbs :: Adds routing methods to the request for all http verbs.
 backtracking_array :: Allows array matchers to backtrack if later matchers
                       do not match.
+content_for :: Allows storage of content in one template and retrieval of
+               that content in a different template.
 csrf :: Adds CSRF protection and helper methods using
         {rack_csrf}[https://github.com/baldowl/rack_csrf].
 default_headers :: Override the default response headers used.
@@ -647,6 +648,7 @@ flash :: Adds a flash handler.
 h :: Adds h method for html escaping.
 halt :: Augments request#halt method to take status and/or body or status,
         headers, and body.
+head :: Treat HEAD requests like GET requests with an empty response body.
 header_matchers :: Adds host, header, and accept hash matchers.
 hooks :: Adds before and after methods to run code before and after requests.
 indifferent_params :: Adds params method with indifferent access to params,
@@ -657,6 +659,8 @@ middleware :: Allows the Roda app to be used as a rack middleware, calling the
               next middleware if no route matches.
 multi_route :: Adds the ability for multiple named route blocks, with the
                ability to dispatch to them add any point in the main route block.
+not_allowed :: Adds support for automatically returning 405 Method Not Allowed
+               responses.
 not_found :: Adds a +not_found+ block that is called for all 404 responses
              without bodies.
 pass :: Adds a pass method allowing you to skip the current +r.on+ block as if
@@ -664,6 +668,7 @@ pass :: Adds a pass method allowing you to skip the current +r.on+ block as if
 per_thread_caching :: Switches the thread-safe cache from a shared cache to a
                       per-thread cache.
 render :: Adds support for rendering templates via tilt, as described above.
+render_each :: Render a template for each value in an enumerable.
 streaming :: Adds support for streaming responses.
 symbol_matchers :: Adds support for symbol-specific matching regexps.
 symbol_views :: Allows match blocks to return template name symbols, uses the

data/lib/roda/plugins/all_verbs.rb

@@ -30,14 +30,12 @@ class Roda
     # The verb methods are defined via metaprogramming, so there
     # isn't documentation for the individual methods created.
     module AllVerbs
-      module RequestMethods
-        %w'delete head options link patch put trace unlink'.each do |t|
-          if ::Rack::Request.method_defined?("#{t}?")
-            class_eval(<<-END, __FILE__, __LINE__+1)
-              def #{t}(*args, &block)
-                _verb(args, &block) if #{t}?
-              end
-            END
+      def self.configure(app)
+        %w'delete head options link patch put trace unlink'.each do |v|
+          if ::Rack::Request.method_defined?("#{v}?")
+            app.request_module do
+              app::RodaRequest.def_verb_method(self, v)
+            end
           end
         end
       end

data/lib/roda/plugins/backtracking_array.rb

@@ -35,6 +35,7 @@ class Roda
         # entry in the array.
         def _match_array(arg, rest=nil)
           return super unless rest
+          env = @env
 
           script = env[SCRIPT_NAME]
           path = env[PATH_INFO]

data/lib/roda/plugins/content_for.rb

@@ -0,0 +1,46 @@
+class Roda
+  module RodaPlugins
+    # The content_for plugin is designed to be used with the
+    # render plugin, allowing you to store content inside one
+    # template, and retrieve that content inside a separate
+    # template.  Most commonly, this is so view templates
+    # can set content for the layout template to display outside
+    # of the normal content pane.
+    #
+    # The content_for template probably only works with erb
+    # templates, and requires that you don't override the
+    # +:outvar+ render option.  In the template in which you
+    # want to store content, call content_for with a block:
+    #
+    #   <% content_for :foo do %>
+    #     Some content here.
+    #   <% end %>
+    #
+    # In the template in which you want to retrieve content,
+    # call content_for without the block:
+    #
+    #   <%= content_for :foo %>
+    module ContentFor
+      module InstanceMethods
+        # If called with a block, store content enclosed by block
+        # under the given key.  If called without a block, retrieve
+        # stored content with the given key, or return nil if there
+        # is no content stored with that key.
+        def content_for(key, &block)
+          if block
+            @_content_for ||= {}
+            buf_was = @_out_buf
+            @_out_buf = ''
+            yield
+            @_content_for[key] = @_out_buf
+            @_out_buf = buf_was
+          elsif @_content_for
+            @_content_for[key]
+          end
+        end
+      end
+    end
+
+    register_plugin(:content_for, ContentFor)
+  end
+end

data/lib/roda/plugins/halt.rb

@@ -1,18 +1,12 @@
 class Roda
   module RodaPlugins
-    # The halt plugin augments the standard request +halt+ method to handle more than
-    # just rack response arrays.
+    # The halt plugin augments the standard request +halt+ method to allow the response
+    # status, body, or headers to be changed when halting.
     #
     # After loading the halt plugin:
     #
     #   plugin :halt
     #
-    # You can call halt with no arguments to immediately stop processing:
-    #
-    #   route do |r|
-    #     r.halt
-    #   end
-    #
     # You can call the halt method with an integer to set the response status and return:
     #   
     #   route do |r|
@@ -38,7 +32,7 @@ class Roda
     #   end
     #
     # Note that there is a difference between provide status, headers, and body as separate
-    # arguments and providing them as a rack response array.  With a rack response array,
+    # arguments and providing them as a single rack response array.  With a rack response array,
     # the values are used directly, while with 3 arguments, the headers given are merged into
     # the existing headers and the given body is written to the existing response body.
     module Halt

data/lib/roda/plugins/head.rb

@@ -0,0 +1,56 @@
+class Roda
+  module RodaPlugins
+    # The head plugin attempts to automatically handle HEAD requests,
+    # by treating them as GET requests and returning an empty body
+    # without modifying the response status or response headers.
+    #
+    # So for the following routes,
+    #
+    #   route do |r|
+    #     r.root do
+    #       'root'
+    #     end
+    #
+    #     r.get 'a' do
+    #       'a'
+    #     end
+    #
+    #     r.is 'b', :method=>[:get, :post] do
+    #       'b'
+    #     end
+    #   end
+    #
+    # HEAD requests for +/+, +/a+, and +/b+ will all return 200 status
+    # with an empty body.
+    module Head
+      module InstanceMethods
+        # Always use an empty response body for head requests, with a
+        # content length of 0.
+        def call(*)
+          res = super
+          if request.head?
+            res[2] = []
+          end
+          res
+        end
+      end
+
+      module RequestMethods
+        # Consider HEAD requests as GET requests.
+        def is_get?
+          super || head?
+        end
+
+        private
+
+        # If the current request is a HEAD request, match if one of
+        # the given methods is a GET request.
+        def match_method(method)
+          super || (!method.is_a?(Array) && head? && method.to_s.upcase == 'GET')
+        end
+      end
+    end
+
+    register_plugin(:head, Head)
+  end
+end

data/lib/roda/plugins/header_matchers.rb

@@ -35,14 +35,14 @@ class Roda
 
         # Match if the given mimetype is one of the accepted mimetypes.
         def match_accept(mimetype)
-          if env["HTTP_ACCEPT"].to_s.split(',').any?{|s| s.strip == mimetype}
+          if @env["HTTP_ACCEPT"].to_s.split(',').any?{|s| s.strip == mimetype}
             response["Content-Type"] = mimetype
           end
         end
 
         # Match if the given uppercase key is present inside the environment.
         def match_header(key)
-          env[key.upcase.tr("-","_")]
+          @env[key.upcase.tr("-","_")]
         end
 
         # Match if the host of the request is the same as the hostname.

data/lib/roda/plugins/json.rb

@@ -2,7 +2,7 @@ require 'json'
 
 class Roda
   module RodaPlugins
-    # The json plugin allows matching blocks to return
+    # The json plugin allows match blocks to return
     # arrays or hashes, and have those arrays or hashes be
     # converted to json which is used as the response body.
     # It also sets the response content type to application/json.

data/lib/roda/plugins/not_allowed.rb

@@ -0,0 +1,133 @@
+class Roda
+  module RodaPlugins
+    # The not_allowed plugin makes Roda attempt to automatically
+    # support the 405 Method Not Allowed response status. The plugin
+    # changes the +r.get+ and +r.post+ verb methods to automatically
+    # return a 405 status if they are called with any arguments, and
+    # the arguments match but the request method does not match. So
+    # this code:
+    #
+    #   r.get '' do
+    #     "a"
+    #   end
+    #
+    # will return a 200 response for <tt>GET /</tt> and a 405
+    # response for <tt>POST /</tt>.
+    #
+    # This plugin also changes the +r.is+ method so that if you use
+    # a verb method inside +r.is+, it returns a 405 status if none
+    # of the verb methods match.  So this code:
+    #
+    #   r.is '' do
+    #     r.get do
+    #       "a"
+    #     end
+    #
+    #     r.post do
+    #       "b"
+    #     end
+    #   end
+    #
+    # will return a 200 response for <tt>GET /</tt> and <tt>POST /</tt>,
+    # but a 405 response for <tt>PUT /</tt>.
+    #
+    # Note that this plugin will probably not do what you want for
+    # code such as:
+    #
+    #   r.get '' do
+    #     "a"
+    #   end
+    #
+    #   r.post '' do
+    #     "b"
+    #   end
+    #
+    # Since for a <tt>POST /</tt> request, when +r.get+ method matches
+    # the path but not the request method, it will return an immediate
+    # 405 response.  You must DRY up this code for it work correctly,
+    # like this:
+    #
+    #   r.is '' do
+    #     r.get do
+    #       "a"
+    #     end
+    #
+    #     r.post do
+    #       "b"
+    #     end
+    #   end
+    #
+    # In all cases where it uses a 405 response, it also sets the +Allow+
+    # header in the response to contain the request methods supported.
+    # 
+    # To make this affect the verb methods added by the all_verbs plugin,
+    # load this plugin first.
+    module NotAllowed
+      # Redefine the +r.get+ and +r.post+ methods when loading the plugin.
+      def self.configure(app)
+        app.request_module do
+          app::RodaRequest.def_verb_method(self, :get)
+          app::RodaRequest.def_verb_method(self, :post)
+        end
+      end
+
+      module RequestClassMethods
+        # Define a method named +verb+ in the given module which will
+        # return a 405 response if the method is called with any
+        # arguments and the arguments terminally match but the
+        # request method does not.
+        #
+        # If called without any arguments, check to see if the call
+        # is inside a terminal match, and in that case record the
+        # request method used.
+        def def_verb_method(mod, verb)
+          mod.class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{verb}(*args, &block)
+              if args.empty?
+                @_is_verbs << "#{verb.to_s.upcase}" if @_is_verbs
+                always(&block) if #{verb == :get ? :is_get : verb}?
+              else
+                args << ::Roda::RodaPlugins::Base::RequestMethods::TERM
+                if_match(args) do
+                  #{verb}(&block)
+                  response.status = 405
+                  response['Allow'] = '#{verb.to_s.upcase}'
+                  nil
+                end
+              end
+            end
+          END
+        end
+      end
+
+      module RequestMethods
+        # Keep track of verb calls inside the block.  If there are any
+        # verb calls inside the block, but the block returned, assume
+        # that the verb calls inside the block did not match, and
+        # since there was already a successful terminal match, the
+        # request method must not be allowed, so return a 405
+        # response in that case.
+        def is(*verbs)
+          super(*verbs) do
+            begin
+              @_is_verbs = []
+
+              ret = yield
+
+              unless @_is_verbs.empty?
+                response.status = 405
+                response['Allow'] = @_is_verbs.join(', ')
+              end
+
+              ret
+            ensure
+              @_is_verbs = nil
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:not_allowed, NotAllowed)
+  end
+end

data/lib/roda/plugins/pass.rb

@@ -1,6 +1,6 @@
 class Roda
   module RodaPlugins
-    # The pass plugin adds a request +pass+ method to skip the current +on+
+    # The pass plugin adds a request +pass+ method to skip the current match
     # block as if it did not match.
     #
     #   plugin :pass
@@ -17,14 +17,21 @@ class Roda
     #   end
     module Pass
       module RequestMethods
-        # Handle passing inside the current block.
-        def _on(_)
+        # Skip the current match block as if it did not match.
+        def pass
+          throw :pass
+        end
+
+        private
+
+        # Handle passing inside the match block.
+        def always
           catch(:pass){super}
         end
 
-        # Skip the current #on block as if it did not match.
-        def pass
-          throw :pass
+        # Handle passing inside the match block.
+        def if_match(_)
+          catch(:pass){super}
         end
       end
     end

data/lib/roda/plugins/render_each.rb

@@ -0,0 +1,61 @@
+class Roda
+  module RodaPlugins
+    # The render_each plugin allows you to render a template for each
+    # value in an enumerable, returning the concatention of all of the
+    # template renderings.  For example:
+    #
+    #   render_each([1,2,3], :foo)
+    #
+    # will render the +foo+ template 3 times.  Each time the template
+    # is rendered, the local variable +foo+ will contain the given
+    # value (e.g. on the first rendering +foo+ is 1).
+    #
+    # You can pass additional render options via an options hash:
+    #
+    #   render_each([1,2,3], :foo, :views=>'partials')
+    #
+    # One additional option supported by is +:local+, which sets the
+    # local variable containing the current value to use.  So:
+    #
+    #   render_each([1,2,3], :foo, :local=>:bar)
+    #
+    # Will render the +foo+ template, but the local variable used inside
+    # the template will be +bar+.  You can use <tt>:local=>nil</tt> to
+    # not set a local variable inside the template.
+    module RenderEach
+      module InstanceMethods
+        EMPTY_STRING = ''.freeze
+
+        # For each value in enum, render the given template using the
+        # given opts.  The template and options hash are passed to +render+.
+        # Additional options supported:
+        # :local :: The local variable to use for the current enum value
+        #           inside the template.  An explicit +nil+ value does not
+        #           set a local variable.  If not set, uses the template name.
+        def render_each(enum, template, opts={})
+          if as = opts.has_key?(:local)
+            as = opts[:local]
+          else
+            as = template.to_s.to_sym
+          end
+
+          if as
+            opts = opts.dup
+            if locals = opts[:locals]
+              locals = opts[:locals] = locals.dup
+            else
+              locals = opts[:locals] = {}
+            end
+          end
+
+          enum.map do |v|
+            locals[as] = v if as
+            render(template, opts)
+          end.join
+        end
+      end
+    end
+
+    register_plugin(:render_each, RenderEach)
+  end
+end

data/lib/roda/plugins/symbol_matchers.rb

@@ -7,7 +7,7 @@ class Roda
     #     # ...
     #   end
     #
-    # By default this will match all segments.  However, if your usernames
+    # By default this will match all nonempty segments.  However, if your usernames
     # must be 6-20 characters, and can only contain +a-z+ and +0-9+, you can do:
     #
     #   plugin :symbol_matchers
@@ -28,11 +28,12 @@ class Roda
     #
     # By default, this plugin sets up the following symbol matchers:
     #
-    # :d :: <tt>/\d+/</tt>, a decimal segment
-    # :format :: <tt>/(?:\.(\w+))?/</tt>, an optional format
+    # :d :: <tt>/(\d+)/</tt>, a decimal segment
+    # :format :: <tt>/(?:\.(\w+))?/</tt>, an optional format/extension
     # :opt :: <tt>/(?:\/([^\/]+))?</tt>, an optional segment
     # :optd :: <tt>/(?:\/(\d+))?</tt>, an optional decimal segment
-    # :w :: <tt>/\w+/</tt>, a alphanumeric segment
+    # :rest :: <tt>/(.*)/</tt>, all remaining characters, if any
+    # :w :: <tt>/(\w+)/</tt>, a alphanumeric segment
     #
     # Note that because of how segment matching works, :format, :opt, and :optd
     # are only going to work inside of a string, like this:
@@ -46,6 +47,7 @@ class Roda
         app.symbol_matcher(:format, /(?:\.(\w+))?/)
         app.symbol_matcher(:opt, /(?:\/([^\/]+))?/)
         app.symbol_matcher(:optd, /(?:\/(\d+))?/)
+        app.symbol_matcher(:rest, /(.*)/)
         app.symbol_matcher(:w, /(\w+)/)
       end
 
@@ -57,6 +59,8 @@ class Roda
       end
 
       module RequestMethods
+        private
+
         # Allow for symbol specific regexps, by using match_symbol_#{s} if
         # defined.  If not defined, calls super for the default behavior.
         def _match_symbol_regexp(s)

data/lib/roda/plugins/symbol_views.rb

@@ -1,6 +1,6 @@
 class Roda
   module RodaPlugins
-    # The symbol_views plugin allows matching blocks to return
+    # The symbol_views plugin allows match blocks to return
     # symbols, and consider those symbols as views to use for the
     # response body.  So you can take code like:
     #

data/lib/roda/version.rb

@@ -1,3 +1,3 @@
 class Roda
-  RodaVersion = '0.9.3'.freeze
+  RodaVersion = '0.9.4'.freeze
 end

data/lib/roda.rb

@@ -301,6 +301,17 @@ 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.
@@ -314,7 +325,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
 
@@ -327,8 +338,8 @@ class Roda
         EMPTY_STRING = "".freeze
         SLASH = "/".freeze
         SEGMENT = "([^\\/]+)".freeze
-        EMPTY_ARRAY = [].freeze
         TERM_INSPECT = "TERM".freeze
+        GET_REQUEST_METHOD = 'GET'.freeze
 
         TERM = Object.new
         def TERM.inspect
@@ -354,14 +365,7 @@ class Roda
         # As request routing modifies SCRIPT_NAME and PATH_INFO, this exists
         # as a helper method to get the full request of the path info.
         def full_path_info
-          "#{env[SCRIPT_NAME]}#{env[PATH_INFO]}"
-        end
-
-        # If this is not a GET method, returns immediately.  Otherwise, if there
-        # are arguments, do a terminal match on the arguments, otherwise do a
-        # regular match.
-        def get(*args, &block)
-          _verb(args, &block) if get?
+          "#{@env[SCRIPT_NAME]}#{@env[PATH_INFO]}"
         end
 
         # Immediately stop execution of the route block and return the given
@@ -371,7 +375,14 @@ class Roda
           throw :halt, res
         end
 
-        # Handle #on block return values.  By default, if a string is given
+        # 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
@@ -383,14 +394,20 @@ class Roda
         # Show information about current request, including request class,
         # request method and full path.
         def inspect
-          "#<#{self.class.inspect} #{env[REQUEST_METHOD]} #{full_path_info}>"
+          "#<#{self.class.inspect} #{@env[REQUEST_METHOD]} #{full_path_info}>"
         end
 
-        # Adds TERM as the final argument and passes to #on, ensuring that
-        # there is only a match if #on has fully matched the path.
+        # Does a terminal match on the input, matching only if the arguments
+        # have fully matched the patch.
         def is(*args, &block)
-          args << TERM
-          _on(args, &block)
+          if args.empty?
+            if @env[PATH_INFO] == EMPTY_STRING
+              always(&block)
+            end
+          else
+            args << TERM
+            if_match(args, &block)
+          end
         end
 
         # Attempts to match on all of the arguments.  If all of the
@@ -399,14 +416,11 @@ class Roda
         # If any of the arguments fails, ensures the request state is
         # returned to that before matches were attempted.
         def on(*args, &block)
-          _on(args, &block)
-        end
-
-        # If this is not a GET method, returns immediately.  Otherwise, if there
-        # are arguments, do a terminal match on the arguments, otherwise do a
-        # regular match.
-        def post(*args, &block)
-          _verb(args, &block) if post?
+          if args.empty?
+            always(&block)
+          else
+            if_match(args, &block)
+          end
         end
 
         # The response related to the current request.
@@ -420,19 +434,17 @@ class Roda
           throw :halt, response.finish
         end
 
-        # If the current path is the root ("/"), match on the block.  If a request
-        # method is given, return immediately if the request does not use the given
-        # method.
-        def root(request_method=nil, &block)
-          if env[PATH_INFO] == SLASH && (!request_method || send(:"#{request_method}?"))
-            _on(EMPTY_ARRAY, &block)
+        # If this is a GET request for the root ("/"), yield to the match block.
+        def root(&block)
+          if @env[PATH_INFO] == SLASH && is_get?
+            always(&block)
           end
         end
 
         # Call the given rack app with the environment and immediately return
         # the response as the response for this request.
         def run(app)
-          throw :halt, app.call(env)
+          throw :halt, app.call(@env)
         end
 
         private
@@ -480,31 +492,21 @@ class Roda
           SEGMENT
         end
 
-        # Internal match method taking array of matchers instead of multiple
-        # arguments.
-        def _on(args)
-          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
-        ensure
-          env[SCRIPT_NAME] = script
-          env[PATH_INFO] = path
-        end
-
         # Backbone of the verb method support, using a terminal match if
         # args is not empty, or a regular match if it is empty.
         def _verb(args, &block)
-          unless args.empty?
+          if args.empty?
+            always(&block)
+          else
             args << TERM
+            if_match(args, &block)
           end
-          _on(args, &block)
+        end
+
+        # Yield to the match block and return rack response after the block returns.
+        def always
+          block_result(yield)
+          throw :halt, response.finish
         end
 
         # The body to use for the response if the response does not return
@@ -521,17 +523,38 @@ 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] = "#{vars.pop}#{matchdata.post_match}"
+          env[PATH_INFO] = matchdata.post_match
 
           captures.concat(vars)
         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)
+          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
+        ensure
+          env[SCRIPT_NAME] = script
+          env[PATH_INFO] = path
+        end
+        
         # Attempt to match the argument to the given request, handling
         # common ruby types.
         def match(matcher)
@@ -543,7 +566,7 @@ class Roda
           when Symbol
             _match_symbol(matcher)
           when TERM
-            env[PATH_INFO] == EMPTY_STRING
+            @env[PATH_INFO] == EMPTY_STRING
           when Hash
             _match_hash(matcher)
           when Array
@@ -563,7 +586,7 @@ class Roda
         # Match files with the given extension.  Requires that the
         # request path end with the extension.
         def match_extension(ext)
-          consume(self.class.cached_matcher(ext){"([^\\/]+?)\.#{ext}\\z"})
+          consume(self.class.cached_matcher([:extension, ext]){"([^\\/]+?)\.#{ext}\\z"})
         end
 
         # Match by request method.  This can be an array if you want
@@ -572,7 +595,7 @@ class Roda
           if type.is_a?(Array)
             type.any?{|t| match_method(t)}
           else
-            type.to_s.upcase == env[REQUEST_METHOD]
+            type.to_s.upcase == @env[REQUEST_METHOD]
           end
         end
 
@@ -698,4 +721,6 @@ class Roda
 
   extend RodaPlugins::Base::ClassMethods
   plugin RodaPlugins::Base
+  RodaRequest.def_verb_method(RodaPlugins::Base::RequestMethods, :get)
+  RodaRequest.def_verb_method(RodaPlugins::Base::RequestMethods, :post)
 end

data/spec/matchers_spec.rb

@@ -487,21 +487,10 @@ describe "path matchers" do
     end
 
     body.should == 'Home'
+    status('REQUEST_METHOD'=>'POST').should == 404
     status("//").should == 404
     status("/foo").should == 404
   end
-
-  it "matching the root with the root method and request method symbol" do
-    app do |r|
-      r.root(:get) do
-        "Home"
-      end
-    end
-
-    body.should == 'Home'
-    status("//").should == 404
-    status('REQUEST_METHOD'=>"POST").should == 404
-  end
 end
 
 describe "root/empty segment matching" do
@@ -658,15 +647,15 @@ end
 describe "extension matcher" do
   it "should match given file extensions" do
     app do |r|
-      r.on "styles" do
+      r.on "css" do
         r.on :extension=>"css" do |file|
           file
         end
       end
     end
 
-    body("/styles/reset.css").should == 'reset'
-    status("/styles/reset.bar").should == 404
+    body("/css/reset.css").should == 'reset'
+    status("/css/reset.bar").should == 404
   end
 end
 

data/spec/plugin/content_for_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+begin
+  require 'tilt/erb'
+rescue LoadError
+  warn "tilt not installed, skipping content_for plugin test"  
+else
+describe "content_for plugin" do
+  before do
+    app(:bare) do
+      plugin :render
+      render_opts[:views] = "./spec/views"
+      plugin :content_for
+
+      route do |r|
+        r.root do
+          view(:inline=>"<% content_for :foo do %>foo<% end %>bar", :layout=>{:inline=>'<%= yield %> <%= content_for(:foo) %>'})
+        end
+        r.get 'a' do
+          view(:inline=>"bar", :layout=>{:inline=>'<%= content_for(:foo) %> <%= yield %>'})
+        end
+      end
+    end
+  end
+
+  it "should be able to set content in template and get that content in the layout" do
+    body.strip.should == "bar foo"
+  end
+
+  it "should work if content is not set by the template" do
+    body('/a').strip.should == "bar"
+  end
+end
+end

data/spec/plugin/head_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "head plugin" do 
+  it "considers HEAD requests as GET requests which return no body" do
+    app(:head) do |r|
+      r.root do
+        'root'
+      end
+
+      r.get 'a' do
+        'a'
+      end
+
+      r.is 'b', :method=>[:get, :post] do
+        'b'
+      end
+    end
+
+    s, h, b = req
+    s.should == 200
+    h['Content-Length'].should == '4'
+    b.should == ['root']
+
+    s, h, b = req('REQUEST_METHOD' => 'HEAD')
+    s.should == 200
+    h['Content-Length'].should == '4'
+    b.should == []
+
+    body('/a').should == 'a'
+    status('/a', 'REQUEST_METHOD' => 'HEAD').should == 200
+
+    body('/b').should == 'b'
+    status('/b', 'REQUEST_METHOD' => 'HEAD').should == 200
+  end
+end

data/spec/plugin/not_allowed_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "not_allowed plugin" do 
+  it "skips the current block if pass is called" do
+    app(:not_allowed) do |r|
+      r.get '' do
+        'a'
+      end
+
+      r.is "c" do
+        r.get do
+          "cg"
+        end
+
+        r.post do
+          "cp"
+        end
+
+        "c"
+      end
+
+      r.get do
+        r.is 'b' do
+          'b'
+        end
+      end
+    end
+
+    body.should == 'a'
+    status('REQUEST_METHOD'=>'POST').should == 405
+    header('Allow', 'REQUEST_METHOD'=>'POST').should == 'GET'
+
+    body('/b').should == 'b'
+    status('/b', 'REQUEST_METHOD'=>'POST').should == 404
+
+    body('/c').should == 'cg'
+    body('/c', 'REQUEST_METHOD'=>'POST').should == 'cp'
+    body('/c', 'REQUEST_METHOD'=>'PATCH').should == 'c'
+    status('/c', 'REQUEST_METHOD'=>'PATCH').should == 405
+    header('Allow', '/c', 'REQUEST_METHOD'=>'PATCH').should == 'GET, POST'
+  end
+end

data/spec/plugin/pass_spec.rb

@@ -3,6 +3,11 @@ require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
 describe "pass plugin" do 
   it "skips the current block if pass is called" do
     app(:pass) do |r|
+      r.root do
+        r.pass if env['FOO']
+        'root'
+      end
+
       r.on :id do |id|
         r.pass if id == 'foo'
         id
@@ -13,11 +18,12 @@ describe "pass plugin" do
       end
     end
 
+    body.should == 'root'
+    status('FOO'=>true).should == 404
     body("/a").should == 'a'
     body("/a/b").should == 'a'
     body("/foo/a").should == 'fooa'
     body("/foo/a/b").should == 'fooa'
     status("/foo").should == 404
-    status.should == 404
   end
 end

data/spec/plugin/render_each_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "render_each plugin" do 
+  it "calls render with each argument, returning joined string with all results" do
+    app(:bare) do
+      plugin :render_each
+      def render(t, opts)
+        "r#{t}#{opts[:locals][:foo] if opts[:locals]}#{opts[:bar]} "
+      end 
+
+      route do |r|
+        r.root do
+          render_each([1,2,3], :foo)
+        end
+
+        r.is 'a' do
+          render_each([1,2,3], :bar, :local=>:foo, :bar=>4)
+        end
+
+        r.is 'b' do
+          render_each([1,2,3], :bar, :local=>nil)
+        end
+      end
+    end
+
+    body.should == 'rfoo1 rfoo2 rfoo3 '
+    body("/a").should == 'rbar14 rbar24 rbar34 '
+    body("/b").should == 'rbar rbar rbar '
+  end
+end

data/spec/plugin/symbol_matchers_spec.rb

@@ -27,6 +27,10 @@ describe "symbol_matchers plugin" do
           "f#{f}"
         end
 
+        r.is 'q:rest' do |r|
+          "rest#{r}"
+        end
+
         r.is :w do |w|
           "w#{w}"
         end
@@ -58,5 +62,7 @@ describe "symbol_matchers plugin" do
     body("/1/1a/f").should == 'dwf11af'
     body("/12/1azy/fffff").should == 'dwf121azyfffff'
     status("/1/f/a").should == 404
+    body("/qa/b/c/d//f/g").should == 'resta/b/c/d//f/g'
+    body('/q').should == 'rest'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda-cj
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2014-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -88,12 +88,16 @@ files:
 - lib/roda/plugins/flash.rb
 - lib/roda/plugins/csrf.rb
 - lib/roda/plugins/symbol_views.rb
+- lib/roda/plugins/content_for.rb
 - lib/roda/plugins/halt.rb
+- lib/roda/plugins/not_allowed.rb
 - lib/roda/plugins/header_matchers.rb
 - lib/roda/plugins/per_thread_caching.rb
 - lib/roda/plugins/error_handler.rb
 - lib/roda/plugins/indifferent_params.rb
+- lib/roda/plugins/head.rb
 - lib/roda/plugins/json.rb
+- lib/roda/plugins/render_each.rb
 - lib/roda/plugins/streaming.rb
 - lib/roda/plugins/all_verbs.rb
 - lib/roda/plugins/not_found.rb
@@ -118,6 +122,7 @@ files:
 - spec/plugin/error_handler_spec.rb
 - spec/plugin/json_spec.rb
 - spec/plugin/symbol_views_spec.rb
+- spec/plugin/head_spec.rb
 - spec/plugin/all_verbs_spec.rb
 - spec/plugin/render_spec.rb
 - spec/plugin/symbol_matchers_spec.rb
@@ -126,12 +131,15 @@ files:
 - spec/plugin/default_headers_spec.rb
 - spec/plugin/backtracking_array_spec.rb
 - spec/plugin/per_thread_caching_spec.rb
+- spec/plugin/content_for_spec.rb
 - spec/plugin/hooks_spec.rb
 - spec/plugin/streaming_spec.rb
 - spec/plugin/flash_spec.rb
 - spec/plugin/pass_spec.rb
+- spec/plugin/render_each_spec.rb
 - spec/plugin/not_found_spec.rb
 - spec/plugin/middleware_spec.rb
+- spec/plugin/not_allowed_spec.rb
 - spec/plugin/h_spec.rb
 - spec/plugin/halt_spec.rb
 - spec/plugin/view_subdirs_spec.rb