usher 0.7.5 → 0.8.0

data/lib/usher/exceptions.rb

@@ -7,4 +7,6 @@ class Usher
   class MissingParameterException < RuntimeError; end
   # Raised when a route is added with identical variable names and allow_identical_variable_names? is false
   class MultipleParameterException < RuntimeError; end
+  # Raised when a route is added with two regex validators
+  class DoubleRegexpException < RuntimeError; end
 end

data/lib/usher/interface/rack.rb

@@ -33,7 +33,7 @@ class Usher
         if redirect_on_trailing_delimiters
           options[:ignore_trailing_delimiters] = true
         end
-        usher_options = {:request_methods => request_methods, :generator => generator, :allow_identical_variable_names => allow_identical_variable_names}
+        usher_options = {:request_methods => request_methods, :generator => generator, :allow_identical_variable_names => allow_identical_variable_names, :detailed_failure => true}
         usher_options.merge!(options)
         @router = Usher.new(usher_options)
         @router.route_class = Rack::Route
@@ -120,12 +120,12 @@ class Usher
         env[router_key] = self
         request = ::Rack::Request.new(env)
         response = @router.recognize(request, request.path_info)
-        if redirect_on_trailing_delimiters and response.only_trailing_delimiters and (request.get? || request.head?)
+        if response.succeeded? && redirect_on_trailing_delimiters and response.only_trailing_delimiters and (request.get? || request.head?)
           response = ::Rack::Response.new
           response.redirect(request.path_info[0, request.path_info.size - 1], 302)
           response.finish
         else
-          after_match(request, response) if response
+          after_match(request, response) if response.succeeded?
           determine_respondant(response).call(env)
         end
       end
@@ -161,11 +161,15 @@ class Usher
       #
       # @api private
       def determine_respondant(response)
-        usable_response = use_destinations? && response && response.destination
+        usable_response = response.succeeded? && use_destinations? && response && response.destination
         if usable_response && response.destination.respond_to?(:call)
           response.destination
         elsif usable_response && response.destination.respond_to?(:args) && response.destination.args.first.respond_to?(:call)
           response.args.first
+        elsif !response.succeeded? && response.request_method?
+          rack_response = ::Rack::Response.new("Method not allowed", 405)
+          rack_response['Allow'] = response.acceptable_responses_only_strings.join(", ")
+          proc { |env| rack_response.finish }
         else
           _app
         end

data/lib/usher/interface/sinatra.rb

@@ -23,10 +23,18 @@ class Usher
         private
           def route!(base=self.class, pass_block=nil)
             if base.router and match = base.router.recognize(@request, @request.path_info)
-              @block_params = match.params.map { |p| p.last }
-              (@params ||= {}).merge!(match.params_as_hash)
-              pass_block = catch(:pass) do
-                route_eval(&match.destination)
+              if match.succeeded?
+                @block_params = match.params.map { |p| p.last }
+                (@params ||= {}).merge!(match.params_as_hash)
+                pass_block = catch(:pass) do
+                  route_eval(&match.destination)
+                end
+              elsif match.request_method?
+                route_eval { 
+                  response['Allow'] = match.acceptable_responses_only_strings.join(", ")
+                  status 405
+                }
+                return
               end
             end
 
@@ -76,7 +84,8 @@ class Usher
                                   :ignore_trailing_delimiters => true,
                                   :generator => Usher::Util::Generators::URL.new,
                                   :delimiters => ['/', '.', '-'],
-                                  :valid_regex => '[0-9A-Za-z\$_\+!\*\',]+')
+                                  :valid_regex => '[0-9A-Za-z\$_\+!\*\',]+',
+                                  :detailed_failure => true)
             block_given? ? yield(@router) : @router
           end
 
@@ -114,6 +123,25 @@ class Usher
                 </html>
                 HTML
               end
+              error 405 do
+                content_type 'text/html'
+
+                (<<-HTML).gsub(/^ {17}/, '')
+                <!DOCTYPE html>
+                <html>
+                <head>
+                  <style type="text/css">
+                  body { text-align:center;font-family:helvetica,arial;font-size:22px;
+                    color:#888;margin:20px}
+                  #c {margin:0 auto;width:500px;text-align:left}
+                  </style>
+                </head>
+                <body>
+                  <h2>Sinatra sorta knows this ditty, but the request method is not allowed.</h2>
+                </body>
+                </html>
+                HTML
+              end
             end
 
             @_configured = true

data/lib/usher/node/failed_response.rb

@@ -0,0 +1,34 @@
+class Usher
+  class Node
+    # The response from {Usher::Node::Root#lookup}. Adds some convenience methods for common parameter manipulation.
+    class FailedResponse < Struct.new(:last_matching_node, :fail_type, :fail_sub_type)
+      # The success of the response
+      # @return [Boolean] Always returns false
+      def succeeded?
+        false
+      end
+      
+      def request_method?
+        fail_type == :request_method
+      end
+
+      def normal_or_greedy?
+        fail_type == :normal_or_greedy
+      end
+      
+      def acceptable_responses
+        case fail_type
+        when :request_method
+          last_matching_node.request.keys
+        when :normal_or_greedy
+          (last_matching_node.greedy || []) + (last_matching_node.normal || [])
+        end
+      end
+
+      def acceptable_responses_only_strings
+        acceptable_responses.select{|r| r.is_a?(String)}
+      end
+
+    end
+  end
+end

data/lib/usher/node/response.rb

@@ -3,6 +3,12 @@ class Usher
     # The response from {Usher::Node::Root#lookup}. Adds some convenience methods for common parameter manipulation.
     class Response < Struct.new(:path, :params_as_array, :remaining_path, :matched_path, :only_trailing_delimiters)
       
+      # The success of the response
+      # @return [Boolean] Always returns true
+      def succeeded?
+        true
+      end
+
       # The params from recognition
       # @return [Array<Symbol, String>] The parameters detected from recognition returned as an array of arrays.
       def params

data/lib/usher/node/root_ignoring_trailing_delimiters.rb

@@ -13,7 +13,7 @@ class Usher
         if path.size > 1
           new_path = path.gsub(@stripper, '')
           response = lookup_without_stripping(request_object, new_path)
-          response.only_trailing_delimiters = (new_path.size != path.size) if response
+          response.only_trailing_delimiters = (new_path.size != path.size) if response && response.succeeded?
           response
         else
           lookup_without_stripping(request_object, path)

data/lib/usher/node.rb

@@ -1,6 +1,7 @@
 require File.join('usher', 'node', 'root')
 require File.join('usher', 'node', 'root_ignoring_trailing_delimiters')
 require File.join('usher', 'node', 'response')
+require File.join('usher', 'node', 'failed_response')
 
 class Usher
   
@@ -120,19 +121,25 @@ class Usher
             route_candidates << ret
           end
           route_candidates.sort!{|r1, r2| r1.path.route.priority <=> r2.path.route.priority}
-          route_candidates.last
+          request_method_respond(route_candidates.last, request_method_type)
         else
           if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params && params.dup)
             ret
           elsif general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params && params.dup)
-            ret
+            request_method_respond(ret, request_method_type)
+          else
+            request_method_respond(nil, request_method_type)
           end
         end
       else
-        nil
+        route_set.detailed_failure? ? FailedResponse.new(self, :normal_or_greedy, nil) : nil
       end
     end
 
+    def request_method_respond(ret, request_method_respond)
+      ret || (route_set.detailed_failure? ? FailedResponse.new(self, :request_method, request_method_respond) : nil)
+    end
+
     def activate_normal!
       @normal ||= {}
     end

data/lib/usher/route/variable.rb

@@ -12,7 +12,7 @@ class Usher
         include Validator
         def valid!(val)
           begin
-            @validator.call(val)
+            @validator.call(val) or raise(ValidationException.new("#{val} does not conform to #{@validator}"))
           rescue Exception => e
             raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
           end

data/lib/usher/splitter.rb

@@ -1,7 +1,7 @@
 class Usher
   class Splitter
 
-    def self.for_delimiters(delimiters_array)
+    def self.new(delimiters_array)
       delimiters = Delimiters.new(delimiters_array)
       delimiters.any?{|d| d.size > 1} ?
         MultiCharacterSplitterInstance.new(delimiters) :
@@ -13,7 +13,7 @@ class Usher
       def initialize(delimiters)
         @url_split_regex = Regexp.new("[^#{delimiters.regexp_char_class}]+|[#{delimiters.regexp_char_class}]")
       end
-      
+        
       def split(path)
         path.scan(@url_split_regex)
       end

data/lib/usher/util/generate.rb

@@ -178,7 +178,7 @@ class Usher
             when Array
               v.each do |v_part|
                 extra_params_result << '&' unless extra_params_result.empty?
-                extra_params_result << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
+                extra_params_result << Rack::Utils.escape(k.to_s) << '%5B%5D=' << Rack::Utils.escape(v_part.to_s)
               end
             else
               extra_params_result << '&' unless extra_params_result.empty?

data/lib/usher/util/parser.rb

@@ -6,16 +6,9 @@ class Usher
 
       attr_reader :router
 
-      def self.for_delimiters(router, valid_regex)
-        new(
-          router,
-          Regexp.new('((:|\*)?' + valid_regex + '|' + router.delimiters_regex + '|\(|\)|\||\{)')
-        )
-      end
-
-      def initialize(router, split_regex)
+      def initialize(router, valid_regex)
         @router = router
-        @split_regex = split_regex
+        @split_regex = Regexp.new('((:|\*)?' + valid_regex + '|' + router.delimiters_regex + '|\(|\)|\||\{)')
         @delimiters_regex = Regexp.new(router.delimiters_regex)
       end
 
@@ -102,12 +95,10 @@ class Usher
           end
 
           case part[0]
-          when ?*
-            var_name = part[1, part.size - 1].to_sym
-            current_group << Usher::Route::Variable::Glob.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
-          when ?:
+          when ?*, ?:
+            variable_class = part[0] == ?* ? Usher::Route::Variable::Glob : Usher::Route::Variable::Single
             var_name = part[1, part.size - 1].to_sym
-            current_group << Usher::Route::Variable::Single.new(part[1, part.size - 1], nil, requirements && requirements[var_name])
+            current_group << variable_class.new(part[1, part.size - 1], requirements && requirements[var_name].is_a?(Regexp) ? requirements[var_name] : nil, requirements && requirements[var_name])
           when ?{
             pattern = ''
             count = 1
@@ -131,6 +122,7 @@ class Usher
               when ?: then Usher::Route::Variable::Single
               end
               variable_name = variable[0, variable.size - 1].to_sym
+              raise DoubleRegexpException.new("#{variable_name} has two regex validators, #{pattern} and #{requirements[variable_name]}") if requirements && requirements[variable_name] && requirements[variable_name].is_a?(Regexp)
               current_group << variable_class.new(variable_name, Regexp.new(pattern), requirements && requirements[variable_name])
             elsif simple
               static = Usher::Route::Static::Greedy.new(pattern)

data/lib/usher.rb

@@ -56,7 +56,7 @@ class Usher
     @routes = []
     @grapher = Grapher.new(self)
     @priority_lookups = false
-    @parser = Util::Parser.for_delimiters(self, valid_regex)
+    @parser = Util::Parser.new(self, valid_regex)
   end
 
   # Creates a route set, with options
@@ -67,6 +67,7 @@ class Usher
   # @option options [nil or Generator] :generator (nil) Take a look at `Usher::Util::Generators for examples.`.
   # @option options [Boolean] :ignore_trailing_delimiters (false) Ignore trailing delimiters in recognizing paths.
   # @option options [Boolean] :consider_destination_keys (false) When generating, and using hash destinations, you can have Usher use the destination hash to match incoming params.
+  # @option options [Boolean] :detailed_failure (false) When a route fails to match, return a {Node::FailedResponse} instead of a `nil`
   #   Example, you create a route with a destination of :controller => 'test', :action => 'action'. If you made a call to generator with :controller => 'test', 
   #   :action => 'action', it would pick that route to use for generation.
   # @option options [Boolean] :allow_identical_variable_names (true) When adding routes, allow identical variable names to be used.
@@ -79,6 +80,8 @@ class Usher
     self.ignore_trailing_delimiters      = options && options.key?(:ignore_trailing_delimiters) ? options.delete(:ignore_trailing_delimiters) : false
     self.consider_destination_keys       = options && options.key?(:consider_destination_keys) ? options.delete(:consider_destination_keys) : false
     self.allow_identical_variable_names  = options && options.key?(:allow_identical_variable_names) ? options.delete(:allow_identical_variable_names) : true
+    self.detailed_failure                = options && options.key?(:detailed_failure) ? options.delete(:detailed_failure) : false
+
     unless options.nil? || options.empty?
       raise "unrecognized options -- #{options.keys.join(', ')}"
     end
@@ -90,6 +93,11 @@ class Usher
     @allow_identical_variable_names
   end
   
+  # @return [Boolean] State of detailed_failure feature.
+  def detailed_failure?
+    @detailed_failure
+  end
+  
   # @return [Boolean] State of ignore_trailing_delimiters feature.
   def ignore_trailing_delimiters?
     @ignore_trailing_delimiters
@@ -320,7 +328,7 @@ class Usher
 
   private
 
-  attr_accessor :request_methods, :ignore_trailing_delimiters, :consider_destination_keys, :allow_identical_variable_names
+  attr_accessor :request_methods, :ignore_trailing_delimiters, :consider_destination_keys, :allow_identical_variable_names, :detailed_failure
   attr_reader :valid_regex
   attr_writer :parser
   
@@ -340,7 +348,7 @@ class Usher
 
   def valid_regex=(valid_regex)
     @valid_regex = valid_regex
-    @splitter = Splitter.for_delimiters(self.delimiters)
+    @splitter = Splitter.new(self.delimiters)
     @valid_regex
   end
 

data/spec/private/rack/dispatch_spec.rb

@@ -66,6 +66,15 @@ describe "Usher (for rack) route dispatching" do
     end
   end
 
+  it "should returns HTTP 405 if the method mis-matches" do
+    route_set.reset!
+    route_set.add('/sample', :conditions => {:request_method => 'POST'}).to(@app)
+    route_set.add('/sample', :conditions => {:request_method => 'PUT'}).to(@app)
+    response = route_set.call_with_mock_request('/sample', 'GET')
+    response.status.should eql(405)
+    response['Allow'].should == 'POST, PUT'
+  end
+
   it "should returns HTTP 404 if route doesn't exist" do
     response = route_set.call_with_mock_request("/not-existing-url")
     response.status.should eql(404)

data/spec/private/recognize_spec.rb

@@ -288,9 +288,18 @@ describe "Usher route recognition" do
     result.params.should == [[:name, "homer"],[:surname, "simpson"]]
   end
 
-  it "should should raise if malformed variables are used" do
+  it "should use a regexp requirement as part of recognition" 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
+    @route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'})).should be_nil
+  end
+
+  it "should use a inline regexp and proc requirement as part of recognition" do
+    @route_set.add_route('/products/show/{:id,^\d+$}', :id => proc{|v| v == '123'}, :conditions => {:method => 'get'})
+    proc { @route_set.recognize(build_request({:method => 'get', :path => '/products/show/234', :domain => 'admin.host.com'}))}.should raise_error(Usher::ValidationException)
+  end
+
+  it "should not allow the use of an inline regexp and regexp requirement as part of recognition" do
+    proc { @route_set.add_route('/products/show/{:id,^\d+$}', :id => /\d+/, :conditions => {:method => 'get'}) }.should raise_error(Usher::DoubleRegexpException)
   end
 
   it "should recognize multiple optional parts" do

data/spec/private/sinatra/recognize_spec.rb

@@ -117,4 +117,16 @@ describe "Usher (for Sinatra) route recognition" do
     end
   end
 
+  describe "method not allowed" do
+
+    it "should correctly generate a not found page without images and return a 405" do
+      @app.post('/bar') { 'found' }
+      @app.put('/bar') { 'found' }
+      response = @app.call_with_mock_request('/bar')
+      response.status.should == 405
+      response.headers['Allow'].should == 'POST, PUT'
+      response.body.should_not match(/__sinatra__/)
+    end
+  end
+
 end

data/spec/private/splitter_spec.rb

@@ -4,37 +4,37 @@ require "usher"
 describe Usher::Splitter, "#split" do
   describe "when there are single-character delimiters" do
     it "should split correctly" do
-      Usher::Splitter.for_delimiters(['.', '/']).split('/one/two.three/').should == ['/', 'one', '/', 'two', '.', 'three', '/']
+      Usher::Splitter.new(['.', '/']).split('/one/two.three/').should == ['/', 'one', '/', 'two', '.', 'three', '/']
     end
   end
 
   describe "when there are multi-character delimiters" do
     it "should split correctly" do
-      Usher::Splitter.for_delimiters(['/', '%28', '%29']).split('/one%28two%29three/').should == ['/', 'one', '%28', 'two', '%29', 'three', '/']
+      Usher::Splitter.new(['/', '%28', '%29']).split('/one%28two%29three/').should == ['/', 'one', '%28', 'two', '%29', 'three', '/']
     end
   end
 
   describe "when there is no delimiter in the end" do
     it "should split correctly" do
-      Usher::Splitter.for_delimiters(['.', '/']).split('/one/two.three').should == ['/', 'one', '/', 'two', '.', 'three']
+      Usher::Splitter.new(['.', '/']).split('/one/two.three').should == ['/', 'one', '/', 'two', '.', 'three']
     end
   end
 
   describe "when there is no delimiter in the beginning" do
     it "should split correctly" do
-      Usher::Splitter.for_delimiters(['.', '/']).split('one/two.three/').should == ['one', '/', 'two', '.', 'three', '/']
+      Usher::Splitter.new(['.', '/']).split('one/two.three/').should == ['one', '/', 'two', '.', 'three', '/']
     end
   end
 
   describe "when delimiters are consecutive" do
     it "should split correctly" do
-      Usher::Splitter.for_delimiters(['/', '!']).split('/cheese/!parmesan').should == ['/', 'cheese', '/', '!', 'parmesan']
+      Usher::Splitter.new(['/', '!']).split('/cheese/!parmesan').should == ['/', 'cheese', '/', '!', 'parmesan']
     end
   end
 
   describe "when delimiters contain escaped characters" do
     it "should split correctly" do
-      Usher::Splitter.for_delimiters(['/', '\(', '\)']).split('/cheese(parmesan)').should == ['/', 'cheese', '(', 'parmesan', ')']
+      Usher::Splitter.new(['/', '\(', '\)']).split('/cheese(parmesan)').should == ['/', 'cheese', '(', 'parmesan', ')']
     end
   end
 end

data/usher.gemspec

@@ -5,7 +5,7 @@ require "base64"
 
 Gem::Specification.new do |s|
   s.name = "usher"
-  s.version = "0.7.5"
+  s.version = "0.8.0"
   s.authors = ["Daniel Neighman", "Daniel Vartanov", "Jakub Šťastný", "Joshua Hull", "Davide D'Agostino"].sort
   s.homepage = "http://github.com/joshbuddy/usher"
   s.summary = "Pure ruby general purpose router with interfaces for rails, rack, email or choose your own adventure"

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 7
-  - 5
-  version: 0.7.5
+  - 8
+  - 0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -19,7 +19,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2010-05-02 00:00:00 -04:00
+date: 2010-05-05 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -121,6 +121,7 @@ files:
 - lib/usher/interface/sinatra.rb
 - lib/usher/interface/text.rb
 - lib/usher/node.rb
+- lib/usher/node/failed_response.rb
 - lib/usher/node/response.rb
 - lib/usher/node/root.rb
 - lib/usher/node/root_ignoring_trailing_delimiters.rb