roda 3.86.0 → 3.88.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1851a201539b728f1af90ea1b85b2b33a9026f71986cb65c1aabdd079f653ad
-  data.tar.gz: f360e0bfeb3442df2fa1f96e28362eee9850c0f54d160bfbfc2b11d62d33ba39
+  metadata.gz: bfe23e68b3616d0513c55ca0d6006639eaa5595c36e48445e3a4b961f17dc483
+  data.tar.gz: 110d2f273b1b2eee5d0717d7238c3c131d7dd9fd2f7eb5a7ff0b575ce0256af0
 SHA512:
-  metadata.gz: d2bef4abc3d5e08ddb5a1c9c27f8b626b631a5951cec7cee062c497074cb7f68e6c8b36e75261cc913a580a87d5111438e8a21488669812c9a3b227bf9609e0b
-  data.tar.gz: e668a47039e529aa026e21ddfd6346b3e1fa224f432b46085b33242c9551ced88278328f2d2d471b2593f841da0a882d8f85dd2468277484409f679485a219df
+  metadata.gz: 2c60bdca82724f3f1f468ca408e6d58a7fb61bb49e5819835afdb59743b82a8f1ad77e98775f8ce720bcc4aff4d72ae2e3526419cba509d60588eefd585aedba
+  data.tar.gz: 223ed6296acb9829902050161f88356e4bd6d2e5da5dc06e43175b4a59cd38c312a63c79cd93b5f2c648d7bf25e84f66a1ab02c72b603b42866ad434851350d1

data/lib/roda/plugins/custom_block_results.rb

@@ -28,7 +28,16 @@ class Roda
     #
     # Note that custom block result handling only occurs if the types
     # are not handled by Roda itself.  You cannot use this to modify
-    # the handling of nil, false, or string results.
+    # the handling of nil, false, or string results.  Additionally,
+    # if the response body has already been written to before the the
+    # route block exits, then the result of the block is ignored,
+    # and the related +handle_block_result+ block will not be called
+    # (this is standard Roda behavior).
+    # 
+    # The return value of the +handle_block_result+ block is written
+    # to the body if the block return value is a String, similar to
+    # standard Roda handling of block results.  Non-String return
+    # values are ignored.
     module CustomBlockResults
       def self.configure(app)
         app.opts[:custom_block_results] ||= {}
@@ -55,7 +64,15 @@ class Roda
         # to get the block result.
         def unsupported_block_result(result)
           roda_class.opts[:custom_block_results].each do |klass, meth|
-            return scope.send(meth, result) if klass === result
+            if klass === result
+              result = scope.send(meth, result)
+
+              if String === result
+                return result
+              else
+                return
+              end
+            end
           end
 
           super

data/lib/roda/plugins/head.rb

@@ -45,7 +45,7 @@ class Roda
         end
 
         # yield nothing
-        def each
+        def each(&_)
         end
 
         # this should be called by the Rack server

data/lib/roda/plugins/header_matchers.rb

@@ -51,7 +51,8 @@ class Roda
 
         # Match if the given uppercase key is present inside the environment.
         def match_header(key)
-          key = key.upcase.tr("-","_")
+          key = key.upcase
+          key.tr!("-","_")
           unless key == "CONTENT_TYPE" || key == "CONTENT_LENGTH"
             key = "HTTP_#{key}"
           end
@@ -75,8 +76,8 @@ class Roda
         # Match the submitted user agent to the given pattern, capturing any
         # regexp match groups.
         def match_user_agent(pattern)
-          if (user_agent = @env["HTTP_USER_AGENT"]) && user_agent.to_s =~ pattern
-            @captures.concat($~[1..-1])
+          if (user_agent = @env["HTTP_USER_AGENT"]) && (match = pattern.match(user_agent))
+            @captures.concat(match.captures)
           end
         end
       end

data/lib/roda/plugins/host_routing.rb

@@ -0,0 +1,190 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The host_routing plugin adds support for more routing requests based on
+    # the requested host.  It also adds predicate methods for checking
+    # whether a request was requested with the given host.
+    #
+    # When loading the plugin, you pass a block, which is used for configuring
+    # the plugin.  For example, if you want to treat requests to api.example.com
+    # or api2.example.com as api requests, and treat other requests as www
+    # requests, you could use:
+    #
+    #   plugin :host_routing do |hosts|
+    #     hosts.to :api, "api.example.com", "api2.example.com"
+    #     hosts.default :www
+    #   end
+    #
+    # With this configuration, in your routing tree, you can call the +r.api+ and
+    # +r.www+ methods for dispatching to routing blocks only for those types of
+    # requests:
+    #
+    #   route do |r|
+    #     r.api do
+    #       # requests to api.example.com or api2.example.com
+    #     end
+    #
+    #     r.www do
+    #       # requests to other domains
+    #     end
+    #   end
+    #
+    # In addition to the routing methods, predicate methods are also added to the
+    # request object:
+    #
+    #   route do |r|
+    #     "#{r.api?}-#{r.www?}"
+    #   end
+    #   # Requests to api.example.com or api2.example.com return "true-false"
+    #   # Other requests return "false-true"
+    #
+    # If the +:scope_predicates+ plugin option is given, predicate methods are also
+    # created in route block scope:
+    #
+    #   plugin :host_routing, scope_predicates: true do |hosts|
+    #     hosts.to :api, "api.example.com"
+    #     hosts.default :www
+    #   end
+    #
+    #   route do |r|
+    #     "#{api?}-#{www?}"
+    #   end
+    #
+    # To handle hosts that match a certain format (such as all subdomains),
+    # where the specific host names are not known up front, you can provide a block
+    # when calling +hosts.default+. This block is passed the host name, or an empty
+    # string if no host name is provided, and is evaluated in route block scope.
+    # When using this support, you should also call +hosts.register+
+    # to register host types that could be returned by the block.  For example, to
+    # handle api subdomains differently:
+    #
+    #   plugin :host_routing do |hosts|
+    #     hosts.to :api, "api.example.com"
+    #     hosts.register :api_sub
+    #     hosts.default :www do |host|
+    #       :api_sub if host.end_with?(".api.example.com")
+    #     end
+    #   end
+    #
+    # This plugin uses the host method on the request to get the hostname (this method
+    # is defined by Rack).
+    module HostRouting
+      # Setup the host routing support.  The block yields an object used to
+      # configure the plugin.  Options:
+      #
+      # :scope_predicates :: Setup predicate methods in route block scope
+      #                      in addition to request scope.
+      def self.configure(app, opts=OPTS, &block)
+        hosts, host_hash, default_block, default_host = DSL.new.process(&block)
+        app.opts[:host_routing_hash] = host_hash
+        app.opts[:host_routing_default_host] = default_host
+
+        app.send(:define_method, :_host_routing_default, &default_block) if default_block
+
+        app::RodaRequest.class_exec do
+          hosts.each do |host|
+            host_sym = host.to_sym
+            define_method(host_sym){|&blk| always(&blk) if _host_routing_host == host}
+            alias_method host_sym, host_sym
+
+            meth = :"#{host}?"
+            define_method(meth){_host_routing_host == host}
+            alias_method meth, meth
+          end
+        end
+
+        if opts[:scope_predicates]
+          app.class_exec do
+            hosts.each do |host|
+              meth = :"#{host}?"
+              define_method(meth){@_request.send(meth)}
+              alias_method meth, meth
+            end
+          end
+        end
+      end
+
+      class DSL
+        def initialize
+          @hosts = []
+          @host_hash = {}
+        end
+
+        # Run the DSL for the given block.
+        def process(&block)
+          instance_exec(self, &block)
+
+          if !@default_host
+            raise RodaError, "must call default method inside host_routing plugin block to set default host"
+          end
+
+          @hosts.concat(@host_hash.values)
+          @hosts << @default_host
+          @hosts.uniq!
+          [@hosts.freeze, @host_hash.freeze, @default_block, @default_host].freeze
+        end
+        
+        # Register hosts that can be returned.  This is only needed if
+        # calling register with a block, where the block can return
+        # a value that doesn't match a host given to +to+ or +default+.
+        def register(*hosts)
+          @hosts = hosts
+        end
+
+        # Treat all given hostnames as routing to the give host.
+        def to(host, *hostnames)
+          hostnames.each do |hostname|
+            @host_hash[hostname] = host
+          end
+        end
+
+        # Register the default hostname.  If a block is provided, it is
+        # called with the host if there is no match for one of the hostnames
+        # provided to +to+.  If the block returns nil/false, the hostname
+        # given to this method is used.
+        def default(hostname, &block)
+          @default_host = hostname
+          @default_block = block
+        end
+      end
+      private_constant :DSL
+
+      module InstanceMethods
+        # Handle case where plugin is used without providing a block to
+        # +hosts.default+.  This returns nil, ensuring that the hostname
+        # provided to +hosts.default+ will be used.
+        def _host_routing_default(_)
+          nil
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Cache the host to use in the host routing support, so the processing
+        # is only done once per request.
+        def _host_routing_host
+          @_host_routing_host ||= _get_host_routing_host
+        end
+
+        # Determine the host to use for the host routing support.  Tries the
+        # following, in order:
+        #
+        # * An exact match for a hostname given in +hosts.to+
+        # * The return value of the +hosts.default+ block, if given
+        # * The default value provided in the +hosts.default+ call
+        def _get_host_routing_host
+          host = self.host || ""
+
+          roda_class.opts[:host_routing_hash][host] ||
+            scope._host_routing_default(host) ||
+            roda_class.opts[:host_routing_default_host]
+        end
+      end
+    end
+
+    register_plugin(:host_routing, HostRouting)
+  end
+end

data/lib/roda/plugins/json_parser.rb

@@ -53,27 +53,28 @@ class Roda
         # parse the request body as JSON.  Ignore an empty request body.
         def POST
           env = @env
-          if post_params = (env["roda.json_params"] || env["rack.request.form_hash"])
-            post_params
-          elsif (input = env["rack.input"]) && content_type =~ /json/
-            str = _read_json_input(input)
-            return super if str.empty?
-            begin
-              json_params = parse_json(str)
-            rescue
-              roda_class.opts[:json_parser_error_handler].call(self)
-            end
+          if post_params = env["roda.json_params"]
+            return post_params
+          end
+
+          unless (input = env["rack.input"]) && (content_type = self.content_type) && content_type.include?('json')
+            return super
+          end
+
+          str = _read_json_input(input)
+          return super if str.empty?
+          begin
+            json_params = parse_json(str)
+          rescue
+            roda_class.opts[:json_parser_error_handler].call(self)
+          end
 
-            wrap = roda_class.opts[:json_parser_wrap]
-            if wrap == :always || (wrap == :unless_hash && !json_params.is_a?(Hash))
-              json_params = {"_json"=>json_params}
-            end
-            env["roda.json_params"] = json_params
-            env["rack.request.form_input"] = input
-            json_params
-          else
-            super
+          wrap = roda_class.opts[:json_parser_wrap]
+          if wrap == :always || (wrap == :unless_hash && !json_params.is_a?(Hash))
+            json_params = {"_json"=>json_params}
           end
+          env["roda.json_params"] = json_params
+          json_params
         end
 
         private

data/lib/roda/plugins/render.rb

@@ -118,6 +118,45 @@ class Roda
     # have either +:template+, +:inline+, +:path+, or +:content+ (for +view+) as
     # one of the keys.
     #
+    # = Fixed Locals in Templates
+    #
+    # By default, you can pass any local variables to any templates.  A separate
+    # template method is compiled for each combination of locals.  This causes
+    # multiple issues:
+    # 
+    # * It is inefficient, especially for large templates that are called with
+    #   many combinations of locals.
+    # * It hides issues if unused local variable names are passed to the template
+    # * It does not support default values for local variables
+    # * It does not support required local variables
+    # * It does not support cases where you want to pass values via a keyword splat
+    # * It does not support named blocks
+    #
+    # If you are using Tilt 2.6+, you can used fixed locals in templates, by
+    # passing the appropriate options in :template_opts.  For example, if you
+    # are using ERB templates, the recommended way to use the render plugin is to
+    # use the +:extract_fixed_locals+ and +:default_fixed_locals+ template options:
+    #
+    #   plugin :render, template_opts: {extract_fixed_locals: true, default_fixed_locals: '()'}
+    #
+    # This will default templates to not allowing any local variables to be passed.
+    # If the template requires local variables, you can specify them using a magic
+    # comment in the template, such as:
+    # 
+    #   <%# locals(required_local:, optional_local: nil) %>
+    #
+    # The magic comment is used as method parameters when defining the compiled template
+    # method.
+    #
+    # For better debugging of issues with invalid keywords being passed to templates that
+    # have not been updated to support fixed locals, it can be helpful to set
+    # +:default_fixed_locals+ to use a single optional keyword argument
+    # <tt>'(_no_kw: nil)'</tt>.  This makes the error message show which keywords
+    # were passed, instead of showing that the takes no arguments (if you use <tt>'()'</tt>),
+    # or that no keywords are accepted (if you pass <tt>(**nil)</tt>).
+    #
+    # See Tilt's documentation for more information regarding fixed locals.
+    #
     # = Speeding Up Template Rendering
     #
     # The render/view method calls are optimized for usage with a single symbol/string
@@ -131,6 +170,21 @@ class Roda
     # the hash, making sure the +:cache_key+ is unique to the template you are
     # rendering.
     #
+    # = Recommended +template_opts+
+    #
+    # Here are the recommended values of :template_opts for new applications (a couple
+    # are Erubi-specific and can be ignored if you are using other templates engines):
+    #
+    #   plugin :render, template_opts: {
+    #       scope_class: self,          # Always uses current class as scope class for compiled templates
+    #       freeze: true,               # Freeze string literals in templates
+    #       extract_fixed_locals: true, # Support fixed locals in templates
+    #       default_fixed_locals: '()', # Default to templates not supporting local variables
+    #       escape: true,               # For Erubi templates, escapes <%= by default (use <%== for unescaped
+    #       chain_appends: true,        # For Erubi templates, improves performance
+    #       skip_compiled_encoding_detection: true, # Unless you need encodings explicitly specified
+    #     }
+    #
     # = Accepting Template Blocks in Methods
     #
     # If you are used to Rails, you may be surprised that this type of template code
@@ -228,6 +282,19 @@ class Roda
         ([1, -2].include?(((compiled_method_arity = Tilt::Template.instance_method(:compiled_method).arity) rescue false)))
       NO_CACHE = {:cache=>false}.freeze
       COMPILED_METHOD_SUPPORT = RUBY_VERSION >= '2.3' && tilt_compiled_method_support && ENV['RODA_RENDER_COMPILED_METHOD_SUPPORT'] != 'no'
+      FIXED_LOCALS_COMPILED_METHOD_SUPPORT = COMPILED_METHOD_SUPPORT && Tilt::Template.method_defined?(:fixed_locals?)
+
+      if FIXED_LOCALS_COMPILED_METHOD_SUPPORT
+        def self.tilt_template_fixed_locals?(template)
+          template.fixed_locals?
+        end
+      # :nocov:
+      else
+        def self.tilt_template_fixed_locals?(template)
+          false
+        end
+      end
+      # :nocov:
 
       if compiled_method_arity == -2
         def self.tilt_template_compiled_method(template, locals_keys, scope_class)
@@ -385,6 +452,11 @@ class Roda
         end
 
         if COMPILED_METHOD_SUPPORT
+          # Whether the underlying template uses fixed locals.
+          def fixed_locals?
+            Render.tilt_template_fixed_locals?(@template)
+          end
+
           # Compile a method in the given module with the given name that will
           # call the compiled template method, updating the compiled template method
           def define_compiled_method(roda_class, method_name, locals_keys=EMPTY_ARRAY)
@@ -403,6 +475,15 @@ class Roda
             method_name
           end
 
+          # Returns an appropriate value for the template method cache.
+          def define_compiled_method_cache_value(roda_class, method_name, locals_keys=EMPTY_ARRAY)
+            if compiled_method = define_compiled_method(roda_class, method_name, locals_keys)
+              [compiled_method, false].freeze
+            else
+              compiled_method
+            end
+          end
+
           private
 
           # Return the compiled method for the current template object.
@@ -422,7 +503,7 @@ class Roda
                 mod.send(:private, method_name)
               end
 
-              send(method_name, locals, &block)
+              _call_optimized_template_method([method_name, Render.tilt_template_fixed_locals?(template)], locals, &block)
             end
           end
         end
@@ -489,17 +570,17 @@ class Roda
         def _freeze_layout_method
           if render_opts[:layout]
             instance = allocate
+            # This needs to be called even if COMPILED_METHOD_SUPPORT is not set,
+            # in order for the precompile_templates plugin to work correctly.
             instance.send(:retrieve_template, instance.send(:view_layout_opts, OPTS))
 
-            if COMPILED_METHOD_SUPPORT
-              if (layout_template = render_opts[:optimize_layout]) && !opts[:render][:optimized_layout_method_created]
+            if COMPILED_METHOD_SUPPORT && (layout_template = render_opts[:optimize_layout]) && !opts[:render][:optimized_layout_method_created]
                 instance.send(:retrieve_template, :template=>layout_template, :cache_key=>nil, :template_method_cache_key => :_roda_layout)
                 layout_method = opts[:render][:template_method_cache][:_roda_layout]
                 define_method(:_layout_method){layout_method}
                 private :_layout_method
                 alias_method(:_layout_method, :_layout_method)
                 opts[:render] = opts[:render].merge(:optimized_layout_method_created=>true)
-              end
             end
           end
         end
@@ -509,9 +590,9 @@ class Roda
         # Render the given template. See Render for details.
         def render(template, opts = (no_opts = true; optimized_template = _cached_template_method(template); OPTS), &block)
           if optimized_template
-            send(optimized_template, OPTS, &block)
+            _call_optimized_template_method(optimized_template, OPTS, &block)
           elsif !no_opts && opts.length == 1 && (locals = opts[:locals]) && (optimized_template = _optimized_render_method_for_locals(template, locals))
-            send(optimized_template, locals, &block)
+            _call_optimized_template_method(optimized_template, locals, &block)
           else
             opts = render_template_opts(template, opts)
             retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||OPTS), &block)
@@ -534,7 +615,7 @@ class Roda
             # and use it if so.  This way avoids the extra conditional and local variable
             # assignments in the next section.
             if layout_method = _layout_method
-              return send(layout_method, OPTS){content}
+              return _call_optimized_template_method(layout_method, OPTS){content}
             end
 
             # If we have an optimized template method but no optimized layout method, create the
@@ -543,7 +624,7 @@ class Roda
             if layout_template = self.class.opts[:render][:optimize_layout]
               retrieve_template(:template=>layout_template, :cache_key=>nil, :template_method_cache_key => :_roda_layout)
               if layout_method = _layout_method
-                return send(layout_method, OPTS){content}
+                return _call_optimized_template_method(layout_method, OPTS){content}
               end
             end
           else
@@ -594,37 +675,43 @@ class Roda
           def _optimized_render_method_for_locals(template, locals)
             return unless method_cache = render_opts[:template_method_cache]
 
-            locals_keys = locals.keys.sort
-            key = [:_render_locals, template, locals_keys]
-
-            optimized_template = case template
+            case template
             when String, Symbol
-              _cached_template_method_lookup(method_cache, key)
+              key = [:_render_locals, template]
+              if optimized_template = _cached_template_method_lookup(method_cache, key)
+                # Fixed locals case
+                return optimized_template
+              end
+
+              locals_keys = locals.keys.sort
+              key << locals_keys
+              if optimized_template = _cached_template_method_lookup(method_cache, key)
+                # Regular locals case
+                return optimized_template
+              end
             else
               return
             end
 
-            case optimized_template
-            when Symbol
-              optimized_template
-            else
-              if method_cache_key = _cached_template_method_key(key)
-                template_obj = retrieve_template(render_template_opts(template, NO_CACHE))
-                method_name = :"_roda_template_locals_#{self.class.object_id}_#{method_cache_key}"
+            if method_cache_key = _cached_template_method_key(key)
+              template_obj = retrieve_template(render_template_opts(template, NO_CACHE))
+              key.pop if fixed_locals = Render.tilt_template_fixed_locals?(template_obj)
+              key.freeze
+              method_cache_key.freeze
+              method_name = :"_roda_template_locals_#{self.class.object_id}_#{method_cache_key}"
 
-                method_cache[method_cache_key] = case template_obj
-                when Render::TemplateMtimeWrapper
-                  template_obj.define_compiled_method(self.class, method_name, locals_keys)
+              method_cache[method_cache_key] = case template_obj
+              when Render::TemplateMtimeWrapper
+                template_obj.define_compiled_method_cache_value(self.class, method_name, locals_keys)
+              else
+                begin
+                  unbound_method = Render.tilt_template_compiled_method(template_obj, locals_keys, self.class)
+                rescue ::NotImplementedError
+                  false
                 else
-                  begin
-                    unbound_method = Render.tilt_template_compiled_method(template_obj, locals_keys, self.class)
-                  rescue ::NotImplementedError
-                    false
-                  else
-                    self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
-                    self.class::RodaCompiledTemplates.send(:private, method_name)
-                    method_name
-                  end
+                  self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
+                  self.class::RodaCompiledTemplates.send(:private, method_name)
+                  [method_name, fixed_locals].freeze
                 end
               end
             end
@@ -634,11 +721,47 @@ class Roda
           # a single argument is passed to view.
           def _optimized_view_content(template)
             if optimized_template = _cached_template_method(template)
-              send(optimized_template, OPTS)
+              _call_optimized_template_method(optimized_template, OPTS)
             elsif template.is_a?(Hash) && template.length == 1
               template[:content]
             end
           end
+
+          if RUBY_VERSION >= '3'
+            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def _call_optimized_template_method((meth, fixed_locals), locals, &block)
+                if fixed_locals
+                  send(meth, **locals, &block)
+                else
+                  send(meth, locals, &block)
+                end
+              end
+            RUBY
+          # :nocov:
+          elsif RUBY_VERSION >= '2'
+            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def _call_optimized_template_method((meth, fixed_locals), locals, &block)
+                if fixed_locals
+                  if locals.empty?
+                    send(meth, &block)
+                  else
+                    send(meth, **locals, &block)
+                  end
+                else
+                  send(meth, locals, &block)
+                end
+              end
+            RUBY
+          else
+            # Call the optimized template method.  This is designed to be used with the
+            # method cache, which caches the method name and whether the method uses
+            # fixed locals.  Methods with fixed locals need to be called with a keyword
+            # splat.
+            def _call_optimized_template_method((meth, fixed_locals), locals, &block)
+              send(meth, locals, &block)
+            end
+          end
+          # :nocov:
         else
           def _cached_template_method(_)
             nil
@@ -648,10 +771,6 @@ class Roda
             nil
           end
 
-          def _layout_method
-            nil
-          end
-
           def _optimized_render_method_for_locals(_, _)
             nil
           end
@@ -661,7 +780,6 @@ class Roda
           end
         end
 
-
         # Convert template options to single hash when rendering templates using render.
         def render_template_opts(template, opts)
           parse_template_opts(template, opts)
@@ -772,7 +890,7 @@ class Roda
 
               if define_compiled_method
                 method_name = :"_roda_template_#{self.class.object_id}_#{method_cache_key}"
-                method_cache[method_cache_key] = template.define_compiled_method(self.class, method_name)
+                method_cache[method_cache_key] = template.define_compiled_method_cache_value(self.class, method_name)
               end
             else
               template = self.class.create_template(opts, template_opts)
@@ -786,7 +904,7 @@ class Roda
                   method_name = :"_roda_template_#{self.class.object_id}_#{method_cache_key}"
                   self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
                   self.class::RodaCompiledTemplates.send(:private, method_name)
-                  method_cache[method_cache_key] = method_name
+                  method_cache[method_cache_key] = [method_name, Render.tilt_template_fixed_locals?(template)].freeze
                 end
               end
             end

data/lib/roda/plugins/render_coverage.rb

@@ -50,17 +50,36 @@ class Roda
         # Set a compiled path on the created template, if the path for
         # the template is in one of the allowed_views.
         def create_template(opts, template_opts)
-          template = super
-          return template if opts[:template_block]
+          return super if opts[:template_block]
 
           path = File.expand_path(opts[:path])
+          compiled_path = nil
           (self.opts[:render_coverage_strip_paths] || render_opts[:allowed_paths]).each do |dir|
             if path.start_with?(dir + '/')
-              template.compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].gsub('/', '-'))
+              compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].gsub('/', '-'))
               break
             end
           end
 
+          # For Tilt 2.6+, when using :scope_class and fixed locals, must provide
+          # compiled path as option, since compilation happens during initalization
+          # in that case. This option should be ignored if the template does not
+          # support it, but some template class may break if the option is not
+          # handled, so for compatibility, only set the method if Tilt::Template
+          # will handle it.
+          if compiled_path && Tilt::Template.method_defined?(:fixed_locals?)
+            template_opts = template_opts.dup
+            template_opts[:compiled_path] = compiled_path
+            compiled_path = nil
+          end
+
+          template = super
+
+          # Set compiled path for template when using older tilt versions.
+          # :nocov:
+          template.compiled_path = compiled_path if compiled_path
+          # :nocov:
+
           template
         end
       end

data/lib/roda/plugins/render_each.rb

@@ -105,7 +105,7 @@ class Roda
           def _optimized_render_each(enum, optimized_template, as, locals)
             enum.map do |v|
               locals[as] = v
-              send(optimized_template, locals)
+              _call_optimized_template_method(optimized_template, locals)
             end.join
           end
         else

data/lib/roda/response.rb

@@ -46,8 +46,6 @@ class Roda
 
       # Instance methods for RodaResponse
       module ResponseMethods
-        DEFAULT_HEADERS = {RodaResponseHeaders::CONTENT_TYPE => "text/html".freeze}.freeze
-
         # The body for the current response.
         attr_reader :body
 
@@ -179,11 +177,15 @@ class Roda
         private
 
         if defined?(Rack::Headers) && Rack::Headers.is_a?(Class)
+          DEFAULT_HEADERS = Rack::Headers[{RodaResponseHeaders::CONTENT_TYPE => "text/html".freeze}].freeze
+
           # Use Rack::Headers for headers by default on Rack 3
           def _initialize_headers
             Rack::Headers.new
           end
         else
+          DEFAULT_HEADERS = {RodaResponseHeaders::CONTENT_TYPE => "text/html".freeze}.freeze
+
           # Use plain hash for headers by default on Rack 1-2
           def _initialize_headers
             {}

data/lib/roda/version.rb

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 3
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 86
+  RodaMinorVersion = 88
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.86.0
+  version: 3.88.0
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2025-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -150,7 +149,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - code@jeremyevans.net
 executables: []
@@ -225,6 +223,7 @@ files:
 - lib/roda/plugins/hmac_paths.rb
 - lib/roda/plugins/hooks.rb
 - lib/roda/plugins/host_authorization.rb
+- lib/roda/plugins/host_routing.rb
 - lib/roda/plugins/hsts.rb
 - lib/roda/plugins/indifferent_params.rb
 - lib/roda/plugins/inject_erb.rb
@@ -312,7 +311,6 @@ metadata:
   documentation_uri: https://roda.jeremyevans.net/documentation.html
   mailing_list_uri: https://github.com/jeremyevans/roda/discussions
   source_code_uri: https://github.com/jeremyevans/roda
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -327,8 +325,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Routing tree web toolkit
 test_files: []