joshbuddy-usher 0.4.2 → 0.4.3

data/README.rdoc

@@ -74,7 +74,6 @@ For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <t
 <tt>/path/something.html</tt>. Generally its more efficent to use one and only sections over using regex.
 
 === +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 +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.

data/VERSION.yml

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

data/lib/usher.rb

@@ -1,6 +1,7 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'cgi'
+require 'uri'
 require 'usher/node'
 require 'usher/route'
 require 'usher/grapher'
@@ -135,12 +136,10 @@ class Usher
   # <tt>/path/something.html</tt>. Generally its more efficent to use one and only sections over using regex.
   #
   # === +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 +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)
-    transformers = options && options.delete(:transformers) || {}
     conditions = options && options.delete(:conditions) || {}
     requirements = options && options.delete(:requirements) || {}
     if options
@@ -151,7 +150,7 @@ class Usher
         end
       end
     end
-    route = Route.new(path, self, {:transformers => transformers, :conditions => conditions, :requirements => requirements})
+    route = Route.new(path, self, {:conditions => conditions, :requirements => requirements})
     route.to(options) if options && !options.empty?
     
     @tree.add(route)
@@ -224,15 +223,18 @@ 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} * delimiter
+          generated_path << param_list.shift.collect{|dp| URI.escape(dp.to_s)} * delimiter
         else
           p.valid!(param_list.first.to_s) if check_variables
-          (dp = param_list.shift) && generated_path << dp.to_s
+          if dp = param_list.shift
+            generated_path << URI.escape(dp.to_s)
+          end
         end
       else
         generated_path << p.to_s
       end
     end
+    
     unless params_hash.empty?
       has_query = generated_path[??]
       params_hash.each do |k,v|

data/lib/usher/interface/rack_interface.rb

@@ -9,6 +9,8 @@ class Usher
       RequestMethods = [:method, :host, :port, :scheme]
       Request = Struct.new(:path, *RequestMethods)
       
+      attr_accessor :routes
+      
       def initialize(&blk)
         @routes = Usher.new(:request_methods => RequestMethods)
         instance_eval(&blk) if blk

data/lib/usher/node.rb

@@ -90,37 +90,27 @@ class Usher
     end
     
     def find(request, path, params = [])
-      part = path.shift unless path.size.zero?
-
-      if @exclusive_type
-        path.unshift part
-        [@lookup[request.send(@exclusive_type)], @lookup[nil]].each do |n|
-          ret = n.find(request, path.dup, params.dup) if n
-          ret and return ret
-        end
-      elsif path.size.zero? && !part
-        if terminates?
-          Response.new(terminates, params)
-        elsif params.last.is_a?(Array) && @lookup[nil]
-          if @lookup[nil].exclusive_type
-            @lookup[nil].find(request, path, params)
-          else
-            Response.new(@lookup[nil].terminates, params)
+      if exclusive_type
+        [lookup[request.send(exclusive_type)], lookup[nil]].each do |n|
+          if n && (ret = n.find(request, path.dup, params.dup))
+            return ret
           end
         end
-      elsif next_part = @lookup[part]
-        if next_part.value.is_a?(Route::Variable)
+      elsif path.size.zero? && terminates?
+        Response.new(terminates, params)
+      elsif next_part = lookup[part = path.shift] || lookup[nil]
+        case next_part.value
+        when Route::Variable
           case next_part.value.type
           when :*
             params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
             loop do
-              if (next_part.value.look_ahead === part || (!part.is_a?(Symbol) && !next_part.value.regex_matcher.match(part)))
+              if (next_part.value.look_ahead === part || (!part.is_a?(Symbol) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
                 path.unshift(part)
                 path.unshift(next_part.parent.value) if next_part.parent.value.is_a?(Symbol)
                 break
               else
                 unless part.is_a?(Symbol) && !next_part.value.globs_capture_separators
-                  part = next_part.value.transform!(part)
                   next_part.value.valid!(part)
                   params.last.last << part
                 end
@@ -131,48 +121,16 @@ class Usher
                 part = path.shift
               end
             end
-            next_part.find(request, path, params)
-          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?
-              params.last.last << path.shift.to_s 
-            end
-            next_part.find(request, path, params)
-          end
-        else
-          next_part.find(request, path, params)
-        end
-      elsif 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
-            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) && !next_part.value.globs_capture_separators
-                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?
               params.last.last << path.shift.to_s 
             end
-            next_part.find(request, path, params)
           end
         end
+        next_part.find(request, path, params)
       else
         nil
       end

data/lib/usher/route.rb

@@ -13,8 +13,7 @@ class Usher
       @router = router
       @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)}
+      @paths = @router.splitter.split(@original_path, @requirements).collect {|path| Path.new(self, path)}
       @primary_path = @paths.first
       #FIXME params is poorly named. this shouldn't be an array
       @params = []

data/lib/usher/route/variable.rb

@@ -1,14 +1,13 @@
 class Usher
   class Route
     class Variable
-      attr_reader :type, :name, :validator, :transformer, :regex_matcher
+      attr_reader :type, :name, :validator, :regex_matcher
       attr_accessor :look_ahead, :globs_capture_separators
       
-      def initialize(type, name, validator = nil, transformer = nil, regex_matcher = nil, globs_capture_separators = false)
+      def initialize(type, name, validator = nil, regex_matcher = nil, globs_capture_separators = false)
         @type = type
         @name = :"#{name}"
         @validator = validator
-        @transformer = transformer
         @regex_matcher = regex_matcher
         @globs_capture_separators = globs_capture_separators
       end
@@ -17,19 +16,6 @@ class Usher
         "#{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

data/lib/usher/splitter.rb

@@ -19,27 +19,18 @@ class Usher
       def initialize(delimiters, split_regex, url_split_regex)
         @delimiters = delimiters
         @delimiter_chars = delimiters.collect{|d| d[0]}
+        @delimiter_chars_map = Hash[*@delimiter_chars.map{|c| [c, c.chr.to_sym]}.flatten]
         @split_regex = split_regex
         @url_split_regex = url_split_regex
       end
       
       def url_split(path)
-        parts = []
-        ss = StringScanner.new(path)
-          while !ss.eos?
-            if part = ss.scan(@url_split_regex)
-              parts << case part[0]
-              when *@delimiter_chars
-                part.to_sym
-              else
-                part
-              end
-            end
-          end if path && !path.empty?
+        parts = path.scan(@url_split_regex)
+        parts.map!{ |part| @delimiter_chars_map[part[0]] || part}
         parts
       end
 
-      def split(path, requirements = nil, transformers = nil)
+      def split(path, requirements = nil)
         parts = Group.new(:all, nil)
         ss = StringScanner.new(path)
         current_group = parts
@@ -48,9 +39,9 @@ class Usher
           case part[0]
           when ?*, ?:
             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])
+            current_group << Usher::Route::Variable.new(type, part, requirements && requirements[part.to_sym])
           when ?{
-            pattern = '^'
+            pattern = ''
             count = 1
             variable = ss.scan(/[:\*]([^,]+),/)
             until count.zero?
@@ -63,12 +54,12 @@ class Usher
               end
               pattern << regex_part
             end
-            pattern[pattern.size - 1] = ?$
+            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], transformers && transformers[variable_name], regex)
+              current_group << Usher::Route::Variable.new(variable_type, variable_name, requirements && requirements[variable_name], regex)
             else
               current_group << regex
             end

data/spec/private/email/recognize_spec.rb

@@ -8,8 +8,6 @@ def build_email_mock(email)
   request
 end
 
-SampleController = Object.new
-
 describe "Usher (for email) route recognition" do
 
   before(:each) do

data/spec/private/generate_spec.rb

@@ -18,6 +18,11 @@ describe "Usher URL generation" do
     route_set.generate_url(: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')
+    route_set.generate_url(: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')
     route_set.generate_url(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'

data/spec/private/rack/dispatch_spec.rb

@@ -18,8 +18,6 @@ def build_app_mock(params)
   request
 end
 
-SampleController = Object.new
-
 describe "Usher (for rack) route dispatching" do
 
   before(:each) do

data/spec/private/recognize_spec.rb

@@ -10,8 +10,6 @@ def build_request(opts)
   request
 end
 
-SampleController = Object.new
-
 describe "Usher route recognition" do
   
   before(:each) do
@@ -83,6 +81,12 @@ describe "Usher route recognition" do
     route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']]]
   end
   
+  it "should recgonize a regex glob variable terminated by a single regex variable" do
+    target_route = route_set.add_route('/test/part/{*test,^(hello|again|\d+)$}/{:party,onemore}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']], [:party, 'onemore']]
+  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'}))
@@ -143,11 +147,6 @@ describe "Usher route recognition" do
     www_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['www'], :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
-  end
-
   it "should use a requirement (proc) on incoming variables" do
     route_set.add_route('/:controller/:action/:id', :id => proc{|v| Integer(v)})
     proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'}))}.should_not raise_error Usher::ValidationException
@@ -164,19 +163,10 @@ describe "Usher route recognition" do
     route_set.recognize(build_request({:method => 'get', :path => '/testing/asd.qwe/testing2/poi.zxc/oiu.asd'})).params.should == [[:id, 'asd.qwe'], [:id2, 'poi.zxc'], [:id3, 'oiu.asd']]
   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'})).params.rassoc(123).first.should == :id
-  end
-  
   it "should should raise if malformed variables are used" do
     route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
     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

data/spec/private/split_spec.rb

@@ -9,7 +9,7 @@ describe "Usher route tokenizing" do
 
   it "should split / delimited routes with a regex in it" do
     Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').
-      split('/test/{this}/split').should == [[:/, 'test', :/, /^this$/, :/, 'split']]
+      split('/test/{this}/split').should == [[:/, 'test', :/, /this/, :/, 'split']]
   end
   
   it "should split on ' ' delimited routes as well" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-11 00:00:00 -07:00
+date: 2009-05-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency