roda 3.107.0 → 3.109.0

data/lib/roda/plugins/content_security_policy.rb

@@ -289,6 +289,10 @@ class Roda
         policy.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :content_security_policy)
+      end
+
       module InstanceMethods
         # If a block is given, yield the current content security policy.  Returns the
         # current content security policy.
@@ -308,7 +312,7 @@ class Roda
 
         # The current content security policy to be used for this response.
         def content_security_policy
-          @content_security_policy ||= roda_class.opts[:content_security_policy].dup
+          @content_security_policy ||= roda_class.content_security_policy.dup
         end
 
         # Do not set a content security policy header for this response.
@@ -322,7 +326,7 @@ class Roda
         def set_default_headers
           super
           unless @skip_content_security_policy
-            (@content_security_policy || roda_class.opts[:content_security_policy]).set_header(headers)
+            (@content_security_policy || roda_class.content_security_policy).set_header(headers)
           end
         end
       end

data/lib/roda/plugins/cookie_flags.rb

@@ -48,9 +48,9 @@ class Roda
     # Note that this plugin only affects cookies set by the application, and does not
     # affect cookies set by middleware the application is using.
     module CookieFlags
-      # :nocov:
+      # simplecov:disable
       MATCH_METH = RUBY_VERSION >= '2.4' ? :match? : :match
-      # :nocov:
+      # simplecov:enable
       private_constant :MATCH_METH
 
       DEFAULTS = {:secure=>true, :httponly=>true, :same_site=>'strict', :action=>:modify}.freeze
@@ -61,7 +61,7 @@ class Roda
       end
 
       def self.configure(app, opts=OPTS)
-        previous = app.opts[:cookie_flags] || DEFAULTS
+        previous = app.cookie_flags || DEFAULTS
         opts = app.opts[:cookie_flags] = previous.merge(opts)
 
         case opts[:same_site]
@@ -74,11 +74,15 @@ class Roda
         opts.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :cookie_flags)
+      end
+
       module InstanceMethods
         private
 
         def _handle_cookie_flags_array(cookies)
-          opts = self.class.opts[:cookie_flags]
+          opts = self.class.cookie_flags
           needs_secure = opts[:secure]
           needs_httponly = opts[:httponly]
           if needs_same_site = opts[:same_site]

data/lib/roda/plugins/cookies.rb

@@ -20,7 +20,11 @@ class Roda
     module Cookies
       # Allow setting default cookie options when loading the cookies plugin.
       def self.configure(app, opts={})
-        app.opts[:cookies_opts] = (app.opts[:cookies_opts]||{}).merge(opts).freeze
+        app.opts[:cookies_opts] = (app.cookies_opts||{}).merge(opts).freeze
+      end
+
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :cookies_opts)
       end
 
       module ResponseMethods
@@ -32,7 +36,7 @@ class Roda
         #   response.delete_cookie('foo')
         #   response.delete_cookie('foo', domain: 'example.org')
         def delete_cookie(key, value = {})
-          ::Rack::Utils.delete_cookie_header!(@headers, key, roda_class.opts[:cookies_opts].merge(value))
+          ::Rack::Utils.delete_cookie_header!(@headers, key, roda_class.cookies_opts.merge(value))
         end
 
         # Set the cookie with the given key in the headers.
@@ -41,7 +45,7 @@ class Roda
         #   response.set_cookie('foo', value: 'bar', domain: 'example.org')
         def set_cookie(key, value)
           value = { :value=>value } unless value.respond_to?(:keys)
-          ::Rack::Utils.set_cookie_header!(@headers, key, roda_class.opts[:cookies_opts].merge(value))
+          ::Rack::Utils.set_cookie_header!(@headers, key, roda_class.cookies_opts.merge(value))
         end
       end
     end

data/lib/roda/plugins/custom_block_results.rb

@@ -44,16 +44,18 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :custom_block_results)
+
         # Freeze the configured custom block results when freezing the app.
         def freeze
-          opts[:custom_block_results].freeze
+          custom_block_results.freeze
           super
         end
 
         # Specify a block that will be called when an instance of klass
         # is returned as a block result.  The block defines a method.
         def handle_block_result(klass, &block)
-          opts[:custom_block_results][klass] = define_roda_method(opts[:custom_block_results][klass] || "custom_block_result_#{klass}", 1, &block)
+          custom_block_results[klass] = define_roda_method(custom_block_results[klass] || "custom_block_result_#{klass}", 1, &block)
         end
       end
 
@@ -63,7 +65,7 @@ class Roda
         # Try each configured custom block result, and call the related method
         # to get the block result.
         def unsupported_block_result(result)
-          roda_class.opts[:custom_block_results].each do |klass, meth|
+          roda_class.custom_block_results.each do |klass, meth|
             if klass === result
               result = scope.send(meth, result)
 

data/lib/roda/plugins/custom_matchers.rb

@@ -58,8 +58,10 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :custom_matchers)
+
         def custom_matcher(match_class, &block)
-          custom_matchers = Hash[opts[:custom_matchers]]
+          custom_matchers = Hash[self.custom_matchers]
           meth = custom_matchers[match_class] = custom_matchers[match_class] || :"_custom_matcher_#{match_class}"
           opts[:custom_matchers] = custom_matchers.freeze
           self::RodaRequest.send(:define_method, meth, &block)
@@ -72,7 +74,7 @@ class Roda
 
         # Try custom matchers before calling super
         def unsupported_matcher(matcher)
-          roda_class.opts[:custom_matchers].each do |match_class, meth|
+          roda_class.custom_matchers.each do |match_class, meth|
             if match_class === matcher
               return send(meth, matcher)
             end

data/lib/roda/plugins/default_headers.rb

@@ -27,15 +27,12 @@ class Roda
       end 
 
       module ClassMethods
-        # The default response headers to use for the current class.
-        def default_headers
-          opts[:default_headers]
-        end
+        RodaPlugins.opt_attr_reader(self, :default_headers)
 
         # Optimize the response class set_default_headers method if it hasn't been
         # overridden and all default headers are strings.
         def freeze
-          if (headers = opts[:default_headers]).all?{|k, v| k.is_a?(String) && v.is_a?(String)} &&
+          if (headers = default_headers).all?{|k, v| k.is_a?(String) && v.is_a?(String)} &&
              (self::RodaResponse.instance_method(:set_default_headers).owner == Base::ResponseMethods)
             self::RodaResponse.class_eval(<<-END, __FILE__, __LINE__+1)
               private

data/lib/roda/plugins/default_status.rb

@@ -18,6 +18,7 @@ class Roda
       def self.configure(app, &block)
         raise RodaError, "default_status plugin requires a block" unless block
         if check_arity = app.opts.fetch(:check_arity, true)
+          # RODA4: Remove support for :check_arity, default to false behavior
           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}"

data/lib/roda/plugins/each_part.rb

@@ -38,46 +38,42 @@ 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
-        # :nocov:
+          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)
             render_each(enum, template, :locals=>locals, &block)
           end
         end
-        # :nocov:
+        # simplecov:enable
       end
 
       module AssumeFixedLocalsInstanceMethods
-        # :nocov:
+        # simplecov:disable
         if RUBY_VERSION >= '3.0'
-        # :nocov:
-          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
+        # simplecov:enable
+          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

@@ -44,9 +44,9 @@ class Roda
         :filter=>lambda{|k,v| false},
         :headers=>OPTS,
         :host=>'localhost',
-        # :nocov:
+        # simplecov:disable
         :emailer=>lambda{|h| Net::SMTP.start(h[:host]){|s| s.send_message(h[:message], h[:from], h[:to])}},
-        # :nocov:
+        # simplecov:enable
         :default_headers=>lambda do |h, e|
           subject = if e.respond_to?(:message)
             "#{e.class}: #{e.message}"
@@ -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/exception_page.rb

@@ -415,14 +415,14 @@ END
           def exception_page_exception_message(exception)
             exception.detailed_message(highlight: false).to_s
           end
-        # :nocov:
+        # simplecov:disable
         else
           # Return message to use for exception.
           def exception_page_exception_message(exception)
             exception.message.to_s
           end
         end
-        # :nocov:
+        # simplecov:enable
       end
 
       module RequestMethods

data/lib/roda/plugins/h.rb

@@ -17,10 +17,10 @@ class Roda
       begin
         require 'cgi/escape'
         unless CGI.respond_to?(:escapeHTML) # work around for JRuby 9.1
-          # :nocov:
+          # simplecov:disable
           CGI = Object.new
           CGI.extend(defined?(::CGI::Escape) ? ::CGI::Escape : ::CGI::Util)
-          # :nocov:
+          # simplecov:enable
         end
 
         module InstanceMethods
@@ -30,7 +30,7 @@ class Roda
           end
         end
       rescue LoadError
-        # :nocov:
+        # simplecov:disable
 
         # A Hash of entities and their escaped equivalents,
         # to be escaped by h().
@@ -50,7 +50,7 @@ class Roda
             string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
           end
         end
-        # :nocov:
+        # simplecov:enable
       end
     end
 

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,15 +127,19 @@ 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]]
-                @remaining_path = rp[segment_end, 100000000]
-                always{scope.send(meth, self)}
+                always do
+                  @remaining_path = rp[segment_end, 100000000]
+                  scope.send(meth, self)
+                end
               end
             elsif meth = routes[rp]
-              @remaining_path = ''
-              always{scope.send(meth, self)}
+              always do
+                @remaining_path = ''
+                scope.send(meth, self)
+              end
             end
           end
         end

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,9 +117,11 @@ 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])
-            @remaining_path = ''
-            always{scope.send(meth, self)}
+          if (routes = roda_class.hash_paths[namespace]) && (meth = routes[@remaining_path])
+            always do
+              @remaining_path = ''
+              scope.send(meth, self)
+            end
           end
         end
       end

data/lib/roda/plugins/hash_public.rb

@@ -51,11 +51,11 @@ class Roda
       Digest = begin
         require 'openssl'
         ::OpenSSL::Digest
-      # :nocov:
+      # simplecov:disable
       rescue LoadError
         require 'digest/sha2'
         ::Digest
-      # :nocov:
+      # simplecov:enable
       end
 
       def self.load_dependencies(app, opts = OPTS)
@@ -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