roda 3.39.0 → 3.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f01105e24f4eae80a69f5734f93d3dfe54b5f6be2489521f1d886053c569102
-  data.tar.gz: 2aebf30460c7d5352ee15baf3f884e59dac972e0aadd63aa7ab81445a8a29f65
+  metadata.gz: 8e87645db18482f3ad97d106e268d76b2567d074490f37d7e99d52d06e4e5483
+  data.tar.gz: b84b082c2f27fcbd31254cb80de5e6610b7417e722eaf3dc3d8753a4604a0701
 SHA512:
-  metadata.gz: d3fd374b3d700106ca814fff8f2dd0c66a3295955f27a453ef5d9fb2ba7fdea583d76ce82f91efb8e2ebcbb97a07e664f3f008689d51eb67ae39aebdd86a5d0e
-  data.tar.gz: 59c34c88ab1e5a5bc5017d46707a530c7cd002f4262c30751ba6429983b32477b813d83ada45a19873be711d1d2bd0abd95fe2a5c44c01038ad4a32dbb8f276d
+  metadata.gz: 3b21d6fa4b33c029a8b23a8ec437e70e2799e3f2bec27239d3cbfc5a1a4bb8cd82fc95309ad27d22243695298535b02687b0948218df1f7a1a0812242079e3b7
+  data.tar.gz: 3dc9629b16a4d9f496cee61bc40396f6893bfe114666ba7554327cd052946719410e2f4e89a27388cea291fd7b5ba1bcd37c669aa1dfc7b64c48a6622bafb013

data/CHANGELOG

@@ -1,3 +1,15 @@
+= 3.40.0 (2021-01-14)
+
+* Add freeze_template_caches! to the precompile_templates plugin, which ensures all templates are precompiled, and speeds up template access (jeremyevans)
+
+* Add precompile_views to the precompile_templates plugin, which precompiles the optimized render methods (jeremyevans)
+
+* Have RodaCache#freeze return the frozen internal hash (which no longer needs a mutex for thread-safety) (jeremyevans)
+
+* Speed up the view method in the render plugin even more when freezing the application (jeremyevans)
+
+* Speed up the view method in the render plugin when called with a single argument (jeremyevans)
+
 = 3.39.0 (2020-12-15)
 
 * Speed up relative_path plugin if relative_path or relative_prefix is called more than once (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2020 Jeremy Evans
+Copyright (c) 2014-2021 Jeremy Evans
 Copyright (c) 2010-2014 Michel Martens, Damian Janowski and Cyril David
 Copyright (c) 2008-2009 Christian Neukirchen
 

data/doc/release_notes/3.40.0.txt

@@ -0,0 +1,24 @@
+= New Features
+
+* A precompile_views method has been added to the
+  precompile_templates plugin.  This method works with Roda's
+  optimized compiled view methods, allowing additional memory
+  sharing between parent and child processes.
+
+* A freeze_template_caches! method has been added to the
+  precompile_templates plugin.  This freezes the template caches,
+  preventing the compilation of additional templates, useful for
+  enforcing that only precompiled templates are used.  Additionally,
+  this speeds up access to the template caches.
+
+* RodaCache#freeze now returns the frozen internal hash, which can
+  then be accessed without a mutex. Previously, freeze only froze
+  the receiver and not the internal hash, so it didn't have the
+  expected effect.
+
+= Other Improvements
+
+* The view method in the render plugin is now faster in most cases
+  when a single argument is used.  When freezing the application,
+  an additional optimization is performed to increase the
+  performance of the view method even further.

data/lib/roda/cache.rb

@@ -22,6 +22,13 @@ class Roda
       @mutex.synchronize{@hash[key] = value}
     end
 
+    # Return the frozen internal hash.  The internal hash can then
+    # be accessed directly since it is frozen and there are no
+    # thread safety issues.
+    def freeze
+      @hash.freeze
+    end
+
     private
 
     # Create a copy of the cache with a separate mutex.

data/lib/roda/plugins/precompile_templates.rb

@@ -13,32 +13,33 @@ class Roda
     # all of the child processes can use the same precompiled templates, which
     # saves memory.
     #
-    # After loading the plugin, you can call +precompile_templates+ with
-    # the pattern of templates you would like to precompile:
+    # Another advantage of the precompile_templates plugin is that after
+    # template precompilation, access to the template file in the file system is
+    # no longer needed, so this can be used with security features that do not
+    # allow access to the template files at runtime.
+    #
+    # After loading the plugin, you should call precompile_views with an array
+    # of views to compile, using the same argument you are passing to view or
+    # render:
     #
     #   plugin :precompile_templates
-    #   precompile_templates "views/\*\*/*.erb"
+    #   precompile_views %w'view1 view2'
+    #   
+    # If the view requires local variables, you should call precompile_views with a second
+    # argument for the local variables:
     #
-    # That will precompile all erb template files in the views directory or
-    # any subdirectory.
+    #   plugin :precompile_templates
+    #   precompile_views :view3, [:local_var1, :local_var2]
     #
-    # If the templates use local variables, you need to specify which local
-    # variables to precompile, which should be an array of symbols:
+    # After all templates are precompiled, you can optionally use freeze_template_caches!,
+    # which will freeze the template caches so that any template compilation at runtime
+    # will result in an error.  This also speeds up template cache access, since the
+    # template caches no longer need a mutex.
     #
-    #   precompile_templates 'views/users/_*.erb', locals: [:user]
+    #   freeze_template_caches!
     #
     # Note that you should use Tilt 2.0.1+ if you are using this plugin, so
     # that locals are handled in the same order.
-    #
-    # You can specify other render options when calling +precompile_templates+,
-    # including +:cache_key+, +:template_class+, and +:template_opts+.  If you
-    # are passing any of those options to render/view for the template, you
-    # should pass the same options when precompiling the template.
-    #
-    # To compile inline templates, just pass a single hash containing an :inline
-    # to +precompile_templates+:
-    #
-    #   precompile_templates inline: some_template_string
     module PrecompileTemplates
       # Load the render plugin as precompile_templates depends on it.
       def self.load_dependencies(app, opts=OPTS)
@@ -46,8 +47,49 @@ class Roda
       end
 
       module ClassMethods
-        # Precompile the templates using the given options.  See PrecompileTemplates
-        # for details.
+        # Freeze the template caches.  Should be called after precompiling all templates during
+        # application startup, if you don't want to allow templates to be cached at runtime.
+        # In addition to ensuring that no templates are compiled at runtime, this also speeds
+        # up rendering by freezing the template caches, so that a mutex is not needed to access
+        # them.
+        def freeze_template_caches!
+          _freeze_layout_method
+
+          opts[:render] = render_opts.merge(
+            :cache=>render_opts[:cache].freeze,
+            :template_method_cache=>render_opts[:template_method_cache].freeze,
+          ).freeze
+          self::RodaCompiledTemplates.freeze
+
+          nil
+        end
+
+        # Precompile the templates using the given options.  Note that this doesn't
+        # handle optimized template methods supported in newer versions of Roda, but
+        # there are still cases where makes sense to use it.
+        #
+        # You can call +precompile_templates+ with the pattern of templates you would
+        # like to precompile:
+        #
+        #   precompile_templates "views/**/*.erb"
+        #
+        # That will precompile all erb template files in the views directory or
+        # any subdirectory.
+        #
+        # If the templates use local variables, you need to specify which local
+        # variables to precompile, which should be an array of symbols:
+        #
+        #   precompile_templates 'views/users/_*.erb', locals: [:user]
+        #
+        # You can specify other render options when calling +precompile_templates+,
+        # including +:cache_key+, +:template_class+, and +:template_opts+.  If you
+        # are passing any of those options to render/view for the template, you
+        # should pass the same options when precompiling the template.
+        #
+        # To compile inline templates, just pass a single hash containing an :inline
+        # to +precompile_templates+:
+        #
+        #   precompile_templates inline: some_template_string
         def precompile_templates(pattern, opts=OPTS)
           if pattern.is_a?(Hash)
             opts = pattern.merge(opts)
@@ -68,7 +110,40 @@ class Roda
           instance = allocate
           compile_opts.each do |compile_opt|
             template = instance.send(:retrieve_template, compile_opt)
-            Render.tilt_template_compiled_method(template, locals, self)
+            begin
+              Render.tilt_template_compiled_method(template, locals, self)
+            rescue NotImplementedError
+              # When freezing template caches, you may want to precompile a template for a
+              # template type that doesn't support template precompilation, just to populate
+              # the cache.  Tilt rescues NotImplementedError in this case, which we can ignore.
+              nil
+            end
+          end
+
+          nil
+        end
+
+        # Precompile the given views with the given locals, handling optimized template methods.
+        def precompile_views(views, locals=EMPTY_ARRAY)
+          instance = allocate
+          views = Array(views)
+
+          if locals.empty?
+            opts = OPTS
+          else
+            locals_hash = {}
+            locals.each{|k| locals_hash[k] = nil}
+            opts = {:locals=>locals_hash}
+          end
+
+          views.each do |view|
+            instance.send(:retrieve_template, instance.send(:render_template_opts, view, opts))
+          end
+
+          if locals_hash
+            views.each do |view|
+              instance.send(:_optimized_render_method_for_locals, view, locals_hash)
+            end
           end
 
           nil

data/lib/roda/plugins/render.rb

@@ -333,6 +333,25 @@ class Roda
       end
 
       module ClassMethods
+        # :nocov:
+        if COMPILED_METHOD_SUPPORT
+        # :nocov:
+          # If using compiled methods and there is an optimized layout, speed up
+          # access to the layout method to improve the performance of view.
+          def freeze
+            begin
+              _freeze_layout_method
+            rescue
+              # This is only for optimization, if any errors occur, they can be ignored.
+              # One possibility for error is the app doesn't use a layout, but doesn't
+              # specifically set the :layout=>false plugin option.
+              nil
+            end
+
+            super
+          end
+        end
+
         # Copy the rendering options into the subclass, duping
         # them as necessary to prevent changes in the subclass
         # affecting the parent class.
@@ -352,6 +371,27 @@ class Roda
         def render_opts
           opts[:render]
         end
+
+        private
+
+        # Precompile the layout method, to reduce method calls to look it up at runtime.
+        def _freeze_layout_method
+          if render_opts[:layout]
+            instance = allocate
+            instance.send(:retrieve_template, instance.send(:view_layout_opts, OPTS))
+
+            # :nocov:
+            if COMPILED_METHOD_SUPPORT
+            # :nocov:
+              if (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}
+                opts[:render] = opts[:render].merge(:optimized_layout_method_created=>true)
+              end
+            end
+          end
+        end
       end
 
       module InstanceMethods
@@ -379,15 +419,19 @@ class Roda
           if optimized_template
             content = send(optimized_template, OPTS)
 
-            render_opts = self.class.opts[:render]
-            if layout_template = render_opts[:optimize_layout]
-              method_cache = render_opts[:template_method_cache]
-              unless layout_method = method_cache[:_roda_layout]
-                retrieve_template(:template=>layout_template, :cache_key=>nil, :template_method_cache_key => :_roda_layout)
-                layout_method = method_cache[:_roda_layout]
-              end
+            # First, check if the optimized layout method has already been created,
+            # 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}
+            end
 
-              if layout_method
+            # If we have an optimized template method but no optimized layout method, create the
+            # optimized layout method if possible and use it.  If you can't create the optimized
+            # layout method, fall through to the slower approach.
+            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}
               end
             end
@@ -428,6 +472,11 @@ class Roda
             method_cache[template]
           end
 
+          # Return a symbol containing the optimized layout method
+          def _layout_method
+            self.class.opts[:render][:template_method_cache][:_roda_layout]
+          end
+
           # Use an optimized render path for templates with a hash of locals.  Returns the result
           # 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.
@@ -471,11 +520,15 @@ class Roda
           end
         else
           # :nocov:
-          def _cached_template_method(template)
+          def _cached_template_method(_)
             nil
           end
 
-          def _cached_template_method_key(template)
+          def _cached_template_method_key(_)
+            nil
+          end
+
+          def _layout_method
             nil
           end
 

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.39.0
+  version: 3.40.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-15 00:00:00.000000000 Z
+date: 2021-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -174,16 +174,8 @@ extra_rdoc_files:
 - MIT-LICENSE
 - CHANGELOG
 - doc/conventions.rdoc
-- doc/release_notes/3.7.0.txt
 - doc/release_notes/3.0.0.txt
 - doc/release_notes/3.1.0.txt
-- doc/release_notes/3.2.0.txt
-- doc/release_notes/3.3.0.txt
-- doc/release_notes/3.4.0.txt
-- doc/release_notes/3.5.0.txt
-- doc/release_notes/3.6.0.txt
-- doc/release_notes/3.8.0.txt
-- doc/release_notes/3.9.0.txt
 - doc/release_notes/3.10.0.txt
 - doc/release_notes/3.11.0.txt
 - doc/release_notes/3.12.0.txt
@@ -195,6 +187,7 @@ extra_rdoc_files:
 - doc/release_notes/3.17.0.txt
 - doc/release_notes/3.18.0.txt
 - doc/release_notes/3.19.0.txt
+- doc/release_notes/3.2.0.txt
 - doc/release_notes/3.20.0.txt
 - doc/release_notes/3.21.0.txt
 - doc/release_notes/3.22.0.txt
@@ -205,6 +198,7 @@ extra_rdoc_files:
 - doc/release_notes/3.27.0.txt
 - doc/release_notes/3.28.0.txt
 - doc/release_notes/3.29.0.txt
+- doc/release_notes/3.3.0.txt
 - doc/release_notes/3.30.0.txt
 - doc/release_notes/3.31.0.txt
 - doc/release_notes/3.32.0.txt
@@ -215,6 +209,13 @@ extra_rdoc_files:
 - doc/release_notes/3.37.0.txt
 - doc/release_notes/3.38.0.txt
 - doc/release_notes/3.39.0.txt
+- doc/release_notes/3.4.0.txt
+- doc/release_notes/3.40.0.txt
+- doc/release_notes/3.5.0.txt
+- doc/release_notes/3.6.0.txt
+- doc/release_notes/3.7.0.txt
+- doc/release_notes/3.8.0.txt
+- doc/release_notes/3.9.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -256,6 +257,7 @@ files:
 - doc/release_notes/3.38.0.txt
 - doc/release_notes/3.39.0.txt
 - doc/release_notes/3.4.0.txt
+- doc/release_notes/3.40.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -394,7 +396,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Routing tree web toolkit