roda 3.17.0 → 3.18.0

data/lib/roda/plugins/_after_hook.rb

@@ -1,33 +1,11 @@
 # frozen-string-literal: true
 
+require_relative 'error_handler'
+
 #
 class Roda
   module RodaPlugins
-    # Internal after hook module, not for external use.
-    # Allows for plugins to configure the order in which
-    # after processing is done by using _roda_after_*
-    # private instance methods that are called in sorted order.
-    # Loaded automatically by the base library if any _roda_after_*
-    # methods are defined.
-    module AfterHook # :nodoc:
-      # Module for internal after hook support.
-      module InstanceMethods
-        # Run internal after hooks with the response
-        def call
-          res = super
-        ensure
-          _roda_after(res)
-        end
-
-        private
-
-        # Empty roda_after method, so nothing breaks if the module is included.
-        # This method will be overridden in most classes using this module.
-        def _roda_after(res)
-        end
-      end
-    end
-
-    register_plugin(:_after_hook, AfterHook)
+    # RODA4: Remove
+    register_plugin(:_after_hook, ErrorHandler)
   end
 end

data/lib/roda/plugins/_before_hook.rb

@@ -3,9 +3,37 @@
 #
 class Roda
   module RodaPlugins
-    # Deprecated plugin, only exists for backwards compatibility.
-    # Features are now part of base library.
+    # Internal before hook module, not for external use.
+    # Allows for plugins to configure the order in which
+    # before processing is done by using _roda_before_*
+    # private instance methods that are called in sorted order.
+    # Loaded automatically by the base library if any _roda_before_*
+    # methods are defined.
     module BeforeHook # :nodoc:
+      module InstanceMethods
+        # Run internal before hooks - Old Dispatch API.
+        def call(&block)
+          # RODA4: Remove
+          super do
+            _roda_before
+            instance_exec(@_request, &block) # call Fallback
+          end
+        end
+
+        # Run internal before hooks before running the main
+        # roda route.
+        def _roda_run_main_route(r)
+          _roda_before
+          super
+        end
+
+        private
+
+        # Default empty implementation of _roda_before, usually
+        # overridden by Roda.def_roda_before.
+        def _roda_before
+        end
+      end
     end
 
     register_plugin(:_before_hook, BeforeHook)

data/lib/roda/plugins/branch_locals.rb

@@ -31,7 +31,7 @@ class Roda
         # Update the default layout locals to use in this branch.
         def set_layout_locals(opts)
           if locals = @_layout_locals
-            @_layout_locals = Hash[locals].merge!(opts)
+            @_layout_locals = locals.merge(opts)
           else
             @_layout_locals = opts
           end
@@ -40,7 +40,7 @@ class Roda
         # Update the default view locals to use in this branch.
         def set_view_locals(opts)
           if locals = @_view_locals
-            @_view_locals = Hash[locals].merge!(opts)
+            @_view_locals = locals.merge(opts)
           else
             @_view_locals = opts
           end

data/lib/roda/plugins/class_level_routing.rb

@@ -62,9 +62,10 @@ class Roda
 
       module ClassMethods
         # 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, convert_route_block(block)].freeze
+        [:root, :on, :is, :get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |request_meth|
+          define_method(request_meth) do |*args, &block|
+            meth = define_roda_method("class_level_routing_#{request_meth}", :any, &block)
+            opts[:class_level_routes] << [request_meth, args, meth].freeze
           end
         end
 
@@ -91,11 +92,12 @@ class Roda
             # the original response.
             @_response.send(:initialize)
             @_response.status = nil
-            result.replace(_call do |r|
-              opts[:class_level_routes].each do |meth, args, blk|
+            result.replace(_roda_handle_route do
+              r = @_request
+              opts[:class_level_routes].each do |request_meth, args, meth|
                 r.instance_variable_set(:@remaining_path, @_original_remaining_path)
-                r.public_send(meth, *args) do |*a|
-                  instance_exec(*a, &blk)
+                r.public_send(request_meth, *args) do |*a|
+                  send(meth, *a)
                 end
               end
               nil

data/lib/roda/plugins/default_headers.rb

@@ -23,7 +23,21 @@ class Roda
     module DefaultHeaders
       # Merge the given headers into the existing default headers, if any.
       def self.configure(app, headers={})
-        app.opts[:default_headers] = (app.default_headers || app::RodaResponse::DEFAULT_HEADERS).merge(headers).freeze
+        headers = app.opts[:default_headers] = (app.default_headers || app::RodaResponse::DEFAULT_HEADERS).merge(headers).freeze
+
+        if headers.all?{|k, v| k.is_a?(String) && v.is_a?(String)}
+          response_class = app::RodaResponse
+          owner = response_class.instance_method(:set_default_headers).owner
+          if owner == Base::ResponseMethods || (owner == response_class && app.opts[:set_default_headers_overridder] == response_class)
+            app.opts[:set_default_headers_overridder] = response_class
+            response_class.class_eval(<<-END, __FILE__, __LINE__+1)
+              def set_default_headers
+                h = @headers
+                #{headers.map{|k,v| "h[#{k.inspect}] ||= #{v.inspect}"}.join('; ')}
+              end
+            END
+          end
+        end
       end 
 
       module ClassMethods

data/lib/roda/plugins/default_status.rb

@@ -7,8 +7,6 @@ class Roda
     # return a response status integer. This integer will be used as
     # the default response status (usually 200) if the body has been
     # written to, and you have not explicitly set a response status.
-    # The block given to the block is instance_execed in the context
-    # of the response.
     #
     # Example:
     #
@@ -19,15 +17,16 @@ class Roda
     module DefaultStatus
       def self.configure(app, &block)
         raise RodaError, "default_status plugin requires a block" unless block
-        app.opts[:default_status] = block
-      end
-
-      module ResponseMethods
-        # instance_exec the default_status plugin block to get the response
-        # status.
-        def default_status
-          instance_exec(&roda_class.opts[:default_status])
+       if check_arity = app.opts.fetch(:check_arity, true)
+          unless block.arity == 0
+            if check_arity == :warn
+              RodaPlugins.warn "Arity mismatch in block passed to plugin :default_status. Expected Arity 0, but arguments required for #{block.inspect}"
+            end
+            b = block
+            block = lambda{instance_exec(&b)} # Fallback
+          end
         end
+        app::RodaResponse.send(:define_method, :default_status, &block)
       end
     end
 

data/lib/roda/plugins/direct_call.rb

@@ -0,0 +1,38 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The direct_call plugin makes the call class method skip the middleware stack
+    # (app.call will still call the middleware).
+    # This can be used as an optimization, as the Roda class itself can be used
+    # as the callable, which is faster than using a lambda.
+    module DirectCall
+      def self.configure(app)
+        app.send(:build_rack_app)
+      end
+
+      module ClassMethods
+        # Call the application without middlware.
+        def call(env)
+          new(env)._roda_handle_main_route
+        end
+
+        private
+
+        # If new_api is true, use the receiver as the base rack app for better
+        # performance.
+        def base_rack_app_callable(new_api=true)
+          if new_api
+            self
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:direct_call, DirectCall)
+  end
+end
+

data/lib/roda/plugins/error_email.rb

@@ -123,7 +123,7 @@ END
         def error_email_content(exception)
           email_opts = self.class.opts[:error_email]
           headers = email_opts[:default_headers].call(email_opts, exception)
-          headers = Hash[headers].merge!(email_opts[:headers])
+          headers = headers.merge(email_opts[:headers])
           headers = headers.map{|k,v| "#{k}: #{v.gsub(/\r?\n/m, "\r\n ")}"}.sort.join("\r\n")
           body = email_opts[:body].call(self, exception)
           "#{headers}\r\n\r\n#{body}"

data/lib/roda/plugins/error_handler.rb

@@ -44,10 +44,6 @@ class Roda
     #
     #   plugin :error_handler, classes: [StandardError, ScriptError, NoMemoryError]
     module ErrorHandler
-      def self.load_dependencies(app, *)
-        app.plugin :_after_hook
-      end
-
       DEFAULT_ERROR_HANDLER_CLASSES = [StandardError, ScriptError].freeze
 
       # If a block is given, automatically call the +error+ method on
@@ -72,13 +68,45 @@ class Roda
 
       module InstanceMethods
         # If an error occurs, set the response status to 500 and call
-        # the error handler.
+        # the error handler. Old Dispatch API.
         def call
-          super
+          # RODA4: Remove
+          begin
+            res = super
+          ensure
+            _roda_after(res)
+          end
+        rescue *opts[:error_handler_classes] => e
+          _handle_error(e)
+        end
+
+        # If an error occurs, set the response status to 500 and call
+        # the error handler. 
+        def _roda_handle_main_route
+          begin
+            res = super
+          ensure
+            _roda_after(res)
+          end
         rescue *opts[:error_handler_classes] => e
-          @_response.send(:initialize)
-          @_response.status = 500
-          res = _call{handle_error(e)}
+          _handle_error(e)
+        end
+
+        private
+
+        # Default empty implementation of _roda_after, usually
+        # overridden by Roda.def_roda_before.
+        def _roda_after(res)
+        end
+
+        # Handle the given exception using handle_error, using a default status
+        # of 500.  Run after hooks on the rack response, but if any error occurs
+        # when doing so, log the error using rack.errors and return the response.
+        def _handle_error(e)
+          res = @_response
+          res.send(:initialize)
+          res.status = 500
+          res = _roda_handle_route{handle_error(e)}
           begin
             _roda_after(res)
           rescue => e2
@@ -90,8 +118,6 @@ class Roda
           res
         end
 
-        private
-
         # By default, have the error handler reraise the error, so using
         # the plugin without installing an error handler doesn't change
         # behavior.

data/lib/roda/plugins/hooks.rb

@@ -34,57 +34,55 @@ class Roda
     # hooks can be called with nil if an exception is raised during routing.
     module Hooks
       def self.configure(app)
-        app.opts[:before_hook] ||= nil
-        app.opts[:after_hook] ||= nil
+        app.opts[:after_hooks] ||= []
+        app.opts[:before_hooks] ||= []
       end
 
       module ClassMethods
-        # Add an after hook.  If there is already an after hook defined,
-        # use a proc that instance_execs the existing after proc and
-        # then instance_execs the given after proc, so that the given
-        # after proc always executes after the previous one.
+        # Freeze the array of hook methods when freezing the app.
+        def freeze
+          opts[:after_hooks].freeze
+          opts[:before_hooks].freeze
+
+          super
+        end
+
+        # Add an after hook.
         def after(&block)
-          opts[:after_hook] = if b = opts[:after_hook]
-            proc do |res|
-              instance_exec(res, &b)
-              instance_exec(res, &block)
-            end
+          opts[:after_hooks] << define_roda_method("after_hook", 1, &block)
+          if opts[:after_hooks].length == 1
+            class_eval("alias _roda_after_80__hooks #{opts[:after_hooks].first}", __FILE__, __LINE__)
           else
-            block
+            class_eval("def _roda_after_80__hooks(res) #{opts[:after_hooks].map{|m| "#{m}(res)"}.join(';')} end", __FILE__, __LINE__)
           end
+          private :_roda_after_80__hooks
+          def_roda_after
+          nil
         end
 
-        # Add a before hook.  If there is already a before hook defined,
-        # use a proc that instance_execs the give before proc and
-        # then instance_execs the existing before proc, so that the given
-        # before proc always executes before the previous one.
+        # Add a before hook.
         def before(&block)
-          opts[:before_hook] = if b = opts[:before_hook]
-            proc do
-              instance_exec(&block)
-              instance_exec(&b)
-            end
+          opts[:before_hooks].unshift(define_roda_method("before_hook", 0, &block))
+          if opts[:before_hooks].length == 1
+            class_eval("alias _roda_before_10__hooks #{opts[:before_hooks].first}", __FILE__, __LINE__)
           else
-            block
+            class_eval("def _roda_before_10__hooks; #{opts[:before_hooks].join(';')} end", __FILE__, __LINE__)
           end
+          private :_roda_before_10__hooks
+          def_roda_before
+          nil
         end
       end
 
       module InstanceMethods
         private
 
-        # Run after hooks.
+        # Default method if no after hooks are defined.
         def _roda_after_80__hooks(res)
-          if b = opts[:after_hook]
-            instance_exec(res, &b)
-          end
         end
 
-        # Run before hooks.
+        # Default method if no before hooks are defined.
         def _roda_before_10__hooks
-          if b = opts[:before_hook]
-            instance_exec(&b)
-          end
         end
       end
     end

data/lib/roda/plugins/mail_processor.rb

@@ -301,7 +301,7 @@ class Roda
 
           begin
             begin
-              scope.process_mail(&@rack_app_route_block)
+              scope.process_mail
             rescue UnhandledMail
               scope.unhandled_mail_hook
             else
@@ -329,16 +329,23 @@ class Roda
         def rcpt(*addresses, &block)
           opts[:mail_processor_string_routes] ||= {}
           opts[:mail_processor_regexp_routes] ||= {}
+          string_meth = nil
+          regexp_meth = nil
           addresses.each do |address|
             key = case address
             when String
-              :mail_processor_string_routes
+              unless string_meth
+                string_meth = define_roda_method("mail_processor_string_route_#{address}", 1, &convert_route_block(block))
+              end
+              opts[:mail_processor_string_routes][address] = string_meth 
             when Regexp
-              :mail_processor_regexp_routes
+              unless regexp_meth
+                regexp_meth = define_roda_method("mail_processor_regexp_route_#{address}", :any, &convert_route_block(block))
+              end
+              opts[:mail_processor_regexp_routes][address] = regexp_meth
             else
               raise RodaError, "invalid address format passed to rcpt, should be Array or String"
             end
-            opts[key][address] = block
           end
           nil
         end
@@ -379,25 +386,23 @@ class Roda
             addresses = mail_recipients
 
             addresses.each do |address|
-              if blk = string_routes[address.to_s.downcase]
-                call(&blk)
+              if meth = string_routes[address.to_s.downcase]
+                _roda_handle_route{send(meth, @_request)}
                 return
               end
             end
 
-            opts[:mail_processor_regexp_routes].each do |regexp, blk|
+            opts[:mail_processor_regexp_routes].each do |regexp, meth|
               addresses.each do |address|
                 if md = regexp.match(address)
-                  call do |r|
-                    instance_exec(r, *md.captures, &blk)
-                  end
+                  _roda_handle_route{send(meth, @_request, *md.captures)}
                   return 
                 end
               end
             end
           end
 
-          call(&block)
+          _roda_handle_main_route
 
           nil
         end