roda 1.3.0 → 2.0.0

data/lib/roda.rb

@@ -59,18 +59,6 @@ class Roda
   @opts = {}
   @route_block = nil
 
-  module RodaDeprecateMutation
-    [:[]=, :clear, :compare_by_identity, :default=, :default_proc=, :delete, :delete_if,
-     :keep_if, :merge!, :reject!, :replace, :select!, :shift, :store, :update].each do |m|
-      class_eval(<<-END, __FILE__, __LINE__+1)
-        def #{m}(*)
-          RodaPlugins.deprecate("Mutating this hash (\#{inspect}) via the #{m} method is deprecated, this hash will be frozen in Roda 2.")
-          super
-        end
-      END
-    end
-  end
-
   # Module in which all Roda plugins should be stored. Also contains logic for
   # registering and loading plugins.
   module RodaPlugins
@@ -98,12 +86,6 @@ class Roda
       @plugins[name] = mod
     end
 
-    # Emit a deprecation message.  By default this just calls warn.  You can override this
-    # method to log deprecation messages to a file or include backtraces (or something else).
-    def self.deprecate(msg)
-      warn(msg)
-    end
-
     # The base plugin for Roda, implementing all default functionality.
     # Methods are put into a plugin so future plugins can easily override
     # them and call super to get the default behavior.
@@ -151,11 +133,6 @@ class Roda
           super
         end
 
-        def hash_matcher(key, &block)
-          RodaPlugins.deprecate("Roda.hash_matcher is deprecated and will be removed in Roda 2.  It has been moved to the hash_matcher plugin.")
-          self::RodaRequest.send(:define_method, :"match_#{key}", &block)
-        end
-
         # When inheriting Roda, copy the shared data into the subclass,
         # and setup the request and response subclasses.
         def inherited(subclass)
@@ -167,9 +144,6 @@ class Roda
           subclass.opts.to_a.each do |k,v|
             if (v.is_a?(Array) || v.is_a?(Hash)) && !v.frozen?
               subclass.opts[k] = v.dup
-              if v.is_a?(RodaDeprecateMutation)
-                subclass.opts[k].extend(RodaDeprecateMutation)
-              end
             end
           end
           subclass.instance_variable_set(:@route_block, @route_block)
@@ -204,16 +178,6 @@ class Roda
           plugin.configure(self, *args, &block) if plugin.respond_to?(:configure)
         end
 
-        def request_module(mod = nil, &block)
-          RodaPlugins.deprecate("Roda.request_module is deprecated and will be removed in Roda 2.  It has been moved to the module_include plugin.")
-          module_include(:request, mod, &block)
-        end
-    
-        def response_module(mod = nil, &block)
-          RodaPlugins.deprecate("Roda.response_module is deprecated and will be removed in Roda 2.  It has been moved to the module_include plugin.")
-          module_include(:response, mod, &block)
-        end
-
         # Setup routing tree for the current Roda application, and build the
         # underlying rack application using the stored middleware. Requires
         # a block, which is yielded the request.  By convention, the block
@@ -254,49 +218,37 @@ class Roda
           if block = @route_block
             builder = Rack::Builder.new
             @middleware.each{|a, b| builder.use(*a, &b)}
-            builder.run lambda{|env| allocate.call(env, &block)}
+            builder.run lambda{|env| new(env).call(&block)}
             @app = builder.to_app
           end
         end
-
-        # REMOVE20
-        def module_include(type, mod)
-          if type == :response
-            klass = self::RodaResponse
-            iv = :@response_module
-          else
-            klass = self::RodaRequest
-            iv = :@request_module
-          end
-
-          if mod
-            raise RodaError, "can't provide both argument and block to response_module" if block_given?
-            klass.send(:include, mod)
-          else
-            if instance_variable_defined?(iv)
-              mod = instance_variable_get(iv)
-            else
-              mod = instance_variable_set(iv, Module.new)
-              klass.send(:include, mod)
-            end
-
-            mod.module_eval(&Proc.new) if block_given?
-          end
-
-          mod
-        end
       end
 
       # Instance methods for the Roda class.
+      #
+      # In addition to the listed methods, the following two methods are available:
+      #
+      # request :: The instance of the request class related to this request.
+      #            This is the same object yielded by Roda.route.
+      # response :: The instance of the response class related to this request.
       module InstanceMethods
-        # Create a request and response of the appopriate
-        # class, the instance_exec the route block with
-        # the request, handling any halts.  This is not usually
-        # called directly.
-        def call(env, &block)
-          @_request = self.class::RodaRequest.new(self, env)
-          @_response = self.class::RodaResponse.new
-          _route(&block)
+        # Create a request and response of the appopriate class
+        def initialize(env)
+          klass = self.class
+          @_request = klass::RodaRequest.new(self, env)
+          @_response = klass::RodaResponse.new
+        end
+
+        # instance_exec the route block in the scope of the
+        # receiver, with the related request.  Catch :halt so that
+        # the route block can throw :halt at any point with the
+        # rack response to use.
+        def call(&block)
+          catch(:halt) do
+            r = @_request
+            r.block_result(instance_exec(r, &block))
+            @_response.finish
+          end
         end
 
         # The environment hash for the current request. Example:
@@ -317,16 +269,13 @@ class Roda
           self.class.opts
         end
 
-        # The instance of the request class related to this request.
-        # This is the same object yielded by Roda.route.
-        def request
-          @_request
-        end
+        attr_reader :_request # :nodoc:
+        alias request _request
+        remove_method :_request
 
-        # The instance of the response class related to this request.
-        def response
-          @_response
-        end
+        attr_reader :_response # :nodoc:
+        alias response _response
+        remove_method :_response
 
         # The session hash for the current request. Raises RodaError
         # if no session exists. Example:
@@ -335,18 +284,6 @@ class Roda
         def session
           @_request.session
         end
-
-        private
-
-        # Internals of #call, extracted so that plugins can override
-        # behavior after the request and response have been setup.
-        def _route(&block)
-          catch(:halt) do
-            r = @_request
-            r.block_result(instance_exec(r, &block))
-            @_response.finish
-          end
-        end
       end
 
       # Class methods for RodaRequest
@@ -418,6 +355,7 @@ class Roda
         def initialize(scope, env)
           @scope = scope
           @captures = []
+          @remaining_path = env[PATH_INFO]
           super(env)
         end
 
@@ -465,7 +403,7 @@ class Roda
         # executed, and when the match block returns, the rack response is
         # returned.
         # 
-        #   r.path_info
+        #   r.remaining_path
         #   # => "/foo/bar"
         #
         #   r.is 'foo' do
@@ -487,7 +425,7 @@ class Roda
         # Note that this matches only if the path after matching the arguments
         # is empty, not if it still contains a trailing slash:
         #
-        #   r.path_info
+        #   r.remaining_path
         #   # =>  "/foo/bar/"
         #
         #   r.is 'foo/bar' do
@@ -526,7 +464,7 @@ class Roda
         # path, this is usually used to setup branches of the routing tree,
         # not for final handling of the request.
         # 
-        #   r.path_info
+        #   r.remaining_path
         #   # => "/foo/bar"
         #
         #   r.on 'foo' do
@@ -558,7 +496,8 @@ class Roda
 
         # The already matched part of the path, including the original SCRIPT_NAME.
         def matched_path
-          @env[SCRIPT_NAME]
+          e = @env
+          e[SCRIPT_NAME] + e[PATH_INFO].chomp(@remaining_path)
         end
 
         # This an an optimized version of Rack::Request#path.
@@ -572,16 +511,8 @@ class Roda
           "#{e[SCRIPT_NAME]}#{e[PATH_INFO]}"
         end
 
-        def full_path_info
-          RodaPlugins.deprecate("RodaRequest#full_path_info is deprecated and will be removed in Roda 2.  Switch to using #path.")
-          path
-        end
-
-        # The current path to match requests against.  This is the same as PATH_INFO
-        # in the environment, which gets updated as the request is being routed.
-        def remaining_path
-          @env[PATH_INFO]
-        end
+        # The current path to match requests against.
+        attr_reader :remaining_path
 
         # Match POST requests.  If no arguments are provided, matches all POST
         # requests, otherwise, matches only POST requests where the arguments
@@ -637,7 +568,7 @@ class Roda
         # path is +/+.  If it matches, the match block is executed, and when
         # the match block returns, the rack response is returned.
         #
-        #   [r.request_method, r.path_info]
+        #   [r.request_method, r.remaining_path]
         #   # => ['GET', '/']
         #
         #   r.root do
@@ -646,7 +577,7 @@ class Roda
         #
         # This is usuable inside other match blocks:
         #
-        #   [r.request_method, r.path_info]
+        #   [r.request_method, r.remaining_path]
         #   # => ['GET', '/foo/']
         #
         #   r.on 'foo' do
@@ -657,7 +588,7 @@ class Roda
         #
         # Note that this does not match non-+GET+ requests:
         #
-        #   [r.request_method, r.path_info]
+        #   [r.request_method, r.remaining_path]
         #   # => ['POST', '/']
         #
         #   r.root do
@@ -669,7 +600,7 @@ class Roda
         # 
         # Nor does it match empty paths:
         #
-        #   [r.request_method, r.path_info]
+        #   [r.request_method, r.remaining_path]
         #   # => ['GET', '/foo']
         #
         #   r.on 'foo' do
@@ -693,8 +624,25 @@ class Roda
         #   r.run(proc{[403, {}, []]}) unless r['letmein'] == '1'
         #   r.run(proc{[404, {}, []]})
         #   response.status = 404 # not reached
+        #
+        # This updates SCRIPT_NAME/PATH_INFO based on the current remaining_path
+        # before dispatching to another rack app, so the app still works as
+        # a URL mapper.
         def run(app)
-          throw :halt, app.call(@env)
+          e = @env
+          path = @remaining_path
+          sn = SCRIPT_NAME
+          pi = PATH_INFO
+          script_name = e[sn]
+          path_info = e[pi]
+          begin
+            e[sn] += path_info.chomp(path)
+            e[pi] = path
+            throw :halt, app.call(e)
+          ensure
+            e[sn] = script_name
+            e[pi] = path_info
+          end
         end
 
         # The session for the current request.  Raises a RodaError if
@@ -780,7 +728,7 @@ class Roda
         # path from PATH_INFO, and updates captures with any regex captures.
         def consume(pattern)
           if matchdata = remaining_path.match(pattern)
-            update_remaining_path(matchdata.post_match)
+            @remaining_path = matchdata.post_match
             @captures.concat(matchdata.captures)
           end
         end
@@ -813,29 +761,18 @@ class Roda
         # returns the rack response when the block returns.  If any of
         # the match arguments doesn't match, does nothing.
         def if_match(args)
-          keep_remaining_path do
-            # For every block, we make sure to reset captures so that
-            # nesting matchers won't mess with each other's captures.
-            @captures.clear
-
-            return unless match_all(args)
-            block_result(yield(*captures))
-            throw :halt, response.finish
-          end
-        end
-        
-        # Yield to the block, restoring SCRIPT_NAME and PATH_INFO to
-        # their initial values before returning from the block.
-        def keep_remaining_path
-          env = @env
-          script = env[sn = SCRIPT_NAME]
-          path = env[pi = PATH_INFO]
-          yield
+          path = @remaining_path
+          # For every block, we make sure to reset captures so that
+          # nesting matchers won't mess with each other's captures.
+          @captures.clear
+
+          return unless match_all(args)
+          block_result(yield(*captures))
+          throw :halt, response.finish
         ensure
-          env[sn] = script
-          env[pi] = path
+          @remaining_path = path
         end
-
+        
         # Attempt to match the argument to the given request, handling
         # common ruby types.
         def match(matcher)
@@ -864,11 +801,6 @@ class Roda
           args.all?{|arg| match(arg)}
         end
 
-        def match_extension(ext)
-          RodaPlugins.deprecate("The :extension matcher is deprecated and will be removed in Roda 2.  It has been moved to the path_matchers plugin.")
-          consume(self.class.cached_matcher([:extension, ext]){/([^\\\/]+)\.#{ext}/})
-        end
-
         # Match by request method.  This can be an array if you want
         # to match on multiple methods.
         def match_method(type)
@@ -878,29 +810,6 @@ class Roda
             type.to_s.upcase == @env[REQUEST_METHOD]
           end
         end
-
-        def match_param(key)
-          RodaPlugins.deprecate("The :param matcher is deprecated and will be removed in Roda 2.  It has been moved to the param_matchers plugin.")
-          if v = self[key]
-            @captures << v
-          end
-        end
-
-        def match_param!(key)
-          RodaPlugins.deprecate("The :param! matcher is deprecated and will be removed in Roda 2.  It has been moved to the param_matchers plugin.")
-          if (v = self[key]) && !v.empty?
-            @captures << v
-          end
-        end
-
-        # Update PATH_INFO and SCRIPT_NAME based on the matchend and remaining variables.
-        def update_remaining_path(remaining)
-          e = @env
-
-          # Don't mutate SCRIPT_NAME, breaks try
-          e[SCRIPT_NAME] += e[pi = PATH_INFO].chomp(remaining)
-          e[pi] = remaining
-        end
       end
 
       # Class methods for RodaResponse
@@ -959,11 +868,6 @@ class Roda
           DEFAULT_HEADERS
         end
 
-        def delete_cookie(key, value = {})
-          RodaPlugins.deprecate("RodaResponse#delete_cookie is deprecated and will be removed in Roda 2.  It has been moved to the cookies plugin.")
-          ::Rack::Utils.delete_cookie_header!(@headers, key, value)
-        end
-
         # Whether the response body has been written to yet.  Note
         # that writing an empty string to the response body marks
         # the response as not empty. Example:
@@ -1025,11 +929,6 @@ class Roda
           self.class.roda_class
         end
 
-        def set_cookie(key, value)
-          RodaPlugins.deprecate("RodaResponse#set_cookie is deprecated and will be removed in Roda 2.  It has been moved to the cookies plugin.")
-          ::Rack::Utils.set_cookie_header!(@headers, key, value)
-        end
-
         # Write to the response body.  Returns nil.
         #
         #   response.write('foo')

data/spec/matchers_spec.rb

@@ -291,20 +291,48 @@ describe "r.on" do
     body("/123").should == '+1'
   end
 
-  it "ensures SCRIPT_NAME and PATH_INFO are reverted" do
+  it "ensures remaining_path is reverted if modified in failing matcher" do
     app do |r|
-      r.on lambda { r.env["SCRIPT_NAME"] = "/hello"; false } do
+      r.on lambda { @remaining_path = "/blah"; false } do
         "Unreachable"
       end
       
       r.on do
-        r.env["SCRIPT_NAME"] + ':' + r.env["PATH_INFO"]
+        r.matched_path + ':' + r.remaining_path
       end
     end
 
     body("/hello").should == ':/hello'
   end
 
+  it "modifies matched_path/remaining_path during routing" do
+    app do |r|
+      r.on 'login', 'foo' do 
+        "Unreachable"
+      end
+      
+      r.on 'hello' do
+        r.matched_path + ':' + r.remaining_path
+      end
+    end
+
+    body("/hello/you").should == '/hello:/you'
+  end
+
+  it "doesn't modify SCRIPT_NAME/PATH_INFO during routing" do
+    app do |r|
+      r.on 'login', 'foo' do 
+        "Unreachable"
+      end
+      
+      r.on 'hello' do
+        r.env["SCRIPT_NAME"] + ':' + r.env["PATH_INFO"]
+      end
+    end
+
+    body("/hello/you").should == ':/hello/you'
+  end
+
   it "doesn't mutate SCRIPT_NAME or PATH_INFO after request is returned" do
     app do |r|
       r.on 'login', 'foo' do 
@@ -377,44 +405,6 @@ describe "r.on" do
   end
 end
 
-describe "param! matcher" do
-  it "should yield a param only if given and not empty" do
-    app do |r|
-      r.get "signup", :param! => "email" do |email|
-        email
-      end
-
-      r.on do
-        "No email"
-      end
-    end
-
-    io = StringIO.new
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").should == 'john@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "").should == 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").should == 'No email'
-  end
-end
-
-describe "param matcher" do
-  it "should yield a param only if given" do
-    app do |r|
-      r.get "signup", :param=>"email" do |email|
-        email
-      end
-
-      r.on do
-        "No email"
-      end
-    end
-
-    io = StringIO.new
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").should == 'john@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "").should == 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").should == ''
-  end
-end
-
 describe "path matchers" do 
   it "one level path" do
     app do |r|
@@ -644,21 +634,6 @@ describe "all matcher" do
   end
 end
 
-describe "extension matcher" do
-  it "should match given file extensions" do
-    app do |r|
-      r.on "css" do
-        r.on :extension=>"css" do |file|
-          file
-        end
-      end
-    end
-
-    body("/css/reset.css").should == 'reset'
-    status("/css/reset.bar").should == 404
-  end
-end
-
 describe "method matcher" do
   it "should match given request types" do
     app do |r|
@@ -686,29 +661,3 @@ describe "route block that returns string" do
     body.should == '+1'
   end
 end
-
-describe "hash_matcher" do
-  it "should enable the handling of arbitrary hash keys" do
-    app(:bare) do 
-      hash_matcher(:foos){|v| consume(self.class.cached_matcher(:"foos-#{v}"){/((?:foo){#{v}})/})}
-      route do |r|
-        r.is :foos=>1 do |f|
-          "1#{f}"
-        end
-        r.is :foos=>2 do |f|
-          "2#{f}"
-        end
-        r.is :foos=>3 do |f|
-          "3#{f}"
-        end
-      end
-    end
-
-    body("/foo").should == '1foo'
-    body("/foofoo").should == '2foofoo'
-    body("/foofoofoo").should == '3foofoofoo'
-    status("/foofoofoofoo").should == 404
-    status.should == 404
-  end
-end
-

data/spec/plugin/assets_spec.rb

@@ -332,11 +332,11 @@ if run_tests
     end
 
     it '#assets should include attributes given' do
-      app.new.assets([:js, :head], 'a'=>'b').should == '<script type="text/javascript" a="b" src="/assets/js/head/app.js"></script>'
+      app.allocate.assets([:js, :head], 'a'=>'b').should == '<script type="text/javascript" a="b" src="/assets/js/head/app.js"></script>'
     end
 
     it '#assets should escape attribute values given' do
-      app.new.assets([:js, :head], 'a'=>'b"e').should == '<script type="text/javascript" a="b&quot;e" src="/assets/js/head/app.js"></script>'
+      app.allocate.assets([:js, :head], 'a'=>'b"e').should == '<script type="text/javascript" a="b&quot;e" src="/assets/js/head/app.js"></script>'
     end
 
     it 'requests for assets should return 304 if the asset has not been modified' do
@@ -397,17 +397,17 @@ if run_tests
     it 'should support :precompiled option' do
       app.plugin :assets, :precompiled=>metadata_file
       File.exist?(metadata_file).should == false
-      app.new.assets([:js, :head]).should == '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
+      app.allocate.assets([:js, :head]).should == '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
 
       app.compile_assets
       File.exist?(metadata_file).should == true
-      app.new.assets([:js, :head]).should =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
+      app.allocate.assets([:js, :head]).should =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
 
       app.plugin :assets, :compiled=>false, :precompiled=>false
-      app.new.assets([:js, :head]).should == '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
+      app.allocate.assets([:js, :head]).should == '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
 
       app.plugin :assets, :precompiled=>metadata_file
-      app.new.assets([:js, :head]).should =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
+      app.allocate.assets([:js, :head]).should =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
     end
   end
 end

data/spec/plugin/error_handler_spec.rb

@@ -24,6 +24,29 @@ describe "error_handler plugin" do
     status.should == 500
   end
 
+  it "executes on SyntaxError exceptions" do
+    app(:bare) do
+      plugin :error_handler
+
+      error do |e|
+        e.message
+      end
+
+      route do |r|
+        r.on "a" do
+          "found"
+        end
+
+        raise SyntaxError, 'bad idea'
+      end
+    end
+
+    body("/a").should == 'found'
+    status("/a").should == 200
+    body.should == 'bad idea'
+    status.should == 500
+  end
+
   it "can override status inside error block" do
     app(:bare) do
       plugin :error_handler do |e|

data/spec/plugin/halt_spec.rb

@@ -25,6 +25,18 @@ describe "halt plugin" do
     status.should == 300 
   end
 
+  it "should consider other single arguments similar to block bodies" do
+    app(:bare) do
+      plugin :halt
+      plugin :json
+      route do |r|
+        r.halt({'a'=>1})
+      end
+    end
+
+    body.should ==  '{"a":1}'
+  end
+
   it "should consider 2 arguments as response status and body" do
     app(:halt) do |r|
       r.halt 300, "foo"
@@ -34,6 +46,19 @@ describe "halt plugin" do
     body.should == "foo"
   end
 
+  it "should handle 2nd of 2 arguments similar to block bodies" do
+    app(:bare) do
+      plugin :halt
+      plugin :json
+      route do |r|
+        r.halt(300, {'a'=>1})
+      end
+    end
+
+    status.should == 300 
+    body.should ==  '{"a":1}'
+  end
+
   it "should consider 3 arguments as response" do
     app(:halt) do |r|
       r.halt 300, {'a'=>'b'}, "foo"
@@ -44,6 +69,20 @@ describe "halt plugin" do
     body.should == "foo"
   end
 
+  it "should handle 3rd of 3 arguments similar to block bodies" do
+    app(:bare) do
+      plugin :halt
+      plugin :json
+      route do |r|
+        r.halt(300, {'a'=>'b'}, {'a'=>1})
+      end
+    end
+
+    status.should == 300 
+    header('a').should == 'b'
+    body.should ==  '{"a":1}'
+  end
+
   it "should raise an error for too many arguments" do
     app(:halt) do |r|
       r.halt 300, {'a'=>'b'}, "foo", 1