usher 0.6.8 → 0.7.0

data/Rakefile

@@ -8,7 +8,7 @@ begin
     s.email = "joshbuddy@gmail.com"
     s.homepage = "http://github.com/joshbuddy/usher"
     s.authors = ["Joshua Hull", 'Jakub Šťastný', 'Daniel Neighman', 'Daniel Vartanov'].sort
-    s.files = FileList["[A-Z]*", "{lib,spec,rails}/**/*"]
+    s.files = FileList["[A-Z]*", "{lib}/**/*"]
     s.add_dependency 'fuzzyhash', '>=0.0.11'
     s.rubyforge_project = 'joshbuddy-usher'
   end
@@ -19,13 +19,27 @@ end
 
 require 'spec'
 require 'spec/rake/spectask'
-task :spec => 'spec:all'
+task :spec => ['spec:private', 'spec:rails2_2', 'spec:rails2_3']
 namespace(:spec) do
-  Spec::Rake::SpecTask.new(:all) do |t|
+  Spec::Rake::SpecTask.new(:private) do |t|
     t.spec_opts ||= []
     t.spec_opts << "-rubygems"
     t.spec_opts << "--options" << "spec/spec.opts"
-    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_files = FileList['spec/private/**/*_spec.rb']
+  end
+
+  Spec::Rake::SpecTask.new(:rails2_2) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/rails2_2/**/*_spec.rb']
+  end
+
+  Spec::Rake::SpecTask.new(:rails2_3) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/rails2_3/**/*_spec.rb']
   end
 
 end

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
+:patch: 0
 :build: 
-:minor: 6
-:patch: 8
 :major: 0
+:minor: 7

data/lib/usher/interface/rack/route.rb

@@ -1,16 +1,22 @@
 class Usher
-  class Route
-    # add("/index.html").redirect("/")
-    def redirect(path, status = 302)
-      unless (300..399).include?(status)
-        raise ArgumentError, "Status has to be an integer between 300 and 399"
+  module Interface
+    class Rack
+      class Route < Usher::Route
+        
+        attr_accessor :redirect_on_trailing_slash
+        
+        def redirect(path, status = 302)
+          unless (300..399).include?(status)
+            raise ArgumentError, "Status has to be an integer between 300 and 399"
+          end
+          @destination = lambda do |env|
+            response = ::Rack::Response.new
+            response.redirect(path, status)
+            response.finish
+          end
+          self
+        end
       end
-      @destination = lambda do |env|
-        response = Rack::Response.new
-        response.redirect(path, status)
-        response.finish
-      end
-      return self
     end
   end
-end
+end

data/lib/usher/interface/rack.rb

@@ -1,15 +1,14 @@
 require "rack"
-require File.join(File.dirname(__FILE__), 'rack', 'route')
+require File.join('usher', 'interface', 'rack', 'route')
 
 class Usher
   module Interface
     class Rack
-
+      
       ENV_KEY_RESPONSE = 'usher.response'
       ENV_KEY_PARAMS = 'usher.params'
       ENV_KEY_DEFAULT_ROUTER = 'usher.router'
-      
-      
+
       # Middleware for using Usher's rack interface to recognize the request, then, pass on to the next application.
       # Values are stored in <tt>env</tt> normally.
       #
@@ -62,6 +61,7 @@ class Usher
       end
 
       attr_reader :router, :router_key
+      attr_accessor :redirect_on_trailing_delimiters
 
       # Constructor for Rack interface for Usher. 
       # <tt>app</tt> - the default application to route to if no matching route is found. The default is a 404 response.
@@ -71,14 +71,22 @@ class Usher
       # * <tt>request_methods</tt> - Request methods on <tt>Rack::Request</tt> to use in determining recognition. (Default <tt>[:request_method, :host, :port, :scheme]</tt>)
       # * <tt>generator</tt> - Route generator to use. (Default <tt>Usher::Util::Generators::URL.new</tt>)
       # * <tt>allow_identical_variable_names</tt> - Option to prevent routes with identical variable names to be added. eg, /:variable/:variable would raise an exception if this option is not enabled. (Default <tt>false</tt>)
-      def initialize(app = nil, options = nil, &blk)
-        @_app = app || proc{|env| ::Rack::Response.new("No route found", 404).finish }
-        @use_destinations = options && options.key?(:use_destinations) ? options[:use_destinations] : true
-        @router_key = options && options[:router_key] || ENV_KEY_DEFAULT_ROUTER
-        request_methods = options && options[:request_methods] || [:request_method, :host, :port, :scheme]
-        generator = options && options[:generator] || Usher::Util::Generators::URL.new
-        allow_identical_variable_names = options && options.key(:allow_identical_variable_names) ? options[:allow_identical_variable_names] : false
-        @router = Usher.new(:request_methods => request_methods, :generator => generator, :allow_identical_variable_names => allow_identical_variable_names)
+      def initialize(options = {}, &blk)
+        @_app = options[:default_app] || proc{|env| ::Rack::Response.new("No route found", 404).finish }
+        @use_destinations = options.key?(:use_destinations) ? options.delete(:use_destinations) : true
+        @router_key = options.delete(:router_key) || ENV_KEY_DEFAULT_ROUTER
+        request_methods = options.delete(:request_methods) || [:request_method, :host, :port, :scheme]
+        generator = options.delete(:generator) || Usher::Util::Generators::URL.new
+        allow_identical_variable_names = options.key?(:allow_identical_variable_names) ? options[:allow_identical_variable_names] : false
+        self.redirect_on_trailing_delimiters = options.key?(:redirect_on_trailing_delimiters) ? options.delete(:redirect_on_trailing_delimiters) : false
+        if redirect_on_trailing_delimiters
+          options[:ignore_trailing_delimiters] = true
+        end
+        usher_options = {:request_methods => request_methods, :generator => generator, :allow_identical_variable_names => allow_identical_variable_names}
+        usher_options.merge!(options)
+        @router = Usher.new(usher_options)
+        @router.route_class = Rack::Route
+
         instance_eval(&blk) if blk
       end
       
@@ -161,8 +169,14 @@ class Usher
         env[router_key] = self
         request = ::Rack::Request.new(env)
         response = @router.recognize(request, request.path_info)
-        after_match(request, response) if response
-        determine_respondant(response).call(env)
+        if request.get? and redirect_on_trailing_delimiters and response.only_trailing_delimiters
+          response = ::Rack::Response.new
+          response.redirect(request.path_info[0, request.path_info.size - 1], 302)
+          response.finish
+        else
+          after_match(request, response) if response
+          determine_respondant(response).call(env)
+        end
       end
 
       def generate(route, options = nil)

data/lib/usher/interface/rails3.rb

@@ -1,56 +1,55 @@
 class Usher
   module Interface
     class Rails3
-    
-      @@instance = nil
-    
-      def initialize
-        @usher = Usher.new
-        @controller_paths = []
-        @configurations_files = []
-        
-        @@instance = self
-      end
       
-      def self.instance
-        @@instance
-      end
+      attr_reader :router
       
-      def draw(&blk)
-        @usher.instance_eval(&blk)
+      def initialize
+        @router = Usher.new(:request_methods => [:request_method, :host, :port, :scheme], :generator => Usher::Util::Generators::URL.new)
       end
       
-      attr_accessor :controller_paths
-      
-      def add_configuration_file(file)
-        @configurations_files << file
+      # Builder method to add a route to the set
+      #
+      # <tt>app</tt>:: A valid Rack app to call if the conditions are met.
+      # <tt>conditions</tt>:: A hash of conditions to match against.
+      #                       Conditions may be expressed as strings or
+      #                       regexps to match against.
+      # <tt>defaults</tt>:: A hash of values that always gets merged in
+      # <tt>name</tt>:: Symbol identifier for the route used with named
+      #                 route generations
+      def add_route(app, conditions = {}, defaults = {}, name = nil)
+        route = router.add_route(conditions.delete(:path_info), :conditions => conditions, :defaults => defaults)
+        route.name(name) if name
+        route.to(app)
       end
       
-      def reload
-        @usher.reset!
-        @configurations_files.each do |c|
-          Kernel.load(c)
+      def call(env)
+        request = ::Rack::Request.new(env)
+        response = router.recognize(request, request.path_info)
+        if response
+          response.destination.call(env)
+        else
+          ::Rack::Response.new("No route found", 404).finish
         end
       end
-      alias_method :reload!, :reload
       
-      def call(env)
-        request = ActionDispatch::Request.new(env)
-        response = @usher.recognize(request, request.path_info)
-        request.parameters.merge!(response.path.route.default_values) if response.path.route.default_values
-        response.params.each{ |hk| request.parameters[hk.first] = hk.last}
-        controller = "#{request.parameters[:controller].to_s.camelize}Controller".constantize
-        controller.action(request.parameters[:action] || 'index').call(env)
-      end
-
-      def recognize(request)
-        params = recognize_path(request.path, extract_request_environment(request))
-        request.path_parameters = params.with_indifferent_access
-        "#{params[:controller].to_s.camelize}Controller".constantize
+      # Generates a url from Rack env and identifiers or significant keys.
+      #
+      # To generate a url by named route, pass the name in as a +Symbol+.
+      #   url(env, :dashboard) # => "/dashboard"
+      #
+      # Additional parameters can be passed in as a hash
+      #   url(env, :people, :id => "1") # => "/people/1"
+      #
+      # If no name route is given, it will fall back to a slower
+      # generation search.
+      #   url(env, :controller => "people", :action => "show", :id => "1")
+      #     # => "/people/1"
+      def url(env, *args)
       end
       
-      def load(app)
-        @app = app
+      def reset!
+        router.reset!
       end
       
     end

data/lib/usher/node/response.rb

@@ -1,6 +1,6 @@
 class Usher
   class Node
-    class Response < Struct.new(:path, :params_as_array, :remaining_path, :matched_path)
+    class Response < Struct.new(:path, :params_as_array, :remaining_path, :matched_path, :only_trailing_delimiters)
 
       def params
         @params ||= path.convert_params_array(params_as_array)

data/lib/usher/node/root.rb

@@ -41,9 +41,8 @@ class Usher
       private
       
       def set_path_with_destination(path, destination = path)
-        nodes = [path.parts.inject(self){ |node, key| process_path_part(node, key) }]
+        nodes = [path.parts ? path.parts.inject(self){ |node, key| process_path_part(node, key)} : self]
         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)))
@@ -69,32 +68,32 @@ class Usher
               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
+              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}
+                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
+                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
@@ -105,30 +104,30 @@ class Usher
 
       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!
+        when Route::Variable::Greedy
+          node.activate_greedy!
+          if key.regex_matcher
             node.upgrade_greedy!
-            node.greedy[key] ||= Node.new(node, key)
+            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.activate_normal!
-            node.upgrade_normal! if key.is_a?(Regexp)
-            node.normal[key] ||= Node.new(node, key)
+            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
 

data/lib/usher/node.rb

@@ -94,33 +94,26 @@ class Usher
 
     def find(request_object, original_path, path, params = [])
       # terminates or is partial
-      if terminates? && (path.empty? || terminates.route.partial_match? || (route_set.ignore_trailing_delimiters? && path.all?{|p| route_set.delimiters.include?(p)}))
-        if terminates.cached_response
-          terminates.cached_response
-        else
-          terminates.route.partial_match? ?
-            Response.new(terminates, params, path.join, original_path[0, original_path.size - path.join.size]) :
-            Response.new(terminates, params, nil, original_path)
-        end
+      if terminates? && (path.nil? || path.empty? || terminates.route.partial_match? || (route_set.ignore_trailing_delimiters? and only_trailing_delimiters = path.all?{|p| route_set.delimiters.include?(p)}))
+        terminates.route.partial_match? ?
+          Response.new(terminates, params, path.join, original_path[0, original_path.size - path.join.size], only_trailing_delimiters) :
+          Response.new(terminates, params, nil, original_path, only_trailing_delimiters)
       # terminates or is partial
-      elsif !path.empty? and greedy and match_with_result_output = greedy.match_with_result(whole_path = path.join)
+      elsif greedy && !path.empty? and match_with_result_output = greedy.match_with_result(whole_path = path.join)
         next_path, matched_part = match_with_result_output
         whole_path.slice!(0, matched_part.size)
         params << matched_part if next_path.value.is_a?(Route::Variable)
         next_path.find(request_object, original_path, whole_path.empty? ? whole_path : route_set.splitter.split(whole_path), params)
-      elsif !path.empty? and normal and next_part = normal[path.first] || normal[nil]
+      elsif normal && !path.empty? and next_part = normal[path.first] || normal[nil]
         part = path.shift
         case next_part.value
         when String
         when Route::Variable::Single
-          # get the variable
-          variable = next_part.value
-          # do a validity check
-          variable.valid!(part)
-          # because its a variable, we need to add it to the params array
-          parameter_value = part
+          variable = next_part.value # get the variable
+          variable.valid!(part)      # do a validity check
+          parameter_value = part     # because its a variable, we need to add it to the params array
           if variable.look_ahead
-            until path.empty? || (variable.look_ahead === path.first)           # variables have a look ahead notion,
+            until (variable.look_ahead === path.first) || path.empty?           # variables have a look ahead notion,
               next_path_part = path.shift                                       # and until they are satified,
               parameter_value << next_path_part
             end
@@ -139,29 +132,29 @@ class Usher
               next_part.value.valid!(part)
               params.last << part
             end
-            if path.empty?
+            unless part = path.shift
               break
-            else
-              part = path.shift
             end
           end
         end
         next_part.find(request_object, original_path, path, params)
       elsif request_method_type
-        return_value = if (specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params && params.dup))
-          route_set.priority_lookups? ? [ret] : ret
-        end
-
-        if route_set.priority_lookups? || return_value.nil? and general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params && params.dup)
-          return_value = route_set.priority_lookups? && return_value ? [return_value, ret] : ret
-        end
-
-        unless route_set.priority_lookups?
-          return_value
+        if route_set.priority_lookups?
+          route_candidates = []
+          if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params && params.dup)
+            route_candidates << ret
+          end
+          if general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params && params.dup)
+            route_candidates << ret
+          end
+          route_candidates.sort!{|r1, r2| r1.path.route.priority <=> r2.path.route.priority}
+          route_candidates.last
         else
-          return_value = Array(return_value).flatten.compact
-          return_value.sort!{|r1, r2| r1.path.route.priority <=> r2.path.route.priority}
-          return_value.last
+          if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params && params.dup)
+            ret
+          elsif general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params && params.dup)
+            ret
+          end
         end
       else
         nil

data/lib/usher/route/path.rb

@@ -2,7 +2,7 @@ class Usher
   class Route
     class Path
 
-      attr_accessor :route, :cached_response
+      attr_accessor :route
       attr_reader :parts
 
       def initialize(route, parts)
@@ -67,7 +67,7 @@ class Usher
       private
       def parts=(parts)
         @parts = parts
-        @dynamic = @parts.any?{|p| p.is_a?(Variable)}
+        @dynamic = @parts && @parts.any?{|p| p.is_a?(Variable)}
       end
 
     end

data/lib/usher/route.rb

@@ -34,7 +34,7 @@ class Usher
     end
 
     def inspect
-      "#<Usher:Route:0x%x @paths=[%s]>" % [self.object_id, paths.collect{|p| p.parts.join}.join(', ')]
+      "#<Usher:Route:0x%x @paths=[%s]>" % [self.object_id, paths.collect{|p| p.parts ? p.parts.join : 'nil'}.join(', ')]
     end
 
     def to_s
@@ -142,9 +142,7 @@ class Usher
       self
     end
 
-    def partial_match?
-      @match_partially
-    end
+    alias_method :partial_match?, :match_partially
 
     private
       attr_writer :grapher

data/lib/usher/util/parser.rb

@@ -31,19 +31,22 @@ class Usher
           processed_path = parse(unprocessed_path, requirements, default_values)
         when Regexp
           processed_path = [Route::Static::Greedy.new(unprocessed_path)]
+        when nil
+          match_partially = true
         else
           match_partially = false
         end
         
-        unless processed_path.first.is_a?(Route::Util::Group)
+        if processed_path && !processed_path.first.is_a?(Route::Util::Group)
           group = Usher::Route::Util::Group.new(:all, nil)
           processed_path.each{|p| group << p}
           processed_path = group
         end
-        paths = Route::Util.expand_path(processed_path)
+        
+        paths = processed_path.nil? ? [nil] : Route::Util.expand_path(processed_path)
 
         paths.each do |path|
-          path.each_with_index do |part, index|
+          path && path.each_with_index do |part, index|
             part.default_value = default_values[part.name] if part.is_a?(Usher::Route::Variable) && default_values && default_values[part.name]
             case part
             when Usher::Route::Variable::Glob
@@ -64,7 +67,7 @@ class Usher
           end
         end
 
-        Route.new(
+        router.route_class.new(
           unprocessed_path,
           paths,
           router,