usher 0.4.8 → 0.5.1

data/lib/usher/interface/rails2_2_interface.rb

@@ -12,8 +12,7 @@ class Usher
       end
       
       def reset!
-        @usher ||= Usher.new
-        @url_generator ||= Usher::Generators::URL.new(@usher)
+        @usher ||= Usher.new(:generator => Usher::Util::Generators::URL.new)
         @module ||= Module.new
         @module.instance_methods.each do |selector|
           @module.class_eval { remove_method selector }
@@ -38,7 +37,7 @@ class Usher
 
         path[0, 0] = '/' unless path[0] == ?/
         route = @usher.add_route(path, options)
-        raise "your route must include a controller" unless route.paths.first.dynamic_keys.include?(:controller) || route.destination.include?(:controller)
+        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
       
@@ -86,7 +85,7 @@ class Usher
       end
       
       def generate_url(route, params)
-        @url_generator.generate(route, params)
+        @usher.generator.generate(route, params)
       end
       
       def path_for_options(options)

data/lib/usher/interface/rails2_3_interface.rb

@@ -28,7 +28,7 @@ class Usher
         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.include?(:controller) || route.destination.include?(:controller))
+        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
       
@@ -72,8 +72,7 @@ class Usher
       end
       
       def reset!
-        @router = Usher.new
-        @url_generator = Usher::Generators::URL.new(@router)
+        @router = Usher.new(:generator => Usher::Util::Generators::URL.new)
         @configuration_files = []
         @module ||= Module.new
         @controller_route_added = false
@@ -123,7 +122,7 @@ class Usher
       end
       
       def generate_url(route, params)
-        @url_generator.generate(route, params)
+        @router.generator.generate(route, params)
       end
       
       def path_for_options(options)

data/lib/usher/interface/rails3_interface.rb

@@ -0,0 +1,57 @@
+class Usher
+  module Interface
+    class Rails3Interface
+    
+      @@instance = nil
+    
+      def initialize
+        @usher = Usher.new
+        @controller_paths = []
+        @configurations_files = []
+        
+        @@instance = self
+      end
+      
+      def self.instance
+        @@instance
+      end
+      
+      def draw(&blk)
+        @usher.instance_eval(&blk)
+      end
+      
+      attr_accessor :controller_paths
+      
+      def add_configuration_file(file)
+        @configurations_files << file
+      end
+      
+      def reload!
+        @usher.reset!
+        @configurations_files.each do |c|
+          Kernel.load(c)
+        end
+      end
+      
+      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
+      end
+      
+      def load(app)
+        @app = app
+      end
+      
+    end
+  end
+end

data/lib/usher/node.rb

@@ -4,15 +4,16 @@ class Usher
 
   class Node
     
-    Response = Struct.new(:path, :params)
+    Response = Struct.new(:path, :params, :remaining_path, :matched_path)
     
-    attr_reader :lookup
-    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods, :globs_capture_separators
+    attr_reader :lookup, :greedy_lookup
+    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods
 
     def initialize(parent, value)
       @parent = parent
       @value = value
       @lookup = Hash.new
+      @greedy_lookup = Hash.new
       @exclusive_type = nil
     end
 
@@ -20,14 +21,21 @@ class Usher
       @lookup = FuzzyHash.new(@lookup)
     end
 
+    def upgrade_greedy_lookup
+      @greedy_lookup = FuzzyHash.new(@greedy_lookup)
+    end
+
     def depth
-      @depth ||= @parent && @parent.is_a?(Node) ? @parent.depth + 1 : 0
+      @depth ||= @parent.is_a?(Node) ? @parent.depth + 1 : 0
     end
     
-    def self.root(route_set, request_methods, globs_capture_separators)
+    def greedy?
+      !@greedy_lookup.empty?
+    end
+    
+    def self.root(route_set, request_methods)
       root = self.new(route_set, nil)
       root.request_methods = request_methods
-      root.globs_capture_separators = globs_capture_separators
       root
     end
 
@@ -47,92 +55,132 @@ class Usher
     
     def add(route)
       route.paths.each do |path|
-        parts = path.parts.dup
-        request_methods.each do |type|
-          parts.push(Route::RequestMethod.new(type, route.conditions[type])) if route.conditions && route.conditions.key?(type)
-        end
-        
-        current_node = self
-        until parts.size.zero?
-          key = parts.shift
-          target_node = case key
-          when Route::RequestMethod
-            current_node.upgrade_lookup if key.value.is_a?(Regexp)
-            if current_node.exclusive_type == key.type
-              current_node.lookup[key.value] ||= Node.new(current_node, key)
-            elsif current_node.lookup.empty?
-              current_node.exclusive_type = key.type
-              current_node.lookup[key.value] ||= Node.new(current_node, key)
-            else
-              parts.unshift(key)
-              current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
-            end
-          else
-            key.globs_capture_separators = globs_capture_separators if key.is_a?(Route::Variable)
-            
-            if !key.is_a?(Route::Variable)
-              current_node.upgrade_lookup if key.is_a?(Regexp)
-              current_node.lookup[key] ||= Node.new(current_node, key)
-            elsif key.regex_matcher
-              current_node.upgrade_lookup
-              current_node.lookup[key.regex_matcher] ||= Node.new(current_node, key)
-            else
-              current_node.lookup[nil] ||= Node.new(current_node, key)
-            end  
-          end
-          current_node = target_node
-        end
-        current_node.terminates = 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.lookup.values.each do |v|
+        unique_routes(v, routes)
       end
-      route
+      node.greedy_lookup.values.each do |v|
+        unique_routes(v, routes)
+      end
+      routes.uniq!
+      routes
     end
     
-    def find(usher, request, path, params = [])
+    def find(usher, request, original_path, path, params = [], position = 0)
       if exclusive_type
         [lookup[request.send(exclusive_type)], lookup[nil]].each do |n|
-          if n && (ret = n.find(usher, request, path.dup, params.dup))
+          if n && (ret = n.find(usher, request, original_path, path.dup, params.dup, position))
             return ret
           end
         end
-      elsif path.size.zero? && terminates?
-        Response.new(terminates, params)
+      elsif terminates? && (path.size.zero? || terminates.route.partial_match?)
+        if terminates.route.partial_match?
+          Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position])
+        else
+          Response.new(terminates, params, nil, original_path)
+        end
+        
+      elsif !path.size.zero? && (greedy? && (match_with_result_output = greedy_lookup.match_with_result(whole_path = original_path[position, original_path.size])))
+				next_path, matched_part = match_with_result_output
+        position += matched_part.size
+        params << [next_path.value.name, whole_path.slice!(0, matched_part.size)]
+        next_path.find(usher, request, original_path, whole_path.size.zero? ? whole_path : usher.splitter.url_split(whole_path), params, position)
       elsif !path.size.zero? && (next_part = lookup[part = path.shift] || lookup[nil])
+        position += part.size
         case next_part.value
-        when Route::Variable
-          case next_part.value.type
-          when :*
-            params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
-            loop do
-              if (next_part.value.look_ahead === part || (!usher.splitter.delimiter_chars.include?(part[0]) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
-                path.unshift(part)
-                path.unshift(next_part.parent.value) if usher.splitter.delimiter_chars.include?(next_part.parent.value[0])
-                break
-              elsif next_part.value.globs_capture_separators
-                params.last.last << part
-              elsif !usher.splitter.delimiter_chars.include?(part[0])
-                next_part.value.valid!(part)
-                params.last.last << part
-              end
-              if path.size.zero?
-                break
-              else
-                part = path.shift
+        when Route::Variable::Glob
+          params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
+          loop do
+            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
+              if usher.delimiter_chars.include?(next_part.parent.value[0])
+                path.unshift(next_part.parent.value)
+                position -= next_part.parent.value.size
               end
+              break
+            elsif !usher.delimiter_chars.include?(part[0])
+              next_part.value.valid!(part)
+              params.last.last << part
             end
-          when :':'
-            var = next_part.value
-            var.valid!(part)
-            params << [var.name, part]
-            until (var.look_ahead === path.first) || path.empty?
-              params.last.last << path.shift 
+            if path.size.zero?
+              break
+            else
+              part = path.shift
             end
           end
+        when Route::Variable::Single
+          var = next_part.value
+          var.valid!(part)
+          params << [var.name, part]
+          until (var.look_ahead === path.first) || path.empty?
+            next_path_part = path.shift
+            position += next_path_part.size
+            params.last.last << next_path_part
+          end
         end
-        next_part.find(usher, request, path, params)
+        next_part.find(usher, request, original_path, path, params, position)
       else
         nil
       end
     end
 
+    private
+    def set_path_with_destination(path, destination = path)
+      parts = path.parts.dup
+      request_methods.each do |type|
+        parts.push(Route::RequestMethod.new(type, path.route.conditions[type])) if path.route.conditions && path.route.conditions.key?(type)
+      end
+      
+      current_node = self
+      until parts.size.zero?
+        key = parts.shift
+        target_node = case key
+        when Route::RequestMethod
+          current_node.upgrade_lookup if key.value.is_a?(Regexp)
+          if current_node.exclusive_type == key.type
+            current_node.lookup[key.value] ||= Node.new(current_node, key)
+          elsif current_node.lookup.empty?
+            current_node.exclusive_type = key.type
+            current_node.lookup[key.value] ||= Node.new(current_node, key)
+          else
+            parts.unshift(key)
+            current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
+          end
+        when Route::Variable
+          upgrade_method, lookup_method = case key
+          when Route::Variable::Greedy
+            [:upgrade_greedy_lookup, :greedy_lookup]
+          else
+            [:upgrade_lookup, :lookup]
+          end
+          
+          if key.regex_matcher
+            current_node.send(upgrade_method)
+            current_node.send(lookup_method)[key.regex_matcher] ||= Node.new(current_node, key)
+          else
+            current_node.send(lookup_method)[nil] ||= Node.new(current_node, key)
+          end  
+        else
+          current_node.upgrade_lookup if key.is_a?(Regexp)
+          current_node.lookup[key] ||= Node.new(current_node, key)
+        end
+        current_node = target_node
+      end
+      current_node.terminates = destination
+    end
+    
+    
   end
 end

data/lib/usher/route.rb

@@ -1,20 +1,20 @@
 require File.join(File.dirname(__FILE__), 'route', 'path')
+require File.join(File.dirname(__FILE__), 'route', 'util')
 require File.join(File.dirname(__FILE__), 'route', 'variable')
 require File.join(File.dirname(__FILE__), 'route', 'request_method')
 
 class Usher
   class Route
-    attr_reader :paths, :original_path, :requirements, :conditions, :destination, :named, :generate_with
+    attr_reader   :paths, :requirements, :conditions,
+                  :destination, :named, :generate_with,
+                  :default_values, :match_partially
+    attr_accessor :parent_route
     
     GenerateWith = Struct.new(:scheme, :port, :host)
     
-    def initialize(original_path, router, conditions, requirements, default_values, generate_with) # :nodoc:
-      @original_path = original_path
-      @router = router
-      @requirements = requirements
-      @conditions = conditions
-      @default_values = default_values
-      @paths = @router.splitter.split(@original_path, @requirements, @default_values).collect {|path| Path.new(self, path)}
+    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
     
@@ -26,11 +26,27 @@ class Usher
       @grapher
     end
 
+    def dup
+      result = super
+      result.grapher = nil
+      result
+    end
+
     def find_matching_path(params)
-      @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
+      if params.nil? || params.empty?
+        matching_path = @paths.first
+      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)
@@ -39,7 +55,13 @@ class Usher
     #   route.to(:controller => 'testing', :action => 'index')
     #   set.recognize(Request.new('/test')).first.params => {:controller => 'testing', :action => 'index'}
     def to(options = nil, &block)
-      @destination = (block_given? ? block : options)
+      raise "cannot set destintaion as block and argument" if block_given? && options
+      @destination = if block_given?
+        block
+      else
+        options.parent_route = self if options.respond_to?(:parent_route=)
+        options
+      end
       self
     end
 
@@ -53,6 +75,18 @@ 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
 
   end
 end