usher 0.5.4 → 0.5.5

data/README.rdoc

@@ -1,4 +1,4 @@
-= Usher 
+= Usher
 
 Tree-based router library. Useful for (specifically) for Rails and Rack, but probably generally useful for anyone interested in doing routing. Based on Ilya Grigorik suggestion, turns out looking up in a hash and following a tree is faster than Krauter's massive regex approach.
 
@@ -19,13 +19,13 @@ Tree-based router library. Useful for (specifically) for Rails and Rack, but pro
 From the rdoc:
 
 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. 
+more parts.
 
 <b>Example:</b>
 <tt>/path/:variable/path</tt> would match
@@ -35,7 +35,7 @@ more parts.
 * <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. 
+However, <tt>/path/test/one_more/path</tt> would not be matched.
 
 <b>Example:</b>
 <tt>/path/*variable/path</tt> would match
@@ -59,7 +59,7 @@ But not
 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 
+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>
@@ -110,7 +110,7 @@ For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <t
       [body]        # Response body
     ]
   end
-  
+
   routes = Usher::Interface.for(:rack) do
     add('/hello/:name').to(app)
   end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 4
-:major: 0
 :minor: 5
+:patch: 5
+:major: 0

data/lib/usher.rb

@@ -7,12 +7,12 @@ require File.join(File.dirname(__FILE__), 'usher', 'exceptions')
 require File.join(File.dirname(__FILE__), 'usher', 'util')
 
 class Usher
-  attr_reader :root, :named_routes, :routes, :splitter, 
-              :delimiters, :delimiter_chars, :delimiters_regex, 
+  attr_reader :root, :named_routes, :routes, :splitter,
+              :delimiters, :delimiter_chars, :delimiters_regex,
               :parent_route, :generator
-  
+
   # Returns whether the route set is empty
-  #   
+  #
   #   set = Usher.new
   #   set.empty? => true
   #   set.add_route('/test')
@@ -20,13 +20,13 @@ class Usher
   def empty?
     @routes.empty?
   end
-  
+
   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
@@ -39,14 +39,14 @@ class Usher
     @grapher = Grapher.new
   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.
   def initialize(options = nil)
@@ -64,13 +64,13 @@ class Usher
   def can_generate?
     !@generator.nil?
   end
-  
+
   def generator
     @generator
   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')
   def add_named_route(name, path, options = nil)
@@ -78,7 +78,7 @@ class Usher
   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')
   def delete_named_route(name, path, options = nil)
@@ -87,7 +87,7 @@ class Usher
   end
 
   # Attaches a +route+ to a +name+
-  #   
+  #
   #   set = Usher.new
   #   route = set.add_route('/test')
   #   set.name(:test, route)
@@ -97,13 +97,13 @@ class Usher
   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. 
+  # more parts.
   #
   # <b>Example:</b>
   # <tt>/path/:variable/path</tt> would match
@@ -113,7 +113,7 @@ class Usher
   # * <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. 
+  # However, <tt>/path/test/one_more/path</tt> would not be matched.
   #
   # <b>Example:</b>
   # <tt>/path/*variable/path</tt> would match
@@ -127,22 +127,22 @@ class Usher
   #
   # <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 
+  # 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>
   #
@@ -176,7 +176,7 @@ 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')
   def delete_route(path, options = nil)
@@ -188,7 +188,7 @@ class Usher
   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')
@@ -198,7 +198,7 @@ class Usher
   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')
@@ -208,35 +208,43 @@ class Usher
   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
   def path_for_options(options)
     @grapher.find_matching_path(options)
   end
-  
+
   def parent_route=(route)
     @parent_route = route
     routes.each{|r| r.parent_route = route}
   end
-  
+
   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|
-        @root.add(route)
-        @routes << route
+        new_route = route.dup
+        new_route.router = self
+        @root.add(new_route)
+        @routes << new_route
+        if name = inverted_named_routes[route]
+          @named_routes[name] = new_route
+        end
       end
+      send(:generator=, original.generator.class.new) if original.can_generate?
       rebuild_grapher!
     end
     replacement
   end
-  
+
   private
-  
+
   attr_accessor :request_methods
   attr_reader :valid_regex
 
@@ -247,7 +255,7 @@ class Usher
     end
     @generator
   end
-  
+
   def delimiters=(delimiters)
     @delimiters = delimiters
     @delimiter_chars = @delimiters.collect{|d| d[0]}
@@ -274,12 +282,12 @@ class Usher
         end
       end
     end
-    
+
     route = parser.generate_route(path, conditions, requirements, default_values, generate_with)
     route.to(options) if options && !options.empty?
     route
   end
-  
+
   def rebuild_grapher!
     @grapher = Grapher.new
     @routes.each{|r| @grapher.add_route(r)}

data/lib/usher/interface.rb

@@ -6,6 +6,7 @@ class Usher
     autoload :RackInterface, File.join(File.dirname(__FILE__), 'interface', 'rack_interface')
     autoload :EmailInterface, File.join(File.dirname(__FILE__), 'interface', 'email_interface')
     autoload :Rails3Interface, File.join(File.dirname(__FILE__), 'interface', 'rails3_interface')
+    autoload :TextInterface, File.join(File.dirname(__FILE__), 'interface', 'text_interface')
     
     def self.for(type, &blk)
       class_for(type).new(&blk)
@@ -25,6 +26,8 @@ class Usher
         EmailInterface
       when :rails3
         Rails3Interface
+      when :text
+        TextInterface
       end
       
     end

data/lib/usher/interface/rack_interface.rb

@@ -3,28 +3,34 @@ require 'rack'
 class Usher
   module Interface
     class RackInterface
-      
+
       attr_reader :router
-      
+      attr_accessor :app
+
+      DEFAULT_APPLICATION = lambda do |env|
+        Rack::Response.new("No route found", 404).finish
+      end
+
       class Builder < Rack::Builder
-        
+
         def initialize(&block)
           @usher = Usher::Interface::RackInterface.new
           super
         end
-        
+
         def map(path, options = nil, &block)
           @usher.add(path, options).to(&block)
           @ins << @usher unless @ins.last == @usher
         end
-        
+
       end
-      
-      def initialize(&blk)
+
+      def initialize(app = nil, &blk)
+        @app = app || DEFAULT_APPLICATION
         @router = Usher.new(:request_methods => [:request_method, :host, :port, :scheme], :generator => Usher::Util::Generators::URL.new)
         instance_eval(&blk) if blk
       end
-      
+
       def dup
         new_one = super
         original = self
@@ -33,15 +39,15 @@ class Usher
         end
         new_one
       end
-      
+
       def add(path, options = nil)
         @router.add_route(path, options)
-      end
-      
+       end
+
       def parent_route=(route)
         @router.parent_route = route
       end
-      
+
       def parent_route
         @router.parent_route
       end
@@ -51,30 +57,43 @@ class Usher
       end
 
       def call(env)
-        env['usher.params'] ||= {}
         response = @router.recognize(request = Rack::Request.new(env), request.path_info)
-        if response.nil?
-          body = "No route found"
-          headers = {"Content-Type" => "text/plain", "Content-Length" => body.length.to_s}
-          [404, headers, [body]]
-        else
-          params = response.path.route.default_values || {}
-          response.params.each{ |hk| params[hk.first] = hk.last}
-          
-          # consume the path_info to the script_name response.remaining_path
-          env["SCRIPT_NAME"] << response.matched_path   || ""
-          env["PATH_INFO"] = response.remaining_path    || ""
-                    
-          env['usher.params'].merge!(params)
-          
-          response.path.route.destination.call(env)
-        end
+        after_match(env, response) if response
+        determine_respondant(response).call(env)
       end
 
       def generate(route, params = nil, options = nil)
         @usher.generator.generate(route, params, options)
       end
 
+      # Allows a hook to be placed for sub classes to make use of between matching
+      # and calling the application
+      #
+      # @api plugin
+      def after_match(env, response)
+        env['usher.params'] ||= {}
+        params = response.path.route.default_values || {}
+        response.params.each{|hk| params[hk.first] = hk.last}
+        env['usher.params'].merge!(params)
+
+        # consume the path_info to the script_name response.remaining_path
+        env["SCRIPT_NAME"] << response.matched_path   || ""
+        env["PATH_INFO"] = response.remaining_path    || ""
+      end
+
+      # Determines which application to respond with.
+      #
+      #  Within the request when determine respondant is called
+      #  If there is a matching route to an application, that
+      #  application is called, Otherwise the middleware application is called.
+      #
+      # @api private
+      def determine_respondant(response)
+        return app if response.nil?
+        respondant = response.path.route.destination
+        respondant = app unless respondant.respond_to?(:call)
+        respondant
+      end
     end
   end
 end

data/lib/usher/interface/text_interface.rb

@@ -0,0 +1,44 @@
+class Usher
+  module Interface
+    class TextInterface
+      
+      def initialize(&blk)
+        @usher = Usher.new(:delimiters => [' '], :generator => Usher::Util::Generators::Generic.new)
+        instance_eval(&blk) if blk
+      end
+      
+      def generate(name, params = nil)
+        @usher.generator.generate(name, params)
+      end
+      
+      def on(text, name = nil, &blk)
+        r = @usher.add_route(text).to(:block => blk, :arg_type => :array)
+        r.name(name) if name
+      end
+      
+      def unrecognized(&blk)
+        @unrecognize_block = blk
+      end
+      
+      def on_with_hash(text, name = nil, &blk)
+        r = @usher.add_route(text).to(:block => blk, :arg_type => :hash)
+        r.name(name) if name
+      end
+      
+      def run(text)
+        response = @usher.recognize_path(text.strip)
+        if response
+          case response.path.route.destination[:arg_type]
+          when :hash
+            response.path.route.destination[:block].call(response.params.inject({}){|h,(k,v)| h[k]=v; h })
+          when :array
+            response.path.route.destination[:block].call(*response.params.collect{|p| p.last})
+          end
+        else
+          @unrecognize_block ? @unrecognize_block.call(text) : nil
+        end
+      end
+
+    end
+  end
+end

data/lib/usher/node.rb

@@ -108,15 +108,7 @@ class Usher
     end
     
     def find(usher, request_object, original_path, path, params = [], position = 0)
-      if request_method_type
-        if (specific_node = request[request_object.send(request_method_type)]) && (ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
-          ret
-        elsif (general_node = request[nil]) && (ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position))
-          ret
-        else
-          nil
-        end
-      elsif terminates? && (path.empty? || terminates.route.partial_match?)
+      if terminates? && (path.empty? || terminates.route.partial_match?)
         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)
@@ -130,7 +122,7 @@ class Usher
         case next_part.value
         when Route::Variable::Glob
           params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
-          loop do
+          while true
             if (next_part.value.look_ahead === part || (!usher.delimiter_chars.include?(part[0]) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
               path.unshift(part)
               position -= part.size
@@ -153,13 +145,21 @@ class Usher
           var = next_part.value
           var.valid!(part)
           params << [var.name, part]
-          until (var.look_ahead === path.first) || path.empty?
+          until path.empty? || (var.look_ahead === path.first)
             next_path_part = path.shift
             position += next_path_part.size
             params.last.last << next_path_part
-          end
+          end if var.look_ahead && usher.delimiter_chars.size > 1
         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)]) && (ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          ret
+        elsif (general_node = request[nil]) && (ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          ret
+        else
+          nil
+        end
       else
         nil
       end

data/lib/usher/route.rb

@@ -8,16 +8,16 @@ class Usher
     attr_reader   :paths, :requirements, :conditions,
                   :destination, :named, :generate_with,
                   :default_values, :match_partially
-    attr_accessor :parent_route
-    
+    attr_accessor :parent_route, :router
+
     GenerateWith = Struct.new(:scheme, :port, :host)
-    
-    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)            
+
+    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)
       @paths = parsed_paths.collect {|path| Path.new(self, path)}
       @router, @requirements, @conditions, @default_values, @match_partially = router, requirements, conditions, default_values, match_partially
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
     end
-    
+
     def grapher
       unless @grapher
         @grapher = Grapher.new
@@ -28,7 +28,9 @@ class Usher
 
     def dup
       result = super
-      result.grapher = nil
+      result.instance_eval do
+        @grapher = nil
+      end
       result
     end
 
@@ -38,17 +40,17 @@ class Usher
       else
         matching_path = @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
       end
-      
+
       if parent_route
         matching_path = parent_route.find_matching_path(params).merge(matching_path)
         matching_path.route = self
       end
-      
+
       matching_path
     end
-    
+
     # Sets +options+ on a route. Returns +self+.
-    #   
+    #
     #   Request = Struct.new(:path)
     #   set = Usher.new
     #   route = set.add_route('/test')
@@ -66,7 +68,7 @@ class Usher
     end
 
     # Sets route as referenceable from +name+. Returns +self+.
-    #   
+    #
     #   set = Usher.new
     #   route = set.add_route('/test').name(:route)
     #   set.generate_url(:route) => '/test'
@@ -75,16 +77,16 @@ class Usher
       @router.name(name, self)
       self
     end
-    
+
     def match_partially!
       @match_partially = true
       self
     end
-    
+
     def partial_match?
       @match_partially
     end
-    
+
     private
     attr_writer :grapher
 

data/lib/usher/util/generate.rb

@@ -1,35 +1,46 @@
-require 'rack'
+class Usher
+  module Util
+    class Generators
 
-unless Rack::Utils.respond_to?(:uri_escape)
-  module Rack
+      class Generic
 
-    module Utils
+        attr_accessor :usher
 
-      def uri_escape(s)
-        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
-          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
-        }.tr(' ', '+')
-      end
-      module_function :uri_escape
+        def generate(name, params)
+          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
+              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
 
-      def uri_unescape(s)
-        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-          [$1.delete('%')].pack('H*')
-        }
       end
-      module_function :uri_unescape
 
-    end
-  end
-end
+      class URL < Generic
 
-class Usher
-  module Util
-    class Generators
-    
-      class URL
-      
-        attr_accessor :usher
+        def initialize
+          require File.join(File.dirname(__FILE__), 'rack-mixins')
+        end
 
         def generate_full(routing_lookup, request, params = nil)
           path = path_for_routing_lookup(routing_lookup, params)
@@ -37,10 +48,75 @@ class Usher
           result << generate_path(path, params)
         end
 
+        # Generates a completed URL based on a +route+ or set of optional +params+
+        #
+        #   set = Usher.new
+        #   route = set.add_named_route(:test_route, '/:controller/:action')
+        #   set.generator.generate(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        #   set.generator.generate(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        #   set.generator.generate(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
         def generate(routing_lookup, params = nil)
           generate_path(path_for_routing_lookup(routing_lookup, params), params)
         end
 
+        def generate_path(path, params = nil)
+          params = Array(params) if params.is_a?(String)
+          if params.is_a?(Array)
+            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.merge!(extra_params) if extra_params
+          end
+
+          result = Rack::Utils.uri_escape(generate_path_for_base_params(path, params))
+          unless params.nil? || params.empty?
+            extra_params = generate_extra_params(params, result[??])
+            result << extra_params
+          end
+          result
+        end
+
+        def generation_module
+          build_module!
+          @generation_module
+        end
+
+        def build_module!
+          unless @generation_module
+            @generation_module = Module.new
+            @generation_module.module_eval <<-END_EVAL
+              @@generator = nil
+              def self.generator=(generator)
+                @@generator = generator
+              end
+            END_EVAL
+            @generation_module.generator = self
+
+            @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))
+                else
+                  super
+                end
+              end
+            END_EVAL
+
+
+            usher.named_routes.each do |name, route|
+              @generation_module.module_eval <<-END_EVAL
+                def #{name}_url(name, request, params = nil)
+                  @@generator.generate_full(name, request, options)
+                end
+
+                def #{name}_path(name, params = nil)
+                  @@generator.generate(name, options)
+                end
+              END_EVAL
+            end
+          end
+        end
+
         def generate_start(path, request)
           result = (path.route.generate_with && path.route.generate_with.scheme || request.scheme).dup
           result << '://'
@@ -53,77 +129,42 @@ class Usher
           end
           result
         end
-        
+
         def path_for_routing_lookup(routing_lookup, params = {})
           path = case routing_lookup
           when Symbol
-            route = @usher.named_routes[routing_lookup] 
+            route = @usher.named_routes[routing_lookup]
+            raise UnrecognizedException unless route
             route.find_matching_path(params || {})
           when Route
-            routing_lookup.find_matching_path(params || {})
+            routing_lookup.find_matching_path(params)
           when nil
-            params.is_a?(Hash) ? @usher.path_for_options(params) : raise
+            params.is_a?(Hash) ? usher.path_for_options(params) : raise
           when Route::Path
             routing_lookup
           end
         end
-    
-        # Generates a completed URL based on a +route+ or set of optional +params+
-        #   
-        #   set = Usher.new
-        #   route = set.add_named_route(:test_route, '/:controller/:action')
-        #   set.generate_url(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-        #   set.generate_url(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-        #   set.generate_url(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-        def generate_path(path, params = nil)
-          raise UnrecognizedException.new unless path
 
-          params = Array(params) if params.is_a?(String)
-          if params.is_a?(Array)
-            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.merge!(extra_params) if extra_params
-          end
 
-          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 << '/' 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
-            else
-              result << part
-            end
-          end
-          result = Rack::Utils.uri_escape(result)
+        def generate_extra_params(params, has_question_mark)
+          extra_params_result = ''
 
-          unless params.nil? || params.empty?
-            has_query = result[??]
-            params.each do |k,v|
-              case v
-              when Array
-                v.each do |v_part|
-                  result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
-                end
-              else
-                result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
+          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)
               end
+            else
+              extra_params_result << (has_question_mark ? '&' : has_question_mark = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
             end
           end
-          result
+          extra_params_result
         end
-      
+
       end
-      
+
     end
   end
-end
+end
+

data/lib/usher/util/rack-mixins.rb

@@ -0,0 +1,24 @@
+require 'rack'
+
+unless Rack::Utils.respond_to?(:uri_escape)
+  module Rack
+
+    module Utils
+
+      def uri_escape(s)
+        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+        }.tr(' ', '+')
+      end
+      module_function :uri_escape
+
+      def uri_unescape(s)
+        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+          [$1.delete('%')].pack('H*')
+        }
+      end
+      module_function :uri_unescape
+
+    end
+  end
+end

data/spec/private/generate_spec.rb

@@ -2,37 +2,37 @@ require 'lib/usher'
 require 'rack'
 
 describe "Usher URL generation" do
-  
+
   before(:each) do
     @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new)
     @route_set.reset!
   end
-  
+
   it "should generate a simple URL" do
     @route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'action')
     @route_set.generator.generate(:sample, {}).should == '/sample'
   end
-  
+
   it "should generate a simple URL with a single variable" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => 'action'}).should == '/sample/action'
   end
-  
+
   it "should generate a simple URL with a single variable (and escape)" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => 'action time'}).should == '/sample/action%20time'
   end
-  
+
   it "should generate a simple URL with a single variable (thats not a string)" do
     @route_set.add_named_route(:sample, '/sample/:action/:id', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
   end
-  
+
   it "should generate a simple URL with a glob variable" do
     @route_set.add_named_route(:sample, '/sample/*action', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
   end
-  
+
   it "should generate a mutliple vairable URL from a hash" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
     @route_set.generator.generate(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
@@ -125,7 +125,7 @@ describe "Usher URL generation" do
     @route_set.add_named_route(:name, '/:one/:two/:three', {:default_values => {:one => 'one', :two => 'two', :three => 'three'}})
     @route_set.generator.generate(:name).should == '/one/two/three'
   end
-  
+
   it "should generate a route using defaults and optionals using the last parameter" do
     @route_set.add_named_route(:opts_with_defaults, '/:one(/:two(/:three))', {:default_values => {:one => '1', :two => '2', :three => '3'}})
     @route_set.generator.generate(:opts_with_defaults, {:three => 'three'}).should == '/1/2/three'
@@ -135,61 +135,114 @@ describe "Usher URL generation" do
     @route_set.add_named_route(:optionals, '/:controller(/:action(/:id))(.:format)')
     @route_set.generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
   end
-  
+
   describe "nested generation" do
     before do
       @route_set2 = Usher.new(:generator => Usher::Util::Generators::URL.new)
       @route_set3 = Usher.new(:generator => Usher::Util::Generators::URL.new)
       @route_set4 = Usher.new(:generator => Usher::Util::Generators::URL.new)
-      
+
       @route_set.add_named_route(:simple,   "/mount_point").match_partially!.to(@route_set2)
       @route_set.add_route("/third/:foo", :default_values => {:foo => "foo"}).match_partially!.to(@route_set3)
       @route_set.add_route("/fourth/:bar").match_partially!.to(@route_set4)
-      
+
       @route_set2.add_named_route(:nested_simple,   "/nested/simple",     :controller => "nested",  :action => "simple")
       @route_set2.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
-      
+
       @route_set3.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
       @route_set3.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
-      
+
       @route_set4.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
     end
-    
+
     it "should generate a route for the simple nested route" do
       @route_set2.generator.generate(:nested_simple).should == "/mount_point/nested/simple"
     end
-    
+
     it "should generate a simple route without optional segments" do
       @route_set2.generator.generate(:nested_complex).should == "/mount_point/another_nested"
     end
-    
+
     it "should generate a route with optional segements" do
       @route_set2.generator.generate(:nested_complex, :complex => "foo").should == "/mount_point/another_nested/foo"
     end
-    
+
     it "should genearte a route with the specified value for the parent route" do
       @route_set3.generator.generate(:nested_simple, :foo => "bar").should == "/third/bar/nested/simple"
     end
-    
+
     it "should generate a route with the default value from the parent route" do
       @route_set3.generator.generate(:nested_simple).should == "/third/foo/nested/simple"
     end
-    
+
     it "should generate a route with an optional segement in the parent and child" do
       @route_set3.generator.generate(:nested_complex, :complex => "complex").should == "/third/foo/another_nested/complex"
     end
-    
+
     it "should generate a route without the optional value from the child" do
       @route_set3.generator.generate(:nested_complex).should == "/third/foo/another_nested"
     end
-    
+
     it "should raise an exception when trying to generate a route where the parent variable is not defined and does not have a default value" do
       lambda do
         @route_set4.generator.generate(:nested_simple)
       end.should raise_error(Usher::MissingParameterException)
     end
-    
-    
-    
   end
-end
+
+  describe "dupped generation" do
+    before(:each) do
+      @r1 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @r2 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @r3 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+
+      @r1.add_route("/r1", :router => "r1").name(:route)
+      @r2.add_route("/r2", :router => "r2").name(:route)
+      @r3.add_route("/r3", :router => "r3").name(:route)
+    end
+
+    it "should generate dupped routes" do
+      @r1.generator.generate(:route).should == "/r1"
+      r1 = @r1.dup
+      r1.generator.generate(:route).should == "/r1"
+    end
+
+    it "should not generate new routes added to a dup on the original" do
+      r1 = @r1.dup
+      r1.add_route("/new_r1", :router => "r4").name(:new_route)
+      lambda do
+        @r1.generator.generate(:new_route).should be_nil
+      end
+    end
+
+    it "should generate new routes added to a dup" do
+      r1 = @r1.dup
+      r1.add_route("/new_r1", :router => "r4").name(:new_route)
+      r1.generator.generate(:new_route).should == "/new_r1"
+    end
+
+    it "should generate a route for a nested usher" do
+      @r1.add_route("/mounted").match_partially!.to(@r2)
+      @r2.generator.generate(:route).should == "/mounted/r2"
+    end
+
+    it "should generate a route for a dupped nested usher" do
+      r3 = @r3.dup
+      @r1.add_route("/mounted").match_partially!.to(r3)
+      r3.generator.generate(:route).should == "/mounted/r3"
+    end
+
+    it "should generate a route for 2 differently mounted dupped ushers" do
+      r21 = @r2.dup
+      r22 = @r2.dup
+
+      @r1.add_route("/mounted").match_partially!.to(r21)
+      @r1.add_route("/other_mount").match_partially!.to(r22)
+
+      r21.generator.generate(:route).should == "/mounted/r2"
+      r22.generator.generate(:route).should == "/other_mount/r2"
+      @r2.generator.generate(:route).should == "/r2"
+    end
+  end
+
+end

data/spec/private/rack/dispatch_spec.rb

@@ -55,40 +55,40 @@ describe "Usher (for rack) route dispatching" do
     response = route_set.call_with_mock_request("/not-existing-url")
     response.status.should eql(404)
   end
-  
+
   describe "mounted rack instances" do
     before do
       @bad_app = mock("bad_app")
-      
+
       @usher2 = Usher::Interface.for(:rack)
       @usher2.add("/good" ).to(@app)
       @usher2.add("/bad"  ).match_partially!.to(@bad_app)
       @usher2.add("/some(/:foo)").to(@app)
-      
+
       route_set.add("/foo/:bar", :default_values => {:foo => "foo"}).match_partially!.to(@usher2)
       route_set.add("/foo", :default_values => {:controller => :foo}).to(@app)
     end
-    
+
     it "should match the route without nesting" do
       @app.should_receive(:call).once.with{ |e| e['usher.params'].should == {:controller => :foo}}
       route_set.call(Rack::MockRequest.env_for("/foo"))
     end
-    
+
     it "should route through the first route, and the second to the app" do
       @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "foo"}}
       result = route_set.call(Rack::MockRequest.env_for("/foo/bar/good"))
     end
-    
+
     it "should go through to the bad app" do
       @bad_app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "some_bar", :foo => "foo"}}
       result = route_set.call(Rack::MockRequest.env_for("/foo/some_bar/bad"))
     end
-    
+
     it "should match optional routes paramters" do
       @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "a_different_foo"}}
       route_set.call(Rack::MockRequest.env_for("/foo/bar/some/a_different_foo"))
     end
-    
+
     describe "SCRIPT_NAME & PATH_INFO" do
       it "should update the script name for a fully consumed route" do
         @app.should_receive(:call).once.with do |e|
@@ -97,48 +97,48 @@ describe "Usher (for rack) route dispatching" do
         end
         route_set.call(Rack::MockRequest.env_for("/foo"))
       end
-      
+
       it "should update the script name and path info for a partially consumed route" do
         @app.should_receive(:call).once.with do |e|
           e['SCRIPT_NAME'].should == "/partial"
           e['PATH_INFO'].should   == "/bar/baz"
         end
-        
+
         route_set.add("/partial").match_partially!.to(@app)
         route_set.call(Rack::MockRequest.env_for("/partial/bar/baz"))
       end
-      
+
       it "should consume the path through a mounted usher" do
         @bad_app.should_receive(:call).once.with do |e|
           e['SCRIPT_NAME'].should == "/foo/bar/bad"
           e['PATH_INFO'].should   == "/leftovers"
         end
-        
+
         route_set.call(Rack::MockRequest.env_for("/foo/bar/bad/leftovers"))
       end
-      
+
     end
-    
+
     describe "dupping" do
-      before do 
+      before do
         @app  = mock("app")
         @u1   = Usher::Interface.for(:rack)
         @u2   = Usher::Interface.for(:rack)
-        
+
         @u1.add("/one", :default_values => {:one => :one}).to(@app)
         @u1.add("/mount").match_partially!.to(@u2)
-        
+
         @u2.add("/app", :default_values => {:foo => :bar}).to(@app)
-        
+
       end
-      
+
       it "should allow me to dup the router" do
         @app.should_receive(:call).twice.with{|e| e['usher.params'].should == {:one => :one}}
         @u1.call(Rack::MockRequest.env_for("/one"))
         u1_dash = @u1.dup
         u1_dash.call(Rack::MockRequest.env_for("/one"))
       end
-      
+
       it "should allow me to dup the router and add a new route without polluting the original" do
         @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
         u1_dash = @u1.dup
@@ -147,27 +147,53 @@ describe "Usher (for rack) route dispatching" do
         @app.should_not_receive(:call)
         @u1.call(Rack::MockRequest.env_for("/foo"))
       end
-      
+
       it "should allow me to dup the router and nested routers should remain intact" do
         @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
         u1_dash = @u1.dup
         u1_dash.call(Rack::MockRequest.env_for("/mount/app"))
       end
-      
+
       it "should allow me to dup the router and add more routes" do
         @app.should_receive(:call).with{|e| e['usher.params'].should == {:another => :bar}}
-        
+
         u3 = Usher::Interface.for(:rack)
         u1_dash = @u1.dup
-        
+
         u3.add("/another_bar", :default_values => {:another => :bar}).to(@app)
         u1_dash.add("/some/mount").match_partially!.to(u3)
-        
+
         u1_dash.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
-        
+
         @app.should_not_receive(:call)
         @u1.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
       end
     end
   end
+  
+  describe "use as middlware" do
+    it "should allow me to set a default application to use" do
+      @app.should_receive(:call).with{|e| e['usher.params'].should == {:middle => :ware}}
+
+      u = Usher::Interface::RackInterface.new(@app)
+      u.add("/foo", :default_values => {:middle => :ware}).name(:foo)
+
+      u.call(Rack::MockRequest.env_for("/foo"))
+    end
+
+    it "should use the default application when no routes match" do
+      env = Rack::MockRequest.env_for("/not_a_route")
+      @app.should_receive(:call).with(env)
+      u = Usher::Interface::RackInterface.new(@app)
+      u.call(env)
+    end
+
+    it "should allow me to set the application after initialization" do
+      @app.should_receive(:call).with{|e| e['usher.params'].should == {:after => :stuff}}
+      u = Usher::Interface.for(:rack)
+      u.app = @app
+      u.add("/foo", :default_values => {:after => :stuff})
+      u.call(Rack::MockRequest.env_for("/foo"))
+    end
+  end
 end

data/spec/private/recognize_spec.rb

@@ -195,6 +195,14 @@ describe "Usher route recognition" do
     route_set.recognize(build_request({:method => 'get', :path => '/testing/asd.qwe/testing2/poi.zxc/oiu.asd'})).params.should == [[:id, 'asd.qwe'], [:id2, 'poi.zxc'], [:id3, 'oiu.asd']]
   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'}))
+    result.params.should == [[:name, "homer"]]
+    result = route_set.recognize(build_request({:method => 'get', :path => "/homer/simpson"}))
+    result.params.should == [[:name, "homer"],[:surname, "simpson"]]
+  end  
+  
   it "should should raise if malformed variables are used" do
     route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
     proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error
@@ -228,8 +236,8 @@ describe "Usher route recognition" do
     end
         
     it "should recognize the originals routes in the dup" do
-      route_set.recognize(build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
-      @r2.recognize(      build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
+      route_set.recognize(  build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
+      @r2.recognize(        build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
     end
 
     it "should not add routes added to the dup to the original" do
@@ -240,8 +248,8 @@ describe "Usher route recognition" do
     
     it "should not delete routes added to the dup to the original" do
       @r2.delete_route("/foo")
-      route_set.recognize(        build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
-      @r2.recognize(  build_request(:path => "/foo")).should == nil
+      route_set.recognize(  build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
+      @r2.recognize(        build_request(:path => "/foo")).should == nil
     end
     
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-28 00:00:00 -04:00
+date: 2009-09-05 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,7 @@ files:
 - lib/usher/interface/rails2_2_interface/mapper.rb
 - lib/usher/interface/rails2_3_interface.rb
 - lib/usher/interface/rails3_interface.rb
+- lib/usher/interface/text_interface.rb
 - lib/usher/node.rb
 - lib/usher/route.rb
 - lib/usher/route/path.rb
@@ -59,6 +60,7 @@ files:
 - lib/usher/util.rb
 - lib/usher/util/generate.rb
 - lib/usher/util/parser.rb
+- lib/usher/util/rack-mixins.rb
 - rails/init.rb
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb