usher 0.7.1 → 0.7.2

data/lib/usher/util/parser.rb

@@ -124,20 +124,23 @@ class Usher
               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
+              variable_class = case variable.slice!(0)
+              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])
+              current_group << variable_class.new(variable_name, Regexp.new(pattern), requirements && requirements[variable_name])
             elsif simple
-              current_group << Usher::Route::Static::Greedy.new(Regexp.new(pattern))
+              static = Usher::Route::Static::Greedy.new(pattern)
+              static.generate_with = pattern
+              current_group << static
             else
-              current_group << regex
+              simple_parts = pattern.split(',', 2)
+              static = Usher::Route::Static::Greedy.new(Regexp.new(simple_parts.last))
+              static.generate_with = simple_parts.first
+              current_group << static
             end
           when ?(
             new_group = Usher::Route::Util::Group.new(:any, current_group)

data/lib/usher.rb

@@ -10,67 +10,66 @@ require File.join('usher', 'exceptions')
 require File.join('usher', 'util')
 require File.join('usher', 'delimiters')
 
+# Main class for routing.
+# If you're going to be routing for a specific context, like rails or rack, you probably want to use an interface. Otherwise, this
+# is the main class that actually does all the work.
+# @example
+#     u = Usher.new
+#     u.add_route('one/two').to(:one)
+#     u.add_route('two/three').to(:two)
+#     u.add_route('two/:variable').to(:variable)
+#     u.recognize_path('one/two').destination
+#     ==> :one
+#     u.recognize_path('two/whatwasthat').params_as_hash
+#     ==> {:variable => 'whatwasthat'}
 class Usher
   attr_reader   :root, :named_routes, :routes, :splitter,
-                :delimiters, :delimiters_regex, :priority_lookups,
-                :parent_route, :generator, :grapher
+                :delimiters, :delimiters_regex, :parent_route, :generator, :grapher, :parser
   attr_accessor :route_class
   
-  alias_method :priority_lookups?, :priority_lookups
-
-  # Returns whether the route set is empty
-  #
-  #   set = Usher.new
-  #   set.empty? => true
-  #   set.add_route('/test')
-  #   set.empty? => false
+  # @return [Boolean] Whether the route set is empty
+  # @example
+  #     set = Usher.new
+  #     set.empty? => true
+  #     set.add_route('/test')
+  #     set.empty? => false
   def empty?
     routes.empty?
   end
 
-  # Returns the number of routes
+  # @return [Number] The number of routes currently mapped
   #
   def route_count
     routes.size
   end
 
   # Resets the route set back to its initial state
-  #
-  #   set = Usher.new
-  #   set.add_route('/test')
-  #   set.empty? => false
-  #   set.reset!
-  #   set.empty? => true
+  # @example
+  #     set = Usher.new
+  #     set.add_route('/test')
+  #     set.empty? => false
+  #     set.reset!
+  #     set.empty? => true
   def reset!
     @root = Node::Root.new(self, request_methods)
     @named_routes = {}
     @routes = []
     @grapher = Grapher.new(self)
     @priority_lookups = false
+    @parser = Util::Parser.for_delimiters(self, valid_regex)
   end
-  alias clear! reset!
 
   # Creates a route set, with options
-  #
-  # <tt>:delimiters</tt>: Array of Strings. (default <tt>['/', '.']</tt>). Delimiters used in path separation. Array must be single character strings.
-  #
-  # <tt>:valid_regex</tt>: String. (default <tt>'[0-9A-Za-z\$\-_\+!\*\',]+'</tt>). String that can be interpolated into regex to match
-  # valid character sequences within path.
-  #
-  # <tt>:request_methods</tt>: Array of Symbols. (default <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]</tt>)
-  # Array of methods called against the request object for the purposes of matching route requirements.
-  #
-  # <tt>:generator</tt>: +nil+ or Generator instance. (default: +nil+) Take a look at <tt>Usher::Util::Generators for examples.</tt>.
-  #
-  # <tt>:ignore_trailing_delimiters</tt>: +true+ or +false+. (default: +false+) Ignore trailing delimiters in recognizing paths.
-  #
-  # <tt>:consider_destination_keys</tt>: +true+ or +false+. (default: +false+) When generating, and using hash destinations, you can have
-  # Usher use the destination hash to match incoming params.
-  #
-  # <tt>:allow_identical_variable_names</tt>: +true+ or +false+. (default: +true+) When adding routes, allow identical variable names to be used.
-  #
-  # 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.
+  # @param [Hash] options the options to create a router with
+  # @option options [Array<String>] :delimiters (['/', '.']) Delimiters used in path separation. Array must be single character strings.
+  # @option options [String] :valid_regex ('[0-9A-Za-z\$\-_\+!\*\',]+') String that can be interpolated into regex to match valid character sequences within path.
+  # @option options [Array<Symbol>] :request_methods ([:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains])  Array of methods called against the request object for the purposes of matching route requirements.
+  # @option options [nil or Generator] :generator (nil) Take a look at `Usher::Util::Generators for examples.`.
+  # @option options [Boolean] :ignore_trailing_delimiters (false) Ignore trailing delimiters in recognizing paths.
+  # @option options [Boolean] :consider_destination_keys (false) When generating, and using hash destinations, you can have Usher use the destination hash to match incoming params.
+  #   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.
+  # @option options [Boolean] :allow_identical_variable_names (true) When adding routes, allow identical variable names to be used.
   def initialize(options = nil)
     self.route_class                     = Usher::Route
     self.generator                       = options && options.delete(:generator)
@@ -80,132 +79,148 @@ class Usher
     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
+    unless options.nil? || options.empty?
+      raise "unrecognized options -- #{options.keys.join(', ')}"
+    end
     reset!
   end
-
+  
+  # @return [Boolean] State of allow_identical_variable_names feature.
   def allow_identical_variable_names?
     @allow_identical_variable_names
   end
   
+  # @return [Boolean] State of ignore_trailing_delimiters feature.
   def ignore_trailing_delimiters?
     @ignore_trailing_delimiters
   end
   
+  # @return [Boolean] State of consider_destination_keys feature.
   def consider_destination_keys?
     @consider_destination_keys
   end
-  
-  def parser
-    @parser ||= Util::Parser.for_delimiters(self, valid_regex)
-  end
 
-  def can_generate?
-    !@generator.nil?
+  # @return [Boolean] State of priority_lookups feature.
+  def priority_lookups?
+    @priority_lookups
   end
 
-  def generator
-    @generator
+  # @return [Boolean] Able to generate
+  def can_generate?
+    !generator.nil?
   end
 
-  # Adds a route referencable by +name+. See add_route for format +path+ and +options+.
-  #
-  #   set = Usher.new
-  #   set.add_named_route(:test_route, '/test')
+  # Adds a route referencable by `name`. See {#add_route} for format `path` and `options`.
+  # @param name Name of route
+  # @param path Path of route
+  # @param options Options for route
+  # @return (Route) Route added
+  # @example
+  #     set = Usher.new
+  #     set.add_named_route(:test_route, '/test')
   def add_named_route(name, path, options = nil)
     add_route(path, options).name(name)
   end
 
-  # Deletes a route referencable by +name+. At least the path and conditions have to match the route you intend to delete.
-  #
-  #   set = Usher.new
-  #   set.delete_named_route(:test_route, '/test')
+  # Deletes a route referencable by `name`. At least the path and conditions have to match the route you intend to delete.
+  # @param name Name of route
+  # @param path Path of route
+  # @param options Options for route
+  # @return (Route) Route added
+  # @example
+  #     set = Usher.new
+  #     set.delete_named_route(:test_route, '/test')
   def delete_named_route(name, path, options = nil)
     delete_route(path, options)
     named_routes.delete(name)
   end
 
-  # Attaches a +route+ to a +name+
-  #
-  #   set = Usher.new
-  #   route = set.add_route('/test')
-  #   set.name(:test, route)
+  # Attaches a `route` to a `name`
+  # @param name Name of route
+  # @param route Route to attach to
+  # @return (Route) Route named
+  # @example
+  #     set = Usher.new
+  #     route = set.add_route('/test')
+  #     set.name(:test, route)
   def name(name, route)
     named_routes[name.to_sym] = route
     route
   end
 
-  # Creates a route from +path+ and +options+
-  #
-  # === +path+
-  # A path consists a mix of dynamic and static parts delimited by <tt>/</tt>
-  #
-  # ==== Dynamic
-  # Dynamic parts are prefixed with either :, *.  :variable matches only one part of the path, whereas *variable can match one or
-  # more parts.
-  #
-  # <b>Example:</b>
-  # <tt>/path/:variable/path</tt> would match
-  #
-  # * <tt>/path/test/path</tt>
-  # * <tt>/path/something_else/path</tt>
-  # * <tt>/path/one_more/path</tt>
-  #
-  # In the above examples, 'test', 'something_else' and 'one_more' respectively would be bound to the key <tt>:variable</tt>.
-  # However, <tt>/path/test/one_more/path</tt> would not be matched.
-  #
-  # <b>Example:</b>
-  # <tt>/path/*variable/path</tt> would match
-  #
-  # * <tt>/path/one/two/three/path</tt>
-  # * <tt>/path/four/five/path</tt>
-  #
-  # In the above examples, ['one', 'two', 'three'] and ['four', 'five'] respectively would be bound to the key :variable.
-  #
-  # As well, variables can have a regex matcher.
-  #
-  # <b>Example:</b>
-  # <tt>/product/{:id,\d+}</tt> would match
-  #
-  # * <tt>/product/123</tt>
-  # * <tt>/product/4521</tt>
-  #
-  # But not
-  # * <tt>/product/AE-35</tt>
-  #
-  # As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
-  # actually be bound to the variable
-  #
-  # Variables can also have a greedy regex matcher. These matchers ignore all delimiters, and continue matching for as long as much as their
-  # regex allows.
-  #
-  # <b>Example:</b>
-  # <tt>/product/{!id,hello/world|hello}</tt> would match
-  #
-  # * <tt>/product/hello/world</tt>
-  # * <tt>/product/hello</tt>
-  #
-  # ==== Static
-  #
-  # Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
-  # As well, static parts can have a regex pattern in them as well, such as <tt>/path/something.{html|xml}</tt> which would match only
-  # <tt>/path/something.html</tt> and <tt>/path/something.xml</tt>
-  #
-  # ==== Optional sections
-  #
-  # Sections of a route can be marked as optional by surrounding it with brackets. For instance, in the above static example, <tt>/path/something(.html)</tt> would match both <tt>/path/something</tt> and <tt>/path/something.html</tt>.
-  #
-  # ==== One and only one sections
-  #
-  # Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes.
-  # For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and
-  # <tt>/path/something.html</tt>. Generally its more efficent to use one and only sections over using regex.
-  #
-  # === +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.
-  # * +priority+ - If there are two routes which equally match, the route with the highest priority will match first.
-  # * Any other key is interpreted as a requirement for the variable of its name.
+  # Creates a route from `path` and `options`
+  # @param [String] path
+  #
+  #   A path consists a mix of dynamic and static parts delimited by `/`
+  #   ## Dynamic
+  #   Dynamic parts are prefixed with either :, *.  :variable matches only one part of the path, whereas *variable can match one or
+  #   more parts.
+  # 
+  #   ### Example
+  #   `/path/:variable/path` would match
+  #   
+  #    *  `/path/test/path`
+  #    *  `/path/something_else/path`
+  #    *  `/path/one_more/path`
+  # 
+  #   In the above examples, 'test', 'something_else' and 'one_more' respectively would be bound to the key `:variable`.
+  #   However, `/path/test/one_more/path` would not be matched.
+  # 
+  #   ### example
+  #   `/path/*variable/path` would match
+  # 
+  #    *  `/path/one/two/three/path`
+  #    *  `/path/four/five/path` 
+  # 
+  #   In the above examples, `['one', 'two', 'three']` and `['four', 'five']` respectively would be bound to the key `:variable`.
+  # 
+  #   As well, variables can have a regex matcher.
+  # 
+  #   ### Example
+  #   `/product/{:id,\d+}` would match
+  # 
+  #   *  `/product/123`
+  #   *  `/product/4521`
+  # 
+  #   But not
+  # 
+  #   *  `/product/AE-35`
+  # 
+  #   As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
+  #   actually be bound to the variable
+  # 
+  #   Variables can also have a greedy regex matcher. These matchers ignore all delimiters, and continue matching for as long as much as their
+  #   regex allows.
+  # 
+  #   ### Example
+  #   `/product/{!id,hello/world|hello}` would match
+  # 
+  #   *  `/product/hello/world`
+  #   *  `/product/hello`
+  # 
+  #   ## Static
+  # 
+  #   Static parts of literal character sequences. For instance, `/path/something.html` would match only the same path.
+  #   As well, static parts can have a regex pattern in them as well, such as `/path/something.{html|xml}` which would match only
+  #   `/path/something.html` and `/path/something.xml`
+  # 
+  #   ## Optional sections
+  # 
+  #   Sections of a route can be marked as optional by surrounding it with brackets. For instance, in the above static example, `/path/something(.html)` would match both `/path/something` and `/path/something.html`.
+  # 
+  #   ## One and only one sections
+  # 
+  #   Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes.
+  #   For instance, the path, `/path/something(.xml|.html)` would only match `/path/something.xml` and
+  #   `/path/something.html`. Generally its more efficent to use one and only sections over using regex.
+  #   
+  # @param [Hash] options
+  #   Any other key is interpreted as a requirement for the variable of its name.
+  # @option options [Object] :requirements After transformation, tests the condition using ===. If it returns false, it raises an {ValidationException}
+  # @option options [String, Regexp] :conditions Accepts any of the `request_methods` specificied in the construction of Usher. This can be either a `String` or a regular expression.
+  # @option options [Hash<Symbol, String>] :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.
+  # @option options [Number] :priority If there are two routes which equally match, the route with the highest priority will match first.
+  # @return [Route] The route added
   def add_route(path, options = nil)
     route = get_route(path, options)
     root.add(route)
@@ -216,57 +231,78 @@ class Usher
   end
 
   # Deletes a route. At least the path and conditions have to match the route you intend to delete.
-  #
-  #   set = Usher.new
-  #   set.delete_route('/test')
+  # @param path [String] The path to delete
+  # @param options [Hash] The options used to identify the path
+  # @example 
+  #      set.delete_route('/test')
+  # @return [Route] The route deleted
   def delete_route(path, options = nil)
     route = get_route(path, options)
     root.delete(route)
-    @routes = root.unique_routes
-    rebuild_grapher!
+    routes.replace(root.unique_routes)
+    build_grapher!
     route
   end
 
-  # Recognizes a +request+ 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.
-  #
-  #   Request = Struct.new(:path)
-  #   set = Usher.new
-  #   route = set.add_route('/test')
-  #   set.recognize(Request.new('/test')).path.route == route => true
+  # Recognizes a `request`
+  # @param request [#path] The request object. Must minimally respond to #path if no path argument is supplied here.
+  # @param path [String] The path to be recognized.
+  # @return [nil, Node::Response] The recognition response if the request object was recognized
+  # @example
+  #     Request = Struct.new(:path)
+  #     set = Usher.new
+  #     route = set.add_route('/test')
+  #     set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request, path = request.path)
-    root.find(request, path, splitter.split(path))
+    if ignore_trailing_delimiters? and path.size > 1
+      path_size = path.size
+      path = path.gsub(/#{Regexp.quote(delimiters.first)}$/, '')
+      response = root.find(request, path, splitter.split(path))
+      response.only_trailing_delimiters = (path.size != path_size) if response
+      response
+    else
+      root.find(request, path, splitter.split(path))
+    end
+
   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.
-  #
-  #   Request = Struct.new(:path)
-  #   set = Usher.new
-  #   route = set.add_route('/test')
-  #   set.recognize_path('/test').path.route == route => true
+  # Recognizes a `path`
+  # @param path [String] The path to be recognized.
+  # @return [nil, Node::Response] The recognition response if the request object was recognized
+  # @example
+  #     Request = Struct.new(:path)
+  #     set = Usher.new
+  #     route = set.add_route('/test')
+  #     set.recognize_path('/test').path.route == route => true
   def recognize_path(path)
     recognize(nil, path)
   end
 
-  # Recognizes a set of +parameters+ and gets the closest matching Usher::Route::Path or +nil+ if no route exists.
-  #
-  #   set = Usher.new
-  #   route = set.add_route('/:controller/:action')
-  #   set.path_for_options({:controller => 'test', :action => 'action'}) == path.route => true
+  # Recognizes a set of `parameters` and gets the closest matching Usher::Route::Path or `nil` if no route exists.
+  # @param options [Hash<Symbol, String>] A set of parameters
+  # @return [nil, Route::Path] A path matched or `nil` if not found.
+  # @example
+  #     set = Usher.new
+  #     route = set.add_route('/:controller/:action')
+  #     set.path_for_options({:controller => 'test', :action => 'action'}) == path.route => true
   def path_for_options(options)
     grapher.find_matching_path(options)
   end
 
+  # The assignes the parent route this router belongs to.
+  # @param route [Route] The route to use to assign as this routers parent route
   def parent_route=(route)
     @parent_route = route
     routes.each{|r| r.parent_route = route}
   end
 
+  # Duplicates the router.
+  # @return [Usher] The duplicated router
   def dup
     replacement = super
     original = self
     inverted_named_routes = original.named_routes.invert
     replacement.instance_eval do
-      @parser = nil
       reset!
       original.routes.each do |route|
         new_route = route.dup
@@ -278,13 +314,13 @@ class Usher
         end
       end
       send(:generator=, original.generator.class.new) if original.can_generate?
-      rebuild_grapher!
+      build_grapher!
     end
     replacement
   end
 
   def inspect
-    "#<Usher:0x%x route_count=%d delimiters=%s request_methods=%s ignore_trailing_delimiters? %s consider_destination_keys? %s can_generate? %s priority_lookups? %s>" % [self.object_id, route_count, self.delimiters.inspect, request_methods.inspect, ignore_trailing_delimiters.inspect, consider_destination_keys.inspect, can_generate?.inspect, priority_lookups.inspect]
+    "#<Usher:0x%x route_count=%d delimiters=%s request_methods=%s ignore_trailing_delimiters? %s consider_destination_keys? %s can_generate? %s priority_lookups? %s>" % [self.object_id, route_count, self.delimiters.inspect, request_methods.inspect, ignore_trailing_delimiters?.inspect, consider_destination_keys?.inspect, can_generate?.inspect, priority_lookups?.inspect]
   end
 
   def to_s
@@ -295,7 +331,8 @@ class Usher
 
   attr_accessor :request_methods, :ignore_trailing_delimiters, :consider_destination_keys, :allow_identical_variable_names
   attr_reader :valid_regex
-
+  attr_writer :parser
+  
   def generator=(generator)
     if generator
       @generator = generator
@@ -320,6 +357,10 @@ class Usher
     @priority_lookups = true
   end
 
+  # Returns the route this path, options belongs to. Used internally by add_route, delete_route.
+  # @see #add_route, #delete_route
+  # @param path [String] path
+  # @param options [Hash] options
   def get_route(path, options = nil)
     conditions = options && options.delete(:conditions) || nil
     requirements = options && options.delete(:requirements) || nil
@@ -336,7 +377,7 @@ class Usher
     end
 
     if conditions && !conditions.empty?
-      conditions.keys.all?{|k| request_methods.include?(k)} or raise("You are trying to use request methods that don't exist in the request_methods supplied #{conditions.keys.join(', ')} -> #{conditions.keys.select{|k| request_methods.include?(k)}.join(", ")}")
+      conditions.keys.all?{|k| request_methods.include?(k)} or raise("You are trying to use request methods that don't exist in the request_methods supplied #{conditions.keys.join(', ')} -> #{(conditions.keys - request_methods).join(", ")}")
     end
 
     if priority
@@ -349,9 +390,10 @@ class Usher
     route
   end
 
-  def rebuild_grapher!
+  # Rebuilds the grapher
+  def build_grapher!
     @grapher = Grapher.new(self)
     routes.each{|r| grapher.add_route(r)}
   end
-  
+
 end

data/spec/private/generate_spec.rb

@@ -44,6 +44,11 @@ describe "Usher URL generation" do
     @route_set.generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
   end
 
+  it "should generate a mutliple vairable URL from an array where the same variable name is repeated" do
+    @route_set.add_named_route(:sample, '/sample/:first/:first', :controller => 'sample')
+    @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')
     @route_set.generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => 'zanz'}).should == '/sample/maz/zoo?third=zanz'

data/spec/private/recognize_spec.rb

@@ -59,12 +59,6 @@ describe "Usher route recognition" do
       @route_set.recognize(build_request({:path => '/'})).path.route.destination.should == :test
     end
 
-    it "should allow adding a pure regex" do
-      @route_set.add_route(/\/test\/(testing|gold)/).to(:test)
-      @route_set.recognize(build_request({:path => '/test/testing'})).path.route.destination.should == :test
-      @route_set.recognize(build_request({:path => '/test/gold'})).path.route.destination.should == :test
-    end
-
     it "should correctly fix that tree if conditionals are used later" do
       noop_route = @route_set.add_route('/noop', :controller => 'products', :action => 'noop')
       product_show_route = @route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
@@ -101,7 +95,9 @@ describe "Usher route recognition" do
 
   it "should recognize a format-style variable" do
     target_route = @route_set.add_route('/sample.:format', :controller => 'sample', :action => 'action')
-    @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, ['html'], nil, "/sample.html")
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'}))
+    response.path.should == target_route.paths.first
+    response.params.should == [[:format, 'html']]
   end
 
   it "should recognize a glob-style variable" do
@@ -166,7 +162,7 @@ describe "Usher route recognition" do
   end
 
   it "should recgonize a regex static part containing {}'s" do
-    target_route = @route_set.add_route('/test/part/{^o{2,3}$}')
+    target_route = @route_set.add_route('/test/part/{oo,^o{2,3}$}')
     @route_set.recognize(build_request({:method => 'get', :path => '/test/part/oo'})).path.route.should == target_route
     @route_set.recognize(build_request({:method => 'get', :path => '/test/part/ooo'})).path.route.should == target_route
     @route_set.recognize(build_request({:method => 'get', :path => '/test/part/oooo'})).should == nil
@@ -236,12 +232,16 @@ describe "Usher route recognition" do
 
   it "should recognize a format-style literal" do
     target_route = @route_set.add_route('/:action.html', :controller => 'sample', :action => 'action')
-    @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, ['sample'], nil, "/sample.html")
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'}))
+    response.path.should == target_route.paths.first
+    response.params.should == [[:action, 'sample']]
   end
 
   it "should recognize a format-style variable along side another variable" do
     target_route = @route_set.add_route('/:action.:format', :controller => 'sample', :action => 'action')
-    @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, ['sample', 'html'], nil, '/sample.html')
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'}))
+    response.path.should == target_route.paths.first
+    response.params.should == [[:action, 'sample'], [:format, 'html']]
   end
 
   it "should use a requirement (proc) on incoming variables" do
@@ -315,14 +315,14 @@ describe "Usher route recognition" do
 
     @route_set.recognize(build_request({:method => 'post', :protocol => 'https', :path => '/foo'})).path.route.should == route_higher
 
-    @route_set.clear!
+    @route_set.reset!
 
     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!
+    @route_set.reset!
   end
 
   it "should only match the specified path of the route when a condition is specified" do