joshbuddy-usher 0.3.2 → 0.3.3

data/Rakefile

@@ -27,3 +27,10 @@ namespace(:spec) do
   end
 
 end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/VERSION.yml

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

data/lib/usher.rb

@@ -44,10 +44,10 @@ class Usher
   # The +request_methods+ are methods that are called against the request object in order to
   # enforce the +conditions+ segment of the routes. For HTTP routes (and in fact the default), those 
   # methods are <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method]</tt>.
-  def initialize(delimiters = ['/', '.'], request_methods = [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method])
-    @delimiters = delimiters
-    @splitter = Splitter.for_delimiters(delimiters)
-    @request_methods = request_methods
+  def initialize(options = {})
+    @delimiters = options.delete(:options) || ['/', '.']
+    @request_methods = options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
+    @splitter = Splitter.for_delimiters(@delimiters)
     reset!
   end
 
@@ -117,7 +117,7 @@ class Usher
     conditions = options.delete(:conditions) || {}
     requirements = options.delete(:requirements) || {}
     options.delete_if do |k, v|
-      if v.is_a?(Regexp)
+      if v.is_a?(Regexp) || v.is_a?(Proc)
         requirements[k] = v 
         true
       end
@@ -173,7 +173,7 @@ class Usher
     else
       route
     end
-    
+    raise UnrecognizedException.new unless path
     params_hash = {}
     param_list = case params
     when Hash

data/lib/usher/node.rb

@@ -16,7 +16,6 @@ class Usher
       @value = value
       @lookup = FuzzyHash.new
       @exclusive_type = nil
-      @has_globber = find_parent{|p| p.value && p.value.is_a?(Route::Variable)}
     end
 
     def depth
@@ -29,28 +28,10 @@ class Usher
       root
     end
 
-    def has_globber?
-      @has_globber
-    end
-
     def terminates?
       @terminates
     end
 
-    def find_parent(&blk)
-      if @parent.nil? || !@parent.is_a?(Node)
-        nil
-      elsif yield @parent
-        @parent
-      else #keep searching
-        @parent.find_parent(&blk)
-      end
-    end
-
-    def replace(src, dest)
-      @lookup.replace(src, dest)
-    end
-    
     def pp
       $stdout << " " * depth
       $stdout << "#{depth}: #{value.inspect} #{!!terminates?}\n"
@@ -83,12 +64,7 @@ class Usher
               current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
             end
           else
-            if current_node.exclusive_type
-              parts.unshift(key)
-              current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
-            else
-              current_node.lookup[key.is_a?(Route::Variable) ? nil : key] ||= Node.new(current_node, key)
-            end
+            current_node.lookup[key.is_a?(Route::Variable) ? nil : key] ||= Node.new(current_node, key)
           end
           current_node = target_node
         end
@@ -109,8 +85,8 @@ class Usher
       elsif path.size.zero? && !part
         if terminates?
           Response.new(terminates, params)
-        else
-          nil
+        elsif params.last.is_a?(Array) && @lookup[nil]
+          Response.new(@lookup[nil].terminates, params)
         end
       elsif next_part = @lookup[part]
         next_part.find(request, path, params)
@@ -120,16 +96,14 @@ class Usher
           next_part.value.valid!(part)
           case next_part.value.type
           when :*
-            params << [next_part.value.name, []]
-            params.last.last << part
+            params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
+            params.last.last << part unless part.is_a?(Symbol)
+            find(request, path, params)
           when :':'
             params << [next_part.value.name, part]
+            next_part.find(request, path, params)
           end
         end
-        next_part.find(request, path, params)
-      elsif has_globber? && p = find_parent{|p| p.value.is_a?(Route::Variable) && p.value.type == :*}
-        params.last.last << part
-        find(request, path, params)
       else
         nil
       end

data/lib/usher/route/request_method.rb

@@ -14,8 +14,9 @@ class Usher
       end
       
       def eql?(o)
-        o.is_a?(Http) && o.type == type && o.value == value
+        o.is_a?(self.class) && o.type == type && o.value == value
       end
+      alias == eql?
     end
   end
 end

data/spec/generate_spec.rb

@@ -80,9 +80,18 @@ describe "Usher URL generation" do
     proc {route_set.generate_url(route_set.add_route('/:controller/:action').primary_path, {:controller => 'controller'})}.should raise_error Usher::MissingParameterException
   end
 
+  it "should generate from a route" do
+    route_set.generate_url(route_set.add_route('/:controller/:action'), {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+  end
+
   it "should require all the parameters (array) to generate a route" do
     route_set.add_named_route(:name, '/:controller/:action.:format')
     proc {route_set.generate_url(:name, ['controller', 'action'])}.should raise_error Usher::MissingParameterException
   end
 
+  it "should generate a route when only one parameter is given" do
+    route_set.add_named_route(:name, '/:controller')
+    route_set.generate_url(:name, 'controller').should == '/controller'
+  end
+
 end

data/spec/grapher_spec.rb

@@ -19,6 +19,11 @@ describe "Usher grapher" do
     route_set.generate_url(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
   end
 
+  it "should fail to generate a route when none matches" do
+    route_set.add_route('/:a/:b')
+    proc {route_set.generate_url(nil, {:c => 'C', :d => 'D'}) }.should raise_error Usher::UnrecognizedException
+  end
+
   it "should find the most specific route and append extra parts on as a query string" do
     route_set.add_route('/:a/:b/:c')
     route_set.add_route('/:a/:b')

data/spec/path_spec.rb

@@ -36,4 +36,33 @@ describe "Usher route adding" do
     route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
   end
 
+  it "should calculate depths for nodes" do
+    route_set.add_named_route(:route, '/bad/route/three/four')
+    route_set.tree.depth.should == 0
+    route_set.tree.lookup[:/].depth.should == 1
+  end
+
+  it "should pp for nodes" do
+    route_set.add_named_route(:route, '/bad/route/three/four')
+    route_set.tree.depth.should == 0
+    old_out = $stdout
+    $stdout = (output = StringIO.new)
+    route_set.tree.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
+
 end

data/spec/recognize_spec.rb

@@ -35,6 +35,11 @@ describe "Usher route recognition" do
     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']])
   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']]]
+  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']])
@@ -72,11 +77,26 @@ describe "Usher route recognition" do
     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'})
+    
+    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
+  
   it "should use a transformer (proc) on incoming variables" do
     route_set.add_route('/:controller/:action/:id', :transformers => {:id => proc{|v| v.to_i}})
     route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'})).params.rassoc(123).first.should == :id
   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
+  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

data/spec/request_method_spec.rb

@@ -0,0 +1,15 @@
+require 'lib/usher'
+
+describe "Usher request method" do
+
+  it "support eql? and ==" do
+    Usher::Route::RequestMethod.new(:method, 'blah').should == Usher::Route::RequestMethod.new(:method, 'blah')
+    Usher::Route::RequestMethod.new(:method, 'blah').should.eql?(Usher::Route::RequestMethod.new(:method, 'blah'))
+  end
+
+  it "support hash" do
+    Usher::Route::RequestMethod.new(:method, 'blah').hash.should == (Usher::Route::RequestMethod.new(:method, 'blah')).hash
+  end
+
+
+end

data/spec/split_spec.rb

@@ -53,5 +53,15 @@ describe "Usher route tokenizing" do
       [:/, "test", :/, "this", :/, "split", '.', Usher::Route::Variable.new(:':', :format)]
     ]
   end
+
+  it "should to_s all different variable types" do
+    Usher::Splitter.for_delimiters(['/', '.']).split('/:split/*splitter').first.collect{|v| v.to_s} == 
+      [ ':split', '*splitter' ]
+  end
+  
+  it "should == variable types" do
+    parts = Usher::Splitter.for_delimiters(['/', '.']).split('/:split/:split').first
+    parts[1].should == parts[3]
+  end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-06 00:00:00 -07:00
+date: 2009-04-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -68,6 +68,7 @@ files:
 - spec/rails/path_spec.rb
 - spec/rails/recognize_spec.rb
 - spec/recognize_spec.rb
+- spec/request_method_spec.rb
 - spec/spec.opts
 - spec/split_spec.rb
 - rails/init.rb