usher 0.4.8 → 0.5.1

data/lib/usher/util/parser.rb

@@ -0,0 +1,145 @@
+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 generate_route(unprocessed_path, conditions, requirements, default_values, generate_with)
+          match_partially = if unprocessed_path.is_a?(String)
+            unprocessed_path = parse(unprocessed_path, requirements, default_values)
+            if unprocessed_path[-1] == ?*
+              unprocessed_path.slice!(-1)
+              true
+            else
+              false
+            end
+          else
+            false
+          end
+          
+          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) && !router.delimiter_chars.include?(p[0])} || nil
+              when Usher::Route::Variable
+                part.look_ahead = path[index + 1, path.size].find{|p| router.delimiter_chars.include?(p[0])} || router.delimiters.first
+              end
+            end
+          end
+
+          Route.new(
+            paths,
+            router, 
+            conditions, 
+            requirements, 
+            default_values, 
+            generate_with,
+            match_partially
+          )
+          
+        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 = 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 ?*
+              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
+              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_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 << variable_class.new(variable_name, regex, requirements && requirements[variable_name])
+              else
+                current_group << regex
+              end
+            when ?(
+              new_group = Usher::Route::Util::Group.new(:any, current_group)
+              current_group << new_group
+              current_group = new_group
+            when ?)
+              current_group = current_group.parent.group_type == :one ? current_group.parent.parent : current_group.parent
+            when ?|
+              unless current_group.parent.group_type == :one
+                detached_group = current_group.parent.pop
+                new_group = Usher::Route::Util::Group.new(:one, detached_group.parent)
+                detached_group.parent = new_group
+                detached_group.group_type = :all
+                new_group << detached_group
+                new_group.parent << new_group
+              end
+              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?
+          parts
+        end
+
+        private
+        attr_reader :router
+
+      end
+      
+
+    end
+  end
+end

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/generate_spec.rb

@@ -4,138 +4,192 @@ require 'rack'
 describe "Usher URL generation" do
   
   before(:each) do
-    @route_set = Usher.new
+    @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new)
     @route_set.reset!
-    @url_generator = Usher::Generators::URL.new(@route_set)
   end
   
   it "should generate a simple URL" do
     @route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'action')
-    @url_generator.generate(:sample, {}).should == '/sample'
+    @route_set.generator.generate(:sample, {}).should == '/sample'
   end
   
   it "should generate a simple URL with a single variable" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action'}).should == '/sample/action'
+    @route_set.generator.generate(:sample, {:action => 'action'}).should == '/sample/action'
   end
   
   it "should generate a simple URL with a single variable (and escape)" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action time'}).should == '/sample/action%20time'
+    @route_set.generator.generate(:sample, {:action => 'action time'}).should == '/sample/action%20time'
   end
   
   it "should generate a simple URL with a single variable (thats not a string)" do
     @route_set.add_named_route(:sample, '/sample/:action/:id', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
+    @route_set.generator.generate(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
   end
   
   it "should generate a simple URL with a glob variable" do
     @route_set.add_named_route(:sample, '/sample/*action', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
+    @route_set.generator.generate(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
   end
   
   it "should generate a mutliple vairable URL from a hash" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
+    @route_set.generator.generate(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
   end
 
   it "should generate a mutliple vairable URL from an array" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
+    @route_set.generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
   end
 
   it "should generate append extra hash variables to the end" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => 'zanz'}).should == '/sample/maz/zoo?third=zanz'
+    @route_set.generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => 'zanz'}).should == '/sample/maz/zoo?third=zanz'
   end
 
   it "should generate append extra hash variables to the end (when the first parts are an array)" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    ['/sample/maz/zoo?four=jane&third=zanz', '/sample/maz/zoo?third=zanz&four=jane'].include?(@url_generator.generate(:sample, ['maz', 'zoo', {:third => 'zanz', :four => 'jane'}])).should == true
+    ['/sample/maz/zoo?four=jane&third=zanz', '/sample/maz/zoo?third=zanz&four=jane'].include?(@route_set.generator.generate(:sample, ['maz', 'zoo', {:third => 'zanz', :four => 'jane'}])).should == true
   end
 
   it "should generate append extra hash variables to the end using [] syntax if its an array" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => ['zanz', 'susie']}).should == '/sample/maz/zoo?third%5B%5D=zanz&third%5B%5D=susie'
+    @route_set.generator.generate(:sample, {:first => 'maz', :second => 'zoo', :third => ['zanz', 'susie']}).should == '/sample/maz/zoo?third%5B%5D=zanz&third%5B%5D=susie'
   end
 
   it "should generate a mutliple vairable URL from an array" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
-    @url_generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
+    @route_set.generator.generate(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
   end
 
   it "should generate a simple URL with a format" do
     @route_set.add_named_route(:sample, '/sample/:action.:format', :controller => 'sample')
-    @url_generator.generate(:sample, {:action => 'action', :format => 'html'}).should == '/sample/action.html'
+    @route_set.generator.generate(:sample, {:action => 'action', :format => 'html'}).should == '/sample/action.html'
   end
 
   it "should generate from parameters" do
     caf = @route_set.add_route('/:controller/:action.:format')
     ca = @route_set.add_route('/:controller/:action')
-    @url_generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
-    @url_generator.generate(nil, {:controller => 'controller', :action => 'action', :format => 'html'}).should == '/controller/action.html'
+    @route_set.generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(nil, {:controller => 'controller', :action => 'action', :format => 'html'}).should == '/controller/action.html'
   end
 
   it "should use the first route when generating a URL from two ambiguous routes" do
     @route_set.add_route('/:controller/:action')
     @route_set.add_route('/:action/:controller')
-    @url_generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(nil, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
   end
 
   it "should accept an array of parameters" do
     caf = @route_set.add_named_route(:name, '/:controller/:action.:format')
-    @url_generator.generate(:name, ['controller', 'action', 'html']).should == '/controller/action.html'
+    @route_set.generator.generate(:name, ['controller', 'action', 'html']).should == '/controller/action.html'
   end
 
   it "should generate a route with a specific host" do
     caf = @route_set.add_named_route(:name, '/:controller/:action.:format', :generate_with => {:host => 'www.slashdot.org', :port => 80})
-    @url_generator.generate_full(:name, Rack::Request.new(Rack::MockRequest.env_for("http://localhost:8080")), ['controller', 'action', 'html']).should == 'http://www.slashdot.org/controller/action.html'
+    @route_set.generator.generate_full(:name, Rack::Request.new(Rack::MockRequest.env_for("http://localhost:8080")), ['controller', 'action', 'html']).should == 'http://www.slashdot.org/controller/action.html'
   end
 
   it "should require all the parameters (hash) to generate a route" do
-    proc {@url_generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller'})}.should raise_error Usher::MissingParameterException
+    proc{@route_set.generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller'})}.should raise_error(Usher::MissingParameterException)
   end
 
   it "should generate from a route" do
-    @url_generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(@route_set.add_route('/:controller/:action'), {:controller => 'controller', :action => 'action'}).should == '/controller/action'
   end
 
   it "should require all the parameters (array) to generate a route" do
     @route_set.add_named_route(:name, '/:controller/:action.:format')
-    proc {@url_generator.generate(:name, ['controller', 'action'])}.should raise_error Usher::MissingParameterException
+    proc {@route_set.generator.generate(:name, ['controller', 'action'])}.should raise_error(Usher::MissingParameterException)
   end
 
   it "should generate a route when only one parameter is given" do
     @route_set.add_named_route(:name, '/:controller')
-    @url_generator.generate(:name, 'controller').should == '/controller'
+    @route_set.generator.generate(:name, 'controller').should == '/controller'
   end
 
   it "should generate the correct route from a route containing optional parts" do
     @route_set.add_named_route(:name, '/:controller(/:action(/:id))')
-    @url_generator.generate(:name, {:controller => 'controller'}).should == '/controller'
-    @url_generator.generate(:name, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
-    @url_generator.generate(:name, {:controller => 'controller', :action => 'action', :id => 'id'}).should == '/controller/action/id'
+    @route_set.generator.generate(:name, {:controller => 'controller'}).should == '/controller'
+    @route_set.generator.generate(:name, {:controller => 'controller', :action => 'action'}).should == '/controller/action'
+    @route_set.generator.generate(:name, {:controller => 'controller', :action => 'action', :id => 'id'}).should == '/controller/action/id'
   end
 
   it "should generate a route using defaults for everything but the first parameter" do
     @route_set.add_named_route(:name, '/:one/:two/:three', {:default_values => {:one => 'one', :two => 'two', :three => 'three'}})
-    @url_generator.generate(:name, {:one => "1"}).should == '/1/two/three'
+    @route_set.generator.generate(:name, {:one => "1"}).should == '/1/two/three'
   end
 
   it "should generate a route using defaults for everything" do
     @route_set.add_named_route(:name, '/:one/:two/:three', {:default_values => {:one => 'one', :two => 'two', :three => 'three'}})
-    @url_generator.generate(:name).should == '/one/two/three'
+    @route_set.generator.generate(:name).should == '/one/two/three'
   end
   
   it "should generate a route using defaults and optionals using the last parameter" do
     @route_set.add_named_route(:opts_with_defaults, '/:one(/:two(/:three))', {:default_values => {:one => '1', :two => '2', :three => '3'}})
-    @url_generator.generate(:opts_with_defaults, {:three => 'three'}).should == '/1/2/three'
+    @route_set.generator.generate(:opts_with_defaults, {:three => 'three'}).should == '/1/2/three'
   end
 
   it "should generate a route with optional segments given two nested optional parameters" do
     @route_set.add_named_route(:optionals, '/:controller(/:action(/:id))(.:format)')
-    @url_generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
+    @route_set.generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
+  end
+  
+  describe "nested generation" do
+    before do
+      @route_set2 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @route_set3 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @route_set4 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      
+      @route_set.add_named_route(:simple,   "/mount_point").match_partially!.to(@route_set2)
+      @route_set.add_route("/third/:foo", :default_values => {:foo => "foo"}).match_partially!.to(@route_set3)
+      @route_set.add_route("/fourth/:bar").match_partially!.to(@route_set4)
+      
+      @route_set2.add_named_route(:nested_simple,   "/nested/simple",     :controller => "nested",  :action => "simple")
+      @route_set2.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
+      
+      @route_set3.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
+      @route_set3.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
+      
+      @route_set4.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
+    end
+    
+    it "should generate a route for the simple nested route" do
+      @route_set2.generator.generate(:nested_simple).should == "/mount_point/nested/simple"
+    end
+    
+    it "should generate a simple route without optional segments" do
+      @route_set2.generator.generate(:nested_complex).should == "/mount_point/another_nested"
+    end
+    
+    it "should generate a route with optional segements" do
+      @route_set2.generator.generate(:nested_complex, :complex => "foo").should == "/mount_point/another_nested/foo"
+    end
+    
+    it "should genearte a route with the specified value for the parent route" do
+      @route_set3.generator.generate(:nested_simple, :foo => "bar").should == "/third/bar/nested/simple"
+    end
+    
+    it "should generate a route with the default value from the parent route" do
+      @route_set3.generator.generate(:nested_simple).should == "/third/foo/nested/simple"
+    end
+    
+    it "should generate a route with an optional segement in the parent and child" do
+      @route_set3.generator.generate(:nested_complex, :complex => "complex").should == "/third/foo/another_nested/complex"
+    end
+    
+    it "should generate a route without the optional value from the child" do
+      @route_set3.generator.generate(:nested_complex).should == "/third/foo/another_nested"
+    end
+    
+    it "should raise an exception when trying to generate a route where the parent variable is not defined and does not have a default value" do
+      lambda do
+        @route_set4.generator.generate(:nested_simple)
+      end.should raise_error(Usher::MissingParameterException)
+    end
+    
+    
+    
   end
-
-
 end

data/spec/private/grapher_spec.rb

@@ -4,31 +4,30 @@ require 'lib/usher'
 describe "Usher grapher" do
 
   before(:each) do
-    @route_set = Usher.new
+    @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new)
     @route_set.reset!
-    @url_generator = Usher::Generators::URL.new(@route_set)
   end
 
   it "should find a simple path" do
     @route_set.add_route('/:a/:b/:c')
-    @url_generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
+    @route_set.generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
   end
 
   it "should pick a more specific route" do
     @route_set.add_route('/:a/:b')
     @route_set.add_route('/:a/:b/:c')
-    @url_generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
+    @route_set.generator.generate(nil, {:a => 'A', :b => 'B', :c => 'C'}).should == '/A/B/C'
   end
 
   it "should fail to generate a route when none matches" do
     @route_set.add_route('/:a/:b')
-    proc {@url_generator.generate(nil, {:c => 'C', :d => 'D'}) }.should raise_error Usher::UnrecognizedException
+    proc {@route_set.generator.generate(nil, {:c => 'C', :d => 'D'}) }.should raise_error Usher::UnrecognizedException
   end
 
   it "should find the most specific route and append extra parts on as a query string" do
     @route_set.add_route('/:a/:b/:c')
     @route_set.add_route('/:a/:b')
-    @url_generator.generate(nil, {:a => 'A', :b => 'B', :d => 'C'}).should == '/A/B?d=C'
+    @route_set.generator.generate(nil, {:a => 'A', :b => 'B', :d => 'C'}).should == '/A/B?d=C'
   end
   
   # FIXME

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_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_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_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_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_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_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_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_and_expand('/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_and_expand('/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_and_expand('/test/this(/split(.:format))') == [
+      ['/', "test", '/', "this"],
+      ['/', "test", '/', "this", '/', "split"],
+      ['/', "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_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_and_expand('/:split/:split').first
+    parts[1].should == parts[3]
+  end
+  
+end