http_router 0.3.17 → 0.4.0

data/Gemfile

@@ -8,5 +8,6 @@ group :development do
   gem 'rake'
   gem 'sinatra'
   gem 'rbench'
+  gem 'code_stats'
   gem 'tumbler', ">= 0.0.11"
 end

data/lib/http_router/node.rb

@@ -53,14 +53,10 @@ class HttpRouter
         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
+        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
       }
       n
@@ -151,103 +147,108 @@ class HttpRouter
       val
     end
 
-    def find_on_parts(request, parts, params)
+    def find_on_parts(request, parts, params = [], routes = [])
       if parts and !parts.empty?
-        if potential = potential_match(request, parts, params)
-          return potential
-        end
+        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 = nil
-          dupped_parts = nil
-          dupped_params = nil
+          response, dupped_parts, dupped_params = nil, nil, nil
           next_node = @linear.find do |(tester, node)|
             if tester.respond_to?(:matches?) and match = tester.matches?(parts)
-              dupped_parts = parts.dup
-              dupped_params = params.dup
+              dupped_parts, dupped_params = parts.dup, params.dup
               dupped_params << escape_val(tester.consume(match, dupped_parts))
-              parts.replace(dupped_parts) if response = node.find_on_parts(request, dupped_parts, dupped_params)
+              node.find_on_parts(request, dupped_parts, dupped_params, routes)
             elsif tester.respond_to?(:match) and match = tester.match(parts.whole_path) and match.begin(0) == 0
-              dupped_parts = router.split(parts.whole_path[match[0].size, parts.whole_path.size])
-              dupped_params = params.dup
-              parts.replace(dupped_parts) if response = node.find_on_parts(request, dupped_parts, dupped_params)
+              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)
             else
               nil
             end
           end
-          if response
-            params.replace(dupped_params)
-            return response
-          end
         end
         if match = @lookup && @lookup[parts.first]
-          part = parts.shift
-          if match = match.find_on_parts(request, parts, params)
-            return match
-          else
-            parts.unshift(part)
-          end
+          match.find_on_parts(request, parts[1, parts.size - 1], params, routes)
         end
         if @catchall
-          params << escape_val(@catchall.variable.consume(nil, parts))
-          return @catchall.find_on_parts(request, parts, params)
+          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)
         end
       end
-      request_node and request_node.find_on_request_methods(request) or resolve_node(request)
+      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
     end
 
-    def create_linear
-      @linear ||= []
+    def process_match(node, parts, params, routes)
+      if node.value.route.partially_match?
+        routes.push << [node, parts, params]
+        node
+      else
+        throw :match, [node, parts, params]
+      end
     end
 
-    def create_lookup
-      @lookup ||= {}
-    end
-    
     protected
-      def resolve_node(request)
-        if arbitrary_node
-          arbitrary_node.find_on_arbitrary(request)
-        elsif @value
-          self
-        else
-          nil
-        end
+      def create_linear
+        @linear ||= []
       end
-    
-      def potential_match(request, parts, params)
-        parts.size == 1 and parts.first == '' and potential = find_on_parts(request, nil, params) and (router.ignore_trailing_slash? or (potential.value and potential.value.route.trailing_slash_ignore?)) and parts.shift ? potential : nil
+
+      def create_lookup
+        @lookup ||= {}
       end
   end
 
   class ArbitraryNode < Node
-    def find_on_arbitrary(request)
-      next_node = @linear && !@linear.empty? && @linear.find { |(procs, node)| procs.all?{|p| p.call(request)} }
-      next_node && next_node.last || @catchall
+    def find_on_arbitrary(request, parts, params, routes)
+      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)}
+      }
+      if next_node
+        process_match(next_node.last, parts, params, routes)
+      elsif @catchall
+        process_match(@catchall, parts, params, routes)
+      end
     end
   end
   
   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)    
+    def find_on_request_methods(request, parts, params, routes)
       next_node = if @request_method
         request_value = request.send(request_method)
-        linear_node(request, request_value) or lookup_node(request, request_value) or catchall_node(request)
+        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
-      next_node or resolve_node(request)
     end
     private
-      def linear_node(request, request_value)
+      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) if node
+          node.last.find_on_request_methods(request, parts, params, routes) if node
         end
       end
-      def lookup_node(request, request_value)
-        @lookup[request_value].find_on_request_methods(request) if @lookup and @lookup[request_value]
+      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)
-        @catchall.find_on_request_methods(request) if @catchall
+      def catchall_node(request, parts, params, request_value, routes)
+        @catchall.find_on_request_methods(request, parts, params, routes) if @catchall
       end
   end
   

data/lib/http_router/parts.rb

@@ -1,11 +1,14 @@
 class HttpRouter
   class Parts < Array
+    SLASH = '/'.freeze
+    SLASH_RX = Regexp.new(SLASH)
+    
     def initialize(path)
-      super((path[0] == ?/ ? path[1, path.size] : path).split('/'))
+      super((path[0] == ?/ ? path[1, path.size] : path).split(SLASH_RX))
     end
 
     def whole_path
-      @whole_path ||= join('/')
+      @whole_path ||= join(SLASH)
     end
 
     def shift

data/lib/http_router/path.rb

@@ -1,6 +1,6 @@
 class HttpRouter
   class Path
-    attr_reader :parts, :route, :splitting_indexes
+    attr_reader :parts, :route, :splitting_indexes, :path
     def initialize(route, path, parts, splitting_indexes)
       @route, @path, @parts, @splitting_indexes = route, path, parts, splitting_indexes
       
@@ -25,6 +25,10 @@ class HttpRouter
       "
     end
 
+    def hashify_params(params)
+      variable_names.zip(params).inject({}) { |h, (k,v)| h[k] = v; h }
+    end
+
     def ===(other_path)
       return false if @parts.size != other_path.parts.size
       @parts.each_with_index {|p,i| 
@@ -56,15 +60,19 @@ class HttpRouter
         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) }
+            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)
+            uri << '&' << ::Rack::Utils.escape(k.to_s) << '=' << ::Rack::Utils.escape(v.to_s)
           end
         end
         uri[uri_size] = ??
       end
     end
 
+    def static?
+      variables.empty?
+    end
+
     def variables
       unless @variables
         @variables = @parts.select{|p| p.is_a?(Variable)}

data/lib/{ext/rack/rack_mapper.rb → http_router/rack/builder.rb}

@@ -1,6 +1,6 @@
 # Replacement for {Rack::Builder} which using HttpRouter to map requests instead of a simple Hash.
 # As well, add convenience methods for the request methods.
-class Rack::Builder
+class HttpRouter::Rack::Builder < ::Rack::Builder
   def initialize(&block)
     super
   end

data/lib/{ext/rack/rack_urlmap.rb → http_router/rack/url_map.rb}

@@ -1,4 +1,4 @@
-class Rack::URLMap
+class HttpRouter::Rack::URLMap < ::Rack::URLMap
   def initialize(map = {})
     @router = HttpRouter.new
     map.each { |path, app| (path =~ /^(https?):\/\/(.*?)(\/.*)/ ? @router.add($3).host($2).scheme($1) : @router.add(path)).partial.to(app) }

data/lib/http_router/rack.rb

@@ -0,0 +1,18 @@
+class HttpRouter
+  module Rack
+    autoload :URLMap,  'http_router/rack/url_map'
+    autoload :Builder, 'http_router/rack/buidler'
+
+    # Monkey-patches Rack::Builder to use HttpRouter.
+    # See examples/rack_mapper.rb
+    def self.override_rack_builder!
+      ::Rack.class_eval("OriginalBuilder = Builder; HttpRouterBuilder = HttpRouter::Rack::Builder; remove_const :Builder; Builder = HttpRouterBuilder")
+    end
+
+    # Monkey-patches Rack::URLMap to use HttpRouter.
+    # See examples/rack_mapper.rb
+    def self.override_rack_urlmap!
+      ::Rack.class_eval("OriginalURLMap = URLMap; HttpRouterURLMap = HttpRouter::Rack::URLMap; remove_const :URLMap; URLMap = HttpRouterURLMap")
+    end
+  end
+end

data/lib/http_router/response.rb

@@ -21,8 +21,8 @@ class HttpRouter
       def initialize(path, params, matched_path, remaining_path = nil)
         raise if matched_path.nil?
         super
-        path.splitting_indexes and path.splitting_indexes.each{|i| params[i] = params[i].split('/')}
-        @params_as_hash = path.variable_names.zip(params).inject({}) {|h, (k,v)| h[k] = v; h }
+        path.splitting_indexes and path.splitting_indexes.each{|i| params[i] = params[i].split(HttpRouter::Parts::SLASH_RX)}
+        @params_as_hash = path.hashify_params(params)
       end
 
       def matched?

data/lib/http_router/root.rb

@@ -10,10 +10,23 @@ class HttpRouter
     end
 
     def find(request)
-      params = []
-      parts = get_parts(request)
-      node = find_on_parts(request, parts, params)
-      process_response(node, parts, params, 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
     end
 
     def get_parts(request)
@@ -24,25 +37,11 @@ class HttpRouter
 
     private
     def process_response(node, parts, params, request)
-      if node && node.value
-        if 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)
-        else
-          nil
-        end
-      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
-          node = find_on_parts(test_request, get_parts(request), [])
-          node && node.value
-        end
-        alternate_methods.empty? ? nil : Response.unmatched(405, {"Allow" => alternate_methods.join(", ")})
-      else
-        nil
+      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)
       end
     end
   end

data/lib/http_router/route.rb

@@ -167,10 +167,10 @@ class HttpRouter
 
     # Convenient regexp matching on an entire path. Returns +self+
     def match_path(matcher)
-      arbitrary{|env| match = matcher.match(env.path_info); !match.nil? and match.begin(0) == 0 and match[0].size == env.path_info.size}
+      arbitrary{|env, params, dest| match = matcher.match(env.path_info); !match.nil? and match.begin(0) == 0 and match[0].size == env.path_info.size}
     end
 
-    # Adds an arbitrary proc matcher to a Route. Receives either a block, or a proc. The proc will receive a Rack::Request object and must return true for the Route to be matched. Returns +self+.
+    # Adds an arbitrary proc matcher to a Route. Receives either a block, or a proc. The proc will receive a Rack::Request object, a Hash of the params, and the destination for this route. The proc must return true if the Route is matched. Returns +self+.
     def arbitrary(proc = nil, &block)
       guard_compiled
       @arbitrary << (proc || block)
@@ -240,22 +240,17 @@ class HttpRouter
     # Generates a URL for this route. See HttpRouter#url for how the arguments for this are structured.
     def url(*args)
       options = args.last.is_a?(Hash) ? args.pop : nil
-      options ||= {} if default_values
-      options = default_values.merge(options) if default_values && options
+      options = options.nil? ? default_values.dup : default_values.merge(options) if default_values
+      options.delete_if{ |k,v| v.nil? } if options
       path = if args.empty?
         matching_path(options)
       else
         matching_path(args, options)
       end
       raise UngeneratableRouteException unless path
-
-      mount_point = nil
-      if !router.url_mount.nil?
-        mount_point = router.url_mount.url(options)
-      end
-
+      mount_point = router.url_mount && router.url_mount.url(options)
       result = path.url(args, options)
-      mount_point.nil? ? result : File.join(mount_point, result)
+      mount_point ? File.join(mount_point, result) : result
     end
 
     def significant_variable_names

data/lib/http_router/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 class HttpRouter #:nodoc
-  VERSION = '0.3.17'
+  VERSION = '0.4.0'
 end

data/lib/http_router.rb

@@ -11,6 +11,7 @@ require 'http_router/path'
 require 'http_router/optional_compiler'
 require 'http_router/parts'
 require 'http_router/version'
+require 'http_router/rack'
 
 class HttpRouter
   # Raised when a Route is not able to be generated.
@@ -33,18 +34,6 @@ class HttpRouter
   attr_reader :named_routes, :routes, :root, :request_methods_specified
   attr_accessor :url_mount
 
-  # Monkey-patches Rack::Builder to use HttpRouter.
-  # See examples/rack_mapper.rb
-  def self.override_rack_mapper!
-    require File.join('ext', 'rack', 'rack_mapper')
-  end
-
-  # Monkey-patches Rack::Builder to use HttpRouter.
-  # See examples/rack_mapper.rb
-  def self.override_rack_urlmap!
-    require File.join('ext', 'rack', 'rack_urlmap')
-  end
-
   # Creates a new HttpRouter.
   # Can be called with either <tt>HttpRouter.new(proc{|env| ... }, { .. options .. })</tt> or with the first argument omitted.
   # If there is a proc first, then it's used as the default app in the case of a non-match.
@@ -56,7 +45,7 @@ class HttpRouter
   def initialize(*args, &block)
     default_app, options = args.first.is_a?(Hash) ? [nil, args.first] : [args.first, args[1]]
     @options                   = options
-    @default_app               = default_app || options && options[:default_app] || proc{|env| Rack::Response.new("Not Found", 404).finish }
+    @default_app               = default_app || options && options[:default_app] || proc{|env| ::Rack::Response.new("Not Found", 404).finish }
     @ignore_trailing_slash     = options && options.key?(:ignore_trailing_slash) ? options[:ignore_trailing_slash] : true
     @redirect_trailing_slash   = options && options.key?(:redirect_trailing_slash) ? options[:redirect_trailing_slash] : false
     @middleware                = options && options.key?(:middleware) ? options[:middleware] : false
@@ -148,7 +137,14 @@ class HttpRouter
 
   # Returns the HttpRouter::Response object if the env is matched, otherwise, returns +nil+.
   def recognize(env)
-    response = @root.find(env.is_a?(Hash) ? Rack::Request.new(env) : env)
+    response = recognize_full(env)
+    response.is_a?(Array) ? response.first : response
+  end
+
+  # Returns the HttpRouter::Response object if the env is matched, an array of HttpRouter::Response objects or otherwise, returns +nil+. If it
+  # returns an array, this represents a set of possible matches.
+  def recognize_full(env)
+    @root.find(env.is_a?(Hash) ? ::Rack::Request.new(env) : env)
   end
 
   # Generate a URL for a specified route. This will accept a list of variable values plus any other variable names named as a hash.
@@ -167,12 +163,9 @@ class HttpRouter
   #   # ==> "/123.html?fun=inthesun"
   def url(route, *args)
     case route
-      when Symbol
-        url(@named_routes[route], *args)
-      when nil
-        raise UngeneratableRouteException
-      else
-        route.url(*args)
+    when Symbol then url(@named_routes[route], *args)
+    when nil    then raise UngeneratableRouteException
+    else             route.url(*args)
     end
   end
 
@@ -181,17 +174,28 @@ class HttpRouter
   # be available under the key <tt>router.params</tt>. The HttpRouter::Response object will be available under the key <tt>router.response</tt> if
   # a response is available.
   def call(env)
-    request = Rack::Request.new(env)
+    request = ::Rack::Request.new(env)
     if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/
-      response = Rack::Response.new
+      response = ::Rack::Response.new
       response.redirect(request.path_info[0, request.path_info.size - 1], 302)
       response.finish
     else
       env['router'] = self
-      if response = recognize(request) and !@middleware
-        if response.matched? && response.route.dest
+      if response = recognize_full(request) and !@middleware
+        if response.is_a?(Array)
+          call_env = env.dup
+          response.each do |match|
+            if match.route.dest.respond_to?(:call)
+              process_params(call_env, match)
+              consume_path!(call_env, match)
+              app_response = match.route.dest.call(call_env)
+              return app_response unless app_response.first == 404 or app_response.first == 410
+            else
+              return response
+            end
+          end
+        elsif response.matched? && response.route.dest
           process_params(env, response)
-          consume_path!(request, response) if response.partial_match?
           return response.route.dest.call(env) if response.route.dest.respond_to?(:call)
         elsif !response.matched?
           return [response.status, response.headers, []]
@@ -239,7 +243,6 @@ class HttpRouter
       new_route = route.clone(cloned_router)
       cloned_router.add_route(new_route).compile
       new_route.name(route.named) if route.named
-
       if route.dest
         begin
           new_route.to route.dest.clone
@@ -265,9 +268,9 @@ class HttpRouter
 
   private
 
-  def consume_path!(request, response)
-    request.env["SCRIPT_NAME"] = (request.env["SCRIPT_NAME"] + response.matched_path)
-    request.env["PATH_INFO"] = response.remaining_path.nil? || response.remaining_path == '' ? '/' : response.remaining_path
+  def consume_path!(env, response)
+    env["SCRIPT_NAME"] = (env["SCRIPT_NAME"] + response.matched_path)
+    env["PATH_INFO"] = response.remaining_path.nil? || response.remaining_path == '' ? '/' : response.remaining_path
   end
 
   def process_params(env, response)

data/spec/generate_spec.rb

@@ -131,6 +131,13 @@ describe "HttpRouter#generate" do
       end
     end
 
+    context "with nil values" do
+      it "shouldn't use nil values" do
+        @router.add("/url(/:var)").name(:test).compile
+        @router.url(:test, :var => nil).should == "/url"
+      end
+    end
+
     context "with a matching" do
       it "should raise an exception when the route is invalid" do
         @router.add("/:var").matching(:var => /\d+/).name(:test).compile

data/spec/rack/urlmap_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "Rack::Urlmap replacement" do
   it "should map urls" do
-    HttpRouter.override_rack_urlmap!
+    HttpRouter::Rack.override_rack_urlmap!
     map = Rack::URLMap.new(
       "http://www.example.org/test" => proc {|env| [200, {}, ['test']]},
       "http://www.example.org/:test" => proc {|env| [200, {}, ['variable']]}

data/spec/recognize_spec.rb

@@ -58,38 +58,54 @@ describe "HttpRouter#recognize" do
 
     end
 
+    context("with multiple partial matching") do
+      it "should match partially" do
+        @router.add("/test").partial.to{|env| [200, {}, ['/test',env['PATH_INFO']]]}
+        @router.add("/").partial.to{|env| [200, {}, ['/',env['PATH_INFO']]]}
+        @router.call(Rack::MockRequest.env_for('/test/optional')).last.should == ['/test', '/optional']
+        @router.call(Rack::MockRequest.env_for('/testing/optional')).last.should == ['/', '/testing/optional']
+      end
+    end
+
+
     context("with proc acceptance") do
       it "should match" do
-        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'hellodooly' }).to(:test1)
-        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test2)
-        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test3)
+        @router.add("/test").arbitrary(Proc.new{|req, params, dest| req.host == 'hellodooly' }).to(:test1)
+        @router.add("/test").arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}.to(:test2)
+        @router.add("/test").arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}.to(:test3)
         response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8080/test'))
         response.dest.should == :test3
       end
 
       it "should still use an existing less specific node if possible" do
         @router.add("/test").to(:test4)
-        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'hellodooly' }).to(:test1)
-        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test2)
-        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test3)
+        @router.add("/test").arbitrary(Proc.new{|req, params, dest| req.host == 'hellodooly' }).to(:test1)
+        @router.add("/test").arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}.to(:test2)
+        @router.add("/test").arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}.to(:test3)
         response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8081/test'))
         response.dest.should == :test4
       end
 
       it "should match with request conditions" do
-        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test1)
-        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test2)
+        @router.add("/test").get.arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}.to(:test1)
+        @router.add("/test").get.arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}.to(:test2)
         response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8080/test'))
         response.dest.should == :test2
       end
 
       it "should still use an existing less specific node if possible with request conditions" do
-        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test1)
-        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test2)
+        @router.add("/test").get.arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}.to(:test1)
+        @router.add("/test").get.arbitrary(Proc.new{|req, params, dest| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}.to(:test2)
         @router.add("/test").get.to(:test3)
         response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8081/test'))
         response.dest.should == :test3
       end
+
+      it "should pass params and dest" do
+        @router.add("/:test").get.arbitrary(Proc.new{|req, params, dest| params[:test] == 'test' and dest == :test1 }).to(:test1)
+        response = @router.recognize(Rack::MockRequest.env_for('/test'))
+        response.dest.should == :test1
+      end
     end
 
     context("with trailing slashes") do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
-  hash: 49
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 17
-  version: 0.3.17
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-08 00:00:00 -07:00
+date: 2010-10-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -169,8 +169,6 @@ files:
 - examples/variable.ru
 - examples/variable_with_regex.ru
 - http_router.gemspec
-- lib/ext/rack/rack_mapper.rb
-- lib/ext/rack/rack_urlmap.rb
 - lib/http_router.rb
 - lib/http_router/glob.rb
 - lib/http_router/interface/sinatra.rb
@@ -178,6 +176,9 @@ files:
 - lib/http_router/optional_compiler.rb
 - lib/http_router/parts.rb
 - lib/http_router/path.rb
+- lib/http_router/rack.rb
+- lib/http_router/rack/builder.rb
+- lib/http_router/rack/url_map.rb
 - lib/http_router/response.rb
 - lib/http_router/root.rb
 - lib/http_router/route.rb