roda 3.41.0 → 3.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f09e850b5f4ee0406c5686317145571fa0bc5e8158b0b39c5161bb9a3cbb3878
-  data.tar.gz: d839bbfa3ff4e7ef4a37501a46ce65c12425dc620ccbdf9aae174a059898aa84
+  metadata.gz: e2bdd27a69c76000c9c1d2d8f37f9919145fdae55224706c78adec42850c5d21
+  data.tar.gz: 8b92e1dbc9ec83ebca5d2d5b068c67fa282dfee25fe241451c93228a406a4749
 SHA512:
-  metadata.gz: dee1ec11e6ca9ca18f74fedf260f10e25e9c49efa3297ca2df02aab02efa6282464dd88f0f1f79e3529c8c56239749c72779d8bfb7fbf8508b40047470e4f6f6
-  data.tar.gz: c7b4d4e1d4cdf7f60707621a57cfdd6a622ef91f6d6724abd1b344fc18b59ab4271ee7536513417023c20c3f470cac73c94ff50675661162d6ec1e62df02cd70
+  metadata.gz: 5c9f2d3f0f021b7b0a16628cefe28c4d4001f2a80804f2bde9b48b641a70482a5d13d699252cb9f7c747de50710b91df30f893f83263e3e73c874621948b4cc6
+  data.tar.gz: c060f123bfb7bd0f02a83d864169d7d2a021c14cd152b8f3e7641c4c7e0317affb84fce0812afcb0d382e0828e31e2fd97b46482338ae92574fbad97793c8996

data/CHANGELOG

@@ -1,3 +1,15 @@
+= 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)

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

@@ -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/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

@@ -388,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

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 = 41
+  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.41.0
+  version: 3.42.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-17 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -212,6 +212,7 @@ extra_rdoc_files:
 - 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
@@ -260,6 +261,7 @@ files:
 - 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
@@ -341,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