joshbuddy-usher 0.5.1 → 0.5.2

data/lib/usher/util/parser.rb

@@ -18,6 +18,52 @@ class Usher
           @split_regex = split_regex
         end
 
+        def generate_route(unprocessed_path, conditions, requirements, default_values, generate_with)
+          match_partially = if unprocessed_path.is_a?(String)
+            unprocessed_path = parse(unprocessed_path, requirements, default_values)
+            if unprocessed_path[-1] == ?*
+              unprocessed_path.slice!(-1)
+              true
+            else
+              false
+            end
+          else
+            false
+          end
+          
+          unless unprocessed_path.first.is_a?(Route::Util::Group)
+            group = Usher::Route::Util::Group.new(:all, nil)
+            unprocessed_path.each{|p| group << p}
+            unprocessed_path = group
+          end
+
+          paths = Route::Util.expand_path(unprocessed_path)
+
+          paths.each do |path|
+            path.each_with_index do |part, index|
+              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
+              when Usher::Route::Variable
+                part.look_ahead = path[index + 1, path.size].find{|p| router.delimiter_chars.include?(p[0])} || router.delimiters.first
+              end
+            end
+          end
+
+          Route.new(
+            paths,
+            router, 
+            conditions, 
+            requirements, 
+            default_values, 
+            generate_with,
+            match_partially
+          )
+          
+        end
+
+
         def parse_and_expand(path, requirements = nil, default_values = nil)
           Usher::Route::Util.expand_path(parse(path, requirements, default_values))
         end
@@ -88,7 +134,11 @@ class Usher
           parts
         end
 
+        private
+        attr_reader :router
+
       end
+      
 
     end
   end

data/spec/private/generate_spec.rb

@@ -4,138 +4,192 @@ require 'rack'
 describe "Usher URL generation" do
   
   before(:each) do
-    @route_set = Usher.new
+    @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new)
     @route_set.reset!
-    @url_generator = Usher::Util::Generators::URL.new(@route_set)
   end
   
   it "should generate a simple URL" do
     @route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'action')
-    @url_generator.generate(:sample, {}).should == '/sample'
+    @route_set.generator.generate(:sample, {}).should == '/sample'
   end
   
   it "should generate a simple URL with a single variable" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action'}).should == '/sample/action'
+    @route_set.generator.generate(:sample, {:action => 'action'}).should == '/sample/action'
   end
   
   it "should generate a simple URL with a single variable (and escape)" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action time'}).should == '/sample/action%20time'
+    @route_set.generator.generate(:sample, {:action => 'action time'}).should == '/sample/action%20time'
   end
   
   it "should generate a simple URL with a single variable (thats not a string)" do
     @route_set.add_named_route(:sample, '/sample/:action/:id', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
+    @route_set.generator.generate(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
   end
   
   it "should generate a simple URL with a glob variable" do
     @route_set.add_named_route(:sample, '/sample/*action', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
+    @route_set.generator.generate(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
   end
   
   it "should generate a mutliple vairable URL from a hash" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
+    @route_set.generator.generate(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
   end
 
   it "should generate a mutliple vairable URL from an array" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
+    @route_set.generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
   end
 
   it "should generate append extra hash variables to the end" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => 'zanz'}).should == '/sample/maz/zoo?third=zanz'
+    @route_set.generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => 'zanz'}).should == '/sample/maz/zoo?third=zanz'
   end
 
   it "should generate append extra hash variables to the end (when the first parts are an array)" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    ['/sample/maz/zoo?four=jane&third=zanz', '/sample/maz/zoo?third=zanz&four=jane'].include?(@url_generator.generate(:sample, ['maz', 'zoo', {:third => 'zanz', :four => 'jane'}])).should == true
+    ['/sample/maz/zoo?four=jane&third=zanz', '/sample/maz/zoo?third=zanz&four=jane'].include?(@route_set.generator.generate(:sample, ['maz', 'zoo', {:third => 'zanz', :four => 'jane'}])).should == true
   end
 
   it "should generate append extra hash variables to the end using [] syntax if its an array" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => ['zanz', 'susie']}).should == '/sample/maz/zoo?third%5B%5D=zanz&third%5B%5D=susie'
+    @route_set.generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => ['zanz', 'susie']}).should == '/sample/maz/zoo?third%5B%5D=zanz&third%5B%5D=susie'
   end
 
   it "should generate a mutliple vairable URL from an array" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
+    @route_set.generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
   end
 
   it "should generate a simple URL with a format" do
     @route_set.add_named_route(:sample, '/sample/:action.:format', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action', :format => 'html'}).should == '/sample/action.html'
+    @route_set.generator.generate(:sample, {:action => 'action', :format => 'html'}).should == '/sample/action.html'
   end
 
   it "should generate from parameters" do
     caf = @route_set.add_route('/:controller/:action.:format')
     ca = @route_set.add_route('/:controller/:action')
-    @url_generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
-    @url_generator.generate(nil, {:controller => 'controller', :action => 'action', :format => 'html'}).should == '/controller/action.html'
+    @route_set.generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(nil, {:controller => 'controller', :action => 'action', :format => 'html'}).should == '/controller/action.html'
   end
 
   it "should use the first route when generating a URL from two ambiguous routes" do
     @route_set.add_route('/:controller/:action')
     @route_set.add_route('/:action/:controller')
-    @url_generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
   end
 
   it "should accept an array of parameters" do
     caf = @route_set.add_named_route(:name, '/:controller/:action.:format')
-    @url_generator.generate(:name, ['controller', 'action', 'html']).should == '/controller/action.html'
+    @route_set.generator.generate(:name, ['controller', 'action', 'html']).should == '/controller/action.html'
   end
 
   it "should generate a route with a specific host" do
     caf = @route_set.add_named_route(:name, '/:controller/:action.:format', :generate_with => {:host => 'www.slashdot.org', :port => 80})
-    @url_generator.generate_full(:name, Rack::Request.new(Rack::MockRequest.env_for("http://localhost:8080")), ['controller', 'action', 'html']).should == 'http://www.slashdot.org/controller/action.html'
+    @route_set.generator.generate_full(:name, Rack::Request.new(Rack::MockRequest.env_for("http://localhost:8080")), ['controller', 'action', 'html']).should == 'http://www.slashdot.org/controller/action.html'
   end
 
   it "should require all the parameters (hash) to generate a route" do
-    proc {@url_generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller'})}.should raise_error Usher::MissingParameterException
+    proc{@route_set.generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller'})}.should raise_error(Usher::MissingParameterException)
   end
 
   it "should generate from a route" do
-    @url_generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(@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 {@url_generator.generate(:name, ['controller', 'action'])}.should raise_error Usher::MissingParameterException
+    proc {@route_set.generator.generate(: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')
-    @url_generator.generate(:name, 'controller').should == '/controller'
+    @route_set.generator.generate(:name, 'controller').should == '/controller'
   end
 
   it "should generate the correct route from a route containing optional parts" do
     @route_set.add_named_route(:name, '/:controller(/:action(/:id))')
-    @url_generator.generate(:name, {:controller => 'controller'}).should == '/controller'
-    @url_generator.generate(:name, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
-    @url_generator.generate(:name, {:controller => 'controller', :action => 'action', :id => 'id'}).should == '/controller/action/id'
+    @route_set.generator.generate(:name, {:controller => 'controller'}).should == '/controller'
+    @route_set.generator.generate(:name, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(:name, {:controller => 'controller', :action => 'action', :id => 'id'}).should == '/controller/action/id'
   end
 
   it "should generate a route using defaults for everything but the first parameter" do
     @route_set.add_named_route(:name, '/:one/:two/:three', {:default_values => {:one => 'one', :two => 'two', :three => 'three'}})
-    @url_generator.generate(:name, {:one => "1"}).should == '/1/two/three'
+    @route_set.generator.generate(:name, {:one => "1"}).should == '/1/two/three'
   end
 
   it "should generate a route using defaults for everything" do
     @route_set.add_named_route(:name, '/:one/:two/:three', {:default_values => {:one => 'one', :two => 'two', :three => 'three'}})
-    @url_generator.generate(:name).should == '/one/two/three'
+    @route_set.generator.generate(:name).should == '/one/two/three'
   end
   
   it "should generate a route using defaults and optionals using the last parameter" do
     @route_set.add_named_route(:opts_with_defaults, '/:one(/:two(/:three))', {:default_values => {:one => '1', :two => '2', :three => '3'}})
-    @url_generator.generate(:opts_with_defaults, {:three => 'three'}).should == '/1/2/three'
+    @route_set.generator.generate(:opts_with_defaults, {:three => 'three'}).should == '/1/2/three'
   end
 
   it "should generate a route with optional segments given two nested optional parameters" do
     @route_set.add_named_route(:optionals, '/:controller(/:action(/:id))(.:format)')
-    @url_generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
+    @route_set.generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
+  end
+  
+  describe "nested generation" do
+    before do
+      @route_set2 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @route_set3 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @route_set4 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      
+      @route_set.add_named_route(:simple,   "/mount_point").match_partially!.to(@route_set2)
+      @route_set.add_route("/third/:foo", :default_values => {:foo => "foo"}).match_partially!.to(@route_set3)
+      @route_set.add_route("/fourth/:bar").match_partially!.to(@route_set4)
+      
+      @route_set2.add_named_route(:nested_simple,   "/nested/simple",     :controller => "nested",  :action => "simple")
+      @route_set2.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
+      
+      @route_set3.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
+      @route_set3.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
+      
+      @route_set4.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
+    end
+    
+    it "should generate a route for the simple nested route" do
+      @route_set2.generator.generate(:nested_simple).should == "/mount_point/nested/simple"
+    end
+    
+    it "should generate a simple route without optional segments" do
+      @route_set2.generator.generate(:nested_complex).should == "/mount_point/another_nested"
+    end
+    
+    it "should generate a route with optional segements" do
+      @route_set2.generator.generate(:nested_complex, :complex => "foo").should == "/mount_point/another_nested/foo"
+    end
+    
+    it "should genearte a route with the specified value for the parent route" do
+      @route_set3.generator.generate(:nested_simple, :foo => "bar").should == "/third/bar/nested/simple"
+    end
+    
+    it "should generate a route with the default value from the parent route" do
+      @route_set3.generator.generate(:nested_simple).should == "/third/foo/nested/simple"
+    end
+    
+    it "should generate a route with an optional segement in the parent and child" do
+      @route_set3.generator.generate(:nested_complex, :complex => "complex").should == "/third/foo/another_nested/complex"
+    end
+    
+    it "should generate a route without the optional value from the child" do
+      @route_set3.generator.generate(:nested_complex).should == "/third/foo/another_nested"
+    end
+    
+    it "should raise an exception when trying to generate a route where the parent variable is not defined and does not have a default value" do
+      lambda do
+        @route_set4.generator.generate(:nested_simple)
+      end.should raise_error(Usher::MissingParameterException)
+    end
+    
+    
+    
   end
-
-
 end

data/spec/private/grapher_spec.rb

@@ -4,31 +4,30 @@ require 'lib/usher'
 describe "Usher grapher" do
 
   before(:each) do
-    @route_set = Usher.new
+    @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new)
     @route_set.reset!
-    @url_generator = Usher::Util::Generators::URL.new(@route_set)
   end
 
   it "should find a simple path" do
     @route_set.add_route('/:a/:b/:c')
-    @url_generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
+    @route_set.generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
   end
 
   it "should pick a more specific route" do
     @route_set.add_route('/:a/:b')
     @route_set.add_route('/:a/:b/:c')
-    @url_generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
+    @route_set.generator.generate(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 {@url_generator.generate(nil, {:c => 'C', :d => 'D'}) }.should raise_error Usher::UnrecognizedException
+    proc {@route_set.generator.generate(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')
-    @url_generator.generate(nil, {:a => 'A', :b => 'B', :d => 'C'}).should == '/A/B?d=C'
+    @route_set.generator.generate(nil, {:a => 'A', :b => 'B', :d => 'C'}).should == '/A/B?d=C'
   end
   
   # FIXME

data/spec/private/path_spec.rb

@@ -36,18 +36,27 @@ describe "Usher route adding" do
     route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
   end
 
+  it "should allow named routes to be added" do
+    route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
+    route_set.route_count.should == 1
+    route_set.named_routes.size == 1
+    route_set.delete_named_route(:route, '/bad/route', :controller => 'sample')
+    route_set.route_count.should == 0
+    route_set.named_routes.size == 0
+  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
+    route_set.root.depth.should == 0
+    route_set.root.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
+    route_set.root.depth.should == 0
     old_out = $stdout
     $stdout = (output = StringIO.new)
-    route_set.tree.lookup['/'].lookup['bad'].lookup['/'].pp
+    route_set.root.lookup['/'].lookup['bad'].lookup['/'].pp
     $stdout = old_out
     output.rewind
     output.read.should == <<-HEREDOC
@@ -64,5 +73,27 @@ describe "Usher route adding" do
         8: "four" true
     HEREDOC
   end
+  
+  describe "merging paths" do
+    before do
+      @r1 = route_set.add_route("/foo/bar")
+      @r2 = route_set.add_route("/other(/:baz)")
+      @p1 = @r1.paths.first
+      @p2 = @r2.paths.first
+    end
+    
+    it "should craete a new path object" do
+      @p1.merge(@p2).should_not eql(@p1)
+    end
+    
+    it "should mash the parts together" do
+      @p1.merge(@p2).parts.should == (@p1.parts + @p2.parts).flatten
+    end
+    
+    it "should maintain the route owner" do
+      @p1.merge(@p2).route.should == @p1.route
+    end
+    
+  end
 
 end

data/spec/private/rack/dispatch_spec.rb

@@ -1,29 +1,114 @@
 require 'lib/usher'
-
 require 'rack'
 
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
 route_set = Usher::Interface.for(:rack)
+route_set.extend(CallWithMockRequestMixin)
 
 describe "Usher (for rack) route dispatching" do
-
   before(:each) do
     route_set.reset!
+    @app = MockApp.new("Hello World!")
+    route_set.add('/sample').to(@app)
   end
 
-  it "should dispatch a simple request" do
-    app = mock 'app'
-    app.should_receive(:call).once.with {|v| v['usher.params'].should == {} }
-    route_set.add('/sample').to(app)
-    route_set.call(Rack::MockRequest.env_for("/sample", :method => 'GET'))
+  describe "HTTP GET" do
+    it "should dispatch a request" do
+      response = route_set.call_with_mock_request
+      response.body.should eql("Hello World!")
+    end
+
+    it "should write usher.params" do
+      response = route_set.call_with_mock_request
+      @app.env["usher.params"].should == {}
+    end
   end
-  
-  it "should dispatch a POST request" do
-    bad_app = mock 'bad_app'
-    app = mock 'app'
-    app.should_receive(:call).once.with {|v| v['usher.params'].should == {} }
-    route_set.add('/sample').to(bad_app)
-    route_set.add('/sample', :requirements => {:request_method => 'POST'}).to(app)
-    route_set.call(Rack::MockRequest.env_for("/sample", :request_method => 'POST'))
+
+  describe "HTTP POST" do
+    before(:each) do
+      bad_app = MockApp.new("You shouldn't get here if you are using POST")
+      route_set.add('/sample').to(bad_app)
+      route_set.add('/sample', :requirements => {:request_method => 'POST'}).to(@app)
+    end
+
+    it "should dispatch a request" do
+      response = route_set.call_with_mock_request
+      response.body.should eql("Hello World!")
+    end
+
+    it "should write usher.params" do
+      response = route_set.call_with_mock_request("/sample", :request_method => 'POST')
+      @app.env["usher.params"].should == {}
+    end
+  end
+
+  it "should returns HTTP 404 if route doesn't exist" do
+    response = route_set.call_with_mock_request("/not-existing-url")
+    response.status.should eql(404)
   end
   
+  describe "mounted rack instances" do
+    before do
+      @bad_app = mock("bad_app")
+      
+      @usher2 = Usher::Interface.for(:rack)
+      @usher2.add("/good" ).to(@app)
+      @usher2.add("/bad"  ).match_partially!.to(@bad_app)
+      @usher2.add("/some(/:foo)").to(@app)
+      
+      route_set.add("/foo/:bar", :default_values => {:foo => "foo"}).match_partially!.to(@usher2)
+      route_set.add("/foo", :default_values => {:controller => :foo}).to(@app)
+    end
+    
+    it "should match the route without nesting" do
+      @app.should_receive(:call).once.with{ |e| e['usher.params'].should == {:controller => :foo}}
+      route_set.call(Rack::MockRequest.env_for("/foo"))
+    end
+    
+    it "should route through the first route, and the second to the app" do
+      @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "foo"}}
+      result = route_set.call(Rack::MockRequest.env_for("/foo/bar/good"))
+    end
+    
+    it "should go through to the bad app" do
+      @bad_app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "some_bar", :foo => "foo"}}
+      result = route_set.call(Rack::MockRequest.env_for("/foo/some_bar/bad"))
+    end
+    
+    it "should match optional routes paramters" do
+      @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "a_different_foo"}}
+      route_set.call(Rack::MockRequest.env_for("/foo/bar/some/a_different_foo"))
+    end
+    
+    describe "SCRIPT_NAME & PATH_INFO" do
+      it "should update the script name for a fully consumed route" do
+        @app.should_receive(:call).once.with do |e|
+          e['SCRIPT_NAME'].should == "/foo"
+          e['PATH_INFO'].should   == ""
+        end
+        route_set.call(Rack::MockRequest.env_for("/foo"))
+      end
+      
+      it "should update the script name and path info for a partially consumed route" do
+        @app.should_receive(:call).once.with do |e|
+          e['SCRIPT_NAME'].should == "/partial"
+          e['PATH_INFO'].should   == "/bar/baz"
+        end
+        
+        route_set.add("/partial").match_partially!.to(@app)
+        route_set.call(Rack::MockRequest.env_for("/partial/bar/baz"))
+      end
+      
+      it "should consume the path through a mounted usher" do
+        @bad_app.should_receive(:call).once.with do |e|
+          e['SCRIPT_NAME'].should == "/foo/bar/bad"
+          e['PATH_INFO'].should   == "/leftovers"
+        end
+        
+        route_set.call(Rack::MockRequest.env_for("/foo/bar/bad/leftovers"))
+      end
+      
+    end
+    
+  end
 end