joshbuddy-usher 0.3.0 → 0.3.2

data/Rakefile

@@ -9,7 +9,7 @@ begin
     s.homepage = "http://github.com/joshbuddy/usher"
     s.authors = ["Joshua Hull"]
     s.files = FileList["[A-Z]*", "{lib,spec,rails}/**/*"]
-    s.add_dependency 'joshbuddy-fuzzy_hash'    
+    s.add_dependency 'joshbuddy-fuzzy_hash', '>=0.0.2'
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION.yml

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

data/lib/usher.rb

@@ -30,7 +30,7 @@ class Usher
   #   set.reset!
   #   set.empty? => true
   def reset!
-    @tree = Node.root(self)
+    @tree = Node.root(self, @request_methods)
     @named_routes = {}
     @routes = []
     @route_count = 0
@@ -38,9 +38,16 @@ class Usher
   end
   alias clear! reset!
   
-  # Creates a route set
-  def initialize(delimiter = '/')
-    @splitter = Splitter.delimiter(delimiter)
+  # Creates a route set, with optional Array of +delimiters+ and +request_methods+
+  # 
+  # The +delimiters+ must be one character. By default <tt>['/', '.']</tt> are used.
+  # The +request_methods+ are methods that are called against the request object in order to
+  # enforce the +conditions+ segment of the routes. For HTTP routes (and in fact the default), those 
+  # methods are <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method]</tt>.
+  def initialize(delimiters = ['/', '.'], request_methods = [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method])
+    @delimiters = delimiters
+    @splitter = Splitter.for_delimiters(delimiters)
+    @request_methods = request_methods
     reset!
   end
 
@@ -103,7 +110,7 @@ class Usher
   # === +options+
   # * +transformers+ - Transforms a variable before it gets to the requirements. Takes either a +proc+ or a +symbol+. If its a +symbol+, calls the method on the incoming parameter. If its a +proc+, its called with the variable.
   # * +requirements+ - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
-  # * +conditions+ - Accepts any of the following <tt>:protocol</tt>, <tt>:domain</tt>, <tt>:port</tt>, <tt>:query_string</tt>, <tt>:remote_ip</tt>, <tt>:user_agent</tt>, <tt>:referer</tt> and <tt>:method</tt>. This can be either a <tt>string</tt> or a regular expression.
+  # * +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 = {})
     transformers = options.delete(:transformers) || {}
@@ -116,7 +123,8 @@ class Usher
       end
     end
     
-    route = Route.new(path, self, {:transformers => transformers, :conditions => conditions, :requirements => requirements}).to(options)
+    route = Route.new(path, self, {:transformers => transformers, :conditions => conditions, :requirements => requirements})
+    route.to(options) unless options.empty?
     
     @tree.add(route)
     @routes << route
@@ -131,8 +139,8 @@ class Usher
   #   set = Usher.new
   #   route = set.add_route('/test')
   #   set.recognize(Request.new('/test')).path.route == route => true
-  def recognize(request)
-    @tree.find(request, @splitter.url_split(request.path))
+  def recognize(request, path = request.path)
+    @tree.find(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.
@@ -153,6 +161,7 @@ class Usher
   #   set.generate_url(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
   def generate_url(route, params = {}, options = {})
     check_variables = options.key?(:check_variables) ? options.delete(:check_variables) : false
+    delimiter = options.key?(:delimiter) ? options.delete(:delimiter) : @delimiters.first
 
     path = case route
     when Symbol
@@ -184,16 +193,13 @@ class Usher
         case p.type
         when :*
           param_list.first.each {|dp| p.valid!(dp.to_s) } if check_variables
-          generated_path << '/' << param_list.shift.collect{|dp| dp.to_s} * '/'
-        when :'.:'
-          p.valid!(param_list.first.to_s) if check_variables
-          (dp = param_list.shift) && generated_path << '.' << dp.to_s
+          generated_path << param_list.shift.collect{|dp| dp.to_s} * delimiter
         else
           p.valid!(param_list.first.to_s) if check_variables
-          (dp = param_list.shift) && generated_path << '/' << dp.to_s
+          (dp = param_list.shift) && generated_path << dp.to_s
         end
       else
-        generated_path << '/' << p.to_s
+        generated_path << p.to_s
       end
     end
     unless params_hash.empty?

data/lib/usher/interface/rack_interface.rb

@@ -23,7 +23,7 @@ class Usher
       def 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)
+        response.path.route.params.first.call(env)
       end
 
     end

data/lib/usher/interface/rails2_interface.rb

@@ -34,18 +34,19 @@ class Usher
           add_route('/:controller', options.merge({:action => 'index'}))
           @controller_route_added = true 
         end
-
-        options[:action] = 'index' unless options[:action]
         
+        options[:action] = 'index' unless options[:action]
+
+        path[0, 0] = '/' unless path[0] == ?/
         route = @usher.add_route(path, options)
-        raise "your route must include a controller" unless route.primary_path.dynamic_set.include?(:controller) || route.params.include?(:controller)
+        raise "your route must include a controller" unless route.primary_path.dynamic_set.include?(:controller) || route.params.first.include?(:controller)
         route
       end
       
       def recognize(request)
         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 = (node.params.empty? ? node.path.route.params.first : node.path.route.params.first.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}"
@@ -70,14 +71,16 @@ class Usher
           merged_options = options
           merged_options[:controller] = recall[:controller] unless options.key?(:controller)
           unless options.key?(:action)
-            options[:action] = nil
+            options[:action] = ''
           end
           route_for_options(merged_options)
         end
         case method
         when :generate
           merged_options ||= recall.merge(options)
-          generate_url(route, merged_options)
+          url = generate_url(route, merged_options)
+          url.slice!(-1) if url[-1] == ?/
+          url 
         else
           raise "method #{method} not recognized"
         end

data/lib/usher/node.rb

@@ -6,11 +6,10 @@ 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
+    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods
 
     def initialize(parent, value)
       @parent = parent
@@ -24,8 +23,10 @@ class Usher
       @depth ||= @parent && @parent.is_a?(Node) ? @parent.depth + 1 : 0
     end
     
-    def self.root(route_set)
-      self.new(route_set, nil)
+    def self.root(route_set, request_methods)
+      root = self.new(route_set, nil)
+      root.request_methods = request_methods
+      root
     end
 
     def has_globber?
@@ -63,8 +64,8 @@ class Usher
     def add(route)
       route.paths.each do |path|
         parts = path.parts.dup
-        ConditionalTypes.each do |type|
-          parts.push(Route::RequestMethod.new(type, route.conditions[type])) if route.conditions[type]
+        request_methods.each do |type|
+          parts.push(Route::RequestMethod.new(type, route.conditions[type])) if route.conditions.key?(type)
         end
         
         current_node = self
@@ -123,9 +124,6 @@ class Usher
             params.last.last << part
           when :':'
             params << [next_part.value.name, part]
-          when:'.:'
-            part.slice!(0)
-            params << [next_part.value.name, part]
           end
         end
         next_part.find(request, path, params)

data/lib/usher/route.rb

@@ -16,6 +16,7 @@ class Usher
       @transformers = options.delete(:transformers)
       @paths = @router.splitter.split(@original_path, @requirements, @transformers).collect {|path| Path.new(self, path)}
       @primary_path = @paths.first
+      @params = []
     end
     
     
@@ -27,7 +28,7 @@ class Usher
     #   route.to(:controller => 'testing', :action => 'index')
     #   set.recognize(Request.new('/test')).first.params => {:controller => 'testing', :action => 'index'}
     def to(options)
-      @params = options
+      @params << options
       self
     end
 

data/lib/usher/splitter.rb

@@ -3,11 +3,13 @@ require 'strscan'
 class Usher
   class Splitter
     
-    def self.delimiter(delimiter = '/')
+    def self.for_delimiters(delimiters)
+      delimiters_regex = delimiters.collect{|d| Regexp.quote(d)} * '|'
+      
       SplitterInstance.new(
-        delimiter,
-        Regexp.new('((:|\*||\.:|\.)[0-9A-Za-z\$\-_\+!\*\',]+|' + Regexp.quote(delimiter) + '|\(|\)|\|)'),
-        Regexp.new(Regexp.quote(delimiter) + '|\.?[0-9A-Za-z\$\-_\+!\*\',]+')
+        delimiters,
+        Regexp.new('((:|\*)?[0-9A-Za-z\$\-_\+!\*\',]+|' + delimiters_regex + '|\(|\)|\|)'),
+        Regexp.new(delimiters_regex + '|[0-9A-Za-z\$\-_\+!\*\',]+')
       )
     end
     
@@ -15,8 +17,9 @@ class Usher
 
     class SplitterInstance
       
-      def initialize(delimiter, split_regex, url_split_regex)
-        @delimiter = delimiter
+      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
@@ -26,7 +29,12 @@ class Usher
         ss = StringScanner.new(path)
           while !ss.eos?
             if part = ss.scan(@url_split_regex)
-              parts << part unless part == @delimiter
+              parts << case part[0]
+              when *@delimiter_chars
+                part.to_sym
+              else
+                part
+              end
             end
           end if path && !path.empty?
         parts
@@ -39,7 +47,7 @@ class Usher
         while !ss.eos?
           part = ss.scan(@split_regex)
           case part[0]
-          when ?*, ?:, ?.
+          when ?*, ?:
             type = (part[1] == ?: ? part.slice!(0,2) : part.slice!(0).chr).to_sym
             current_group << Usher::Route::Variable.new(type, part, :validator => requirements[part.to_sym], :transformer => transformers[part.to_sym])
           when ?(
@@ -59,7 +67,8 @@ class Usher
             end
             current_group.parent << Group.new(:all, current_group.parent)
             current_group = current_group.parent.last
-          when @delimiter[0]
+          when *@delimiter_chars
+            current_group << part.to_sym
           else
             current_group << part
           end

data/spec/path_spec.rb

@@ -22,12 +22,12 @@ describe "Usher route adding" do
   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"]
+      [:/, "a", :/, "b"],
+      [:/, "a", :/, "b", :/, "c", :/, "d"], 
+      [:/, "a", :/, "b", :/, "d", :/, "e"], 
+      [:/, "a", :/, "b", :/, "c"],
+      [:/, "a", :/, "b", :/, "d"],
+      [:/, "a", :/, "b", :/, "c", :/, "d", :/, "e"]
     ]
     
   end

data/spec/rack/dispatch_spec.rb

@@ -28,7 +28,7 @@ describe "Usher (for rack) route dispatching" do
 
   it "should dispatch a simple request" do
     env = {'REQUEST_URI' => '/sample', 'REQUEST_METHOD' => 'get', 'usher.params' => {}}
-    route_set.add('/sample', :controller => 'sample', :action => 'action').to(build_app_mock(env.dup))
+    route_set.add('/sample').to(build_app_mock(env.dup))
     route_set.call(env)
   end
   

data/spec/rails/generate_spec.rb

@@ -10,17 +10,17 @@ describe "Usher (for rails) URL generation" do
   end
 
   it "should fill in the controller from recall" do
-    route_set.add_route(':controller/:action/:id')
+    route_set.add_route('/:controller/:action/:id')
     route_set.generate({:action => 'thingy'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/sample/thingy'
   end
 
   it "should skip the action if not provided" do
-    route_set.add_route(':controller/:action/:id')
+    route_set.add_route('/:controller/:action/:id')
     route_set.generate({:controller => 'thingy'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/thingy'
   end
 
   it "should pick the correct param from optional parts" do
-    route_set.add_route(':controller/:action(.:format)')
+    route_set.add_route('/:controller/:action(.:format)')
     route_set.generate({:action => 'thingy', :format => 'html'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/sample/thingy.html'
     route_set.generate({:action => 'thingy'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/sample/thingy'
   end

data/spec/recognize_spec.rb

@@ -36,12 +36,12 @@ describe "Usher route recognition" do
   end
   
   it "should recognize a format-style literal" do
-    target_route = route_set.add_route(':action.html', :controller => 'sample', :action => 'action')
+    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 == 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')
+    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 == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample'], [:format, 'html']])
   end
   
@@ -57,12 +57,21 @@ describe "Usher route recognition" do
   end
   
   it "should correctly fix that tree if conditionals are used later" do
-    noop_route = route_set.add_route('noop', :controller => 'products', :action => 'noop')
+    noop_route = route_set.add_route('/noop', :controller => 'products', :action => 'noop')
     product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
     noop_route.paths.include?(route_set.recognize(build_request({:method => 'get', :path => '/noop', :domain => 'admin.host.com'})).first).should == true
     product_show_route.paths.include?(route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'})).first).should == true
   end
   
+  it "should use conditionals that are boolean" do
+    # hijacking user_agent
+    insecure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => false, :method => 'get'})
+    secure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => true, :method => 'get'})
+    
+    secure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => true})).path.route
+    insecure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => false})).path.route
+  end
+  
   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'})).params.rassoc(123).first.should == :id

data/spec/split_spec.rb

@@ -4,53 +4,53 @@ describe "Usher route tokenizing" do
   
   
   it "should split / delimited routes" do
-    Usher::Splitter.delimiter('/').split('/test/this/split').should == [['test', 'this', 'split']]
+    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this/split').should == [[:/, 'test', :/,'this', :/, 'split']]
   end
   
   it "should split on ' ' delimited routes as well" do
-    Usher::Splitter.delimiter(' ').split('test this split').should == [['test', 'this', 'split']]
+    Usher::Splitter.for_delimiters([' ']).split('test this split').should == [['test', :' ', 'this', :' ', 'split']]
   end
   
   it "should split on ' ' delimited routes for more complex routes as well" do
-    Usher::Splitter.delimiter(' ').split('(test|this) split').should == [['test', 'split'], ['this', 'split']]
+    Usher::Splitter.for_delimiters([' ']).split('(test|this) split').should == [['test', :' ', 'split'], ['this', :' ', 'split']]
   end
   
   it "should group optional parts with brackets" do
-    Usher::Splitter.delimiter('/').split('/test/this(/split)').should == [
-      ['test', 'this'],
-      ['test', 'this', 'split']
+    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split)').should == [
+      [:/, 'test', :/, 'this'],
+      [:/, 'test', :/, 'this', :/, 'split']
     ]
   end
 
   it "should group exclusive optional parts with brackets and pipes" do
-    Usher::Splitter.delimiter('/').split('/test/this(/split|/split2)').should == [
-      ['test', 'this', 'split'],
-      ['test', 'this', 'split2']
+    Usher::Splitter.for_delimiters(['/', '.']).split('/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::Splitter.delimiter('/').split('/test/this((/split|/split2))').should == [
-      ['test', 'this'],
-      ['test', 'this', 'split'],
-      ['test', 'this', 'split2']
+    Usher::Splitter.for_delimiters(['/', '.']).split('/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::Splitter.delimiter('/').split('/test/this(/split)(/split2)') == [
-      ["test", "this"],
-      ["test", "this", "split"],
-      ["test", "this", "split2"],
-      ["test", "this", "split", "split2"]
+    Usher::Splitter.for_delimiters(['/', '.']).split('/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::Splitter.delimiter('/').split('/test/this(/split(.:format))') == [
-      ["test", "this"],
-      ["test", "this", "split"],
-      ["test", "this", "split", Usher::Route::Variable.new(:'.:', :format)]
+    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split(.:format))') == [
+      [:/, "test", :/, "this"],
+      [:/, "test", :/, "this", :/, "split"],
+      [:/, "test", :/, "this", :/, "split", '.', Usher::Route::Variable.new(:':', :format)]
     ]
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-03 00:00:00 -07:00
+date: 2009-04-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.0.2
     version: 
 description: A general purpose routing library
 email: joshbuddy@gmail.com