http_router 0.4.1 → 0.5.0

data/Rakefile

@@ -1,12 +1,13 @@
 require 'rubygems'
 require 'bundler'
 require 'code_stats'
-require 'rspec/core/rake_task'
 
-desc "Run specs"
-RSpec::Core::RakeTask.new do |t|
-  #t.rspec_opts = %w(--options spec/spec.opts)
-  #t.ruby_opts  = %w(-w)
+desc "Run tests"
+task :test do
+  $: << 'lib'
+  require 'http_router'
+  require 'test/helper'
+  Dir['test/**/test_*.rb'].each { |test| require test }
 end
 
 require 'rake/rdoctask'

data/benchmarks/rack_mount.rb

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rbench'
 require 'rack'
 require 'rack/mount'
-require '../usher/lib/usher'
+#require '../usher/lib/usher'
 require 'lib/http_router'
 
 set = Rack::Mount::RouteSet.new do |set|
@@ -11,10 +11,10 @@ set = Rack::Mount::RouteSet.new do |set|
   set.add_route(proc{|env| [200, {'Content-type'=>'text/html'}, []]}, {:path => '/dynamic/:variable'}, {}, :variable)
 end
 
-u = Usher::Interface.for(:rack)
-u.add('/simple').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
-u.add('/simple/again').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
-u.add('/dynamic/anything').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
+#u = Usher::Interface.for(:rack)
+#u.add('/simple').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
+#u.add('/simple/again').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
+#u.add('/dynamic/anything').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
 
 hr = HttpRouter.new
 hr.add('/simple').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
@@ -27,50 +27,21 @@ simple_env = Rack::MockRequest.env_for('/simple')
 simple2_env = Rack::MockRequest.env_for('/simple/again')
 simple_and_dynamic_env = Rack::MockRequest.env_for('/dynamic/anything')
 
-RBench.run(TIMES) do
+3.times do
 
-  report "2 levels, static" do
-    set.url(simple_env, :simple)
-  end
-
-  report "4 levels, static" do
-    set.url(simple_env, :again)
-  end
-
-  report "4 levels, 1 dynamic" do
-    set.url(simple_env, :variable, {:variable => 'onemore'})
-  end
-  
-end
+  RBench.run(TIMES) do
 
-RBench.run(TIMES) do
+    report "2 levels, static" do
+      set.url(simple_env, :simple)
+    end
 
-  report "2 levels, static" do
-    set.url(simple_env, :simple)
-  end
-
-  report "4 levels, static" do
-    set.url(simple_env, :again)
-  end
+    report "4 levels, static" do
+      set.url(simple_env, :again)
+    end
 
-  report "4 levels, 1 dynamic" do
-    set.url(simple_env, :variable, {:variable => 'onemore'})
-  end
+    report "4 levels, 1 dynamic" do
+      set.url(simple_env, :variable, {:variable => 'onemore'})
+    end
   
-end
-
-RBench.run(TIMES) do
-
-  report "2 levels, static" do
-    set.url(simple_env, :simple)
   end
-
-  report "4 levels, static" do
-    set.url(simple_env, :again)
-  end
-
-  report "4 levels, 1 dynamic" do
-    set.url(simple_env, :variable, {:variable => 'onemore'})
-  end
-  
 end

data/benchmarks/rec2.rb

@@ -8,9 +8,9 @@ require 'http_router'
 
 u = HttpRouter.new
 u.add('/simple').to {|env| [200, {'Content-type'=>'text/html'}, []]}
-u.add('/simple/again').compile.to {|env| [200, {'Content-type'=>'text/html'}, []]}
+u.add('/simple/again').to {|env| [200, {'Content-type'=>'text/html'}, []]}
 #u.add('/simple/again/and/again').compile.to {|env| [200, {'Content-type'=>'text/html'}, []]}
-u.add('/dynamic/:variable').compile.to {|env| [200, {'Content-type'=>'text/html'}, []]}
+u.add('/dynamic/:variable').to {|env| [200, {'Content-type'=>'text/html'}, []]}
 #u.add('/rails/:controller/:action/:id').compile.to {|env| [200, {'Content-type'=>'text/html'}, []]}
 #u.add('/greedy/:greed').matching(:greed => /.*/).compile.to {|env| [200, {'Content-type'=>'text/html'}, []]}
 #u.add('/greedy/hey.:greed.html').to {|env| [200, {'Content-type'=>'text/html'}, []]}
@@ -27,10 +27,10 @@ puts Benchmark.measure {
 #
 TIMES = 50_000
 
-simple_env = Rack::MockRequest.env_for('/simple')
-simple2_env = Rack::MockRequest.env_for('/simple/again')
+#simple_env = 
+#simple2_env = 
 #simple3_env = Rack::MockRequest.env_for('/simple/again/and/again')
-simple_and_dynamic_env = Rack::MockRequest.env_for('/dynamic/anything')
+#simple_and_dynamic_env = 
 #simple_and_dynamic_env1 = Rack::MockRequest.env_for('/rails/controller/action/id')
 #simple_and_dynamic_env2 = Rack::MockRequest.env_for('/greedy/controller/action/id')
 #simple_and_dynamic_env3 = Rack::MockRequest.env_for('/greedy/hey.hello.html')
@@ -38,11 +38,11 @@ simple_and_dynamic_env = Rack::MockRequest.env_for('/dynamic/anything')
   RBench.run(TIMES) do
 
     report "2 levels, static" do
-      u.call(simple_env).first == 200 or raise
+      u.call(Rack::MockRequest.env_for('/simple')).first == 200 or raise
     end
 
     report "4 levels, static" do
-      u.call(simple2_env).first == 200 or raise
+      u.call(Rack::MockRequest.env_for('/simple/again')).first == 200 or raise
     end
 
     #report "8 levels, static" do
@@ -50,7 +50,7 @@ simple_and_dynamic_env = Rack::MockRequest.env_for('/dynamic/anything')
     #end
 
     report "4 levels, 1 dynamic" do
-      u.call(simple_and_dynamic_env).first == 200 or raise
+      u.call(Rack::MockRequest.env_for('/dynamic/anything')).first == 200 or raise
     end
 
     #report "8 levels, 3 dynamic" do

data/http_router.gemspec

@@ -20,14 +20,15 @@ Gem::Specification.new do |s|
   s.rubyforge_project = 'http_router'
 
   # dependencies
-  s.add_runtime_dependency 'rack',        '>= 1.0.0'
-  s.add_runtime_dependency 'url_mount',   '~> 0.2.1'
-  s.add_development_dependency 'rspec',   '~> 2.0.0'
+  s.add_runtime_dependency 'rack',         '>= 1.0.0'
+  s.add_runtime_dependency 'url_mount',    '~> 0.2.1'
+  s.add_development_dependency 'minitest', '~> 2.0.0'
   s.add_development_dependency 'code_stats'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'sinatra'
   s.add_development_dependency 'rbench'
-  s.add_development_dependency 'bundler', "~> 1.0.0"
+  s.add_development_dependency 'phocus'
+  s.add_development_dependency 'bundler',  '~> 1.0.0'
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/lib/http_router/interface/sinatra.rb

@@ -25,16 +25,16 @@ class HttpRouter
         private
           def route!(base=self.class, pass_block=nil)
             if base.router and match = base.router.recognize(@request)
-              if match.matched?
-                @block_params = match.params
-                (@params ||= {}).merge!(match.params_as_hash)
+              if match.first.respond_to?(:path)
+                @block_params = match.first.param_values
+                (@params ||= {}).merge!(match.first.params)
                 pass_block = catch(:pass) do
-                  route_eval(&match.route.dest)
+                  route_eval(&match.first.path.route.dest)
                 end
-              else
+              elsif match.is_a?(Array)
                 route_eval { 
-                  match.headers.each{|k,v| response[k] = v}
-                  status match.status
+                  match[1].each{|k,v| response[k] = v}
+                  status match[0]
                 }
               end
             end

data/lib/http_router/node.rb

@@ -1,5 +1,17 @@
 class HttpRouter
   class Node
+    class Response < Struct.new(:path, :param_values)
+      attr_reader :params
+      def initialize(path, param_values)
+        super
+        if path.splitting_indexes
+          param_values = param_values.dup
+          path.splitting_indexes.each{|i| param_values[i] = param_values[i].split(HttpRouter::Parts::SLASH_RX)}
+        end
+        @params = path.route.default_values ? path.route.default_values.merge(path.hashify_params(param_values)) : path.hashify_params(param_values)
+      end
+    end
+
     attr_accessor :value, :variable, :catchall
     attr_reader :linear, :lookup, :request_node, :arbitrary_node
 
@@ -17,9 +29,7 @@ class HttpRouter
         if val.matches_with
           add_to_linear(val)
         else
-          @catchall ||= router.node
-          @catchall.variable = val
-          @catchall
+          add_to_catchall(val)
         end
       elsif val.is_a?(Regexp)
         add_to_linear(val)
@@ -29,20 +39,6 @@ class HttpRouter
       end
     end
     
-    def add_request_methods(options)
-      if !options.empty?
-        generate_request_method_tree(options)
-      elsif @request_node
-        current_node = @request_node
-        while current_node.request_method
-          current_node = (current_node.catchall ||= router.request_node)
-        end
-        [current_node]
-      else
-        [self]
-      end
-    end
- 
     def add_to_linear(val)
       create_linear
       n = if @linear.assoc(val)
@@ -52,13 +48,7 @@ class HttpRouter
         @linear << [val, new_node]
         new_node
       end
-      @linear.sort!{|a, b|
-        if    a.first.respond_to?(:priority) and b.first.respond_to?(:priority) ; b.first.priority <=> a.first.priority
-        elsif a.first.respond_to?(:priority)                                    ; -1
-        elsif b.first.respond_to?(:priority)                                    ; 1
-        else                                                                    ; 0
-        end
-      }
+      @linear.sort!{|a, b| b.first.priority <=> a.first.priority }
       n
     end
    
@@ -80,35 +70,20 @@ class HttpRouter
       target
     end
     
-    protected
-    
-    attr_reader :router
-
-    def transplant_value
-      if @value
-        target_node = @request_node
-        while target_node.request_method
-          target_node = (target_node.catchall ||= router.request_node)
-        end
-        target_node.value = @value
-        @value = nil
-      end
+    def add_to_catchall(val)
+      (@catchall ||= router.node).variable = val
+      @catchall
     end
     
-    def generate_request_method_tree(request_options)
-      raise UnsupportedRequestConditionError if (request_options.keys & RequestNode::RequestMethods).size != request_options.size
+    def add_request_methods(request_options)
+      raise UnsupportedRequestConditionError if request_options && (request_options.keys & RequestNode::RequestMethods).size != request_options.size
       current_nodes = [self]
       RequestNode::RequestMethods.each do |method|
-        if request_options.key?(method) # so, the request method we care about it ..
-          if current_nodes == [self]
-            current_nodes = [@request_node ||= router.request_node]
-          end
-          
+        if request_options && request_options.key?(method) # so, the request method we care about it ..
+          current_nodes = [@request_node ||= router.request_node] if current_nodes == [self]
           for current_node_index in (0...current_nodes.size)
             current_node = current_nodes.at(current_node_index)
-            unless current_node.request_method
-              current_node.request_method = method
-            end
+            current_node.request_method = method unless current_node.request_method
             case RequestNode::RequestMethods.index(method) <=> RequestNode::RequestMethods.index(current_node.request_method)
             when 0 #use this node
               Array(request_options[method]).each_with_index do |request_value, index|
@@ -134,66 +109,102 @@ class HttpRouter
             end
           end
           current_nodes.flatten!
-        elsif current_nodes.first.is_a?(RequestNode) && !current_nodes.first.request_method.nil?
-          current_nodes.map!{|n| n.catchall ||= router.request_node}
+        else
+          current_nodes.map!{|n| n.is_a?(RequestNode) && n.request_method == method ? (n.catchall ||= router.request_node) : n}
         end
       end
       transplant_value
       current_nodes
     end
 
+    protected
+    
+    attr_reader :router
+
+    def transplant_value
+      if @value && @request_node
+        target_node = @request_node
+        while target_node.request_method
+          target_node = (target_node.catchall ||= router.request_node)
+        end
+        target_node.value ||= @value
+        @value = nil
+      end
+    end
+    
     def escape_val(val)
       val.is_a?(Array) ? val.each{|v| HttpRouter.uri_unescape!(v)} : HttpRouter.uri_unescape!(val)
       val
     end
 
-    def find_on_parts(request, parts, params = [], routes = [])
+    def find_on_parts(request, parts, action = :call, params = [])
       if parts and !parts.empty?
-        if parts.size == 1 and parts.first == '' 
-          potential, match_parts, match_params = catch(:match) { find_on_parts(request, nil, params) }
-          process_match(potential, nil, match_params, routes) if potential and potential.value and (router.ignore_trailing_slash? or potential.value.route.trailing_slash_ignore?)
-        end 
-        if @linear && !@linear.empty?
-          response, dupped_parts, dupped_params = nil, nil, nil
-          next_node = @linear.find do |(tester, node)|
+        find_on_parts(request, nil, :"#{action}_with_trailing_slash", params) if parts.size == 1 and parts.first == ''
+        if @linear
+          dupped_parts, dupped_params = nil, nil
+          response = @linear.find do |(tester, node)|
             if tester.respond_to?(:matches?) and match = tester.matches?(parts)
               dupped_parts, dupped_params = parts.dup, params.dup
               dupped_params << escape_val(tester.consume(match, dupped_parts))
-              node.find_on_parts(request, dupped_parts, dupped_params, routes)
+              node.find_on_parts(request, dupped_parts, action, dupped_params)
             elsif tester.respond_to?(:match) and match = tester.match(parts.whole_path) and match.begin(0) == 0
               dupped_parts, dupped_params = router.split(parts.whole_path[match[0].size, parts.whole_path.size]), params.dup
-              node.find_on_parts(request, dupped_parts, dupped_params, routes)
+              node.find_on_parts(request, dupped_parts, action, dupped_params)
             else
               nil
             end
           end
         end
         if match = @lookup && @lookup[parts.first]
-          match.find_on_parts(request, parts[1, parts.size - 1], params, routes)
+          match.find_on_parts(request, parts[1, parts.size - 1], action, params)
         end
-        if @catchall
+        if catchall
           dupped_parts, dupped_params = parts.dup, params.dup
-          dupped_params << escape_val(@catchall.variable.consume(nil, dupped_parts))
-          @catchall.find_on_parts(request, dupped_parts, dupped_params, routes)
+          dupped_params << escape_val(catchall.variable.consume(nil, dupped_parts))
+          catchall.find_on_parts(request, dupped_parts, action, dupped_params)
         end
       end
-      if request_node
-        request_node.find_on_request_methods(request, parts, params, routes)
-      elsif arbitrary_node
-        arbitrary_node.find_on_arbitrary(request, parts, params, routes)
-      elsif @value
-        process_match(self, parts, params, routes)
-      else
-        nil
-      end
+      request_node.find_on_request_methods(request, parts, action, params) if request_node
+      arbitrary_node.find_on_arbitrary(request, parts, action, params) if arbitrary_node
+      response = process_match(self, parts, params, request, action) if @value
+      nil
     end
 
-    def process_match(node, parts, params, routes)
-      if node.value.route.partially_match?
-        routes.push << [node, parts, params]
-        node
+    def process_match(node, parts, params, request, action)
+      env = request.env
+      case action
+      when :call, :call_with_trailing_slash
+        node.value.each do |path|
+          response_struct = Response.new(path, params)
+          previous_params = env['router.params']
+          env['router'] = router
+          env['router.params'] ||= {}
+          env['router.params'].merge!(response_struct.params)
+          env['router.response'] = response_struct
+          env['SCRIPT_NAME'] ||= ''
+          matched = if path.route.partially_match?
+            env['PATH_INFO'] = "#{HttpRouter::Parts::SLASH}#{parts && parts.join(HttpRouter::Parts::SLASH)}"
+            env['SCRIPT_NAME'] += request.path_info[0, request.path_info.size - env['PATH_INFO'].size]
+            true
+          elsif (parts and (action == :call_with_trailing_slash) and (router.ignore_trailing_slash? or (parts.size == 1 and parts.first == ''))) or parts.nil? || parts.empty?
+            env["PATH_INFO"] = ''
+            env["SCRIPT_NAME"] += request.path_info
+            true
+          else
+            false
+          end
+          if matched
+            response = path.route.dest.call(env)
+            env['router.last_repsonse'] = response
+            if response.first != 404 and response.first != 410
+              throw :response, response
+            end
+          end
+        end if node.value
+      when :nocall, :nocall_with_trailing_slash
+        throw :response, node.value.map{|path| Response.new(path, params)}
       else
-        throw :match, [node, parts, params]
+        raise
       end
     end
 
@@ -208,15 +219,17 @@ class HttpRouter
   end
 
   class ArbitraryNode < Node
-    def find_on_arbitrary(request, parts, params, routes)
+    def find_on_arbitrary(request, parts, action, params)
       next_node = @linear && !@linear.empty? && @linear.find { |(procs, node)| 
-        params_hash = node.value.hashify_params(params)
-        procs.all?{|p| p.call(request, params_hash, node.value.route.dest)}
+        params_hash = node.value ? node.value.first.hashify_params(params) : {}
+        procs.all?{|p| p.call(request, params_hash)}
       }
       if next_node
-        process_match(next_node.last, parts, params, routes)
+        process_match(next_node.last, parts, params, request, action)
       elsif @catchall
-        process_match(@catchall, parts, params, routes)
+        process_match(@catchall, parts, params, request, action)
+      elsif @value
+        process_match(self, parts, params, request, action)
       end
     end
   end
@@ -224,32 +237,20 @@ class HttpRouter
   class RequestNode < Node
     RequestMethods = [:request_method, :host, :port, :scheme, :user_agent, :ip, :fullpath, :query_string].freeze
     attr_accessor :request_method
-    def find_on_request_methods(request, parts, params, routes)
-      next_node = if @request_method
+    def find_on_request_methods(request, parts, action, params)
+      if @request_method
         request_value = request.send(request_method)
-        linear_node(request, parts, params, request_value, routes) or
-          lookup_node(request, parts, params, request_value, routes) or
-          catchall_node(request, parts, params, request_value, routes)
-      end
-      if next_node
-        process_match(next_node, parts, params, routes)
-      else
-        find_on_parts(request, parts, params, routes)
-      end
-    end
-    private
-      def linear_node(request, parts, params, request_value, routes)
-        if @linear && !@linear.empty?
-          node = @linear.find { |(regexp, node)| regexp === request_value }
-          node.last.find_on_request_methods(request, parts, params, routes) if node
+        if @linear && !@linear.empty? && match = @linear.find { |(regexp, node)| regexp === request_value }
+          match.last.find_on_request_methods(request, parts, action, params)
         end
+        @lookup[request_value].find_on_request_methods(request, parts, action, params) if @lookup and @lookup[request_value]
+        @catchall.find_on_request_methods(request, parts, action, params) if @catchall
       end
-      def lookup_node(request, parts, params, request_value, routes)
-        @lookup[request_value].find_on_request_methods(request, parts, params, routes) if @lookup and @lookup[request_value]
-      end
-      def catchall_node(request, parts, params, request_value, routes)
-        @catchall.find_on_request_methods(request, parts, params, routes) if @catchall
+      if @value
+        process_match(self, parts, params, request, action)
+      elsif arbitrary_node
+        arbitrary_node.find_on_arbitrary(request, parts, action, params)
       end
+    end
   end
-  
 end

data/lib/http_router/optional_compiler.rb

@@ -7,11 +7,20 @@ class HttpRouter
       @paths = [""]
       @chars = path.split('')
       while !@chars.empty?
-        case @chars.first
-          when '('  then @chars.shift and double_paths
-          when ')'  then @chars.shift and half_paths
-          when '\\' then @chars.shift and add_to_current_set(@chars.shift)
-          else           add_to_current_set(@chars.shift)
+      case @chars.first[0]
+        when ?(
+          @chars.shift and double_paths
+        when ?)
+          @chars.shift and half_paths
+        when ?\\ 
+          if @chars[1] == ?( || @chars[1] == ?)
+            @chars.shift 
+          else
+            add_to_current_set(@chars.shift)
+          end
+          add_to_current_set(@chars.shift)
+        else
+          add_to_current_set(@chars.shift)
         end
       end
       @paths

data/lib/http_router/path.rb

@@ -3,30 +3,36 @@ class HttpRouter
     attr_reader :parts, :route, :splitting_indexes, :path
     def initialize(route, path, parts, splitting_indexes)
       @route, @path, @parts, @splitting_indexes = route, path, parts, splitting_indexes
-      
       duplicate_variable_names = variable_names.dup.uniq!
       raise AmbiguousVariableException, "You have duplicate variable name present: #{duplicate_variable_names.join(', ')}" if duplicate_variable_names
-
-      @path_validation_regex = path.split(/([:\*][a-zA-Z0-9_]+)/).map{ |part|
-        case part[0]
+      regex_parts = path.split(/([:\*][a-zA-Z0-9_]+)/)
+      @path_validation_regex, code = '', ''
+      regex_parts.each_with_index{ |part, index|
+        new_part = case part[0]
         when ?:, ?*
-          route.matches_with[part[1, part.size].to_sym] || '.*?' 
+          if index != 0 && regex_parts[index - 1][-1] == ?\\
+            @path_validation_regex << Regexp.quote(part)
+            code << part
+          else
+            @path_validation_regex << (route.matches_with[part[1, part.size].to_sym] || '.*?').to_s
+            code << "\#{args.shift || (options && options.delete(:#{part[1, part.size]})) || raise(MissingParameterException, \"missing parameter :#{part[1, part.size]}\")}"
+          end
         else
-          Regexp.quote(part)
+          @path_validation_regex << Regexp.quote(part)
+          code << part
         end
-      }.join
+        new_part
+      }
       @path_validation_regex = Regexp.new("^#{@path_validation_regex}$")
-
-      eval_path = path.gsub(/[:\*]([a-zA-Z0-9_]+)/) {"\#{args.shift || (options && options.delete(:#{$1})) || raise(MissingParameterException, \"missing parameter #{$1}\")}" }
       instance_eval "
       def raw_url(args,options)
-        \"#{eval_path}\"
+        \"#{code}\"
       end
       "
     end
 
     def hashify_params(params)
-      variable_names.zip(params).inject({}) { |h, (k,v)| h[k] = v; h }
+      variable_names && params ? variable_names.zip(params).inject({}) { |h, (k,v)| h[k] = v; h } : {}
     end
 
     def ===(other_path)
@@ -50,23 +56,7 @@ class HttpRouter
       raise InvalidRouteException if path !~ @path_validation_regex
       raise TooManyParametersException unless args.empty?
       HttpRouter.uri_escape!(path)
-      generate_querystring(path, options)
-      path
-    end
-
-    def generate_querystring(uri, params)
-      if params && !params.empty?
-        uri_size = uri.size
-        params.each do |k,v|
-          case v
-          when Array
-            v.each { |v_part| uri << '&' << ::Rack::Utils.escape(k.to_s) << '%5B%5D=' << ::Rack::Utils.escape(v_part.to_s) }
-          else
-            uri << '&' << ::Rack::Utils.escape(k.to_s) << '=' << ::Rack::Utils.escape(v.to_s)
-          end
-        end
-        uri[uri_size] = ??
-      end
+      [path, options]
     end
 
     def static?

data/lib/http_router/root.rb

@@ -9,40 +9,28 @@ class HttpRouter
       node
     end
 
-    def find(request)
-      routes = []
-      node, parts, params = catch(:match) { find_on_parts(request, get_parts(request), [], routes) }
-      if !routes.empty?
-        routes.map { |node, parts, params| process_response(node, parts, params, request) }
-      elsif node
-        process_response(node, parts, params, request)
-      elsif !router.request_methods_specified.empty?
-        alternate_methods = (router.request_methods_specified - [request.request_method]).select do |alternate_method|
-          test_request = request.dup
-          test_request.env['REQUEST_METHOD'] = alternate_method
-          routes = []
-          catch(:match) { find_on_parts(test_request, get_parts(request), [], routes) } || !routes.empty?
-        end
-        alternate_methods.empty? ? nil : Response.unmatched(405, {"Allow" => alternate_methods.join(", ")})
-      else
-        nil
-      end
+    def recognize(request)
+      call(request, :nocall)
     end
 
-    def get_parts(request)
-      parts = router.split(request.path_info.dup)
-      parts << '' if request.path_info[-1] == ?/
-      parts
+    def call(request, action = :call)
+      request = ::Rack::Request.new(request) if request.is_a?(Hash)
+      catch(:response) { find_on_parts(request, get_parts(request), action) } || construct_unmatched(request)
     end
 
-    private
-    def process_response(node, parts, params, request)
-      if parts.nil? || parts.empty?
-        Response.matched(node.value, params, request.path_info)
-      elsif node.value.route.partially_match?
-        rest = '/' << parts.join('/')
-        Response.matched(node.value, params, request.path_info[0, request.path_info.size - rest.size], rest)
+    def construct_unmatched(request)
+      alternate_methods = (router.request_methods_specified - [request.request_method]).select do |alternate_method|
+        test_request = ::Rack::Request.new(request.env.dup)
+        test_request.env['REQUEST_METHOD'] = alternate_method
+        catch(:response) { find_on_parts(test_request, get_parts(request), :nocall) }
       end
+      alternate_methods.empty? ? nil : ::Rack::Response.new("Method not found", 405, {"Allow" => alternate_methods.join(", ")}).finish
+    end
+
+    def get_parts(request)
+      parts = router.split(request.path_info)
+      parts << '' if request.path_info.size > 1 && request.path_info[-1] == ?/
+      parts
     end
   end
 end