joshbuddy-usher 0.2.0 → 0.2.1

data/README.rdoc

@@ -1,8 +1,16 @@
 = Usher 
 
-Tree-based router for Ruby on Rails.
+Tree-based router library. Useful for (specifically) for Rails and Rack, but probably generally useful for anyone interested in doing routing. Based on Ilya Grigorik suggestion, turns out looking up in a hash and following a tree is faster than Krauter's massive regex approach.
 
-This is a tree-based router (based on Ilya Grigorik suggestion). Turns out looking up in a hash and following a tree is faster than Krauter's massive regex approach, so why not? I said, Heck Yes, and here we are.
+== Features
+
+* Understands single and path-globbing variables
+* Arbitrary HTTP header requirements
+* No optimization phase, so routes are always alterable after the fact
+* Understands Proc and Regex transformations, validations
+* Really, really fast
+* Relatively light and happy code-base, should be easy and fun to alter
+* Interface and implementation are separate, encouraging cross-pollination
 
 == Route format
 
@@ -87,15 +95,13 @@ From the rdoc:
 
 * add support for () optional parts
 * Add support for arbitrary HTTP header checks
+* Emit exceptions inline with relevant interfaces
+* More RDoc! (optionally cowbell)
 
 == TODO
 
 * Make it integrate with merb
 * Make it integrate with rails3
 * Create decent DSL for use with rack
-* Emit exceptions inline with relevant interfaces
-* More RDoc! (optionally cowbell)
-
-Looks about 20-50% faster than the router Rails ships with for non-trivial cases.
 
 (Let me show you to your request)

data/VERSION.yml

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

data/lib/usher/exceptions.rb

@@ -1,5 +1,7 @@
 class Usher
   class UnrecognizedException < RuntimeError; end
-  class ValidationException < RuntimeError; end
+  class ValidationException < RuntimeError
+    
+  end
   class MissingParameterException < RuntimeError; end
 end

data/lib/usher/grapher.rb

@@ -1,8 +1,5 @@
-require 'singleton'
-
 class Usher
   class Grapher
-    include Singleton
 
     def initialize
       reset!

data/lib/usher/interface/rack_interface.rb

@@ -21,9 +21,9 @@ class Usher
       end
 
       def call(env)
-        (path, params) = @routes.recognize(Request.new(env['REQUEST_URI'], env['REQUEST_METHOD']))
-        env['usher.params'] = params.inject({}){|h,(k,v)| h[k]=v; h }
-        path.route.params.call(env)
+        response = @routes.recognize(Request.new(env['REQUEST_URI'], env['REQUEST_METHOD']))
+        env['usher.params'] = response.params.inject({}){|h,(k,v)| h[k]=v; h }
+        response.path.route.params.call(env)
       end
 
     end

data/lib/usher/interface/rails2_interface.rb

@@ -43,9 +43,9 @@ class Usher
       end
       
       def recognize(request)
-        (path, params_list) = @usher.recognize(request)
-        params = params_list.inject({}){|h,(k,v)| h[k]=v; h }
-        request.path_parameters = (params_list.empty? ? path.route.params : path.route.params.merge(params)).with_indifferent_access
+        node = @usher.recognize(request)
+        params = node.params.inject({}){|h,(k,v)| h[k]=v; h }
+        request.path_parameters = (node.params.empty? ? node.path.route.params : node.path.route.params.merge(params)).with_indifferent_access
         "#{request.path_parameters[:controller].camelize}Controller".constantize
       rescue
         raise ActionController::RoutingError, "No route matches #{request.path.inspect} with #{request.inspect}"

data/lib/usher/node.rb

@@ -7,6 +7,7 @@ class Usher
   class Node
     
     ConditionalTypes = [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method]
+    Response = Struct.new(:path, :params)
     
     attr_reader :lookup
     attr_accessor :terminates, :exclusive_type, :parent, :value
@@ -70,14 +71,14 @@ class Usher
       route.paths.each do |path|
         parts = path.parts.dup
         ConditionalTypes.each do |type|
-          parts.push(Route::Http.new(type, route.conditions[type])) if route.conditions[type]
+          parts.push(Route::RequestMethod.new(type, route.conditions[type])) if route.conditions[type]
         end
         
         current_node = self
         until parts.size.zero?
           key = parts.shift
           target_node = case key
-          when Route::Http
+          when Route::RequestMethod
             if current_node.exclusive_type == key.type
               current_node.lookup[key.value] ||= Node.new(current_node, key)
             elsif current_node.lookup.empty?
@@ -85,12 +86,12 @@ class Usher
               current_node.lookup[key.value] ||= Node.new(current_node, key)
             else
               parts.unshift(key)
-              current_node.lookup[nil] ||= Node.new(current_node, Route::Http.new(current_node.exclusive_type, nil))
+              current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
             end
           else
             if current_node.exclusive_type
               parts.unshift(key)
-              current_node.lookup[nil] ||= Node.new(current_node, Route::Http.new(current_node.exclusive_type, nil))
+              current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
             else
               current_node.lookup[key.is_a?(Route::Variable) ? nil : key] ||= Node.new(current_node, key)
             end
@@ -113,7 +114,7 @@ class Usher
         end
       elsif path.size.zero? && !part
         if terminates?
-          [terminates, params]
+          Response.new(terminates, params)
         else
           nil
         end
@@ -121,13 +122,8 @@ class Usher
         next_part.find(request, path, params)
       elsif next_part = @lookup[nil]
         if next_part.value.is_a?(Route::Variable)
-          case t = next_part.value.transformer
-          when Proc
-            part = t.call(part)
-          when Symbol
-            part = part.send(t)
-          end
-          raise ValidationException.new("#{part} does not conform to #{next_part.value.validator}") if next_part.value.validator && (not next_part.value.validator === part)
+          part = next_part.value.transform!(part)
+          next_part.value.valid!(part)
           case next_part.value.type
           when :*
             params << [next_part.value.name, []]

data/lib/usher/route/path.rb

@@ -1,9 +1,11 @@
+require 'set'
+
 class Usher
   class Route
     class Path
   
       attr_reader :dynamic_parts, :dynamic_map, :dynamic_indicies, :route, :dynamic_set, :parts
-  
+      
       def initialize(route, parts)
         @route = route
         @parts = parts

data/lib/usher/route/{http.rb → request_method.rb}

@@ -1,6 +1,6 @@
 class Usher
   class Route
-    class Http
+    class RequestMethod
   
       attr_reader :type, :value
   

data/lib/usher/route/splitter.rb

@@ -1,9 +1,11 @@
+require 'strscan'
+
 class Usher
   class Route
     class Splitter
       
-      ScanRegex = /((:|\*||\.:|\.)[0-9a-z_]+|\/|\(|\)|\|)/
-      UrlScanRegex = /\/|\.?\w+/
+      ScanRegex = /((:|\*||\.:|\.)[0-9A-Za-z\$\-_\+!\*',]+|\/|\(|\)|\|)/
+      UrlScanRegex = /\/|\.?[0-9A-Za-z\$\-_\+!\*',]+/
       
       attr_reader :paths
       

data/lib/usher/route/variable.rb

@@ -13,6 +13,30 @@ class Usher
       def to_s
         "#{type}#{name}"
       end
+      
+      def transform!(val)
+        return val unless @transformer
+
+        case @transformer
+        when Proc
+          @transformer.call(val)
+        when Symbol
+          val.send(@transformer)
+        end
+      rescue Exception => e
+        raise ValidationException.new("#{val} could not be successfully transformed by #{@transformer}, root cause #{e.inspect}")
+      end
+
+      def valid!(val)
+        case @validator
+        when Proc
+          @validator.call(val)
+        else
+          @validator === val or raise
+        end if @validator
+      rescue Exception => e
+        raise ValidationException.new(e, "#{val} does not conform to #{@validator}")
+      end
   
       def ==(o)
         o && (o.type == @type && o.name == @name && o.validator == @validator)

data/lib/usher/route.rb

@@ -3,7 +3,7 @@ $:.unshift File.dirname(__FILE__)
 require 'route/path'
 require 'route/splitter'
 require 'route/variable'
-require 'route/http'
+require 'route/request_method'
 
 class Usher
   class Route
@@ -18,7 +18,15 @@ class Usher
       @paths = Splitter.new(@original_path, @requirements, @transformers).paths.collect {|path| Path.new(self, path)}
       @primary_path = @paths.first
     end
-
+    
+    
+    # Sets +options+ on a route
+    #   
+    #   Request = Struct.new(:path)
+    #   set = Usher.new
+    #   route = set.add_route('/test')
+    #   route.to(:controller => 'testing', :action => 'index')
+    #   set.recognize(Request.new('/test')).first.params => {:controller => 'testing', :action => 'index'}
     def to(options)
       @params = options
       self

data/lib/usher.rb

@@ -33,7 +33,7 @@ class Usher
     @named_routes = {}
     @routes = []
     @route_count = 0
-    Grapher.instance.reset!
+    @grapher = Grapher.new
   end
   alias clear! reset!
   
@@ -120,16 +120,17 @@ class Usher
     
     @tree.add(route)
     @routes << route
-    Grapher.instance.add_route(route)
+    @grapher.add_route(route)
     @route_count += 1
     route
   end
 
-  # Recognizes a +request+ and returns +nil+ or an Usher::Route::Path
+  # 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.name(:test, route)
+  #   set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request)
     @tree.find(request)
   end
@@ -140,7 +141,7 @@ class Usher
   #   route = set.add_route('/:controller/:action')
   #   set.route_for_options({:controller => 'test', :action => 'action'}) == path.route => true
   def route_for_options(options)
-    Grapher.instance.find_matching_path(options)
+    @grapher.find_matching_path(options)
   end
   
   # Generates a completed URL based on a +route+ or set of +params+
@@ -156,6 +157,8 @@ class Usher
       @named_routes[route]
     when nil
       route_for_options(params)
+    when Route
+      route.paths.first
     else
       route
     end
@@ -188,7 +191,7 @@ class Usher
         generated_path << '/' << p.to_s
       end
     end
-    unless params_hash.blank?
+    unless params_hash.empty?
       has_query = generated_path[??]
       params_hash.each do |k,v|
         case v

data/spec/recognize_spec.rb

@@ -32,17 +32,17 @@ describe "Usher route recognition" do
   
   it "should recognize a format-style variable" do
     target_route = route_set.add_route('/sample.:format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == [target_route.paths.first, [[:format , 'html']]]
+    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:format , 'html']])
   end
   
   it "should recognize a format-style literal" do
     target_route = route_set.add_route(':action.html', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == [target_route.paths.first, [[:action , 'sample']]]
+    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample']])
   end
   
   it "should recognize a format-style variable along side another variable" do
     target_route = route_set.add_route(':action.:format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == [target_route.paths.first, [[:action , 'sample'], [:format, 'html']]]
+    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample'], [:format, 'html']])
   end
   
   it "should recognize a specific route when several http-style restrictions are used" do
@@ -65,12 +65,17 @@ describe "Usher route recognition" do
   
   it "should use a transformer (proc) on incoming variables" do
     route_set.add_route('/:controller/:action/:id', :transformers => {:id => proc{|v| v.to_i}})
-    route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'})).last.rassoc(123).first.should == :id
+    route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'})).params.rassoc(123).first.should == :id
+  end
+
+  it "shouldn't care about mildly weird characters in the URL" do
+    route = route_set.add_route('/!asd,qwe/hjk$qwe/:id')
+    route_set.recognize(build_request({:method => 'get', :path => '/!asd,qwe/hjk$qwe/09AZaz$-_+!*\'', :domain => 'admin.host.com'})).params.rassoc('09AZaz$-_+!*\'').first.should == :id
   end
   
   it "should use a transformer (symbol) on incoming variables" do
     route_set.add_route('/:controller/:action/:id', :transformers => {:id => :to_i})
-    route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'})).last.rassoc(123).first.should == :id
+    route_set.recognize(build_request({:method => 'get', :path => '/products/show/123asd', :domain => 'admin.host.com'})).params.rassoc(123).first.should == :id
   end
   
   it "should should raise if malformed variables are used" do
@@ -78,4 +83,9 @@ describe "Usher route recognition" do
     proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error
   end
   
+  it "should should raise if transformer proc raises (anything)" do
+    route_set.add_route('/products/show/:id', :transformers => {:id => proc{|v| Integer(v)}})
+    proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error(Usher::ValidationException)
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-31 00:00:00 -07:00
+date: 2009-04-02 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,12 +49,10 @@ files:
 - lib/usher/interface/rails2_interface/mapper.rb
 - lib/usher/interface/rails2_interface.rb
 - lib/usher/interface.rb
-- lib/usher/node
-- lib/usher/node/lookup.rb
 - lib/usher/node.rb
 - lib/usher/route
-- lib/usher/route/http.rb
 - lib/usher/route/path.rb
+- lib/usher/route/request_method.rb
 - lib/usher/route/splitter.rb
 - lib/usher/route/variable.rb
 - lib/usher/route.rb

data/lib/usher/node/lookup.rb

@@ -1,78 +0,0 @@
-class Usher
-  class Node
-    class Lookup
-      
-      def initialize
-        @hash = {}
-        @regexes = []
-        @hash_reverse = {}
-        @regexes_reverse = {}
-      end
-      
-      def empty?
-        @hash.empty? && @regexes.empty?
-      end
-      
-      def keys
-        @hash.keys + @regexes.collect{|r| r.first}
-      end
-      
-      def values
-        @hash.values + @regexes.collect{|r| r.last}
-      end
-      
-      def each
-        @hash.each{|k,v| yield k,v }
-        @regexes.each{|v| yield v.first, v.last }
-      end
-      
-      def delete_value(value)
-        @hash.delete(@hash_reverse[value]) || ((rr = @regexes_reverse[value]) && @regexes.delete_at(rr[0]))
-      end
-      
-      def []=(key, value)
-        case key
-        when Regexp
-          @regexes << [key, value]
-          @regex_test = nil
-          @regexes_reverse[value] = [@regexes.size - 1, key, value]
-        else
-          @hash[key] = value
-          @hash_reverse[value] = key
-        end
-      end
-      
-      def replace(src, dest)
-        if @hash_reverse.key?(src)
-          key = @hash_reverse[src]
-          @hash[key] = dest
-          @hash_reverse.delete(src)
-          @hash_reverse[dest] = key
-        elsif @regexes_reverse.key?(src)
-          key = @regexes_reverse[src]
-          @regexes[rkey[0]] = [rkey[1], dest]
-          @regexes_reverse.delete(src)
-          @regexes_reverse[dest] = [rkey[0], rkey[1], dest]
-        end
-      end
-      
-      def [](key)
-        @hash[key] || regex_lookup(key)
-      end
-      
-      private
-      def regex_test
-        @regex_test ||= Regexp.union(*@regexes.collect{|r| r[0]})
-      end
-      
-      def regex_lookup(key)
-        if !@regexes.empty? && key.is_a?(String) && data = regex_test.match(key)
-          (data_array = data.to_a).each_index do |i|
-            break @regexes[i].last if data_array.at(i)
-          end
-        end
-      end
-      
-    end
-  end
-end