roda 3.88.0 → 3.90.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfe23e68b3616d0513c55ca0d6006639eaa5595c36e48445e3a4b961f17dc483
-  data.tar.gz: 110d2f273b1b2eee5d0717d7238c3c131d7dd9fd2f7eb5a7ff0b575ce0256af0
+  metadata.gz: c42c5f4d45d0f7fe64602e9d2a32bec3c690606c98709f7bd0bde537dd7a6463
+  data.tar.gz: c5f4edfdf88244770bd0184220df443ea5183c017f11c7342b4192db158d8d6c
 SHA512:
-  metadata.gz: 2c60bdca82724f3f1f468ca408e6d58a7fb61bb49e5819835afdb59743b82a8f1ad77e98775f8ce720bcc4aff4d72ae2e3526419cba509d60588eefd585aedba
-  data.tar.gz: 223ed6296acb9829902050161f88356e4bd6d2e5da5dc06e43175b4a59cd38c312a63c79cd93b5f2c648d7bf25e84f66a1ab02c72b603b42866ad434851350d1
+  metadata.gz: 19ccf7e44d75f36bc372f2dcad01bb9bf23831c12397d142ea94d1e5f10d0cfe1be3f62f8f45e584ab9e4d0510c8d6acba7dd13e5d9df0680dece3838a43f5a6
+  data.tar.gz: 48e7c8fc21d75df1adfb616fa5fa88c2b410b290168b2fa1b14ab2c53f8f33167e039f310007dc19831e0571c4ce2b2d34c023b8b88c07d4ff666afe4b426ce9

data/lib/roda/plugins/common_logger.rb

@@ -56,14 +56,15 @@ class Roda
 
           env = @_request.env
 
-          line = "#{env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-"} - #{env["REMOTE_USER"] || "-"} [#{Time.now.strftime("%d/%b/%Y:%H:%M:%S %z")}] \"#{env["REQUEST_METHOD"]} #{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}#{"?#{env["QUERY_STRING"]}" if ((qs = env["QUERY_STRING"]) && !qs.empty?)} #{@_request.http_version}\" #{status} #{((length = headers[RodaResponseHeaders::CONTENT_LENGTH]) && (length unless length == '0')) || '-'} #{elapsed_time}\n"
+          line = "#{env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-"} - #{env["REMOTE_USER"] || "-"} [#{Time.now.strftime("%d/%b/%Y:%H:%M:%S %z")}] \"#{env["REQUEST_METHOD"]} #{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}#{"?#{env["QUERY_STRING"]}" if ((qs = env["QUERY_STRING"]) && !qs.empty?)} #{@_request.http_version}\" #{status} #{((length = headers[RodaResponseHeaders::CONTENT_LENGTH]) && (length unless length == '0')) || '-'} #{elapsed_time} "
           if MUTATE_LINE
-            line.gsub!(/[^[:print:]\n]/){|c| sprintf("\\x%x", c.ord)}
+            line.gsub!(/[^[:print:]]/){|c| sprintf("\\x%x", c.ord)}
           # :nocov:
           else
-            line = line.gsub(/[^[:print:]\n]/){|c| sprintf("\\x%x", c.ord)}
+            line = line.gsub(/[^[:print:]]/){|c| sprintf("\\x%x", c.ord)}
           # :nocov:
           end
+          line[-1] = "\n"
           opts[:common_logger_meth].call(line)
         end
 

data/lib/roda/plugins/mailer.rb

@@ -151,6 +151,9 @@ class Roda
             mail
           end
         end
+        # :nocov:
+        ruby2_keywords(:mail) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Calls +mail+ with given arguments and immediately sends the resulting mail.
         def sendmail(*args)
@@ -158,6 +161,9 @@ class Roda
             m.deliver
           end
         end
+        # :nocov:
+        ruby2_keywords(:sendmail) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
 
       module RequestMethods

data/lib/roda/plugins/middleware.rb

@@ -134,9 +134,7 @@ class Roda
         # and store +app+ as the next middleware to call.
         def initialize(mid, app, *args, &block)
           @mid = Class.new(mid)
-          # :nocov:
-          @mid.set_temporary_name("#{mid.name}(middleware)") if mid.name && RUBY_VERSION >= "3.3"
-          # :nocov:
+          RodaPlugins.set_temp_name(@mid){"#{mid}::middleware_subclass"}
           if @mid.opts[:middleware_next_if_not_found]
             @mid.plugin(:not_found, &NEXT_PROC)
           end

data/lib/roda/plugins/module_include.rb

@@ -79,6 +79,7 @@ class Roda
               mod = instance_variable_get(iv)
             else
               mod = instance_variable_set(iv, Module.new)
+              RodaPlugins.set_temp_name(mod){"#{klass}::module_include"}
               klass.send(:include, mod)
             end
 

data/lib/roda/plugins/part.rb

@@ -0,0 +1,76 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The part plugin adds a part method, which is a
+    # render-like method that treats all keywords as locals.
+    #
+    #   # Can replace this:
+    #   render(:template, locals: {foo: 'bar'})
+    #
+    #   # With this:
+    #   part(:template, foo: 'bar')
+    #
+    # On Ruby 2.7+, the part method takes a keyword splat, so you
+    # must pass keywords and not a positional hash for the locals.
+    #
+    # If you are using the :assume_fixed_locals render plugin option,
+    # template caching is enabled, you are using Ruby 3+, and you
+    # are freezing your Roda application, in addition to providing a
+    # simpler API, this also provides a significant performance
+    # improvement (more significant on Ruby 3.4+).
+    module Part
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module ClassMethods
+        # When freezing, optimize the part method if assuming fixed locals
+        # and caching templates.
+        def freeze
+          if render_opts[:assume_fixed_locals] && !render_opts[:check_template_mtime]
+            include AssumeFixedLocalsInstanceMethods
+          end
+
+          super
+        end
+      end
+
+      module InstanceMethods
+        if RUBY_VERSION >= '2.7'
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def part(template, **locals, &block)
+              render(template, :locals=>locals, &block)
+            end
+          RUBY
+        # :nocov:
+        else
+          def part(template, locals=OPTS, &block)
+            render(template, :locals=>locals, &block)
+          end
+        end
+        # :nocov:
+      end
+
+      module AssumeFixedLocalsInstanceMethods
+        # :nocov:
+        if RUBY_VERSION >= '3.0'
+        # :nocov:
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def part(template, ...)
+              if optimized_method = _optimized_render_method_for_locals(template, OPTS)
+                send(optimized_method[0], ...)
+              else
+                super
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+    register_plugin(:part, Part)
+  end
+end
+

data/lib/roda/plugins/render.rb

@@ -48,6 +48,9 @@ class Roda
     #
     # :allowed_paths :: Set the template paths to allow.  Attempts to render paths outside
     #                   of these paths will raise an error.  Defaults to the +:views+ directory.
+    # :assume_fixed_locals :: Set if you are sure all templates in your application use fixed locals
+    #                         to allow for additional optimization. This is ignored unless both
+    #                         compiled methods and fixed locals are not supported.
     # :cache :: nil/false to explicitly disable permanent template caching.  By default, permanent
     #           template caching is disabled by default if RACK_ENV is development.  When permanent
     #           template caching is disabled, for templates with paths in the file system, the
@@ -155,6 +158,11 @@ class Roda
     # 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>).
     #
+    # If you are sure your application works with all templates using fixed locals,
+    # set the :assume_fixed_locals render plugin option, which will allow the plugin
+    # to optimize cache lookup for renders with locals, and avoid duplicate compiled
+    # methods for templates rendered both with and without locals.
+    #
     # See Tilt's documentation for more information regarding fixed locals.
     #
     # = Speeding Up Template Rendering
@@ -175,7 +183,9 @@ class Roda
     # 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: {
+    #   plugin :render, 
+    #     assume_fixed_locals: true,    # Optimize plugin by assuming all templates use fixed locals
+    #     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
@@ -324,6 +334,7 @@ class Roda
         opts[:allowed_paths] ||= [opts[:views]].freeze
         opts[:allowed_paths] = opts[:allowed_paths].map{|f| app.expand_path(f, nil)}.uniq.freeze
         opts[:check_paths] = true unless opts.has_key?(:check_paths)
+        opts[:assume_fixed_locals] &&= FIXED_LOCALS_COMPILED_METHOD_SUPPORT
 
         unless opts.has_key?(:check_template_mtime)
           opts[:check_template_mtime] = if opts[:cache] == false || opts[:explicit_cache]
@@ -531,6 +542,12 @@ class Roda
               nil
             end
 
+            # Optimize _call_optimized_template_method if you know all templates
+            # are going to be using fixed locals.
+            if render_opts[:assume_fixed_locals] && !render_opts[:check_template_mtime]
+              include AssumeFixedLocalsInstanceMethods
+            end
+
             super
           end
         end
@@ -673,21 +690,29 @@ class Roda
           # of the template render if the optimized path is used, or nil if the optimized
           # path is not used and the long method needs to be used.
           def _optimized_render_method_for_locals(template, locals)
+            render_opts = self.render_opts
             return unless method_cache = render_opts[:template_method_cache]
 
             case template
             when String, Symbol
-              key = [:_render_locals, template]
-              if optimized_template = _cached_template_method_lookup(method_cache, key)
-                # Fixed locals case
-                return optimized_template
-              end
+              if fixed_locals = render_opts[:assume_fixed_locals]
+                key = template
+                if optimized_template = _cached_template_method_lookup(method_cache, key)
+                  return optimized_template
+                end
+              else
+                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
+                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
               end
             else
               return
@@ -695,9 +720,10 @@ class Roda
 
             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
+              unless fixed_locals
+                key.pop if fixed_locals = Render.tilt_template_fixed_locals?(template_obj)
+                key.freeze
+              end
               method_name = :"_roda_template_locals_#{self.class.object_id}_#{method_cache_key}"
 
               method_cache[method_cache_key] = case template_obj
@@ -953,6 +979,18 @@ class Roda
           end
         end
       end
+
+      module AssumeFixedLocalsInstanceMethods
+        # :nocov:
+        if RUBY_VERSION >= '3.0'
+        # :nocov:
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def _call_optimized_template_method((meth,_), locals, &block)
+              send(meth, **locals, &block)
+            end
+          RUBY
+        end
+      end
     end
 
     register_plugin(:render, Render)

data/lib/roda/plugins/sinatra_helpers.rb

@@ -354,9 +354,7 @@ class Roda
           res.status = opts[:status] || s
           headers.delete(RodaResponseHeaders::CONTENT_LENGTH)
           headers.replace(h.merge!(headers))
-          res.body = b
-
-          halt
+          halt res.finish_with_body(b)
         rescue Errno::ENOENT
           not_found
         end

data/lib/roda/plugins/symbol_views.rb

@@ -23,8 +23,11 @@ class Roda
     #     :foo
     #   end
     module SymbolViews
-      def self.configure(app)
+      def self.load_dependencies(app)
         app.plugin :custom_block_results
+      end
+
+      def self.configure(app)
         app.opts[:custom_block_results][Symbol] = :view
       end
     end

data/lib/roda/plugins/view_options.rb

@@ -133,7 +133,7 @@ class Roda
             return if @_view_options || @_layout_options
 
             if subdir = @_view_subdir
-              template = [subdir, template]
+              template = [subdir, template].freeze
             end
 
             super

data/lib/roda/plugins.rb

@@ -49,5 +49,20 @@ class Roda
       end
       # :nocov:
     end
+
+    if RUBY_VERSION >= '3.3'
+      # Create a new module using the block, and set the temporary name
+      # on it using the given a containing module and name.
+      def self.set_temp_name(mod)
+        mod.set_temporary_name(yield)
+        mod
+      end
+    # :nocov:
+    else
+      def self.set_temp_name(mod)
+        mod
+      end
+    end
+    # :nocov:
   end
 end

data/lib/roda/session_middleware.rb

@@ -159,6 +159,7 @@ class RodaSessionMiddleware
   # Setup the middleware, passing +opts+ as the Roda sessions plugin options.
   def initialize(app, opts)
     mid = Class.new(Roda)
+    Roda::RodaPlugins.set_temp_name(mid){"RodaSessionMiddleware::_RodaSubclass"}
     mid.plugin :sessions, opts
     @req_class = mid::RodaRequest
     @req_class.send(:include, RequestMethods)

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 = 88
+  RodaMinorVersion = 90
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.88.0
+  version: 3.90.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-01-14 00:00:00.000000000 Z
+date: 2025-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -253,6 +253,7 @@ files:
 - lib/roda/plugins/padrino_render.rb
 - lib/roda/plugins/param_matchers.rb
 - lib/roda/plugins/params_capturing.rb
+- lib/roda/plugins/part.rb
 - lib/roda/plugins/partials.rb
 - lib/roda/plugins/pass.rb
 - lib/roda/plugins/path.rb