joshbuddy-usher 0.1.2 → 0.2.0

data/README.rdoc

@@ -6,14 +6,52 @@ This is a tree-based router (based on Ilya Grigorik suggestion). Turns out looki
 
 == Route format
 
-Here are some examples of routes recognized by usher (so far)
-
-  *Route*                  *Matches*
-  /path/to/something       /path/to/something
-  /path/:variable/more     /path/foo/more, /path/bar/more ...
-  /show/*tags              /show/hot /show/hot/coffee /show/some/more/hot/coffee ...
-  /route(/help)            /route, /route/help
-  /route(.:format)         /route, /route.xml, /route.html ...
+From the rdoc:
+
+<tt>+path+</tt>::
+   A path consists a mix of dynamic and static parts delimited by <tt>/</tt>
+
+   *Dynamic*
+
+   Dynamic parts are prefixed with either :, *.  :variable matches only one part of the path, whereas *variable can match one or
+   more parts. 
+
+   Example:
+   <tt>/path/:variable/path</tt> would match
+   
+   * <tt>/path/test/path</tt>
+   * <tt>/path/something_else/path</tt>
+   * <tt>/path/one_more/path</tt>
+   
+   In the above examples, 'test', 'something_else' and 'one_more' respectively would be bound to the key <tt>:variable</tt>.
+   However, <tt>/path/test/one_more/path</tt> would not be matched. 
+   
+   Example:
+   <tt>/path/*variable/path</tt> would match
+   
+   * <tt>/path/one/two/three/path</tt>
+   * <tt>/path/four/five/path</tt>
+   
+   In the above examples, ['one', 'two', 'three'] and ['four', 'five'] respectively would be bound to the key :variable.
+
+   *Static*
+   
+   Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
+
+   <b>Optional sections</b>
+
+   Sections of a route can be marked as optional by surrounding it with brackets. For instance, in the above static example, <tt>/path/something(.html)</tt> would match both <tt>/path/something</tt> and <tt>/path/something.html</tt>.
+
+   <b>One and only one sections</b>
+
+   Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes. For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and <tt>/path/something.html</tt>.
+
+<tt>+options+</tt>::
+   --
+   * :transformers - Transforms a variable before it gets to the conditions and requirements. Takes either a +proc+ or a +symbol+. If its a +symbol+, calls the method on the incoming parameter. If its a +proc+, its called with the variable.
+   * :requirements - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
+   * :conditions - Accepts any of the following <tt>:protocol</tt>, <tt>:domain</tt>, <tt>:port</tt>, <tt>:query_string</tt>, <tt>:remote_ip</tt>, <tt>:user_agent</tt>, <tt>:referer</tt> and <tt>:method</tt>. This can be either a <tt>string</tt> or a <tt>regexp</tt>.
+   * any other key is interpreted as a requirement for the variable of its name.
 
 == Rails
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 2
 :major: 0
-:minor: 1
+:minor: 2
+:patch: 0

data/lib/usher/route/splitter.rb

@@ -2,7 +2,7 @@ class Usher
   class Route
     class Splitter
       
-      ScanRegex = /((:|\*||\.:|\.)[0-9a-z_]+|\/|\(|\))/
+      ScanRegex = /((:|\*||\.:|\.)[0-9a-z_]+|\/|\(|\)|\|)/
       UrlScanRegex = /\/|\.?\w+/
       
       attr_reader :paths
@@ -10,6 +10,7 @@ class Usher
       def initialize(path, requirements = {}, transformers = {})
         @parts = Splitter.split(path, requirements, transformers)
         @paths = calc_paths(@parts)
+        @paths
       end
 
       def self.url_split(path)
@@ -24,9 +25,8 @@ class Usher
       end
       
       def self.split(path, requirements = {}, transformers = {})
-        parts = []
+        parts = Group.new(:all, nil)
         ss = StringScanner.new(path)
-        groups = [parts]
         current_group = parts
         while !ss.eos?
           part = ss.scan(ScanRegex)
@@ -35,13 +35,22 @@ class Usher
             type = (part[1] == ?: ? part.slice!(0,2) : part.slice!(0).chr).to_sym
             current_group << Variable.new(type, part, :validator => requirements[part.to_sym], :transformer => transformers[part.to_sym])
           when ?(
-            new_group = []
-            groups << new_group
+            new_group = Group.new(:any, current_group)
             current_group << new_group
             current_group = new_group
-          when ?)
-            groups.pop
-            current_group = groups.last
+          when ?)            
+            current_group = 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
           when ?/
           else
             current_group << part
@@ -49,33 +58,57 @@ class Usher
         end unless !path || path.empty?
         parts
       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)
-        paths = []
-        optional_parts = []
-        parts.each_index {|i| optional_parts << i if parts[i].is_a?(Array)}
-        if optional_parts.size.zero?
-          [parts]
-        else
-          (0...(2 << (optional_parts.size - 1))).each do |i|
-            current_paths = [[]]
-            parts.each_index do |part_index|
-              part = parts[part_index]
-              if optional_parts.include?(part_index) && (2 << (optional_parts.index(part_index)-1) & i != 0)
-                new_sub_parts = calc_paths(part)
-                current_paths_size = current_paths.size
-                (new_sub_parts.size - 1).times {|i| current_paths << current_paths[i % current_paths_size].dup }
-                current_paths.each_index do |current_path_idx|
-                  current_paths[current_path_idx].push(*new_sub_parts[current_path_idx % new_sub_parts.size])
-                end
-              elsif !optional_parts.include?(part_index)
-                current_paths.each { |current_path| current_path << part }
-              end
+        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.push(*current_paths)
+            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
+      
+      class Group < Array
+        attr_accessor :type
+        attr_accessor :parent
+        
+        def inspect
+          "#{type}->#{super}"
+        end
+        
+        def initialize(type, parent)
+          @type = type
+          @parent = parent
         end
       end
       

data/lib/usher.rb

@@ -9,7 +9,7 @@ require 'usher/exceptions'
 class Usher
   attr_reader :tree, :named_routes, :route_count, :routes
   
-  SymbolArraySorter = proc {|a,b| a.hash <=> b.hash}
+  SymbolArraySorter = proc {|a,b| a.hash <=> b.hash} #:nodoc:
   
   # Returns whether the route set is empty
   #   
@@ -63,33 +63,47 @@ class Usher
   #  
   # <tt>+path+</tt>::
   #    A path consists a mix of dynamic and static parts delimited by <tt>/</tt>
-  # 
+  #
   #    *Dynamic*
   #
   #    Dynamic parts are prefixed with either :, *.  :variable matches only one part of the path, whereas *variable can match one or
-  #    more parts. Example:
-  #    <b>/path/:variable/path</b> would match
-  #    
-  #    * /path/test/path
-  #    * /path/something_else/path
-  #    * /path/one_more/path
-  #    
-  #    In the above examples, 'test', 'something_else' and 'one_more' respectively would be bound to the key :variable.
-  #    However, /path/test/one_more/path would not be matched. 
-  #    
+  #    more parts. 
+  #
+  #    Example:
+  #    <tt>/path/:variable/path</tt> would match
+  #
+  #    * <tt>/path/test/path</tt>
+  #    * <tt>/path/something_else/path</tt>
+  #    * <tt>/path/one_more/path</tt>
+  #
+  #    In the above examples, 'test', 'something_else' and 'one_more' respectively would be bound to the key <tt>:variable</tt>.
+  #    However, <tt>/path/test/one_more/path</tt> would not be matched. 
+  #
   #    Example:
-  #    <b>/path/*variable/path</b> would match
-  #    
-  #    * /path/one/two/three/path
-  #    * /path/four/five/path
-  #    
+  #    <tt>/path/*variable/path</tt> would match
+  #
+  #    * <tt>/path/one/two/three/path</tt>
+  #    * <tt>/path/four/five/path</tt>
+  #
   #    In the above examples, ['one', 'two', 'three'] and ['four', 'five'] respectively would be bound to the key :variable.
-  #    
+  #
+  #    *Static*
+  #
+  #    Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
+  #
+  #    <b>Optional sections</b>
+  #
+  #    Sections of a route can be marked as optional by surrounding it with brackets. For instance, in the above static example, <tt>/path/something(.html)</tt> would match both <tt>/path/something</tt> and <tt>/path/something.html</tt>.
+  #
+  #    <b>One and only one sections</b>
+  #
+  #    Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes. For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and <tt>/path/something.html</tt>.
+  #
   # <tt>+options+</tt>::
   #    --
-  #    * :transformers - Transforms a variable before it gets to the conditions and requirements. Takes either a +proc+ or a +symbol+. If its a +symbol+, calls the method on the incoming parameter. If its a +proc+, its called with the variable.
-  #    * :requirements - After transformation, tests the condition using ===. If it returns false, it raises an +Usher::ValidationException+
-  #    * :conditions - Accepts any of the following +:protocol+, +:domain+, +:port+, +:query_string+, +:remote_ip+, +:user_agent+, +:referer+ and +:method+. This can be either a +string+ or a +regexp+.
+  #    * :transformers - Transforms a variable before it gets to the requirements. Takes either a +proc+ or a +symbol+. If its a +symbol+, calls the method on the incoming parameter. If its a +proc+, its called with the variable.
+  #    * :requirements - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
+  #    * :conditions - Accepts any of the following <tt>:protocol</tt>, <tt>:domain</tt>, <tt>:port</tt>, <tt>:query_string</tt>, <tt>:remote_ip</tt>, <tt>:user_agent</tt>, <tt>:referer</tt> and <tt>:method</tt>. This can be either a <tt>string</tt> or a <tt>regexp</tt>.
   #    * any other key is interpreted as a requirement for the variable of its name.
   def add_route(path, options = {})
     transformers = options.delete(:transformers) || {}
@@ -180,16 +194,10 @@ class Usher
         case v
         when Array
           v.each do |v_part|
-            generated_path << (has_query ? '&' : has_query = true && '?')
-            generated_path << CGI.escape("#{k.to_s}[]")
-            generated_path << '='
-            generated_path << CGI.escape(v_part.to_s)
+            generated_path << (has_query ? '&' : has_query = true && '?') << CGI.escape("#{k.to_s}[]") << '=' << CGI.escape(v_part.to_s)
           end
         else
-          generated_path << (has_query ? '&' : has_query = true && '?')
-          generated_path << CGI.escape(k.to_s)
-          generated_path << '='
-          generated_path << CGI.escape(v.to_s)
+          generated_path << (has_query ? '&' : has_query = true && '?') << CGI.escape(k.to_s) << '=' << CGI.escape(v.to_s)
         end
       end
     end

data/spec/path_spec.rb

@@ -23,10 +23,10 @@ describe "Usher route adding" do
     route_set.add_route('/a/b(/c)(/d(/e))')
     route_set.routes.first.paths.collect{|a| a.parts }.should == [
       ["a", "b"],
+      ["a", "b", "c", "d"], 
+      ["a", "b", "d", "e"], 
       ["a", "b", "c"],
       ["a", "b", "d"],
-      ["a", "b", "d", "e"], 
-      ["a", "b", "c", "d"], 
       ["a", "b", "c", "d", "e"]
     ]
     

data/spec/rack/dispatch_spec.rb

@@ -1,4 +1,3 @@
-require 'lib/compat'
 require 'lib/usher'
 
 route_set = Usher::Interface.for(:rack)

data/spec/rails/generate_spec.rb

@@ -1,4 +1,4 @@
-require 'lib/compat'
+require File.join(File.dirname(__FILE__), 'compat')
 require 'lib/usher'
 
 route_set = Usher::Interface.for(:rails2)

data/spec/rails/path_spec.rb

@@ -1,4 +1,4 @@
-require 'lib/compat'
+require File.join(File.dirname(__FILE__), 'compat')
 require 'lib/usher'
 
 route_set = Usher::Interface.for(:rails2)

data/spec/rails/recognize_spec.rb

@@ -1,4 +1,4 @@
-require 'lib/compat'
+require File.join(File.dirname(__FILE__), 'compat')
 require 'lib/usher'
 require 'action_controller'
 

data/spec/split_spec.rb

@@ -14,6 +14,21 @@ describe "Usher route tokenizing" do
     ]
   end
 
+  it "should group exclusive optional parts with brackets and pipes" do
+    Usher::Route::Splitter.new('/test/this(/split|/split2)').paths.should == [
+      ['test', 'this', 'split'],
+      ['test', 'this', 'split2']
+    ]
+  end
+
+  it "should group exclusive optional-optional parts with brackets and pipes" do
+    Usher::Route::Splitter.new('/test/this((/split|/split2))').paths.should == [
+      ['test', 'this'],
+      ['test', 'this', 'split'],
+      ['test', 'this', 'split2']
+    ]
+  end
+
   it "should group optional parts with brackets (for non overlapping groups)" do
     Usher::Route::Splitter.new('/test/this(/split)(/split2)').paths == [
       ["test", "this"],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-28 00:00:00 -07:00
+date: 2009-03-31 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,7 +36,6 @@ files:
 - Rakefile
 - README.rdoc
 - VERSION.yml
-- lib/compat.rb
 - lib/usher
 - lib/usher/exceptions.rb
 - lib/usher/grapher.rb
@@ -65,6 +64,7 @@ files:
 - spec/rack
 - spec/rack/dispatch_spec.rb
 - spec/rails
+- spec/rails/compat.rb
 - spec/rails/generate_spec.rb
 - spec/rails/path_spec.rb
 - spec/rails/recognize_spec.rb