usher 0.6.2 → 0.6.3

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
+:patch: 3
 :build: 
-:patch: 2
 :major: 0
 :minor: 6

data/lib/usher/exceptions.rb

@@ -2,4 +2,5 @@ class Usher
   class UnrecognizedException < RuntimeError; end
   class ValidationException < RuntimeError; end
   class MissingParameterException < RuntimeError; end
+  class MultipleParameterException < RuntimeError; end
 end

data/lib/usher/interface/rack.rb

@@ -57,7 +57,7 @@ class Usher
 
       def initialize(app = nil, options = nil, &blk)
         @_app = app || lambda { |env| ::Rack::Response.new("No route found", 404).finish }
-        @router = Usher.new(:request_methods => [:request_method, :host, :port, :scheme], :generator => Usher::Util::Generators::URL.new)
+        @router = Usher.new(:request_methods => [:request_method, :host, :port, :scheme], :generator => Usher::Util::Generators::URL.new, :allow_identical_variable_names => false)
         @use_destinations = options && options.key?(:use_destinations) ? options[:use_destinations] : true
         instance_eval(&blk) if blk
       end

data/lib/usher/node.rb

@@ -122,14 +122,14 @@ class Usher
     def find(usher, request_object, original_path, path, params = [], position = 0)
       if terminates? && (path.empty? || terminates.route.partial_match? || (usher.ignore_trailing_delimiters? && path.all?{|p| usher.delimiters.include?(p)}))
         terminates.route.partial_match? ?
-          Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position]) :
-          Response.new(terminates, params, nil, original_path)
+          Response.new(terminates, terminates.convert_params_array(params), original_path[position, original_path.size], original_path[0, position]) :
+          Response.new(terminates, terminates.convert_params_array(params), nil, original_path)
       elsif !path.empty? and greedy and match_with_result_output = greedy.match_with_result(whole_path = original_path[position, original_path.size])
 				next_path, matched_part = match_with_result_output
         position += matched_part.size
         whole_path.slice!(0, matched_part.size)
-        params << [next_path.value.name, matched_part] if next_path.value.is_a?(Route::Variable)
-        next_path.find(usher, request_object, original_path, whole_path.empty? ? whole_path : usher.splitter.url_split(whole_path), params, position)
+        params << matched_part if next_path.value.is_a?(Route::Variable)
+        next_path.find(usher, request_object, original_path, whole_path.empty? ? whole_path : usher.splitter.split(whole_path), params, position)
       elsif !path.empty? and normal and next_part = normal[path.first] || normal[nil]
         part = path.shift
         position += part.size
@@ -142,14 +142,14 @@ class Usher
           # do a validity check
           var.valid!(part)
           # because its a variable, we need to add it to the params array
-          params << [var.name, part]
+          params << part
           until path.empty? || (var.look_ahead === path.first)                # variables have a look ahead notion, 
             next_path_part = path.shift                                       # and until they are satified,
             position += next_path_part.size                                   # keep appending to the value in params
-            params.last.last << next_path_part
+            params.last << next_path_part
           end if var.look_ahead && usher.delimiters.size > 1
         when Route::Variable::Glob
-          params << [next_part.value.name, []]
+          params << []
           while true
             if (next_part.value.look_ahead === part || (!usher.delimiters.unescaped.include?(part) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
               path.unshift(part)
@@ -161,7 +161,7 @@ class Usher
               break
             elsif !usher.delimiters.unescaped.include?(part)
               next_part.value.valid!(part)
-              params.last.last << part
+              params.last << part
             end
             if path.empty?
               break

data/lib/usher/route/path.rb

@@ -9,7 +9,11 @@ class Usher
         self.route = route
         self.parts = parts
       end
-
+      
+      def convert_params_array(ary)
+        ary.empty? ? ary : dynamic_keys.zip(ary)
+      end
+      
       def dynamic_indicies
         unless dynamic? && @dynamic_indicies
           @dynamic_indicies = []
@@ -31,7 +35,7 @@ class Usher
       end
       
       def dynamic_keys
-        @dynamic_keys ||= dynamic_map.keys if dynamic?
+        @dynamic_keys ||= dynamic_parts.map{|dp| dp.name} if dynamic?
       end
       
       def dynamic_required_keys

data/lib/usher/route/variable.rb

@@ -1,6 +1,23 @@
 class Usher
   class Route
     class Variable
+
+      module ProcValidator
+        def valid!(val)
+          begin
+            @validator.call(val)
+          rescue Exception => e
+            raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
+          end
+        end
+      end
+
+      module CaseEqualsValidator
+        def valid!(val)
+          @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}"))
+        end
+      end
+      
       attr_reader :type, :name, :validator, :regex_matcher
       attr_accessor :look_ahead, :default_value, :look_ahead_priority
       
@@ -10,12 +27,12 @@ class Usher
         @regex_matcher = regex_matcher
         
         case @validator
-        when Proc
-          self.extend(ProcValidator)
         when nil
           # do nothing
+        when Proc
+          extend(ProcValidator)
         else
-          self.extend(CaseEqualsValidator)
+          extend(CaseEqualsValidator)
         end
       end
       private :initialize
@@ -23,22 +40,6 @@ class Usher
       def valid!(val)
       end
       
-      module ProcValidator
-        def valid!(val)
-          begin
-            @validator.call(val)
-          rescue Exception => e
-            raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
-          end
-        end
-      end
-
-      module CaseEqualsValidator
-        def valid!(val)
-          @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}"))
-        end
-      end
-      
       def ==(o)
         o && (o.class == self.class && o.name == @name && o.validator == @validator)
       end

data/lib/usher/splitter.rb

@@ -14,10 +14,9 @@ class Usher
         @url_split_regex = Regexp.new("[#{delimiters.collect{|d| Regexp.quote(d)}.join}]|[^#{delimiters.collect{|d| Regexp.quote(d)}.join}]+")
       end
       
-      def url_split(path)
+      def split(path)
         path.scan(@url_split_regex)
       end
-      alias split url_split
     end
     
     class MultiCharacterSplitterInstance
@@ -26,12 +25,11 @@ class Usher
         @delimiters = delimiters
       end
 
-      def url_split(path)
+      def split(path)
         split_path = path.split(delimiters_regexp)
-        split_path.reject!{|s| s.size.zero? }
+        split_path.reject!{|s| s.empty? }
         split_path
       end
-      alias split url_split
 
       protected
 

data/lib/usher/util/generate.rb

@@ -12,28 +12,50 @@ class Usher
 
         def generate_path_for_base_params(path, params)
           raise UnrecognizedException.new unless path
-
           result = ''
-          path.parts.each do |part|
-            case part
-            when Route::Variable::Glob
-              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
-              value.each_with_index do |current_value, index|
-                part.valid!(current_value)
-                result << current_value.to_s
-                result << usher.delimiters.first if index != value.size - 1
+
+          case params
+          when nil, Hash
+            path.parts.each do |part|
+              case part
+              when String
+                result << part
+              when Route::Variable::Glob
+                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+                value.each_with_index do |current_value, index|
+                  part.valid!(current_value)
+                  result << current_value.to_s
+                  result << usher.delimiters.first if index != value.size - 1
+                end
+              when Route::Variable
+                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+                part.valid!(value)
+                result << value.to_s
+              end
+            end
+          else
+            params = Array(params)
+            path.parts.each do |part|
+              case part
+              when String
+                result << part
+              when Route::Variable::Glob
+                value = (params && params.shift) || part.default_value || raise(MissingParameterException.new)
+                value.each_with_index do |current_value, index|
+                  part.valid!(current_value)
+                  result << current_value.to_s
+                  result << usher.delimiters.first if index != value.size - 1
+                end
+              when Route::Variable
+                value = (params && params.shift) || part.default_value || raise(MissingParameterException.new)
+                part.valid!(value)
+                result << value.to_s
               end
-            when Route::Variable
-              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
-              part.valid!(value)
-              result << value.to_s
-            else
-              result << part
             end
           end
           result
         end
-
+        
       end
 
       class URL < Generic
@@ -104,26 +126,30 @@ class Usher
 
         def generate_path(path, params = nil, generate_extra = true)
           params = Array(params) if params.is_a?(String)
+          extra_params = nil
           case params
           when nil
             params = path && path.route.default_values
           when Hash
             params = path.route.default_values.merge(params) if path && path.route.default_values
-          when String, Array
+          else
             params = Array(params)
-            given_size = params.size
             extra_params = params.last.is_a?(Hash) ? params.pop : nil
-            params = Hash[*path.dynamic_parts.inject(path.route.default_values ? path.route.default_values.to_a : []){|a, dynamic_part| a.concat([dynamic_part.name, params.shift || raise(MissingParameterException.new("got #{given_size}, expected #{path.dynamic_parts.size} parameters"))]); a}]
-            params.merge!(extra_params) if extra_params
+            raise MissingParameterException.new("got #{params.size}, expected #{path.dynamic_parts.size} parameters") unless path.dynamic_parts.size == params.size
           end
           
           result = Rack::Utils.uri_escape(generate_path_for_base_params(path, params))
+          
+          params = extra_params if extra_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
+            unless params.empty?
+              result << '?' unless result[??]
+              result << generate_extra_params(params)
+            end
           end
           result
         end
@@ -188,6 +214,8 @@ class Usher
 
         def path_for_routing_lookup(routing_lookup, params = {})
           path = case routing_lookup
+          when Route::Path
+            routing_lookup
           when Symbol
             route = @usher.named_routes[routing_lookup]
             raise UnrecognizedException unless route
@@ -196,23 +224,23 @@ class Usher
             routing_lookup.find_matching_path(params)
           when nil
             params.is_a?(Hash) ? usher.path_for_options(params) : raise
-          when Route::Path
-            routing_lookup
           end
         end
 
 
-        def generate_extra_params(params, has_question_mark)
+        def generate_extra_params(params)
           extra_params_result = ''
 
           params.each do |k,v|
             case v
             when Array
               v.each do |v_part|
-                extra_params_result << (has_question_mark ? '&' : has_question_mark = true && '?') << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
+                extra_params_result << '&' unless extra_params_result.empty?
+                extra_params_result << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
               end
             else
-              extra_params_result << (has_question_mark ? '&' : has_question_mark = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
+              extra_params_result << '&' unless extra_params_result.empty?
+              extra_params_result << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
             end
           end
           extra_params_result

data/lib/usher.rb

@@ -67,15 +67,20 @@ class Usher
   # Example, you create a route with a destination of :controller => 'test', :action => 'action'. If you made a call to generator with :controller => 'test', 
   # :action => 'action', it would pick that route to use for generation.
   def initialize(options = nil)
-    self.generator                   = options && options.delete(:generator)
-    self.delimiters                  = Delimiters.new(options && options.delete(:delimiters) || ['/', '.'])
-    self.valid_regex                 = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
-    self.request_methods             = options && options.delete(:request_methods)
-    self.ignore_trailing_delimiters  = options && options.key?(:ignore_trailing_delimiters) ? options.delete(:ignore_trailing_delimiters) : false
-    self.consider_destination_keys   = options && options.key?(:consider_destination_keys) ? options.delete(:consider_destination_keys) : false
+    self.generator                      = options && options.delete(:generator)
+    self.delimiters                     = Delimiters.new(options && options.delete(:delimiters) || ['/', '.'])
+    self.valid_regex                    = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
+    self.request_methods                = options && options.delete(:request_methods)
+    self.ignore_trailing_delimiters     = options && options.key?(:ignore_trailing_delimiters) ? options.delete(:ignore_trailing_delimiters) : false
+    self.consider_destination_keys      = options && options.key?(:consider_destination_keys) ? options.delete(:consider_destination_keys) : false
+    self.allow_identical_variable_names = options && options.key?(:allow_identical_variable_names) ? options.delete(:allow_identical_variable_names) : true
     reset!
   end
 
+  def allow_identical_variable_names?
+    @allow_identical_variable_names
+  end
+  
   def ignore_trailing_delimiters?
     @ignore_trailing_delimiters
   end
@@ -223,7 +228,7 @@ class Usher
   #   route = set.add_route('/test')
   #   set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request, path = request.path)
-    @root.find(self, request, path, @splitter.url_split(path))
+    @root.find(self, request, path, @splitter.split(path))
   end
 
   # Recognizes a +path+ and returns +nil+ or an Usher::Node::Response, which is a struct containing a Usher::Route::Path and an array of arrays containing the extracted parameters. Convenience method for when recognizing on the request object is unneeded.
@@ -282,7 +287,7 @@ class Usher
 
   private
 
-  attr_accessor :request_methods, :ignore_trailing_delimiters, :consider_destination_keys
+  attr_accessor :request_methods, :ignore_trailing_delimiters, :consider_destination_keys, :allow_identical_variable_names
   attr_reader :valid_regex
 
   def generator=(generator)
@@ -333,6 +338,7 @@ class Usher
     end
 
     route = parser.generate_route(path, conditions, requirements, default_values, generate_with, priority)
+    raise(MultipleParameterException.new) if !allow_identical_variable_names? and route.paths.first.dynamic? and route.paths.first.dynamic_keys.uniq.size != route.paths.first.dynamic_keys.size
     route.to(options) if options && !options.empty?
     route
   end

data/spec/private/recognize_spec.rb

@@ -273,6 +273,13 @@ describe "Usher route recognition" do
     @route_set.recognize(build_request({:path => '/id1/one/id2.html'})).params.should == [[:id1, 'id1'], [:id2, 'id2'], [:format, 'html']]
   end
 
+  it "should pick the correct variable name when there are two variable names that could be represented" do
+    @route_set.add_route('/:var1')
+    @route_set.add_route('/:var2/foo')
+    @route_set.recognize(build_request({:path => '/foo1'})).params.should == [[:var1, 'foo1']]
+    @route_set.recognize(build_request({:path => '/foo2/foo'})).params.should == [[:var2, 'foo2']]
+  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'}))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-05 00:00:00 -05:00
+date: 2010-01-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency