roda 3.37.0 → 3.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de8c769572875e477058b48557b22861b9de731fa3b00b20a3022a67c929609d
-  data.tar.gz: 5cacc0d7b988bd3dc5bafbc30fcac145f6f67ddcc0e7809e1fc9cd60d8a16273
+  metadata.gz: e2bdd27a69c76000c9c1d2d8f37f9919145fdae55224706c78adec42850c5d21
+  data.tar.gz: 8b92e1dbc9ec83ebca5d2d5b068c67fa282dfee25fe241451c93228a406a4749
 SHA512:
-  metadata.gz: 1bf7df28d82f31820cd19c29b5a3f0f3afbbae2c41cf05974b16698c7ffb1725e924491874ddbb3f355a88990d4aab6d5b5b38f2d9c7612a548bfe0e3701ac2e
-  data.tar.gz: 32fca636d6324d29958cbcdf5c949c413eaeda7b74a701032d5766a60ec6b3f2db7ec262268dac697c3b3f5f9b183e127ddf265c7ba5015578969bc7f8be02a2
+  metadata.gz: 5c9f2d3f0f021b7b0a16628cefe28c4d4001f2a80804f2bde9b48b641a70482a5d13d699252cb9f7c747de50710b91df30f893f83263e3e73c874621948b4cc6
+  data.tar.gz: c060f123bfb7bd0f02a83d864169d7d2a021c14cd152b8f3e7641c4c7e0317affb84fce0812afcb0d382e0828e31e2fd97b46482338ae92574fbad97793c8996

data/CHANGELOG

@@ -1,3 +1,43 @@
+= 3.42.0 (2021-03-12)
+
+* Make Roda.plugin support plugins using keyword arguments in Ruby 3 (jeremyevans)
+
+* Make Roda.use support middleware using keyword arguments in Ruby 3 (pat) (#207)
+
+* Support common_logger plugin :method option for specifying the method to call on the logger (fnordfish, jeremyevans) (#206)
+
+* Add recheck_precompiled_assets plugin for checking for updates to the precompiled asset metadata file (jeremyevans)
+
+* Make compile_assets class method in assets plugin use an atomic approach to writing precompiled metadata file (jeremyevans)
+
+= 3.41.0 (2021-02-17)
+
+* Improve view performance with :content option up to 3x by calling compiled template methods directly (jeremyevans)
+
+= 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)
+
+* Avoid method redefinition warnings in verbose warning mode (jeremyevans)
+
+* Make typecast_params.convert! handle explicit nil values the same as missing values (jeremyevans)
+
+= 3.38.0 (2020-11-16)
+
+* Make error_email and error_mail plugins rescue invalid parameter errors when preparing the email body (jeremyevans)
+
 = 3.37.0 (2020-10-16)
 
 * Add custom_matchers plugin, for supporting arbitrary objects as matchers (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.3.0.txt

@@ -248,7 +248,7 @@
   Note that if there are multiple conversion errors raised inside a
   convert! or convert_each!  block, they are recorded and a single
   Roda::RodaPlugins::TypecastParams::Error instance is raised after
-  processing the block.  TypecastParams::Error#params_names can be
+  processing the block.  TypecastParams::Error#param_names can be
   called on the exception to get an array of all parameter names
   with conversion issues, and TypecastParams::Error#all_errors
   can be used to get an array of all Error instances.

data/doc/release_notes/3.38.0.txt

@@ -0,0 +1,5 @@
+= Improvements
+
+* The error_email and error_mail plugins now rescue invalid parameter
+  errors when preparing the email body, because you generally don't
+  want your error handler to raise an exception.

data/doc/release_notes/3.39.0.txt

@@ -0,0 +1,16 @@
+= Improvements
+
+* The relative_path plugin is now faster if you are calling
+  relative_path or relative_prefix more than once when handling a
+  request.
+
+* The typecast_params.convert! method in the typecast_params plugin
+  now handles explicit nil values the same as missing values.
+  Explicit nil values do not generally occur in normal Rack parameter
+  parsing, but they can occur when using the json_parser plugin to
+  parse JSON requests.
+
+* Roda now avoids method redefinition warnings in verbose mode by
+  using a self alias.  As Ruby 3 is dropping uninitialized instance
+  variable warnings, Roda will be verbose warning free if you are
+  using Ruby 3.

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/doc/release_notes/3.41.0.txt

@@ -0,0 +1,9 @@
+= Improvements
+
+* The performance of the render plugin's view method when passed the
+  :content option and no other options or arguments has been improved
+  by about 3x, by calling compiled template methods directly.
+
+* The compiled template method for the layout is cleared when the
+  render plugin is loaded again, which can fix issues when it is
+  loaded with different options that affect the layout.

data/doc/release_notes/3.42.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* A recheck_precompiled_assets plugin has been added, which allows
+  for checking for updates to the precompiled asset metadata file,
+  and automatically using the updated data.
+
+* The common_logger plugin now supports a :method plugin option to
+  specify the method to call on the logger.
+
+= Other Improvements
+
+* Plugins and middleware that use keyword arguments are now supported
+  in Ruby 3.
+
+* The compile_assets class method in the assets plugin now uses an
+  atomic approach to writing the precompiled asset metadata file.
+
+* Minor method visibility issues have been fixed.  The custom_matchers
+  plugin no longer makes the unsupported_matcher request method
+  public, and the render plugin no longer makes the _layout_method
+  public when the application is frozen.

data/lib/roda.rb

@@ -114,6 +114,7 @@ class Roda
                 alias_method meth, temp_method
                 undef_method temp_method
                 private meth
+                alias_method meth, meth
                 meth = :"#{meth}_arity"
               elsif required_args > 1
                 b = block
@@ -144,6 +145,7 @@ class Roda
 
           define_method(meth, &block)
           private meth
+          alias_method meth, meth
 
           if arity_meth
             required_args, optional_args, rest, keyword = _define_roda_method_arg_numbers(instance_method(meth))
@@ -167,6 +169,7 @@ class Roda
               send(meth, *a)
             end
             private arity_meth
+            alias_method arity_meth, arity_meth
           end
 
           call_meth
@@ -199,6 +202,7 @@ class Roda
 
                 private
 
+                alias set_default_headers set_default_headers
                 def set_default_headers
                   @headers['Content-Type'] ||= 'text/html'
                 end
@@ -288,6 +292,9 @@ class Roda
           plugin.configure(self, *args, &block) if plugin.respond_to?(:configure)
           @app = nil
         end
+        # :nocov:
+        ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Setup routing tree for the current Roda application, and build the
         # underlying rack application using the stored middleware. Requires
@@ -323,6 +330,9 @@ class Roda
           @middleware << [args, block].freeze
           @app = nil
         end
+        # :nocov:
+        ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         private
 
@@ -403,6 +413,7 @@ class Roda
               class_eval("def _roda_before; #{meths.join(';')} end", __FILE__, __LINE__)
             end
             private :_roda_before
+            alias_method :_roda_before, :_roda_before
           end
         end
 
@@ -419,6 +430,7 @@ class Roda
               class_eval("def _roda_after(res); #{meths.map{|s| "#{s}(res)"}.join(';')} end", __FILE__, __LINE__)
             end
             private :_roda_after
+            alias_method :_roda_after, :_roda_after
           end
         end
 

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/assets.rb

@@ -376,7 +376,7 @@ class Roda
 
         if opts[:precompiled] && !opts[:compiled] && ::File.exist?(opts[:precompiled])
           require 'json'
-          opts[:compiled] = (app.opts[:json_parser] || ::JSON.method(:parse)).call(::File.read(opts[:precompiled]))
+          opts[:compiled] = app.send(:_precompiled_asset_metadata, opts[:precompiled])
         end
 
         if opts[:early_hints]
@@ -455,7 +455,7 @@ class Roda
           require 'fileutils'
 
           unless assets_opts[:compiled]
-            opts[:assets] = assets_opts.merge(:compiled => {})
+            opts[:assets] = assets_opts.merge(:compiled => _compiled_assets_initial_hash).freeze
           end
 
           if type == nil
@@ -465,10 +465,12 @@ class Roda
             _compile_assets(type)
           end
 
-          if assets_opts[:precompiled]
+          if precompile_file = assets_opts[:precompiled]
             require 'json'
-            ::FileUtils.mkdir_p(File.dirname(assets_opts[:precompiled]))
-            ::File.open(assets_opts[:precompiled], 'wb'){|f| f.write((opts[:json_serializer] || :to_json.to_proc).call(assets_opts[:compiled]))}
+            ::FileUtils.mkdir_p(File.dirname(precompile_file))
+            tmp_file = "#{precompile_file}.tmp"
+            ::File.open(tmp_file, 'wb'){|f| f.write((opts[:json_serializer] || :to_json.to_proc).call(assets_opts[:compiled]))}
+            ::File.rename(tmp_file, precompile_file)
           end
 
           assets_opts[:compiled]
@@ -476,6 +478,11 @@ class Roda
 
         private
 
+        # The initial hash to use to store compiled asset metadata.
+        def _compiled_assets_initial_hash
+          {}
+        end
+
         # Internals of compile_assets, handling recursive calls for loading
         # all asset groups under the given type.
         def _compile_assets(type)
@@ -493,6 +500,11 @@ class Roda
           end
         end
 
+        # The precompiled asset metadata stored in the given file
+        def _precompiled_asset_metadata(file)
+          (opts[:json_parser] || ::JSON.method(:parse)).call(::File.read(file))
+        end
+
         # Compile each array of files for the given type into a single
         # file.  Dirs should be an array of asset group names, if these
         # are files in an asset group.
@@ -794,23 +806,32 @@ class Roda
         # handled.
         def assets_matchers
           @assets_matchers ||= [:css, :js].map do |t|
-            [t, assets_regexp(t)].freeze if roda_class.assets_opts[t]
+            if regexp = assets_regexp(t)
+              [t, regexp].freeze
+            end
           end.compact.freeze
         end
 
         private
 
+        # A string for the asset filename for the asset type, key, and digest.
+        def _asset_regexp(type, key, digest)
+          "#{key.sub(/\A#{type}/, '')}.#{digest}.#{type}"
+        end
+
         # The regexp matcher to use for the given type.  This handles any asset groups
         # for the asset types.
         def assets_regexp(type)
           o = roda_class.assets_opts
           if compiled = o[:compiled]
-            assets = compiled.select{|k,_| k =~ /\A#{type}/}.map do |k, md|
-              "#{k.sub(/\A#{type}/, '')}.#{md}.#{type}"
-            end
+            assets = compiled.
+              select{|k,_| k =~ /\A#{type}/}.
+              map{|k, md| _asset_regexp(type, k, md)}
+            return if assets.empty?
             /#{o[:"compiled_#{type}_prefix"]}(#{Regexp.union(assets)})/
           else
-            assets = unnest_assets_hash(o[type])
+            return unless assets = o[type]
+            assets = unnest_assets_hash(assets)
             ts = o[:timestamp_paths]
             /#{o[:"#{type}_prefix"]}#{"\\d+#{ts}" if ts}(#{Regexp.union(assets.uniq)})#{o[:"#{type}_suffix"]}/
           end

data/lib/roda/plugins/common_logger.rb

@@ -18,10 +18,11 @@ class Roda
     #   plugin :common_logger
     #   plugin :common_logger, $stdout
     #   plugin :common_logger, Logger.new('filename')
+    #   plugin :common_logger, Logger.new('filename'), method: :debug
     module CommonLogger
-      def self.configure(app, logger=nil)
+      def self.configure(app, logger=nil, opts=OPTS)
         app.opts[:common_logger] = logger || app.opts[:common_logger] || $stderr
-        app.opts[:common_logger_meth] = app.opts[:common_logger].method(logger.respond_to?(:write) ? :write : :<<)
+        app.opts[:common_logger_meth] = app.opts[:common_logger].method(opts.fetch(:method){logger.respond_to?(:write) ? :write : :<<})
       end
 
       if RUBY_VERSION >= '2.1'

data/lib/roda/plugins/custom_matchers.rb

@@ -68,6 +68,8 @@ class Roda
       end
 
       module RequestMethods
+        private
+
         # Try custom matchers before calling super
         def unsupported_matcher(matcher)
           roda_class.opts[:custom_matchers].each do |match_class, meth|

data/lib/roda/plugins/default_headers.rb

@@ -33,6 +33,7 @@ class Roda
             response_class.class_eval(<<-END, __FILE__, __LINE__+1)
               private
 
+              alias set_default_headers set_default_headers
               def set_default_headers
                 h = @headers
                 #{headers.map{|k,v| "h[#{k.inspect}] ||= #{v.inspect}"}.join('; ')}

data/lib/roda/plugins/error_email.rb

@@ -54,6 +54,13 @@ class Roda
         :body=>lambda do |s, e|
           format = lambda{|h| h.map{|k, v| "#{k.inspect} => #{v.inspect}"}.sort.join("\n")}
 
+          begin
+            params = s.request.params
+            params = (format[params] unless params.empty?)
+          rescue
+            params = 'Invalid Parameters!'
+          end
+
           message = String.new
           message << <<END
 Path: #{s.request.path}
@@ -73,12 +80,12 @@ ENV:
 #{format[s.env]}
 END
 
-          unless s.request.params.empty?
+          if params
             message << <<END
 
 Params:
 
-#{format[s.request.params]}
+#{params}
 END
           end
 

data/lib/roda/plugins/error_mail.rb

@@ -71,6 +71,13 @@ class Roda
 
           format = lambda{|h| h.map{|k, v| "#{k.inspect} => #{v.inspect}"}.sort.join("\n")}
 
+          begin
+            params = request.params
+            params = (format[params] unless params.empty?)
+          rescue
+            params = 'Invalid Parameters!'
+          end
+
           message = String.new
           message << <<END
 Path: #{request.path}
@@ -91,12 +98,12 @@ ENV:
 #{format[env]}
 END
 
-          unless request.params.empty?
+          if params
             message << <<END
 
 Params:
 
-#{format[request.params]}
+#{params}
 END
           end
 

data/lib/roda/plugins/mail_processor.rb

@@ -476,6 +476,8 @@ class Roda
 
         undef_method :match_rcpt
         undef_method :match_text
+        undef_method :match_body
+        undef_method :match_subject
 
         # Same as +header+, but also mark the message as being handled.
         def handle_header(key, value=nil)

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/recheck_precompiled_assets.rb

@@ -0,0 +1,107 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The recheck_precompiled_assets plugin enables checking for the precompiled asset metadata file.
+    # You need to have already loaded the assets plugin with the +:precompiled+ option and the file
+    # specified by the +:precompiled+ option must already exist in order to use the
+    # recheck_precompiled_assets plugin.
+    #
+    # Any time you want to check whether the precompiled asset metadata file has changed and should be
+    # reloaded, you can call the +recheck_precompiled_assets+ class method.  This method will check
+    # whether the file has changed, and reload it if it has.  If you want to check for modifications on
+    # every request, you can use +self.class.recheck_precompiled_assets+ inside your route block.
+    module RecheckPrecompiledAssets
+      # Thread safe wrapper for the compiled asset metadata hash.  Does not wrap all
+      # hash methods, only a few that are used.
+      class CompiledAssetsHash
+        include Enumerable
+
+        def initialize
+          @hash = {}
+          @mutex = Mutex.new
+        end
+
+        def [](key)
+          @mutex.synchronize{@hash[key]}
+        end
+
+        def []=(key, value)
+          @mutex.synchronize{@hash[key] = value}
+        end
+
+        def replace(hash)
+          hash = hash.instance_variable_get(:@hash) if (CompiledAssetsHash === hash)
+          @mutex.synchronize{@hash.replace(hash)}
+          self
+        end
+
+        def each(&block)
+          @mutex.synchronize{@hash.dup}.each(&block)
+          self
+        end
+
+        def to_json(*args)
+          @mutex.synchronize{@hash.dup}.to_json(*args)
+        end
+      end
+
+      def self.load_dependencies(app)
+        unless app.respond_to?(:assets_opts) && app.assets_opts[:precompiled]
+          raise RodaError, "must load assets plugin with precompiled option before loading recheck_precompiled_assets plugin"
+        end
+      end
+
+      def self.configure(app)
+        precompiled_file = app.assets_opts[:precompiled]
+        prev_mtime = ::File.mtime(precompiled_file)
+        app.instance_exec do
+          opts[:assets] = opts[:assets].merge(:compiled=>_compiled_assets_initial_hash.replace(assets_opts[:compiled])).freeze
+
+          define_singleton_method(:recheck_precompiled_assets) do
+            new_mtime = ::File.mtime(precompiled_file)
+            if new_mtime != prev_mtime
+              prev_mtime = new_mtime
+              assets_opts[:compiled].replace(_precompiled_asset_metadata(precompiled_file))
+
+              # Unset the cached asset matchers, so new ones will be generated.
+              # This is needed in case the new precompiled metadata uses
+              # different files.
+              app::RodaRequest.instance_variable_set(:@assets_matchers, nil)
+            end
+          end
+          singleton_class.send(:alias_method, :recheck_precompiled_assets, :recheck_precompiled_assets)
+        end
+      end
+
+      module ClassMethods
+        private
+
+        # Wrap the precompiled asset metadata in a thread-safe hash.
+        def _precompiled_asset_metadata(file)
+          CompiledAssetsHash.new.replace(super)
+        end
+
+        # Use a thread-safe wrapper of a hash for the :compiled assets option, since
+        # the recheck_precompiled_asset_metadata can modify it at runtime.
+        def _compiled_assets_initial_hash
+          CompiledAssetsHash.new
+        end
+      end
+
+      module RequestClassMethods
+        private
+
+        # Use a regexp that matches any digest.  When the precompiled asset metadata
+        # file is updated, this allows requests for a previous precompiled asset to
+        # still work.
+        def _asset_regexp(type, key, _)
+          /#{Regexp.escape(key.sub(/\A#{type}/, ''))}\.[0-9a-fA-F]+\.#{type}/
+        end
+      end
+    end
+
+    register_plugin(:recheck_precompiled_assets, RecheckPrecompiledAssets)
+  end
+end

data/lib/roda/plugins/relative_path.rb

@@ -41,6 +41,7 @@ class Roda
         # Return a relative prefix to append to an absolute path to a relative path
         # based on the current path of the request.
         def relative_prefix
+          return @_relative_prefix if @_relative_prefix
           env = @_request.env
           script_name = env["SCRIPT_NAME"]
           path_info = env["PATH_INFO"]
@@ -50,16 +51,16 @@ class Roda
           case script_name.getbyte(0)
           when nil # SCRIPT_NAME empty
             unless path_info.getbyte(0) == 47 # PATH_INFO starts with /
-              return ''
+              return(@_relative_prefix = '')
             end
           when 47 # SCRIPT_NAME starts with /
             # nothing
           else
-            return ''
+            return(@_relative_prefix = '')
           end
 
           slash_count = script_name.count('/') + path_info.count('/')
-          if slash_count > 1
+          @_relative_prefix = if slash_count > 1
             ("../" * (slash_count - 2)) << ".."
           else
             "."

data/lib/roda/plugins/render.rb

@@ -106,7 +106,7 @@ class Roda
     # :template_block :: Pass this block when creating the underlying template,
     #                    ignored when using :inline.  Disables caching of the
     #                    template by default.
-    # :template_class :: Provides the template class to use, inside of using
+    # :template_class :: Provides the template class to use, instead of using
     #                    Tilt or <tt>Tilt[:engine]</tt>.
     #
     # Here's an example of using these options:
@@ -183,6 +183,7 @@ class Roda
           app.const_set(:RodaCompiledTemplates, compiled_templates_module)
         end
         opts[:template_method_cache] = orig_method_cache || (opts[:cache_class] || RodaCache).new
+        opts[:template_method_cache][:_roda_layout] = nil if opts[:template_method_cache][:_roda_layout]
         opts[:cache] = orig_cache || (opts[:cache_class] || RodaCache).new
 
         opts[:layout_opts] = (opts[:layout_opts] || {}).dup
@@ -333,6 +334,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 +372,29 @@ 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}
+                private :_layout_method
+                alias_method(:_layout_method, :_layout_method)
+                opts[:render] = opts[:render].merge(:optimized_layout_method_created=>true)
+              end
+            end
+          end
+        end
       end
 
       module InstanceMethods
@@ -375,19 +418,21 @@ class Roda
         # Render the given template.  If there is a default layout
         # for the class, take the result of the template rendering
         # and render it inside the layout.  See Render for details.
-        def view(template, opts = (optimized_template = _cached_template_method(template); OPTS))
-          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
+        def view(template, opts = (content = _optimized_view_content(template); OPTS))
+          if content
+            # 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 +473,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.
@@ -469,19 +519,37 @@ class Roda
               end
             end
           end
+
+          # Get the content for #view, or return nil to use the unoptimized approach. Only called if
+          # a single argument is passed to view.
+          def _optimized_view_content(template)
+            if optimized_template = _cached_template_method(template)
+              send(optimized_template, OPTS)
+            elsif template.is_a?(Hash) && template.length == 1
+              template[:content]
+            end
+          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
 
           def _optimized_render_method_for_locals(_, _)
             nil
           end
+
+          def _optimized_view_content(template)
+            nil
+          end
           # :nocov:
         end
 

data/lib/roda/plugins/render_locals.rb

@@ -51,6 +51,10 @@ class Roda
           def _cached_template_method(template)
             nil
           end
+
+          def _optimized_view_content(template)
+            nil
+          end
         end
 
         def render_locals

data/lib/roda/plugins/type_routing.rb

@@ -141,6 +141,7 @@ class Roda
           app::RodaRequest.send(:define_method, type) do |&block|
             on_type(type, &block)
           end
+          app::RodaRequest.send(:alias_method, type, type)
         end
 
         app.opts[:type_routing] = config.freeze

data/lib/roda/plugins/typecast_params.rb

@@ -229,7 +229,7 @@ class Roda
     #
     # Note that if there are multiple conversion Error raised inside a +convert!+ or +convert_each!+ 
     # block, they are recorded and a single TypecastParams::Error instance is raised after
-    # processing the block.  TypecastParams::Error#params_names can be called on the exception to
+    # processing the block.  TypecastParams::Error#param_names can be called on the exception to
     # get an array of all parameter names with conversion issues, and TypecastParams::Error#all_errors
     # can be used to get an array of all Error instances.
     #
@@ -724,7 +724,7 @@ class Roda
               raise Error, "parameter #{param_name(nil)} is not a hash" if do_raise
               return
             end
-            present = @obj.has_key?(key)
+            present = !@obj[key].nil?
           when Integer
             unless @obj.is_a?(Array)
               raise Error, "parameter #{param_name(nil)} is not an array" if do_raise

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 = 37
+  RodaMinorVersion = 42
 
   # 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.37.0
+  version: 3.42.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-16 00:00:00.000000000 Z
+date: 2021-03-12 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
@@ -213,6 +207,17 @@ extra_rdoc_files:
 - doc/release_notes/3.35.0.txt
 - doc/release_notes/3.36.0.txt
 - 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.41.0.txt
+- doc/release_notes/3.42.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
@@ -251,7 +256,12 @@ files:
 - doc/release_notes/3.35.0.txt
 - doc/release_notes/3.36.0.txt
 - 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.41.0.txt
+- doc/release_notes/3.42.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -333,6 +343,7 @@ files:
 - lib/roda/plugins/precompile_templates.rb
 - lib/roda/plugins/public.rb
 - lib/roda/plugins/r.rb
+- lib/roda/plugins/recheck_precompiled_assets.rb
 - lib/roda/plugins/relative_path.rb
 - lib/roda/plugins/render.rb
 - lib/roda/plugins/render_each.rb
@@ -390,7 +401,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