http_router 0.8.9 → 0.8.10

data/benchmarks/gen2.rb

@@ -3,14 +3,14 @@ require 'rbench'
 #require 'lib/usher'
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 
-require 'lib/http_router'
+require 'http_router'
 
 u = HttpRouter.new
-u.add('/simple')                                                                                     .name(:simple).send(:compile)
-u.add('/simple/:variable')                                                                           .name(:one_variable).send(:compile)
-u.add('/simple/:var1/:var2/:var3')                                                                   .name(:three_variables).send(:compile)
-u.add('/simple/:v1/:v2/:v3/:v4/:v5/:v6/:v7/:v8')                                                     .name(:eight_variables).send(:compile)
-u.add('/with_condition/:cond1/:cond2').matching(:cond1 => /^\d+$/, :cond2 => /^[a-z]+$/)             .name(:two_conditions).send(:compile)
+u.add('/simple')                                                                                     .name(:simple).to{}
+u.add('/simple/:variable')                                                                           .name(:one_variable).to{}
+u.add('/simple/:var1/:var2/:var3')                                                                   .name(:three_variables).to{}
+u.add('/simple/:v1/:v2/:v3/:v4/:v5/:v6/:v7/:v8')                                                     .name(:eight_variables).to{}
+u.add('/with_condition/:cond1/:cond2').matching(:cond1 => /^\d+$/, :cond2 => /^[a-z]+$/)             .name(:two_conditions).to{}
 
 TIMES = 50_000
 

data/lib/http_router.rb

@@ -196,10 +196,6 @@ class HttpRouter
     cloned_router
   end
 
-  def compile
-    @root.compile
-  end
-
   def next_counter
     @counter += 1
   end

data/lib/http_router/node.rb

@@ -65,18 +65,13 @@ class HttpRouter
 
     private
     def inject_root_methods(code = nil, &blk)
-      if code
-        root.methods_module.module_eval(code)
-      else
-        root.methods_module.module_eval(&blk)
-      end
+      code ? root.methods_module.module_eval(code) : root.methods_module.module_eval(&blk)
     end
 
     def inject_root_ivar(name, val)
       root.instance_variable_set(name, val)
     end
 
-
     def add(matcher)
       @matchers << matcher unless matcher.usable?(@matchers.last)
       @matchers.last

data/lib/http_router/node/lookup.rb

@@ -25,9 +25,7 @@ class HttpRouter
             #{@map[k].map{|n| n.to_code} * "\n"}
             request.path.unshift part
           end"}.join("\n")
-        code = "
-        send(\"#{method_prefix}\#{request.path.first}\", request) if !request.path_finished? && #{lookup_ivar}.key?(request.path.first)
-        "
+        "send(\"#{method_prefix}\#{request.path.first}\", request) if !request.path_finished? && #{lookup_ivar}.key?(request.path.first)"
       end
     end
   end

data/lib/http_router/node/regex.rb

@@ -2,10 +2,14 @@ class HttpRouter
   class Node
     class Regex < Node
       alias_method :node_to_code, :to_code
-      attr_reader :matcher, :splitting_indicies, :capturing_indicies
+      attr_reader :matcher, :splitting_indicies, :capturing_indicies, :ordered_indicies
 
       def initialize(router, parent, matcher, capturing_indicies, splitting_indicies = nil)
         @matcher, @capturing_indicies, @splitting_indicies = matcher, capturing_indicies, splitting_indicies
+        @ordered_indicies = []
+        @ordered_indicies.concat(capturing_indicies.map{|i| [i, :capture]}) if capturing_indicies
+        @ordered_indicies.concat(splitting_indicies.map{|i| [i, :split]}) if splitting_indicies
+        @ordered_indicies.sort!
         super(router, parent)
       end
 
@@ -16,14 +20,21 @@ class HttpRouter
       def to_code
         params_size = @splitting_indicies.size + @capturing_indicies.size
         "if match = #{@matcher.inspect}.match(request.path.first) and match.begin(0).zero?
-          part = request.path.shift\n" <<
-          @splitting_indicies.map { |s| "request.params << match[#{s}].split(/\\//)\n" }.join <<
-          @capturing_indicies.map { |c| "request.params << match[#{c}]\n" }.join << "
-          #{super}
+          part = request.path.shift\n" << param_capturing_code <<
+          "#{super}
           request.path.unshift part
           #{params_size == 1 ? "request.params.pop" : "request.params.slice!(#{-params_size}, #{params_size})"}
         end"
       end
+
+      def param_capturing_code
+        @ordered_indicies.map{|(i, type)|
+          case type
+          when :capture then "request.params << match[#{i}]\n"
+          when :split   then "request.params << match[#{i}].split(/\\//)\n"
+          end
+        }.join("")
+      end
     end
   end
 end

data/lib/http_router/node/request.rb

@@ -16,6 +16,7 @@ class HttpRouter
       def to_code
         code = "if "
         code << @opts.map do |k,v|
+          v = [v] unless v.is_a?(Array)
           case v.size
           when 1 then to_code_condition(k, v.first)
           else        "(#{v.map{|vv| to_code_condition(k, vv)}.join(' or ')})"

data/lib/http_router/node/spanning_regex.rb

@@ -2,13 +2,11 @@ class HttpRouter
   class Node
     class SpanningRegex < Regex
       def to_code
-        params_count = (@splitting_indicies || []).size + @capturing_indicies.size
+        params_count = @ordered_indicies.size
         "whole_path#{depth} = request.joined_path
         if match = #{@matcher.inspect}.match(whole_path#{depth}) and match.begin(0).zero?
           original_path#{depth} = request.path.dup
-          " <<
-          (@splitting_indicies || []).map { |s| "request.params << match[#{s}].split(/\\//)\n" }.join <<
-          @capturing_indicies.map { |c| "request.params << match[#{c}]\n" }.join << "
+          " << param_capturing_code << "
           remaining_path = whole_path#{depth}[match[0].size + (whole_path#{depth}[match[0].size] == ?/ ? 1 : 0), whole_path#{depth}.size]
           request.path = remaining_path.split('/')
           #{node_to_code}

data/lib/http_router/regex_route.rb

@@ -2,13 +2,17 @@ class HttpRouter
   class RegexRoute < Route
     def initialize(router, path, opts = {})
       @router, @original_path, @opts = router, path, opts
+      @param_names = @original_path.respond_to?(:names) ? @original_path.names.map(&:to_sym) : []
       process_opts
     end
 
-    def compile
-      @param_names = @original_path.respond_to?(:names) ? @original_path.names.map(&:to_sym) : []
+    def add_path_to_tree
+      @paths = [@original_path]
       add_non_path_to_tree(@router.root.add_free_match(@original_path), path, @param_names)
-      @compiled = true
+    end
+
+    def significant_variable_names
+      @param_names
     end
 
     def match_partially?

data/lib/http_router/route.rb

@@ -1,13 +1,13 @@
 class HttpRouter
   class Route
-    attr_reader :default_values, :matches_with, :router, :path, :conditions, :original_path
+    DoubleCompileError = Class.new(RuntimeError)
+
+    attr_reader :default_values, :router, :path, :conditions, :original_path, :match_partially, :dest, :regex, :named, :matches_with
+    alias_method :match_partially?, :match_partially
+    alias_method :regex?, :regex
 
     def initialize(router, path, opts = {})
-      @router = router
-      @original_path = path
-      @opts = opts
-      @matches_with = {}
-      @default_values = opts[:default_values] || {}
+      @router, @original_path, @opts = router, path, opts
       if @original_path[-1] == ?*
         @match_partially = true
         path.slice!(-1)
@@ -16,15 +16,24 @@ class HttpRouter
     end
 
     def process_opts
-      @arbitrary = @opts[:arbitrary] || @opts[:__arbitrary__]
-      @conditions = @opts[:conditions] || @opts[:__conditions__] || {}
-      @opts.merge!(@opts[:matching]) if @opts[:matching]
-      @match_partially = @opts[:partial] if @match_partially.nil? && @opts.key?(:partial)
-      name(@opts[:name]) if @opts.key?(:name)
+      @default_values = @opts[:__default_values__] || @opts[:default_values] || {}
+      @arbitrary = @opts[:__arbitrary__] || @opts[:arbitrary]
+      @matches_with = significant_variable_names.include?(:matching) ? @opts : @opts[:__matching__] || @opts[:matching] || {}
+      significant_variable_names.each do |name|
+        @matches_with[name] = @opts[name] if @opts.key?(name) && !@matches_with.key?(name)
+      end
+      @conditions = @opts[:__conditions__] || @opts[:conditions] || {}
+      @match_partially = @opts[:__partial__] if @match_partially.nil? && !@opts[:__partial__].nil?
+      @match_partially = @opts[:partial] if @match_partially.nil? && !@opts[:partial].nil?
+      name(@opts[:__name__] || @opts[:name]) if @opts.key?(:__name__) || @opts.key?(:name)
     end
 
     def as_options
-      {:matching => @matches_with, :conditions => @conditions, :default_values => @default_values, :name => @name, :partial => @partially_match, :arbitrary => @arbitrary}
+      {:__matching__ => @matches_with, :__conditions__ => @conditions, :__default_values__ => @default_values, :__name__ => @named, :__partial__ => @partially_match, :__arbitrary__ => @arbitrary}
+    end
+
+    def compiled?
+      !@paths.nil?
     end
 
     def partial(match_partially = true)
@@ -32,30 +41,14 @@ class HttpRouter
       self
     end
 
-    def match_partially?
-      @match_partially
-    end
-
-    def dest
-      @app
-    end
-
-    def regex?
-      false
-    end
-
     def to(dest = nil, &dest2)
-      @app = dest || dest2
-      compile
+      @dest = dest || dest2
+      add_path_to_tree
       self
     end
 
-    def compiled?
-      @compiled
-    end
-
     def name(n)
-      @name = n
+      @named = n
       @router.named_routes[n] = self
       self
     end
@@ -77,8 +70,7 @@ class HttpRouter
     end
 
     def matching(matchers)
-      matchers = Hash[*matchers] if matchers.is_a?(Array)
-      @opts.merge!(matchers)
+      @matches_with.merge!(matchers.is_a?(Array) ? Hash[*matchers] : matchers)
       self
     end
 
@@ -141,11 +133,7 @@ class HttpRouter
       options = args.last.is_a?(Hash) ? args.pop : nil
       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
+      path = args.empty? ? matching_path(options) : matching_path(args, options)
       raise InvalidRouteException unless path
       result, params = path.url(args, options)
       mount_point = router.url_mount && router.url_mount.url(options)
@@ -157,118 +145,100 @@ class HttpRouter
     end
 
     def matching_path(params, other_hash = nil)
-      if @paths.size == 1
-        @paths.first
-      else
-        if params.is_a?(Array)
-          significant_keys = other_hash && significant_variable_names & other_hash.keys
-          @paths.find { |path|
-            var_count = significant_keys ? params.size + significant_keys.size : params.size
-            path.param_names.size == var_count
-          }
-        else
-          @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?
-              return path
-            end
-          end
-          nil
-        end
+      return @paths.first if @paths.size == 1
+      case params
+      when Array
+        significant_keys = other_hash && significant_variable_names & other_hash.keys
+        @paths.find { |path| path.param_names.size == (significant_keys ? params.size + significant_keys.size : params.size) }
+      when Hash
+        @paths.find { |path| (params && !params.empty? && (path.param_names & params.keys).size == path.param_names.size) || path.param_names.empty? }
       end
     end
 
-    def named
-      @name
-    end
-
     def to_s
       "#<HttpRouter:Route #{object_id} @original_path=#{@original_path.inspect} @conditions=#{@conditions.inspect} @arbitrary=#{@arbitrary.inspect}>"
     end
 
-    def compile
-      return if @compiled
-      start_index, end_index = 0, 1
-      raw_paths, chars = [""], @original_path.split('')
-      until chars.empty?
-      case fc = chars.first[0]
-        when ?(
-          chars.shift
-          (start_index...end_index).each { |path_index| raw_paths << raw_paths[path_index].dup }
-          start_index = end_index
-          end_index = raw_paths.size
-        when ?)
-          chars.shift
-          start_index -= end_index - start_index
-        else
-          c = if chars[0][0] == ?\\ && (chars[1][0] == ?( || chars[1][0] == ?)); chars.shift; chars.shift; else; chars.shift; end
-          (start_index...end_index).each { |path_index| raw_paths[path_index] << c } 
+    private
+    def raw_paths
+      @raw_paths ||= begin
+        start_index, end_index = 0, 1
+        @raw_paths, chars = [""], @original_path.split('')
+        until chars.empty?
+        case fc = chars.first[0]
+          when ?(
+            chars.shift
+            (start_index...end_index).each { |path_index| raw_paths << raw_paths[path_index].dup }
+            start_index = end_index
+            end_index = raw_paths.size
+          when ?)
+            chars.shift
+            start_index -= end_index - start_index
+          else
+            c = if chars[0][0] == ?\\ && (chars[1][0] == ?( || chars[1][0] == ?)); chars.shift; chars.shift; else; chars.shift; end
+            (start_index...end_index).each { |path_index| raw_paths[path_index] << c } 
+          end
         end
+        @raw_paths.reverse!
+      end
+    end
+
+    def add_normal_part(node, part, param_names)
+      name = part[1, part.size]
+      node = case part[0]
+      when ?\\
+        node.add_lookup(part[1].chr)
+      when ?:
+        param_names << name.to_sym
+        @matches_with[name.to_sym] ? node.add_spanning_match(@matches_with[name.to_sym]) : node.add_variable
+      when ?*
+        param_names << name.to_sym
+        @matches_with[name.to_sym] ? node.add_glob_regexp(@matches_with[name.to_sym]) : node.add_glob
+      else
+        node.add_lookup(part)
       end
-      raw_paths.reverse!
-      @paths = raw_paths.map do |path|
-        param_names = []
-        node = @router.root
-        path.split(/\//).each do |part|
-          next if part == ''
-          parts = part.scan(/\\.|[:*][a-z0-9_]+|[^:*\\]+/)
-          if parts.size == 1
-            name = part[1, part.size]
-            node = case parts[0][0]
-            when ?\\
-              node.add_lookup(parts[0][1].chr)
-            when ?:
-              param_names << name.to_sym
-              matches_with[name.to_sym] = @opts[name.to_sym]
-              @opts[name.to_sym] ? node.add_spanning_match(@opts.delete(name.to_sym)) : node.add_variable
-            when ?*
-              param_names << name.to_sym
-              matches_with[name.to_sym] = @opts[name.to_sym]
-              @opts[name.to_sym] ? node.add_glob_regexp(@opts.delete(name.to_sym)) : node.add_glob
-            else
-              node.add_lookup(parts[0])
-            end
+    end
+
+    def add_complex_part(node, parts, param_names)
+      capturing_indicies, splitting_indicies, captures, spans = [], [], 0, false
+      regex = parts.inject('') do |reg, part|
+        reg << case part[0]
+        when ?\\ then Regexp.quote(part[1].chr)
+        when ?:, ?*
+          spans = true if part[0] == ?*
+          captures += 1
+          (part[0] == ?* ? splitting_indicies : capturing_indicies) << captures
+          name = part[1, part.size].to_sym
+          param_names << name
+          if spans
+            @matches_with[name] ? "((?:#{@matches_with[name]}\\/?)+)" : '(.*?)'
           else
-            capturing_indicies = []
-            splitting_indicies = []
-            captures = 0
-            spans = false
-            regex = parts.inject('') do |reg, part|
-              reg << case part[0]
-              when ?\\
-                Regexp.quote(part[1].chr)
-              when ?:
-                captures += 1
-                capturing_indicies << captures
-                name = part[1, part.size].to_sym
-                param_names << name
-                matches_with[name] = @opts[name]
-                "(#{(@opts[name] || '[^/]*?')})"
-              when ?*
-                spans = true
-                captures += 1
-                splitting_indicies << captures
-                name = part[1, part.size].to_sym
-                param_names << name
-                matches_with[name] = @opts[name]
-                @opts[name] ?
-                  "((?:#{@opts[name]}\\/?)+)" : '(.*?)'
-              else
-                Regexp.quote(part)
-              end
-            end
-            node = spans ? node.add_spanning_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies) :
-              node.add_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies)
+            "(#{(@matches_with[name] || '[^/]*?')})"
           end
+        else
+          Regexp.quote(part)
+        end
+      end
+      spans ? node.add_spanning_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies) :
+        node.add_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies)
+    end
+
+    def add_path_to_tree
+      raise DoubleCompileError if compiled?
+      @paths ||= begin
+        raw_paths.map do |path|
+          param_names = []
+          node = @router.root
+          path.split(/\//).each do |part|
+            next if part == ''
+            parts = part.scan(/\\.|[:*][a-z0-9_]+|[^:*\\]+/)
+            node = parts.size == 1 ? add_normal_part(node, part, param_names) : add_complex_part(node, parts, param_names)
+          end
+          add_non_path_to_tree(node, path, param_names)
         end
-        add_non_path_to_tree(node, path, param_names)
       end
-      @compiled = true
-      self
     end
 
-    private
     def add_non_path_to_tree(node, path, names)
       path_obj = Path.new(self, path, names)
       node = node.add_request(@conditions) unless @conditions.empty?

data/lib/http_router/version.rb

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

data/test/test_recognize.rb

@@ -53,6 +53,7 @@ class TestRecognition < MiniTest::Unit::TestCase
     assert_route route, '/one/two/three'
     assert_route route, '/one/two/three/four'
     assert_route route, '/one/two/three/five'
+    assert_route route, '/one/two/three/four/five'
   end
 
   def test_escape_paren

data/test/test_request.rb

@@ -7,11 +7,16 @@ class TestRequest < MiniTest::Unit::TestCase
   end
 
   def test_simple_case_with_array
-    r = router { add('test', :request => {:request_methods => ['POST', 'GET']}) }
+    r = router { add('test', :conditions => {:request_method => ['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_simple_case_with_non_array
+    r = router { add('test', :conditions => {:request_method => 'GET'}) }
+    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

@@ -94,6 +94,10 @@ class TestVariable < MiniTest::Unit::TestCase
     assert_route '/test/*variable/test/*variable2', '/test/one/two/three/test/four/five/six', {:variable => ['one', 'two', 'three'], :variable2 => ['four', 'five', 'six']}
   end
 
+  def test_var_glob_var
+    assert_route '/test/:test-*variable.:format', '/test/one-two/three/four/five.six', {:test=> 'one', :variable => ['two', 'three', 'four', 'five'], :format => 'six'}
+  end
+
   def test_glob_with_regexp
     r = router { add('/test/*variable', :variable => /[a-z]+/) }
     assert_route nil, '/test/asd/123'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
-  hash: 45
+  hash: 43
   prerelease: 
   segments: 
   - 0
   - 8
-  - 9
-  version: 0.8.9
+  - 10
+  version: 0.8.10
 platform: ruby
 authors: 
 - Joshua Hull
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-19 00:00:00 -07:00
+date: 2011-06-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency