usher 0.5.11 → 0.5.12

data/lib/usher/interface/{rails3_interface.rb → rails3.rb}

@@ -1,6 +1,6 @@
 class Usher
   module Interface
-    class Rails3Interface
+    class Rails3
     
       @@instance = nil
     

data/lib/usher/interface/{text_interface.rb → text.rb}

@@ -1,6 +1,6 @@
 class Usher
   module Interface
-    class TextInterface
+    class Text
       
       def initialize(&blk)
         @usher = Usher.new(:delimiters => [' '], :generator => Usher::Util::Generators::Generic.new)

data/lib/usher/node.rb

@@ -51,7 +51,7 @@ class Usher
     end
     
     def greedy?
-      @greedy && !@greedy.empty?
+      @greedy
     end
     
     def self.root(route_set, request_methods)
@@ -116,17 +116,32 @@ class Usher
         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? && (greedy? && (match_with_result_output = greedy.match_with_result(whole_path = original_path[position, original_path.size])))
+      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
         position += matched_part.size
-        params << [next_path.value.name, whole_path.slice!(0, matched_part.size)]
+        whole_path.slice!(0, matched_part.size)
+        params << [next_path.value.name, 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.url_split(whole_path), params, position)
-      elsif !path.empty? && normal && (next_part = normal[path.first] || normal[nil])
+      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 << [var.name, 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.last << next_path_part
+          end if var.look_ahead && usher.delimiters.size > 1
         when Route::Variable::Glob
-          params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
+          params << [next_part.value.name, []]
           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)
@@ -146,21 +161,12 @@ class Usher
               part = path.shift
             end
           end
-        when Route::Variable::Single
-          var = next_part.value
-          var.valid!(part)
-          params << [var.name, part]
-          until path.empty? || (var.look_ahead === path.first)
-            next_path_part = path.shift
-            position += next_path_part.size
-            params.last.last << next_path_part
-          end if var.look_ahead && usher.delimiters.size > 1
         end
         next_part.find(usher, request_object, original_path, path, params, position)
       elsif request_method_type
-        if (specific_node = request[request_object.send(request_method_type)]) && (ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+        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)
           ret
-        elsif (general_node = request[nil]) && (ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+        elsif general_node = request[nil] and ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position)
           ret
         else
           nil
@@ -173,65 +179,69 @@ class Usher
     private
     
     def set_path_with_destination(path, destination = path)
-      node = path.parts.inject(self){ |node, key| process_path_part(node, key) }
-      node = process_request_parts(node, request_methods_for_path(path)) if request_methods
-
-      while node.request_method_type
-        node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))
+      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
-
-      node.terminates = destination
     end
     
     def request_method_index(type)
       request_methods.index(type)
     end
     
-    def process_request_parts(node, parts)
+    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!
 
-        node.activate_request!
-
-        node = if node.request_method_type.nil?
-          node.request_method_type = key.type
-          node.upgrade_request! if key.value.is_a?(Regexp)
-          node.request[key.value] ||= Node.new(node, key)
-        else
-          case request_method_index(node.request_method_type) <=> request_method_index(key.type)
-          when -1
-            parts.unshift(key)
-            node.request[key.value] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil))
-          when 0
+          if node.request_method_type.nil?
+            node.request_method_type = key.type
             node.upgrade_request! if key.value.is_a?(Regexp)
-            node.request[key.value] ||= 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}
+            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[k] ||= 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
 
-            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)
+              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
+              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
-      node
+      nodes
     end      
       
     
@@ -253,6 +263,10 @@ class Usher
         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)

data/lib/usher/route.rb

@@ -1,14 +1,19 @@
-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')
+require File.join('usher', 'route', 'path')
+require File.join('usher', 'route', 'util')
+require File.join('usher', 'route', 'variable')
+require File.join('usher', 'route', 'static')
+require File.join('usher', 'route', 'request_method')
 
 class Usher
   class Route
     attr_reader   :paths, :requirements, :conditions, :named, :generate_with, :default_values, :match_partially, :destination
     attr_accessor :parent_route, :router, :recognizable
 
-    GenerateWith = Struct.new(:scheme, :port, :host)
+    class GenerateWith < Struct.new(:scheme, :port, :host)
+      def empty?
+        scheme.nil? and port.nil? and host.nil?
+      end
+    end
 
     def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)
       @router, @requirements, @conditions, @default_values, @match_partially = router, requirements, conditions, default_values, match_partially

data/lib/usher/route/static.rb

@@ -0,0 +1,9 @@
+class Usher
+  class Route
+    class Static
+      class Greedy < String
+        
+      end
+    end
+  end
+end

data/lib/usher/route/variable.rb

@@ -6,22 +6,37 @@ class Usher
       
       def initialize(name, regex_matcher = nil, validator = nil)
         @name = name.to_s.to_sym
-        @validator = validator
+        @validator = validator || regex_matcher
         @regex_matcher = regex_matcher
+        
+        case @validator
+        when Proc
+          self.extend(ProcValidator)
+        when nil
+          # do nothing
+        else
+          self.extend(CaseEqualsValidator)
+        end
       end
       private :initialize
-      
+
       def valid!(val)
-        case @validator
-        when Proc
+      end
+      
+      module ProcValidator
+        def valid!(val)
           begin
             @validator.call(val)
           rescue Exception => e
-            raise ValidationException.new("#{val} does not conform to #{@g}, root cause #{e.inspect}")
+            raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
           end
-        else
-          @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}"))
-        end if @validator
+        end
+      end
+
+      module CaseEqualsValidator
+        def valid!(val)
+          @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}"))
+        end
       end
       
       def ==(o)
@@ -40,7 +55,11 @@ class Usher
         end
       end
 
-      Greedy = Class.new(Variable)
+      class Greedy < Variable
+        def to_s
+          "!#{name}"
+        end
+      end
       
     end
     

data/lib/usher/util.rb

@@ -1,7 +1,7 @@
 class Usher
   module Util
-    autoload :Generators, File.join(File.dirname(__FILE__), 'util', 'generate')
-    autoload :Parser, File.join(File.dirname(__FILE__), 'util', 'parser')
-    autoload :Graph, File.join(File.dirname(__FILE__), 'util', 'graph')
+    autoload :Generators, File.join('usher', 'util', 'generate')
+    autoload :Parser,     File.join('usher', 'util', 'parser')
+    autoload :Graph,      File.join('usher', 'util', 'graph')
   end
 end

data/lib/usher/util/generate.rb

@@ -38,13 +38,56 @@ class Usher
 
       class URL < Generic
 
+        class UrlParts < Struct.new(:path, :request)
+          def scheme
+            @scheme ||= generate_with(:scheme) || (request.respond_to?(:scheme) and request.scheme)
+          end
+
+          def protocol
+            @protocol ||= scheme ? "#{scheme}://" : request.protocol
+          end
+
+          def host
+            @host ||= generate_with(:host) || request.host
+          end
+
+          def port
+            @port ||= generate_with(:port) || request.port
+          end
+
+          def port_string
+            @port_string ||= standard_port? ? '' : ":#{port}"
+          end
+
+          def url            
+            path.route.generate_with.nil? || path.route.generate_with.empty? ?
+              request.url :
+              protocol + host + port_string
+          end
+
+        protected
+
+          def generate_with(property)
+            path.route.generate_with and path.route.generate_with[property]
+          end
+
+          def standard_port?
+            ssl? ? port == 443 : port == 80
+          end
+
+          def ssl?
+            protocol[0..4] == 'https'
+          end
+        end
+
         def initialize
-          require File.join(File.dirname(__FILE__), 'rack-mixins')
+          require File.join('usher', 'util', 'rack-mixins')
         end
 
         def generate_full(routing_lookup, request, params = nil)
           path = path_for_routing_lookup(routing_lookup, params)
-          result = generate_start(path, request)
+
+          result = generate_start(path, request)          
           result << generate_path(path, params)
         end
 
@@ -105,12 +148,12 @@ class Usher
 
             usher.named_routes.each do |name, route|
               @generation_module.module_eval <<-END_EVAL
-                def #{name}_url(name, request, params = nil)
-                  @@generator.generate_full(name, request, options)
+                def #{name}_url(options={})
+                  @@generator.generate_full('#{name}'.to_sym, request, options)
                 end
 
-                def #{name}_path(name, params = nil)
-                  @@generator.generate(name, options)
+                def #{name}_path(options={})
+                  @@generator.generate('#{name}'.to_sym, options)
                 end
               END_EVAL
             end
@@ -127,20 +170,14 @@ class Usher
           end
         end
 
-        def generate_start(path, request)
-          result = (path.route.generate_with && path.route.generate_with.scheme || request.scheme).dup
-          result << '://'
-          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 unless port == 443
-          else
-            result << ':' << port.to_s unless port == 80
-          end
-          result
+        def generate_start(path, request)          
+          url_parts = UrlParts.new(path, request)
+          url = url_parts.url
+
+          (url[-1] == ?/) ? url[0..-2] : url
         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]

data/lib/usher/util/parser.rb

@@ -39,25 +39,30 @@ class Usher
 
           paths = Route::Util.expand_path(unprocessed_path)
 
-          paths.each do |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
-                if part.look_ahead && !part.look_ahead_priority
-                  part.look_ahead = nil
-                  part.look_ahead_priority = true
-                else
-                  part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiters.unescaped.include?(p)} || nil
-                end
-              when Usher::Route::Variable
-                if part.look_ahead && !part.look_ahead_priority
-                  part.look_ahead = nil
-                  part.look_ahead_priority = true
-                else
-                  part.look_ahead = router.delimiters.first_in(path[index + 1, path.size]) || router.delimiters.unescaped.first
+          paths.map! do |path|
+            if path.all?{|part| String === part}
+              path #parse "{~#{path.join}}"
+            else
+              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
+                  if part.look_ahead && !part.look_ahead_priority
+                    part.look_ahead = nil
+                    part.look_ahead_priority = true
+                  else
+                    part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiters.unescaped.include?(p)} || nil
+                  end
+                when Usher::Route::Variable
+                  if part.look_ahead && !part.look_ahead_priority
+                    part.look_ahead = nil
+                    part.look_ahead_priority = true
+                  else
+                    part.look_ahead = router.delimiters.first_in(path[index + 1, path.size]) || router.delimiters.unescaped.first
+                  end
                 end
               end
+              path
             end
           end
 
@@ -104,6 +109,7 @@ class Usher
             when ?{
               pattern = ''
               count = 1
+              simple = scanner.scan(/~/)
               variable = scanner.scan(/[!:\*]([^,]+),/)
               until count.zero?
                 regex_part = scanner.scan(/\{|\}|[^\{\}]+/)
@@ -124,9 +130,10 @@ class Usher
                 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])
+              elsif simple
+                current_group << Usher::Route::Static::Greedy.new(pattern)
               else
                 current_group << regex
               end