usher 0.4.8

data/lib/usher/splitter.rb

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

data/lib/usher.rb

@@ -0,0 +1,184 @@
+require File.join(File.dirname(__FILE__), 'usher', 'node')
+require File.join(File.dirname(__FILE__), 'usher', 'route')
+require File.join(File.dirname(__FILE__), 'usher', 'grapher')
+require File.join(File.dirname(__FILE__), 'usher', 'interface')
+require File.join(File.dirname(__FILE__), 'usher', 'splitter')
+require File.join(File.dirname(__FILE__), 'usher', 'exceptions')
+
+class Usher
+
+  autoload :Generators, File.join(File.dirname(__FILE__), 'usher', 'generate')
+
+  attr_reader :tree, :named_routes, :route_count, :routes, :splitter, :delimiters
+  
+  SymbolArraySorter = proc {|a,b| a.hash <=> b.hash} #:nodoc:
+  
+  # Returns whether the route set is empty
+  #   
+  #   set = Usher.new
+  #   set.empty? => true
+  #   set.add_route('/test')
+  #   set.empty? => false
+  def empty?
+    @route_count.zero?
+  end
+
+  # Resets the route set back to its initial state
+  #   
+  #   set = Usher.new
+  #   set.add_route('/test')
+  #   set.empty? => false
+  #   set.reset!
+  #   set.empty? => true
+  def reset!
+    @tree = Node.root(self, @request_methods, @globs_capture_separators)
+    @named_routes = {}
+    @routes = []
+    @route_count = 0
+    @grapher = Grapher.new
+  end
+  alias clear! reset!
+  
+  # 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
+  # valid character sequences within path.
+  # 
+  # <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) || ['/', '.']
+    @valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
+    @request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
+    @splitter = Splitter.for_delimiters(@delimiters, @valid_regex)
+    reset!
+  end
+
+  # Adds a route referencable by +name+. Sett add_route for format +path+ and +options+.
+  #   
+  #   set = Usher.new
+  #   set.add_named_route(:test_route, '/test')
+  def add_named_route(name, path, options = nil)
+    add_route(path, options).name(name)
+  end
+
+  # Attaches a +route+ to a +name+
+  #   
+  #   set = Usher.new
+  #   route = set.add_route('/test')
+  #   set.name(:test, route)
+  def name(name, route)
+    @named_routes[name] = route
+    route
+  end
+
+  # Creates a route from +path+ and +options+
+  #  
+  # === +path+
+  # 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. 
+  #
+  # <b>Example:</b>
+  # <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. 
+  #
+  # <b>Example:</b>
+  # <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.
+  #
+  # As well, variables can have a regex matcher.
+  #
+  # <b>Example:</b>
+  # <tt>/product/{:id,\d+}</tt> would match
+  # 
+  # * <tt>/product/123</tt>
+  # * <tt>/product/4521</tt>
+  # 
+  # But not
+  # * <tt>/product/AE-35</tt>
+  # 
+  # As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
+  # actually be bound to the variable
+  #
+  # ==== Static
+  #
+  # Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
+  # As well, static parts can have a regex pattern in them as well, such as <tt>/path/something.{html|xml}</tt> which would match only
+  # <tt>/path/something.html</tt> and <tt>/path/something.xml</tt>
+  #
+  # ==== Optional sections
+  #
+  # 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>.
+  #
+  # ==== One and only one sections
+  #
+  # 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>. Generally its more efficent to use one and only sections over using regex.
+  #
+  # === +options+
+  # * +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)
+    conditions = options && options.delete(:conditions) || nil
+    requirements = options && options.delete(:requirements) || nil
+    default_values = options && options.delete(:default_values) || nil
+    generate_with = options && options.delete(:generate_with) || nil
+    if options
+      options.delete_if do |k, v|
+        if v.is_a?(Regexp) || v.is_a?(Proc)
+          (requirements ||= {})[k] = v 
+          true
+        end
+      end
+    end
+    route = Route.new(path, self, conditions, requirements, default_values, generate_with)
+    route.to(options) if options && !options.empty?
+    
+    @tree.add(route)
+    @routes << route
+    @grapher.add_route(route)
+    @route_count += 1
+    route
+  end
+
+  # Recognizes a +request+ 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.
+  #   
+  #   Request = Struct.new(:path)
+  #   set = Usher.new
+  #   route = set.add_route('/test')
+  #   set.recognize(Request.new('/test')).path.route == route => true
+  def recognize(request, path = request.path)
+    @tree.find(self, request, @splitter.url_split(path))
+  end
+
+  # Recognizes a set of +parameters+ and gets the closest matching Usher::Route::Path or +nil+ if no route exists.
+  #   
+  #   set = Usher.new
+  #   route = set.add_route('/:controller/:action')
+  #   set.path_for_options({:controller => 'test', :action => 'action'}) == path.route => true
+  def path_for_options(options)
+    @grapher.find_matching_path(options)
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+if Rails::VERSION::MAJOR == 2 && Rails::VERSION::MINOR == 3
+  ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails2_3)"
+elsif Rails::VERSION::MAJOR == 2 && Rails::VERSION::MINOR >= 2
+  class Usher::Interface::Rails2_2Interface::Mapper
+    include ActionController::Resources
+  end
+  ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails2_2)"
+end

data/spec/private/email/recognize_spec.rb

@@ -0,0 +1,38 @@
+require 'lib/usher'
+
+
+
+def build_email_mock(email)
+  request = mock "Request"
+  request.should_receive(:email).any_number_of_times.and_return(email)
+  request
+end
+
+describe "Usher (for email) route recognition" do
+
+  before(:each) do
+    @route_set = Usher::Interface.for(:email)
+  end
+
+  it "should recognize a simple request" do
+    receiver = mock('receiver')
+    receiver.should_receive(:action).with({}).exactly(1)
+    @route_set.for('joshbuddy@gmail.com') { |params| receiver.action(params) }
+    @route_set.act('joshbuddy@gmail.com')
+  end
+
+  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.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.act('sub+ect.123-456-sdqwe123ae@mydomain.org')
+  end
+
+end

data/spec/private/generate_spec.rb

@@ -0,0 +1,141 @@
+require 'lib/usher'
+require 'rack'
+
+describe "Usher URL generation" do
+  
+  before(:each) do
+    @route_set = Usher.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'
+  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'
+  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'
+  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'
+  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'
+  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'
+  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'
+  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'
+  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
+  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'
+  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'
+  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'
+  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'
+  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'
+  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'
+  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'
+  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
+  end
+
+  it "should generate from a route" do
+    @url_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
+  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'
+  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'
+  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'
+  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'
+  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'
+  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'
+  end
+
+
+end

data/spec/private/grapher_spec.rb

@@ -0,0 +1,41 @@
+require 'lib/usher'
+
+
+describe "Usher grapher" do
+
+  before(:each) do
+    @route_set = Usher.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'
+  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'
+  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
+  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'
+  end
+  
+  # FIXME
+  #it "should do a validity check against the incoming variables when asked to" do
+  #  route_set.add_route('/:a/:b', :b => /\d+/)
+  #  route_set.generate_url(nil, {:a => 'A', :b => 'B'}).should == '/A/B'
+  #  proc{ route_set.generate_url(nil, {:a => 'A', :b => 'B'})}.should raise_error Usher::ValidationException
+  #end
+
+end

data/spec/private/path_spec.rb

@@ -0,0 +1,68 @@
+require 'lib/usher'
+
+route_set = Usher.new
+
+describe "Usher route adding" do
+
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "should be empty after a reset" do
+    route_set.add_route('/sample', :controller => 'sample')
+    route_set.empty?.should == false
+    route_set.reset!
+    route_set.empty?.should == true
+  end
+  
+  it "shouldn't care about routes without a controller" do
+    proc { route_set.add_route('/bad/route') }.should_not raise_error
+  end
+
+  it "should add every kind of optional route possible" 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", '/', "c", '/', "d", '/', "e"]
+    ]
+    
+  end
+
+  it "should allow named routes to be added" do
+    route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
+  end
+
+  it "should calculate depths for nodes" do
+    route_set.add_named_route(:route, '/bad/route/three/four')
+    route_set.tree.depth.should == 0
+    route_set.tree.lookup['/'].depth.should == 1
+  end
+
+  it "should pp for nodes" do
+    route_set.add_named_route(:route, '/bad/route/three/four')
+    route_set.tree.depth.should == 0
+    old_out = $stdout
+    $stdout = (output = StringIO.new)
+    route_set.tree.lookup['/'].lookup['bad'].lookup['/'].pp
+    $stdout = old_out
+    output.rewind
+    output.read.should == <<-HEREDOC
+   3: "/" false
+    route ==> 
+    4: "route" false
+     / ==> 
+     5: "/" false
+      three ==> 
+      6: "three" false
+       / ==> 
+       7: "/" false
+        four ==> 
+        8: "four" true
+    HEREDOC
+  end
+
+end

data/spec/private/rack/dispatch_spec.rb

@@ -0,0 +1,29 @@
+require 'lib/usher'
+
+require 'rack'
+
+route_set = Usher::Interface.for(:rack)
+
+describe "Usher (for rack) route dispatching" do
+
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "should dispatch a simple request" do
+    app = mock 'app'
+    app.should_receive(:call).once.with {|v| v['usher.params'].should == {} }
+    route_set.add('/sample').to(app)
+    route_set.call(Rack::MockRequest.env_for("/sample", :method => 'GET'))
+  end
+  
+  it "should dispatch a POST request" do
+    bad_app = mock 'bad_app'
+    app = mock 'app'
+    app.should_receive(:call).once.with {|v| v['usher.params'].should == {} }
+    route_set.add('/sample').to(bad_app)
+    route_set.add('/sample', :requirements => {:request_method => 'POST'}).to(app)
+    route_set.call(Rack::MockRequest.env_for("/sample", :request_method => 'POST'))
+  end
+  
+end

data/spec/private/rails2_2/compat.rb

@@ -0,0 +1 @@
+require 'activesupport'