joshbuddy-usher 0.5.1 → 0.5.2

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,7 +4,7 @@ class Usher
 
   class Node
     
-    Response = Struct.new(:path, :params)
+    Response = Struct.new(:path, :params, :remaining_path, :matched_path)
     
     attr_reader :lookup, :greedy_lookup
     attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods
@@ -26,7 +26,7 @@ class Usher
     end
 
     def depth
-      @depth ||= @parent && @parent.is_a?(Node) ? @parent.depth + 1 : 0
+      @depth ||= @parent.is_a?(Node) ? @parent.depth + 1 : 0
     end
     
     def greedy?
@@ -55,52 +55,26 @@ 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
-            case key
-            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
-          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
+      node.greedy_lookup.values.each do |v|
+        unique_routes(v, routes)
       end
-      route
+      routes.uniq!
+      routes
     end
     
     def find(usher, request, original_path, path, params = [], position = 0)
@@ -110,10 +84,16 @@ class Usher
             return ret
           end
         end
-      elsif path.size.zero? && terminates?
-        Response.new(terminates, params)
+        nil
+      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
+				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)
@@ -157,5 +137,51 @@ class Usher
       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

@@ -5,17 +5,17 @@ require File.join(File.dirname(__FILE__), 'route', 'request_method')
 
 class Usher
   class Route
-    attr_reader :paths, :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(parsed_paths, router, conditions, requirements, default_values, generate_with) # :nodoc:
-      @router = router
-      @requirements = requirements
-      @conditions = conditions
-      @default_values = default_values
-      @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
+    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)            
       @paths = parsed_paths.collect {|path| Path.new(self, path)}
+      @router, @requirements, @conditions, @default_values, @match_partially = router, requirements, conditions, default_values, match_partially
+      @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
     end
     
     def grapher
@@ -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

data/lib/usher/route/path.rb

@@ -2,16 +2,16 @@ class Usher
   class Route
     class Path
   
-      attr_reader :route, :parts
+      attr_accessor :route
+      attr_reader :parts
       
       def initialize(route, parts)
-        @route = route
-        @parts = parts
-        @dynamic = @parts.any?{|p| p.is_a?(Variable)}
+        self.route = route
+        self.parts = parts
       end
 
       def dynamic_indicies
-        unless @dynamic_indicies
+        unless dynamic? && @dynamic_indicies
           @dynamic_indicies = []
           parts.each_index{|i| @dynamic_indicies << i if parts[i].is_a?(Variable)}
         end
@@ -19,11 +19,11 @@ class Usher
       end
 
       def dynamic_parts
-        @dynamic_parts ||= parts.values_at(*dynamic_indicies)
+        @dynamic_parts ||= parts.values_at(*dynamic_indicies) if dynamic?
       end
 
       def dynamic_map
-        unless @dynamic_map
+        unless dynamic? && @dynamic_map
           @dynamic_map = {}
           dynamic_parts.each{|p| @dynamic_map[p.name] = p }
         end
@@ -31,11 +31,11 @@ class Usher
       end
       
       def dynamic_keys
-        @dynamic_keys ||= dynamic_map.keys
+        @dynamic_keys ||= dynamic_map.keys if dynamic?
       end
       
       def dynamic_required_keys
-        @dynamic_required_keys ||= dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name}
+        @dynamic_required_keys ||= dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name} if dynamic?
       end
       
       def dynamic?
@@ -45,6 +45,19 @@ class Usher
       def can_generate_from?(keys)
         (dynamic_required_keys - keys).size.zero?
       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
+      
     end
   end
 end

data/lib/usher/util/generate.rb

@@ -29,9 +29,7 @@ class Usher
     
       class URL
       
-        def initialize(usher)
-          @usher = usher
-        end
+        attr_accessor :usher
 
         def generate_full(routing_lookup, request, params = nil)
           path = path_for_routing_lookup(routing_lookup, params)
@@ -49,20 +47,20 @@ class Usher
           result << (path.route.generate_with && path.route.generate_with.host) ? path.route.generate_with.host : request.host
           port = path.route.generate_with && path.route.generate_with.port || request.port
           if result[4] == ?s
-            result << ':' << port.to_s if port != 443
+            result << ':' << port.to_s unless port == 443
           else
-            result << ':' << port.to_s if port != 80
+            result << ':' << port.to_s unless port == 80
           end
           result
         end
-
-        def path_for_routing_lookup(routing_lookup, params)
+        
+        def path_for_routing_lookup(routing_lookup, params = {})
           path = case routing_lookup
           when Symbol
             route = @usher.named_routes[routing_lookup] 
-            params.is_a?(Hash) ? route.find_matching_path(params) : route.paths.first
+            route.find_matching_path(params || {})
           when Route
-            params.is_a?(Hash) ? routing_lookup.find_matching_path(params) : routing_lookup.paths.first
+            routing_lookup.find_matching_path(params || {})
           when nil
             params.is_a?(Hash) ? @usher.path_for_options(params) : raise
           when Route::Path
@@ -94,23 +92,21 @@ class Usher
             when Route::Variable::Glob
               value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
               value.each_with_index do |current_value, index|
-                current_value = current_value.to_s unless current_value.is_a?(String)
                 part.valid!(current_value)
-                result << current_value
+                result << current_value.to_s
                 result << '/' if index != value.size - 1
               end
             when Route::Variable
               value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
-              value = value.to_s unless value.is_a?(String)
               part.valid!(value)
-              result << value
+              result << value.to_s
             else
               result << part
             end
           end
           result = Rack::Utils.uri_escape(result)
 
-          if params && !params.empty?
+          unless params.nil? || params.empty?
             has_query = result[??]
             params.each do |k,v|
               case v
@@ -125,7 +121,9 @@ class Usher
           end
           result
         end
+      
       end
+      
     end
   end
 end