http_router 0.6.9 → 0.7.0

data/{README.rdoc → README.md}

@@ -1,6 +1,10 @@
-= HTTP Router
+# HTTP Router
 
-== Features
+## What is it?
+
+This is an HTTP router for use in either a web framework, or on it's own using Rack. It takes a set of routes and attempts to find the best match for it. Take a look at the examples directory for how you'd use it in the Rack context.
+
+## Features
 
 * Supports variables, and globbing, both named and unnamed.
 * Regex support for variables.
@@ -10,30 +14,30 @@
 * Very fast and small code base (~1,000 loc).
 * Sinatra via https://github.com/joshbuddy/http_router_sinatra
 
-== Usage
+## Usage
 
 Please see the examples directory for a bunch of awesome rackup file examples, with tonnes of commentary. As well, the rdocs should provide a lot of useful specifics and exact usage.
 
-=== <tt>HttpRouter.new</tt>
+### `HttpRouter.new`
 
 Takes the following options:
 
-* <tt>:default_app</tt> - The default #call made on non-matches. Defaults to a 404 generator.
-* <tt>:ignore_trailing_slash</tt> - Ignores the trailing slash when matching. Defaults to true.
-* <tt>:redirect_trailing_slash</tt> - Redirect on trailing slash matches to non-trailing slash paths. Defaults to false.
-* <tt>:middleware</tt> - Perform matching without deferring to matched route. Defaults to false.
+* `:default_app` - The default #call made on non-matches. Defaults to a 404 generator.
+* `:ignore_trailing_slash` - Ignores the trailing slash when matching. Defaults to true.
+* `:redirect_trailing_slash` - Redirect on trailing slash matches to non-trailing slash paths. Defaults to false.
+* `:middleware` - Perform matching without deferring to matched route. Defaults to false.
 
-=== <tt>#add(name, options)</tt>
+### `#add(name, options)`
 
 Maps a route. The format for variables in paths is:
   :variable
   *glob
 
-Everything else is treated literally. Optional parts are surrounded by brackets. Partially matching paths have a trailing <tt>*</tt>. Optional trailing slash matching is done with <tt>/?</tt>.
+Everything else is treated literally. Optional parts are surrounded by brackets. Partially matching paths have a trailing `*`. Optional trailing slash matching is done with `/?`.
 
-As well, you can escape the following characters with a backslash: <tt>( ) : *</tt>
+As well, you can escape the following characters with a backslash: `( ) : *`
 
-Once you have a route object, use <tt>HttpRouter::Route#to</tt> to add a destination and <tt>HttpRouter::Route#name</tt> to name it.
+Once you have a route object, use `HttpRouter::Route#to` to add a destination and `HttpRouter::Route#name` to name it.
 
 e.g.
 
@@ -42,22 +46,22 @@ e.g.
   r.add('/test').redirect("http://www.google.com/")
   r.add('/static').static('/my_file_system')
 
-As well, you can support regex matching and request conditions. To add a regex match, use <tt>matching(:id => /\d+/)</tt>.
-To match on a request condition you can use <tt>condition(:request_method => %w(POST HEAD))</tt> or more succinctly <tt>request_method('POST', 'HEAD')</tt>.
+As well, you can support regex matching and request conditions. To add a regex match, use `matching(:id => /\d+/)`.
+To match on a request condition you can use `condition(:request_method => %w(POST HEAD))` or more succinctly `request_method('POST', 'HEAD')`.
 
 There are convenience methods HttpRouter#get, HttpRouter#post, etc for each request method.
 
-Routes will not be recognized unless <tt>#to</tt> has been called on it.
+Routes will not be recognized unless `#to` has been called on it.
 
-=== <tt>#url(name or route, *args)</tt>
+### `#url(name or route, *args)`
 
 Generates a route. The args can either be a hash, a list, or a mix of both.
 
-=== <tt>#call(env or Rack::Request)</tt>
+### `#call(env or Rack::Request)`
 
 Recognizes and dispatches the request.
 
-=== <tt>#recognize(env or Rack::Request)</tt>
+### `#recognize(env or Rack::Request)`
 
 Only performs recognition.
 

data/Rakefile

@@ -39,7 +39,7 @@ namespace :test do
           case c
           when /^\$/
             out = `#{c[1, c.size]} 2>/dev/null`.split(/\n/)
-            raise "#{c} produced #{out}" unless $?.success?
+            raise "#{c} produced #{`#{c[1, c.size]} 2>&1`}" unless $?.success?
           when /^=> ?(.*)/
             c = $1
             raise "out was nil" if out.nil?

data/examples/rack_mapper.ru

@@ -1,8 +1,8 @@
 require 'http_router'
 HttpRouter::Rack.override_rack_builder!
 
-map('/get/:id') { |env|
-  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}\n"]]
+map('/get/:id', :matching => {:id => /\d+/}) { |env|
+  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}, which is a number\n"]]
 }
 
 # you have post, get, head, put and delete.
@@ -10,10 +10,11 @@ post('/get/:id') { |env|
   [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]} and you posted!\n"]]
 }
 
-map('/get/:id', :matching => {:id => /\d+/}) { |env|
-  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}, which is a number\n"]]
+map('/get/:id') { |env|
+  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}\n"]]
 }
 
+
 # $ curl http://127.0.0.1:3000/get/foo
 # => My id is foo
 # $ curl -X POST http://127.0.0.1:3000/get/foo

data/http_router.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.summary = "A kick-ass HTTP router for use in Rack"
   s.description = "This library allows you to recognize and build URLs in a Rack application."
   s.email = %q{joshbuddy@gmail.com}
-  s.extra_rdoc_files = ['README.rdoc']
+  s.extra_rdoc_files = ['README.md']
   s.files = `git ls-files`.split("\n")
   s.homepage = %q{http://github.com/joshbuddy/http_router}
   s.rdoc_options = ["--charset=UTF-8"]

data/lib/http_router/node/arbitrary.rb

@@ -2,13 +2,14 @@ class HttpRouter
   class Node
     class Arbitrary < Node
       def initialize(router, allow_partial, blk, param_names)
-        @router, @allow_partial, @blk, @param_names = router, allow_partial, blk, param_names
+        @allow_partial, @blk, @param_names = allow_partial, blk, param_names
+        super(router)
       end
 
       def [](request)
         if request.path.empty? or (request.path.size == 1 and request.path[0] == '') or @allow_partial
           request = request.clone
-          request.continue = proc { |state| destination(request) if state }
+          request.continue = proc { |state| super(request) if state }
           params = @param_names.nil? ? {} : Hash[@param_names.zip(request.params)]
           @blk.call(request, params)
         end

data/lib/http_router/node/destination.rb

@@ -0,0 +1,21 @@
+class HttpRouter
+  class Node
+    class Destination < Node
+      def initialize(router, blk, allow_partial)
+        @blk, @allow_partial = blk, allow_partial
+        super(router)
+      end
+
+      def [](request)
+        if request.path.empty? or (request.path.size == 1 and request.path[0] == '') or @allow_partial
+          catch(:pass) do
+            request = request.clone
+            request.continue = proc { |state| destination(request) if state }
+            params = @param_names.nil? ? {} : Hash[@param_names.zip(request.params)]
+            @blk.call(request, params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/http_router/node/free_regex.rb

@@ -3,7 +3,8 @@ class HttpRouter
     class FreeRegex < Node
       attr_reader :matcher
       def initialize(router, matcher)
-        @router, @matcher = router, matcher
+        @matcher = matcher
+        super(router)
       end
 
       def [](request)
@@ -11,6 +12,7 @@ class HttpRouter
         if match = @matcher.match(whole_path) and match[0].size == whole_path.size
           request = request.clone
           request.extra_env['router.regex_match'] = match
+          request.path = ['']
           match.names.size.times{|i| request.params << match[i + 1]} if match.respond_to?(:names) && match.names
           super
         end

data/lib/http_router/node/lookup.rb

@@ -0,0 +1,21 @@
+class HttpRouter
+  class Node
+    class Lookup < Node
+      def initialize(router)
+        @map = {}
+        super(router)
+      end
+
+      def [](request)
+        if @map[request.path.first]
+          request = request.clone
+          @map[request.path.shift].each{|m| m[request]}
+        end
+      end
+
+      def add(part)
+        Node.new(@router, @map[part] ||= [])
+      end
+    end
+  end
+end

data/lib/http_router/node/regex.rb

@@ -4,8 +4,9 @@ class HttpRouter
       alias_method :node_lookup, :[]
       attr_reader :matcher, :splitting_indicies
 
-      def initialize(router, matcher, capturing_indicies, priority = 0, splitting_indicies = nil)
-        @router, @matcher, @capturing_indicies, @priority, @splitting_indicies = router, matcher, capturing_indicies, priority, splitting_indicies
+      def initialize(router, matcher, capturing_indicies, splitting_indicies = nil)
+        @matcher, @capturing_indicies, @splitting_indicies = matcher, capturing_indicies, splitting_indicies
+        super(router)
       end
 
       def [](request)

data/lib/http_router/node/request.rb

@@ -3,57 +3,21 @@ class HttpRouter
     class Request < Node
       attr_reader :request_method
 
-      def initialize(router)
-        @router, @linear, @catchall, @lookup = router, [], nil, {}
-      end
-
-      def transform_to(meth)
-        new_node = Request.new(router)
-        new_node.request_method = @request_method
-        new_node.instance_var_set(:@linear, @linear.dup)
-        new_node.instance_var_set(:@catchall, @catchall)
-        new_node.instance_var_set(:@lookup, @lookup.dup)
-        @linear.clear
-        @lookup.clear
-        @catchall = new_node
-        @request_method = meth
-        new_node
-      end
-
-      def request_method=(meth)
-        @request_method = meth == :method ? :request_method : meth
-        if @destination
-          next_node = add_catchall
-          next_node.instance_variable_set(:@destination, @destination)
-          @destination = nil
-        end
-        @request_method
-      end
-
-      def add_lookup(val)
-        @router.known_methods << val if @request_method == :request_method
-        @lookup[val] ||= Request.new(@router)
-      end
-
-      def add_catchall
-        @catchall ||= Request.new(@router)
-      end
-
-      def add_linear(matcher)
-        next_node = Request.new(@router)
-        @linear << [matcher, next_node]
-        next_node
+      def initialize(router, opts)
+        @opts = opts
+        Array(@opts[:request_method]).each { |m| router.known_methods << m } if @opts.key?(:request_method)
+        super(router)
       end
 
       def [](request)
-        if @request_method
-          val = request.rack_request.send(@request_method.to_sym)
-          @linear.each { |(matcher, node)| node[request] if matcher === val }
-          @lookup[val][request] if @lookup.key?(val)
-          @catchall[request] if @catchall
-        else
-          super(request)
-        end
+        @opts.each{|k,v|
+          test = request.rack_request.send(k)
+          return unless case v
+          when Array then v.any?{|vv| vv === test}
+          else            v === test
+          end
+        }
+        super(request)
       end
     end
   end

data/lib/http_router/node/variable.rb

@@ -2,9 +2,11 @@ class HttpRouter
   class Node
     class Variable < Node
       def [](request)
-        request = request.clone
-        request.params << unescape(request.path.shift)
-        super(request)
+        unless request.path.empty?
+          request = request.clone
+          request.params << unescape(request.path.shift)
+          super(request)
+        end
       end
     end
   end

data/lib/http_router/node.rb

@@ -8,145 +8,69 @@ class HttpRouter
     autoload :FreeRegex,     'http_router/node/free_regex'
     autoload :Arbitrary,     'http_router/node/arbitrary'
     autoload :Request,       'http_router/node/request'
+    autoload :Lookup,        'http_router/node/lookup'
+    autoload :Destination,   'http_router/node/destination'
 
     attr_reader :priority, :router
 
-    def initialize(router)
-      @router = router
+    def initialize(router, matchers = [])
+      @router, @matchers = router, matchers
     end
 
     def [](request)
-      destination(request, false)
-      unless request.path.empty?
-        linear(request)
-        lookup(request)
-        variable(request)
-        glob(request)
-      end
-      destination(request)
-    end
-
-    def linear(request)
-      @linear && @linear.each{|n| n[request]}
-    end
-
-    def lookup(request)
-      if @lookup && @lookup[request.path.first]
-        request = request.clone
-        @lookup[request.path.shift][request]
-      end
-    end
-
-    def variable(request)
-      @variable && @variable[request]
-    end
-
-    def glob(request)
-      @glob && @glob[request]
-    end
-
-    def request(request)
-      @request && @request[request]
-    end
-
-    def arbitrary(request)
-      @arbitrary && @arbitrary.each{|n| n[request]}
-    end
-
-    def unescape(val)
-      val.to_s.gsub(/((?:%[0-9a-fA-F]{2})+)/n){ [$1.delete('%')].pack('H*') }
-    end
-
-    def destination(request_obj, match_partially = true)
-      request(request_obj)
-      arbitrary(request_obj)
-      @destination.call(request_obj, match_partially) if @destination
+      @matchers.each {|m| m[request] }
+      nil
     end
 
     def add_variable
-      @variable ||= Variable.new(@router)
+      add(Variable.new(@router))
     end
 
     def add_glob
-      @glob ||= Glob.new(@router)
+      add(Glob.new(@router))
     end
 
     def add_request(opts)
-      @request ||= Request.new(@router)
-      next_requests = [@request]
-      @router.request_methods.each_with_index do |method, method_index|
-        next_requests.map! do |next_request|
-          if opts[method].nil? && next_request.request_method.nil?
-            next_request
-          else
-            next_request_index = next_request.request_method && @router.request_methods.index(next_request.request_method)
-            rank = next_request_index ? method_index <=> next_request_index : 0
-            case rank
-            when 0
-              next_request.request_method = method
-              (opts[method].nil? ? [nil] : Array(opts[method])).map do |request_matcher|
-                case request_matcher
-                when nil    then next_request.add_catchall
-                when String then next_request.add_lookup(request_matcher)
-                when Regexp then next_request.add_linear(request_matcher)
-                end
-              end
-            when -1 then next_request
-            when  1 then next_request.transform_to(method)
-            end
-          end
-        end
-        next_requests.flatten!
-      end
-      next_requests
+      add(Request.new(@router, opts))
     end
 
     def add_arbitrary(blk, allow_partial, param_names)
-      @arbitrary ||= []
-      @arbitrary << Arbitrary.new(@router, allow_partial, blk, param_names)
-      @arbitrary.last
+      add(Arbitrary.new(@router, allow_partial, blk, param_names))
     end
 
-    def add_match(regexp, matching_indicies = [0], priority = 0, splitting_indicies = nil)
-      add_prioritized_match(Regex.new(@router, regexp, matching_indicies, priority, splitting_indicies))
+    def add_match(regexp, matching_indicies = [0], splitting_indicies = nil)
+      add(Regex.new(@router, regexp, matching_indicies, splitting_indicies))
     end
 
-    def add_spanning_match(regexp, matching_indicies = [0], priority = 0, splitting_indicies = nil)
-      add_prioritized_match(SpanningRegex.new(@router, regexp, matching_indicies, priority, splitting_indicies))
+    def add_spanning_match(regexp, matching_indicies = [0], splitting_indicies = nil)
+      add(SpanningRegex.new(@router, regexp, matching_indicies, splitting_indicies))
     end
 
     def add_free_match(regexp)
-      @linear ||= []
-      @linear << FreeRegex.new(@router, regexp)
-      @linear.last
+      add(FreeRegex.new(@router, regexp))
     end
 
-    def add_destination(&dest)
-      @destination = dest
+    def add_destination(blk, partial)
+      add(Destination.new(@router, blk, partial))
     end
 
     def add_lookup(part)
-      @lookup ||= {}
-      @lookup[part] ||= Node.new(@router)
+      add(Lookup.new(@router)) unless @matchers.last.is_a?(Lookup)
+      @matchers.last.add(part)
     end
 
-    def join_whole_path(request)
-      request.path * '/'
+    private
+    def add(matcher)
+      @matchers << matcher
+      @matchers.last
     end
 
-    private
-    def add_prioritized_match(match)
-      @linear ||= []
-      if match.priority != 0
-        @linear.each_with_index { |n, i|
-          if match.priority > (n.priority || 0)
-            @linear[i, 0] = match
-            return @linear[i]
-          end
-        }
-      end
-      @linear << match
-      @linear.last
+    def unescape(val)
+      val.to_s.gsub(/((?:%[0-9a-fA-F]{2})+)/n){ [$1.delete('%')].pack('H*') }
+    end
+
+    def join_whole_path(request)
+      request.path * '/'
     end
   end
 end

data/lib/http_router/optional_compiler.rb

@@ -15,7 +15,7 @@ class HttpRouter
           add_to_current_set(@chars.shift)
         end
       end
-      @paths
+      @paths.reverse!
     end
 
     private

data/lib/http_router/route.rb

@@ -167,7 +167,7 @@ class HttpRouter
             path.param_names.size == var_count
           }
         else
-          @paths.reverse_each do |path|
+          @paths.each do |path|
             if params && !params.empty?
               return path if (path.param_names & params.keys).size == path.param_names.size
             elsif path.param_names.empty?
@@ -216,7 +216,6 @@ class HttpRouter
             capturing_indicies = []
             splitting_indicies = []
             captures = 0
-            priority = 0
             spans = false
             regex = parts.inject('') do |reg, part|
               reg << case part[0]
@@ -238,12 +237,11 @@ class HttpRouter
                 matches_with[name] = @opts[name]
                 "(#{(@opts[name] || '.*?')})"
               else
-                priority += part.size
                 Regexp.quote(URI.encode(part))
               end
             end
-            node = spans ? node.add_spanning_match(Regexp.new("#{regex}$"), capturing_indicies, priority, splitting_indicies) :
-              node.add_match(Regexp.new("#{regex}$"), capturing_indicies, priority, splitting_indicies)
+            node = spans ? node.add_spanning_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies) :
+              node.add_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies)
           end
         end
         add_non_path_to_tree(node, path, param_names)
@@ -274,9 +272,9 @@ class HttpRouter
           end
         end
       }
-      nodes = @conditions && !@conditions.empty? ? node.add_request(@conditions) : [node]
-      @arbitrary.each{|a| nodes.map!{|n| n.add_arbitrary(a, match_partially?, names)} } if @arbitrary
-      nodes.map!{|n| n.add_destination(&destination)}
+      node = node.add_request(@conditions) if @conditions && !@conditions.empty?
+      @arbitrary.each{|a| node = node.add_arbitrary(a, match_partially?, names)} if @arbitrary
+      node.add_destination(destination, @match_partially)
       if dest.respond_to?(:url_mount=)
         urlmount = UrlMount.new(@original_path, @default_values)
         urlmount.url_mount = router.url_mount if router.url_mount

data/lib/http_router/version.rb

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

data/test/test_arbitrary.rb

@@ -9,11 +9,11 @@ class TestArbitrary < MiniTest::Unit::TestCase
   end
 
   def test_less_specific_node
-    general, hello, love80, love8080 = router {
-      add("/test")
+    hello, love80, love8080, general = router {
       add("/test").arbitrary(Proc.new{|req, params| req.rack.host == 'hellodooly' })
       add("/test").arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 80}
       add("/test").arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 8080}
+      add("/test")
     }
     assert_route general,  'http://lovelove:8081/test'
     assert_route hello,    'http://hellodooly:8081/test'

data/test/test_interstitial.rb

@@ -20,13 +20,13 @@ class TestInterstitial < MiniTest::Unit::TestCase
   end
 
   def test_multi
-    r1, r2, r3, r4, r5, r6 = router {
-      add('/:var1')
-      add('/:var1-:var2')
-      add('/:var1-:var2-:var3')
-      add('/:var1-:var2-:var3-:var4')
-      add('/:var1-:var2-:var3-:var4-:var5')
+    r6, r5, r4, r3, r2, r1 = router {
       add('/:var1-:var2-:var3-:var4-:var5-:var6')
+      add('/:var1-:var2-:var3-:var4-:var5')
+      add('/:var1-:var2-:var3-:var4')
+      add('/:var1-:var2-:var3')
+      add('/:var1-:var2')
+      add('/:var1')
     }
     assert_route r1, '/one',                           {:var1 => 'one'}
     assert_route r2, '/one-value',                     {:var1 => 'one', :var2 => 'value'}

data/test/test_recognize.rb

@@ -12,6 +12,14 @@ class TestRecognition < MiniTest::Unit::TestCase
     assert_route router.add('/.html'),        '/.html'
   end
 
+  def test_passing
+    passed, working = router {
+      add('/').to { |env| throw :pass; [200, {}, ['pass']] }
+      add('/').to { |env| [200, {}, ['working']] }
+    }
+    assert_body 'working', router.call(Rack::MockRequest.env_for('/'))
+  end
+
   def test_optional
     route = router {
       add 'one(/two(/three(/four)(/five)))'

data/test/test_request.rb

@@ -47,20 +47,20 @@ class TestRequest < MiniTest::Unit::TestCase
   end
 
   def test_move_node
-    general, post = router {
-      add("/test").default_destination
+    post, general = router {
       post("/test").default_destination
+      add("/test").default_destination
     }
     assert_route post,    Rack::MockRequest.env_for('/test', :method => 'POST')
     assert_route general, Rack::MockRequest.env_for('/test', :method => 'PUT')
   end
 
   def test_complex_routing
-    host2, post, host2_get, host2_post = router {
+    host2_post, host2_get, host2, post = router {
+      add("/test").post.host('host2')
+      add("/test").host('host2').get
       add("/test").host('host2')
       add("/test").post
-      add("/test").host('host2').get
-      add("/test").post.host('host2')
     }
     assert_route host2,      Rack::MockRequest.env_for('http://host2/test', :method => 'PUT')
     assert_route post,       Rack::MockRequest.env_for('http://host1/test', :method => 'POST')

data/test/test_variable.rb

@@ -5,7 +5,7 @@ class TestVariable < MiniTest::Unit::TestCase
   end
 
   def test_variable_vs_static
-    dynamic, static = router { add ':one'; add 'one' }
+    static, dynamic = router { add 'one'; add ':one' }
     assert_route dynamic, '/two', {:one => 'two'}
     assert_route static,  '/one'
   end
@@ -107,10 +107,10 @@ class TestVariable < MiniTest::Unit::TestCase
   end
 
   def test_regex_and_greedy
-    with_regex, without_regex, with_post = router {
+    with_regex, with_post, without_regex = router {
       add("/:common_variable/:matched").matching(:matched => /\d+/)
-      add("/:common_variable/:unmatched")
       post("/:common_variable/:unmatched")
+      add("/:common_variable/:unmatched")
     }
     assert_route with_regex,    '/common/123',   {:common_variable => 'common', :matched => '123'}
     assert_route without_regex, '/common/other', {:common_variable => 'common', :unmatched => 'other'}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
+  hash: 3
+  prerelease: 
   segments: 
   - 0
-  - 6
-  - 9
-  version: 0.6.9
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 -07:00
+date: 2011-04-18 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -161,13 +161,13 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.rdoc
+- README.md
 files: 
 - .gitignore
 - .rspec
 - CHANGELOG
 - Gemfile
-- README.rdoc
+- README.md
 - Rakefile
 - benchmarks/gen2.rb
 - benchmarks/generation_bm.rb
@@ -189,9 +189,11 @@ files:
 - lib/http_router.rb
 - lib/http_router/node.rb
 - lib/http_router/node/arbitrary.rb
+- lib/http_router/node/destination.rb
 - lib/http_router/node/free_regex.rb
 - lib/http_router/node/glob.rb
 - lib/http_router/node/glob_regex.rb
+- lib/http_router/node/lookup.rb
 - lib/http_router/node/regex.rb
 - lib/http_router/node/request.rb
 - lib/http_router/node/spanning_regex.rb
@@ -250,7 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: http_router
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A kick-ass HTTP router for use in Rack