lib/usher/util/generate.rb in usher-0.6.2 vs lib/usher/util/generate.rb in usher-0.6.3

@@ -10,32 +10,54 @@
           generate_path_for_base_params(@usher.named_routes[name].find_matching_path(params), params)
         end
 
         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
-            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
+          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
+            end
           end
           result
         end
-
+        
       end
 
       class URL < Generic
 
         class UrlParts < Struct.new(:path, :request)
@@ -102,30 +124,34 @@
           generate_path(path_for_routing_lookup(routing_lookup, params), params)
         end
 
         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
 
         def generation_module
@@ -186,34 +212,36 @@
           (url[-1] == ?/) ? url[0..-2] : url
         end
 
         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
             route.find_matching_path(params || {})
           when Route
             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
         end