usher 0.5.10 → 0.5.11

data/VERSION.yml

@@ -1,4 +1,5 @@
 --- 
-:patch: 10
+:build: 
+:patch: 11
 :major: 0
 :minor: 5

data/lib/usher.rb

@@ -5,10 +5,12 @@ 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')
+require File.join(File.dirname(__FILE__), 'usher', 'spinoffs', 'strscan_additions')
+require File.join(File.dirname(__FILE__), 'usher', 'delimiters')
 
 class Usher
   attr_reader :root, :named_routes, :routes, :splitter,
-              :delimiters, :delimiter_chars, :delimiters_regex,
+              :delimiters, :delimiters_regex,
               :parent_route, :generator, :grapher
 
   # Returns whether the route set is empty
@@ -50,9 +52,10 @@ 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)
-    self.generator = options && options.delete(:generator)
-    self.delimiters = options && options.delete(:delimiters) || ['/', '.']
-    self.valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
+    self.generator       = options && options.delete(:generator)
+    delimiters_array     = options && options.delete(:delimiters) || ['/', '.']
+    self.delimiters      = Delimiters.new(delimiters_array)
+    self.valid_regex     = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
     self.request_methods = options && options.delete(:request_methods)
     reset!
   end
@@ -258,14 +261,13 @@ class Usher
 
   def delimiters=(delimiters)
     @delimiters = delimiters
-    @delimiter_chars = @delimiters.collect{|d| d[0]}
     @delimiters_regex = @delimiters.collect{|d| Regexp.quote(d)} * '|'
     @delimiters
   end
 
   def valid_regex=(valid_regex)
     @valid_regex = valid_regex
-    @splitter = Splitter.for_delimiters(self, @valid_regex)
+    @splitter = Splitter.for_delimiters(self.delimiters)
     @valid_regex
   end
 

data/lib/usher/delimiters.rb

@@ -0,0 +1,22 @@
+class Delimiters < Array
+  # TODO: caching
+  
+  def unescaped
+    self.map do |delimiter|
+      (delimiter[0] == ?\\) ?
+              delimiter[1..-1] :
+              delimiter
+    end
+  end
+
+  def first_in(array)
+    # TODO: should we optimize this O(n*m)? hash or modified or KNP or at leaset sort + b-search. But they are so short
+
+    array.each do |element|
+      return element if self.unescaped.any? { |delimiter| delimiter == element }
+    end
+    nil    
+  end
+
+  # TODO: Delimiters#regex and so on  
+end

data/lib/usher/interface/rails2_3_interface.rb

@@ -71,16 +71,19 @@ class Usher
         "#{request.path_parameters[:controller].camelize}Controller".constantize
       end
       
-      def reset!
-        @router = Usher.new(:generator => Usher::Util::Generators::URL.new, :request_methods => [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains])
+      def reset!(options={})
+        options[:generator] = options[:generator] || Usher::Util::Generators::URL.new
+        options[:request_methods] = options[:request_methods] || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
+                
+        @router = Usher.new(options)
         @configuration_files = []
         @module ||= Module.new
         @controller_route_added = false
         @controller_action_route_added = false
       end
       
-      def draw
-        reset!
+      def draw(options={})
+        reset!(options)
         yield ActionController::Routing::RouteSet::Mapper.new(self)
         install_helpers
       end

data/lib/usher/node.rb

@@ -61,7 +61,7 @@ class Usher
     end
 
     def terminates?
-      @terminates
+      @terminates && @terminates.route.recognizable?
     end
 
     def pp
@@ -128,15 +128,15 @@ class Usher
         when Route::Variable::Glob
           params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
           while true
-            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)))
+            if (next_part.value.look_ahead === part || (!usher.delimiters.unescaped.include?(part) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
               path.unshift(part)
               position -= part.size
-              if usher.delimiter_chars.include?(next_part.parent.value[0])
+              if usher.delimiters.unescaped.include?(next_part.parent.value)
                 path.unshift(next_part.parent.value)
                 position -= next_part.parent.value.size
               end
               break
-            elsif !usher.delimiter_chars.include?(part[0])
+            elsif !usher.delimiters.unescaped.include?(part)
               next_part.value.valid!(part)
               params.last.last << part
             end
@@ -154,7 +154,7 @@ class Usher
             next_path_part = path.shift
             position += next_path_part.size
             params.last.last << next_path_part
-          end if var.look_ahead && usher.delimiter_chars.size > 1
+          end if var.look_ahead && usher.delimiters.size > 1
         end
         next_part.find(usher, request_object, original_path, path, params, position)
       elsif request_method_type

data/lib/usher/route.rb

@@ -5,16 +5,15 @@ require File.join(File.dirname(__FILE__), 'route', 'request_method')
 
 class Usher
   class Route
-    attr_reader   :paths, :requirements, :conditions,
-                  :destination, :named, :generate_with,
-                  :default_values, :match_partially
-    attr_accessor :parent_route, :router
+    attr_reader   :paths, :requirements, :conditions, :named, :generate_with, :default_values, :match_partially, :destination
+    attr_accessor :parent_route, :router, :recognizable
 
     GenerateWith = Struct.new(:scheme, :port, :host)
 
     def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)
-      @paths = parsed_paths.collect {|path| Path.new(self, path)}
       @router, @requirements, @conditions, @default_values, @match_partially = router, requirements, conditions, default_values, match_partially
+      @recognizable = true
+      @paths = parsed_paths.collect {|path| Path.new(self, path)}
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
     end
 
@@ -25,7 +24,21 @@ class Usher
       end
       @grapher
     end
+    
+    def unrecognizable!
+      self.recognizable = false
+      self
+    end
 
+    def recognizable!
+      self.recognizable = true
+      self
+    end
+
+    def recognizable?
+      self.recognizable
+    end
+    
     def dup
       result = super
       result.instance_eval do

data/lib/usher/spinoffs/strscan_additions.rb

@@ -0,0 +1,31 @@
+require 'strscan'
+
+#TODO: rewrite this in C and commit this addition back to community
+class StringScanner
+  #      scan_before(pattern)
+  #
+  #
+  # Scans the string until the +pattern+ is matched. As opposed to #scan_until,
+  # it does not include a matching pattern into a returning value and sets
+  # pointer just _before_ the pattern position.
+  # If there is no match, +nil+ is returned.
+  #
+  #  s = StringScanner.new("Fri Dec 12 1975 14:39")
+  #  s.scan_until(/1/)        # -> "Fri Dec "
+  #  s.scan(/1/)              # -> "1"
+  #  s.scan_until(/1/)        # -> nil
+  #
+  def scan_before(pattern)
+    return nil unless self.exist?(pattern)
+
+    pattern_size = self.matched_size
+    result = self.scan_until(pattern)
+
+    self.pos = self.pos - pattern_size
+    (result.length == pattern_size) ?
+      (result = '') :
+      (result = result[0..(result.length - pattern_size - 1)])    
+
+    result
+  end
+end

data/lib/usher/splitter.rb

@@ -1,22 +1,44 @@
-require 'strscan'
-
 class Usher
   class Splitter
-    
-    def self.for_delimiters(router, valid_regex)
-      SplitterInstance.new(Regexp.new("[#{router.delimiters.collect{|d| Regexp.quote(d)}.join}]|[^#{router.delimiters.collect{|d| Regexp.quote(d)}.join}]+"))
+
+    def self.for_delimiters(delimiters_array)
+      delimiters = Delimiters.new(delimiters_array)
+      delimiters_array.any?{|d| d.size > 1} ?
+        MultiCharacterSplitterInstance.new(delimiters) :
+        SingleCharacterSplitterInstance.new(delimiters)
     end
 
-    class SplitterInstance
+    class SingleCharacterSplitterInstance
     
-      def initialize(url_split_regex)
-        @url_split_regex = url_split_regex
+      def initialize(delimiters)
+        @url_split_regex = Regexp.new("[#{delimiters.collect{|d| Regexp.quote(d)}.join}]|[^#{delimiters.collect{|d| Regexp.quote(d)}.join}]+")
       end
       
       def url_split(path)
         path.scan(@url_split_regex)
       end
+      alias split url_split
     end
     
+    class MultiCharacterSplitterInstance
+    
+      def initialize(delimiters)
+        @delimiters = delimiters
+      end
+
+      def url_split(path)
+        split_path = path.split(delimiters_regexp)
+        split_path.reject!{|s| s.size.zero? }
+        split_path
+      end
+      alias split url_split
+
+      protected
+
+      def delimiters_regexp
+        Regexp.new("(#{@delimiters.unescaped.collect{|d| Regexp.quote(d)}.join('|')})")
+      end
+      
+    end    
   end
 end

data/lib/usher/util/generate.rb

@@ -59,7 +59,7 @@ class Usher
           generate_path(path_for_routing_lookup(routing_lookup, params), params)
         end
 
-        def generate_path(path, params = nil)
+        def generate_path(path, params = nil, generate_extra = true)
           params = Array(params) if params.is_a?(String)
           if params.is_a?(Array)
             given_size = params.size
@@ -69,7 +69,7 @@ class Usher
           end
 
           result = Rack::Utils.uri_escape(generate_path_for_base_params(path, params))
-          unless params.nil? || params.empty?
+          unless !generate_extra || params.nil? || params.empty?
             extra_params = generate_extra_params(params, result[??])
             result << extra_params
           end
@@ -117,6 +117,16 @@ class Usher
           end
         end
 
+        def generate_base_url(params = nil)
+          if usher.parent_route
+            usher.parent_route.router.generator.generate_path(usher.parent_route.paths.first, params, false)
+          elsif params && params.key?(:default)
+            params[:default].to_s
+          else
+            '/'
+          end
+        end
+
         def generate_start(path, request)
           result = (path.route.generate_with && path.route.generate_with.scheme || request.scheme).dup
           result << '://'

data/lib/usher/util/parser.rb

@@ -12,10 +12,10 @@ class Usher
       end
 
       class ParserInstance
-
         def initialize(router, split_regex)
           @router = router
           @split_regex = split_regex
+          @delimiters_regex = Regexp.new(router.delimiters_regex)
         end
 
         def generate_route(unprocessed_path, conditions, requirements, default_values, generate_with)
@@ -48,14 +48,14 @@ class Usher
                   part.look_ahead = nil
                   part.look_ahead_priority = true
                 else
-                  part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiter_chars.include?(p[0])} || nil
+                  part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiters.unescaped.include?(p)} || nil
                 end
               when Usher::Route::Variable
                 if part.look_ahead && !part.look_ahead_priority
                   part.look_ahead = nil
                   part.look_ahead_priority = true
                 else
-                  part.look_ahead = path[index + 1, path.size].find{|p| router.delimiter_chars.include?(p[0])} || router.delimiters.first
+                  part.look_ahead = router.delimiters.first_in(path[index + 1, path.size]) || router.delimiters.unescaped.first
                 end
               end
             end
@@ -73,17 +73,27 @@ class Usher
           
         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)
+          scanner = StringScanner.new(path)
+
           current_group = parts
-          while !ss.eos?
-            part = ss.scan(@split_regex)
+          part = nil
+          while !scanner.eos?
+            part ?
+              (part << scanner.scan(@split_regex)) :
+              (part = scanner.scan(@split_regex))
+
+            if scanner.match?(/\\/) and !scanner.match?(@delimiters_regex)
+              scanner.skip(/\\/)
+              part << scanner.getch
+              next
+            end
+
             case part[0]
             when ?*
               var_name = part[1, part.size - 1].to_sym
@@ -94,9 +104,9 @@ class Usher
             when ?{
               pattern = ''
               count = 1
-              variable = ss.scan(/[!:\*]([^,]+),/)
+              variable = scanner.scan(/[!:\*]([^,]+),/)
               until count.zero?
-                regex_part = ss.scan(/\{|\}|[^\{\}]+/)
+                regex_part = scanner.scan(/\{|\}|[^\{\}]+/)
                 case regex_part[0]
                 when ?{
                   count += 1
@@ -137,19 +147,20 @@ class Usher
               end
               current_group.parent << Usher::Route::Util::Group.new(:all, current_group.parent)
               current_group = current_group.parent.last
+            when ?\\
+              current_group << part[1..-1]
             else
               current_group << part
             end
+            part = nil
           end unless !path || path.empty?
           parts
         end
 
-        private
-        attr_reader :router
+      private
 
+        attr_reader :router
       end
-      
-
     end
   end
 end

data/lib/usher/util/rack-mixins.rb

@@ -8,7 +8,7 @@ unless Rack::Utils.respond_to?(:uri_escape)
       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
 

data/spec/private/delimiters_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+require 'usher'
+
+describe Delimiters do
+  describe "#unescaped" do
+    it "should unescape delimiters correctly" do
+      Delimiters.new(['/', '\)', '\\\\']).unescaped.should == ['/', ')', '\\']
+    end
+  end
+
+  describe "#first_in" do
+    describe "when there is a complex path with a lot of delimiters occurrences" do
+      before :each do
+        @delimiters = Delimiters.new ['@', '.', '/']
+        @paths = ['var', '.', 'var', '/', 'var', '@']
+      end
+
+      it "should find nearest delimiter correctly" do
+        @delimiters.first_in(@paths).should == '.'
+        @delimiters.first_in(@paths[2..-1]).should == '/'
+        @delimiters.first_in(@paths[4..-1]).should == '@'
+      end
+    end
+
+    describe "when there are delimiters with escaped charaters" do
+      before :each do
+        @delimiters = Delimiters.new ['\\(', '\\)']
+        @paths = ['var', '(', 'var', ')']
+      end
+
+      it "should find nearest delimiter in unescaped path" do
+        @delimiters.first_in(@paths).should == '('
+      end
+    end
+
+    describe "when there is no occurence of delimiters in path" do
+      before :each do
+        @delimiters = Delimiters.new ['-', '/']
+        @paths = ['e', '@', 'ma', '.', 'il']
+      end
+
+      it "should return nil" do
+        @delimiters.first_in(@paths).should be_nil
+      end
+    end
+    
+  end
+end

data/spec/private/generate_spec.rb

@@ -189,6 +189,33 @@ describe "Usher URL generation" do
         @route_set4.generator.generate(:nested_simple)
       end.should raise_error(Usher::MissingParameterException)
     end
+
+    describe "generate_base_url" do
+      it "should generate a base url for a non nested router" do
+        @route_set.generator.generate_base_url.should == "/"
+      end
+
+      it "should generate a base url for a nested router" do
+        @route_set2.generator.generate_base_url.should == "/mount_point"
+      end
+
+      it "should generate a base url with parameters" do
+        @route_set4.generator.generate_base_url(:bar => "the_bar").should == "/fourth/the_bar"
+      end
+
+      it "should generate a base url with a default route" do
+        @route_set.generator.generate_base_url(:default => "/foo").should == "/foo"
+      end
+
+      it "should generate a base url with a default that is not a /" do
+        @route_set.generator.generate_base_url(:default => ":").should == ":"
+      end
+
+      it "should generate a base url with a default of a blank string" do
+        @route_set.generator.generate_base_url(:default => "").should == ""
+        @route_set.generator.generate_base_url(:default => nil).should == ""
+      end
+    end
   end
 
   describe "dupped generation" do

data/spec/private/parser_spec.rb

@@ -23,6 +23,10 @@ describe "Usher route tokenizing" do
   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 correctly handle multichar delimiters as well" do
+    Usher.new(:delimiters => ['%28', '%29'], :valid_regex => '[0-9A-Za-z\$\-_\+!\*\',]+').parser.parse_and_expand('cheese%28parmesan%29').should == [['cheese', '%28', 'parmesan', '%29']]    
+  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 == [
@@ -73,4 +77,27 @@ describe "Usher route tokenizing" do
     parts[1].should == parts[3]
   end
   
-end
+  it "should let me escape reserved characters" do
+    Usher.new.parser.parse_and_expand('/my\/thing/is\*lovingyou').should == [["/", "my/thing", "/", "is*lovingyou"]]
+  end
+
+  it "should let me use escaped characters as delimiters" do
+    Usher.new(:delimiters => ['/', '\(', '\)']).parser.parse_and_expand('/cheese\(:kind\)').should == [['/', 'cheese', '(', Usher::Route::Variable::Single.new(:kind), ')']]
+  end
+
+  describe "#generate_route" do
+    describe "when delimiters contain escaped characters" do
+      before :each do
+        @parser = Usher.new(:delimiters => ['/', '\(', '\)']).parser
+      end
+
+      it "should correctly generate route with a variable" do
+        route = @parser.generate_route('/cheese\(:kind\)', nil, nil, nil, nil)        
+        variable = route.paths[0].parts[3]
+        
+        variable.should be_kind_of(Usher::Route::Variable::Single)        
+        variable.look_ahead.should == ')'
+      end
+    end
+  end
+end

data/spec/private/recognize_spec.rb

@@ -17,6 +17,11 @@ describe "Usher route recognition" do
 
   describe 'request conditions' do
 
+    it "should ignore an unrecognized route" do
+      target_route = @route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http'}).unrecognizable!
+      @route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http'})).should be_nil
+    end
+
     it "should recognize a specific domain name" do
       target_route = @route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http'})
       @route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https'})
@@ -79,6 +84,35 @@ describe "Usher route recognition" do
     @route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple'})).params.should == [[:format, ['html', 'json', 'apple']]]
   end
 
+  it "should recognize variables between multi-char delimiters" do
+    @route_set = Usher.new(:delimiters => ['%28', '%29', '/', '.'])
+    target_route = @route_set.add_route('/cheese%28:kind%29', :controller => 'sample', :action => 'action')
+
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/cheese%28parmesan%29'}))
+    response.path.route.should == target_route
+    response.params.should == [[:kind , 'parmesan']]
+  end
+
+  it "should recognize route with escaped characters as delimiters" do
+    @route_set = Usher.new(:delimiters => ['/', '.', '\\(', '\\)'])
+
+    target_route = @route_set.add_route('/cheese\\(:kind\\)', :controller => 'sample', :action => 'action')
+
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/cheese(parmesan)'}))
+    response.should_not be_nil
+    response.path.route.should == target_route
+    response.params.should == [[:kind , 'parmesan']]
+  end
+
+  it "should recognize route with consecutive delimiters" do
+    @route_set = Usher.new(:delimiters => ['!', '/'])
+    target_route = @route_set.add_route('/cheese/!:kind', :controller => 'sample', :action => 'action')
+
+    response = @route_set.recognize(build_request({:method => 'get', :path => '/cheese/!parmesan'}))
+    response.path.route.should == target_route
+    response.params.should == [[:kind , 'parmesan']]
+  end
+
   it "should recgonize only a glob-style variable" do
     target_route = @route_set.add_route('/*format')
     response = @route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple'}))
@@ -94,10 +128,10 @@ describe "Usher route recognition" do
   end
 
   it "should recgonize a two identical regex static parts distinguished by request methods" do
-    get_route = @route_set.add_route('/{:val,test}', :conditions => {:method => 'get'})
-    post_route = @route_set.add_route('/{:val,test}', :conditions => {:method => 'post'})
-    @route_set.recognize(build_request({:method => 'get', :path => '/test'})).path.route.should == get_route
-    @route_set.recognize(build_request({:method => 'post', :path => '/test'})).path.route.should == post_route
+    get_route = @route_set.add_route('/test1/{:val,test}', :conditions => {:method => 'get'})
+    post_route = @route_set.add_route('/test1/{:val,test}', :conditions => {:method => 'post'})
+    @route_set.recognize(build_request({:method => 'get', :path => '/test1/test'})).path.route.should == get_route
+    @route_set.recognize(build_request({:method => 'post', :path => '/test1/test'})).path.route.should == post_route
   end
 
   it "shouldn't accept a nil variable" do

data/spec/private/splitter_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+require "usher"
+
+describe Usher::Splitter, "#split" do
+  describe "when there are single-character delimiters" do
+    it "should split correctly" do
+      Usher::Splitter.for_delimiters(['.', '/']).split('/one/two.three/').should == ['/', 'one', '/', 'two', '.', 'three', '/']
+    end
+  end
+
+  describe "when there are multi-character delimiters" do
+    it "should split correctly" do
+      Usher::Splitter.for_delimiters(['/', '%28', '%29']).split('/one%28two%29three/').should == ['/', 'one', '%28', 'two', '%29', 'three', '/']
+    end
+  end
+
+  describe "when there is no delimiter in the end" do
+    it "should split correctly" do
+      Usher::Splitter.for_delimiters(['.', '/']).split('/one/two.three').should == ['/', 'one', '/', 'two', '.', 'three']
+    end
+  end
+
+  describe "when there is no delimiter in the beginning" do
+    it "should split correctly" do
+      Usher::Splitter.for_delimiters(['.', '/']).split('one/two.three/').should == ['one', '/', 'two', '.', 'three', '/']
+    end
+  end
+
+  describe "when delimiters are consecutive" do
+    it "should split correctly" do
+      Usher::Splitter.for_delimiters(['/', '!']).split('/cheese/!parmesan').should == ['/', 'cheese', '/', '!', 'parmesan']
+    end
+  end
+
+  describe "when delimiters contain escaped characters" do
+    it "should split correctly" do
+      Usher::Splitter.for_delimiters(['/', '\(', '\)']).split('/cheese(parmesan)').should == ['/', 'cheese', '(', 'parmesan', ')']
+    end
+  end
+end

data/spec/private/string_scanner_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+require "usher"
+
+describe StringScanner do
+  describe "#scan_before" do
+    before :each do
+      @scanner = StringScanner.new("/one/two..three")
+    end
+
+    describe "when there is a match" do
+      it "should return subsequent string without matching pattern in the end" do
+        @scanner.scan_before(/\.\./).should == "/one/two"
+      end
+
+      it "should set pointer right before the matching pattern" do
+        @scanner.scan_before(/\.\./)
+        @scanner.scan(/\.\./).should == '..'
+      end
+
+      describe "when matching pattern is right at the position" do
+        it "should return empty string" do
+          @scanner.scan_before(/\//).should == ''
+        end
+      end
+    end
+
+    describe "when there is no match" do
+      it "should return nil" do
+        @scanner.scan_before(/bla-bla-bla/).should == nil
+      end
+
+      it "should not move the pointer" do
+        @scanner.scan_before(/bla-bla-bla/)
+        @scanner.pos.should == 0
+      end
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.5.10
+  version: 0.5.11
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-11 00:00:00 -04:00
+date: 2009-11-20 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,6 +37,7 @@ files:
 - Rakefile
 - VERSION.yml
 - lib/usher.rb
+- lib/usher/delimiters.rb
 - lib/usher/exceptions.rb
 - lib/usher/grapher.rb
 - lib/usher/interface.rb
@@ -56,6 +57,7 @@ files:
 - lib/usher/route/request_method.rb
 - lib/usher/route/util.rb
 - lib/usher/route/variable.rb
+- lib/usher/spinoffs/strscan_additions.rb
 - lib/usher/splitter.rb
 - lib/usher/util.rb
 - lib/usher/util/generate.rb
@@ -63,6 +65,7 @@ files:
 - lib/usher/util/parser.rb
 - lib/usher/util/rack-mixins.rb
 - rails/init.rb
+- spec/private/delimiters_spec.rb
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
@@ -80,6 +83,8 @@ files:
 - spec/private/rails2_3/recognize_spec.rb
 - spec/private/recognize_spec.rb
 - spec/private/request_method_spec.rb
+- spec/private/splitter_spec.rb
+- spec/private/string_scanner_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
@@ -111,6 +116,7 @@ signing_key:
 specification_version: 3
 summary: A general purpose routing library
 test_files: 
+- spec/private/delimiters_spec.rb
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
@@ -128,4 +134,6 @@ test_files:
 - spec/private/rails2_3/recognize_spec.rb
 - spec/private/recognize_spec.rb
 - spec/private/request_method_spec.rb
+- spec/private/splitter_spec.rb
+- spec/private/string_scanner_spec.rb
 - spec/spec_helper.rb