joshbuddy-usher 0.3.6 → 0.4.0

data/README.rdoc

@@ -67,7 +67,7 @@ Sections of a route can be marked as "one and only one" by surrounding it with b
 
 == Rack
 
-=== rackup.ru
+=== config.ru
 
   require 'usher'
   app = proc do |env|
@@ -82,8 +82,10 @@ Sections of a route can be marked as "one and only one" by surrounding it with b
     ]
   end
   
-  routes = Usher::Interface.for(:rack)
-  routes.add('/hello/:name').to(app)
+  routes = Usher::Interface.for(:rack) do
+    add('/hello/:name').to(app)
+  end
+
   run routes
 
 ------------

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', '>=0.0.2'
+    s.add_dependency 'joshbuddy-fuzzy_hash', '>=0.0.3'
   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: 6
+:minor: 4
+:patch: 0

data/lib/usher/grapher.rb

@@ -11,7 +11,6 @@ class Usher
       @significant_keys = nil
       @orders = Hash.new{|h,k| h[k] = Hash.new{|h2, k2| h2[k2] = []}}
       @key_count = Hash.new(0)
-      @cache = {}
     end
 
     def add_route(route)

data/lib/usher/interface/rack_interface.rb

@@ -14,7 +14,7 @@ class Usher
         instance_eval(&blk) if blk
       end
       
-      def add(path, options = {})
+      def add(path, options = nil)
         @routes.add_route(path, options)
       end
 

data/lib/usher/interface/rails2_interface/mapper.rb

@@ -7,7 +7,7 @@ class Usher
           @set = set
         end
 
-        def connect(path, options = {})
+        def connect(path, options = nil)
           @set.add_route(path, options)
         end
 
@@ -21,7 +21,7 @@ class Usher
           named_route(:root, '/', options)
         end
 
-        def named_route(name, path, options = {})
+        def named_route(name, path, options = nil)
           @set.add_named_route(name, path, options)
         end
 

data/lib/usher/node.rb

@@ -14,10 +14,14 @@ class Usher
     def initialize(parent, value)
       @parent = parent
       @value = value
-      @lookup = FuzzyHash.new
+      @lookup = Hash.new
       @exclusive_type = nil
     end
 
+    def upgrade_lookup
+      @lookup = FuzzyHash.new(@lookup)
+    end
+
     def depth
       @depth ||= @parent && @parent.is_a?(Node) ? @parent.depth + 1 : 0
     end
@@ -54,6 +58,7 @@ class Usher
           key = parts.shift
           target_node = case key
           when Route::RequestMethod
+            current_node.upgrade_lookup if key.value.is_a?(Regexp)
             if current_node.exclusive_type == key.type
               current_node.lookup[key.value] ||= Node.new(current_node, key)
             elsif current_node.lookup.empty?
@@ -64,7 +69,15 @@ class Usher
               current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
             end
           else
-            current_node.lookup[key.is_a?(Route::Variable) ? nil : key] ||= Node.new(current_node, key)
+            if !key.is_a?(Route::Variable)
+              current_node.upgrade_lookup if key.is_a?(Regexp)
+              current_node.lookup[key] ||= Node.new(current_node, key)
+            elsif key.regex_matcher
+              current_node.upgrade_lookup
+              current_node.lookup[key.regex_matcher] ||= Node.new(current_node, key)
+            else
+              current_node.lookup[nil] ||= Node.new(current_node, key)
+            end  
           end
           current_node = target_node
         end
@@ -86,20 +99,45 @@ class Usher
         if terminates?
           Response.new(terminates, params)
         elsif params.last.is_a?(Array) && @lookup[nil]
-          Response.new(@lookup[nil].terminates, params)
+          if @lookup[nil].exclusive_type
+            @lookup[nil].find(request, path, params)
+          else
+            Response.new(@lookup[nil].terminates, params)
+          end
         end
       elsif next_part = @lookup[part]
-        next_part.find(request, path, params)
-      elsif next_part = @lookup[nil]
         if next_part.value.is_a?(Route::Variable)
           part = next_part.value.transform!(part)
           next_part.value.valid!(part)
+          var = next_part.value
+          params << [next_part.value.name, part]
+          until (path.first == var.look_ahead) || path.empty?
+            params.last.last << path.shift.to_s 
+          end
+          next_part.find(request, path, params)
+        else
+          next_part.find(request, path, params)
+        end
+      elsif next_part = @lookup[part] || next_part = @lookup[nil]
+        if next_part.value.is_a?(Route::Variable)
           case next_part.value.type
           when :*
             params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
-            params.last.last << part unless part.is_a?(Symbol)
-            find(request, path, params)
+            if next_part.value.look_ahead === part
+              path.unshift(part)
+              path.unshift(next_part.parent.value) if next_part.parent.value.is_a?(Symbol)
+              next_part.find(request, path, params)
+            else
+              unless part.is_a?(Symbol)
+                part = next_part.value.transform!(part)
+                next_part.value.valid!(part)
+                params.last.last << part
+              end
+              find(request, path, params)
+            end
           when :':'
+            part = next_part.value.transform!(part)
+            next_part.value.valid!(part)
             var = next_part.value
             params << [next_part.value.name, part]
             until (path.first == var.look_ahead) || path.empty?

data/lib/usher/route/variable.rb

@@ -1,14 +1,15 @@
 class Usher
   class Route
     class Variable
-      attr_reader :type, :name, :validator, :transformer
+      attr_reader :type, :name, :validator, :transformer, :regex_matcher
       attr_accessor :look_ahead
       
-      def initialize(type, name, opts = {})
+      def initialize(type, name, validator = nil, transformer = nil, regex_matcher = nil)
         @type = type
         @name = :"#{name}"
-        @validator = opts[:validator]
-        @transformer = opts[:transformer]
+        @validator = validator
+        @transformer = transformer
+        @regex_matcher = regex_matcher
       end
 
       def to_s

data/lib/usher/route.rb

@@ -8,14 +8,15 @@ class Usher
   class Route
     attr_reader :paths, :original_path, :requirements, :conditions, :params, :primary_path
     
-    def initialize(original_path, router, options = {}) # :nodoc:
+    def initialize(original_path, router, options = nil) # :nodoc:
       @original_path = original_path
       @router = router
-      @requirements = options.delete(:requirements)
-      @conditions = options.delete(:conditions)
-      @transformers = options.delete(:transformers)
+      @requirements = options && options.delete(:requirements)
+      @conditions = options && options.delete(:conditions)
+      @transformers = options && options.delete(:transformers)
       @paths = @router.splitter.split(@original_path, @requirements, @transformers).collect {|path| Path.new(self, path)}
       @primary_path = @paths.first
+      #FIXME params is poorly named. this shouldn't be an array
       @params = []
     end
     
@@ -27,8 +28,8 @@ class Usher
     #   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
+    def to(options = nil, &block)
+      @params << (block_given? ? block : options)
       self
     end
 

data/lib/usher/splitter.rb

@@ -8,7 +8,7 @@ class Usher
       
       SplitterInstance.new(
         delimiters,
-        Regexp.new('((:|\*)?[0-9A-Za-z\$\-_\+!\*\',]+|' + delimiters_regex + '|\(|\)|\|)'),
+        Regexp.new('((:|\*)?[0-9A-Za-z\$\-_\+!\*\',]+|' + delimiters_regex + '|\(|\)|\||\{)'),
         Regexp.new(delimiters_regex + '|[0-9A-Za-z\$\-_\+!\*\',]+')
       )
     end
@@ -40,7 +40,7 @@ class Usher
         parts
       end
 
-      def split(path, requirements = {}, transformers = {})
+      def split(path, requirements = nil, transformers = nil)
         parts = Group.new(:all, nil)
         ss = StringScanner.new(path)
         current_group = parts
@@ -48,8 +48,32 @@ class Usher
           part = ss.scan(@split_regex)
           case part[0]
           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])
+            type = part.slice!(0).chr.to_sym
+            current_group << Usher::Route::Variable.new(type, part, requirements && requirements[part.to_sym], transformers && transformers[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.size - 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], transformers && transformers[variable_name], regex)
+            else
+              current_group << regex
+            end
+            
           when ?(
             new_group = Group.new(:any, current_group)
             current_group << new_group
@@ -75,20 +99,16 @@ class Usher
         end unless !path || path.empty?
         paths = calc_paths(parts)
         paths.each do |path|
-          last_delimiter = nil
-          last_variable = nil
-          path.each do |part|
-            case part
-            when Symbol
-              last_delimiter = part
-            when Usher::Route::Variable
-              if last_variable
-                last_variable.look_ahead = last_delimiter || @delimiters.first.to_sym
+          path.each_with_index do |part, index|
+            if part.is_a?(Usher::Route::Variable)
+              case part.type
+              when :*
+                part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Symbol) && !p.is_a?(Usher::Route::Variable)} || nil
+              when :':'
+                part.look_ahead = path[index + 1, path.size].find{|p| p.is_a?(Symbol)} || @delimiters.first.to_sym
               end
-              last_variable = part
             end
           end
-          last_variable.look_ahead = last_delimiter || @delimiters.first.to_sym if last_variable
         end
         paths
       end

data/lib/usher.rb

@@ -45,9 +45,9 @@ class Usher
   # 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(options = {})
-    @delimiters = options.delete(:options) || ['/', '.']
-    @request_methods = options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
+  def initialize(options = nil)
+    @delimiters = options && options.delete(:options) || ['/', '.']
+    @request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
     @splitter = Splitter.for_delimiters(@delimiters)
     reset!
   end
@@ -56,7 +56,7 @@ class Usher
   #   
   #   set = Usher.new
   #   set.add_named_route(:test_route, '/test')
-  def add_named_route(name, path, options = {})
+  def add_named_route(name, path, options = nil)
     add_route(path, options).name(name)
   end
 
@@ -113,19 +113,20 @@ class Usher
   # * +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 = {})
-    transformers = options.delete(:transformers) || {}
-    conditions = options.delete(:conditions) || {}
-    requirements = options.delete(:requirements) || {}
-    options.delete_if do |k, v|
-      if v.is_a?(Regexp) || v.is_a?(Proc)
-        requirements[k] = v 
-        true
+  def add_route(path, options = nil)
+    transformers = options && options.delete(:transformers) || {}
+    conditions = options && options.delete(:conditions) || {}
+    requirements = options && options.delete(:requirements) || {}
+    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, {:transformers => transformers, :conditions => conditions, :requirements => requirements})
-    route.to(options) unless options.empty?
+    route.to(options) if options && !options.empty?
     
     @tree.add(route)
     @routes << route
@@ -160,10 +161,10 @@ class Usher
   #   set.generate_url(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
   #   set.generate_url(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
   #   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
-    extra_params = options.key?(:extra_params) ? options.delete(:extra_params) : {}
+  def generate_url(route, params = nil, options = nil)
+    check_variables = options && options.key?(:check_variables) ? options.delete(:check_variables) : false
+    delimiter = options && options.key?(:delimiter) ? options.delete(:delimiter) : @delimiters.first
+    extra_params = options && options.key?(:extra_params) ? options.delete(:extra_params) : {}
     
     path = case route
     when Symbol
@@ -183,6 +184,8 @@ class Usher
       path.dynamic_parts.collect{|k| params_hash.delete(k.name) {|el| raise MissingParameterException.new(k.name)} }
     when Array
       path.dynamic_parts.size == params.size ? params : raise(MissingParameterException.new("got #{params.size} arguments, expected #{path.dynamic_parts.size}"))
+    when nil
+      nil
     else
       Array(params)
     end

data/spec/recognize_spec.rb

@@ -40,6 +40,50 @@ 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 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'}))
+    response.params.should == [[:format, ['sample', 'html', 'json', 'apple']]]
+    response.path.route.should == target_route
+  end
+  
+  it "should recgonize a regex static part" do
+    target_route = route_set.add_route('/test/part/{one|two}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/two'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/three'})).should == nil
+  end
+  
+  it "should recgonize a regex static part containing {}'s" do
+    target_route = route_set.add_route('/test/part/{^o{2,3}$}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/oo'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/ooo'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/oooo'})).should == nil
+  end
+  
+  it "should recgonize a regex static part containing {}'s" do
+    target_route = route_set.add_route('/test/part/{:test,hello|again}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello'})).params.should == [[:test, 'hello']]
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/again'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/again'})).params.should == [[:test, 'again']]
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/world'})).should == nil
+  end
+  
+  it "should recgonize two glob-style variables separated by a static part" do
+    target_route = route_set.add_route('/*format/innovate/*onemore')
+    response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/innovate/apple'}))
+    response.params.should == [[:format, ['sample', 'html']], [:onemore, ['apple']]]
+    response.path.route.should == target_route
+  end
+  
+  it "should recgonize only a glob-style variable with a condition" do
+    target_route = route_set.add_route('/*format', :conditions => {:domain => 'test-domain'})
+    response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/json/apple', :domain => 'test-domain'}))
+    response.params.should == [[:format, ['sample', 'html', 'json', 'apple']]]
+    response.path.route.should == target_route
+  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 == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample']])

data/spec/split_spec.rb

@@ -6,6 +6,11 @@ describe "Usher route tokenizing" do
   it "should split / delimited routes" do
     Usher::Splitter.for_delimiters(['/', '.']).split('/test/this/split').should == [[:/, 'test', :/,'this', :/, 'split']]
   end
+
+  it "should split / delimited routes with a regex in it" do
+    Usher::Splitter.for_delimiters(['/', '.']).
+      split('/test/{this}/split').should == [[:/, 'test', :/, /this/, :/, 'split']]
+  end
   
   it "should split on ' ' delimited routes as well" do
     Usher::Splitter.for_delimiters([' ']).split('test this split').should == [['test', :' ', 'this', :' ', 'split']]
@@ -50,7 +55,7 @@ describe "Usher route tokenizing" do
     Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split(.:format))') == [
       [:/, "test", :/, "this"],
       [:/, "test", :/, "this", :/, "split"],
-      [:/, "test", :/, "this", :/, "split", '.', Usher::Route::Variable.new(:':', :format)]
+      [:/, "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.6
+  version: 0.4.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-27 00:00:00 -07:00
+date: 2009-05-09 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.2
+        version: 0.0.3
     version: 
 description: A general purpose routing library
 email: joshbuddy@gmail.com