usher 0.5.12 → 0.5.13

data/README.rdoc

@@ -88,6 +88,7 @@ For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <t
 === +options+
 * +requirements+ - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
 * +conditions+ - Accepts any of the +request_methods+ specificied in the construction of Usher. This can be either a <tt>string</tt> or a regular expression.
+* +default_values+ - Provides values for variables in your route for generation. If you're using URL generation, then any values supplied here that aren't included in your path will be appended to the query string.
 * Any other key is interpreted as a requirement for the variable of its name.
 
 == Rails

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
+:major: 0
 :build: 
 :minor: 5
-:patch: 12
-:major: 0
+:patch: 13

data/lib/usher/node.rb

@@ -164,12 +164,20 @@ class Usher
         end
         next_part.find(usher, request_object, original_path, path, params, position)
       elsif request_method_type
-        if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position)
-          ret
-        elsif general_node = request[nil] and ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position)
-          ret
+        return_value = if (specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          usher.priority_lookups? ? [ret] : ret
+        end
+        
+        if usher.priority_lookups? || return_value.nil? and general_node = request[nil] and ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position)
+          return_value = usher.priority_lookups? && return_value ? [return_value, ret] : ret
+        end
+        
+        unless usher.priority_lookups?
+          return_value
         else
-          nil
+          return_value = Array(return_value).flatten.compact
+          return_value.sort!{|r1, r2| r1.path.route.priority <=> r2.path.route.priority}
+          return_value.last
         end
       else
         nil
@@ -199,11 +207,8 @@ class Usher
         key = parts.shift
 
         next if key.trivial?
-        
         nodes.map! do |node|
-        
           node.activate_request!
-
           if node.request_method_type.nil?
             node.request_method_type = key.type
             node.upgrade_request! if key.value.is_a?(Regexp)
@@ -212,7 +217,7 @@ class Usher
             case request_method_index(node.request_method_type) <=> request_method_index(key.type)
             when -1
               parts.unshift(key)
-              Array(key.value).map{|k| node.request[k] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)) }
+              Array(key.value).map{|k| node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)) }
             when 0
               node.upgrade_request! if key.value.is_a?(Regexp)
               Array(key.value).map{|k| node.request[k] ||= Node.new(node, key) }

data/lib/usher/route.rb

@@ -6,7 +6,7 @@ require File.join('usher', 'route', 'request_method')
 
 class Usher
   class Route
-    attr_reader   :paths, :requirements, :conditions, :named, :generate_with, :default_values, :match_partially, :destination
+    attr_reader   :paths, :requirements, :conditions, :named, :generate_with, :default_values, :match_partially, :destination, :priority
     attr_accessor :parent_route, :router, :recognizable
 
     class GenerateWith < Struct.new(:scheme, :port, :host)
@@ -15,8 +15,8 @@ class Usher
       end
     end
 
-    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)
-      @router, @requirements, @conditions, @default_values, @match_partially = router, requirements, conditions, default_values, match_partially
+    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially, priority)
+      @router, @requirements, @conditions, @default_values, @match_partially, @priority = router, requirements, conditions, default_values, match_partially, priority
       @recognizable = true
       @paths = parsed_paths.collect {|path| Path.new(self, path)}
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with

data/lib/usher/util/generate.rb

@@ -104,13 +104,20 @@ class Usher
 
         def generate_path(path, params = nil, generate_extra = true)
           params = Array(params) if params.is_a?(String)
-          if params.is_a?(Array)
+          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
+            params = Array(params)
             given_size = params.size
             extra_params = params.last.is_a?(Hash) ? params.pop : nil
-            params = Hash[*path.dynamic_parts.inject([]){|a, dynamic_part| a.concat([dynamic_part.name, params.shift || raise(MissingParameterException.new("got #{given_size}, expected #{path.dynamic_parts.size} parameters"))]); a}]
+            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
           end
-
+          
+          
           result = Rack::Utils.uri_escape(generate_path_for_base_params(path, params))
           unless !generate_extra || params.nil? || params.empty?
             extra_params = generate_extra_params(params, result[??])

data/lib/usher/util/parser.rb

@@ -18,7 +18,7 @@ class Usher
           @delimiters_regex = Regexp.new(router.delimiters_regex)
         end
 
-        def generate_route(unprocessed_path, conditions, requirements, default_values, generate_with)
+        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] == ?*
@@ -73,7 +73,8 @@ class Usher
             requirements, 
             default_values, 
             generate_with,
-            match_partially
+            match_partially,
+            priority
           )
           
         end

data/lib/usher.rb

@@ -11,9 +11,11 @@ require File.join('usher', 'delimiters')
 
 class Usher
   attr_reader :root, :named_routes, :routes, :splitter,
-              :delimiters, :delimiters_regex,
+              :delimiters, :delimiters_regex, :priority_lookups,
               :parent_route, :generator, :grapher
 
+  alias_method :priority_lookups?, :priority_lookups
+
   # Returns whether the route set is empty
   #
   #   set = Usher.new
@@ -40,6 +42,7 @@ class Usher
     @named_routes = {}
     @routes = []
     @grapher = Grapher.new
+    @priority_lookups = false
   end
   alias clear! reset!
 
@@ -168,6 +171,7 @@ class Usher
   # === +options+
   # * +requirements+ - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
   # * +conditions+ - Accepts any of the +request_methods+ specificied in the construction of Usher. This can be either a <tt>string</tt> or a regular expression.
+  # * +default_values+ - Provides values for variables in your route for generation. If you're using URL generation, then any values supplied here that aren't included in your path will be appended to the query string.
   # * Any other key is interpreted as a requirement for the variable of its name.
   def add_route(path, options = nil)
     route = get_route(path, options)
@@ -271,11 +275,16 @@ class Usher
     @valid_regex
   end
 
+  def enable_priority_lookups!
+    @priority_lookups = true
+  end
+
   def get_route(path, options = nil)
     conditions = options && options.delete(:conditions) || nil
     requirements = options && options.delete(:requirements) || nil
     default_values = options && options.delete(:default_values) || nil
     generate_with = options && options.delete(:generate_with) || nil
+    priority = options && options.delete(:priority) || nil
     if options
       options.delete_if do |k, v|
         if v.is_a?(Regexp) || v.is_a?(Proc)
@@ -289,7 +298,11 @@ class Usher
       conditions.keys.all?{|k| request_methods.include?(k)} or raise
     end
 
-    route = parser.generate_route(path, conditions, requirements, default_values, generate_with)
+    if priority
+      enable_priority_lookups!
+    end
+
+    route = parser.generate_route(path, conditions, requirements, default_values, generate_with, priority)
     route.to(options) if options && !options.empty?
     route
   end

data/spec/private/generate_spec.rb

@@ -137,6 +137,11 @@ describe "Usher URL generation" do
     @route_set.generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
   end
 
+  it "should generate a route with default values that aren't represented in the path" do
+    @route_set.add_named_route(:default_values_not_in_path, '/:controller', :default_values => {:page => 1})
+    @route_set.generator.generate(:default_values_not_in_path, {:controller => "foo"}).should == '/foo?page=1'
+  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'

data/spec/private/parser_spec.rb

@@ -92,7 +92,7 @@ describe "Usher route tokenizing" do
       end
 
       it "should correctly generate route with a variable" do
-        route = @parser.generate_route('/cheese\(:kind\)', nil, nil, nil, nil)        
+        route = @parser.generate_route('/cheese\(:kind\)', nil, nil, nil, nil, nil)        
         variable = route.paths[0].parts[3]
         
         variable.should be_kind_of(Usher::Route::Variable::Single)        

data/spec/private/recognize_spec.rb

@@ -276,6 +276,22 @@ describe "Usher route recognition" do
     @route_set.recognize(build_request({:method => 'get', :path => '/foo'})).path.route.should == route
   end
 
+  it "should match between two routes where one has a higher priroty" do
+    route_lower = @route_set.add_route("/foo", :conditions => {:protocol => 'https'}, :priority => 1)
+    route_higher = @route_set.add_route("/foo", :conditions => {:method => 'post'}, :priority => 2)
+
+    @route_set.recognize(build_request({:method => 'post', :protocol => 'https', :path => '/foo'})).path.route.should == route_higher
+
+    @route_set.clear!
+
+    route_higher = @route_set.add_route("/foo", :conditions => {:protocol => 'https'}, :priority => 2)
+    route_lower = @route_set.add_route("/foo", :conditions => {:method => 'post'}, :priority => 1)
+
+    @route_set.recognize(build_request({:method => 'post', :protocol => 'https', :path => '/foo'})).path.route.should == route_higher
+
+    @route_set.clear!
+  end
+
   it "should only match the specified path of the route when a condition is specified" do
     @route_set.add_route("/", :conditions => {:method => "get"})
     @route_set.add_route("/foo")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.5.12
+  version: 0.5.13
 platform: ruby
 authors: 
 - Daniel Neighman