joshbuddy-usher 0.4.8 → 0.4.10

data/Rakefile

@@ -9,7 +9,7 @@ begin
     s.homepage = "http://github.com/joshbuddy/usher"
     s.authors = ["Joshua Hull"]
     s.files = FileList["[A-Z]*", "{lib,spec,rails}/**/*"]
-    s.add_dependency 'fuzzyhash', '>=0.0.3'
+    s.add_dependency 'fuzzyhash', '>=0.0.5'
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 4
-:patch: 8
+:patch: 10
 :major: 0
+:minor: 4

data/lib/usher/interface/rack_interface.rb

@@ -8,7 +8,7 @@ class Usher
       
       def initialize(&blk)
         @routes = Usher.new(:request_methods => [:method, :host, :port, :scheme])
-        @generator = Usher::Generators::URL.new(@routes)
+        @generator = Usher::Util::Generators::URL.new(@routes)
         instance_eval(&blk) if blk
       end
       

data/lib/usher/interface/rails2_2_interface.rb

@@ -13,7 +13,7 @@ class Usher
       
       def reset!
         @usher ||= Usher.new
-        @url_generator ||= Usher::Generators::URL.new(@usher)
+        @url_generator ||= Usher::Util::Generators::URL.new(@usher)
         @module ||= Module.new
         @module.instance_methods.each do |selector|
           @module.class_eval { remove_method selector }

data/lib/usher/interface/rails2_3_interface.rb

@@ -73,7 +73,7 @@ class Usher
       
       def reset!
         @router = Usher.new
-        @url_generator = Usher::Generators::URL.new(@router)
+        @url_generator = Usher::Util::Generators::URL.new(@router)
         @configuration_files = []
         @module ||= Module.new
         @controller_route_added = false

data/lib/usher/node.rb

@@ -6,13 +6,14 @@ class Usher
     
     Response = Struct.new(:path, :params)
     
-    attr_reader :lookup
+    attr_reader :lookup, :greedy_lookup
     attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods, :globs_capture_separators
 
     def initialize(parent, value)
       @parent = parent
       @value = value
       @lookup = Hash.new
+      @greedy_lookup = Hash.new
       @exclusive_type = nil
     end
 
@@ -20,10 +21,18 @@ 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
     end
     
+    def greedy?
+      !@greedy_lookup.empty?
+    end
+    
     def self.root(route_set, request_methods, globs_capture_separators)
       root = self.new(route_set, nil)
       root.request_methods = request_methods
@@ -69,16 +78,29 @@ class Usher
             end
           else
             key.globs_capture_separators = globs_capture_separators if key.is_a?(Route::Variable)
-            
-            if !key.is_a?(Route::Variable)
+
+            case key
+            when Route::Variable
+              if key.greedy?
+                if key.regex_matcher
+                  current_node.upgrade_greedy_lookup
+                  current_node.greedy_lookup[key.regex_matcher] ||= Node.new(current_node, key)
+                else
+                  current_node.greedy_lookup[nil] ||= Node.new(current_node, key)
+                end  
+              else
+                if 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
+            else
               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
+            
           end
           current_node = target_node
         end
@@ -87,29 +109,38 @@ class Usher
       route
     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 !path.size.zero? && (greedy? && ((next_path, matched_part) = greedy_lookup.match_with_result(whole_path = original_path[position, original_path.size])))
+        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)))
+              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)
-                path.unshift(next_part.parent.value) if usher.splitter.delimiter_chars.include?(next_part.parent.value[0])
+                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 next_part.value.globs_capture_separators
                 params.last.last << part
-              elsif !usher.splitter.delimiter_chars.include?(part[0])
+              elsif !usher.delimiter_chars.include?(part[0])
                 next_part.value.valid!(part)
                 params.last.last << part
               end
@@ -124,11 +155,13 @@ class Usher
             var.valid!(part)
             params << [var.name, part]
             until (var.look_ahead === path.first) || path.empty?
-              params.last.last << path.shift 
+              next_path_part = path.shift
+              position += next_path_part.size
+              params.last.last << next_path_part
             end
           end
         end
-        next_part.find(usher, request, path, params)
+        next_part.find(usher, request, original_path, path, params, position)
       else
         nil
       end

data/lib/usher/route/variable.rb

@@ -16,6 +16,10 @@ class Usher
         "#{type}#{name}"
       end
       
+      def greedy?
+        type == :'!'
+      end
+      
       def valid!(val)
         case @validator
         when Proc

data/lib/usher/route.rb

@@ -4,18 +4,17 @@ 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
     
     GenerateWith = Struct.new(:scheme, :port, :host)
     
-    def initialize(original_path, router, conditions, requirements, default_values, generate_with) # :nodoc:
-      @original_path = original_path
+    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with) # :nodoc:
       @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)}
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
+      @paths = parsed_paths.collect {|path| Path.new(self, path)}
     end
     
     def grapher

data/lib/usher/splitter.rb

@@ -3,156 +3,19 @@ require 'strscan'
 class Usher
   class Splitter
     
-    def self.for_delimiters(delimiters, valid_regex)
-      delimiters_regex = delimiters.collect{|d| Regexp.quote(d)} * '|'
-      SplitterInstance.new(
-        delimiters,
-        Regexp.new('((:|\*)?' + valid_regex + '|' + delimiters_regex + '|\(|\)|\||\{)'),
-        Regexp.new("[#{delimiters.collect{|d| Regexp.quote(d)}}]|[^#{delimiters.collect{|d| Regexp.quote(d)}}]+")
-      )
+    def self.for_delimiters(router, valid_regex)
+      SplitterInstance.new(Regexp.new("[#{router.delimiters.collect{|d| Regexp.quote(d)}}]|[^#{router.delimiters.collect{|d| Regexp.quote(d)}}]+"))
     end
-    
-    attr_reader :paths
 
     class SplitterInstance
-      
-      attr_reader :delimiter_chars
-      
-      def initialize(delimiters, split_regex, url_split_regex)
-        @delimiters = delimiters
-        @delimiter_chars = delimiters.collect{|d| d[0]}
-        @split_regex = split_regex
+    
+      def initialize(url_split_regex)
         @url_split_regex = url_split_regex
       end
       
       def url_split(path)
         path.scan(@url_split_regex)
       end
-
-      def split(path, requirements = nil, default_values = nil)
-        parts = Group.new(:all, nil)
-        ss = StringScanner.new(path)
-        current_group = parts
-        while !ss.eos?
-          part = ss.scan(@split_regex)
-          case part[0]
-          when ?*, ?:
-            type = part.slice!(0).chr.to_sym
-            current_group << Usher::Route::Variable.new(type, part, requirements && requirements[part.to_sym])
-          when ?{
-            pattern = ''
-            count = 1
-            variable = ss.scan(/[:\*]([^,]+),/)
-            until count.zero?
-              regex_part = ss.scan(/\{|\}|[^\{\}]+/)
-              case regex_part[0]
-              when ?{
-                count += 1
-              when ?}
-                count -= 1
-              end
-              pattern << regex_part
-            end
-            pattern.slice!(pattern.length - 1)
-            regex = Regexp.new(pattern)
-            if variable
-              variable_type = variable.slice!(0).chr.to_sym
-              variable_name = variable[0, variable.size - 1].to_sym
-              current_group << Usher::Route::Variable.new(variable_type, variable_name, requirements && requirements[variable_name], regex)
-            else
-              current_group << regex
-            end
-          when ?(
-            new_group = Group.new(:any, current_group)
-            current_group << new_group
-            current_group = new_group
-          when ?)
-            current_group = current_group.parent.type == :one ? current_group.parent.parent : current_group.parent
-          when ?|
-            unless current_group.parent.type == :one
-              detached_group = current_group.parent.pop
-              new_group = Group.new(:one, detached_group.parent)
-              detached_group.parent = new_group
-              detached_group.type = :all
-              new_group << detached_group
-              new_group.parent << new_group
-            end
-            current_group.parent << Group.new(:all, current_group.parent)
-            current_group = current_group.parent.last
-          else
-            current_group << part
-          end
-        end unless !path || path.empty?
-        paths = calc_paths(parts)
-        paths.each do |path|
-          path.each_with_index do |part, index|
-            if part.is_a?(Usher::Route::Variable)
-              part.default_value = default_values[part.name] if default_values
-              
-              case part.type
-              when :*
-                part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !@delimiter_chars.include?(p[0])} || nil
-              when :':'
-                part.look_ahead = path[index + 1, path.size].find{|p| @delimiter_chars.include?(p[0])} || @delimiters.first
-              end
-            end
-          end
-        end
-        paths
-      end
-
-      private
-
-      def cartesian_product!(lval, rval)
-        product = []
-        (lval.size * rval.size).times do |index|
-          val = []
-          val.push(*lval[index % lval.size])
-          val.push(*rval[index % rval.size])
-          product << val
-        end
-        lval.replace(product)
-      end
-
-      def calc_paths(parts)
-        if parts.is_a?(Group)
-          paths = [[]]
-          case parts.type
-          when :all
-            parts.each do |p|
-              cartesian_product!(paths, calc_paths(p))
-            end
-          when :any
-            parts.each do |p|
-              cartesian_product!(paths, calc_paths(p))
-            end
-            paths.unshift([])
-          when :one
-            cartesian_product!(paths, parts.collect do |p|
-              calc_paths(p)
-            end)
-          end
-          paths.each{|p| p.compact!; p.flatten! }
-          paths
-        else
-          [[parts]]
-        end
-
-      end
-    end
-    
-    class Group < Array
-      attr_accessor :type
-      attr_accessor :parent
-      
-      def inspect
-        "#{type}->#{super}"
-      end
-      
-      def initialize(type, parent)
-        @type = type
-        @parent = parent
-      end
     end
     
   end

data/lib/usher/util/generate.rb

@@ -0,0 +1,133 @@
+require 'rack'
+
+unless Rack::Utils.respond_to?(:uri_escape)
+  module Rack
+
+    module Utils
+
+      def uri_escape(s)
+        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+        }.tr(' ', '+')
+      end
+      module_function :uri_escape
+
+      def uri_unescape(s)
+        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+          [$1.delete('%')].pack('H*')
+        }
+      end
+      module_function :uri_unescape
+
+    end
+  end
+end
+
+class Usher
+  module Util
+    class Generators
+    
+      class URL
+      
+        def initialize(usher)
+          @usher = usher
+        end
+
+        def generate_full(routing_lookup, request, params = nil)
+          path = path_for_routing_lookup(routing_lookup, params)
+          result = generate_start(path, request)
+          result << generate_path(path, params)
+        end
+
+        def generate(routing_lookup, params = nil)
+          generate_path(path_for_routing_lookup(routing_lookup, params), params)
+        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 if port != 443
+          else
+            result << ':' << port.to_s if port != 80
+          end
+          result
+        end
+
+        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
+          when Route
+            params.is_a?(Hash) ? routing_lookup.find_matching_path(params) : routing_lookup.paths.first
+          when nil
+            params.is_a?(Hash) ? @usher.path_for_options(params) : raise
+          when Route::Path
+            routing_lookup
+          end
+        end
+    
+        # Generates a completed URL based on a +route+ or set of optional +params+
+        #   
+        #   set = Usher.new
+        #   route = set.add_named_route(:test_route, '/:controller/:action')
+        #   set.generate_url(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        #   set.generate_url(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        #   set.generate_url(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        def generate_path(path, params = nil)
+          raise UnrecognizedException.new unless path
+
+          params = Array(params) if params.is_a?(String)
+          if params.is_a?(Array)
+            given_size = params.size
+            extra_params = params.last.is_a?(Hash) ? params.pop : nil
+            params = Hash[*path.dynamic_parts.inject([]){|a, dynamic_part| a.concat([dynamic_part.name, params.shift || raise(MissingParameterException.new("got #{given_size}, expected #{path.dynamic_parts.size} parameters"))]); a}]
+            params.merge!(extra_params) if extra_params
+          end
+
+          result = ''
+          path.parts.each do |part|
+            case part
+            when Route::Variable
+              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+              case part.type
+              when :*
+                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 << '/' if index != value.size - 1
+                end
+              when :':'
+                value = value.to_s unless value.is_a?(String)
+                part.valid!(value)
+                result << value
+              end
+            else
+              result << part
+            end
+          end
+          result = Rack::Utils.uri_escape(result)
+
+          if params && !params.empty?
+            has_query = result[??]
+            params.each do |k,v|
+              case v
+              when Array
+                v.each do |v_part|
+                  result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
+                end
+              else
+                result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
+              end
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/usher/util/parser.rb

@@ -0,0 +1,148 @@
+require 'strscan'
+
+class Usher
+  module Util
+    class Parser
+
+      def self.for_delimiters(router, valid_regex)
+        ParserInstance.new(
+          router,
+          Regexp.new('((:|\*)?' + valid_regex + '|' + router.delimiters_regex + '|\(|\)|\||\{)')
+        )
+      end
+
+      class ParserInstance
+
+        def initialize(router, split_regex)
+          @router = router
+          @split_regex = split_regex
+        end
+
+        def parse(path, requirements = nil, default_values = nil)
+          parts = Group.new(:all, nil)
+          ss = StringScanner.new(path)
+          current_group = parts
+          while !ss.eos?
+            part = ss.scan(@split_regex)
+            case part[0]
+            when ?*, ?:
+              type = part.slice!(0).chr.to_sym
+              current_group << Usher::Route::Variable.new(type, part, requirements && requirements[part.to_sym])
+            when ?{
+              pattern = ''
+              count = 1
+              variable = ss.scan(/[!:\*]([^,]+),/)
+              until count.zero?
+                regex_part = ss.scan(/\{|\}|[^\{\}]+/)
+                case regex_part[0]
+                when ?{
+                  count += 1
+                when ?}
+                  count -= 1
+                end
+                pattern << regex_part
+              end
+              pattern.slice!(pattern.length - 1)
+              regex = Regexp.new(pattern)
+              if variable
+                variable_type = variable.slice!(0).chr.to_sym
+                variable_name = variable[0, variable.size - 1].to_sym
+                current_group << Usher::Route::Variable.new(variable_type, variable_name, requirements && requirements[variable_name], regex)
+              else
+                current_group << regex
+              end
+            when ?(
+              new_group = Group.new(:any, current_group)
+              current_group << new_group
+              current_group = new_group
+            when ?)
+              current_group = current_group.parent.type == :one ? current_group.parent.parent : current_group.parent
+            when ?|
+              unless current_group.parent.type == :one
+                detached_group = current_group.parent.pop
+                new_group = Group.new(:one, detached_group.parent)
+                detached_group.parent = new_group
+                detached_group.type = :all
+                new_group << detached_group
+                new_group.parent << new_group
+              end
+              current_group.parent << Group.new(:all, current_group.parent)
+              current_group = current_group.parent.last
+            else
+              current_group << part
+            end
+          end unless !path || path.empty?
+          paths = calc_paths(parts)
+          paths.each do |path|
+            path.each_with_index do |part, index|
+              if part.is_a?(Usher::Route::Variable)
+                part.default_value = default_values[part.name] if default_values
+
+                case part.type
+                when :*
+                  part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !@router.delimiter_chars.include?(p[0])} || nil
+                when :':'
+                  part.look_ahead = path[index + 1, path.size].find{|p| @router.delimiter_chars.include?(p[0])} || @router.delimiters.first
+                end
+              end
+            end
+          end
+          paths
+        end
+
+        private
+
+        def cartesian_product!(lval, rval)
+          product = []
+          (lval.size * rval.size).times do |index|
+            val = []
+            val.push(*lval[index % lval.size])
+            val.push(*rval[index % rval.size])
+            product << val
+          end
+          lval.replace(product)
+        end
+
+        def calc_paths(parts)
+          if parts.is_a?(Group)
+            paths = [[]]
+            case parts.type
+            when :all
+              parts.each do |p|
+                cartesian_product!(paths, calc_paths(p))
+              end
+            when :any
+              parts.each do |p|
+                cartesian_product!(paths, calc_paths(p))
+              end
+              paths.unshift([])
+            when :one
+              cartesian_product!(paths, parts.collect do |p|
+                calc_paths(p)
+              end)
+            end
+            paths.each{|p| p.compact!; p.flatten! }
+            paths
+          else
+            [[parts]]
+          end
+
+        end
+      end
+
+      class Group < Array
+        attr_accessor :type
+        attr_accessor :parent
+
+        def inspect
+          "#{type}->#{super}"
+        end
+
+        def initialize(type, parent)
+          @type = type
+          @parent = parent
+        end
+      end
+    end
+  end
+end

data/lib/usher/util.rb

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

data/lib/usher.rb

@@ -4,12 +4,12 @@ require File.join(File.dirname(__FILE__), 'usher', 'grapher')
 require File.join(File.dirname(__FILE__), 'usher', 'interface')
 require File.join(File.dirname(__FILE__), 'usher', 'splitter')
 require File.join(File.dirname(__FILE__), 'usher', 'exceptions')
+require File.join(File.dirname(__FILE__), 'usher', 'util')
 
 class Usher
 
-  autoload :Generators, File.join(File.dirname(__FILE__), 'usher', 'generate')
 
-  attr_reader :tree, :named_routes, :route_count, :routes, :splitter, :delimiters
+  attr_reader :tree, :named_routes, :route_count, :routes, :splitter, :delimiters, :delimiter_chars, :delimiters_regex
   
   SymbolArraySorter = proc {|a,b| a.hash <=> b.hash} #:nodoc:
   
@@ -54,12 +54,18 @@ class Usher
   def initialize(options = nil)
     @globs_capture_separators = options && options.key?(:globs_capture_separators) ? options.delete(:globs_capture_separators) : false
     @delimiters = options && options.delete(:delimiters) || ['/', '.']
+    @delimiter_chars = @delimiters.collect{|d| d[0]}
+    @delimiters_regex = @delimiters.collect{|d| Regexp.quote(d)} * '|'
     @valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
     @request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
-    @splitter = Splitter.for_delimiters(@delimiters, @valid_regex)
+    @splitter = Splitter.for_delimiters(self, @valid_regex)
     reset!
   end
 
+  def parser
+    @parser ||= Util::Parser.for_delimiters(self, @valid_regex)
+  end
+
   # Adds a route referencable by +name+. Sett add_route for format +path+ and +options+.
   #   
   #   set = Usher.new
@@ -152,7 +158,18 @@ class Usher
         end
       end
     end
-    route = Route.new(path, self, conditions, requirements, default_values, generate_with)
+    
+    path = parser.parse(path, requirements, default_values) if path.is_a?(String)
+    
+    route = Route.new(
+      path,
+      self, 
+      conditions, 
+      requirements, 
+      default_values, 
+      generate_with
+    )
+    
     route.to(options) if options && !options.empty?
     
     @tree.add(route)
@@ -169,7 +186,7 @@ class Usher
   #   route = set.add_route('/test')
   #   set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request, path = request.path)
-    @tree.find(self, request, @splitter.url_split(path))
+    @tree.find(self, request, path, @splitter.url_split(path))
   end
 
   # Recognizes a set of +parameters+ and gets the closest matching Usher::Route::Path or +nil+ if no route exists.

data/spec/private/generate_spec.rb

@@ -6,7 +6,7 @@ describe "Usher URL generation" do
   before(:each) do
     @route_set = Usher.new
     @route_set.reset!
-    @url_generator = Usher::Generators::URL.new(@route_set)
+    @url_generator = Usher::Util::Generators::URL.new(@route_set)
   end
   
   it "should generate a simple URL" do

data/spec/private/grapher_spec.rb

@@ -6,7 +6,7 @@ describe "Usher grapher" do
   before(:each) do
     @route_set = Usher.new
     @route_set.reset!
-    @url_generator = Usher::Generators::URL.new(@route_set)
+    @url_generator = Usher::Util::Generators::URL.new(@route_set)
   end
 
   it "should find a simple path" do

data/spec/private/parser_spec.rb

@@ -0,0 +1,75 @@
+require 'lib/usher'
+
+describe "Usher route tokenizing" do
+  
+  
+  it "should split / delimited routes" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/this/split').should == [['/', 'test', '/','this', '/', 'split']]
+  end
+
+  it "should split / delimited routes with a regex in it" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/{this}/split').should == [['/', 'test', '/', /this/, '/', 'split']]
+  end
+  
+  it "should split on ' ' delimited routes as well" do
+    Usher.new(:delimiters => [' '], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('test this split').should == [['test', ' ', 'this', ' ', 'split']]
+  end
+  
+  it "should split on email delimiters as well" do
+    Usher.new(:delimiters => ['@', '+', '-', '.'], :valid_regex => '[a-zA-Z0-9]+').parser.parse('one+more.12345-09876-alphanum3ric5@domain.com').should == [["one", '+', "more", ".", "12345", '-', "09876", '-', "alphanum3ric5", "@", "domain", ".", "com"]]
+  end
+  
+  it "should split on ' ' delimited routes for more complex routes as well" do
+    Usher.new(:delimiters => [' '], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('(test|this) split').should == [['test', ' ', 'split'], ['this', ' ', 'split']]
+  end
+  
+  it "should group optional parts with brackets" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/this(/split)').should == [
+      ['/', 'test', '/', 'this'],
+      ['/', 'test', '/', 'this', '/', 'split']
+    ]
+  end
+
+  it "should group exclusive optional parts with brackets and pipes" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/this(/split|/split2)').should == [
+      ['/', 'test', '/', 'this','/', 'split'],
+      ['/', 'test', '/', 'this','/', 'split2']
+    ]
+  end
+
+  it "should group exclusive optional-optional parts with brackets and pipes" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/this((/split|/split2))').should == [
+      ['/', 'test','/', 'this'],
+      ['/', 'test','/', 'this', '/', 'split'],
+      ['/', 'test','/', 'this', '/', 'split2']
+    ]
+  end
+
+  it "should group optional parts with brackets (for non overlapping groups)" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/this(/split)(/split2)') == [
+      ['/', "test", '/', "this"],
+      ['/', "test", '/', "this", '/', "split"],
+      ['/', "test", '/', "this", '/', "split2"],
+      ['/', "test", '/', "this", '/', "split", '/', "split2"]
+    ]
+  end
+
+  it "should group nested-optional parts with brackets" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/test/this(/split(.:format))') == [
+      ['/', "test", '/', "this"],
+      ['/', "test", '/', "this", '/', "split"],
+      ['/', "test", '/', "this", '/', "split", '.', Usher::Route::Variable.new(:':', :format)]
+    ]
+  end
+
+  it "should to_s all different variable types" do
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/:split/*splitter').first.collect{|v| v.to_s} == 
+      [ ':split', '*splitter' ]
+  end
+  
+  it "should == variable types" do
+    parts = Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse('/:split/:split').first
+    parts[1].should == parts[3]
+  end
+  
+end

data/spec/private/recognize_spec.rb

@@ -93,6 +93,18 @@ describe "Usher route recognition" do
     route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']], [:party, 'onemore']]
   end
 
+  it "should recgonize a greedy regex single variable" do
+    target_route = route_set.add_route('/test/part/{!test,one/more/time}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).params.should == [[:test, 'one/more/time']]
+  end
+
+  it "should recgonize a greedy regex single variable with static parts after" do
+    target_route = route_set.add_route('/test/part/{!test,one/more/time}/help')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).params.should == [[:test, 'one/more/time']]
+  end
+
   it "should recgonize two glob-style variables separated by a static part" do
     target_route = route_set.add_route('/*format/innovate/*onemore')
     response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/innovate/apple'}))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.4.8
+  version: 0.4.10
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-16 00:00:00 -07:00
+date: 2009-07-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.3
+        version: 0.0.5
     version: 
 description: A general purpose routing library
 email: joshbuddy@gmail.com
@@ -38,7 +38,6 @@ files:
 - VERSION.yml
 - lib/usher.rb
 - lib/usher/exceptions.rb
-- lib/usher/generate.rb
 - lib/usher/grapher.rb
 - lib/usher/interface.rb
 - lib/usher/interface/email_interface.rb
@@ -55,10 +54,14 @@ files:
 - lib/usher/route/request_method.rb
 - lib/usher/route/variable.rb
 - lib/usher/splitter.rb
+- lib/usher/util.rb
+- lib/usher/util/generate.rb
+- lib/usher/util/parser.rb
 - rails/init.rb
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
+- spec/private/parser_spec.rb
 - spec/private/path_spec.rb
 - spec/private/rack/dispatch_spec.rb
 - spec/private/rails2_2/compat.rb
@@ -71,7 +74,6 @@ files:
 - spec/private/rails2_3/recognize_spec.rb
 - spec/private/recognize_spec.rb
 - spec/private/request_method_spec.rb
-- spec/private/split_spec.rb
 - spec/spec.opts
 has_rdoc: false
 homepage: http://github.com/joshbuddy/usher
@@ -103,6 +105,7 @@ test_files:
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
+- spec/private/parser_spec.rb
 - spec/private/path_spec.rb
 - spec/private/rack/dispatch_spec.rb
 - spec/private/rails2_2/compat.rb
@@ -115,4 +118,3 @@ test_files:
 - spec/private/rails2_3/recognize_spec.rb
 - spec/private/recognize_spec.rb
 - spec/private/request_method_spec.rb
-- spec/private/split_spec.rb

data/lib/usher/generate.rb

@@ -1,131 +0,0 @@
-require 'rack'
-
-unless Rack::Utils.respond_to?(:uri_escape)
-  module Rack
-
-    module Utils
-
-      def uri_escape(s)
-        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
-          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
-        }.tr(' ', '+')
-      end
-      module_function :uri_escape
-
-      def uri_unescape(s)
-        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-          [$1.delete('%')].pack('H*')
-        }
-      end
-      module_function :uri_unescape
-
-    end
-  end
-end
-
-class Usher
-  class Generators
-    
-    class URL
-      
-      def initialize(usher)
-        @usher = usher
-      end
-
-      def generate_full(routing_lookup, request, params = nil)
-        path = path_for_routing_lookup(routing_lookup, params)
-        result = generate_start(path, request)
-        result << generate_path(path, params)
-      end
-
-      def generate(routing_lookup, params = nil)
-        generate_path(path_for_routing_lookup(routing_lookup, params), params)
-      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 if port != 443
-        else
-          result << ':' << port.to_s if port != 80
-        end
-        result
-      end
-
-      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
-        when Route
-          params.is_a?(Hash) ? routing_lookup.find_matching_path(params) : routing_lookup.paths.first
-        when nil
-          params.is_a?(Hash) ? @usher.path_for_options(params) : raise
-        when Route::Path
-          routing_lookup
-        end
-      end
-    
-      # Generates a completed URL based on a +route+ or set of optional +params+
-      #   
-      #   set = Usher.new
-      #   route = set.add_named_route(:test_route, '/:controller/:action')
-      #   set.generate_url(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-      #   set.generate_url(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-      #   set.generate_url(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-      def generate_path(path, params = nil)
-        raise UnrecognizedException.new unless path
-
-        params = Array(params) if params.is_a?(String)
-        if params.is_a?(Array)
-          given_size = params.size
-          extra_params = params.last.is_a?(Hash) ? params.pop : nil
-          params = Hash[*path.dynamic_parts.inject([]){|a, dynamic_part| a.concat([dynamic_part.name, params.shift || raise(MissingParameterException.new("got #{given_size}, expected #{path.dynamic_parts.size} parameters"))]); a}]
-          params.merge!(extra_params) if extra_params
-        end
-
-        result = ''
-        path.parts.each do |part|
-          case part
-          when Route::Variable
-            value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
-            case part.type
-            when :*
-              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 << '/' if index != value.size - 1
-              end
-            when :':'
-              value = value.to_s unless value.is_a?(String)
-              part.valid!(value)
-              result << value
-            end
-          else
-            result << part
-          end
-        end
-        result = Rack::Utils.uri_escape(result)
-
-        if params && !params.empty?
-          has_query = result[??]
-          params.each do |k,v|
-            case v
-            when Array
-              v.each do |v_part|
-                result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
-              end
-            else
-              result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
-            end
-          end
-        end
-        result
-      end
-    end
-  end
-end

data/spec/private/split_spec.rb

@@ -1,76 +0,0 @@
-require 'lib/usher'
-
-describe "Usher route tokenizing" do
-  
-  
-  it "should split / delimited routes" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this/split').should == [['/', 'test', '/','this', '/', 'split']]
-  end
-
-  it "should split / delimited routes with a regex in it" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').
-      split('/test/{this}/split').should == [['/', 'test', '/', /this/, '/', 'split']]
-  end
-  
-  it "should split on ' ' delimited routes as well" do
-    Usher::Splitter.for_delimiters([' '], '[0-9A-Za-z\$\-_\+!\*\',]+').split('test this split').should == [['test', ' ', 'this', ' ', 'split']]
-  end
-  
-  it "should split on email delimiters as well" do
-    Usher::Splitter.for_delimiters(['@', '+', '-', '.'], '[a-zA-Z0-9]+').split('one+more.12345-09876-alphanum3ric5@domain.com').should == [["one", '+', "more", ".", "12345", '-', "09876", '-', "alphanum3ric5", "@", "domain", ".", "com"]]
-  end
-  
-  it "should split on ' ' delimited routes for more complex routes as well" do
-    Usher::Splitter.for_delimiters([' '], '[0-9A-Za-z\$\-_\+!\*\',]+').split('(test|this) split').should == [['test', ' ', 'split'], ['this', ' ', 'split']]
-  end
-  
-  it "should group optional parts with brackets" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split)').should == [
-      ['/', 'test', '/', 'this'],
-      ['/', 'test', '/', 'this', '/', 'split']
-    ]
-  end
-
-  it "should group exclusive optional parts with brackets and pipes" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split|/split2)').should == [
-      ['/', 'test', '/', 'this','/', 'split'],
-      ['/', 'test', '/', 'this','/', 'split2']
-    ]
-  end
-
-  it "should group exclusive optional-optional parts with brackets and pipes" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this((/split|/split2))').should == [
-      ['/', 'test','/', 'this'],
-      ['/', 'test','/', 'this', '/', 'split'],
-      ['/', 'test','/', 'this', '/', 'split2']
-    ]
-  end
-
-  it "should group optional parts with brackets (for non overlapping groups)" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split)(/split2)') == [
-      ['/', "test", '/', "this"],
-      ['/', "test", '/', "this", '/', "split"],
-      ['/', "test", '/', "this", '/', "split2"],
-      ['/', "test", '/', "this", '/', "split", '/', "split2"]
-    ]
-  end
-
-  it "should group nested-optional parts with brackets" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split(.:format))') == [
-      ['/', "test", '/', "this"],
-      ['/', "test", '/', "this", '/', "split"],
-      ['/', "test", '/', "this", '/', "split", '.', Usher::Route::Variable.new(:':', :format)]
-    ]
-  end
-
-  it "should to_s all different variable types" do
-    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/:split/*splitter').first.collect{|v| v.to_s} == 
-      [ ':split', '*splitter' ]
-  end
-  
-  it "should == variable types" do
-    parts = Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/:split/:split').first
-    parts[1].should == parts[3]
-  end
-  
-end