roda 3.107.0 → 3.109.0

data/lib/roda/plugins/mail_processor.rb

@@ -285,11 +285,14 @@ class Roda
       class UnhandledMail < StandardError; end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :mail_processor_string_routes)
+        RodaPlugins.opt_attr_reader(self, :mail_processor_regexp_routes)
+
         # Freeze the rcpt routes if they are present.
         def freeze
-          if string_routes = opts[:mail_processor_string_routes].freeze
+          if string_routes = mail_processor_string_routes.freeze
             string_routes.freeze
-            opts[:mail_processor_regexp_routes].freeze
+            mail_processor_regexp_routes.freeze
           end
           super
         end
@@ -337,12 +340,12 @@ class Roda
               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 
+              mail_processor_string_routes[address] = string_meth 
             when Regexp
               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
+              mail_processor_regexp_routes[address] = regexp_meth
             else
               raise RodaError, "invalid address format passed to rcpt, should be Array or String"
             end
@@ -382,7 +385,7 @@ class Roda
         # routes defined via the class-level +rcpt+ method, and then the
         # normal routing tree passed in as the block.
         def process_mail(&block)
-          if string_routes = opts[:mail_processor_string_routes]
+          if string_routes = self.class.mail_processor_string_routes
             addresses = mail_recipients
 
             addresses.each do |address|
@@ -392,7 +395,7 @@ class Roda
               end
             end
 
-            opts[:mail_processor_regexp_routes].each do |regexp, meth|
+            self.class.mail_processor_regexp_routes.each do |regexp, meth|
               addresses.each do |address|
                 if md = regexp.match(address)
                   _roda_handle_route{send(meth, @_request, *md.captures)}
@@ -510,11 +513,11 @@ class Roda
             a1.casecmp?(a2)
           end
         else
-          # :nocov:
+          # simplecov:disable
           def address_match?(a1, a2)
             a1.downcase == a2.downcase
           end
-          # :nocov:
+          # simplecov:enable
         end
 
         # Match if any of the given addresses match the given val, which

data/lib/roda/plugins/mailer.rb

@@ -136,10 +136,12 @@ class Roda
       # Set the options for the mailer.  Options:
       # :content_type :: The default content type for emails (default: text/plain)
       def self.configure(app, opts=OPTS)
-        app.opts[:mailer] = (app.opts[:mailer]||OPTS).merge(opts).freeze
+        app.opts[:mailer] = (app.mailer_opts||OPTS).merge(opts).freeze
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :mailer, name: :mailer_opts)
+
         # Return a Mail::Message instance for the email for the given request path
         # and arguments.   Any arguments given are yielded to the appropriate +r.mail+
         # block after any usual match block arguments. You can further manipulate the
@@ -153,9 +155,9 @@ class Roda
             mail
           end
         end
-        # :nocov:
+        # simplecov:disable
         ruby2_keywords(:mail) if respond_to?(:ruby2_keywords, true)
-        # :nocov:
+        # simplecov:enable
 
         # Calls +mail+ with given arguments and immediately sends the resulting mail.
         def sendmail(*args)
@@ -163,9 +165,9 @@ class Roda
             m.deliver
           end
         end
-        # :nocov:
+        # simplecov:disable
         ruby2_keywords(:sendmail) if respond_to?(:ruby2_keywords, true)
-        # :nocov:
+        # simplecov:enable
       end
 
       module RequestMethods
@@ -177,7 +179,7 @@ class Roda
         def mail(*args)
           if @env["REQUEST_METHOD"] == "MAIL"
             # RODA4: Make terminal match the default
-            send(roda_class.opts[:mailer][:terminal] ? :_verb : :if_match, args) do |*vs|
+            send(roda_class.mailer_opts[:terminal] ? :_verb : :if_match, args) do |*vs|
               yield(*(vs + @env['roda.mail_args']))
             end
           end
@@ -202,7 +204,7 @@ class Roda
               block.call if block
             end
 
-            if content_type = header_content_type || roda_class.opts[:mailer][:content_type]
+            if content_type = header_content_type || roda_class.mailer_opts[:content_type]
               if mail.multipart?
                 if /multipart\/mixed/ =~ mail.content_type &&
                    mail.parts.length >= 2 &&

data/lib/roda/plugins/match_affix.rb

@@ -39,13 +39,18 @@ class Roda
         app.opts[:match_suffix] = suffix if suffix
       end
       
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :match_prefix)
+        RodaPlugins.opt_attr_reader(self, :match_suffix)
+      end
+
       module RequestClassMethods
         private
 
         # Use the match prefix and suffix provided when loading the plugin, or fallback
         # to Roda's default prefix/suffix if one was not provided.
         def consume_pattern(pattern)
-          /\A#{roda_class.opts[:match_prefix] || "/"}(?:#{pattern})#{roda_class.opts[:match_suffix] || "(?=\/|\z)"}/
+          /\A#{roda_class.match_prefix || "/"}(?:#{pattern})#{roda_class.match_suffix || "(?=\/|\z)"}/
         end
       end
 

data/lib/roda/plugins/match_hook_args.rb

@@ -40,20 +40,22 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :match_hook_args)
+
         # Freeze the array of hook methods when freezing the app
         def freeze
-          opts[:match_hook_args].freeze
+          match_hook_args.freeze
           super
         end
 
         # Add a match hook that will be called with matchers and block args.
         def add_match_hook(&block)
-          opts[:match_hook_args] << define_roda_method("match_hook_args", :any, &block)
+          match_hook_args << define_roda_method("match_hook_args", :any, &block)
 
-          if opts[:match_hook_args].length == 1
-            class_eval("alias _match_hook_args #{opts[:match_hook_args].first}", __FILE__, __LINE__)
+          if match_hook_args.length == 1
+            class_eval("alias _match_hook_args #{match_hook_args.first}", __FILE__, __LINE__)
           else
-            class_eval("def _match_hook_args(v, a); #{opts[:match_hook_args].map{|m| "#{m}(v, a)"}.join(';')} end", __FILE__, __LINE__)
+            class_eval("def _match_hook_args(v, a); #{match_hook_args.map{|m| "#{m}(v, a)"}.join(';')} end", __FILE__, __LINE__)
           end
 
           public :_match_hook_args

data/lib/roda/plugins/middleware.rb

@@ -136,10 +136,10 @@ class Roda
         def initialize(mid, app, *args, &block)
           @mid = Class.new(mid)
           RodaPlugins.set_temp_name(@mid){"#{mid}::middleware_subclass"}
-          if @mid.opts[:middleware_next_if_not_found]
+          if @mid.middleware_next_if_not_found?
             @mid.plugin(:not_found, &NEXT_PROC)
           end
-          if configure = @mid.opts[:middleware_configure]
+          if configure = @mid.middleware_configure
             configure.call(@mid, *args, &block)
           elsif block || !args.empty?
             raise RodaError, "cannot provide middleware args or block unless loading middleware plugin with a block"
@@ -154,7 +154,7 @@ class Roda
           res = nil
 
           call_next = catch(:next) do
-            env[@mid.opts[:middleware_env_var]] = true
+            env[@mid.middleware_env_var] = true
             res = @mid.call(env)
             false
           end
@@ -167,7 +167,7 @@ class Roda
             end
           end
 
-          if handle_result = @mid.opts[:middleware_handle_result]
+          if handle_result = @mid.middleware_handle_result
             handle_result.call(env, res)
           end
 
@@ -176,6 +176,12 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :middleware_env_var)
+        RodaPlugins.opt_attr_reader(self, :middleware_configure)
+        RodaPlugins.opt_attr_reader(self, :middleware_handle_result)
+        RodaPlugins.opt_attr_reader(self, :middleware_forward_response_headers)
+        RodaPlugins.opt_attr_reader(self, :middleware_next_if_not_found, name: :middleware_next_if_not_found?)
+
         # Create a Forwarder instead of a new instance if a non-Hash is given.
         def new(app, *args, &block)
           if app.is_a?(Hash)
@@ -193,7 +199,7 @@ class Roda
           super do |r|
             res = instance_exec(r, &block) # call Fallback
             if r.forward_next
-              r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+              r.env['roda.response_headers'] = response.headers if self.class.middleware_forward_response_headers
               throw :next, true
             end
             res
@@ -205,7 +211,7 @@ class Roda
         def _roda_run_main_route(r)
           res = super
           if r.forward_next
-            r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+            r.env['roda.response_headers'] = response.headers if self.class.middleware_forward_response_headers
             throw :next, true
           end
           res
@@ -216,7 +222,7 @@ class Roda
         # Whether to forward the request to the next application.  Set only if
         # this request is being performed for middleware.
         def forward_next
-          env[roda_class.opts[:middleware_env_var]]
+          env[roda_class.middleware_env_var]
         end
       end
     end

data/lib/roda/plugins/module_include.rb

@@ -83,7 +83,7 @@ class Roda
               klass.send(:include, mod)
             end
 
-            mod.module_eval(&block) if block
+            mod.module_eval(&block) if block # RODA4: Switch to module_exec
           end
 
           mod

data/lib/roda/plugins/multi_public.rb

@@ -72,7 +72,7 @@ class Roda
 
       # Use the given directories to setup servers.  Any opts are passed to the public plugin.
       def self.configure(app, directories, _=OPTS)
-        roots = app.opts[:multi_public_servers] = (app.opts[:multi_public_servers] || {}).dup
+        roots = app.opts[:multi_public_servers] = (app.multi_public_servers || {}).dup
         directories.each do |key, path|
           path, headers, mime = path
           roots[key] = RACK_FILES.new(app.expand_path(path), headers||{}, mime||'text/plain')
@@ -80,11 +80,15 @@ class Roda
         roots.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :multi_public_servers)
+      end
+
       module RequestMethods
         # Serve files from the directory corresponding to the given key if the file exists and
         # this is a GET request.
         def multi_public(key)
-          public_serve_with(roda_class.opts[:multi_public_servers].fetch(key))
+          public_serve_with(roda_class.multi_public_servers.fetch(key))
         end
       end
     end

data/lib/roda/plugins/multi_route.rb

@@ -94,7 +94,7 @@ class Roda
         # Freeze the multi_route regexp matchers so that there can be no thread safety issues at runtime.
         def freeze
           super
-          opts[:namespaced_routes].each_key do |k|
+          namespaced_routes.each_key do |k|
             self::RodaRequest.named_route_regexp(k)
           end
           self::RodaRequest.instance_variable_get(:@namespaced_route_regexps).freeze

data/lib/roda/plugins/multi_run.rb

@@ -70,12 +70,15 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :multi_run_apps)
+        RodaPlugins.opt_attr_reader(self, :multi_run_app_blocks)
+
         # Convert app blocks into apps by calling them, in order to force autoloads
         # and to speed up subsequent calls.
         # Freeze the multi_run apps so that there can be no thread safety issues at runtime.
         def freeze
-          app_blocks = opts[:multi_run_app_blocks]
-          apps = opts[:multi_run_apps]
+          app_blocks = multi_run_app_blocks
+          apps = multi_run_apps
           app_blocks.each do |prefix, block|
             apps[prefix] = block.call
           end
@@ -85,12 +88,6 @@ class Roda
           super
         end
 
-        # Hash storing rack applications to dispatch to, keyed by the prefix
-        # for the application.
-        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. If a block is given, it is called every time
         # there is a request for the route to get the app to call. If neither
@@ -100,14 +97,14 @@ class Roda
           prefix = prefix.to_s
           if app 
             raise Roda::RodaError, "cannot provide both app and block to Roda.run" if block
-            opts[:multi_run_apps][prefix] = app
-            opts[:multi_run_app_blocks].delete(prefix)
+            multi_run_apps[prefix] = app
+            multi_run_app_blocks.delete(prefix)
           elsif block
-            opts[:multi_run_apps].delete(prefix)
-            opts[:multi_run_app_blocks][prefix] = block
+            multi_run_apps.delete(prefix)
+            multi_run_app_blocks[prefix] = block
           else
-            opts[:multi_run_apps].delete(prefix)
-            opts[:multi_run_app_blocks].delete(prefix)
+            multi_run_apps.delete(prefix)
+            multi_run_app_blocks.delete(prefix)
           end
           self::RodaRequest.refresh_multi_run_regexp!
         end
@@ -117,7 +114,7 @@ class Roda
         # Refresh the multi_run_regexp, using the stored route prefixes,
         # preferring longer routes before shorter routes.
         def refresh_multi_run_regexp!
-          @multi_run_regexp = /(#{Regexp.union((roda_class.opts[:multi_run_apps].keys + roda_class.opts[:multi_run_app_blocks].keys).sort.reverse)})/
+          @multi_run_regexp = /(#{Regexp.union((roda_class.multi_run_apps.keys + roda_class.multi_run_app_blocks.keys).sort.reverse)})/
         end
 
         # Refresh the multi_run_regexp if it hasn't been loaded yet.
@@ -132,8 +129,7 @@ class Roda
         def multi_run
           on self.class.multi_run_regexp do |prefix|
             yield prefix if defined?(yield)
-            opts = scope.opts
-            run(opts[:multi_run_apps][prefix] || opts[:multi_run_app_blocks][prefix].call)
+            run(roda_class.multi_run_apps[prefix] || roda_class.multi_run_app_blocks[prefix].call)
           end
         end
       end

data/lib/roda/plugins/named_routes.rb

@@ -111,22 +111,24 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :namespaced_routes)
+
         # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
         def freeze
-          opts[:namespaced_routes].freeze.each_value(&:freeze)
+          namespaced_routes.freeze.each_value(&:freeze)
           super
         end
 
         # Copy the named routes into the subclass when inheriting.
         def inherited(subclass)
           super
-          nsr = subclass.opts[:namespaced_routes]
-          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
+          nsr = subclass.namespaced_routes
+          namespaced_routes.each{|k, v| nsr[k] = v.dup}
         end
 
         # The names for the currently stored named routes
         def named_routes(namespace=nil)
-          unless routes = opts[:namespaced_routes][namespace]
+          unless routes = namespaced_routes[namespace]
             raise RodaError, "unsupported named_routes namespace used: #{namespace.inspect}"
           end
           routes.keys
@@ -134,7 +136,7 @@ class Roda
 
         # Return the named route with the given name.
         def named_route(name, namespace=nil)
-          opts[:namespaced_routes][namespace][name]
+          namespaced_routes[namespace][name]
         end
 
         # If the given route has a name, treat it as a named route and
@@ -142,7 +144,7 @@ class Roda
         # call super.
         def route(name=nil, namespace=nil, &block)
           if name
-            routes = opts[:namespaced_routes][namespace] ||= {}
+            routes = namespaced_routes[namespace] ||= {}
             if block
               routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1, &convert_route_block(block))
             elsif meth = routes.delete(name)

data/lib/roda/plugins/named_templates.rb

@@ -61,15 +61,17 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :named_templates)
+
         # Freeze the named templates so that there can be no thread safety issues at runtime.
         def freeze
-          opts[:named_templates].freeze
+          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, define_roda_method("named_templates_#{name}", 0, &block)].freeze
+          named_templates[name.to_s] = [options, define_roda_method("named_templates_#{name}", 0, &block)].freeze
           nil
         end
       end
@@ -80,7 +82,7 @@ class Roda
         # If a template name is given and it matches a named template, call
         # the named template block to get the inline template to use.
         def find_template(options)
-          if options[:template] && (template_opts, meth = opts[:named_templates][template_name(options)]; meth)
+          if options[:template] && (template_opts, meth = self.class.named_templates[template_name(options)]; meth)
             if template_opts
               options = template_opts.merge(options)
             else

data/lib/roda/plugins/optimized_segment_matchers.rb

@@ -27,11 +27,16 @@ class Roda
           rp = @remaining_path
           if rp.getbyte(0) == 47
             if last = rp.index('/', 1)
-              @remaining_path = rp[last, rp.length]
-              always{yield rp[1, last-1]}
+              return false if last == 1
+              always do
+                @remaining_path = rp[last, rp.length]
+                yield rp[1, last-1]
+              end
             elsif (len = rp.length) > 1
-              @remaining_path = ""
-              always{yield rp[1, len]}
+              always do
+                @remaining_path = ""
+                yield rp[1, len]
+              end
             end
           end
         end
@@ -41,8 +46,10 @@ class Roda
         def is_segment
           rp = @remaining_path
           if rp.getbyte(0) == 47 && !rp.index('/', 1) && (len = rp.length) > 1
-            @remaining_path = ""
-            always{yield rp[1, len]}
+            always do
+              @remaining_path = ""
+              yield rp[1, len]
+            end
           end
         end
       end

data/lib/roda/plugins/optimized_string_matchers.rb

@@ -28,7 +28,11 @@ class Roda
       module RequestMethods
         # Optimized version of +on+ that only supports a single string.
         def on_branch(s)
-          always{yield} if _match_string(s)
+          rp = @remaining_path
+          if _match_string(s)
+            always{yield}
+            @remaining_path = rp
+          end
         end
 
         # Optimized version of +is+ that only supports a single string.
@@ -37,9 +41,8 @@ class Roda
           if _match_string(s)
             if @remaining_path.empty?
               always{yield}
-            else
-              @remaining_path = rp
             end
+            @remaining_path = rp
           end
         end
       end

data/lib/roda/plugins/params_capturing.rb

@@ -54,14 +54,20 @@ class Roda
     # Also note that this plugin will not work correctly if you are using
     # the symbol_matchers plugin with custom symbol matching and are using
     # symbols that capture multiple values or no values.
+    #
+    # If you are using the pass or break plugin along with this plugin,
+    # it is recommended you load the params_capturing_restore plugin, as that
+    # allows +r.pass+ or +break+ inside param capturing blocking to work
+    # correctly.
     module ParamsCapturing
       REQUEST_INSTANCE_VARIABLES = [:@_params_captures].freeze
 
       module RequestMethods
         # Lazily initialize captures entry when params is called.
         def params
+          return @params if @params
           ret = super
-          ret['captures'] ||= []
+          ret['captures'] = []
           ret
         end
 
@@ -100,16 +106,19 @@ class Roda
           end
 
           super do |*a|
-            if pc
-              @_params_captures = nil
-              pc.zip(a).each do |k,v|
-                params[k] = v
-              end
-            end
+            _set_params_captures(a) if pc
             params['captures'].concat(a) 
             yield(*a)
           end
         end
+
+        # Set the captures into the parameters.
+        def _set_params_captures(a)
+          @_params_captures.zip(a).each do |k,v|
+            params[k] = v
+          end
+          @_params_captures = nil
+        end
       end
     end
 

data/lib/roda/plugins/params_capturing_restore.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The params_capturing_restore plugin allows the params_capturing plugin
+    # to work with the use of +r.pass+ (pass plugin) or +break+ (break plugin)
+    # inside a block that uses param capturing, restoring the previous state of
+    # the params.
+    #
+    # This is not done by the params_capturing plugin as it requires significant
+    # extra work for every param capturing block, and most users of the
+    # params_capturing plugin are not using the pass or break plugins.
+    module ParamsCapturingRestore
+      REQUEST_INSTANCE_VARIABLES = [:@_params_captures_restore].freeze
+
+      ABSENT = Object.new.freeze
+      private_constant :ABSENT
+
+      def self.load_dependencies(app)
+        app.plugin :params_capturing
+      end
+
+      module RequestMethods
+        private
+
+        # Restore previous state of the params before capturing when
+        # the block exits.
+        def if_match(args)
+          params = self.params
+          num_captures = params['captures'].length
+          old_params = nil
+
+          super do |*a|
+            old_params = @_params_captures_restore
+            @_params_captures_restore = nil
+            yield(*a)
+          end
+        ensure
+          if old_params
+            old_params.each_slice(2) do |k, v|
+              if v == ABSENT
+                params.delete(k)
+              else
+                params[k] = v
+              end
+            end
+          end
+
+          captures = params['captures']
+          if num_captures != captures.length
+            captures.slice!(num_captures, 1000000)
+          end
+        end
+
+        # Record the original value of the params before calling super
+        # to update the params.
+        def _set_params_captures(a)
+          restore = @_params_captures_restore = []
+          @_params_captures.zip(a).each do |k,v|
+            restore << k << params.fetch(k, ABSENT)
+          end
+
+          super
+        end
+      end
+    end
+
+    register_plugin(:params_capturing_restore, ParamsCapturingRestore)
+  end
+end
+

data/lib/roda/plugins/part.rb

@@ -44,19 +44,19 @@ class Roda
               render(template, :locals=>locals, &block)
             end
           RUBY
-        # :nocov:
+        # simplecov:disable
         else
           def part(template, locals=OPTS, &block)
             render(template, :locals=>locals, &block)
           end
         end
-        # :nocov:
+        # simplecov:enable
       end
 
       module AssumeFixedLocalsInstanceMethods
-        # :nocov:
+        # simplecov:disable
         if RUBY_VERSION >= '3.0'
-        # :nocov:
+        # simplecov:enable
           class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
             def part(template, ...)
               if optimized_method = _optimized_render_method_for_locals(template, OPTS)

data/lib/roda/plugins/pass.rb

@@ -29,7 +29,10 @@ class Roda
 
         # Handle passing inside the match block.
         def always
-          catch(:pass){super}
+          rp = @remaining_path
+          ret = catch(:pass){super}
+          @remaining_path = rp
+          ret
         end
 
         # Handle passing inside the match block.