roda 3.108.0 → 3.109.0

data/lib/roda/plugins/each_part.rb

@@ -38,11 +38,9 @@ class Roda
 
       module InstanceMethods
         if RUBY_VERSION >= '2.7'
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def each_part(enum, template, **locals, &block)
-              render_each(enum, template, :locals=>locals, &block)
-            end
-          RUBY
+          def each_part(enum, template, **locals, &block)
+            render_each(enum, template, :locals=>locals, &block)
+          end
         # simplecov:disable
         else
           def each_part(enum, template, locals=OPTS, &block)
@@ -56,28 +54,26 @@ class Roda
         # simplecov:disable
         if RUBY_VERSION >= '3.0'
         # simplecov:enable
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def each_part(enum, template, **locals, &block)
-              if optimized_method = _cached_render_each_template_method(template)
-                optimized_method = optimized_method[0]
-                as = render_each_default_local(template)
-                if defined?(yield)
-                  enum.each do |v|
-                    locals[as] = v
-                    yield send(optimized_method, **locals)
-                  end
-                  nil
-                else
-                  enum.map do |v|
-                    locals[as] = v
-                    send(optimized_method, **locals)
-                  end.join
+          def each_part(enum, template, **locals, &block)
+            if optimized_method = _cached_render_each_template_method(template)
+              optimized_method = optimized_method[0]
+              as = render_each_default_local(template)
+              if defined?(yield)
+                enum.each do |v|
+                  locals[as] = v
+                  yield send(optimized_method, **locals)
                 end
+                nil
               else
-                render_each(enum, template, :locals=>locals, &block)
+                enum.map do |v|
+                  locals[as] = v
+                  send(optimized_method, **locals)
+                end.join
               end
+            else
+              render_each(enum, template, :locals=>locals, &block)
             end
-          RUBY
+          end
         end
       end
     end

data/lib/roda/plugins/environments.rb

@@ -44,10 +44,12 @@ class Roda
       # if no environment is given.  If ENV['RACK_ENV'] is not set and
       # no environment is given, assume the development environment.
       def self.configure(app, env=ENV["RACK_ENV"])
-        app.environment = (env || 'development').to_sym
+        app.opts[:environment] = (env || 'development').to_sym
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :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)
@@ -56,12 +58,6 @@ 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)

data/lib/roda/plugins/error_email.rb

@@ -56,7 +56,7 @@ class Roda
           {'From'=>h[:from], 'To'=>h[:to], 'Subject'=>"#{h[:prefix]}#{subject}"}
         end,
         :body=>lambda do |s, e|
-          filter = s.opts[:error_email][:filter]
+          filter = s.class.error_email_opts[:filter]
           format = lambda do |h|
             h = h.map{|k, v| "#{k.inspect} => #{filter.call(k, v) ? 'FILTERED' : v.inspect}"}
             h.sort!
@@ -120,8 +120,12 @@ END
           raise RodaError, "must provide :to and :from options to error_email plugin"
         end
         app.opts[:error_email] = email_opts
-        app.opts[:error_email][:headers].freeze
-        app.opts[:error_email].freeze
+        app.error_email_opts[:headers].freeze
+        app.error_email_opts.freeze
+      end
+
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :error_email, name: :error_email_opts)
       end
 
       module InstanceMethods
@@ -129,7 +133,7 @@ END
         # instance, but it can be a plain string which is used as the subject for
         # the email.
         def error_email(exception)
-          email_opts = self.class.opts[:error_email].dup
+          email_opts = self.class.error_email_opts.dup
           email_opts[:message] = error_email_content(exception)
           email_opts[:emailer].call(email_opts)
         end
@@ -137,7 +141,7 @@ END
         # The content of the email to send, include the headers and the body.
         # Takes the same argument as #error_email.
         def error_email_content(exception)
-          email_opts = self.class.opts[:error_email]
+          email_opts = self.class.error_email_opts
           headers = email_opts[:default_headers].call(email_opts, exception)
           headers = headers.merge(email_opts[:headers])
           headers = headers.map{|k,v| "#{k}: #{v.gsub(/\r?\n/m, "\r\n ")}"}.sort.join("\r\n")

data/lib/roda/plugins/error_handler.rb

@@ -49,7 +49,7 @@ class Roda
       # If a block is given, automatically call the +error+ method on
       # the Roda class with it.
       def self.configure(app, opts={}, &block)
-        app.opts[:error_handler_classes] = (opts[:classes] || app.opts[:error_handler_classes] || DEFAULT_ERROR_HANDLER_CLASSES).dup.freeze
+        app.opts[:error_handler_classes] = (opts[:classes] || app.error_handler_classes || DEFAULT_ERROR_HANDLER_CLASSES).dup.freeze
 
         if block
           app.error(&block)
@@ -57,6 +57,8 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :error_handler_classes)
+
         # Install the given block as the error handler, so that if routing
         # the request raises an exception, the block will be called with
         # the exception in the scope of the Roda instance.
@@ -77,7 +79,7 @@ class Roda
           ensure
             _roda_after(res)
           end
-        rescue *opts[:error_handler_classes] => e
+        rescue *self.class.error_handler_classes => e
           _handle_error(e)
         end
 
@@ -89,7 +91,7 @@ class Roda
           ensure
             _roda_after(res)
           end
-        rescue *opts[:error_handler_classes] => e
+        rescue *self.class.error_handler_classes => e
           _handle_error(e)
         end
 

data/lib/roda/plugins/error_mail.rb

@@ -44,12 +44,16 @@ class Roda
 
       # Set default opts for plugin.  See ErrorEmail module RDoc for options.
       def self.configure(app, opts=OPTS)
-        app.opts[:error_mail] = email_opts = (app.opts[:error_mail] || {:filter=>DEFAULT_FILTER}).merge(opts).freeze
+        app.opts[:error_mail] = email_opts = (app.error_mail_opts || {:filter=>DEFAULT_FILTER}).merge(opts).freeze
         unless email_opts[:to] && email_opts[:from]
           raise RodaError, "must provide :to and :from options to error_mail plugin"
         end
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :error_mail, name: :error_mail_opts)
+      end
+
       module InstanceMethods
         # Send an email for the given error.  +exception+ is usually an exception
         # instance, but it can be a plain string which is used as the subject for
@@ -67,7 +71,7 @@ class Roda
         private
 
         def _error_mail(e)
-          email_opts = self.class.opts[:error_mail]
+          email_opts = self.class.error_mail_opts
           subject = if e.respond_to?(:message)
             "#{e.class}: #{e.message}"
           else

data/lib/roda/plugins/hash_branch_view_subdir.rb

@@ -33,9 +33,11 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hash_branch_view_subdir_methods)
+
         # Freeze the hash_branch_view_subdir metadata when freezing the app.
         def freeze
-          opts[:hash_branch_view_subdir_methods].freeze.each_value(&:freeze)
+          hash_branch_view_subdir_methods.freeze.each_value(&:freeze)
           super
         end
 
@@ -43,8 +45,8 @@ class Roda
         def inherited(subclass)
           super
 
-          h = subclass.opts[:hash_branch_view_subdir_methods]
-          opts[:hash_branch_view_subdir_methods].each do |namespace, routes|
+          h = subclass.hash_branch_view_subdir_methods
+          hash_branch_view_subdir_methods.each do |namespace, routes|
             h[namespace] = routes.dup
           end
         end
@@ -53,7 +55,7 @@ class Roda
         # by modifying the generated method to append the view subdirectory before
         # dispatching to the original block.
         def hash_branch(namespace='', segment, &block)
-          meths = opts[:hash_branch_view_subdir_methods][namespace] ||= {}
+          meths = hash_branch_view_subdir_methods[namespace] ||= {}
 
           if block
             meth = meths[segment] = define_roda_method(meths[segment] || "_hash_branch_view_subdir_#{namespace}_#{segment}", 1, &convert_route_block(block))

data/lib/roda/plugins/hash_branches.rb

@@ -88,9 +88,11 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hash_branches)
+
         # Freeze the hash_branches metadata when freezing the app.
         def freeze
-          opts[:hash_branches].freeze.each_value(&:freeze)
+          hash_branches.freeze.each_value(&:freeze)
           super
         end
 
@@ -98,8 +100,8 @@ class Roda
         def inherited(subclass)
           super
 
-          h = subclass.opts[:hash_branches]
-          opts[:hash_branches].each do |namespace, routes|
+          h = subclass.hash_branches
+          hash_branches.each do |namespace, routes|
             h[namespace] = routes.dup
           end
         end
@@ -108,7 +110,7 @@ class Roda
         # a block, removes the existing branch handler if it exists.
         def hash_branch(namespace='', segment, &block)
           segment = "/#{segment}"
-          routes = opts[:hash_branches][namespace] ||= {}
+          routes = hash_branches[namespace] ||= {}
           if block
             routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1, &convert_route_block(block))
           elsif meth = routes.delete(segment)
@@ -125,7 +127,7 @@ class Roda
 
           return unless rp.getbyte(0) == 47 # "/"
 
-          if routes = roda_class.opts[:hash_branches][namespace]
+          if routes = roda_class.hash_branches[namespace]
             if segment_end = rp.index('/', 1)
               if meth = routes[rp[0, segment_end]]
                 always do

data/lib/roda/plugins/hash_paths.rb

@@ -80,9 +80,11 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hash_paths)
+
         # Freeze the hash_paths metadata when freezing the app.
         def freeze
-          opts[:hash_paths].freeze.each_value(&:freeze)
+          hash_paths.freeze.each_value(&:freeze)
           super
         end
 
@@ -90,8 +92,8 @@ class Roda
         def inherited(subclass)
           super
 
-          h = subclass.opts[:hash_paths]
-          opts[:hash_paths].each do |namespace, routes|
+          h = subclass.hash_paths
+          hash_paths.each do |namespace, routes|
             h[namespace] = routes.dup
           end
         end
@@ -102,7 +104,7 @@ class Roda
         # there is one.  If called without a block, removes the existing
         # path handler if it exists.
         def hash_path(namespace='', path, &block)
-          routes = opts[:hash_paths][namespace] ||= {}
+          routes = hash_paths[namespace] ||= {}
           if block
             routes[path] = define_roda_method(routes[path] || "hash_path_#{namespace}_#{path}", 1, &convert_route_block(block))
           elsif meth = routes.delete(path)
@@ -115,7 +117,7 @@ class Roda
         # Checks the matching hash_path namespace for a branch matching the 
         # remaining path, and dispatch to that block if there is one.
         def hash_paths(namespace=matched_path)
-          if (routes = roda_class.opts[:hash_paths][namespace]) && (meth = routes[@remaining_path])
+          if (routes = roda_class.hash_paths[namespace]) && (meth = routes[@remaining_path])
             always do
               @remaining_path = ''
               scope.send(meth, self)

data/lib/roda/plugins/hash_public.rb

@@ -78,16 +78,20 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hash_public_prefix)
+        RodaPlugins.opt_attr_reader(self, :hash_public_length)
+        RodaPlugins.opt_attr_reader(self, :hash_public_mutex)
+        RodaPlugins.opt_attr_reader(self, :hash_public_cache)
+
         # The digest for the given file to use in hash_path.
         def hash_path_digest(file)
-          opts = self.opts
-          cache = opts[:hash_public_cache]
-          mutex = opts[:hash_public_mutex]
+          cache = hash_public_cache
+          mutex = hash_public_mutex
           unless digest = mutex.synchronize{cache[file]}
-            digest = Digest::SHA256.file(File.join(opts[:public_root], file)).base64digest
+            digest = Digest::SHA256.file(File.join(public_root, file)).base64digest
             digest.chomp!("=")
             digest.tr!("+/", "-_")
-            if length = opts[:hash_public_length]
+            if length = hash_public_length
               digest = digest[0, length]
             end
             digest.freeze
@@ -102,7 +106,7 @@ class Roda
         # This does not check the file is inside the directory for performance
         # reasons, so this should not be called with untrusted input.
         def hash_path(file)
-          "/#{opts[:hash_public_prefix]}/#{self.class.hash_path_digest(file)}/#{file}"
+          "/#{self.class.hash_public_prefix}/#{self.class.hash_path_digest(file)}/#{file}"
         end
       end
 
@@ -112,7 +116,7 @@ class Roda
         # a string segment for the content hash, and this is a GET request.
         def hash_public
           if is_get?
-            on roda_class.opts[:hash_public_prefix], String do |_|
+            on roda_class.hash_public_prefix, String do |_|
               public
             end
           end

data/lib/roda/plugins/hash_public_cache.rb

@@ -1,6 +1,5 @@
 # frozen-string-literal: true
 
-require 'json'
 require 'find'
 
 class Roda
@@ -29,6 +28,7 @@ class Roda
     #   load_hash_public_cache_file
     module HashPublicCache
       def self.load_dependencies(app, _cache_file, opts = OPTS)
+        app.plugin :_json
         app.plugin :hash_public, opts
       end
 
@@ -40,13 +40,15 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hash_public_cache_file)
+
         # Load the hash public cache file, if it exists. This replaces the hash
         # public cache with the values from the file.
         def load_hash_public_cache_file
-          file = opts[:hash_public_cache_file]
+          file = hash_public_cache_file
           return unless File.file?(file)
 
-          cache = opts[:hash_public_cache] = (opts[:json_parser] || ::JSON.method(:parse)).call(::File.read(file))
+          cache = opts[:hash_public_cache] = json_parser.call(::File.read(file))
           cache.each_value(&:freeze)
           nil
         end
@@ -56,13 +58,13 @@ class Roda
         # If a block is given, it will only calculate the digest for the file
         # if the block returns truthy.
         def scan_hash_public_cache_dir
-          cache = opts[:hash_public_cache]
+          cache = hash_public_cache
 
           # Public root doesn't have trailing slash even if given, as
           # File.expand_path removes it.
-          root = opts[:public_root] + File::SEPARATOR
+          root = public_root + File::SEPARATOR
 
-          Find.find(opts[:public_root]) do |file|
+          Find.find(public_root) do |file|
             if File.file?(file)
               file = file.sub(root, '')
               next if cache[file]
@@ -80,7 +82,7 @@ class Roda
 
         # Write the current hash public cache to the cache file.
         def dump_hash_public_cache_file
-          File.write(opts[:hash_public_cache_file], (opts[:json_serializer] || :to_json.to_proc).call(opts[:hash_public_cache]))
+          File.write(hash_public_cache_file, json_serializer.call(hash_public_cache))
           nil
         end
       end

data/lib/roda/plugins/hash_routes.rb

@@ -191,7 +191,7 @@ class Roda
         def dispatch_from(namespace='', branch, &block)
           ns = @namespace
           if block
-            meth_hash = @roda.opts[:hash_routes_methods]
+            meth_hash = @roda.hash_routes_methods
             key = [:dispatch_from, namespace, branch].freeze
             meth = meth_hash[key] = @roda.define_roda_method(meth_hash[key] || "hash_routes_dispatch_from_#{namespace}_#{branch}", 1, &block)
             @roda.hash_branch(namespace, branch) do |r|
@@ -253,7 +253,7 @@ class Roda
         # Returns 404 for requests for the path with a different request method.
         def verb(verb, path, &block)
           path = path == true ? "" : "/#{path}"
-          meth_hash = @roda.opts[:hash_routes_methods]
+          meth_hash = @roda.hash_routes_methods
           key = [@namespace, path].freeze
           meth = meth_hash[key] = @roda.define_roda_method(meth_hash[key] || "hash_routes_#{@namespace}_#{path}", 0, &block)
           @roda.hash_path(@namespace, path) do |r|
@@ -265,9 +265,11 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hash_routes_methods)
+
         # Freeze the hash_routes metadata when freezing the app.
         def freeze
-          opts[:hash_routes_methods].freeze
+          hash_routes_methods.freeze
           super
         end
 

data/lib/roda/plugins/heartbeat.rb

@@ -16,7 +16,11 @@ class Roda
     module Heartbeat
       # Set the heartbeat path to the given path.
       def self.configure(app, opts=OPTS)
-        app.opts[:heartbeat_path] = (opts[:path] || app.opts[:heartbeat_path] || "/heartbeat").dup.freeze
+        app.opts[:heartbeat_path] = (opts[:path] || app.heartbeat_path || "/heartbeat").dup.freeze
+      end
+
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :heartbeat_path)
       end
 
       module InstanceMethods
@@ -24,7 +28,7 @@ class Roda
 
         # If the request is for a heartbeat path, return the heartbeat response.
         def _roda_before_20__heartbeat
-          if env['PATH_INFO'] == opts[:heartbeat_path]
+          if env['PATH_INFO'] == self.class.heartbeat_path
             response = @_response
             response.status = 200
             response[RodaResponseHeaders::CONTENT_TYPE] = 'text/plain'

data/lib/roda/plugins/hmac_paths.rb

@@ -231,6 +231,12 @@ class Roda
         end
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :hmac_paths_secret)
+        RodaPlugins.opt_attr_reader(self, :hmac_paths_old_secret)
+        RodaPlugins.opt_attr_reader(self, :hmac_paths_namespace_session_key)
+      end
+
       module InstanceMethods
         # Return a path with an HMAC.  Designed to be used with r.hmac_path, to make sure
         # users can only request paths that they have been provided by the application
@@ -315,7 +321,7 @@ class Roda
         # using the secret given in the plugin, for the given root and options.
         # This always returns a hexidecimal string.
         def hmac_path_hmac_secret(root, opts=OPTS)
-          secret = opts[:secret] || self.opts[:hmac_paths_secret]
+          secret = opts[:secret] || self.class.hmac_paths_secret
 
           if namespace = hmac_path_namespace(opts)
             secret = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, secret, namespace)
@@ -326,7 +332,7 @@ class Roda
 
         # The default namespace to use for hmac_path, if a :namespace option is not provided.
         def hmac_path_default_namespace
-          if (key = opts[:hmac_paths_namespace_session_key]) && (value = session[key])
+          if (key = self.class.hmac_paths_namespace_session_key) && (value = session[key])
             value.to_s
           end
         end
@@ -395,7 +401,7 @@ class Roda
         def hmac_path_valid?(root, path, hmac, opts=OPTS)
           if Rack::Utils.secure_compare(scope.hmac_path_hmac(root, path, opts), hmac)
             true
-          elsif old_secret = roda_class.opts[:hmac_paths_old_secret]
+          elsif old_secret = roda_class.hmac_paths_old_secret
             opts = opts.dup
             opts[:secret] = old_secret
             Rack::Utils.secure_compare(scope.hmac_path_hmac(root, path, opts), hmac)

data/lib/roda/plugins/hooks.rb

@@ -39,21 +39,24 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :after_hooks)
+        RodaPlugins.opt_attr_reader(self, :before_hooks)
+
         # Freeze the array of hook methods when freezing the app.
         def freeze
-          opts[:after_hooks].freeze
-          opts[:before_hooks].freeze
+          after_hooks.freeze
+          before_hooks.freeze
 
           super
         end
 
         # Add an after hook.
         def after(&block)
-          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__)
+          after_hooks << define_roda_method("after_hook", 1, &block)
+          if after_hooks.length == 1
+            class_eval("alias _roda_after_80__hooks #{after_hooks.first}", __FILE__, __LINE__)
           else
-            class_eval("def _roda_after_80__hooks(res) #{opts[:after_hooks].map{|m| "#{m}(res)"}.join(';')} end", __FILE__, __LINE__)
+            class_eval("def _roda_after_80__hooks(res) #{after_hooks.map{|m| "#{m}(res)"}.join(';')} end", __FILE__, __LINE__)
           end
           private :_roda_after_80__hooks
           def_roda_after
@@ -62,11 +65,11 @@ class Roda
 
         # Add a before hook.
         def before(&block)
-          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__)
+          before_hooks.unshift(define_roda_method("before_hook", 0, &block))
+          if before_hooks.length == 1
+            class_eval("alias _roda_before_10__hooks #{before_hooks.first}", __FILE__, __LINE__)
           else
-            class_eval("def _roda_before_10__hooks; #{opts[:before_hooks].join(';')} end", __FILE__, __LINE__)
+            class_eval("def _roda_before_10__hooks; #{before_hooks.join(';')} end", __FILE__, __LINE__)
           end
           private :_roda_before_10__hooks
           def_roda_before

data/lib/roda/plugins/host_authorization.rb

@@ -101,6 +101,11 @@ class Roda
         end
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :host_authorization_host)
+        RodaPlugins.opt_attr_reader(self, :host_authorization_check_forwarded, name: :host_authorization_check_forwarded?)
+      end
+
       module InstanceMethods
         # Check whether the host is authorized.  If not authorized, return a response
         # immediately based on the plugin block.
@@ -108,7 +113,7 @@ class Roda
           r = @_request
           return if host_authorized?(_convert_host_for_authorization(r.env["HTTP_HOST"].to_s.dup))
 
-          if opts[:host_authorization_check_forwarded] && (host = r.env["HTTP_X_FORWARDED_HOST"])
+          if self.class.host_authorization_check_forwarded? && (host = r.env["HTTP_X_FORWARDED_HOST"])
             if i = host.rindex(',')
               host = host[i+1, 10000000].to_s
             end
@@ -133,7 +138,7 @@ class Roda
         end
 
         # Whether the host given is one of the authorized hosts for this application.
-        def host_authorized?(host, authorized_host = opts[:host_authorization_host])
+        def host_authorized?(host, authorized_host = self.class.host_authorization_host)
           case authorized_host
           when Array
             authorized_host.any?{|auth_host| host_authorized?(host, auth_host)}

data/lib/roda/plugins/host_routing.rb

@@ -176,6 +176,11 @@ class Roda
       end
       private_constant :DSL
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :host_routing_hash)
+        RodaPlugins.opt_attr_reader(self, :host_routing_default_host)
+      end
+
       module InstanceMethods
         # Handle case where plugin is used without providing a block to
         # +hosts.default+.  This returns nil, ensuring that the hostname
@@ -207,9 +212,9 @@ class Roda
             host = ""
           end
 
-          roda_class.opts[:host_routing_hash][host] ||
+          roda_class.host_routing_hash[host] ||
             scope._host_routing_default(host) ||
-            roda_class.opts[:host_routing_default_host]
+            roda_class.host_routing_default_host
         end
       end
     end

data/lib/roda/plugins/invalid_request_body.rb

@@ -37,13 +37,25 @@ class Roda
     #     # To treat the exception raised as a submitted parameter
     #     {body_error: exception}
     #   end
+    #
+    # You can use the +rescue_classes+ argument when loading the plugin to only rescue
+    # specific exception classes:
+    #
+    #   plugin :invalid_request_body, :empty_hash, rescue_classes: Rack::BadRequest
+    #
+    # However, this can be risky, because there have been many cases in the past where
+    # Rack can rescue classes such as +ArgumentError+ or +NoMethodError+ when parsing
+    # invalid request bodies. The default for +rescue_classes+ is +StandardError+.
     module InvalidRequestBody
       # Exception class raised for invalid request bodies.
       Error = Class.new(RodaError)
 
       # Set the action to use (:empty_400, :empty_hash, :raise) for invalid request bodies,
-      # or use a block for custom behavior.
-      def self.configure(app, action=nil, &block)
+      # or use a block for custom behavior. The rescue_classes argument is an exception
+      # class or array of exception classes to rescue.
+      def self.configure(app, action=nil, rescue_classes: StandardError, &block)
+        app.opts[:invalid_response_body_rescue_classes] = Array(rescue_classes).dup.freeze
+
         if action
           if block
             raise RodaError, "cannot provide both block and action when loading invalid_request_body plugin"
@@ -56,7 +68,7 @@ class Roda
 
           app::RodaRequest.send(:alias_method, :handle_invalid_request_body, method)
         elsif block
-          app::RodaRequest.class_eval do
+          app::RodaRequest.class_exec do
             define_method(:handle_invalid_request_body, &block)
             alias handle_invalid_request_body handle_invalid_request_body
           end
@@ -67,6 +79,10 @@ class Roda
         app::RodaRequest.send(:private, :handle_invalid_request_body)
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :invalid_response_body_rescue_classes)
+      end
+
       module RequestMethods
         # Handle invalid request bodies as configured if the default behavior
         # raises an exception.
@@ -74,7 +90,7 @@ class Roda
           super
         rescue RodaError
           raise
-        rescue => e 
+        rescue *roda_class.invalid_response_body_rescue_classes => e 
           handle_invalid_request_body(e)
         end