joshbuddy-usher 0.4.11 → 0.5.1

data/README.rdoc

@@ -5,11 +5,12 @@ Tree-based router library. Useful for (specifically) for Rails and Rack, but pro
 == Features
 
 * Understands single and path-globbing variables
+* Understands arbitrary regex variables
 * Arbitrary HTTP header requirements
 * No optimization phase, so routes are always alterable after the fact
 * Understands Proc and Regex transformations, validations
 * Really, really fast
-* Relatively light and happy code-base, should be easy and fun to alter
+* Relatively light and happy code-base, should be easy and fun to alter (it hovers around 1,000 LOC, 800 for the core)
 * Interface and implementation are separate, encouraging cross-pollination
 
 == Route format

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.5'
+    s.add_dependency 'fuzzyhash', '>=0.0.6'
   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 @@
 --- 
-:patch: 11
 :major: 0
-:minor: 4
+:minor: 5
+:patch: 1

data/lib/usher/grapher.rb

@@ -14,7 +14,7 @@ class Usher
 
     def add_route(route)
       route.paths.each do |path|
-        unless path.dynamic_keys.size.zero?
+        if path.dynamic?
           path.dynamic_keys.each do |k|
             @orders[path.dynamic_keys.size][k] << path
             @key_count[k] += 1
@@ -50,12 +50,12 @@ class Usher
         end
         set.size.downto(1) do |o|
           set.each do |k|
-            @orders[o][k].each { |r| 
+            @orders[o][k].each do |r| 
               if r.can_generate_from?(set)
                 @cache[set] = r
                 return r
               end
-            }
+            end
           end
         end
         nil

data/lib/usher/interface/email_interface.rb

@@ -3,7 +3,7 @@ class Usher
     class EmailInterface
       
       def initialize(&blk)
-        @routes = Usher.new(:delimiters => ['@', '-', '.'], :valid_regex => '[\+a-zA-Z0-9]+', :globs_capture_separators => true)
+        @routes = Usher.new(:delimiters => ['@', '-', '.'], :valid_regex => '[\+a-zA-Z0-9]+')
         instance_eval(&blk) if blk
       end
       

data/lib/usher/interface/rails2_2_interface.rb

@@ -38,7 +38,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
       

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
       

data/lib/usher/node.rb

@@ -7,7 +7,7 @@ class Usher
     Response = Struct.new(:path, :params)
     
     attr_reader :lookup, :greedy_lookup
-    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods, :globs_capture_separators
+    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods
 
     def initialize(parent, value)
       @parent = parent
@@ -33,10 +33,9 @@ class Usher
       !@greedy_lookup.empty?
     end
     
-    def self.root(route_set, request_methods, globs_capture_separators)
+    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
 
@@ -77,30 +76,25 @@ class Usher
               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)
-
             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  
+              (upgrade_method, lookup_method) = case key
+              when Route::Variable::Greedy
+                [:upgrade_greedy_lookup, :greedy_lookup]
               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  
+                [: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
@@ -118,48 +112,44 @@ class Usher
         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])))
+      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.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 next_part.value.globs_capture_separators
-                params.last.last << part
-              elsif !usher.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?
-              next_path_part = path.shift
-              position += next_path_part.size
-              params.last.last << next_path_part
+            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, original_path, path, params, position)
       else

data/lib/usher/route/path.rb

@@ -2,22 +2,48 @@ class Usher
   class Route
     class Path
   
-      attr_reader :dynamic_parts, :dynamic_map, :dynamic_indicies, :route, :parts, :dynamic_required_keys, :dynamic_keys
+      attr_reader :route, :parts
       
       def initialize(route, parts)
         @route = route
         @parts = parts
-        @dynamic_indicies = []
-        @parts.each_index{|i| @dynamic_indicies << i if @parts[i].is_a?(Variable)}
-        @dynamic_parts = @parts.values_at(*@dynamic_indicies)
-        @dynamic_map = {}
-        @dynamic_parts.each{|p| @dynamic_map[p.name] = p }
-        @dynamic_keys = @dynamic_map.keys
-        @dynamic_required_keys = @dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name}
+        @dynamic = @parts.any?{|p| p.is_a?(Variable)}
+      end
+
+      def dynamic_indicies
+        unless @dynamic_indicies
+          @dynamic_indicies = []
+          parts.each_index{|i| @dynamic_indicies << i if parts[i].is_a?(Variable)}
+        end
+        @dynamic_indicies
+      end
+
+      def dynamic_parts
+        @dynamic_parts ||= parts.values_at(*dynamic_indicies)
+      end
+
+      def dynamic_map
+        unless @dynamic_map
+          @dynamic_map = {}
+          dynamic_parts.each{|p| @dynamic_map[p.name] = p }
+        end
+        @dynamic_map
+      end
+      
+      def dynamic_keys
+        @dynamic_keys ||= dynamic_map.keys
+      end
+      
+      def dynamic_required_keys
+        @dynamic_required_keys ||= dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name}
+      end
+      
+      def dynamic?
+        @dynamic
       end
 
       def can_generate_from?(keys)
-        (@dynamic_required_keys - keys).size.zero?
+        (dynamic_required_keys - keys).size.zero?
       end
     end
   end

data/lib/usher/route/util.rb

@@ -0,0 +1,65 @@
+class Usher
+  class Route
+
+    module Util
+
+      class Group < Array
+        attr_accessor :group_type
+        attr_accessor :parent
+
+        def inspect
+          "#{group_type}->#{super}"
+        end
+
+        def initialize(group_type, parent)
+          @group_type = group_type
+          @parent = parent
+        end
+      end
+
+      def self.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 self.expand_path(parts)
+        if parts.is_a?(Array)
+          paths = [[]]
+          
+          unless parts.respond_to?(:group_type)
+            new_parts = Group.new(:any, nil)
+            parts.each{|p| new_parts << p}
+            parts = new_parts
+          end
+          
+          case parts.group_type
+          when :all
+            parts.each do |p|
+              cartesian_product!(paths, expand_path(p))
+            end
+          when :any
+            parts.each do |p|
+              cartesian_product!(paths, expand_path(p))
+            end
+            paths.unshift([])
+          when :one
+            cartesian_product!(paths, parts.collect do |p|
+              expand_path(p)
+            end)
+          end
+          paths.each{|p| p.compact!; p.flatten! }
+          paths
+        else
+          [[parts]]
+        end
+
+      end
+    end
+  end
+end

data/lib/usher/route/variable.rb

@@ -2,23 +2,14 @@ class Usher
   class Route
     class Variable
       attr_reader :type, :name, :validator, :regex_matcher
-      attr_accessor :look_ahead, :globs_capture_separators, :default_value
+      attr_accessor :look_ahead, :default_value
       
-      def initialize(type, name, validator = nil, regex_matcher = nil, globs_capture_separators = false)
-        @type = type
-        @name = :"#{name}"
+      def initialize(name, regex_matcher = nil, validator = nil)
+        @name = name.to_s.to_sym
         @validator = validator
         @regex_matcher = regex_matcher
-        @globs_capture_separators = globs_capture_separators
-      end
-
-      def to_s
-        "#{type}#{name}"
-      end
-      
-      def greedy?
-        type == :'!'
       end
+      private :initialize
       
       def valid!(val)
         case @validator
@@ -26,7 +17,7 @@ class Usher
           begin
             @validator.call(val)
           rescue Exception => e
-            raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
+            raise ValidationException.new("#{val} does not conform to #{@g}, root cause #{e.inspect}")
           end
         else
           @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}"))
@@ -34,8 +25,24 @@ class Usher
       end
       
       def ==(o)
-        o && (o.type == @type && o.name == @name && o.validator == @validator)
+        o && (o.class == self.class && o.name == @name && o.validator == @validator)
+      end
+      
+      class Single < Variable
+        def to_s
+          ":#{name}"
+        end
+      end
+
+      class Glob < Variable
+        def to_s
+          "*#{name}"
+        end
       end
+
+      Greedy = Class.new(Variable)
+      
     end
+    
   end
 end

data/lib/usher/route.rb

@@ -1,4 +1,5 @@
 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')
 

data/lib/usher/splitter.rb

@@ -4,7 +4,7 @@ class Usher
   class Splitter
     
     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)}}]+"))
+      SplitterInstance.new(Regexp.new("[#{router.delimiters.collect{|d| Regexp.quote(d)}.join}]|[^#{router.delimiters.collect{|d| Regexp.quote(d)}.join}]+"))
     end
 
     class SplitterInstance

data/lib/usher/util/generate.rb

@@ -91,21 +91,19 @@ class Usher
           result = ''
           path.parts.each do |part|
             case part
-            when Route::Variable
+            when Route::Variable::Glob
               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
+              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 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
             else
               result << part
             end

data/lib/usher/util/parser.rb

@@ -18,16 +18,23 @@ class Usher
           @split_regex = split_regex
         end
 
+        def parse_and_expand(path, requirements = nil, default_values = nil)
+          Usher::Route::Util.expand_path(parse(path, requirements, default_values))
+        end
+
         def parse(path, requirements = nil, default_values = nil)
-          parts = Group.new(:all, nil)
+          parts = Usher::Route::Util::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 ?*
+              var_name = part[1, part.size - 1].to_sym
+              current_group << Usher::Route::Variable::Glob.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
+            when ?:
+              var_name = part[1, part.size - 1].to_sym
+              current_group << Usher::Route::Variable::Single.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
             when ?{
               pattern = ''
               count = 1
@@ -46,103 +53,43 @@ class Usher
               regex = Regexp.new(pattern)
               if variable
                 variable_type = variable.slice!(0).chr.to_sym
+                variable_class = case variable_type
+                when :'!' then Usher::Route::Variable::Greedy
+                when :*   then Usher::Route::Variable::Glob
+                when :':' then Usher::Route::Variable::Single
+                end
+                
                 variable_name = variable[0, variable.size - 1].to_sym
-                current_group << Usher::Route::Variable.new(variable_type, variable_name, requirements && requirements[variable_name], regex)
+                current_group << variable_class.new(variable_name, regex, requirements && requirements[variable_name])
               else
                 current_group << regex
               end
             when ?(
-              new_group = Group.new(:any, current_group)
+              new_group = Usher::Route::Util::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
+              current_group = current_group.parent.group_type == :one ? current_group.parent.parent : current_group.parent
             when ?|
-              unless current_group.parent.type == :one
+              unless current_group.parent.group_type == :one
                 detached_group = current_group.parent.pop
-                new_group = Group.new(:one, detached_group.parent)
+                new_group = Usher::Route::Util::Group.new(:one, detached_group.parent)
                 detached_group.parent = new_group
-                detached_group.type = :all
+                detached_group.group_type = :all
                 new_group << detached_group
                 new_group.parent << new_group
               end
-              current_group.parent << Group.new(:all, current_group.parent)
+              current_group.parent << Usher::Route::Util::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)
+          parts
         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.rb

@@ -31,7 +31,7 @@ class Usher
   #   set.reset!
   #   set.empty? => true
   def reset!
-    @tree = Node.root(self, @request_methods, @globs_capture_separators)
+    @tree = Node.root(self, @request_methods)
     @named_routes = {}
     @routes = []
     @route_count = 0
@@ -41,9 +41,6 @@ class Usher
   
   # Creates a route set, with options
   # 
-  # <tt>:globs_capture_separators</tt>: +true+ or +false+. (default +false+) Specifies whether glob matching will also include separators
-  # that are matched.
-  # 
   # <tt>:delimiters</tt>: Array of Strings. (default <tt>['/', '.']</tt>). Delimiters used in path separation. Array must be single character strings.
   # 
   # <tt>:valid_regex</tt>: String. (default <tt>'[0-9A-Za-z\$\-_\+!\*\',]+'</tt>). String that can be interpolated into regex to match
@@ -52,7 +49,6 @@ class Usher
   # <tt>:request_methods</tt>: Array of Symbols. (default <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]</tt>)
   # Array of methods called against the request object for the purposes of matching route requirements.
   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)} * '|'
@@ -154,7 +150,7 @@ class Usher
   # * +requirements+ - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
   # * +conditions+ - Accepts any of the +request_methods+ specificied in the construction of Usher. This can be either a <tt>string</tt> or a regular expression.
   # * Any other key is interpreted as a requirement for the variable of its name.
-  def add_route(path, options = nil)
+  def add_route(unprocessed_path, options = nil)
     conditions = options && options.delete(:conditions) || nil
     requirements = options && options.delete(:requirements) || nil
     default_values = options && options.delete(:default_values) || nil
@@ -168,10 +164,30 @@ class Usher
       end
     end
     
-    path = parser.parse(path, requirements, default_values) if path.is_a?(String)
+    unprocessed_path = parser.parse(unprocessed_path, requirements, default_values) if unprocessed_path.is_a?(String)
+    
+    unless unprocessed_path.first.is_a?(Route::Util::Group)
+      group = Usher::Route::Util::Group.new(:all, nil)
+      unprocessed_path.each{|p| group << p}
+      unprocessed_path = group
+    end
+
+    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
+          part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !delimiter_chars.include?(p[0])} || nil
+        when Usher::Route::Variable
+          part.look_ahead = path[index + 1, path.size].find{|p| delimiter_chars.include?(p[0])} || delimiters.first
+        end
+      end
+    end
+
     route = Route.new(
-      path,
+      paths,
       self, 
       conditions, 
       requirements, 
@@ -198,6 +214,16 @@ class Usher
     @tree.find(self, request, path, @splitter.url_split(path))
   end
 
+  # Recognizes a +path+ and returns +nil+ or an Usher::Node::Response, which is a struct containing a Usher::Route::Path and an array of arrays containing the extracted parameters. Convenience method for when recognizing on the request object is unneeded.
+  #   
+  #   Request = Struct.new(:path)
+  #   set = Usher.new
+  #   route = set.add_route('/test')
+  #   set.recognize_path('/test').path.route == route => true
+  def recognize_path(path)
+    recognize(nil, path)
+  end
+
   # Recognizes a set of +parameters+ and gets the closest matching Usher::Route::Path or +nil+ if no route exists.
   #   
   #   set = Usher.new

data/spec/private/email/recognize_spec.rb

@@ -1,7 +1,5 @@
 require 'lib/usher'
 
-
-
 def build_email_mock(email)
   request = mock "Request"
   request.should_receive(:email).any_number_of_times.and_return(email)
@@ -24,14 +22,14 @@ describe "Usher (for email) route recognition" do
   it "should recognize a wildcard domain" do
     receiver = mock('receiver')
     receiver.should_receive(:action).with({:domain => 'gmail.com'}).exactly(1)
-    @route_set.for('joshbuddy@*domain') { |params| receiver.action(params) }
+    @route_set.for('joshbuddy@{!domain,.*}') { |params| receiver.action(params) }
     @route_set.act('joshbuddy@gmail.com')
   end
 
   it "should recognize a complex email" do
     receiver = mock('receiver')
     receiver.should_receive(:action).with({:subject => 'sub+ect', :id => '123', :sid => '456', :tok => 'sdqwe123ae', :domain => 'mydomain.org'}).exactly(1)
-    @route_set.for(':subject.{:id,^\d+$}-{:sid,^\d+$}-{:tok,^\w+$}@*domain') { |params| receiver.action(params) }
+    @route_set.for(':subject.{!id,\d+}-{!sid,\d+}-{!tok,\w+}@{!domain,.*}') { |params| receiver.action(params) }
     @route_set.act('sub+ect.123-456-sdqwe123ae@mydomain.org')
   end
 

data/spec/private/parser_spec.rb

@@ -4,41 +4,41 @@ 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']]
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/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']]
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/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']]
+    Usher.new(:delimiters => [' '], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('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"]]
+    Usher.new(:delimiters => ['@', '+', '-', '.'], :valid_regex => '[a-zA-Z0-9]+').parser.parse_and_expand('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']]
+    Usher.new(:delimiters => [' '], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('(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 == [
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/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 == [
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/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 == [
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/test/this((/split|/split2))').should == [
       ['/', 'test','/', 'this'],
       ['/', 'test','/', 'this', '/', 'split'],
       ['/', 'test','/', 'this', '/', 'split2']
@@ -46,7 +46,7 @@ describe "Usher route tokenizing" do
   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)') == [
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/test/this(/split)(/split2)') == [
       ['/', "test", '/', "this"],
       ['/', "test", '/', "this", '/', "split"],
       ['/', "test", '/', "this", '/', "split2"],
@@ -55,20 +55,20 @@ describe "Usher route tokenizing" do
   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))') == [
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/test/this(/split(.:format))') == [
       ['/', "test", '/', "this"],
       ['/', "test", '/', "this", '/', "split"],
-      ['/', "test", '/', "this", '/', "split", '.', Usher::Route::Variable.new(:':', :format)]
+      ['/', "test", '/', "this", '/', "split", '.', Usher::Route::Variable::Single.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} == 
+    Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/: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 = Usher.new(:delimiters => ['/', '.'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('/:split/:split').first
     parts[1].should == parts[3]
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.4.11
+  version: 0.5.1
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-22 00:00:00 -07:00
+date: 2009-08-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.5
+        version: 0.0.6
     version: 
 description: A general purpose routing library
 email: joshbuddy@gmail.com
@@ -52,6 +52,7 @@ files:
 - lib/usher/route.rb
 - lib/usher/route/path.rb
 - lib/usher/route/request_method.rb
+- lib/usher/route/util.rb
 - lib/usher/route/variable.rb
 - lib/usher/splitter.rb
 - lib/usher/util.rb
@@ -77,6 +78,7 @@ files:
 - spec/spec.opts
 has_rdoc: false
 homepage: http://github.com/joshbuddy/usher
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -97,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A general purpose routing library