usher 0.6.3 → 0.6.4

data/Rakefile

@@ -1,12 +1,10 @@
 # encoding: utf-8
 
-require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'usher'))
-
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |s|
     s.name = "usher"
-    s.description = s.summary = "A general purpose routing library"
+    s.description = s.summary = "Pure ruby general purpose router with interfaces for rails, rack, email or choose your own adventure"
     s.email = "joshbuddy@gmail.com"
     s.homepage = "http://github.com/joshbuddy/usher"
     s.authors = ["Joshua Hull", 'Jakub Šťastný', 'Daniel Neighman', 'Daniel Vartanov'].sort

data/VERSION.yml

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

data/lib/usher/interface/email.rb

@@ -1,12 +1,12 @@
 class Usher
   module Interface
     class Email
-      
+
       def initialize(&blk)
         @routes = Usher.new(:delimiters => ['@', '-', '.'], :valid_regex => '[\+a-zA-Z0-9]+')
         instance_eval(&blk) if blk
       end
-      
+
       def for(path, &block)
         @routes.add_route(path).to(block)
       end
@@ -18,10 +18,10 @@ class Usher
       def act(email)
         response = @routes.recognize(email, email)
         if response.path
-          response.path.route.destination.call(response.params.inject({}){|h,(k,v)| h[k]=v.to_s; h })
+          response.path.route.destination.call(response.params_as_hash)
         end
       end
 
     end
   end
-end
+end

data/lib/usher/interface/rack.rb

@@ -4,24 +4,24 @@ require File.join(File.dirname(__FILE__), 'rack', 'route')
 class Usher
   module Interface
     class Rack
-      
+
       ENV_KEY_RESPONSE = 'usher.response'
       ENV_KEY_PARAMS = 'usher.params'
-      
+
       class Middleware
-        
+
         def initialize(app, router)
           @app = app
           @router = router
         end
-        
+
         def call(env)
           @router.call(env)
           @app.call(env)
         end
-        
+
       end
-      
+
       class Builder < ::Rack::Builder
         def initialize(&block)
           @usher = Usher::Interface::Rack.new
@@ -79,7 +79,7 @@ class Usher
         @router.add_route(path, options)
       end
       alias_method :path, :add
-      
+
       # default { |env| ... }
       # default DefaultApp
       def default(app = nil, &block)
@@ -138,14 +138,14 @@ class Usher
       # @api plugin
       def after_match(request, response)
         params = response.path.route.default_values ? response.path.route.default_values.merge(response.params_as_hash) : response.params_as_hash
-        
+
         request.env[ENV_KEY_RESPONSE] ||= []
         request.env[ENV_KEY_RESPONSE] << response
 
         request.env[ENV_KEY_PARAMS] ?
           request.env[ENV_KEY_PARAMS].merge!(params) :
           (request.env[ENV_KEY_PARAMS] = params)
-        
+
         # consume the path_info to the script_name
         # response.remaining_path
         consume_path!(request, response) if response.partial_match?
@@ -159,7 +159,11 @@ class Usher
       #
       # @api private
       def determine_respondant(response)
-        use_destinations? && response && response.destination || _app
+        if use_destinations? && response && response.destination && response.destination.respond_to?(:call)
+          response.destination
+        else
+          _app
+        end
       end
 
       # Consume the path from path_info to script_name
@@ -167,14 +171,14 @@ class Usher
         request.env["SCRIPT_NAME"] = (request.env["SCRIPT_NAME"] + response.matched_path)   || ""
         request.env["PATH_INFO"] = response.remaining_path    || ""
       end
-      
+
       def default_app
         _app
       end
-      
+
       private
       attr_reader :_app
-      
+
     end
   end
 end

data/lib/usher/interface/rails22.rb

@@ -46,7 +46,7 @@ class Usher
       
       def recognize(request)
         node = @usher.recognize(request)
-        params = node.params.inject({}){|h,(k,v)| h[k]=v; h }
+        params = node.params_as_hash
         request.path_parameters = (node.params.empty? ? node.path.route.destination : node.path.route.destination.merge(params)).with_indifferent_access
         "#{request.path_parameters[:controller].camelize}Controller".constantize
       rescue

data/lib/usher/interface/rails23.rb

@@ -1,13 +1,13 @@
 class Usher
   module Interface
     class Rails23
-      
+
       attr_reader :configuration_files
-      
+
       def named_routes
         @router.named_routes
       end
-      
+
       def add_named_route(name, route, options = {})
         @router.add_route(route, options).name(name)
       end
@@ -15,38 +15,38 @@ class Usher
       def add_route(path, options = {})
         if !@controller_action_route_added && path =~ %r{^/?:controller/:action/:id$}
           add_route('/:controller/:action', options.dup)
-          @controller_action_route_added = true 
+          @controller_action_route_added = true
         end
 
         if !@controller_route_added && path =~ %r{^/?:controller/:action$}
           add_route('/:controller', options.merge({:action => 'index'}))
-          @controller_route_added = true 
+          @controller_route_added = true
         end
-        
+
         options[:action] = 'index' unless options[:action]
 
         path[0, 0] = '/' unless path[0] == ?/
         route = @router.add_route(path, options).to(options)
-        
+
         raise "your route must include a controller" unless (route.paths.first.dynamic_keys && route.paths.first.dynamic_keys.include?(:controller)) || route.destination.include?(:controller)
         route
       end
-      
+
       def initialize
         reset!
       end
-      
+
       def add_configuration_file(file)
         @configuration_files << file
       end
-      
+
       def reload!
         if configuration_files.any?
           configuration_files.each { |config| load(config) }
         else
           add_route ":controller/:action/:id"
         end
-        
+
       end
       alias_method :reload, :reload!
 
@@ -63,75 +63,74 @@ class Usher
         app = recognize(request)
         app.call(env).to_a
       end
-      
+
       def recognize(request)
         response = @router.recognize(request)
-        request.path_parameters = (response.params.empty? ? response.path.route.destination : response.path.route.destination.merge(response.params.inject({}){|h,(k,v)| h[k]=v; h })).with_indifferent_access
-        response.params.each { |pair| request.path_parameters[pair.first] = pair.last }
+        request.path_parameters.merge!(response.params_as_hash)
         "#{request.path_parameters[:controller].camelize}Controller".constantize
       end
-      
+
       def reset!(options={})
         options[:generator] = options[:generator] || Usher::Util::Generators::URL.new
         options[:request_methods] = options[:request_methods] || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
-                
+
         @router = Usher.new(options)
         @configuration_files = []
         @module ||= Module.new
         @controller_route_added = false
         @controller_action_route_added = false
       end
-      
+
       def draw(options={})
         reset!(options)
         yield ActionController::Routing::RouteSet::Mapper.new(self)
         install_helpers
       end
-      
+
       def install_helpers(destinations = [ActionController::Base, ActionView::Base], regenerate_code = false)
         #*_url and hash_for_*_url
-        Array(destinations).each do |d| d.module_eval { include Helpers } 
+        Array(destinations).each do |d| d.module_eval { include Helpers }
           @router.named_routes.keys.each do |name|
             @module.module_eval <<-end_eval # We use module_eval to avoid leaks
-              def #{name}_url(options = {})
-                ActionController::Routing::UsherRoutes.generate(options, {}, :generate, :#{name})
-              end
-            end_eval
-          end
-          d.__send__(:include, @module)
-        end
-      end
+            def #{name}_url(options = {})
+              ActionController::Routing::UsherRoutes.generate(options, {}, :generate, :#{name})
+                                                              end
+                                                              end_eval
+                                                              end
+                                                              d.__send__(:include, @module)
+                                                              end
+                                                              end
 
-      def generate(options, recall = {}, method = :generate, route_name = nil)
-        route = if(route_name)
-          @router.named_routes[route_name]
-        else
-          merged_options = options
-          merged_options[:controller] = recall[:controller] unless options.key?(:controller)
-          unless options.key?(:action)
-            options[:action] = ''
-          end
-          path_for_options(merged_options)
-        end
-        case method
-        when :generate
-          merged_options ||= recall.merge(options)
-          url = generate_url(route, merged_options)
-          url.slice!(-1) if url[-1] == ?/
-          url 
-        else
-          raise "method #{method} not recognized"
-        end
-      end
-      
-      def generate_url(route, params)
-        @router.generator.generate(route, params)
-      end
-      
-      def path_for_options(options)
-        @router.path_for_options(options)
-      end
-      
-    end
-  end
-end
+                                                              def generate(options, recall = {}, method = :generate, route_name = nil)
+                                                                route = if(route_name)
+                                                                  @router.named_routes[route_name]
+                                                                else
+                                                                  merged_options = options
+                                                                  merged_options[:controller] = recall[:controller] unless options.key?(:controller)
+                                                                  unless options.key?(:action)
+                                                                    options[:action] = ''
+                                                                  end
+                                                                  path_for_options(merged_options)
+                                                                end
+                                                                case method
+                                                                  when :generate
+                                                                    merged_options ||= recall.merge(options)
+                                                                    url = generate_url(route, merged_options)
+                                                                    url.slice!(-1) if url[-1] == ?/
+                                                                    url
+                                                                  else
+                                                                    raise "method #{method} not recognized"
+                                                                end
+                                                              end
+
+                                                              def generate_url(route, params)
+                                                                @router.generator.generate(route, params)
+                                                              end
+
+                                                              def path_for_options(options)
+                                                                @router.path_for_options(options)
+                                                              end
+
+                                                              end
+                                                              end
+                                                              end

data/lib/usher/node/response.rb

@@ -0,0 +1,22 @@
+class Usher
+  class Node
+    class Response < Struct.new(:path, :params_as_array, :remaining_path, :matched_path)
+
+      def params
+        @params ||= params_as_array.nil? ? [] : path.convert_params_array(params_as_array)
+      end
+
+      def partial_match?
+        !remaining_path.nil?
+      end
+
+      def params_as_hash
+        @params_as_hash ||= params_as_array.nil? ? {} : params_as_array.inject({}){|hash, val| hash[path.dynamic_keys[hash.size]] = val; hash}
+      end
+
+      def destination
+        path && path.route.destination
+      end
+    end
+  end
+end

data/lib/usher/node/root.rb

@@ -0,0 +1,140 @@
+class Usher
+  class Node
+    class Root < Node
+      
+      def initialize(route_set, request_methods)
+        super(route_set, nil)
+        self.request_methods = request_methods
+      end
+      
+      def add(route)
+        route.paths.each do |path|
+          set_path_with_destination(path)
+        end
+      end
+
+      def delete(route)
+        route.paths.each do |path|
+          set_path_with_destination(path, nil)
+        end
+      end
+
+      def unique_routes(node = self, routes = [])
+        routes << node.terminates.route if node.terminates
+        node.normal.values.each do |v|
+          unique_routes(v, routes)
+        end if node.normal
+        node.greedy.values.each do |v|
+          unique_routes(v, routes)
+        end if node.greedy
+        node.request.values.each do |v|
+          unique_routes(v, routes)
+        end if node.request
+        routes.uniq!
+        routes
+      end
+
+      private
+      
+      def set_path_with_destination(path, destination = path)
+        nodes = [path.parts.inject(self){ |node, key| process_path_part(node, key) }]
+        nodes = process_request_parts(nodes, request_methods_for_path(path)) if request_methods
+
+        nodes.each do |node|
+          while node.request_method_type
+            node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))
+          end
+          node.terminates = destination
+        end
+      end
+
+      def request_method_index(type)
+        request_methods.index(type)
+      end
+
+      def process_request_parts(nodes, parts)
+        while parts.any?{ |p| !p.trivial? }
+          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)
+              Array(key.value).map{|k| node.request[k] ||= Node.new(node, key) }
+            else
+              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[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) }
+                when 1
+                  previous_node = node.parent
+                  current_node_entry_key = nil
+                  current_node_entry_lookup = nil
+                  [previous_node.normal, previous_node.greedy, previous_node.request].compact.each do |l|
+                    current_node_entry_key = l.each{|k,v| break k if node == v}
+                    current_node_entry_lookup = l and break if current_node_entry_key
+                  end
+
+                  current_node_entry_lookup.respond_to?(:delete_value) ?
+                    current_node_entry_lookup.delete_value(node) : current_node_entry_lookup.delete_if{|k,v| v == node}
+
+                  new_node = Node.new(previous_node, Route::RequestMethod.new(key.type, nil))
+                  new_node.activate_request!
+                  new_node.request_method_type = key.type
+                  current_node_entry_lookup[current_node_entry_key] = new_node
+                  node.parent = new_node
+                  new_node.request[nil] = node
+                  parts.unshift(key)
+                  new_node
+              end
+            end
+          end
+          nodes.flatten!
+        end
+        nodes
+      end
+
+      def process_path_part(node, key)
+        case key
+          when Route::Variable::Greedy
+            node.activate_greedy!
+            if key.regex_matcher
+              node.upgrade_greedy!
+              node.greedy[key.regex_matcher] ||= Node.new(node, key)
+            else
+              node.greedy[nil] ||= Node.new(node, key)
+            end
+          when Route::Variable
+            node.activate_normal!
+            if key.regex_matcher
+              node.upgrade_normal!
+              node.normal[key.regex_matcher] ||= Node.new(node, key)
+            else
+              node.normal[nil] ||= Node.new(node, key)
+            end
+          when Route::Static::Greedy
+            node.activate_greedy!
+            node.upgrade_greedy!
+            node.greedy[key] ||= Node.new(node, key)
+          else
+            node.activate_normal!
+            node.upgrade_normal! if key.is_a?(Regexp)
+            node.normal[key] ||= Node.new(node, key)
+        end
+      end
+
+      def request_methods_for_path(path)
+        request_methods.collect do |type|
+          Route::RequestMethod.new(type, path.route.conditions && path.route.conditions[type])
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/usher/node.rb

@@ -1,23 +1,9 @@
-require 'fuzzy_hash'
+require File.join('usher', 'node', 'root')
+require File.join('usher', 'node', 'response')
 
 class Usher
-
   class Node
-    
-    class Response < Struct.new(:path, :params, :remaining_path, :matched_path)
-      def partial_match?
-        !remaining_path.nil?
-      end
-      
-      def params_as_hash
-        params.inject({}){|hash, pair| hash[pair.first] = pair.last; hash}
-      end
-      
-      def destination
-        path && path.route.destination
-      end
-    end
-    
+
     attr_reader :normal, :greedy, :request
     attr_accessor :terminates, :request_method_type, :parent, :value, :request_methods
 
@@ -29,7 +15,7 @@ class Usher
       @greedy = nil
       @request_method_type = nil
     end
-    
+
     def activate_normal!
       @normal ||= Hash.new
     end
@@ -57,16 +43,10 @@ class Usher
     def depth
       @depth ||= @parent.is_a?(Node) ? @parent.depth + 1 : 0
     end
-    
+
     def greedy?
       @greedy
     end
-    
-    def self.root(route_set, request_methods)
-      root = self.new(route_set, nil)
-      root.request_methods = request_methods
-      root
-    end
 
     def terminates?
       @terminates && @terminates.route.recognizable?
@@ -91,95 +71,68 @@ class Usher
         v.pp
       end if request
     end
-    
-    def add(route)
-      route.paths.each do |path|
-        set_path_with_destination(path)
-      end
-    end
-    
-    def delete(route)
-      route.paths.each do |path|
-        set_path_with_destination(path, nil)
-      end
-    end
-    
-    def unique_routes(node = self, routes = [])
-      routes << node.terminates.route if node.terminates
-      node.normal.values.each do |v|
-        unique_routes(v, routes)
-      end if node.normal
-      node.greedy.values.each do |v|
-        unique_routes(v, routes)
-      end if node.greedy
-      node.request.values.each do |v|
-        unique_routes(v, routes)
-      end if node.request
-      routes.uniq!
-      routes
-    end
-    
-    def find(usher, request_object, original_path, path, params = [], position = 0)
+
+    def find(usher, request_object, original_path, path, params = nil, position = 0)
       if terminates? && (path.empty? || terminates.route.partial_match? || (usher.ignore_trailing_delimiters? && path.all?{|p| usher.delimiters.include?(p)}))
         terminates.route.partial_match? ?
-          Response.new(terminates, terminates.convert_params_array(params), original_path[position, original_path.size], original_path[0, position]) :
-          Response.new(terminates, terminates.convert_params_array(params), nil, original_path)
+          Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position]) :
+          Response.new(terminates, params, nil, original_path)
       elsif !path.empty? and greedy and match_with_result_output = greedy.match_with_result(whole_path = original_path[position, original_path.size])
-				next_path, matched_part = match_with_result_output
+        next_path, matched_part = match_with_result_output
         position += matched_part.size
         whole_path.slice!(0, matched_part.size)
-        params << matched_part if next_path.value.is_a?(Route::Variable)
+        (params ||= []) << matched_part if next_path.value.is_a?(Route::Variable)
         next_path.find(usher, request_object, original_path, whole_path.empty? ? whole_path : usher.splitter.split(whole_path), params, position)
       elsif !path.empty? and normal and next_part = normal[path.first] || normal[nil]
         part = path.shift
         position += part.size
         case next_part.value
-        when String
-          # do nothing
-        when Route::Variable::Single
-          # get the variable
-          var = next_part.value
-          # do a validity check
-          var.valid!(part)
-          # because its a variable, we need to add it to the params array
-          params << part
-          until path.empty? || (var.look_ahead === path.first)                # variables have a look ahead notion, 
-            next_path_part = path.shift                                       # and until they are satified,
-            position += next_path_part.size                                   # keep appending to the value in params
-            params.last << next_path_part
-          end if var.look_ahead && usher.delimiters.size > 1
-        when Route::Variable::Glob
-          params << []
-          while true
-            if (next_part.value.look_ahead === part || (!usher.delimiters.unescaped.include?(part) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
-              path.unshift(part)
-              position -= part.size
-              if usher.delimiters.unescaped.include?(next_part.parent.value)
-                path.unshift(next_part.parent.value)
-                position -= next_part.parent.value.size
+          when String
+            # do nothing
+          when Route::Variable::Single
+            # get the variable
+            var = next_part.value
+            # do a validity check
+            var.valid!(part)
+            # because its a variable, we need to add it to the params array
+            (params ||= []) << part
+            until path.empty? || (var.look_ahead === path.first)                # variables have a look ahead notion,
+              next_path_part = path.shift                                       # and until they are satified,
+              position += next_path_part.size                                   # keep appending to the value in params
+              params.last << next_path_part
+            end if var.look_ahead && usher.delimiters.size > 1
+          when Route::Variable::Glob
+            (params ||= []) << []
+            while true
+              if (next_part.value.look_ahead === part || (!usher.delimiters.unescaped.include?(part) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
+                path.unshift(part)
+                position -= part.size
+                if usher.delimiters.unescaped.include?(next_part.parent.value)
+                  path.unshift(next_part.parent.value)
+                  position -= next_part.parent.value.size
+                end
+                break
+              elsif !usher.delimiters.unescaped.include?(part)
+                next_part.value.valid!(part)
+                params.last << part
+              end
+              if path.empty?
+                break
+              else
+                part = path.shift
               end
-              break
-            elsif !usher.delimiters.unescaped.include?(part)
-              next_part.value.valid!(part)
-              params.last << part
-            end
-            if path.empty?
-              break
-            else
-              part = path.shift
             end
-          end
         end
         next_part.find(usher, request_object, original_path, path, params, position)
       elsif request_method_type
-        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))
+        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 && 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)
+
+        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 && params.dup, position)
           return_value = usher.priority_lookups? && return_value ? [return_value, ret] : ret
         end
-        
+
         unless usher.priority_lookups?
           return_value
         else
@@ -192,106 +145,5 @@ class Usher
       end
     end
 
-    private
-    
-    def set_path_with_destination(path, destination = path)
-      nodes = [path.parts.inject(self){ |node, key| process_path_part(node, key) }]
-      nodes = process_request_parts(nodes, request_methods_for_path(path)) if request_methods
-      
-      nodes.each do |node|
-        while node.request_method_type
-          node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))
-        end
-        node.terminates = destination
-      end
-    end
-    
-    def request_method_index(type)
-      request_methods.index(type)
-    end
-    
-    def process_request_parts(nodes, parts)
-      while parts.any?{ |p| !p.trivial? }
-        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)
-            Array(key.value).map{|k| node.request[k] ||= Node.new(node, key) }
-          else
-            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[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) }
-            when 1
-              previous_node = node.parent
-              current_node_entry_key = nil
-              current_node_entry_lookup = nil
-              [previous_node.normal, previous_node.greedy, previous_node.request].compact.each do |l|
-                current_node_entry_key = l.each{|k,v| break k if node == v}
-                current_node_entry_lookup = l and break if current_node_entry_key
-              end
-
-              current_node_entry_lookup.respond_to?(:delete_value) ? 
-                current_node_entry_lookup.delete_value(node) : current_node_entry_lookup.delete_if{|k,v| v == node}
-
-              new_node = Node.new(previous_node, Route::RequestMethod.new(key.type, nil))
-              new_node.activate_request!
-              new_node.request_method_type = key.type
-              current_node_entry_lookup[current_node_entry_key] = new_node
-              node.parent = new_node
-              new_node.request[nil] = node
-              parts.unshift(key)
-              new_node
-            end
-          end
-        end
-        nodes.flatten!
-      end
-      nodes
-    end      
-      
-    
-    def process_path_part(node, key)
-      case key
-      when Route::Variable::Greedy
-        node.activate_greedy!
-        if key.regex_matcher
-          node.upgrade_greedy!
-          node.greedy[key.regex_matcher] ||= Node.new(node, key)
-        else
-          node.greedy[nil] ||= Node.new(node, key)
-        end  
-      when Route::Variable
-        node.activate_normal!
-        if key.regex_matcher
-          node.upgrade_normal!
-          node.normal[key.regex_matcher] ||= Node.new(node, key)
-        else
-          node.normal[nil] ||= Node.new(node, key)
-        end
-      when Route::Static::Greedy
-        node.activate_greedy!
-        node.upgrade_greedy!
-        node.greedy[key] ||= Node.new(node, key)
-      else
-        node.activate_normal!
-        node.upgrade_normal! if key.is_a?(Regexp)
-        node.normal[key] ||= Node.new(node, key)
-      end
-    end
-    
-    def request_methods_for_path(path)
-      request_methods.collect do |type|
-        Route::RequestMethod.new(type, path.route.conditions && path.route.conditions[type])
-      end
-    end
-    
   end
 end

data/lib/usher/route/path.rb

@@ -1,19 +1,19 @@
 class Usher
   class Route
     class Path
-  
+
       attr_accessor :route
       attr_reader :parts
-      
+
       def initialize(route, parts)
         self.route = route
         self.parts = parts
       end
-      
+
       def convert_params_array(ary)
         ary.empty? ? ary : dynamic_keys.zip(ary)
       end
-      
+
       def dynamic_indicies
         unless dynamic? && @dynamic_indicies
           @dynamic_indicies = []
@@ -33,15 +33,15 @@ class Usher
         end
         @dynamic_map
       end
-      
+
       def dynamic_keys
         @dynamic_keys ||= dynamic_parts.map{|dp| dp.name} if dynamic?
       end
-      
+
       def dynamic_required_keys
         @dynamic_required_keys ||= dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name} if dynamic?
       end
-      
+
       def dynamic?
         @dynamic
       end
@@ -51,26 +51,26 @@ class Usher
           (dynamic_required_keys - keys).size.zero? ? keys : nil
         end
       end
-      
+
       def can_generate_from_params?(params)
         if route.router.consider_destination_keys?
           route.destination.to_a - params.to_a
           (route.destination.to_a - params.to_a).size.zero?
         end
       end
-      
+
       # Merges paths for use in generation
       def merge(other_path)
         new_parts = parts + other_path.parts
         Path.new(route, new_parts)
       end
-      
-      private 
-      def parts=(parts)
-        @parts = parts
-        @dynamic = @parts.any?{|p| p.is_a?(Variable)}
-      end
-      
+
+      private
+        def parts=(parts)
+          @parts = parts
+          @dynamic = @parts.any?{|p| p.is_a?(Variable)}
+        end
+
     end
   end
-end
+end

data/lib/usher/route.rb

@@ -24,12 +24,12 @@ class Usher
 
     def destination_keys
       @destination_keys ||= case
-      when Hash
-        destination.keys
-      when CompoundDestination
-        destination.options.keys
-      else
-        nil
+        when Hash
+          destination.keys
+        when CompoundDestination
+          destination.options.keys
+        else
+          nil
       end
     end
 
@@ -48,7 +48,7 @@ class Usher
       end
       @grapher
     end
-    
+
     def unrecognizable!
       self.recognizable = false
       self
@@ -62,7 +62,7 @@ class Usher
     def recognizable?
       self.recognizable
     end
-    
+
     def dup
       result = super
       result.instance_eval do
@@ -78,11 +78,11 @@ class Usher
       else
         @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
       end
-      
+
       if matching_path.nil? and router.find_matching_paths_based_on_destination_keys?
         # do something
       end
-      
+
       if parent_route
         matching_path = parent_route.find_matching_path(params).merge(matching_path)
         matching_path.route = self
@@ -105,19 +105,19 @@ class Usher
     #   route.to(:controller => 'testing', :action => 'index')
     #   set.recognize(Request.new('/test')).first.params => {:controller => 'testing', :action => 'index'}
     #
-    #   
+    #
     #
     def to(*args, &block)
       if !args.empty? && block
         @destination = CompoundDestination.new(args, block, args.last.is_a?(Hash) ? args.pop : {})
       elsif block.nil?
         case args.size
-        when 0 
-          raise "destination should be set as something"
-        when 1
-          @destination = args.first
-        else
-          @destination = CompoundDestination.new(args, nil, args.last.is_a?(Hash) ? args.pop : {})
+          when 0
+            raise "destination should be set as something"
+          when 1
+            @destination = args.first
+          else
+            @destination = CompoundDestination.new(args, nil, args.last.is_a?(Hash) ? args.pop : {})
         end
       else
         @destination = block
@@ -147,7 +147,7 @@ class Usher
     end
 
     private
-    attr_writer :grapher
+      attr_writer :grapher
 
   end
 end

data/lib/usher/util/mapper.rb

@@ -0,0 +1,9 @@
+class Usher
+  module Util
+    class Mapper
+      
+      def 
+      
+    end
+  end
+end

data/lib/usher/util.rb

@@ -3,5 +3,6 @@ class Usher
     autoload :Generators, File.join('usher', 'util', 'generate')
     autoload :Parser,     File.join('usher', 'util', 'parser')
     autoload :Graph,      File.join('usher', 'util', 'graph')
+    autoload :Mapper,     File.join('usher', 'util', 'mapper')
   end
 end

data/lib/usher.rb

@@ -1,3 +1,5 @@
+require 'fuzzy_hash'
+
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
 require File.join('usher', 'node')
 require File.join('usher', 'route')
@@ -39,7 +41,7 @@ class Usher
   #   set.reset!
   #   set.empty? => true
   def reset!
-    @root = Node.root(self, request_methods)
+    @root = Node::Root.new(self, request_methods)
     @named_routes = {}
     @routes = []
     @grapher = Grapher.new(self)
@@ -64,6 +66,8 @@ class Usher
   # <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.
   def initialize(options = nil)

data/spec/private/rack/dispatch_spec.rb

@@ -75,6 +75,21 @@ describe "Usher (for rack) route dispatching" do
     end
   end
 
+  describe "non rack app destinations" do
+    it "should route to a default application when using a hash" do
+      $captures = []
+      @default_app = lambda do |e|
+        $captures << :default
+        Rack::Response.new("Default").finish
+      end
+      @router = Usher::Interface.for(:rack)
+      @router.default(@default_app)
+      @router.add("/default").to(:action => "default")
+      response = @router.call(Rack::MockRequest.env_for("/default"))
+      $captures.should == [:default]
+    end
+  end
+
   describe "mounted rack instances" do
     before do
       @bad_app = mock("bad_app")

data/spec/private/rails2_3/recognize_spec.rb

@@ -10,7 +10,7 @@ def build_request_mock(path, method, params)
   request.should_receive(:path).any_number_of_times.and_return(path)
   request.should_receive(:method).any_number_of_times.and_return(method)
   params = params.with_indifferent_access
-  request.should_receive(:path_parameters=).any_number_of_times.with(params)
+  request.should_receive(:path_parameters=).any_number_of_times.with(hash_including(params))
   request.should_receive(:path_parameters).any_number_of_times.and_return(params)
   request
 end
@@ -45,36 +45,36 @@ describe "Usher (for rails 2.3) route recognition" do
     route_set.add_route('/sample/test', :controller => 'sample', :action => 'action')
     route_set.recognize(build_request_mock('/sample/test', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
   end
-  
+
   it "should raise based upon an invalid param" do
     route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample', :requirements => {:action => /\d+/})
     proc { route_set.recognize(build_request_mock('/sample/asdqwe', :post, {})) }.should raise_error
   end
-  
+
   it "should raise based upon an invalid route" do
     route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'test')
     proc { route_set.recognize(build_request_mock('/test/asdqwe', :post, {})) }.should raise_error
   end
-  
+
   it "should add /:controller and /:controller/:action if /:controller/:action/:id is added" do
     route_set.add_route('/:controller/:action/:id')
     route_set.route_count.should == 3
   end
-  
+
   it "should correctly recognize a format (dynamic path path with . delimiter)" do
     route_set.add_route('/:controller/:action/:id.:format')
     route_set.recognize(build_request_mock('/sample/test/123.html', 'get', {:controller => 'sample', :action => 'test', :id => '123', :format => 'html'})).should == SampleController
   end
-  
+
   it "should support root nodes" do
     route_set.add_route('/', :controller => 'sample')
     route_set.recognize(build_request_mock('/', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
-  
+
   it "should default action to 'index' when controller (and not index) is specified" do
     route_set.add_route('/:controller/:action')
     route_set.recognize(build_request_mock('/sample', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
-  
-  
+
+
 end

data/spec/private/recognize_spec.rb

@@ -47,18 +47,18 @@ describe "Usher route recognition" do
       @route_set.recognize(build_request({:method => 'put', :path => '/sample', :protocol => 'wacky', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_http_admin_generic
 
     end
-    
+
     it "should recognize an empty path" do
       @route_set.add_route('').to(:test)
       @route_set.recognize(build_request({:path => ''})).path.route.destination.should == :test
     end
-    
+
     it "should recognize an optionally empty path" do
       @route_set.add_route('(/)').to(:test)
       @route_set.recognize(build_request({:path => ''})).path.route.destination.should == :test
       @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
@@ -92,7 +92,7 @@ describe "Usher route recognition" do
 
   it "should recognize path with a trailing slash" do
     @route_set = Usher.new(:request_methods => [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains], :ignore_trailing_delimiters => true)
-    
+
     target_route = @route_set.add_route('/path', :controller => 'sample', :action => 'action')
 
     response = @route_set.recognize(build_request({:method => 'get', :path => '/path/'}))
@@ -101,7 +101,7 @@ 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, [[:format , 'html']], nil, "/sample.html")
+    @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")
   end
 
   it "should recognize a glob-style variable" do
@@ -236,12 +236,12 @@ 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, [[:action , 'sample']], nil, "/sample.html")
+    @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")
   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, [[:action , 'sample'], [:format, 'html']], nil, '/sample.html')
+    @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')
   end
 
   it "should use a requirement (proc) on incoming variables" do
@@ -336,7 +336,11 @@ describe "Usher route recognition" do
     it "should partially match a route" do
       route = @route_set.add_route("/foo")
       route.match_partially!
-      @route_set.recognize(build_request(:method => "get", :path => "/foo/bar")).should == Usher::Node::Response.new(route.paths.first, [], "/bar", '/foo')
+      response = @route_set.recognize(build_request(:method => "get", :path => "/foo/bar"))
+      response.partial_match?.should be_true
+      response.params.should == []
+      response.remaining_path.should == '/bar'
+      response.matched_path.should == '/foo'
     end
 
     it "should partially match a route and use request conditions" do
@@ -401,5 +405,5 @@ describe "Usher route recognition" do
     end
 
   end
-  
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-09 00:00:00 -05:00
+date: 2010-01-12 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,7 +27,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.0.11
     version: 
-description: A general purpose routing library
+description: Pure ruby general purpose router with interfaces for rails, rack, email or choose your own adventure
 email: joshbuddy@gmail.com
 executables: []
 
@@ -60,6 +60,8 @@ files:
 - lib/usher/interface/sinatra.rb
 - lib/usher/interface/text.rb
 - lib/usher/node.rb
+- lib/usher/node/response.rb
+- lib/usher/node/root.rb
 - lib/usher/route.rb
 - lib/usher/route/path.rb
 - lib/usher/route/request_method.rb
@@ -70,6 +72,7 @@ files:
 - lib/usher/util.rb
 - lib/usher/util/generate.rb
 - lib/usher/util/graph.rb
+- lib/usher/util/mapper.rb
 - lib/usher/util/parser.rb
 - lib/usher/util/rack-mixins.rb
 - rails/init.rb
@@ -125,7 +128,7 @@ rubyforge_project: joshbuddy-usher
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: A general purpose routing library
+summary: Pure ruby general purpose router with interfaces for rails, rack, email or choose your own adventure
 test_files: 
 - spec/private/delimiters_spec.rb
 - spec/private/destination_spec.rb