roda 3.17.0 → 3.18.0

data/lib/roda/plugins/mailer.rb

@@ -140,7 +140,7 @@ class Roda
         def mail(path, *args)
           mail = ::Mail.new
           catch(:no_mail) do
-            unless mail.equal?(new("PATH_INFO"=>path, 'SCRIPT_NAME'=>'', "REQUEST_METHOD"=>"MAIL", 'rack.input'=>StringIO.new, 'roda.mail'=>mail, 'roda.mail_args'=>args).call(&@rack_app_route_block))
+            unless mail.equal?(new("PATH_INFO"=>path, 'SCRIPT_NAME'=>'', "REQUEST_METHOD"=>"MAIL", 'rack.input'=>StringIO.new, 'roda.mail'=>mail, 'roda.mail_args'=>args)._roda_handle_main_route)
               raise Error, "route did not return mail instance for #{path.inspect}, #{args.inspect}"
             end
             mail

data/lib/roda/plugins/middleware.rb

@@ -127,16 +127,26 @@ class Roda
             Forwarder.new(self, app, *args, &block)
           end
         end
+      end
 
+      module InstanceMethods
         # Override the route block so that if no route matches, we throw so
-        # that the next middleware is called.
-        def route(*args, &block)
+        # that the next middleware is called. Old Dispatch API.
+        def call(&block)
           super do |r|
-            res = instance_exec(r, &block)
+            res = instance_exec(r, &block) # call Fallback
             throw :next, true if r.forward_next
             res
           end
         end
+
+        # Override the route block so that if no route matches, we throw so
+        # that the next middleware is called.
+        def _roda_run_main_route(r)
+          res = super
+          throw :next, true if r.forward_next
+          res
+        end
       end
 
       module RequestMethods

data/lib/roda/plugins/multi_route.rb

@@ -169,8 +169,8 @@ class Roda
         # call super.
         def route(name=nil, namespace=nil, &block)
           if name
-            opts[:namespaced_routes][namespace] ||= {}
-            opts[:namespaced_routes][namespace][name] = convert_route_block(block)
+            routes = opts[:namespaced_routes][namespace] ||= {}
+            routes[name] = define_roda_method(routes[name] || "multi_route_#{namespace}_#{name}", 1, &convert_route_block(block))
             self::RodaRequest.clear_named_route_regexp!(namespace)
           else
             super(&block)
@@ -213,7 +213,7 @@ class Roda
 
         # Dispatch to the named route with the given name.
         def route(name, namespace=nil)
-          scope.instance_exec(self, &roda_class.named_route(name, namespace))
+          scope.send(roda_class.named_route(name, namespace), self)
         end
       end
     end

data/lib/roda/plugins/named_templates.rb

@@ -69,7 +69,7 @@ class Roda
 
         # Store a new template block and options for the given template name.
         def template(name, options=nil, &block)
-          opts[:named_templates][name.to_s] = [options, block].freeze
+          opts[:named_templates][name.to_s] = [options, define_roda_method("named_templates_#{name}", 0, &block)].freeze
           nil
         end
       end
@@ -80,14 +80,14 @@ class Roda
         # If a template name is given and it matches a named template, call
         # the named template block to get the inline template to use.
         def find_template(options)
-          if options[:template] && (template_opts, block = opts[:named_templates][template_name(options)]; block)
+          if options[:template] && (template_opts, meth = opts[:named_templates][template_name(options)]; meth)
             if template_opts
-              options = Hash[template_opts].merge!(options)
+              options = template_opts.merge(options)
             else
               options = Hash[options]
             end
 
-            options[:inline] = instance_exec(&block)
+            options[:inline] = send(meth)
 
             super(options)
           else

data/lib/roda/plugins/path.rb

@@ -10,7 +10,7 @@ class Roda
     #
     # Additionally, you can call the +path+ class method with a class and a block, and it will register
     # the class.  You can then call the +path+ instance method with an instance of that class, and it will
-    # instance_exec the block with the arguments provided to path.
+    # execute the block in the context of the route block scope with the arguments provided to path.
     #
     # Example:
     #
@@ -60,9 +60,8 @@ class Roda
     #         method.  If a Symbol or String, uses the value as the url method name.
     # :url_only :: Do not create a path method, just a url method.
     #
-    # Note that if :add_script_name, :url, or :url_only is used, will also create a <tt>_*_path</tt>
-    # method.  This is necessary in order to support path methods that accept blocks, as you can't pass
-    # a block to a block that is instance_execed.
+    # Note that if :add_script_name, :url, or :url_only is used, the path method will also create a
+    # <tt>_*_path</tt> private method.
     module Path
       DEFAULT_PORTS = {'http' => 80, 'https' => 443}.freeze
 
@@ -73,6 +72,7 @@ class Roda
         app.instance_eval do
           self.opts[:path_class_by_name] = opts.fetch(:by_name, ENV['RACK_ENV'] == 'development')
           self.opts[:path_classes] ||= {}
+          self.opts[:path_class_methods] ||= {}
           unless path_block(String)
             path(String){|str| str}
           end
@@ -88,6 +88,7 @@ class Roda
         # Freeze the path classes when freezing the app.
         def freeze
           path_classes.freeze
+          opts[:path_classes_methods].freeze
           super
         end
 
@@ -100,6 +101,7 @@ class Roda
               name = name.name
             end
             path_classes[name] = block
+            self.opts[:path_class_methods][name] = define_roda_method("path_#{name}", :any, &block)
             return
           end
 
@@ -164,6 +166,7 @@ class Roda
         
         # Return the block related to the given class, or nil if there is no block.
         def path_block(klass)
+          # RODA4: Remove
           if opts[:path_class_by_name]
             klass = klass.name
           end
@@ -175,14 +178,16 @@ class Roda
         # Return a path based on the class of the object.  The object passed must have
         # had its class previously registered with the application.  If the app's
         # :add_script_name option is true, this prepends the SCRIPT_NAME to the path.
-        def path(obj, *args)
+        def path(obj, *args, &block)
           app = self.class
-          unless blk = app.path_block(obj.class)
+          opts = app.opts
+          klass =  opts[:path_class_by_name] ? obj.class.name : obj.class
+          unless meth = opts[:path_class_methods][klass]
             raise RodaError, "unrecognized object given to Roda#path: #{obj.inspect}"
           end
 
-          path = instance_exec(obj, *args, &blk)
-          path = request.script_name.to_s + path if app.opts[:add_script_name]
+          path = send(meth, obj, *args, &block)
+          path = request.script_name.to_s + path if opts[:add_script_name]
           path
         end
       end

data/lib/roda/plugins/render.rb

@@ -342,10 +342,10 @@ class Roda
             opts = found_template_opts || find_template(opts)
             template_opts = render_opts[:template_opts]
             if engine_opts = render_opts[:engine_opts][opts[:engine]]
-              template_opts = Hash[template_opts].merge!(engine_opts)
+              template_opts = template_opts.merge(engine_opts)
             end
             if current_template_opts = opts[:template_opts]
-              template_opts = Hash[template_opts].merge!(current_template_opts)
+              template_opts = template_opts.merge(current_template_opts)
             end
             opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
           end

data/lib/roda/plugins/route_block_args.rb

@@ -25,7 +25,7 @@ class Roda
     module RouteBlockArgs
       def self.configure(app, &block)
         app.instance_exec do 
-          opts[:route_block_args] = block
+          define_roda_method(:_roda_route_block_args, 0, &block)
           route(&@raw_route_block) if @raw_route_block
         end
       end
@@ -37,8 +37,9 @@ class Roda
         private
 
         def convert_route_block(block)
-          proc do |r|
-            instance_exec(*instance_exec(&opts[:route_block_args]), &block)
+          meth = define_roda_method("convert_route_block_args", :any, &super(block))
+          lambda do |_|
+            send(meth, *_roda_route_block_args)
           end
         end
       end

data/lib/roda/plugins/route_csrf.rb

@@ -164,11 +164,13 @@ class Roda
 
       def self.configure(app, opts=OPTS, &block)
         options = app.opts[:route_csrf] = (app.opts[:route_csrf] || DEFAULTS).merge(opts)
-        if block
-          if opts[:csrf_failure]
+        if block || opts[:csrf_failure].is_a?(Proc)
+          if block && opts[:csrf_failure]
             raise RodaError, "Cannot specify both route_csrf plugin block and :csrf_failure option"
           end
-          options[:csrf_failure] = block
+          block ||= opts[:csrf_failure]
+          options[:csrf_failure] = :csrf_failure_method
+          app.define_roda_method(:_roda_route_csrf_failure, 1, &app.send(:convert_route_block, block))
         end
         options[:env_header] = "HTTP_#{options[:header].to_s.gsub('-', '_').upcase}".freeze
         options.freeze
@@ -192,8 +194,11 @@ class Roda
               throw :halt, [403, {'Content-Type'=>'text/html', 'Content-Length'=>'0'}, []]
             when :clear_session
               session.clear
+            when :csrf_failure_method
+              @_request.on{_roda_route_csrf_failure(@_request)}
             when Proc
-              @_request.on{instance_exec(@_request, &failure_action)}
+              RodaPlugins.warn "Passing a Proc as the :csrf_failure option value to check_csrf! is deprecated"
+              @_request.on{instance_exec(@_request, &failure_action)} # Deprecated
             else
               raise RodaError, "Unsupported :csrf_failure option: #{failure_action.inspect}"
             end

data/lib/roda/plugins/sessions.rb

@@ -162,6 +162,7 @@ class Roda
         plugin_opts = opts
         opts = (app.opts[:sessions] || DEFAULT_OPTIONS).merge(opts)
         co = opts[:cookie_options] = DEFAULT_COOKIE_OPTIONS.merge(opts[:cookie_options] || OPTS).freeze
+        opts[:remove_cookie_options] = co.merge(:max_age=>'0', :expires=>Time.at(0))
         opts[:parser] ||= app.opts[:json_parser] || JSON.method(:parse)
         opts[:serializer] ||= app.opts[:json_serializer] || :to_json.to_proc
 
@@ -231,7 +232,7 @@ class Roda
           if session.empty?
             if env[SESSION_SERIALIZED]
               # If session was submitted and is now empty, remove the cookie
-              Rack::Utils.delete_cookie_header!(headers, opts[:key])
+              Rack::Utils.delete_cookie_header!(headers, opts[:key], opts[:remove_cookie_options])
             # else
               # If no session was submitted, and the session is empty
               # then there is no need to do anything

data/lib/roda/plugins/shared_vars.rb

@@ -64,7 +64,7 @@ class Roda
           if block_given?
             if vars
               begin
-                env['roda.shared'] = Hash[h].merge!(vars)
+                env['roda.shared'] = h.merge(vars)
                 yield
               ensure
                 env['roda.shared'] = h

data/lib/roda/plugins/static_routing.rb

@@ -50,7 +50,7 @@ class Roda
     # while still handling the request methods differently.
     module StaticRouting
       def self.configure(app)
-        app.opts[:static_routes] = {}
+        app.opts[:static_routes] ||= {}
       end
 
       module ClassMethods
@@ -96,7 +96,8 @@ class Roda
 
         # Add a static route for the given method.
         def add_static_route(method, path, &block)
-          (opts[:static_routes][path] ||= {})[method] = convert_route_block(block)
+          routes = opts[:static_routes][path] ||= {}
+          routes[method] = define_roda_method(routes[method] || "static_route_#{method}_#{path}", 1, &convert_route_block(block))
         end
       end
 
@@ -107,21 +108,10 @@ class Roda
         # instead having the routing tree handle the request.
         def _roda_before_30__static_routing
           r = @_request
-          if route = self.class.static_route_for(r.request_method, r.path_info)
-            r.static_route(&route)
-          end
-        end
-      end
-
-      module RequestMethods
-        # Assume that this request matches a static route, setting
-        # the remaining path to the emptry string and passing
-        # control to the given block.
-        def static_route(&block)
-          @remaining_path = ''
-
-          always do
-            scope.instance_exec(self, &block)
+          if meth = self.class.static_route_for(r.request_method, r.path_info)
+            r.instance_variable_set(:@remaining_path, '')
+            r.send(:block_result, send(meth, r))
+            throw :halt, @_response.finish
           end
         end
       end

data/lib/roda/plugins/status_handler.rb

@@ -30,7 +30,9 @@ class Roda
       module ClassMethods
         # Install the given block as a status handler for the given HTTP response code.
         def status_handler(code, &block)
-          opts[:status_handler][code] = block
+          # For backwards compatibility, pass request argument if block accepts argument
+          arity = block.arity == 0 ? 0 : 1
+          opts[:status_handler][code] = [define_roda_method(:"_roda_status_handler_#{code}", arity, &block), arity]
         end
 
         # Freeze the hash of status handlers so that there can be no thread safety issues at runtime.
@@ -45,11 +47,11 @@ class Roda
 
         # If routing returns a response we have a handler for, call that handler.
         def _roda_after_20__status_handler(result)
-          if result && (block = opts[:status_handler][result[0]]) && (v = result[2]).is_a?(Array) && v.empty?
+          if result && (meth, arity = opts[:status_handler][result[0]]; meth) && (v = result[2]).is_a?(Array) && v.empty?
             res = @_response
             res.headers.clear
             res.status = result[0]
-            result.replace(_call(&block))
+            result.replace(_roda_handle_route{arity == 1 ? send(meth, @_request) : send(meth)})
           end
         end
       end

data/lib/roda/plugins/view_options.rb

@@ -107,7 +107,7 @@ class Roda
         # Set branch/route options to use when rendering the layout
         def set_layout_options(opts)
           if options = @_layout_options
-            @_layout_options = Hash[options].merge!(opts)
+            @_layout_options = options.merge!(opts)
           else
             @_layout_options = opts
           end
@@ -116,7 +116,7 @@ class Roda
         # Set branch/route options to use when rendering the view
         def set_view_options(opts)
           if options = @_view_options
-            @_view_options = Hash[options].merge!(opts)
+            @_view_options = options.merge!(opts)
           else
             @_view_options = opts
           end

data/lib/roda/version.rb

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 3
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 17
+  RodaMinorVersion = 18
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/define_roda_method_spec.rb

@@ -0,0 +1,257 @@
+require_relative "spec_helper"
+
+describe "Roda.define_roda_method" do
+  before do
+    @scope = app.new({})
+  end
+
+  it "should define methods using block" do
+    m0 = app.define_roda_method("x", 0){1}
+    m0.must_be_kind_of Symbol
+    m0.must_match /\A_roda_x_\d+\z/
+    @scope.send(m0).must_equal 1
+
+    m1 = app.define_roda_method("x", 1){|x| [x, 2]}
+    m1.must_be_kind_of Symbol
+    m1.must_match /\A_roda_x_\d+\z/
+    @scope.send(m1, 3).must_equal [3, 2]
+  end
+
+  it "should define private methods" do
+    proc{@scope.public_send(app.define_roda_method("x", 0){1})}.must_raise NoMethodError
+  end
+
+  it "should accept symbols as method name and return the same symbol" do
+    m0 = app.define_roda_method(:_roda_foo, 0){1}
+    m0.must_equal :_roda_foo
+    @scope.send(m0).must_equal 1
+  end
+
+  it "should handle optional arguments and splats for expected_arity 0" do
+    m2 = app.define_roda_method("x", 0){|*x| [x, 3]}
+    @scope.send(m2).must_equal [[], 3]
+
+    m3 = app.define_roda_method("x", 0){|x=5| [x, 4]}
+    @scope.send(m3).must_equal [5, 4]
+
+    m4 = app.define_roda_method("x", 0){|x=6, *y| [x, y, 5]}
+    @scope.send(m4).must_equal [6, [], 5]
+  end
+
+  it "should should optional arguments and splats for expected_arity 1" do
+    m2 = app.define_roda_method("x", 1){|y, *x| [y, x, 3]}
+    @scope.send(m2, :a).must_equal [:a, [], 3]
+
+    m3 = app.define_roda_method("x", 1){|y, x=5| [y, x, 4]}
+    @scope.send(m3, :b).must_equal [:b, 5, 4]
+
+    m4 = app.define_roda_method("x", 1){|y, x=6, *z| [y, x, z, 5]}
+    @scope.send(m4, :c).must_equal [:c, 6, [], 5]
+  end
+
+  it "should handle differences in arity" do
+    m0 = app.define_roda_method("x", 0){|x| [x, 1]}
+    @scope.send(m0).must_equal [nil, 1]
+
+    m1 = app.define_roda_method("x", 1){2}
+    @scope.send(m1, 3).must_equal 2
+  end
+
+  it "should raise for unexpected expected_arity" do
+    proc{app.define_roda_method("x", 2){|x|}}.must_raise Roda::RodaError
+  end
+
+  it "should fail if :check_arity false app option is used and a block with invalid arity is passed" do
+    app.opts[:check_arity] = false
+    m0 = app.define_roda_method("x", 0){|x| [x, 1]}
+    proc{@scope.send(m0)}.must_raise ArgumentError
+
+    m1 = app.define_roda_method("x", 1){2}
+    proc{@scope.send(m1, 1)}.must_raise ArgumentError
+  end
+
+  deprecated "should warn if :check_arity :warn app option is used and a block with invalid arity is passed" do
+    app.opts[:check_arity] = :warn
+    m0 = app.define_roda_method("x", 0){|x| [x, 1]}
+    @scope.send(m0).must_equal [nil, 1]
+
+    m1 = app.define_roda_method("x", 1){2}
+    @scope.send(m1, 3).must_equal 2
+  end
+
+  [false, true].each do |warn_dynamic_arity| 
+    meth = warn_dynamic_arity ? :deprecated : :it
+    send meth, "should handle expected_arity :any and do dynamic arity check/fix" do
+      if warn_dynamic_arity
+        app.opts[:check_dynamic_arity] = :warn
+      end
+
+      m0 = app.define_roda_method("x", :any){1}
+      @scope.send(m0).must_equal 1
+      @scope.send(m0, 2).must_equal 1
+
+      m1 = app.define_roda_method("x", :any){|x| [x, 1]}
+      @scope.send(m1).must_equal [nil, 1]
+      @scope.send(m1, 2).must_equal [2, 1]
+      @scope.send(m1, 2, 3).must_equal [2, 1]
+
+      m2 = app.define_roda_method("x", :any){|x=5| [x, 2]}
+      @scope.send(m2).must_equal [5, 2]
+      @scope.send(m2, 2).must_equal [2, 2]
+      @scope.send(m2, 2, 3).must_equal [2, 2]
+
+      m3 = app.define_roda_method("x", :any){|y, x=5| [x, y, 3]}
+      @scope.send(m3).must_equal [5, nil, 3]
+      @scope.send(m3, 2).must_equal [5, 2, 3]
+      @scope.send(m3, 2, 3).must_equal [3, 2, 3]
+      @scope.send(m3, 2, 3, 4).must_equal [3, 2, 3]
+
+      m4 = app.define_roda_method("x", :any){|*z| [z, 1]}
+      @scope.send(m4).must_equal [[], 1]
+      @scope.send(m4, 2).must_equal [[2], 1]
+
+      m5 = app.define_roda_method("x", :any){|x, *z| [x, z, 1]}
+      @scope.send(m5).must_equal [nil, [], 1]
+      @scope.send(m5, 2).must_equal [2, [], 1]
+      @scope.send(m5, 2, 3).must_equal [2, [3], 1]
+
+      m6 = app.define_roda_method("x", :any){|x=5, *z| [x, z, 2]}
+      @scope.send(m6).must_equal [5, [], 2]
+      @scope.send(m6, 2).must_equal [2, [], 2]
+      @scope.send(m6, 2, 3).must_equal [2, [3], 2]
+
+      m7 = app.define_roda_method("x", :any){|y, x=5, *z| [x, y, z, 3]}
+      @scope.send(m7).must_equal [5, nil, [], 3]
+      @scope.send(m7, 2).must_equal [5, 2, [], 3]
+      @scope.send(m7, 2, 3).must_equal [3, 2, [], 3]
+      @scope.send(m7, 2, 3, 4).must_equal [3, 2, [4], 3]
+    end
+  end
+
+  it "should not fix dynamic arity issues if :check_dynamic_arity false app option is used" do
+    app.opts[:check_dynamic_arity] = false
+
+    m0 = app.define_roda_method("x", :any){1}
+    @scope.send(m0).must_equal 1
+    proc{@scope.send(m0, 2)}.must_raise ArgumentError
+
+    m1 = app.define_roda_method("x", :any){|x| [x, 1]}
+    proc{@scope.send(m1)}.must_raise ArgumentError
+    @scope.send(m1, 2).must_equal [2, 1]
+    proc{@scope.send(m1, 2, 3)}.must_raise ArgumentError
+
+    m2 = app.define_roda_method("x", :any){|x=5| [x, 2]}
+    @scope.send(m2).must_equal [5, 2]
+    @scope.send(m2, 2).must_equal [2, 2]
+    proc{@scope.send(m2, 2, 3)}.must_raise ArgumentError
+
+    m3 = app.define_roda_method("x", :any){|y, x=5| [x, y, 3]}
+    proc{@scope.send(m3)}.must_raise ArgumentError
+    @scope.send(m3, 2).must_equal [5, 2, 3]
+    @scope.send(m3, 2, 3).must_equal [3, 2, 3]
+    proc{@scope.send(m3, 2, 3, 4)}.must_raise ArgumentError
+
+    m4 = app.define_roda_method("x", :any){|*z| [z, 1]}
+    @scope.send(m4).must_equal [[], 1]
+    @scope.send(m4, 2).must_equal [[2], 1]
+
+    m5 = app.define_roda_method("x", :any){|x, *z| [x, z, 1]}
+    proc{@scope.send(m5)}.must_raise ArgumentError
+    @scope.send(m5, 2).must_equal [2, [], 1]
+    @scope.send(m5, 2, 3).must_equal [2, [3], 1]
+
+    m6 = app.define_roda_method("x", :any){|x=5, *z| [x, z, 2]}
+    @scope.send(m6).must_equal [5, [], 2]
+    @scope.send(m6, 2).must_equal [2, [], 2]
+    @scope.send(m6, 2, 3).must_equal [2, [3], 2]
+
+    m7 = app.define_roda_method("x", :any){|y, x=5, *z| [x, y, z, 3]}
+    proc{@scope.send(m7)}.must_raise ArgumentError
+    @scope.send(m7, 2).must_equal [5, 2, [], 3]
+    @scope.send(m7, 2, 3).must_equal [3, 2, [], 3]
+    @scope.send(m7, 2, 3, 4).must_equal [3, 2, [4], 3]
+  end
+
+  if RUBY_VERSION > '2.1'
+    it "should raise for required keyword arguments for expected_arity 0 or 1" do
+      proc{eval("app.define_roda_method('x', 0){|b:| [b, 1]}", binding)}.must_raise Roda::RodaError
+      proc{eval("app.define_roda_method('x', 0){|c=1, b:| [c, b, 1]}", binding)}.must_raise Roda::RodaError
+      proc{eval("app.define_roda_method('x', 1){|x, b:| [b, 1]}", binding)}.must_raise Roda::RodaError
+      proc{eval("app.define_roda_method('x', 1){|x, c=1, b:| [c, b, 1]}", binding)}.must_raise Roda::RodaError
+    end
+
+    it "should ignore keyword arguments for expected_arity 0" do
+      @scope.send(eval("app.define_roda_method('x', 0){|b:2| [b, 1]}", binding)).must_equal [2, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|**b| [b, 1]}", binding)).must_equal [{}, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|c=1, b:2| [c, b, 1]}", binding)).must_equal [1, 2, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|c=1, **b| [c, b, 1]}", binding)).must_equal [1, {}, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|x, b:2| [x, b, 1]}", binding)).must_equal [nil, 2, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|x, **b| [x, b, 1]}", binding)).must_equal [nil, {}, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|x, c=1, b:2| [x, c, b, 1]}", binding)).must_equal [nil, 1, 2, 1]
+      @scope.send(eval("app.define_roda_method('x', 0){|x, c=1, **b| [x, c, b, 1]}", binding)).must_equal [nil, 1, {}, 1]
+    end
+
+    it "should ignore keyword arguments for expected_arity 1" do
+      @scope.send(eval("app.define_roda_method('x', 1){|b:2| [b, 1]}", binding), 3).must_equal [2, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|**b| [b, 1]}", binding), 3).must_equal [{}, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|c=1, b:2| [c, b, 1]}", binding), 3).must_equal [3, 2, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|c=1, **b| [c, b, 1]}", binding), 3).must_equal [3, {}, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|x, b:2| [x, b, 1]}", binding), 3).must_equal [3, 2, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|x, **b| [x, b, 1]}", binding), 3).must_equal [3, {}, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|x, c=1, b:2| [x, c, b, 1]}", binding), 3).must_equal [3, 1, 2, 1]
+      @scope.send(eval("app.define_roda_method('x', 1){|x, c=1, **b| [x, c, b, 1]}", binding), 3).must_equal [3, 1, {}, 1]
+    end
+
+    it "should handle expected_arity :any with keyword arguments" do
+      m = eval('app.define_roda_method("x", :any){|b:2| b}', binding)
+      @scope.send(m).must_equal 2
+      @scope.send(m, 4).must_equal 2
+      @scope.send(m, b: 3).must_equal 3
+      @scope.send(m, 4, b: 3).must_equal 3
+
+      m = eval('app.define_roda_method("x", :any){|b:| b}', binding)
+      proc{@scope.send(m)}.must_raise ArgumentError
+      proc{@scope.send(m, 4)}.must_raise ArgumentError
+      @scope.send(m, b: 3).must_equal 3
+      @scope.send(m, 4, b: 3).must_equal 3
+
+      m = eval('app.define_roda_method("x", :any){|**b| b}', binding)
+      @scope.send(m).must_equal({})
+      @scope.send(m, 4).must_equal({})
+      @scope.send(m, b: 3).must_equal(b: 3)
+      @scope.send(m, 4, b: 3).must_equal(b: 3)
+
+      m = eval('app.define_roda_method("x", :any){|x, b:9| [x, b, 1]}', binding)
+      @scope.send(m).must_equal [nil, 9, 1]
+      @scope.send(m, 2).must_equal [2, 9, 1]
+      @scope.send(m, 2, 3).must_equal [2, 9, 1]
+      @scope.send(m, b: 4).must_equal [{b: 4}, 9, 1]
+      @scope.send(m, 2, b: 4).must_equal [2, 4, 1]
+      @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 1]
+
+      m = eval('app.define_roda_method("x", :any){|x, b:| [x, b, 1]}', binding)
+      proc{@scope.send(m)}.must_raise ArgumentError
+      proc{@scope.send(m, 2)}.must_raise ArgumentError
+      proc{@scope.send(m, 2, 3)}.must_raise ArgumentError
+      proc{@scope.send(m, b: 4)}.must_raise ArgumentError
+      @scope.send(m, 2, b: 4).must_equal [2, 4, 1]
+      @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 1]
+
+      m = eval('app.define_roda_method("x", :any){|x, **b| [x, b, 1]}', binding)
+      @scope.send(m).must_equal [nil, {}, 1]
+      @scope.send(m, 2).must_equal [2, {}, 1]
+      @scope.send(m, 2, 3).must_equal [2, {}, 1]
+      @scope.send(m, b: 4).must_equal [{b: 4}, {}, 1]
+      @scope.send(m, 2, b: 4).must_equal [2, {b: 4}, 1]
+      @scope.send(m, 2, 3, b: 4).must_equal [2, {b: 4}, 1]
+
+      m = eval('m = app.define_roda_method("x", :any){|x=5, b:9| [x, b, 2]}', binding)
+      @scope.send(m).must_equal [5, 9, 2]
+      @scope.send(m, 2).must_equal [2, 9, 2]
+      @scope.send(m, 2, 3).must_equal [2, 9, 2]
+      @scope.send(m, b: 4).must_equal [5, 4, 2]
+      @scope.send(m, 2, b: 4).must_equal [2, 4, 2]
+      @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 2]
+    end
+  end
+end