roda 3.88.0 → 3.89.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfe23e68b3616d0513c55ca0d6006639eaa5595c36e48445e3a4b961f17dc483
-  data.tar.gz: 110d2f273b1b2eee5d0717d7238c3c131d7dd9fd2f7eb5a7ff0b575ce0256af0
+  metadata.gz: 5c056e15afde950dcb27063296ba5b911fe3b900d16c121dd8833374731cdbaa
+  data.tar.gz: 95225a9c11b07979b50359df7451283eff570557c926f82c49cc34b67d1868fb
 SHA512:
-  metadata.gz: 2c60bdca82724f3f1f468ca408e6d58a7fb61bb49e5819835afdb59743b82a8f1ad77e98775f8ce720bcc4aff4d72ae2e3526419cba509d60588eefd585aedba
-  data.tar.gz: 223ed6296acb9829902050161f88356e4bd6d2e5da5dc06e43175b4a59cd38c312a63c79cd93b5f2c648d7bf25e84f66a1ab02c72b603b42866ad434851350d1
+  metadata.gz: e38354627d456f2b2bd593703d4ef64f5e934c071d439f1d9647cc8ef010de5fb463d001068ce2e06fd57b0cbccd926005d199b76761ebadefeda699937f5501
+  data.tar.gz: d542a024a5dd63bfa069baa38d2929bc0925d410641e303839f4a408139614249f223c3054f1f827550522aa21c0f52429184d3484001f7ed6996bbb9b366add

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/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/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/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 = 89
 
   # 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.89.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-01-14 00:00:00.000000000 Z
+date: 2025-02-12 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