usher 0.5.7 → 0.5.8

data/VERSION.yml

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

data/lib/usher/interface/rails2_2_interface.rb

@@ -12,7 +12,7 @@ class Usher
       end
       
       def reset!
-        @usher ||= Usher.new(:generator => Usher::Util::Generators::URL.new)
+        @usher ||= Usher.new(:generator => Usher::Util::Generators::URL.new, :request_methods => [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains])
         @module ||= Module.new
         @module.instance_methods.each do |selector|
           @module.class_eval { remove_method selector }

data/lib/usher/interface/rails2_3_interface.rb

@@ -72,7 +72,7 @@ class Usher
       end
       
       def reset!
-        @router = Usher.new(:generator => Usher::Util::Generators::URL.new)
+        @router = Usher.new(:generator => Usher::Util::Generators::URL.new, :request_methods => [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains])
         @configuration_files = []
         @module ||= Module.new
         @controller_route_added = false

data/lib/usher/node.rb

@@ -173,7 +173,7 @@ class Usher
     
     def set_path_with_destination(path, destination = path)
       node = path.parts.inject(self){ |node, key| process_path_part(node, key) }
-      node = process_request_parts(node, request_methods_for_path(path))
+      node = process_request_parts(node, request_methods_for_path(path)) if request_methods
 
       while node.request_method_type
         node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))

data/lib/usher/route/variable.rb

@@ -2,7 +2,7 @@ class Usher
   class Route
     class Variable
       attr_reader :type, :name, :validator, :regex_matcher
-      attr_accessor :look_ahead, :default_value
+      attr_accessor :look_ahead, :default_value, :look_ahead_priority
       
       def initialize(name, regex_matcher = nil, validator = nil)
         @name = name.to_s.to_sym

data/lib/usher/util/graph.rb

@@ -0,0 +1,21 @@
+class Usher
+  module Util
+    class Graph
+      
+      attr_reader :router
+            
+      def initialize(router)
+        @router = router
+      end
+      
+      def draw(output)
+        File.open(output, 'w') do |f|
+          f.puts "digraph {"
+          f.puts %|node[label="node"]|
+          f.puts "}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/usher/util/parser.rb

@@ -44,9 +44,19 @@ class Usher
               part.default_value = default_values[part.name] if part.is_a?(Usher::Route::Variable) && default_values && default_values[part.name]
               case part
               when Usher::Route::Variable::Glob
-                part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiter_chars.include?(p[0])} || nil
+                if part.look_ahead && !part.look_ahead_priority
+                  part.look_ahead = nil
+                  part.look_ahead_priority = true
+                else
+                  part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiter_chars.include?(p[0])} || nil
+                end
               when Usher::Route::Variable
-                part.look_ahead = path[index + 1, path.size].find{|p| router.delimiter_chars.include?(p[0])} || router.delimiters.first
+                if part.look_ahead && !part.look_ahead_priority
+                  part.look_ahead = nil
+                  part.look_ahead_priority = true
+                else
+                  part.look_ahead = path[index + 1, path.size].find{|p| router.delimiter_chars.include?(p[0])} || router.delimiters.first
+                end
               end
             end
           end

data/lib/usher/util.rb

@@ -2,5 +2,6 @@ class Usher
   module Util
     autoload :Generators, File.join(File.dirname(__FILE__), 'util', 'generate')
     autoload :Parser, File.join(File.dirname(__FILE__), 'util', 'parser')
+    autoload :Graph, File.join(File.dirname(__FILE__), 'util', 'graph')
   end
 end

data/lib/usher.rb

@@ -53,7 +53,7 @@ class Usher
     self.generator = options && options.delete(:generator)
     self.delimiters = options && options.delete(:delimiters) || ['/', '.']
     self.valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
-    self.request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
+    self.request_methods = options && options.delete(:request_methods)
     reset!
   end
 

data/spec/private/recognize_spec.rb

@@ -1,8 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
 require "usher"
 
-route_set = Usher.new
-
 def build_request(opts)
   request = mock "Request"
   opts.each do |k,v|
@@ -14,228 +12,249 @@ end
 describe "Usher route recognition" do
   
   before(:each) do
-    route_set.reset!
+    @route_set = Usher.new(:request_methods => [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains])
   end
   
   describe 'request conditions' do
   
     it "should recognize a specific domain name" do
-      target_route = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http'})
-      route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https'})
-      route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http'})).path.route.should == target_route
+      target_route = @route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http'})
+      @route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https'})
+      @route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http'})).path.route.should == target_route
     end
   
     it "should recognize a regex domain name" do
-      target_route = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:domain => /^admin.*$/})
-      route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:domain => 'www.host.com'})
-      route_set.recognize(build_request({:method => 'get', :path => '/sample', :domain => 'admin.host.com'})).path.route.should == target_route
+      target_route = @route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:domain => /^admin.*$/})
+      @route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:domain => 'www.host.com'})
+      @route_set.recognize(build_request({:method => 'get', :path => '/sample', :domain => 'admin.host.com'})).path.route.should == target_route
     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', :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
+      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', :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
-      noop_route = route_set.add_route('/noop', :controller => 'products', :action => 'noop')
-      product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
-      route_set.recognize(build_request({:method => 'get', :path => '/noop', :domain => 'admin.host.com'})).path.route.should == noop_route
-      route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'})).path.route.should == product_show_route
+      noop_route = @route_set.add_route('/noop', :controller => 'products', :action => 'noop')
+      product_show_route = @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
+      @route_set.recognize(build_request({:method => 'get', :path => '/noop', :domain => 'admin.host.com'})).path.route.should == noop_route
+      @route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'})).path.route.should == product_show_route
     end
 
     it "should use conditionals that are boolean" do
       # hijacking user_agent
-      insecure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => false, :method => 'get'})
-      secure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => true, :method => 'get'})
+      insecure_product_show_route = @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => false, :method => 'get'})
+      secure_product_show_route = @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => true, :method => 'get'})
 
-      secure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => true})).path.route
-      insecure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => false})).path.route
+      secure_product_show_route.should == @route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => true})).path.route
+      insecure_product_show_route.should == @route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => false})).path.route
     end
 
     it "should use conditionals that are arrays" do
       # hijacking user_agent
-      www_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['www'], :method => 'get'})
-      admin_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['admin'], :method => 'get'})
+      www_product_show_route = @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['www'], :method => 'get'})
+      admin_product_show_route = @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['admin'], :method => 'get'})
 
-      admin_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['admin'], :user_agent => true})).path.route
-      www_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['www'], :user_agent => false})).path.route
+      admin_product_show_route.should == @route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['admin'], :user_agent => true})).path.route
+      www_product_show_route.should == @route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['www'], :user_agent => false})).path.route
     end
   end
   
   it "should recognize a format-style variable" do
-    target_route = route_set.add_route('/sample.:format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:format , 'html']], nil, "/sample.html")
+    target_route = @route_set.add_route('/sample.:format', :controller => 'sample', :action => 'action')
+    @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:format , 'html']], nil, "/sample.html")
   end
   
   it "should recognize a glob-style variable" do
-    target_route = route_set.add_route('/sample/*format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple'})).params.should == [[:format, ['html', 'json', 'apple']]]
+    target_route = @route_set.add_route('/sample/*format', :controller => 'sample', :action => 'action')
+    @route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple'})).params.should == [[:format, ['html', 'json', 'apple']]]
   end
   
   it "should recgonize only a glob-style variable" do
-    target_route = route_set.add_route('/*format')
-    response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple'}))
+    target_route = @route_set.add_route('/*format')
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple'}))
     response.params.should == [[:format, ['sample', 'html', 'json', 'apple']]]
     response.path.route.should == target_route
   end
   
   it "should recgonize a regex static part" do
-    target_route = route_set.add_route('/test/part/{one|two}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/two'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/three'})).should == nil
+    target_route = @route_set.add_route('/test/part/{one|two}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/two'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/three'})).should == nil
   end
   
   it "shouldn't accept a nil variable" do
-    target_route = route_set.add_route('/:one')
-    route_set.recognize(build_request({:method => 'get', :path => '/one'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/'})).should == nil
+    target_route = @route_set.add_route('/:one')
+    @route_set.recognize(build_request({:method => 'get', :path => '/one'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/'})).should == nil
   end
   
   it "should recgonize a regex static part containing {}'s" do
-    target_route = route_set.add_route('/test/part/{^o{2,3}$}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/oo'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/ooo'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/oooo'})).should == nil
+    target_route = @route_set.add_route('/test/part/{^o{2,3}$}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/oo'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/ooo'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/oooo'})).should == nil
   end
   
   it "should recgonize a regex single variable" do
-    target_route = route_set.add_route('/test/part/{:test,hello|again}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello'})).params.should == [[:test, 'hello']]
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/again'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/again'})).params.should == [[:test, 'again']]
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/world'})).should == nil
+    target_route = @route_set.add_route('/test/part/{:test,hello|again}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello'})).params.should == [[:test, 'hello']]
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/again'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/again'})).params.should == [[:test, 'again']]
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/world'})).should == nil
   end
   
   it "should recgonize a regex glob variable" do
-    target_route = route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']]]
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/agaim/123/hello/again'})).should == nil
+    target_route = @route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']]]
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/agaim/123/hello/again'})).should == nil
   end
   
   it "should recgonize a regex glob variable terminated by a static part" do
-    target_route = route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}/onemore')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']]]
+    target_route = @route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}/onemore')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']]]
   end
   
   it "should recgonize a regex glob variable terminated by a single regex variable" do
-    target_route = route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}/{:party,onemore}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']], [:party, 'onemore']]
+    target_route = @route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}/{:party,onemore}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']], [:party, 'onemore']]
   end
 
   it "should recgonize a greedy regex single variable" do
-    target_route = route_set.add_route('/test/part/{!test,one/more/time}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).params.should == [[:test, 'one/more/time']]
+    target_route = @route_set.add_route('/test/part/{!test,one/more/time}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).params.should == [[:test, 'one/more/time']]
   end
 
   it "should recgonize a greedy regex that matches across / and not" do
-    target_route = route_set.add_route('/test/part/{!test,one/more|one}')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more'})).params.should == [[:test, 'one/more']]
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).params.should == [[:test, 'one']]
+    target_route = @route_set.add_route('/test/part/{!test,one/more|one}')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more'})).params.should == [[:test, 'one/more']]
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).params.should == [[:test, 'one']]
   end
 
   it "should recgonize a greedy regex single variable with static parts after" do
-    target_route = route_set.add_route('/test/part/{!test,one/more/time}/help')
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).path.route.should == target_route
-    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).params.should == [[:test, 'one/more/time']]
+    target_route = @route_set.add_route('/test/part/{!test,one/more/time}/help')
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).path.route.should == target_route
+    @route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).params.should == [[:test, 'one/more/time']]
   end
 
   it "should recgonize two glob-style variables separated by a static part" do
-    target_route = route_set.add_route('/*format/innovate/*onemore')
-    response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/innovate/apple'}))
+    target_route = @route_set.add_route('/*format/innovate/*onemore')
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/sample/html/innovate/apple'}))
     response.params.should == [[:format, ['sample', 'html']], [:onemore, ['apple']]]
     response.path.route.should == target_route
   end
   
   it "should recgonize only a glob-style variable with a condition" do
-    target_route = route_set.add_route('/*format', :conditions => {:domain => 'test-domain'})
-    response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple', :domain => 'test-domain'}))
+    target_route = @route_set.add_route('/*format', :conditions => {:domain => 'test-domain'})
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple', :domain => 'test-domain'}))
     response.params.should == [[:format, ['sample', 'html', 'json', 'apple']]]
     response.path.route.should == target_route
   end
   
   it "should recognize a format-style literal" do
-    target_route = route_set.add_route('/:action.html', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample']], nil, "/sample.html")
+    target_route = @route_set.add_route('/:action.html', :controller => 'sample', :action => 'action')
+    @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample']], nil, "/sample.html")
   end
   
   it "should recognize a format-style variable along side another variable" do
-    target_route = route_set.add_route('/:action.:format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample'], [:format, 'html']], nil, '/sample.html')
+    target_route = @route_set.add_route('/:action.:format', :controller => 'sample', :action => 'action')
+    @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample'], [:format, 'html']], nil, '/sample.html')
   end
   
   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)
+    @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)
   end
 
   it "shouldn't care about mildly weird characters in the URL" do
-    route = route_set.add_route('/!asd,qwe/hjk$qwe/:id')
-    route_set.recognize(build_request({:method => 'get', :path => '/!asd,qwe/hjk$qwe/09AZaz$-_+!*\'', :domain => 'admin.host.com'})).params.rassoc('09AZaz$-_+!*\'').first.should == :id
+    route = @route_set.add_route('/!asd,qwe/hjk$qwe/:id')
+    @route_set.recognize(build_request({:method => 'get', :path => '/!asd,qwe/hjk$qwe/09AZaz$-_+!*\'', :domain => 'admin.host.com'})).params.rassoc('09AZaz$-_+!*\'').first.should == :id
   end
   
   it "shouldn't care about non-primary delimiters in the path" do
-    route = route_set.add_route('/testing/:id/testing2/:id2/:id3')
-    route_set.recognize(build_request({:method => 'get', :path => '/testing/asd.qwe/testing2/poi.zxc/oiu.asd'})).params.should == [[:id, 'asd.qwe'], [:id2, 'poi.zxc'], [:id3, 'oiu.asd']]
+    route = @route_set.add_route('/testing/:id/testing2/:id2/:id3')
+    @route_set.recognize(build_request({:method => 'get', :path => '/testing/asd.qwe/testing2/poi.zxc/oiu.asd'})).params.should == [[:id, 'asd.qwe'], [:id2, 'poi.zxc'], [:id3, 'oiu.asd']]
+  end
+  
+  it "should pick the path when there are mutliple conflicting delimiters" do
+    @route_set.add_route('/:id1(.:format)')
+    @route_set.add_route('/:id1/one(.:format)')
+    @route_set.add_route('/:id1/one/:id2(.:format)')
+    
+    @route_set.recognize(build_request({:path => '/id1'})).params.should == [[:id1, 'id1']]
+    @route_set.recognize(build_request({:path => '/id1.html'})).params.should == [[:id1, 'id1'], [:format, 'html']]
+    @route_set.recognize(build_request({:path => '/id1/one'})).params.should == [[:id1, 'id1']]
+    @route_set.recognize(build_request({:path => '/id1/one.html'})).params.should == [[:id1, 'id1'], [:format, 'html']]
+    @route_set.recognize(build_request({:path => '/id1/one/id2'})).params.should == [[:id1, 'id1'], [:id2, 'id2']]
+    @route_set.recognize(build_request({:path => '/id1/one/id2.html'})).params.should == [[:id1, 'id1'], [:id2, 'id2'], [:format, 'html']]
   end
   
   it "should recognize a path with an optional compontnet" do
-    route_set.add_route("/:name(/:surname)", :conditions => {:method => 'get'})
-    result = route_set.recognize(build_request({:method => 'get', :path => '/homer'}))
+    @route_set.add_route("/:name(/:surname)", :conditions => {:method => 'get'})
+    result = @route_set.recognize(build_request({:method => 'get', :path => '/homer'}))
     result.params.should == [[:name, "homer"]]
-    result = route_set.recognize(build_request({:method => 'get', :path => "/homer/simpson"}))
+    result = @route_set.recognize(build_request({:method => 'get', :path => "/homer/simpson"}))
     result.params.should == [[:name, "homer"],[:surname, "simpson"]]
   end  
   
   it "should should raise if malformed variables are used" do
-    route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
-    proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error
+    @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
+    proc {@route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error
   end
   
   it "should recognize multiple optional parts" do
-    target_route = route_set.add_route('/test(/this)(/too)')
-    route_set.recognize_path('/test').path.route.should == target_route
-    route_set.recognize_path('/test/this').path.route.should == target_route
-    route_set.recognize_path('/test/too').path.route.should == target_route
-    route_set.recognize_path('/test/this/too').path.route.should == target_route
+    target_route = @route_set.add_route('/test(/this)(/too)')
+    @route_set.recognize_path('/test').path.route.should == target_route
+    @route_set.recognize_path('/test/this').path.route.should == target_route
+    @route_set.recognize_path('/test/too').path.route.should == target_route
+    @route_set.recognize_path('/test/this/too').path.route.should == target_route
   end
   
+  it "should match between two routes where one is more specific from request conditions" do
+    route_with_post = @route_set.add_route("/foo", :conditions => {:method => 'post'})
+    route = @route_set.add_route("/foo")
+    
+    @route_set.recognize(build_request({:method => 'post', :path => '/foo'})).path.route.should == route_with_post
+    @route_set.recognize(build_request({:method => 'get', :path => '/foo'})).path.route.should == route
+  end
+
   describe "partial recognition" do
     it "should partially match a route" do
-      route = route_set.add_route("/foo")
+      route = @route_set.add_route("/foo")
       route.match_partially!
-      route_set.recognize(build_request(:method => "get", :path => "/foo/bar")).should == Usher::Node::Response.new(route.paths.first, [], "/bar", '/foo')
+      @route_set.recognize(build_request(:method => "get", :path => "/foo/bar")).should == Usher::Node::Response.new(route.paths.first, [], "/bar", '/foo')
     end
 
     it "should partially match a route and use request conditions" do
-      route = route_set.add_route("/foo", :conditions => {:method => 'get'})
+      route = @route_set.add_route("/foo", :conditions => {:method => 'get'})
       route.match_partially!
 
-      route_set.recognize(build_request({:method => 'get', :path => '/foo/bar'})).path.route.should == route
-      route_set.recognize(build_request({:method => 'post', :path => '/foo/bar'})).should.nil?
+      @route_set.recognize(build_request({:method => 'get', :path => '/foo/bar'})).path.route.should == route
+      @route_set.recognize(build_request({:method => 'post', :path => '/foo/bar'})).should.nil?
     end
 
     it "should not match partially when a route is not set as partially matched" do
-      route = route_set.add_route("/foo", :foo => :bar)
-      route_set.recognize(build_request(:path => "/foo")).path.route.should == route
-      route_set.recognize(build_request(:path => "/foo/bar")).should be_nil
+      route = @route_set.add_route("/foo", :foo => :bar)
+      @route_set.recognize(build_request(:path => "/foo")).path.route.should == route
+      @route_set.recognize(build_request(:path => "/foo/bar")).should be_nil
     end
     
 
@@ -243,28 +262,28 @@ describe "Usher route recognition" do
 
   describe "dup safety" do
     before do 
-      route_set.add_route("/foo", :foo => "foo")
-      @r2 = route_set.dup
+      @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)
+      @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"}
+      @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
+      @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"}
+      @route_set.recognize(  build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
       @r2.recognize(        build_request(:path => "/foo")).should == nil
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-25 00:00:00 -04:00
+date: 2009-10-09 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ files:
 - lib/usher/splitter.rb
 - lib/usher/util.rb
 - lib/usher/util/generate.rb
+- lib/usher/util/graph.rb
 - lib/usher/util/parser.rb
 - lib/usher/util/rack-mixins.rb
 - rails/init.rb