usher 0.6.5 → 0.6.6

data/CHANGES.rdoc

@@ -0,0 +1,9 @@
+= Changelog
+
+== From 0.6.5 to 0.6.6
+
+* Faster recognition (~10%)
+* Nicer exception message when generating a route and raising a MissingParameterException
+* Nodes now support #ancestors and #root methods.
+* Cache responses on non-dynamic paths.
+* Started a changelog.

data/VERSION.yml

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

data/lib/usher/node/response.rb

@@ -3,7 +3,7 @@ class Usher
     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)
+        @params ||= path.convert_params_array(params_as_array)
       end
 
       def partial_match?
@@ -11,7 +11,7 @@ class Usher
       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}
+        @params_as_hash ||= params_as_array.inject({}){|hash, val| hash[path.dynamic_keys[hash.size]] = val; hash}
       end
 
       def destination

data/lib/usher/node/root.rb

@@ -7,6 +7,10 @@ class Usher
         self.request_methods = request_methods
       end
       
+      def route_set
+        parent
+      end
+      
       def add(route)
         route.paths.each do |path|
           set_path_with_destination(path)

data/lib/usher/node.rb

@@ -52,6 +52,26 @@ class Usher
       @terminates && @terminates.route.recognizable?
     end
 
+    def ancestors
+      unless @ancestors
+        @ancestors = []
+        node = self
+        while (node.respond_to?(:parent))
+          @ancestors << node
+          node = node.parent
+        end
+      end
+      @ancestors
+    end
+
+    def root
+      @root ||= ancestors.last
+    end
+    
+    def route_set
+      @route_set ||= root.route_set
+    end
+
     def pp
       $stdout << " " * depth
       $stdout << "#{terminates? ? '* ' : ''}#{depth}: #{value.inspect}\n"
@@ -72,68 +92,71 @@ class Usher
       end if request
     end
 
-    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, 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])
+    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
+      # terminates or is partial
+      elsif !path.empty? and greedy and match_with_result_output = greedy.match_with_result(whole_path = path.join)
         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)
-        next_path.find(usher, request_object, original_path, whole_path.empty? ? whole_path : usher.splitter.split(whole_path), params, position)
+        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]
         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,
+        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
+          if variable.look_ahead
+            until path.empty? || (variable.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
+              parameter_value << next_path_part
+            end
+          end
+          params << parameter_value
+        when Route::Variable::Glob
+          params << []
+          loop do
+            if (next_part.value.look_ahead === part || (!route_set.delimiters.unescaped.include?(part) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
+              path.unshift(part)
+              if route_set.delimiters.unescaped.include?(next_part.parent.value)
+                path.unshift(next_part.parent.value)
               end
+              break
+            elsif !route_set.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)
+        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(usher, request_object, original_path, path.dup, params && params.dup, position))
-          usher.priority_lookups? ? [ret] : ret
+        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 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
+        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 usher.priority_lookups?
+        unless route_set.priority_lookups?
           return_value
         else
           return_value = Array(return_value).flatten.compact

data/lib/usher/route/path.rb

@@ -2,7 +2,7 @@ class Usher
   class Route
     class Path
 
-      attr_accessor :route
+      attr_accessor :route, :cached_response
       attr_reader :parts
 
       def initialize(route, parts)

data/lib/usher/util/generate.rb

@@ -21,14 +21,14 @@ class Usher
               when String
                 result << part
               when Route::Variable::Glob
-                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new("expected a value for #{part.name}"))
                 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)
+                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new("expected a value for #{part.name}"))
                 part.valid!(value)
                 result << value.to_s
               end

data/lib/usher/util/parser.rb

@@ -123,9 +123,9 @@ class Usher
             if variable
               variable_type = variable.slice!(0).chr.to_sym
               variable_class = case variable_type
-              when :'!' : Usher::Route::Variable::Greedy
-              when :*   : Usher::Route::Variable::Glob
-              when :':' : Usher::Route::Variable::Single
+              when :'!' then Usher::Route::Variable::Greedy
+              when :*   then Usher::Route::Variable::Glob
+              when :':' then Usher::Route::Variable::Single
               end
               variable_name = variable[0, variable.size - 1].to_sym
               current_group << variable_class.new(variable_name, regex, requirements && requirements[variable_name])

data/lib/usher.rb

@@ -232,7 +232,11 @@ class Usher
   #   route = set.add_route('/test')
   #   set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request, path = request.path)
-    @root.find(self, request, path, @splitter.split(path))
+    response = @root.find(request, path, @splitter.split(path))
+    if response && !response.path.dynamic?
+      response.path.cached_response = response
+    end
+    response
   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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.6.5
+  version: 0.6.6
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-13 00:00:00 -05:00
+date: 2010-01-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,6 +36,7 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- CHANGES.rdoc
 - History.txt
 - Manifest.txt
 - README.rdoc