roda 1.2.0 → 1.3.0

data/lib/roda/plugins/class_level_routing.rb

@@ -58,9 +58,15 @@ class Roda
         # Define routing methods that will store class level routes.
         [:root, :on, :is, :get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |meth|
           define_method(meth) do |*args, &block|
-            opts[:class_level_routes] << [meth, args, block]
+            opts[:class_level_routes] << [meth, args, block].freeze
           end
         end
+
+        # Freeze the class level routes so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:class_level_routes].freeze
+          super
+        end
       end
 
       module InstanceMethods

data/lib/roda/plugins/cookies.rb

@@ -0,0 +1,34 @@
+class Roda
+  module RodaPlugins
+    # The cookies plugin adds response methods for handling cookies.
+    # Currently, you can set cookies with +set_cookie+ and delete cookies
+    # with +delete_cookie+:
+    #
+    #   response.set_cookie('foo', 'bar')
+    #   response.delete_cookie('foo')
+    module Cookies
+      module ResponseMethods
+        # Modify the headers to include a Set-Cookie value that
+        # deletes the cookie.  A value hash can be provided to
+        # override the default one used to delete the cookie.
+        # Example:
+        #
+        #   response.delete_cookie('foo')
+        #   response.delete_cookie('foo', :domain=>'example.org')
+        def delete_cookie(key, value = {})
+          ::Rack::Utils.delete_cookie_header!(@headers, key, value)
+        end
+
+        # Set the cookie with the given key in the headers.
+        #
+        #   response.set_cookie('foo', 'bar')
+        #   response.set_cookie('foo', :value=>'bar', :domain=>'example.org')
+        def set_cookie(key, value)
+          ::Rack::Utils.set_cookie_header!(@headers, key, value)
+        end
+      end
+    end
+
+    register_plugin(:cookies, Cookies)
+  end
+end

data/lib/roda/plugins/default_headers.rb

@@ -12,15 +12,16 @@ class Roda
     #
     #   plugin :default_headers, 'Content-Type'=>'text/csv'
     #
-    # You can also modify the default headers later:
+    # You can modify the default headers later by loading the
+    # plugin again:
     #
-    #   plugin :default_headers
-    #   default_headers['Foo'] = 'bar'
-    #   default_headers.merge!('Bar'=>'baz')
+    #   plugin :default_headers, 'Foo'=>'bar'
+    #   plugin :default_headers, 'Bar'=>'baz'
     module DefaultHeaders
       # Merge the given headers into the existing default headers, if any.
       def self.configure(app, headers={})
-        (app.opts[:default_headers] ||= {}).merge!(headers)
+        app.opts[:default_headers] = (app.opts[:default_headers] || {}).merge(headers)
+        app.opts[:default_headers].extend(RodaDeprecateMutation)
       end 
 
       module ClassMethods
@@ -33,7 +34,7 @@ class Roda
       module ResponseMethods
         # Get the default headers from the related roda class.
         def default_headers
-          roda_class.default_headers.dup
+          roda_class.default_headers
         end
       end
     end

data/lib/roda/plugins/delegate.rb

@@ -2,7 +2,7 @@ class Roda
   module RodaPlugins
     # The delegate plugin allows you to easily setup instance methods in
     # the scope of the route block that call methods on the related
-    # request or response, which may offer a simpler API in some cases.
+    # request, response, or class which may offer a simpler API in some cases.
     # Roda doesn't automatically setup such delegate methods because
     # it pollutes the application's method namespace, but this plugin
     # allows the user to do so.
@@ -43,6 +43,13 @@ class Roda
     #   end
     module Delegate
       module ClassMethods
+        # Delegate the given methods to the class
+        def class_delegate(*meths)
+          meths.each do |meth|
+            define_method(meth){|*a, &block| self.class.send(meth, *a, &block)}
+          end
+        end
+
         # Delegate the given methods to the request
         def request_delegate(*meths)
           meths.each do |meth|

data/lib/roda/plugins/delete_empty_headers.rb

@@ -0,0 +1,33 @@
+class Roda
+  module RodaPlugins
+    # The delete_empty_headers plugin deletes any headers whose
+    # value is set to the empty string.  Because of how default headers are
+    # set in Roda, if you have a default header but don't want
+    # to set it for a specific request, you need to use this plugin
+    # and set the header value to the empty string, and Roda will automatically
+    # delete the header.
+    module DeleteEmptyHeaders
+      module ResponseMethods
+        # Delete any empty headers when calling finish
+        def finish
+          delelete_empty_headers(super)
+        end
+
+        # Delete any empty headers when calling finish_with_body
+        def finish_with_body(_)
+          delelete_empty_headers(super)
+        end
+
+        private
+
+        # Delete any empty headers from response
+        def delelete_empty_headers(res)
+          res[1].delete_if{|_, v| v.is_a?(String) && v.empty?}
+          res
+        end
+      end
+    end
+
+    register_plugin(:delete_empty_headers, DeleteEmptyHeaders)
+  end
+end

data/lib/roda/plugins/delete_nil_headers.rb

@@ -0,0 +1,34 @@
+class Roda
+  module RodaPlugins
+    # The delete_nil_headers plugin deletes any headers whose
+    # value is set to nil.  Because of how default headers are
+    # set in Roda, if you have a default header but don't want
+    # to set it for a specific request, you need to use this plugin
+    # and set the value to nil so that 
+    #
+    # The following example will return "<foo>" as the body.
+    #
+    #   plugin :h
+    #
+    #   route do |r|
+    #     h('<foo>')
+    #   end
+    module DeleteHeaders
+      module ResponseMethods
+        def finish
+          res = super
+          res[1].delete_if{|_, v| v.nil?}
+          res
+        end
+
+        def finish_with_body(_)
+          res = super
+          res[1].delete_if{|_, v| v.nil?}
+          res
+        end
+      end
+    end
+
+    register_plugin(:delete_headers, DeleteHeaders)
+  end
+end

data/lib/roda/plugins/environments.rb

@@ -45,10 +45,6 @@ class Roda
       end
 
       module ClassMethods
-        # The current environment for the application, which should be stored
-        # as a symbol.
-        attr_accessor :environment
-
         # If no environments are given or one of the given environments
         # matches the current environment, yield the receiver to the block.
         def configure(*envs)
@@ -57,6 +53,18 @@ class Roda
           end
         end
 
+        # The current environment for the application, which should be stored
+        # as a symbol.
+        def environment
+          opts[:environment]
+        end
+
+        # Override the environment for the application, instead of using
+        # RACK_ENV.
+        def environment=(v)
+          opts[:environment] = v
+        end
+
         [:development, :test, :production].each do |env|
           define_method("#{env}?"){environment == env}
         end

data/lib/roda/plugins/error_email.rb

@@ -77,10 +77,13 @@ END
       def self.configure(app, opts={})
         email_opts = app.opts[:error_email] ||= DEFAULTS
         email_opts = email_opts.merge(opts)
+        email_opts[:headers] = email_opts[:headers].dup
         unless email_opts[:to] && email_opts[:from]
           raise RodaError, "must provide :to and :from options to error_email plugin"
         end
         app.opts[:error_email] = email_opts
+        app.opts[:error_email].extend(RodaDeprecateMutation)
+        app.opts[:error_email][:headers].extend(RodaDeprecateMutation)
       end
 
       module ClassMethods
@@ -88,7 +91,9 @@ END
         # the superclass.
         def inherited(subclass)
           super
-          subclass.opts[:error_email][:headers] = subclass.opts[:error_email][:headers].dup
+          opts = subclass.opts[:error_email].dup
+          opts[:headers] = opts[:headers].dup.extend(RodaDeprecateMutation)
+          subclass.opts[:error_email] = opts.extend(RodaDeprecateMutation)
         end
       end
 

data/lib/roda/plugins/error_handler.rb

@@ -21,9 +21,11 @@ class Roda
     # In both cases, the exception instance is passed into the block,
     # and the block can return the request body via a string.
     #
-    # If an exception is raised, the response status will be set to 500
-    # before executing the error handler.  The error handler can change
-    # the response status if necessary.
+    # If an exception is raised, a new response will be used, with the
+    # default status set to 500, before executing the error handler.
+    # The error handler can change the response status if necessary,
+    # as well set headers and/or write to the body, just like a regular
+    # request.
     module ErrorHandler
       # If a block is given, automatically call the +error+ method on
       # the Roda class with it.
@@ -51,7 +53,8 @@ class Roda
         def _route
           super
         rescue => e
-          @_response.status = 500
+          res = @_response = self.class::RodaResponse.new
+          res.status = 500
           super{handle_error(e)}
         end
 

data/lib/roda/plugins/hash_matcher.rb

@@ -0,0 +1,32 @@
+class Roda
+  module RodaPlugins
+    # The hash_matcher plugin adds the hash_matcher class method, which
+    # allows for easily defining hash matchers:
+    #
+    #   class App < Roda
+    #     hash_matcher(:foo) do |v|
+    #       self['foo'] == v
+    #     end
+    #
+    #     route do
+    #       r.on :foo=>'bar' do
+    #         # matches when param foo has value bar
+    #       end
+    #     end
+    #   end
+    module HashMatcher
+      module ClassMethods
+        # Create a match_#{key} method in the request class using the given
+        # block, so that using a hash key in a request match method will
+        # call the block.  The block should return nil or false to not
+        # match, and anything else to match.  See the HashMatcher module
+        # documentation for an example.
+        def hash_matcher(key, &block)
+          self::RodaRequest.send(:define_method, :"match_#{key}", &block)
+        end
+      end
+    end
+
+    register_plugin(:hash_matcher, HashMatcher)
+  end
+end

data/lib/roda/plugins/header_matchers.rb

@@ -15,6 +15,8 @@ class Roda
     #
     #   r.on :host=>'foo.example.com' do
     #   end
+    #   r.on :host=>/\A\w+.example.com/ do
+    #   end
     #
     # It adds a +:user_agent+ matcher for matching on a user agent patterns, which
     # yields the regexp captures to the block:
@@ -42,10 +44,18 @@ class Roda
 
         # Match if the given uppercase key is present inside the environment.
         def match_header(key)
-          @env[key.upcase.tr("-","_")]
+          if v = @env[key.upcase.tr("-","_")]
+            if roda_class.opts[:match_header_yield]
+              @captures << v
+            else
+              RodaPlugins.deprecate("The :header hash matcher will yield the header value in Roda 2.  To turn on the Roda 2 behavior, set opts[:match_header_yield] to true for your Roda class.")
+            end
+          end
+          v
         end
 
-        # Match if the host of the request is the same as the hostname.
+        # Match if the host of the request is the same as the hostname.  +hostname+
+        # can be a regexp or a string.
         def match_host(hostname)
           hostname === host
         end

data/lib/roda/plugins/json.rb

@@ -28,15 +28,18 @@ class Roda
     #   end
     #
     # By default, only arrays and hashes are handled, but you
-    # can automatically convert other types to json by adding
-    # them to json_result_classes:
+    # can specifically set the allowed classes to json by adding
+    # using the :classes option when loading the plugin:
     #
-    #   plugin :json
-    #   json_result_classes << Sequel::Model
+    #   plugin :json, :classes=>[Array, Hash, Sequel::Model]
     module Json
       # Set the classes to automatically convert to JSON
-      def self.configure(app)
-        app.opts[:json_result_classes] ||= [Array, Hash]
+      def self.configure(app, opts={})
+        classes = opts[:classes] || [Array, Hash]
+        app.opts[:json_result_classes] ||= []
+        app.opts[:json_result_classes] += classes
+        app.opts[:json_result_classes].uniq!
+        app.opts[:json_result_classes].extend(RodaDeprecateMutation)
       end
 
       module ClassMethods

data/lib/roda/plugins/module_include.rb

@@ -0,0 +1,92 @@
+class Roda
+  module RodaPlugins
+    # The module_include plugin adds request_module and response_module class methods
+    # for adding modules/methods to request/response classes.  It's designed to make
+    # it easier to add request/response methods for a given roda class.  To add a module
+    # to the request or response class:
+    #
+    #   Roda.request_module SomeRequestModule
+    #   Roda.response_module SomeResponseModule
+    #
+    # Alternatively, you can pass a block to the methods and it will create a module
+    # automatically:
+    #
+    #   Roda.request_module do
+    #     def description
+    #       "#{request_method} #{path_info}"
+    #     end
+    #   end
+    module ModuleInclude
+      module ClassMethods
+        # Include the given module in the request class. If a block
+        # is provided instead of a module, create a module using the
+        # the block. Example:
+        #
+        #   Roda.request_module SomeModule
+        #
+        #   Roda.request_module do
+        #     def description
+        #       "#{request_method} #{path_info}"
+        #     end
+        #   end
+        #
+        #   Roda.route do |r|
+        #     r.description
+        #   end
+        def request_module(mod = nil, &block)
+          module_include(:request, mod, &block)
+        end
+    
+        # Include the given module in the response class. If a block
+        # is provided instead of a module, create a module using the
+        # the block. Example:
+        #
+        #   Roda.response_module SomeModule
+        #
+        #   Roda.response_module do
+        #     def error!
+        #       self.status = 500
+        #     end
+        #   end
+        #
+        #   Roda.route do |r|
+        #     response.error!
+        #   end
+        def response_module(mod = nil, &block)
+          module_include(:response, mod, &block)
+        end
+
+        private
+
+        # Backbone of the request_module and response_module methods.
+        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
+    end
+
+    register_plugin(:module_include, ModuleInclude)
+  end
+end

data/lib/roda/plugins/multi_route.rb

@@ -130,6 +130,13 @@ class Roda
       end
 
       module ClassMethods
+        # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:namespaced_routes].freeze
+          opts[:namespaced_routes].each_value{|v| v.freeze}
+          super
+        end
+
         # Copy the named routes into the subclass when inheriting.
         def inherited(subclass)
           super