roda 3.40.0 → 3.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e87645db18482f3ad97d106e268d76b2567d074490f37d7e99d52d06e4e5483
-  data.tar.gz: b84b082c2f27fcbd31254cb80de5e6610b7417e722eaf3dc3d8753a4604a0701
+  metadata.gz: b60182ef0483279ac1d1983495ba020c1803d6c1fe0fa84af882142f816f72bc
+  data.tar.gz: 20f6053b7c73fed454dc3f39e55a516d7a5461a4005356b5788480b8aab36f14
 SHA512:
-  metadata.gz: 3b21d6fa4b33c029a8b23a8ec437e70e2799e3f2bec27239d3cbfc5a1a4bb8cd82fc95309ad27d22243695298535b02687b0948218df1f7a1a0812242079e3b7
-  data.tar.gz: 3dc9629b16a4d9f496cee61bc40396f6893bfe114666ba7554327cd052946719410e2f4e89a27388cea291fd7b5ba1bcd37c669aa1dfc7b64c48a6622bafb013
+  metadata.gz: 89359f0c972c236bee671606fc7254f4999c6fc03f1b0ef8ff7c9691b581b6e796197b9fbee6fd109ae4d1026624f041d2e64c6182dbf8c80818756543923c9d
+  data.tar.gz: 2d786d8641f5195a65874f3326abe07057748e4de2df7d0a8e8cd9439b6afceb08e65b6a3733e15b0289e273cc070033c1dc466e1909880410b4d05541fa04ae

data/CHANGELOG

@@ -1,3 +1,33 @@
+= 3.44.0 (2021-05-12)
+
+* Add optimized_segment_matchers plugin for optimized matchers for a single String class argument (jeremyevans)
+
+* Use RFC 5987 UTF-8 and ISO-8859-1 encoded filenames when using send_file and attachment in the sinatra_helpers plugin (jeremyevans)
+
+= 3.43.1 (2021-04-13)
+
+* [SECURITY] Fix issue where loading content_security_policy plugin after default_headers plugin had no effect (jeremyevans)
+
+= 3.43.0 (2021-04-12)
+
+* Add host_authorization plugin, for checking that requests are submitted using an approved host (jeremyevans)
+
+= 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)

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

@@ -0,0 +1,34 @@
+= New Features
+
+* A host_authorization plugin has been added to verify the requested
+  Host header is authorized.  Using it can prevent DNS rebinding
+  attacks in cases where the application can receive requests for
+  arbitrary hosts.
+
+  To check for authorized hosts in your routing tree, you call the
+  check_host_authorization! method.  For example, if you want to
+  check for authorized hosts after serving requests for public
+  files, you could do:
+
+    plugin :public
+    plugin :host_authorization, 'my-domain-name.example.com'
+
+    route do |r|
+      r.public
+      check_host_authorized!
+
+      # ... rest of routing tree
+    end
+
+  In addition to handling single domain names via a string, you can
+  provide an array of domain names, a regexp to match again, or a
+  proc.
+  
+  By default, requests using unauthorized hosts receive an empty 403
+  response.  If you would like to customize the response, you can
+  pass a block when loading the plugin:
+
+    plugin :host_authorization, 'my-domain-name.example.com' do |r|
+      response.status = 403
+      "Response Body Here"
+    end

data/doc/release_notes/3.44.0.txt

@@ -0,0 +1,23 @@
+= New Features
+
+* An optimized_segment_matchers plugin has been added that offers
+  very fast matchers for arbitrary segments (the same segments
+  that would be matched by the String class matcher).  The
+  on_segment method it offers accepts no arguments and yields
+  the next segment if there is a segment.  The is_segment method
+  is similar, but only yields if the next segment is the final
+  segment.
+
+= Other Improvements
+
+* The send_file and attachment methods in the sinatra_helpers plugin
+  now support RFC 5987 UTF-8 and ISO-8859-1 encoded filenames,
+  allowing modern browsers to save files with encoded chracters. For
+  older browsers that do not support RFC 5987, unsupported characters
+  in filenames are replaced with dashes.  This is considered to be an
+  improvement over the previous behavior of using Ruby's inspect
+  output for the filename, which could contain backslashes (backslash
+  is not an allowed chracter in Windows filenames).
+
+* The performance of the String class matcher has been slightly
+  improved.

data/lib/roda.rb

@@ -292,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
@@ -327,6 +330,9 @@ class Roda
           @middleware << [args, block].freeze
           @app = nil
         end
+        # :nocov:
+        ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         private
 

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

@@ -23,30 +23,31 @@ class Roda
     module DefaultHeaders
       # Merge the given headers into the existing default headers, if any.
       def self.configure(app, headers={})
-        headers = app.opts[:default_headers] = (app.default_headers || app::RodaResponse::DEFAULT_HEADERS).merge(headers).freeze
+        app.opts[:default_headers] = (app.default_headers || app::RodaResponse::DEFAULT_HEADERS).merge(headers).freeze
+      end 
+
+      module ClassMethods
+        # The default response headers to use for the current class.
+        def default_headers
+          opts[:default_headers]
+        end
 
-        if headers.all?{|k, v| k.is_a?(String) && v.is_a?(String)}
-          response_class = app::RodaResponse
-          owner = response_class.instance_method(:set_default_headers).owner
-          if owner == Base::ResponseMethods || (owner == response_class && app.opts[:set_default_headers_overridder] == response_class)
-            app.opts[:set_default_headers_overridder] = response_class
-            response_class.class_eval(<<-END, __FILE__, __LINE__+1)
+        # Optimize the response class set_default_headers method if it hasn't been
+        # overridden and all default headers are strings.
+        def freeze
+          if (headers = opts[:default_headers]).all?{|k, v| k.is_a?(String) && v.is_a?(String)} &&
+             (self::RodaResponse.instance_method(:set_default_headers).owner == Base::ResponseMethods)
+            self::RodaResponse.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('; ')}
               end
             END
           end
-        end
-      end 
 
-      module ClassMethods
-        # The default response headers to use for the current class.
-        def default_headers
-          opts[:default_headers]
+          super
         end
       end
 

data/lib/roda/plugins/host_authorization.rb

@@ -0,0 +1,156 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The host_authorization plugin allows configuring an authorized host or
+    # an array of authorized hosts.  Then in the routing tree, you can check
+    # whether the request uses an authorized host via the +check_host_authorized!+
+    # method.
+    # 
+    # If the request doesn't match one of the authorized hosts, the
+    # request processing stops at that point. Using this plugin can prevent
+    # DNS rebinding attacks if the application can receive requests for
+    # arbitrary hosts.
+    #
+    # By default, an empty response using status 403 will be returned for requests
+    # with unauthorized hosts.
+    #
+    # Because +check_host_authorized!+ is an instance method, you can easily choose
+    # to only check for authorization in certain routes, or to check it after
+    # other processing.  For example, you could check for authorized hosts after
+    # serving static files, since the serving of static files should not be
+    # vulnerable to DNS rebinding attacks.
+    #
+    # = Usage
+    #
+    # In your routing tree, call the +check_host_authorized!+ method at the point you
+    # want to check for authorized hosts:
+    #
+    #   plugin :host_authorization, 'www.example.com'
+    #   plugin :public
+    #
+    #   route do |r|
+    #    r.public
+    #    check_host_authorized!
+    #
+    #    # ...
+    #   end
+    #
+    # = Specifying authorized hosts
+    #
+    # For applications hosted on a single domain name, you can use a single string:
+    #
+    #   plugin :host_authorization, 'www.example.com'
+    #
+    # For applications hosted on multiple domain names, you can use an array of strings:
+    #
+    #   plugin :host_authorization, %w'www.example.com www.example2.com'
+    #
+    # For applications supporting arbitrary subdomains, you can use a regexp. If using
+    # a regexp, make sure you use <tt>\A<tt> and <tt>\z</tt> in your regexp, and restrict
+    # the allowed characters to the minimum required, otherwise you can potentionally
+    # introduce a security issue:
+    #
+    #   plugin :host_authorization, /\A[-0-9a-f]+\.example\.com\z/
+    #
+    # For applications with more complex requirements, you can use a proc.  Similarly
+    # to the regexp case, the proc should be aware the host contains user-submitted
+    # values, and not assume it is in any particular format:
+    #
+    #   plugin :host_authorization, proc{|host| ExternalService.allowed_host?(host)}
+    #
+    # If an array of values is passed as the host argument, the host is authorized if
+    # it matches any value in the array.  All host authorization checks use the
+    # <tt>===</tt> method, which is why it works for strings, regexps, and procs.
+    # It can also work with arbitrary objects that support <tt>===</tt>.
+    #
+    # For security reasons, only the +Host+ header is checked by default.  If you are
+    # sure that your application is being run behind a forwarding proxy that sets the
+    # <tt>X-Forwarded-Host</tt> header, you should enable support for checking that
+    # header using the +:check_forwarded+ option:
+    # 
+    #   plugin :host_authorization, 'www.example.com', check_forwarded: true
+    #
+    # In this case, the trailing host in the <tt>X-Forwarded-Host</tt> header is checked,
+    # which should be the host set by the forwarding proxy closest to the application.
+    # In cases where multiple forwarding proxies are used that append to the
+    # <tt>X-Forwarded-Host</tt> header, you should not use this plugin.
+    #
+    # = Customizing behavior
+    #
+    # By default, an unauthorized host will receive an empty 403 response.  You can
+    # customize this by passing a block when loading the plugin. For example, for
+    # sites using the render plugin, you could return a page that uses your default
+    # layout:
+    #
+    #   plugin :render
+    #   plugin :host_authorization, 'www.example.com' do |r|
+    #     response.status = 403
+    #     view(:content=>"<h1>Forbidden</h1>")
+    #   end
+    #
+    # The block passed to this plugin is treated as a match block.
+    module HostAuthorization
+      def self.configure(app, host, opts=OPTS, &block)
+        app.opts[:host_authorization_host] = host
+        app.opts[:host_authorization_check_forwarded] = opts[:check_forwarded] if opts.key?(:check_forwarded)
+
+        if block
+          app.define_roda_method(:host_authorization_unauthorized, 1, &block)
+        end
+      end
+
+      module InstanceMethods
+        # Check whether the host is authorized.  If not authorized, return a response
+        # immediately based on the plugin block.
+        def check_host_authorization!
+          r = @_request
+          return if host_authorized?(_convert_host_for_authorization(r.env["HTTP_HOST"].to_s.dup))
+
+          if opts[:host_authorization_check_forwarded] && (host = r.env["HTTP_X_FORWARDED_HOST"])
+            if i = host.rindex(',')
+              host = host[i+1, 10000000].to_s
+            end
+            host = _convert_host_for_authorization(host.strip)
+
+            if !host.empty? && host_authorized?(host)
+              return
+            end
+          end
+
+          r.on do
+            host_authorization_unauthorized(r)
+          end
+        end
+
+        private
+
+        # Remove the port information from the passed string (mutates the passed argument).
+        def _convert_host_for_authorization(host)
+          host.sub!(/:\d+\z/, "")
+          host
+        end
+
+        # Whether the host given is one of the authorized hosts for this application.
+        def host_authorized?(host, authorized_host = opts[:host_authorization_host])
+          case authorized_host
+          when Array
+            authorized_host.any?{|auth_host| host_authorized?(host, auth_host)}
+          else
+            authorized_host === host
+          end
+        end
+
+        # Action to take for unauthorized hosts. Sets a 403 status by default.
+        def host_authorization_unauthorized(_)
+          @_response.status = 403
+          nil
+        end
+      end
+    end
+
+    register_plugin(:host_authorization, HostAuthorization)
+  end
+end
+

data/lib/roda/plugins/optimized_segment_matchers.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The optimized_segment_matchers plugin adds two optimized matcher methods,
+    # +r.on_segment+ and +r.is_segment+.  +r.on_segment+ is an optimized version of
+    # +r.on String+ that accepts no arguments and yields the next segment if there
+    # is a segment. +r.is_segment+ is an optimized version of +r.is String+ that accepts
+    # no arguments and yields the next segment only if it is the last segment.
+    #
+    #   plugin :optimized_segment_matchers
+    #
+    #   route do |r|
+    #     r.on_segment do |x|
+    #       # matches any segment (e.g. /a, /b, but not /)
+    #       r.is_segment do |y|
+    #         # matches only if final segment (e.g. /a/b, /b/c, but not /c, /c/d/, /c/d/e)
+    #       end
+    #     end
+    #   end
+    module OptimizedSegmentMatchers
+      module RequestMethods
+        # Optimized version of +r.on String+ that yields the next segment if there
+        # is a segment.
+        def on_segment
+          rp = @remaining_path
+          if rp.getbyte(0) == 47
+            if last = rp.index('/', 1)
+              @remaining_path = rp[last, rp.length]
+              always{yield rp[1, last-1]}
+            elsif (len = rp.length) > 1
+              @remaining_path = ""
+              always{yield rp[1, len]}
+            end
+          end
+        end
+
+        # Optimized version of +r.is String+ that yields the next segment only if it
+        # is the final segment.
+        def is_segment
+          rp = @remaining_path
+          if rp.getbyte(0) == 47 && !rp.index('/', 1) && (len = rp.length) > 1
+            @remaining_path = ""
+            always{yield rp[1, len]}
+          end
+        end
+      end
+    end
+
+    register_plugin(:optimized_segment_matchers, OptimizedSegmentMatchers)
+  end
+end

data/lib/roda/plugins/optimized_string_matchers.rb

@@ -19,7 +19,8 @@ class Roda
     #     end
     #   end
     #
-    # Note that both of these methods only work with plain strings, not
+    # If you are using the placeholder_string_matchers plugin, note
+    # that both of these methods only work with plain strings, not
     # with strings with embedded colons for capturing.  Matching will work
     # correctly in such cases, but the captures will not be yielded to the
     # match blocks.

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

@@ -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
@@ -387,6 +388,8 @@ class Roda
                 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
@@ -415,10 +418,8 @@ 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)
-
+        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.
@@ -518,6 +519,16 @@ 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(_)
@@ -535,6 +546,10 @@ class Roda
           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/sinatra_helpers.rb

@@ -211,6 +211,10 @@ class Roda
     # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     # OTHER DEALINGS IN THE SOFTWARE.
     module SinatraHelpers
+      UTF8_ENCODING = Encoding.find('UTF-8')
+      ISO88591_ENCODING = Encoding.find('ISO-8859-1')
+      BINARY_ENCODING = Encoding.find('BINARY')
+
       # Depend on the status_303 plugin.
       def self.load_dependencies(app, _opts = nil)
         app.plugin :status_303
@@ -432,7 +436,25 @@ class Roda
         # instructing the user agents to prompt to save.
         def attachment(filename = nil, disposition='attachment')
           if filename
-            params = "; filename=#{File.basename(filename).inspect}"
+            param_filename = File.basename(filename)
+            encoding = param_filename.encoding
+
+            needs_encoding = param_filename.gsub!(/[^ 0-9a-zA-Z!\#$&\+\.\^_`\|~]+/, '-')
+            params = "; filename=#{param_filename.inspect}"
+
+            if needs_encoding && (encoding == UTF8_ENCODING || encoding == ISO88591_ENCODING)
+              # File name contains non attr-char characters from RFC 5987 Section 3.2.1
+
+              encoded_filename = File.basename(filename).force_encoding(BINARY_ENCODING)
+              # Similar regexp as above, but treat each byte separately, and encode
+              # space characters, since those aren't allowed in attr-char
+              encoded_filename.gsub!(/[^0-9a-zA-Z!\#$&\+\.\^_`\|~]/) do |c|
+                "%%%X" % c.ord
+              end
+
+              encoded_params = "; filename*=#{encoding.to_s}''#{encoded_filename}"
+            end
+
             unless @headers["Content-Type"]
               ext = File.extname(filename)
               unless ext.empty?
@@ -440,7 +462,7 @@ class Roda
               end
             end
           end
-          @headers["Content-Disposition"] = "#{disposition}#{params}"
+          @headers["Content-Disposition"] = "#{disposition}#{params}#{encoded_params}"
         end
 
         # Whether or not the status is set to 1xx. Returns nil if status not yet set.

data/lib/roda/request.rb

@@ -468,8 +468,8 @@ class Roda
             if last = rp.index('/', 1)
               @captures << rp[1, last-1]
               @remaining_path = rp[last, rp.length]
-            elsif rp.length > 1
-              @captures << rp[1,rp.length]
+            elsif (len = rp.length) > 1
+              @captures << rp[1, len]
               @remaining_path = ""
             end
           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 = 40
+  RodaMinorVersion = 44
 
   # 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.40.0
+  version: 3.44.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-14 00:00:00.000000000 Z
+date: 2021-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -211,6 +211,10 @@ extra_rdoc_files:
 - 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.43.0.txt
+- doc/release_notes/3.44.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -258,6 +262,10 @@ files:
 - 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.43.0.txt
+- doc/release_notes/3.44.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -308,6 +316,7 @@ files:
 - lib/roda/plugins/header_matchers.rb
 - lib/roda/plugins/heartbeat.rb
 - lib/roda/plugins/hooks.rb
+- lib/roda/plugins/host_authorization.rb
 - lib/roda/plugins/indifferent_params.rb
 - lib/roda/plugins/json.rb
 - lib/roda/plugins/json_parser.rb
@@ -326,6 +335,7 @@ files:
 - lib/roda/plugins/named_templates.rb
 - lib/roda/plugins/not_allowed.rb
 - lib/roda/plugins/not_found.rb
+- lib/roda/plugins/optimized_segment_matchers.rb
 - lib/roda/plugins/optimized_string_matchers.rb
 - lib/roda/plugins/padrino_render.rb
 - lib/roda/plugins/param_matchers.rb
@@ -339,6 +349,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
@@ -396,7 +407,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: Routing tree web toolkit