usher 0.5.3 → 0.5.4

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 5
-:patch: 3
+:patch: 4
 :major: 0
+:minor: 5

data/lib/usher/interface/rack_interface.rb

@@ -25,6 +25,15 @@ class Usher
         instance_eval(&blk) if blk
       end
       
+      def dup
+        new_one = super
+        original = self
+        new_one.instance_eval do
+          @router = router.dup
+        end
+        new_one
+      end
+      
       def add(path, options = nil)
         @router.add_route(path, options)
       end

data/lib/usher/node.rb

@@ -6,23 +6,40 @@ class Usher
     
     Response = Struct.new(:path, :params, :remaining_path, :matched_path)
     
-    attr_reader :lookup, :greedy_lookup
-    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods
+    attr_reader :normal, :greedy, :request
+    attr_accessor :terminates, :request_method_type, :parent, :value, :request_methods
 
     def initialize(parent, value)
       @parent = parent
       @value = value
-      @lookup = Hash.new
-      @greedy_lookup = Hash.new
-      @exclusive_type = nil
+      @request = nil
+      @normal = nil
+      @greedy = nil
+      @request_method_type = nil
+    end
+    
+    def activate_normal!
+      @normal ||= Hash.new
+    end
+
+    def activate_greedy!
+      @greedy ||= Hash.new
+    end
+
+    def activate_request!
+      @request ||= Hash.new
     end
 
-    def upgrade_lookup
-      @lookup = FuzzyHash.new(@lookup)
+    def upgrade_normal!
+      @normal = FuzzyHash.new(@normal)
     end
 
-    def upgrade_greedy_lookup
-      @greedy_lookup = FuzzyHash.new(@greedy_lookup)
+    def upgrade_greedy!
+      @greedy = FuzzyHash.new(@greedy)
+    end
+
+    def upgrade_request!
+      @request = FuzzyHash.new(@request)
     end
 
     def depth
@@ -30,7 +47,7 @@ class Usher
     end
     
     def greedy?
-      !@greedy_lookup.empty?
+      @greedy && !@greedy.empty?
     end
     
     def self.root(route_set, request_methods)
@@ -45,12 +62,22 @@ class Usher
 
     def pp
       $stdout << " " * depth
-      $stdout << "#{depth}: #{value.inspect} #{!!terminates?}\n"
-      @lookup.each do |k,v|
+      $stdout << "#{terminates? ? '* ' : ''}#{depth}: #{value.inspect}\n"
+      normal.each do |k,v|
         $stdout << " " * (depth + 1)
-        $stdout << "#{k} ==> \n"
+        $stdout << ". #{k.inspect} ==> \n"
         v.pp
-      end
+      end if normal
+      greedy.each do |k,v|
+        $stdout << " " * (depth + 1)
+        $stdout << "g #{k.inspect} ==> \n"
+        v.pp
+      end if greedy
+      request.each do |k,v|
+        $stdout << " " * (depth + 1)
+        $stdout << "r #{k.inspect} ==> \n"
+        v.pp
+      end if request
     end
     
     def add(route)
@@ -67,37 +94,38 @@ class Usher
     
     def unique_routes(node = self, routes = [])
       routes << node.terminates.route if node.terminates
-      node.lookup.values.each do |v|
+      node.normal.values.each do |v|
         unique_routes(v, routes)
-      end
-      node.greedy_lookup.values.each do |v|
+      end if node.normal
+      node.greedy.values.each do |v|
         unique_routes(v, routes)
-      end
+      end if node.greedy
+      node.request.values.each do |v|
+        unique_routes(v, routes)
+      end if node.request
       routes.uniq!
       routes
     end
     
-    def find(usher, request, original_path, path, params = [], position = 0)
-      if exclusive_type
-        [lookup[request.send(exclusive_type)], lookup[nil]].each do |n|
-          if n && (ret = n.find(usher, request, original_path, path.dup, params.dup, position))
-            return ret
-          end
-        end
-        nil
-      elsif terminates? && (path.size.zero? || terminates.route.partial_match?)
-        if terminates.route.partial_match?
-          Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position])
+    def find(usher, request_object, original_path, path, params = [], position = 0)
+      if request_method_type
+        if (specific_node = request[request_object.send(request_method_type)]) && (ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          ret
+        elsif (general_node = request[nil]) && (ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          ret
         else
-          Response.new(terminates, params, nil, original_path)
+          nil
         end
-        
-      elsif !path.size.zero? && (greedy? && (match_with_result_output = greedy_lookup.match_with_result(whole_path = original_path[position, original_path.size])))
+      elsif terminates? && (path.empty? || terminates.route.partial_match?)
+        terminates.route.partial_match? ?
+          Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position]) :
+          Response.new(terminates, params, nil, original_path)
+      elsif !path.empty? && (greedy? && (match_with_result_output = greedy.match_with_result(whole_path = original_path[position, original_path.size])))
 				next_path, matched_part = match_with_result_output
         position += matched_part.size
         params << [next_path.value.name, whole_path.slice!(0, matched_part.size)]
-        next_path.find(usher, request, original_path, whole_path.size.zero? ? whole_path : usher.splitter.url_split(whole_path), params, position)
-      elsif !path.size.zero? && (next_part = lookup[part = path.shift] || lookup[nil])
+        next_path.find(usher, request_object, original_path, whole_path.empty? ? whole_path : usher.splitter.url_split(whole_path), params, position)
+      elsif !path.empty? && normal && (next_part = normal[part = path.shift] || normal[nil])
         position += part.size
         case next_part.value
         when Route::Variable::Glob
@@ -115,7 +143,7 @@ class Usher
               next_part.value.valid!(part)
               params.last.last << part
             end
-            if path.size.zero?
+            if path.empty?
               break
             else
               part = path.shift
@@ -131,59 +159,107 @@ class Usher
             params.last.last << next_path_part
           end
         end
-        next_part.find(usher, request, original_path, path, params, position)
+        next_part.find(usher, request_object, original_path, path, params, position)
       else
         nil
       end
     end
 
     private
+    
     def set_path_with_destination(path, destination = path)
-      parts = path.parts.dup
-      request_methods.each do |type|
-        parts.push(Route::RequestMethod.new(type, path.route.conditions[type])) if path.route.conditions && path.route.conditions.key?(type)
+      node = path.parts.inject(self){ |node, key| process_path_part(node, key) }
+      node = process_request_parts(node, request_methods_for_path(path))
+
+      while node.request_method_type
+        node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))
       end
-      
-      current_node = self
-      while !parts.size.zero? || current_node.exclusive_type
+
+      node.terminates = destination
+    end
+    
+    def request_method_index(type)
+      request_methods.index(type)
+    end
+    
+    def process_request_parts(node, parts)
+      while parts.any?{ |p| !p.trivial? }
         key = parts.shift
-        target_node = case key
-        when Route::RequestMethod
-          current_node.upgrade_lookup if key.value.is_a?(Regexp)
-          if current_node.exclusive_type == key.type
-            current_node.lookup[key.value] ||= Node.new(current_node, key)
-          elsif current_node.lookup.empty?
-            current_node.exclusive_type = key.type
-            current_node.lookup[key.value] ||= Node.new(current_node, key)
-          else
+
+        next if key.trivial?
+
+        node.activate_request!
+
+        node = if node.request_method_type.nil?
+          node.request_method_type = key.type
+          node.upgrade_request! if key.value.is_a?(Regexp)
+          node.request[key.value] ||= Node.new(node, key)
+        else
+          case request_method_index(node.request_method_type) <=> request_method_index(key.type)
+          when -1
             parts.unshift(key)
-            current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
-          end
-        when Route::Variable
-          upgrade_method, lookup_method = case key
-          when Route::Variable::Greedy
-            [:upgrade_greedy_lookup, :greedy_lookup]
-          else
-            [:upgrade_lookup, :lookup]
+            node.request[key.value] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil))
+          when 0
+            node.upgrade_request! if key.value.is_a?(Regexp)
+            node.request[key.value] ||= Node.new(node, key)
+          when 1
+            previous_node = node.parent
+            current_node_entry_key = nil
+            current_node_entry_lookup = nil
+            [previous_node.normal, previous_node.greedy, previous_node.request].compact.each do |l|
+              current_node_entry_key = l.each{|k,v| break k if node == v}
+              current_node_entry_lookup = l and break if current_node_entry_key
+            end
+
+            current_node_entry_lookup.respond_to?(:delete_value) ? 
+              current_node_entry_lookup.delete_value(node) : current_node_entry_lookup.delete_if{|k,v| v == node}
+
+            new_node = Node.new(previous_node, Route::RequestMethod.new(key.type, nil))
+            new_node.activate_request!
+            new_node.request_method_type = key.type
+            current_node_entry_lookup[current_node_entry_key] = new_node
+            node.parent = new_node
+            new_node.request[nil] = node
+            parts.unshift(key)
+
+            new_node
           end
-          
-          if key.regex_matcher
-            current_node.send(upgrade_method)
-            current_node.send(lookup_method)[key.regex_matcher] ||= Node.new(current_node, key)
-          else
-            current_node.send(lookup_method)[nil] ||= Node.new(current_node, key)
-          end  
-        else
-          
-          current_node.upgrade_lookup if key.is_a?(Regexp)
-          current_node.lookup[key] ||= Node.new(current_node, key)
         end
-        current_node = target_node
       end
+      node
+    end      
       
-      current_node.terminates = destination
+    
+    def process_path_part(node, key)
+      case key
+      when Route::Variable::Greedy
+        node.activate_greedy!
+        if key.regex_matcher
+          node.upgrade_greedy!
+          node.greedy[key.regex_matcher] ||= Node.new(node, key)
+        else
+          node.greedy[nil] ||= Node.new(node, key)
+        end  
+      when Route::Variable
+        node.activate_normal!
+        if key.regex_matcher
+          node.upgrade_normal!
+          node.normal[key.regex_matcher] ||= Node.new(node, key)
+        else
+          node.normal[nil] ||= Node.new(node, key)
+        end
+      else
+        node.activate_normal!
+        node.upgrade_normal! if key.is_a?(Regexp)
+        node.normal[key] ||= Node.new(node, key)
+      end
     end
     
+    def request_methods_for_path(path)
+      request_methods.collect do |type|
+        Route::RequestMethod.new(type, path.route.conditions && path.route.conditions[type])
+      end
+    end
     
   end
 end

data/lib/usher/route/request_method.rb

@@ -17,6 +17,11 @@ class Usher
         o.is_a?(self.class) && o.type == type && o.value == value
       end
       alias == eql?
+      
+      def trivial?
+        value.nil?
+      end
+      
     end
   end
 end

data/lib/usher.rb

@@ -221,6 +221,20 @@ class Usher
     routes.each{|r| r.parent_route = route}
   end
   
+  def dup
+    replacement = super
+    original = self
+    replacement.instance_eval do
+      reset!
+      original.routes.each do |route|
+        @root.add(route)
+        @routes << route
+      end
+      rebuild_grapher!
+    end
+    replacement
+  end
+  
   private
   
   attr_accessor :request_methods
@@ -255,7 +269,7 @@ class Usher
     if options
       options.delete_if do |k, v|
         if v.is_a?(Regexp) || v.is_a?(Proc)
-          (requirements ||= {})[k] = v 
+          (requirements ||= {})[k] = v
           true
         end
       end

data/spec/private/path_spec.rb

@@ -48,32 +48,9 @@ describe "Usher route adding" do
   it "should calculate depths for nodes" do
     route_set.add_named_route(:route, '/bad/route/three/four')
     route_set.root.depth.should == 0
-    route_set.root.lookup['/'].depth.should == 1
+    route_set.root.normal['/'].depth.should == 1
   end
 
-  it "should pp for nodes" do
-    route_set.add_named_route(:route, '/bad/route/three/four')
-    route_set.root.depth.should == 0
-    old_out = $stdout
-    $stdout = (output = StringIO.new)
-    route_set.root.lookup['/'].lookup['bad'].lookup['/'].pp
-    $stdout = old_out
-    output.rewind
-    output.read.should == <<-HEREDOC
-   3: "/" false
-    route ==> 
-    4: "route" false
-     / ==> 
-     5: "/" false
-      three ==> 
-      6: "three" false
-       / ==> 
-       7: "/" false
-        four ==> 
-        8: "four" true
-    HEREDOC
-  end
-  
   describe "merging paths" do
     before do
       @r1 = route_set.add_route("/foo/bar")

data/spec/private/rack/dispatch_spec.rb

@@ -119,5 +119,55 @@ describe "Usher (for rack) route dispatching" do
       
     end
     
+    describe "dupping" do
+      before do 
+        @app  = mock("app")
+        @u1   = Usher::Interface.for(:rack)
+        @u2   = Usher::Interface.for(:rack)
+        
+        @u1.add("/one", :default_values => {:one => :one}).to(@app)
+        @u1.add("/mount").match_partially!.to(@u2)
+        
+        @u2.add("/app", :default_values => {:foo => :bar}).to(@app)
+        
+      end
+      
+      it "should allow me to dup the router" do
+        @app.should_receive(:call).twice.with{|e| e['usher.params'].should == {:one => :one}}
+        @u1.call(Rack::MockRequest.env_for("/one"))
+        u1_dash = @u1.dup
+        u1_dash.call(Rack::MockRequest.env_for("/one"))
+      end
+      
+      it "should allow me to dup the router and add a new route without polluting the original" do
+        @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
+        u1_dash = @u1.dup
+        u1_dash.add("/foo", :default_values => {:foo => :bar}).to(@app)
+        u1_dash.call(Rack::MockRequest.env_for("/foo"))
+        @app.should_not_receive(:call)
+        @u1.call(Rack::MockRequest.env_for("/foo"))
+      end
+      
+      it "should allow me to dup the router and nested routers should remain intact" do
+        @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
+        u1_dash = @u1.dup
+        u1_dash.call(Rack::MockRequest.env_for("/mount/app"))
+      end
+      
+      it "should allow me to dup the router and add more routes" do
+        @app.should_receive(:call).with{|e| e['usher.params'].should == {:another => :bar}}
+        
+        u3 = Usher::Interface.for(:rack)
+        u1_dash = @u1.dup
+        
+        u3.add("/another_bar", :default_values => {:another => :bar}).to(@app)
+        u1_dash.add("/some/mount").match_partially!.to(u3)
+        
+        u1_dash.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
+        
+        @app.should_not_receive(:call)
+        @u1.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
+      end
+    end
   end
 end

data/spec/private/recognize_spec.rb

@@ -31,14 +31,17 @@ describe "Usher route recognition" do
     end
 
     it "should recognize a specific route when several http-style restrictions are used" do
+      target_route_http_admin_generic = route_set.add_route('/sample', :conditions => {:domain => 'admin.spec.com'})
       target_route_http_admin = route_set.add_route('/sample', :conditions => {:protocol => 'http', :domain => 'admin.spec.com'})
       target_route_http_www = route_set.add_route('/sample', :conditions => {:protocol => 'http', :domain => 'www.spec.com'})
-      target_route_https_msie = route_set.add_route('/sample', :conditions => {:protocol => 'https', :user_agent => 'MSIE 6.0'})
+      target_route_https_msie = route_set.add_route('/sample', :conditions => {:protocol => 'https', :domain => 'admin.spec.com', :user_agent => 'MSIE 6.0'})
       target_route_https_admin = route_set.add_route('/sample', :conditions => {:protocol => 'https', :domain => 'admin.spec.com'})
       route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_http_admin
       route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http', :domain => 'www.spec.com', :user_agent => nil})).path.route.should == target_route_http_www
       route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'https', :domain => 'admin.spec.com', :user_agent => 'MSIE 6.0'})).path.route.should == target_route_https_msie
       route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'https', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_https_admin
+      route_set.recognize(build_request({:method => 'put', :path => '/sample', :protocol => 'wacky', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_http_admin_generic
+      
     end
 
     it "should correctly fix that tree if conditionals are used later" do
@@ -178,8 +181,8 @@ describe "Usher route recognition" do
   
   it "should use a requirement (proc) on incoming variables" do
     route_set.add_route('/:controller/:action/:id', :id => proc{|v| Integer(v)})
-    proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'}))}.should_not raise_error Usher::ValidationException
-    proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'}))}.should raise_error Usher::ValidationException
+    proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'}))}.should_not raise_error(Usher::ValidationException)
+    proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'}))}.should raise_error(Usher::ValidationException)
   end
 
   it "shouldn't care about mildly weird characters in the URL" do
@@ -213,4 +216,51 @@ describe "Usher route recognition" do
     end
 
   end
+
+  describe "dup safety" do
+    before do 
+      route_set.add_route("/foo", :foo => "foo")
+      @r2 = route_set.dup
+    end
+    
+    it "should provide a different object" do
+      route_set.should_not eql(@r2)
+    end
+        
+    it "should recognize the originals routes in the dup" do
+      route_set.recognize(build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
+      @r2.recognize(      build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
+    end
+
+    it "should not add routes added to the dup to the original" do
+      @r2.add_route("/bar", :bar => "bar")
+      @r2.recognize(        build_request(:path => "/bar")).path.route.destination.should == {:bar => "bar"}
+      route_set.recognize(  build_request(:path => "/bar")).should == nil
+    end
+    
+    it "should not delete routes added to the dup to the original" do
+      @r2.delete_route("/foo")
+      route_set.recognize(        build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
+      @r2.recognize(  build_request(:path => "/foo")).should == nil
+    end
+    
+    
+    it "should safely dup with nested ushers" do
+      r1 = Usher.new
+      r2 = Usher.new
+      r3 = Usher.new
+      
+      r1.add_route("/mounted"           ).match_partially!.to(r2)
+      r2.add_route("/inner"             ).match_partially!.to(r3)
+      r3.add_route("/baz", :baz => :baz )
+      
+      r1.recognize(build_request(:path => "/mounted/inner")).path.route.destination.should == r2
+      r4 = r1.dup
+      r4.recognize(build_request(:path => "/mounted/inner")).path.route.destination.should == r2
+      r4.add_route("/r3").match_partially!.to(r3)
+      r4.recognize(build_request(:path => "/r3")).path.route.destination.should == r3
+      r1.recognize(build_request(:path => "/r3")).should be_nil
+    end
+    
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-27 00:00:00 -04:00
+date: 2009-08-28 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency