usher 0.5.13 → 0.6.0

data/lib/usher/route/path.rb

@@ -42,8 +42,17 @@ class Usher
         @dynamic
       end
 
-      def can_generate_from?(keys)
-        (dynamic_required_keys - keys).size.zero?
+      def can_generate_from_keys?(keys)
+        if dynamic?
+          (dynamic_required_keys - keys).size.zero? ? keys : nil
+        end
+      end
+      
+      def can_generate_from_params?(params)
+        if route.router.consider_destination_keys?
+          route.destination.to_a - params.to_a
+          (route.destination.to_a - params.to_a).size.zero?
+        end
       end
       
       # Merges paths for use in generation

data/lib/usher/route/static.rb

@@ -1,7 +1,7 @@
 class Usher
   class Route
     class Static
-      class Greedy < String
+      class Greedy < Regexp
         
       end
     end

data/lib/usher/util/generate.rb

@@ -117,9 +117,11 @@ class Usher
             params.merge!(extra_params) if extra_params
           end
           
-          
           result = Rack::Utils.uri_escape(generate_path_for_base_params(path, params))
           unless !generate_extra || params.nil? || params.empty?
+            if usher.consider_destination_keys? && path.route.destination_keys
+              params.delete_if{|k, v| path.route.destination_keys.include?(k)}
+            end
             extra_params = generate_extra_params(params, result[??])
             result << extra_params
           end
@@ -144,8 +146,8 @@ class Usher
 
             @generation_module.module_eval <<-END_EVAL
               def respond_to?(method_name)
-                if match = Regexp.new('^(.*?)_(path|url)$').match(method_name.to_s)
-                  @@generator.usher.named_routes.key?(match.group(1))
+                if method_name =~ /^(.*?)_(path|url)$/
+                  @@generator.usher.named_routes.key?($1)
                 else
                   super
                 end
@@ -184,7 +186,7 @@ class Usher
           (url[-1] == ?/) ? url[0..-2] : url
         end
 
-        def path_for_routing_lookup(routing_lookup, params = {})                    
+        def path_for_routing_lookup(routing_lookup, params = {})
           path = case routing_lookup
           when Symbol
             route = @usher.named_routes[routing_lookup]

data/lib/usher/util/parser.rb

@@ -4,170 +4,161 @@ class Usher
   module Util
     class Parser
 
+      attr_reader :router
+
       def self.for_delimiters(router, valid_regex)
-        ParserInstance.new(
+        new(
           router,
           Regexp.new('((:|\*)?' + valid_regex + '|' + router.delimiters_regex + '|\(|\)|\||\{)')
         )
       end
 
-      class ParserInstance
-        def initialize(router, split_regex)
-          @router = router
-          @split_regex = split_regex
-          @delimiters_regex = Regexp.new(router.delimiters_regex)
-        end
+      def initialize(router, split_regex)
+        @router = router
+        @split_regex = split_regex
+        @delimiters_regex = Regexp.new(router.delimiters_regex)
+      end
 
-        def generate_route(unprocessed_path, conditions, requirements, default_values, generate_with, priority)
-          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
+      def generate_route(unprocessed_path, conditions, requirements, default_values, generate_with, priority)
+        match_partially = false
+        case unprocessed_path
+        when String
+          if unprocessed_path[-1] == ?*
+            unprocessed_path.slice!(-1)
+            match_partially = true
           end
+          unprocessed_path = parse(unprocessed_path, requirements, default_values)
+        when Regexp
+          unprocessed_path = [Route::Static::Greedy.new(unprocessed_path)]
+        else
+          match_partially = 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 = Route::Util.expand_path(unprocessed_path)
-
-          paths.map! do |path|
-            if path.all?{|part| String === part}
-              path #parse "{~#{path.join}}"
-            else
-              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
-                  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.delimiters.unescaped.include?(p)} || nil
-                  end
-                when Usher::Route::Variable
-                  if part.look_ahead && !part.look_ahead_priority
-                    part.look_ahead = nil
-                    part.look_ahead_priority = true
-                  else
-                    part.look_ahead = router.delimiters.first_in(path[index + 1, path.size]) || router.delimiters.unescaped.first
-                  end
-                end
+        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
+              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.delimiters.unescaped.include?(p)} || nil
+              end
+            when Usher::Route::Variable
+              if part.look_ahead && !part.look_ahead_priority
+                part.look_ahead = nil
+                part.look_ahead_priority = true
+              else
+                part.look_ahead = router.delimiters.first_in(path[index + 1, path.size]) || router.delimiters.unescaped.first
               end
-              path
             end
           end
-
-          Route.new(
-            paths,
-            router, 
-            conditions, 
-            requirements, 
-            default_values, 
-            generate_with,
-            match_partially,
-            priority
-          )
-          
         end
 
-        def parse_and_expand(path, requirements = nil, default_values = nil)
-          Usher::Route::Util.expand_path(parse(path, requirements, default_values))
-        end
+        Route.new(
+          paths,
+          router, 
+          conditions, 
+          requirements, 
+          default_values, 
+          generate_with,
+          match_partially,
+          priority
+        )
+      end
 
-        def parse(path, requirements = nil, default_values = nil)
-          parts = Usher::Route::Util::Group.new(:all, nil)
-          scanner = StringScanner.new(path)
+      def parse_and_expand(path, requirements = nil, default_values = nil)
+        Usher::Route::Util.expand_path(parse(path, requirements, default_values))
+      end
 
-          current_group = parts
-          part = nil
-          while !scanner.eos?
-            part ?
-              (part << scanner.scan(@split_regex)) :
-              (part = scanner.scan(@split_regex))
+      def parse(path, requirements = nil, default_values = nil)
+        parts = Usher::Route::Util::Group.new(:all, nil)
+        scanner = StringScanner.new(path)
 
-            if scanner.match?(/\\/) and !scanner.match?(@delimiters_regex)
-              scanner.skip(/\\/)
-              part << scanner.getch
-              next
-            end
+        current_group = parts
+        part = nil
+        while !scanner.eos?
+          part ?
+            (part << scanner.scan(@split_regex)) :
+            (part = scanner.scan(@split_regex))
 
-            case part[0]
-            when ?*
-              var_name = part[1, part.size - 1].to_sym
-              current_group << Usher::Route::Variable::Glob.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
-            when ?:
-              var_name = part[1, part.size - 1].to_sym
-              current_group << Usher::Route::Variable::Single.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
-            when ?{
-              pattern = ''
-              count = 1
-              simple = scanner.scan(/~/)
-              variable = scanner.scan(/[!:\*]([^,]+),/)
-              until count.zero?
-                regex_part = scanner.scan(/\{|\}|[^\{\}]+/)
-                case regex_part[0]
-                when ?{
-                  count += 1
-                when ?}
-                  count -= 1
-                end
-                pattern << regex_part
-              end
-              pattern.slice!(pattern.length - 1)
-              regex = Regexp.new(pattern)
-              if variable
-                variable_type = variable.slice!(0).chr.to_sym
-                variable_class = case variable_type
-                when :'!' then Usher::Route::Variable::Greedy
-                when :*   then Usher::Route::Variable::Glob
-                when :':' then Usher::Route::Variable::Single
-                end
-                variable_name = variable[0, variable.size - 1].to_sym
-                current_group << variable_class.new(variable_name, regex, requirements && requirements[variable_name])
-              elsif simple
-                current_group << Usher::Route::Static::Greedy.new(pattern)
-              else
-                current_group << regex
+          if scanner.match?(/\\/) and !scanner.match?(@delimiters_regex)
+            scanner.skip(/\\/)
+            part << scanner.getch
+            next
+          end
+
+          case part[0]
+          when ?*
+            var_name = part[1, part.size - 1].to_sym
+            current_group << Usher::Route::Variable::Glob.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
+          when ?:
+            var_name = part[1, part.size - 1].to_sym
+            current_group << Usher::Route::Variable::Single.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
+          when ?{
+            pattern = ''
+            count = 1
+            simple = scanner.scan(/~/)
+            variable = scanner.scan(/[!:\*]([^,]+),/)
+            until count.zero?
+              regex_part = scanner.scan(/\{|\}|[^\{\}]+/)
+              case regex_part[0]
+              when ?{
+                count += 1
+              when ?}
+                count -= 1
               end
-            when ?(
-              new_group = Usher::Route::Util::Group.new(:any, current_group)
-              current_group << new_group
-              current_group = new_group
-            when ?)
-              current_group = current_group.parent.group_type == :one ? current_group.parent.parent : current_group.parent
-            when ?|
-              unless current_group.parent.group_type == :one
-                detached_group = current_group.parent.pop
-                new_group = Usher::Route::Util::Group.new(:one, detached_group.parent)
-                detached_group.parent = new_group
-                detached_group.group_type = :all
-                new_group << detached_group
-                new_group.parent << new_group
+              pattern << regex_part
+            end
+            pattern.slice!(pattern.length - 1)
+            regex = Regexp.new(pattern)
+            if variable
+              variable_type = variable.slice!(0).chr.to_sym
+              variable_class = case variable_type
+              when :'!' then Usher::Route::Variable::Greedy
+              when :*   then Usher::Route::Variable::Glob
+              when :':' then Usher::Route::Variable::Single
               end
-              current_group.parent << Usher::Route::Util::Group.new(:all, current_group.parent)
-              current_group = current_group.parent.last
-            when ?\\
-              current_group << part[1..-1]
+              variable_name = variable[0, variable.size - 1].to_sym
+              current_group << variable_class.new(variable_name, regex, requirements && requirements[variable_name])
+            elsif simple
+              current_group << Usher::Route::Static::Greedy.new(Regexp.new(pattern))
             else
-              current_group << part
+              current_group << regex
             end
-            part = nil
-          end unless !path || path.empty?
-          parts
-        end
-
-      private
-
-        attr_reader :router
+          when ?(
+            new_group = Usher::Route::Util::Group.new(:any, current_group)
+            current_group << new_group
+            current_group = new_group
+          when ?)
+            current_group = current_group.parent.group_type == :one ? current_group.parent.parent : current_group.parent
+          when ?|
+            unless current_group.parent.group_type == :one
+              detached_group = current_group.parent.pop
+              new_group = Usher::Route::Util::Group.new(:one, detached_group.parent)
+              detached_group.parent = new_group
+              detached_group.group_type = :all
+              new_group << detached_group
+              new_group.parent << new_group
+            end
+            current_group.parent << Usher::Route::Util::Group.new(:all, current_group.parent)
+            current_group = current_group.parent.last
+          when ?\\
+            current_group << part[1..-1]
+          else
+            current_group << part
+          end
+          part = nil
+        end unless !path || path.empty?
+        parts
       end
     end
   end

data/spec/private/delimiters_spec.rb

@@ -1,17 +1,17 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
 require 'usher'
 
-describe Delimiters do
+describe Usher::Delimiters do
   describe "#unescaped" do
     it "should unescape delimiters correctly" do
-      Delimiters.new(['/', '\)', '\\\\']).unescaped.should == ['/', ')', '\\']
+      Usher::Delimiters.new(['/', '\)', '\\\\']).unescaped.should == ['/', ')', '\\']
     end
   end
 
   describe "#first_in" do
     describe "when there is a complex path with a lot of delimiters occurrences" do
       before :each do
-        @delimiters = Delimiters.new ['@', '.', '/']
+        @delimiters = Usher::Delimiters.new ['@', '.', '/']
         @paths = ['var', '.', 'var', '/', 'var', '@']
       end
 
@@ -24,7 +24,7 @@ describe Delimiters do
 
     describe "when there are delimiters with escaped charaters" do
       before :each do
-        @delimiters = Delimiters.new ['\\(', '\\)']
+        @delimiters = Usher::Delimiters.new ['\\(', '\\)']
         @paths = ['var', '(', 'var', ')']
       end
 
@@ -35,7 +35,7 @@ describe Delimiters do
 
     describe "when there is no occurence of delimiters in path" do
       before :each do
-        @delimiters = Delimiters.new ['-', '/']
+        @delimiters = Usher::Delimiters.new ['-', '/']
         @paths = ['e', '@', 'ma', '.', 'il']
       end
 

data/spec/private/destination_spec.rb

@@ -0,0 +1,32 @@
+describe "a route destination" do
+  before(:each) do
+    @u = Usher.new
+  end
+
+  it "should return a compound with given var args" do
+    r = @u.add_route('/testsauce').to(:one, :two, :three, :four)
+    r.destination.args.should  == [:one, :two, :three, :four]
+  end
+  
+  it "should return a compound with given var args and a hash on the end" do
+    r = @u.add_route('/testsauce').to(:one, :two, :three, :four, :five => 'six', :seven => 'heaven')
+    r.destination.args.should  == [:one, :two, :three, :four]
+    r.destination.options.should  == {:five => 'six', :seven => 'heaven'}
+  end
+
+  it "should never wrap it in a compound if its a simple hash" do
+    r = @u.add_route('/testsauce').to(:five => 'six', :seven => 'heaven')
+    r.destination.should  == {:five => 'six', :seven => 'heaven'}
+  end
+
+  it "should never wrap it in a compound if its a simple object" do
+    r = @u.add_route('/testsauce').to(:eighteen)
+    r.destination.should  == :eighteen
+  end
+
+  it "should never wrap it in a compound if its a simple block" do
+    p = proc{ puts 'lovetown' }
+    r = @u.add_route('/testsauce').to(&p)
+    r.destination.should == p
+  end
+end

data/spec/private/generate_spec.rb

@@ -142,6 +142,21 @@ describe "Usher URL generation" do
     @route_set.generator.generate(:default_values_not_in_path, {:controller => "foo"}).should == '/foo?page=1'
   end
 
+  describe "with consider_destination_keys enabled" do
+    
+    before(:each) do
+      @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new, :consider_destination_keys => true)
+      @route_set.reset!
+    end
+
+    it "should generate direct unnamed paths" do
+      @route_set.add_route('/profiles', :controller => 'profiles', :action => 'edit')
+      @route_set.add_route('/users', :controller => 'users', :action => 'index')
+      @route_set.generator.generate(nil, :controller => 'profiles', :action => 'edit').should == '/profiles'
+      @route_set.generator.generate(nil, :controller => 'users', :action => 'index').should == '/users'
+    end
+  end
+
   describe "when named route was added with string key" do
     before :each do
       @route_set.add_named_route 'items', '/items', :controller => 'items', :action => 'index'
@@ -258,6 +273,19 @@ describe "Usher URL generation" do
     end
   end
 
+  describe "#path_for_routing_lookup" do
+    describe "when direct route exists" do
+      before :each do
+        @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new, :consider_destination_keys => true)
+        @route = @route_set.add_named_route(:direct_path, '/some-neat-name', :controller => 'foo', :action => 'bar')
+      end
+
+      it "should return exactly this route" do
+        @route_set.generator.path_for_routing_lookup(nil, :controller => 'foo', :action => 'bar').should == @route.paths.first
+      end
+    end
+  end
+
   describe "nested generation" do
     before do
       @route_set2 = Usher.new(:generator => Usher::Util::Generators::URL.new)