roda 1.2.0 → 1.3.0

data/lib/roda/plugins/multi_run.rb

@@ -34,20 +34,26 @@ class Roda
     module MultiRun
       # Initialize the storage for the dispatched applications
       def self.configure(app)
-        app.instance_eval do
-          @multi_run_apps ||= {}
-        end
+        app.opts[:multi_run_apps] ||= {}
       end
 
       module ClassMethods
+        # Freeze the multi_run apps so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:multi_run_apps].freeze
+          super
+        end
+
         # Hash storing rack applications to dispatch to, keyed by the prefix
         # for the application.
-        attr_reader :multi_run_apps
+        def multi_run_apps
+          opts[:multi_run_apps]
+        end
 
         # Add a rack application to dispatch to for the given prefix when
         # r.multi_run is called.
         def run(prefix, app)
-          @multi_run_apps[prefix.to_s] = app
+          multi_run_apps[prefix.to_s] = app
           self::RodaRequest.refresh_multi_run_regexp!
         end
       end

data/lib/roda/plugins/named_templates.rb

@@ -58,9 +58,15 @@ class Roda
       end
 
       module ClassMethods
+        # Freeze the named templates so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:named_templates].freeze
+          super
+        end
+
         # Store a new template block and options for the given template name.
         def template(name, options=nil, &block)
-          opts[:named_templates][name.to_s] = [options, block]
+          opts[:named_templates][name.to_s] = [options, block].freeze
           nil
         end
       end

data/lib/roda/plugins/not_found.rb

@@ -18,6 +18,11 @@ class Roda
     #   not_found do
     #     "Where did it go?"
     #   end
+    #
+    # Before not_found is called, any existing headers on the response
+    # will be cleared.  So if you want to be sure the headers are set
+    # even in a not_found block, you need to reset them in the
+    # not_found block.
     module NotFound
       # If a block is given, install the block as the not_found handler.
       def self.configure(app, &block)
@@ -43,6 +48,7 @@ class Roda
           result = super
 
           if result[0] == 404 && (v = result[2]).is_a?(Array) && v.empty?
+            @_response.headers.clear
             super{not_found}
           else
             result

data/lib/roda/plugins/param_matchers.rb

@@ -0,0 +1,43 @@
+class Roda
+  module RodaPlugins
+    # The param_matchers plugin adds hash matchers that operate
+    # on the request's params.
+    #
+    # It adds a :param matcher for matching on any param with the
+    # same name, yielding the value of the param.
+    #
+    #   r.on :param=>'foo' do |value|
+    #     # Matches '?foo=bar', '?foo='
+    #     # Doesn't match '?bar=foo'
+    #   end
+    #
+    # It adds a :param! matcher for matching on any non-empty param
+    # with the same name, yielding the value of the param
+    #
+    #   r.on :param!=>'foo' do |value|
+    #     # Matches '?foo=bar'
+    #     # Doesn't match '?foo=', '?bar=foo'
+    #   end
+    module ParamMatchers
+      module RequestMethods
+        # Match the given parameter if present, even if the parameter is empty.
+        # Adds any match to the captures.
+        def match_param(key)
+          if v = self[key]
+            @captures << v
+          end
+        end
+
+        # Match the given parameter if present and not empty.
+        # Adds any match to the captures.
+        def match_param!(key)
+          if (v = self[key]) && !v.empty?
+            @captures << v
+          end
+        end
+      end
+    end
+
+    register_plugin(:param_matchers, ParamMatchers)
+  end
+end

data/lib/roda/plugins/path_matchers.rb

@@ -0,0 +1,51 @@
+class Roda
+  module RodaPlugins
+    # The path_matchers plugin adds hash matchers that operate
+    # on the request's path.
+    #
+    # It adds a :prefix matcher for matching on the path's prefix,
+    # yielding the rest of the matched segment:
+    #
+    #   r.on :prefix=>'foo' do |suffix|
+    #     # Matches '/foo-bar', yielding '-bar'
+    #     # Does not match bar-foo
+    #   end
+    #
+    # It adds a :suffix matcher for matching on the path's suffix,
+    # yielding the part of the segment before the suffix:
+    #
+    #   r.on :suffix=>'bar' do |prefix|
+    #     # Matches '/foo-bar', yielding 'foo-'
+    #     # Does not match bar-foo
+    #   end
+    #
+    # It adds an :extension matcher for matching on the given file extension,
+    # yielding the part of the segment before the extension:
+    #
+    #   r.on :extension=>'bar' do |reset|
+    #     # Matches '/foo.bar', yielding 'foo'
+    #     # Does not match bar.foo
+    #   end
+    module PathMatchers
+      module RequestMethods
+        # Match when the current segment ends with the given extension.
+        # request path end with the extension.
+        def match_extension(ext)
+          match_suffix(".#{ext}")
+        end
+
+        # Match when the current path segment starts with the given prefix.
+        def match_prefix(prefix)
+          consume(self.class.cached_matcher([:prefix, prefix]){/#{prefix}([^\\\/]+)/})
+        end
+
+        # Match when the current path segment ends with the given suffix.
+        def match_suffix(suffix)
+          consume(self.class.cached_matcher([:suffix, suffix]){/([^\\\/]+)#{suffix}/})
+        end
+      end
+    end
+
+    register_plugin(:path_matchers, PathMatchers)
+  end
+end

data/lib/roda/plugins/render.rb

@@ -36,8 +36,8 @@ class Roda
     # :layout :: The base name of the layout file, defaults to 'layout'.
     # :layout_opts :: The options to use when rendering the layout, if different
     #                 from the default options.
-    # :opts :: The tilt options used when rendering templates, defaults to
-    #          <tt>{:outvar=>'@_out_buf', :default_encoding=>Encoding.default_external}</tt>.
+    # :template_opts :: The tilt options used when rendering templates, defaults to
+    #                   <tt>{:outvar=>'@_out_buf', :default_encoding=>Encoding.default_external}</tt>.
     # :views :: The directory holding the view files, defaults to 'views' in the
     #           current directory.
     #
@@ -86,11 +86,16 @@ class Roda
       # Setup default rendering options.  See Render for details.
       def self.configure(app, opts=OPTS)
         if app.opts[:render]
-          app.opts[:render].merge!(opts)
+          app.opts[:render] = app.opts[:render].merge(opts)
         else
           app.opts[:render] = opts.dup
         end
 
+        if opts[:opts] && !opts[:template_opts]
+          RodaPlugins.deprecate("The render plugin :opts option is deprecated and will be removed in Roda 2.  Switch to using the :template_opts option")
+          app.opts[:render][:template_opts] = opts[:opts]
+        end
+
         opts = app.opts[:render]
         opts[:engine] ||= "erb"
         opts[:ext] = nil unless opts.has_key?(:ext)
@@ -103,15 +108,18 @@ class Roda
           opts[:layout_opts] = opts[:layout_opts].merge(layout)
         end
 
-        opts[:opts] ||= (opts[:opts] || {}).dup
-        opts[:opts][:outvar] ||= '@_out_buf'
-        if RUBY_VERSION >= "1.9" && !opts[:opts].has_key?(:default_encoding)
-          opts[:opts][:default_encoding] = Encoding.default_external
+        template_opts = opts[:template_opts] = (opts[:template_opts] || {}).dup
+        template_opts[:outvar] ||= '@_out_buf'
+        if RUBY_VERSION >= "1.9" && !template_opts.has_key?(:default_encoding)
+          template_opts[:default_encoding] = Encoding.default_external
         end
         if opts[:escape]
-          opts[:opts][:engine_class] = ErubisEscaping::Eruby
+          template_opts[:engine_class] = ErubisEscaping::Eruby
         end
         opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, ENV['RACK_ENV'] != 'development')
+        opts.extend(RodaDeprecateMutation)
+        opts[:layout_opts].extend(RodaDeprecateMutation)
+        opts[:template_opts].extend(RodaDeprecateMutation)
       end
 
       module ClassMethods
@@ -120,10 +128,11 @@ class Roda
         # affecting the parent class.
         def inherited(subclass)
           super
-          opts = subclass.opts[:render]
-          opts[:layout_opts] = opts[:layout_opts].dup
-          opts[:opts] = opts[:opts].dup
+          opts = subclass.opts[:render].dup
+          opts[:layout_opts] = opts[:layout_opts].dup.extend(RodaDeprecateMutation)
+          opts[:template_opts] = opts[:template_opts].dup.extend(RodaDeprecateMutation)
           opts[:cache] = thread_safe_cache if opts[:cache]
+          subclass.opts[:render] = opts.extend(RodaDeprecateMutation)
         end
 
         # Return the render options for this class.
@@ -137,8 +146,13 @@ class Roda
         def render(template, opts = OPTS, &block)
           opts = find_template(parse_template_opts(template, opts))
           cached_template(opts) do
-            template_opts = render_opts[:opts]
-            template_opts = template_opts.merge(opts[:opts]) if opts[:opts]
+            template_opts = render_opts[:template_opts]
+            current_template_opts = opts[:template_opts]
+            if opts[:opts] && !current_template_opts
+              RodaPlugins.deprecate("The render method :opts option is deprecated and will be removed in Roda 2.  Switch to using the :template_opts option")
+              current_template_opts = opts[:opts]
+            end
+            template_opts = template_opts.merge(current_template_opts) if current_template_opts
             opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
           end.render(self, (opts[:locals]||OPTS), &block)
         end
@@ -199,7 +213,11 @@ class Roda
           end
 
           if render_opts[:cache]
-            template_opts = opts[:opts]
+            template_opts = opts[:template_opts]
+            if opts[:opts] && !template_opts
+              RodaPlugins.deprecate("The render method :opts option is deprecated and will be removed in Roda 2.  Switch to using the :template_opts option")
+              template_opts = opts[:opts]
+            end
             template_block = opts[:template_block] if !content
 
             key = if template_class || template_opts || template_block

data/lib/roda/plugins/static_path_info.rb

@@ -36,9 +36,16 @@ class Roda
         def run(_)
           e = @env
           path = @remaining_path
-          e[SCRIPT_NAME] += e[PATH_INFO].chomp(path)
-          e[PATH_INFO] = path
-          super
+          begin
+            script_name = e[SCRIPT_NAME]
+            path_info = e[PATH_INFO]
+            e[SCRIPT_NAME] += path_info.chomp(path)
+            e[PATH_INFO] = path
+            super
+          ensure
+            e[SCRIPT_NAME] = script_name
+            e[PATH_INFO] = path_info
+          end
         end
 
         private

data/lib/roda/plugins/symbol_matchers.rb

@@ -54,7 +54,7 @@ class Roda
       module ClassMethods
         # Set the regexp to use for the given symbol, instead of the default.
         def symbol_matcher(s, re)
-          request_module{define_method(:"match_symbol_#{s}"){re}}
+          self::RodaRequest.send(:define_method, :"match_symbol_#{s}"){re}
         end
       end
 

data/lib/roda/version.rb

@@ -1,3 +1,15 @@
 class Roda
-  RodaVersion = '1.2.0'.freeze
+  # The major version of Roda, updated only for major changes that are
+  # likely to require modification to Roda apps.
+  RodaMajorVersion = 1
+
+  # The minor version of Roda, updated for new feature releases of Roda.
+  RodaMinorVersion = 3
+
+  # The patch version of Roda, updated only for bug fixes from the last
+  # feature release.
+  RodaPatchVersion = 0
+
+  # The full version of Roda as a string.
+  RodaVersion = "#{RodaMajorVersion}.#{RodaMinorVersion}.#{RodaPatchVersion}".freeze
 end

data/spec/freeze_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe "Roda.freeze" do
+  before do
+    app{}.freeze
+  end
+
+  it "should make opts not be modifiable after calling finalize!" do
+    proc{app.opts[:foo] = 'bar'}.should raise_error
+  end
+
+  it "should make use and route raise errors" do
+    proc{app.use Class.new}.should raise_error
+    proc{app.route{}}.should raise_error
+  end
+
+  it "should make plugin raise errors" do
+    proc{app.plugin Module.new}.should raise_error
+  end
+
+  it "should make subclassing raise errors" do
+    proc{Class.new(app)}.should raise_error
+  end
+
+  it "should freeze app" do
+    app.frozen?.should == true
+  end
+end

data/spec/plugin/class_level_routing_spec.rb

@@ -135,4 +135,30 @@ describe "class_level_routing plugin" do
     status("/asdfa/asdf").should == 404
     body("/asdfa/asdf").should == "nf"
   end
+
+  it "works when freezing the app" do
+    app.freeze
+    body.should == 'root'
+    body('/foo').should == 'foo'
+    body('/foo/bar').should == 'foobar'
+    body('/dgo').should == 'bazgetgo'
+    body('/dgo', 'REQUEST_METHOD'=>'POST').should == 'bazpostgo'
+    body('/bar').should == "x-get-bar"
+    body('/bar', 'REQUEST_METHOD'=>'POST').should == "x-post-bar"
+    body('/bar', 'REQUEST_METHOD'=>'DELETE').should == "x-delete-bar"
+    body('/bar', 'REQUEST_METHOD'=>'HEAD').should == "x-head-bar"
+    body('/bar', 'REQUEST_METHOD'=>'OPTIONS').should == "x-options-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PATCH').should == "x-patch-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PUT').should == "x-put-bar"
+    body('/bar', 'REQUEST_METHOD'=>'TRACE').should == "x-trace-bar"
+    if ::Rack::Request.method_defined?("link?")
+      body('/bar', 'REQUEST_METHOD'=>'LINK').should == "x-link-bar"
+      body('/bar', 'REQUEST_METHOD'=>'UNLINK').should == "x-unlink-bar"
+    end
+
+    status.should == 200
+    status("/asdfa/asdf").should == 404
+
+    proc{app.on{}}.should raise_error
+  end
 end

data/spec/plugin/content_for_spec.rb

@@ -8,8 +8,7 @@ else
 describe "content_for plugin" do
   before do
     app(:bare) do
-      plugin :render
-      render_opts[:views] = "./spec/views"
+      plugin :render, :views=>'./spec/views'
       plugin :content_for
 
       route do |r|

data/spec/plugin/cookies_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "cookies plugin" do 
+  it "should set cookies on response" do
+    app(:cookies) do |r|
+      response.set_cookie("foo", "bar")
+      response.set_cookie("bar", "baz")
+      "Hello"
+    end
+
+    header('Set-Cookie').should == "foo=bar\nbar=baz"
+    body.should == 'Hello'
+  end
+
+  it "should delete cookies on response" do
+    app(:cookies) do |r|
+      response.set_cookie("foo", "bar")
+      response.delete_cookie("foo")
+      "Hello"
+    end
+
+    header('Set-Cookie').should =~ /foo=; (max-age=0; )?expires=Thu, 01[ -]Jan[ -]1970 00:00:00 (-0000|GMT)/
+    body.should == 'Hello'
+  end
+end

data/spec/plugin/default_headers_spec.rb

@@ -30,11 +30,10 @@ describe "default_headers plugin" do
     req[1].should == h
   end
 
-  it "should allow modifying the default headers at a later point" do
+  it "should allow modifying the default headers by reloading the plugin" do
     app(:bare) do
-      plugin :default_headers
-      default_headers['Content-Type'] = 'text/json'
-      default_headers['Foo'] = 'baz'
+      plugin :default_headers, 'Content-Type' => 'text/json'
+      plugin :default_headers, 'Foo' => 'baz'
 
       route do |r|
         r.halt response.finish_with_body([])
@@ -48,9 +47,7 @@ describe "default_headers plugin" do
     h = {'Content-Type'=>'text/json', 'Foo'=>'bar'}
 
     app(:bare) do
-      plugin :default_headers
-      default_headers['Content-Type'] = 'text/json'
-      default_headers['Foo'] = 'bar'
+      plugin :default_headers, h
 
       route do |r|
         r.halt response.finish_with_body([])

data/spec/plugin/delegate_spec.rb

@@ -7,9 +7,12 @@ describe "delegate plugin" do
       request_delegate :root
       response_delegate :headers
 
+      def self.a; 'foo'; end
+      class_delegate :a
+
       route do
         root do
-          headers['Content-Type'] = 'foo'
+          headers['Content-Type'] = a
         end
       end
     end