http_router 0.8.1 → 0.8.2

data/lib/http_router.rb

@@ -39,7 +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                   = []
+    @counter                 = 0
     reset!
     instance_eval(&blk) if blk
   end
@@ -138,7 +138,7 @@ class HttpRouter
 
   # Resets the router to a clean state.
   def reset!
-    @routes, @named_routes, @root = [], {}, Node.new(self, nil)
+    @routes, @named_routes, @root = [], {}, Node::Root.new(self)
     @default_app = Proc.new{ |env| ::Rack::Response.new("Your request couldn't be found", 404).finish }
   end
 
@@ -147,15 +147,6 @@ 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.
   #
@@ -208,6 +199,10 @@ class HttpRouter
     @root.compile
   end
 
+  def next_counter
+    @counter += 1
+  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

@@ -1,6 +1,8 @@
 class HttpRouter
   class Node
+    autoload :Root,          'http_router/node/root'
     autoload :Glob,          'http_router/node/glob'
+    autoload :GlobRegex,     'http_router/node/glob_regex'
     autoload :Variable,      'http_router/node/variable'
     autoload :Regex,         'http_router/node/regex'
     autoload :SpanningRegex, 'http_router/node/spanning_regex'
@@ -25,6 +27,10 @@ class HttpRouter
       add(Glob.new(@router, self))
     end
 
+    def add_glob_regexp(matcher)
+      add(GlobRegex.new(@router, self, matcher))
+    end
+
     def add_request(opts)
       add(Request.new(@router, self, opts))
     end
@@ -57,20 +63,15 @@ class HttpRouter
       false
     end
 
-    def method_missing(m, *args, &blk)
-      if m.to_s == '[]'
-        compile
-        send(:[], *args)
+    private
+    def inject_root_methods(code = nil, &blk)
+      if code
+        root.methods_module.module_eval(code, __FILE__, __LINE__)
       else
-        super
+        root.methods_module.module_eval(&blk)
       end
     end
 
-    def compile
-      instance_eval "def [](request)\n#{to_code}\nnil\nend", __FILE__, __LINE__
-    end
-
-    private
     def add(matcher)
       @matchers << matcher unless matcher.usable?(@matchers.last)
       @matchers.last
@@ -80,14 +81,18 @@ class HttpRouter
       @matchers.map{ |m| "# #{m.class}\n" << m.to_code }.join("\n") << "\n"
     end
 
+    def root
+      @router.root
+    end
+
     def depth
-      p = @parent
-      d = 0
-      until p.nil?
-        d += 1
-        p = p.parent
-      end
+      d, p = 0, @parent
+      d, p = d + 1, p.parent until p.nil?
       d
     end
+
+    def use_named_captures?
+      //.respond_to?(:names)
+    end
   end
 end

data/lib/http_router/node/arbitrary.rb

@@ -5,7 +5,6 @@ class HttpRouter
 
       def initialize(router, parent, sallow_partial, blk, param_names)
         @allow_partial, @blk, @param_names = allow_partial, blk, param_names
-        @node_position = router.register_node(blk)
         super(router, parent)
       end
 
@@ -14,13 +13,15 @@ class HttpRouter
       end
 
       def to_code
+        b, method_name = @blk, :"blk_#{router.next_counter}"
+        inject_root_methods { define_method(method_name) { b } }
         "#{"if request.path_finished?" unless @allow_partial}
           request.continue = proc { |state|
             if state
               #{super}
             end
           }
-          router.nodes.at(#{node_position})[request, #{@param_names.nil? || @param_names.empty? ? '{}' : "Hash[#{@param_names.inspect}.zip(request.params)]"}]
+          #{method_name}[request, #{@param_names.nil? || @param_names.empty? ? '{}' : "Hash[#{@param_names.inspect}.zip(request.params)]"}]
           request.continue = nil
         #{"end" unless @allow_partial}"
       end

data/lib/http_router/node/destination.rb

@@ -5,7 +5,6 @@ class HttpRouter
       
       def initialize(router, parent, blk, allow_partial)
         @blk, @allow_partial = blk, allow_partial
-        @node_position = router.register_node(blk)
         super(router, parent)
       end
 
@@ -14,9 +13,11 @@ class HttpRouter
       end
 
       def to_code
+        b, method_name = @blk, :"blk_#{router.next_counter}"
+        inject_root_methods { define_method(method_name) { b } }
         "#{"if request.path_finished?" unless @allow_partial}
           request.passed_with = catch(:pass) do
-            router.nodes.at(#{node_position})[request, #{@param_names.nil? || @param_names.empty? ? 'nil' : "Hash[#{@param_names.inspect}.zip(request.params)]"}]
+            #{method_name}[request, #{@param_names.nil? || @param_names.empty? ? 'nil' : "Hash[#{@param_names.inspect}.zip(request.params)]"}]
           end
         #{"end" unless @allow_partial}"
       end

data/lib/http_router/node/free_regex.rb

@@ -8,17 +8,17 @@ class HttpRouter
       end
 
       def to_code
-        "whole_path = \"/\#{request.joined_path}\"
-        if match = #{matcher.inspect}.match(whole_path) and match[0].size == whole_path.size
+        "whole_path#{depth} = \"/\#{request.joined_path}\"
+        if match = #{matcher.inspect}.match(whole_path#{depth}) and match[0].size == whole_path#{depth}.size
           request.extra_env['router.regex_match'] = match
           old_path = request.path
           request.path = ['']
-          " << (//.respond_to?(:names) ?
+          " << (use_named_captures? ?
           "match.names.size.times{|i| request.params << match[i + 1]} if match.respond_to?(:names) && match.names" : "") << "
           #{super}
           request.path = old_path
           request.extra_env.delete('router.regex_match')
-          " << (//.respond_to?(:names) ?
+          " << (use_named_captures? ?
           "params.slice!(-match.names.size, match.names.size)" : ""
           ) << "
         end"

data/lib/http_router/node/glob.rb

@@ -1,6 +1,7 @@
 class HttpRouter
   class Node
     class Glob < Node
+      alias_method :node_to_code, :to_code
       def usable?(other)
         other.class == self.class
       end
@@ -9,12 +10,11 @@ class HttpRouter
         "request.params << (globbed_params#{depth} = [])
           remaining_parts = request.path.dup
           until remaining_parts.empty?
-            globbed_params#{depth} << URI.unescape(remaining_parts.shift)
+            globbed_params#{depth} << remaining_parts.shift
             request.path = remaining_parts
             #{super}
           end
-          request.path[0,0] = request.params.pop
-          "
+          request.path[0,0] = request.params.pop"
       end
     end
   end

data/lib/http_router/node/glob_regex.rb

@@ -1,18 +1,25 @@
 class HttpRouter
   class Node
-    class GlobRegex < SpanningRegex
+    class GlobRegex < Glob
+      attr_reader :matcher
+      def initialize(router, parent, matcher)
+        @matcher = matcher
+        super router, parent
+      end
+
+      def usable?(other)
+        other.class == self.class && other.matcher == matcher
+      end
+
       def to_code
-        "whole_path = request.joined_path
-          if match = #{@matcher.inspect}.match(whole_path) and match.begin(0).zero?
-            original_path = request.path.dup\n" << 
-          @capturing_indicies.map { |c| "request.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]
-          request.path = remaining_path.split('/')
-          #{super}
-          request.path = original_path
-          #{@capturing_indicies.size == 1 ? "request.params.pop" : "request.params.slice!(#{-@capturing_indicies.size}, #{@capturing_indicies.size})"}
-        end
-          "
+        "request.params << (globbed_params#{depth} = [])
+          remaining_parts = request.path.dup
+          while !remaining_parts.empty? and match = remaining_parts.first.match(#{@matcher.inspect}) and match[0] == remaining_parts.first
+            globbed_params#{depth} << remaining_parts.shift
+            request.path = remaining_parts
+            #{node_to_code}
+          end
+          request.path[0,0] = request.params.pop"
       end
     end
   end

data/lib/http_router/node/lookup.rb

@@ -15,15 +15,19 @@ class HttpRouter
       end
 
       def to_code
-        code = "\ncase request.path.first\n"
-        @map.keys.each do |k|
-          code << "when #{k.inspect}\n
-  part#{depth} = request.path.shift
-  #{@map[k].map{|n| n.to_code} * "\n"}
-  request.path.unshift part#{depth}
-  "
+        inject_root_methods @map.keys.map {|k| 
+          method = :"lookup_#{object_id}_#{k.hash}"
+          "define_method(#{method.inspect}) do |request|
+            part = request.path.shift
+            #{@map[k].map{|n| n.to_code} * "\n"}
+            request.path.unshift part
+          end"}.join("\n")
+        code = "
+        unless request.path_finished?
+          m = \"lookup_#{object_id}_\#{request.path.first.hash}\"
+          send(m, request) if respond_to?(m)
         end
-        code << "\nend"
+        "
       end
     end
   end

data/lib/http_router/node/regex.rb

@@ -17,8 +17,8 @@ class HttpRouter
         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 << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
-          @capturing_indicies.map { |c| "request.params << URI.unescape(match[#{c}])\n" }.join << "
+          @splitting_indicies.map { |s| "request.params << match[#{s}].split(/\\//)\n" }.join <<
+          @capturing_indicies.map { |c| "request.params << match[#{c}]\n" }.join << "
           #{super}
           request.path.unshift part
           #{params_size == 1 ? "request.params.pop" : "request.params.slice!(#{-params_size}, #{params_size})"}

data/lib/http_router/node/request.rb

@@ -16,13 +16,21 @@ class HttpRouter
       def to_code
         code = "if "
         code << @opts.map do |k,v|
-          case v
-          when Array then "(#{v.map{|vv| "#{vv.inspect} === request.rack_request.#{k}"}.join(' or ')})"
-          else            "#{v.inspect} === request.rack_request.#{k.inspect}"
+          case v.size
+          when 1 then to_code_condition(k, v.first)
+          else        "(#{v.map{|k, vv| to_code_condition(k, vv)}.join(' or ')})"
           end           
         end * ' and '
         code << "\n  #{super}\nend"
       end
+
+      private
+      def to_code_condition(k, v)
+        case v
+        when String then "#{v.inspect} == request.rack_request.#{k}"
+        else             "#{v.inspect} === request.rack_request.#{k}"
+        end
+      end
     end
   end
 end

data/lib/http_router/node/root.rb

@@ -0,0 +1,22 @@
+class HttpRouter
+  class Node
+    class Root < Node
+      attr_reader :methods_module
+      def initialize(router)
+        super(router, nil)
+        @methods_module = Module.new
+      end
+
+      def [](request)
+        compile
+        self[request]
+      end
+
+      private
+      def compile
+        root.extend(root.methods_module)
+        instance_eval "def [](request)\n#{to_code}\nnil\nend", __FILE__, __LINE__
+      end
+    end
+  end
+end

data/lib/http_router/node/spanning_regex.rb

@@ -3,18 +3,18 @@ class HttpRouter
     class SpanningRegex < Regex
       def to_code
         params_count = (@splitting_indicies || []).size + @capturing_indicies.size
-        "whole_path = request.joined_path
-          if match = #{@matcher.inspect}.match(whole_path) and match.begin(0).zero?
-            original_path#{depth} = request.path.dup
-            " <<
-            (@splitting_indicies || []).map { |s| "request.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
-            @capturing_indicies.map { |c| "request.params << URI.unescape(match[#{c}])\n" }.join << "
-            remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
-            request.path = remaining_path.split('/')
-            #{node_to_code}
-            request.path = original_path#{depth}
-            request.params.slice!(#{-params_count.size}, #{params_count})
-          end
+        "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 << "
+          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}
+          request.path = original_path#{depth}
+          request.params.slice!(#{-params_count.size}, #{params_count})
+        end
         "
       end
     end

data/lib/http_router/node/variable.rb

@@ -7,9 +7,9 @@ class HttpRouter
 
       def to_code
         "unless request.path_finished?
-          request.params << URI.unescape(request.path.shift)
+          request.params << request.path.shift
           #{super}
-          request.path.unshift URI.escape(request.params.pop)
+          request.path.unshift request.params.pop
         end"
       end
     end

data/lib/http_router/request.rb

@@ -5,8 +5,9 @@ class HttpRouter
     alias_method :rack, :rack_request
     def initialize(path, rack_request, perform_call, &acceptance_test)
       @rack_request, @perform_call, @acceptance_test = rack_request, perform_call, acceptance_test
-      @path = (path[0] == ?/ ? path[1, path.size] : path).split(/\//)
-      @path << '' if path.size > 1 && path[-1] == ?/
+      @path = URI.unescape(path).split(/\//)
+      @path.shift if @path.first == ''
+      @path.push('') if path[-1] == ?/
       @extra_env = {}
       @params = []
     end

data/lib/http_router/route.rb

@@ -210,9 +210,9 @@ class HttpRouter
             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_glob
+              @opts[name.to_sym] ? node.add_glob_regexp(@opts.delete(name.to_sym)) : node.add_glob
             else
-              node.add_lookup(URI.encode(parts[0]))
+              node.add_lookup(parts[0])
             end
           else
             capturing_indicies = []
@@ -237,9 +237,10 @@ class HttpRouter
                 name = part[1, part.size].to_sym
                 param_names << name
                 matches_with[name] = @opts[name]
-                "(#{(@opts[name] || '.*?')})"
+                @opts[name] ?
+                  "((?:#{@opts[name]}\\/?)+)" : '(.*?)'
               else
-                Regexp.quote(URI.encode(part))
+                Regexp.quote(part)
               end
             end
             node = spans ? node.add_spanning_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies) :

data/lib/http_router/version.rb

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

data/test/test_recognize.rb

@@ -92,6 +92,16 @@ class TestRecognition < MiniTest::Unit::TestCase
     assert_body '/',         router.call(Rack::MockRequest.env_for('/'))
   end
 
+  def test_request_mutation
+    got_this_far = false
+    non_matching, matching = router {
+      add("/test/:var/:var2/*glob").matching(:var2 => /123/, :glob => /[a-z]+/).get.arbitrary{|env, params| got_this_far = true; false}
+      add("/test/:var/:var2/*glob").matching(:var2 => /123/, :glob => /[a-z]+/).get
+    }
+    assert_route matching, '/test/123/123/asd/aasd/zxcqwe/asdzxc', {:var => '123', :var2 => '123', :glob => %w{asd aasd zxcqwe asdzxc}}
+    assert got_this_far, "matching should have gotten this far"
+  end
+
   def test_multiple_partial
     test, root = router {
       add("/test").partial.to{|env| [200, {}, ['/test',env['PATH_INFO']]]}

data/test/test_variable.rb

@@ -90,6 +90,19 @@ class TestVariable < MiniTest::Unit::TestCase
     assert_route '/test/*variable/test', '/test/one/two/three/test', {:variable => ['one', 'two', 'three']}
   end
 
+  def test_glob_with_regexp
+    r = router { add('/test/*variable', :variable => /[a-z]+/) }
+    assert_route nil, '/test/asd/123'
+    assert_route nil, '/test/asd/asd123'
+    assert_route r, '/test/asd/qwe', :variable => ['asd', 'qwe']
+  end
+
+  def test_glob_with_regexp_and_static
+    r = router { add('/test/*variable/test', :variable => /[a-z]+/) }
+    assert_route nil, '/test/asd/123/test'
+    assert_route r, '/test/asd/qwe/test', :variable => ['asd', 'qwe']
+  end
+
   def test_glob_with_variable
     assert_route '/test/*variable/:test', '/test/one/two/three', {:variable => ['one', 'two'], :test => 'three'}
   end
@@ -98,6 +111,13 @@ class TestVariable < MiniTest::Unit::TestCase
     assert_route '/test/*variable.:format', 'test/one/two/three.html', {:variable => ['one', 'two', 'three'], :format => 'html'}
   end
 
+  def test_glob_regexp_with_format
+    r = router { add('/test/*variable.:format', :variable => /[a-z]+/, :format => 'html') }
+    assert_route nil, 'test/one/2/three.html'
+    assert_route nil, 'test/one/two/three.xml'
+    assert_route r, 'test/one/two/three.html', {:variable => ['one', 'two', 'three'], :format => 'html'}
+  end
+
   def test_glob_with_optional_format
     assert_route '/test/*variable(.:format)', 'test/one/two/three.html', {:variable => ['one', 'two', 'three'], :format => 'html'}
   end

metadata

@@ -2,7 +2,7 @@
 name: http_router
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors: 
 - Joshua Hull
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-01 00:00:00 -04:00
+date: 2011-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -155,6 +155,7 @@ files:
 - lib/http_router/node/lookup.rb
 - lib/http_router/node/regex.rb
 - lib/http_router/node/request.rb
+- lib/http_router/node/root.rb
 - lib/http_router/node/spanning_regex.rb
 - lib/http_router/node/variable.rb
 - lib/http_router/optional_compiler.rb