http_router 0.7.10 → 0.8.0

data/README.md

@@ -6,6 +6,7 @@ This is an HTTP router for use in either a web framework, or on it's own using R
 
 ## Features
 
+* Ordered route resolution.
 * Supports variables, and globbing, both named and unnamed.
 * Regex support for variables.
 * Request condition support.

data/benchmarks/rec2.rb

@@ -15,6 +15,8 @@ u.add('/dynamic/:variable').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'}, []]}
 
+u.compile rescue nil
+
 puts Benchmark.measure {
   ('aa'..'nn').each do |first|
     ('a'..'n').each do |second|
@@ -34,7 +36,7 @@ TIMES = 50_000
 #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')
-#5.times {
+5.times {
   RBench.run(TIMES) do
 
     report "2 levels, static" do
@@ -62,5 +64,5 @@ TIMES = 50_000
     #end
 
   end
-#}
+}
 puts `ps -o rss= -p #{Process.pid}`.to_i

data/lib/http_router.rb

@@ -1,5 +1,8 @@
 require 'set'
 require 'rack'
+require 'uri'
+require 'cgi'
+require 'url_mount'
 require 'http_router/node'
 require 'http_router/request'
 require 'http_router/response'
@@ -11,7 +14,7 @@ require 'http_router/optional_compiler'
 
 class HttpRouter
 
-  attr_reader :root, :routes, :known_methods, :named_routes
+  attr_reader :root, :routes, :known_methods, :named_routes, :nodes
   attr_accessor :default_app, :url_mount
 
   # Raised when a Route is not able to be generated.
@@ -36,6 +39,7 @@ class HttpRouter
     @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
     @known_methods           = Set.new(options && options[:known_methods] || [])
+    @nodes                   = []
     reset!
     instance_eval(&blk) if blk
   end
@@ -143,6 +147,15 @@ class HttpRouter
     @default_app = app
   end
 
+  def register_node(n)
+    @nodes << n
+    @nodes.size - 1
+  end
+
+  def [](pos)
+    @nodes.at(pos)
+  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.
   # This first value must be either the Route object or the name of the route.
   #
@@ -191,6 +204,10 @@ class HttpRouter
     cloned_router
   end
 
+  def compile
+    @root.compile
+  end
+
   private
   def no_response(env, perform_call = true)
     supported_methods = (@known_methods - [env['REQUEST_METHOD']]).select do |m|

data/lib/http_router/node.rb

@@ -11,16 +11,12 @@ class HttpRouter
     autoload :Lookup,        'http_router/node/lookup'
     autoload :Destination,   'http_router/node/destination'
 
-    attr_reader :priority, :router
+    attr_reader :priority, :router, :node_position
 
     def initialize(router, matchers = [])
       @router, @matchers = router, matchers
     end
 
-    def [](request)
-      @matchers.each {|m| m[request] }; nil
-    end
-
     def add_variable
       add(Variable.new(@router))
     end
@@ -61,15 +57,37 @@ class HttpRouter
       false
     end
 
+    def method_missing(m, *args, &blk)
+      if m.to_s == '[]'
+        compile
+        send(:[], *args)
+      else
+        super
+      end
+    end
+
+    def compile
+      instance_eval "def [](r0)\n#{to_code(0)}\nnil\nend", __FILE__, __LINE__
+    end
+
     private
     def add(matcher)
       @matchers << matcher unless matcher.usable?(@matchers.last)
       @matchers.last
     end
 
-    def unescape(val)
-      val.to_s.gsub!(/((?:%[0-9a-fA-F]{2})+)/n){ [$1.delete('%')].pack('H*') }
-      val
+    def to_code(pos)
+      @matchers.map{ |m| m.to_code(pos) }.join("\n") << "\n"
+    end
+
+    def indented_code(pos, code)
+      lines = code.
+        strip.
+        split(/\n/).
+        select{|l| !l.strip.size.zero?}
+      indent_size = lines.first[/ */].size
+      lines.map! {|l| "#{'  ' * pos.next}#{l[indent_size, l.size]}"}
+      "\n" << lines.join("\n") << "\n"
     end
   end
 end

data/lib/http_router/node/arbitrary.rb

@@ -1,26 +1,30 @@
 class HttpRouter
   class Node
     class Arbitrary < Node
-      alias_method :node_lookup, :[]
       attr_reader :allow_partial, :blk, :param_names
 
       def initialize(router, allow_partial, blk, param_names)
         @allow_partial, @blk, @param_names = allow_partial, blk, param_names
+        @node_position = router.register_node(blk)
         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| node_lookup(request) if state }
-          params = @param_names.nil? ? {} : Hash[@param_names.zip(request.params)]
-          @blk.call(request, params)
-        end
-      end
-
       def usuable?(other)
         other.class == self.class && other.allow_partial == allow_partial && other.blk == blk && other.param_names == param_names
       end
+
+      def to_code(pos)
+        indented_code pos, "
+        #{"if r#{pos}.path_finished?" unless @allow_partial}
+          r#{pos.next} = r#{pos}.dup
+          r#{pos.next}.continue = proc { |state|
+            if state
+              #{super(pos.next)}
+            end
+          }
+          router.nodes.at(#{node_position})[r#{pos.next}, #{@param_names.nil? || @param_names.empty? ? '{}' : "Hash[#{@param_names.inspect}.zip(r#{pos.next}.params)]"}]
+        #{"end" unless @allow_partial}"
+      end
     end
   end
 end

data/lib/http_router/node/destination.rb

@@ -1,25 +1,26 @@
 class HttpRouter
   class Node
     class Destination < Node
+      attr_reader :blk, :allow_partial, :param_names
+      
       def initialize(router, blk, allow_partial)
         @blk, @allow_partial = blk, allow_partial
+        @node_position = router.register_node(blk)
         super(router)
       end
 
-      def [](request)
-        if request.path.empty? or (request.path.size == 1 and request.path[0] == '') or @allow_partial
-          request.passed_with = 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
-
       def usuable?(other)
         other.class == self.class && other.allow_partial == allow_partial && other.blk == blk
       end
+
+      def to_code(pos)
+        indented_code pos, "
+        #{"if r#{pos}.path_finished?" unless @allow_partial}
+          r0.passed_with = catch(:pass) do
+            router.nodes.at(#{node_position})[r#{pos}, #{@param_names.nil? || @param_names.empty? ? 'nil' : "Hash[#{@param_names.inspect}.zip(r#{pos.next}.params)]"}]
+          end
+        #{"end" unless @allow_partial}"
+      end
     end
   end
 end

data/lib/http_router/node/free_regex.rb

@@ -7,15 +7,17 @@ class HttpRouter
         super(router)
       end
 
-      def [](request)
-        whole_path = "/#{request.joined_path}"
-        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
+      def to_code(pos)
+        indented_code pos, "
+        whole_path = \"/\#{r#{pos}.joined_path}\"
+        if match = #{matcher.inspect}.match(whole_path) and match[0].size == whole_path.size
+          r#{pos.next} = r#{pos}.dup
+          r#{pos.next}.extra_env['router.regex_match'] = match
+          r#{pos.next}.path = ['']
+          " << (//.respond_to?(:names) ?
+          "match.names.size.times{|i| r#{pos.next}.params << match[i + 1]} if match.respond_to?(:names) && match.names" : "") << "
+          #{super(pos.next)}
+        end"
       end
 
       def usuable?(other)

data/lib/http_router/node/glob.rb

@@ -1,20 +1,21 @@
 class HttpRouter
   class Node
     class Glob < Node
-      def [](request)
-        request = request.clone
-        request.params << []
-        remaining_parts = request.path.dup
-        until remaining_parts.empty?
-          request.params[-1] << unescape(remaining_parts.shift)
-          request.path = remaining_parts
-          super(request)
-        end
-      end
-
       def usuable?(other)
         other.class == self.class
       end
+
+      def to_code(pos)
+        indented_code pos, "
+          r#{pos.next} = r#{pos}.dup
+          r#{pos.next}.params << []
+          remaining_parts = r#{pos.next}.path.dup
+          until remaining_parts.empty?
+            r#{pos.next}.params[-1] << URI.unescape(remaining_parts.shift)
+            r#{pos.next}.path = remaining_parts
+            #{super(pos.next)}
+          end"
+      end
     end
   end
 end

data/lib/http_router/node/glob_regex.rb

@@ -1,8 +1,17 @@
 class HttpRouter
   class Node
     class GlobRegex < SpanningRegex
-      def add_params(request)
-        @capturing_indicies.each { |idx| request.params << unescape(match[idx].split('/')) }
+      def to_code(pos)
+        indented_code pos, "
+          whole_path = r#{pos}.joined_path
+          if match = #{@matcher.inspect}.match(whole_path) and match.begin(0).zero?
+            r#{pos.next} = r#{pos}.dup\n" << 
+          @capturing_indicies.map { |c| "r#{pos.next}.params << URI.unescape(match[#{c}].split(/\\//))\n" }.join << "
+          remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
+          r#{pos.next}.path = remaining_path.split('/')
+          #{super(pos.next)}
+        end
+          "
       end
     end
   end

data/lib/http_router/node/lookup.rb

@@ -6,13 +6,6 @@ class HttpRouter
         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
@@ -20,6 +13,18 @@ class HttpRouter
       def usuable?(other)
         other.class == self.class
       end
+
+      def to_code(pos)
+        code = "case r#{pos}.path.first\n"
+        @map.keys.each do |k|
+          code << "when #{k.inspect}\n
+  r#{pos.next} = r#{pos}.dup
+  r#{pos.next}.path.shift
+  #{@map[k].map{|n| n.to_code(pos.next)} * "\n"}"
+        end
+        code << "\nend"
+        indented_code pos, code
+      end
     end
   end
 end

data/lib/http_router/node/regex.rb

@@ -1,7 +1,7 @@
 class HttpRouter
   class Node
     class Regex < Node
-      alias_method :node_lookup, :[]
+      alias_method :node_to_code, :to_code
       attr_reader :matcher, :splitting_indicies, :capturing_indicies
 
       def initialize(router, matcher, capturing_indicies, splitting_indicies = nil)
@@ -9,23 +9,20 @@ class HttpRouter
         super(router)
       end
 
-      def [](request)
-        if match = @matcher.match(request.path.first) and match.begin(0).zero?
-          request = request.clone
-          request.path.shift
-          add_params(request, match)
-          super(request)
-        end
-      end
-
-      def add_params(request, match)
-        @splitting_indicies.each { |idx| request.params << unescape(match[idx]).split(/\//) } if @splitting_indicies
-        @capturing_indicies.each { |idx| request.params << unescape(match[idx]) }
-      end
-
       def usuable?(other)
         other.class == self.class && other.matcher == matcher && other.splitting_indicies == splitting_indicies && other.capturing_indicies == capturing_indicies
       end
+
+      def to_code(pos)
+          indented_code pos, "
+          if match = #{@matcher.inspect}.match(r#{pos}.path.first) and match.begin(0).zero?
+            r#{pos.next} = r#{pos}.dup
+            r#{pos.next}.path.shift\n" <<
+            @splitting_indicies.map { |s| "r#{pos.next}.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
+            @capturing_indicies.map { |c| "r#{pos.next}.params << URI.unescape(match[#{c}])\n" }.join << "
+            #{super(pos.next)}
+          end"
+      end
     end
   end
 end

data/lib/http_router/node/request.rb

@@ -9,20 +9,21 @@ class HttpRouter
         super(router)
       end
 
-      def [](request)
-        @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
-
       def usuable?(other)
         other.class == self.class && other.opts == opts
       end
+
+      def to_code(pos)
+        code = "if "
+        code << @opts.map do |k,v|
+          case v
+          when Array then "(#{v.map{|vv| "#{vv.inspect} === r#{pos}.rack_request.#{k}"}.join(' or ')})"
+          else            "#{v.inspect} === r#{pos}.rack_request.#{k.inspect}"
+          end           
+        end * ' and '
+        code << "\n  #{super}\nend"
+        indented_code pos, code
+      end
     end
   end
 end

data/lib/http_router/node/spanning_regex.rb

@@ -1,15 +1,18 @@
 class HttpRouter
   class Node
     class SpanningRegex < Regex
-      def [](request)
-        whole_path = request.joined_path
-        if match = @matcher.match(whole_path) and match.begin(0).zero?
-          request = request.clone
-          add_params(request, match)
-          remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
-          request.path = remaining_path.split('/')
-          node_lookup(request)
-        end
+      def to_code(pos)
+        indented_code(pos, "
+          whole_path = r#{pos}.joined_path
+          if match = #{@matcher.inspect}.match(whole_path) and match.begin(0).zero?
+            r#{pos.next} = r#{pos}.dup\n" <<
+            (@splitting_indicies || []).map { |s| "r#{pos.next}.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
+            @capturing_indicies.map { |c| "r#{pos.next}.params << URI.unescape(match[#{c}])\n" }.join << "
+            remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
+            r#{pos.next}.path = remaining_path.split('/')
+            #{node_to_code(pos.next)}
+          end
+        ")
       end
     end
   end

data/lib/http_router/node/variable.rb

@@ -1,17 +1,18 @@
 class HttpRouter
   class Node
     class Variable < Node
-      def [](request)
-        unless request.path.empty?
-          request = request.clone
-          request.params << unescape(request.path.shift)
-          super(request)
-        end
-      end
-
       def usuable?(other)
         other.class == self.class
       end
+
+      def to_code(pos)
+        indented_code(pos, "
+          unless r#{pos}.path_finished?
+            r#{pos.next} = r#{pos}.dup
+            r#{pos.next}.params << URI.unescape(r#{pos.next}.path.shift)
+            #{super(pos.next)}
+          end")
+      end
     end
   end
 end

data/lib/http_router/request.rb

@@ -27,12 +27,16 @@ class HttpRouter
       "request path, #{path.inspect}"
     end
 
-    def clone
+    def dup
       dup_obj = super
       dup_obj.path = path.dup
       dup_obj.params = params.dup
       dup_obj.extra_env = extra_env.dup
       dup_obj
     end
+
+    def path_finished?
+      @path.size == 0 or @path.size == 1 && @path.first == ''
+    end
   end
 end

data/lib/http_router/route.rb

@@ -1,5 +1,3 @@
-require 'url_mount'
-require 'uri'
 
 class HttpRouter
   class Route
@@ -300,7 +298,7 @@ class HttpRouter
       when Hash
         value.each{ |k, v| append_querystring_value(uri, "#{key}[#{k}]", v) }
       else
-        uri << '&' << ::Rack::Utils.escape(key.to_s) << '=' << ::Rack::Utils.escape(value.to_s)
+        uri << '&' << CGI.escape(key.to_s) << '=' << CGI.escape(value.to_s)
       end
     end
 

data/lib/http_router/version.rb

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

data/test/test_recognize.rb

@@ -4,12 +4,27 @@ class TestRecognition < MiniTest::Unit::TestCase
     assert_route router.add(''),              '/'
   end
 
-  def test_simple
+  def test_simple1
     assert_route router.add('/'),             '/'
+  end
+
+  def test_simple2
     assert_route router.add('/test'),         '/test'
+  end
+
+  def test_simple3
     assert_route router.add('/test/one'),     '/test/one'
+  end
+
+  def test_simple4
     assert_route router.add('/test/one/two'), '/test/one/two'
+  end
+
+  def test_simple5
     assert_route router.add('/test.html'),    '/test.html'
+  end
+
+  def test_simple6
     assert_route router.add('/.html'),        '/.html'
   end
 

data/test/test_request.rb

@@ -6,6 +6,12 @@ class TestRequest < MiniTest::Unit::TestCase
     assert_status(405, Rack::MockRequest.env_for('/test', :method => 'GET'))
   end
 
+  def test_simple_case_with_array
+    r = router { add('test', :request => {:request_methods => ['POST', 'GET']}) }
+    assert_route r, Rack::MockRequest.env_for('/test', :method => 'POST')
+    assert_route r, Rack::MockRequest.env_for('/test', :method => 'GET')
+  end
+
   def test_single_app_with_404
     r = router { add('test').post.to{|env| [404, {}, []]} }
     assert_route nil, Rack::MockRequest.env_for('/test', :method => 'POST')

data/test/test_variable.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 class TestVariable < MiniTest::Unit::TestCase
   def test_variable
     assert_route ':one',      '/two',        {:one => 'two'}

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
+  hash: 63
   prerelease: 
-  version: 0.7.10
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -10,108 +15,147 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-30 00:00:00 -07:00
+date: 2011-06-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rack
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
         version: 1.0.0
+  requirement: *id001
+  prerelease: false
   type: :runtime
-  version_requirements: *id001
+  name: rack
 - !ruby/object:Gem::Dependency 
-  name: url_mount
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
         version: 0.2.1
+  requirement: *id002
+  prerelease: false
   type: :runtime
-  version_requirements: *id002
+  name: url_mount
 - !ruby/object:Gem::Dependency 
-  name: minitest
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
         version: 2.0.0
+  requirement: *id003
+  prerelease: false
   type: :development
-  version_requirements: *id003
+  name: minitest
 - !ruby/object:Gem::Dependency 
-  name: code_stats
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
+  requirement: *id004
+  prerelease: false
   type: :development
-  version_requirements: *id004
+  name: code_stats
 - !ruby/object:Gem::Dependency 
-  name: rake
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
         version: 0.8.7
+  requirement: *id005
+  prerelease: false
   type: :development
-  version_requirements: *id005
+  name: rake
 - !ruby/object:Gem::Dependency 
-  name: rbench
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
+  requirement: *id006
+  prerelease: false
   type: :development
-  version_requirements: *id006
+  name: rbench
 - !ruby/object:Gem::Dependency 
-  name: phocus
-  prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
+  requirement: *id007
+  prerelease: false
   type: :development
-  version_requirements: *id007
+  name: phocus
 - !ruby/object:Gem::Dependency 
-  name: bundler
-  prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
         version: 1.0.0
+  requirement: *id008
+  prerelease: false
   type: :development
-  version_requirements: *id008
+  name: bundler
 - !ruby/object:Gem::Dependency 
-  name: thin
-  prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  version_requirements: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 2
+        - 8
         version: 1.2.8
+  requirement: *id009
+  prerelease: false
   type: :development
-  version_requirements: *id009
+  name: thin
 description: This library allows you to recognize and build URLs in a Rack application.
 email: joshbuddy@gmail.com
 executables: []
@@ -195,12 +239,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 requirements: []