roda 3.64.0 → 3.66.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 715e94da6acab0fa1c5e8409051f3faf0800ca56874d8640fa8f00c2ac432322
-  data.tar.gz: 79d9f75da1af54c8288918f722dff874433c7935a996180311344a24acc751ec
+  metadata.gz: 52a6bb08790a0a3414771a5d772a27d98089a96a306812ddb781ce31724289f0
+  data.tar.gz: 8679931319b2abf3b8aba64151664cf2d154517fbfd5020ded910e5ba32452a0
 SHA512:
-  metadata.gz: 507d5395d337ae4e6c13a3ace905a605ecad5690bf8ceabd8d40bf3c9e2b162649a2a6cb79d1422c8c560396f4abdf891d8f3543b9866cd4f20e944acb4b6347
-  data.tar.gz: 37cdd77e3b2894ca55370d638e411e3bf10005101d83939a970b242a4750aa2df929994343c20546cdd6046553897e4d7cde19788f10c2406eb5b446d31e97d5
+  metadata.gz: 4ace69f14606887e7243a5ec00598d8a3ded4230e8fbdf849c801579f38c9242ca87c5ab48887aeba65911cbcf49e675e768c077d20680e9693c5989180218b7
+  data.tar.gz: 7986400736b3631524c3427f135a8d3cb9da04da0d1413f59d764fd8c5b7c4ee6f81be9a3b92d848c5546229b7bd7f236278cfe41cb12410c34def542762d1f9

data/CHANGELOG

@@ -1,3 +1,19 @@
+= 3.66.0 (2023-03-13)
+
+* Support overriding exception page assets via exception_page_{css,js} instance methods (jeremyevans) (#306)
+
+* Avoid keeping reference to Roda instance that caches an inline template (jeremyevans)
+
+* Add render_coverage plugin, using tilt 2.1 features to allow for compiled templates in Ruby <3.2 (jeremyevans)
+
+= 3.65.0 (2023-02-13)
+
+* Make indifferent_params plugin work with changes in rack main branch (jeremyevans)
+
+* Add autoload_named_routes plugin for autoloading file for a named route when there is a request for that route (jeremyevans)
+
+* Make path method in path plugin accept class name string/symbol with :class_name option to register classes without forcing autoloads (jeremyevans)
+
 = 3.64.0 (2023-01-12)
 
 * Automatically expand paths for autoload_hash_branches files, so that relative paths work (jeremyevans)

data/doc/release_notes/3.65.0.txt

@@ -0,0 +1,12 @@
+= New Features
+
+* An autoload_named_routes plugin has been added for autoloading files
+  for a named route setup by the named_routes plugin when there is a
+  request for that route.
+
+= Other Improvements
+
+* The path method in the path plugin now supports a :class_name option.
+  You can set this option to true and use a class name String/Symbol
+  to register paths for classes without referencing the related class,
+  useful when autoloading the class.

data/doc/release_notes/3.66.0.txt

@@ -0,0 +1,23 @@
+= New Features
+
+* A render_coverage plugin has been added, which will cause compiled
+  template code to be saved to a folder and loaded using load instead
+  of eval. This allows for coverage to work for the compiled template
+  code in Ruby versions before 3.2.  It can also allow for verbose
+  syntax warnings in compiled template code (ignored by eval), and
+  can also be useful for static analysis of compiled template code.
+  This plugin requires tilt 2.1+.
+
+* The exception_page plugin now supports exception_page_{css,js}
+  instance methods for overriding the CSS and JavaScript on the
+  generated exception page.
+
+= Other Improvements
+
+* Using inline templates (render/view :inline option) no longer keeps
+  a reference to the Roda instance that caches the template.
+
+= Backwards Compatibility
+
+* The Render::TemplateMtimeWrapper API has changed.  Any external
+  use of this class needs to be updated.

data/lib/roda/plugins/autoload_named_routes.rb

@@ -0,0 +1,65 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The autoload_named_routes plugin builds on the named_routes plugin and allows for
+    # delaying loading of a file containing a named route for an application until there
+    # is a request that uses the named route. This can be useful in development
+    # to improvement startup time by not loading all named routes up front.  It can also be
+    # useful in testing subsets of an application by only loading the named routes being
+    # tested.
+    #
+    # You can specify a single hash branch for autoloading:
+    #
+    #   plugin :autoload_named_route
+    #   autoload_named_route(:route_name, '/absolute/path/to/file')
+    #   autoload_named_route(:namespace, :route_name, 'relative/path/to/file')
+    #
+    # Note that unlike the +route+ method defined by the named_routes plugin, when providing
+    # a namespace, the namespace comes before the route name and not after.
+    #
+    # When the autoloaded file is required, it should redefine the same
+    # named route.  If it does not, requests to the named route will be ignored (as if the
+    # related named route block was empty).
+    #
+    # When freezing an application, all named routes are automatically loaded, because
+    # autoloading named routes does not work for frozen applications.
+    module AutoloadNamedRoutes
+      def self.load_dependencies(app)
+        app.plugin :named_routes
+      end
+
+      def self.configure(app)
+        app.opts[:autoload_named_route_files] ||= []
+      end
+
+      module ClassMethods
+        # Autoload the given file when there is request for the named route.
+        # The given file should configure the named route specified.
+        def autoload_named_route(namespace=nil, name, file)
+          file = File.expand_path(file)
+          opts[:autoload_named_route_files] << file
+          routes = opts[:namespaced_routes][namespace] ||= {}
+          meth = routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1) do |r|
+            loc = method(routes[name]).source_location
+            require file
+            # Avoid infinite loop in case method is not overridden
+            if method(meth).source_location != loc
+              send(meth, r)
+            end
+          end
+          nil
+        end
+
+        # Eagerly load all autoloaded named routes when freezing the application.
+        def freeze
+          opts.delete(:autoload_named_route_files).each{|file| require file}
+          super
+        end
+      end
+    end
+
+    register_plugin(:autoload_named_routes, AutoloadNamedRoutes)
+  end
+end

data/lib/roda/plugins/exception_page.rb

@@ -227,7 +227,7 @@ END
 
             css = case css_file
             when nil
-              "<style type=\"text/css\">#{ExceptionPage.css}</style>"
+              "<style type=\"text/css\">#{exception_page_css}</style>"
             when false
               # :nothing
             else
@@ -236,7 +236,7 @@ END
 
             js = case js_file
             when nil
-              "<script type=\"text/javascript\">\n//<!--\n#{ExceptionPage.js}\n//-->\n</script>"
+              "<script type=\"text/javascript\">\n//<!--\n#{exception_page_js}\n//-->\n</script>"
             when false
               # :nothing
             else
@@ -399,6 +399,16 @@ END
           end
         end
 
+        # The CSS to use on the exception page
+        def exception_page_css
+          ExceptionPage.css
+        end
+
+        # The JavaScript to use on the exception page
+        def exception_page_js
+          ExceptionPage.js
+        end
+
         private
 
         if RUBY_VERSION >= '3.2'
@@ -420,11 +430,11 @@ END
         def exception_page_assets
           get 'exception_page.css' do
             response['Content-Type'] = "text/css"
-            ExceptionPage.css
+            scope.exception_page_css
           end
           get 'exception_page.js' do
             response['Content-Type'] = "application/javascript"
-            ExceptionPage.js
+            scope.exception_page_js
           end
         end
       end

data/lib/roda/plugins/indifferent_params.rb

@@ -53,9 +53,18 @@ class Roda
           
           class Params < Rack::QueryParser::Params
             if Rack.release >= '3'
-              def initialize
-                @size   = 0
-                @params = Hash.new(&INDIFFERENT_PROC)
+              # rack main branch compatibility
+              # :nocov:
+              if Params < Hash
+                def initialize
+                  super(&INDIFFERENT_PROC)
+                end
+              # :nocov:
+              else
+                def initialize
+                  @size   = 0
+                  @params = Hash.new(&INDIFFERENT_PROC)
+                end
               end
             else
               def initialize(limit = Rack::Utils.key_space_limit)

data/lib/roda/plugins/path.rb

@@ -26,6 +26,9 @@ class Roda
     #   path Quux do |quux, path|
     #     "/quux/#{quux.id}/#{path}"
     #   end
+    #   path 'FooBar', class_name: true do |foobar|
+    #     "/foobar/#{foobar.id}"
+    #   end
     #
     #   route do |r|
     #     r.post 'foo' do
@@ -65,9 +68,18 @@ class Roda
     #
     # Note that if :add_script_name, :relative, :url, or :url_only is used, the path method will also create a
     # <tt>_*_path</tt> private method.
+    #
+    # If the path class method is passed a string or symbol as the first argument, and the second argument
+    # is a hash with the :class_name option passed, the symbol/string is treated as a class name.
+    # This enables the use of class-based paths without forcing autoloads for the related
+    # classes.  If the plugin is not registering classes by name, this will use the symbol or
+    # string to find the related class.
     module Path
       DEFAULT_PORTS = {'http' => 80, 'https' => 443}.freeze
 
+      # Regexp for valid constant names, to prevent code execution.
+      VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+
       # Initialize the path classes when loading the plugin. Options:
       # :by_name :: Register classes by name, which is friendlier when reloading code (defaults to
       #             true in development mode)
@@ -97,11 +109,20 @@ class Roda
 
         # Create a new instance method for the named path.  See plugin module documentation for options.
         def path(name, path=nil, opts=OPTS, &block)
-          if name.is_a?(Class)
-            raise RodaError, "can't provide path or options when calling path with a class" unless path.nil? && opts.empty?
+          if name.is_a?(Class) || (path.is_a?(Hash) && (class_name = path[:class_name]))
+            raise RodaError, "can't provide path when calling path with a class" if path && !class_name
+            raise RodaError, "can't provide options when calling path with a class" unless opts.empty?
             raise RodaError, "must provide a block when calling path with a class" unless block
             if self.opts[:path_class_by_name]
-              name = name.name
+              if class_name
+                name = name.to_s
+              else
+                name = name.name
+              end
+            elsif class_name
+              name = name.to_s
+              raise RodaError, "invalid class name passed when using class_name option" unless VALID_CONSTANT_NAME_REGEXP =~ name
+              name = Object.class_eval(name, __FILE__, __LINE__)
             end
             path_classes[name] = block
             self.opts[:path_class_methods][name] = define_roda_method("path_#{name}", :any, &block)

data/lib/roda/plugins/render.rb

@@ -320,14 +320,16 @@ class Roda
       # template file has been modified.  This is an internal class and
       # the API is subject to change at any time.
       class TemplateMtimeWrapper
-        def initialize(template_class, path, dependencies, *template_args)
-          @template_class = template_class
-          @path = path
-          @template_args = template_args
-          @dependencies = ([path] + Array(dependencies)) if dependencies
+        def initialize(roda_class, opts, template_opts)
+          @roda_class = roda_class
+          @opts = opts
+          @template_opts = template_opts
+          reset_template
 
-          @mtime = template_last_modified if File.file?(path)
-          @template = template_class.new(path, *template_args)
+          @path = opts[:path]
+          deps = opts[:dependencies]
+          @dependencies = ([@path] + Array(deps)) if deps
+          @mtime = template_last_modified
         end
 
         # If the template file exists and the modification time has
@@ -358,7 +360,7 @@ class Roda
           else
             if mtime != @mtime
               @mtime = mtime
-              @template = @template_class.new(@path, *@template_args)
+              reset_template
               return true
             end
           end
@@ -407,6 +409,14 @@ class Roda
             end
           end
         end
+
+        private
+
+        # Reset the template, done every time the template or one of its
+        # dependencies is modified.
+        def reset_template
+          @template = @roda_class.create_template(@opts, @template_opts)
+        end
       end
 
       module ClassMethods
@@ -427,6 +437,17 @@ class Roda
           end
         end
 
+        # Return an Tilt::Template object based on the given opts and template_opts.
+        def create_template(opts, template_opts)
+          opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
+        end
+
+        # A proc that returns content, used for inline templates, so that the template
+        # doesn't hold a reference to the instance of the class
+        def inline_template_block(content)
+          Proc.new{content}
+        end
+
         # Copy the rendering options into the subclass, duping
         # them as necessary to prevent changes in the subclass
         # affecting the parent class.
@@ -656,7 +677,7 @@ class Roda
           if content = opts[:inline]
             path = opts[:path] = content
             template_class = opts[:template_class] ||= ::Tilt[engine]
-            opts[:template_block] = Proc.new{content}
+            opts[:template_block] = self.class.inline_template_block(content)
           else
             opts[:views] ||= render_opts[:views]
             path = opts[:path] ||= template_path(opts)
@@ -730,14 +751,14 @@ class Roda
                !opts[:inline]
 
             if render_opts[:check_template_mtime] && !opts[:template_block] && !cache
-              template = TemplateMtimeWrapper.new(opts[:template_class], opts[:path], opts[:dependencies], 1, template_opts)
+              template = TemplateMtimeWrapper.new(self.class, opts, template_opts)
 
               if define_compiled_method
                 method_name = :"_roda_template_#{self.class.object_id}_#{method_cache_key}"
                 method_cache[method_cache_key] = template.define_compiled_method(self.class, method_name)
               end
             else
-              template = opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
+              template = self.class.create_template(opts, template_opts)
 
               if define_compiled_method && cache != false
                 begin

data/lib/roda/plugins/render_coverage.rb

@@ -0,0 +1,86 @@
+# frozen-string-literal: true
+
+require 'tilt'
+# :nocov:
+raise 'Tilt version does not support coverable templates' unless Tilt::Template.method_defined?(:compiled_path=)
+# :nocov:
+
+#
+class Roda
+  module RodaPlugins
+    # The render_coverage plugin builds on top of the render plugin
+    # and sets compiled_path on created templates.  This allows
+    # Ruby's coverage library before Ruby 3.2 to consider code created
+    # by templates. You may not need this plugin on Ruby 3.2+, since
+    # on Ruby 3.2+, coverage can consider code loaded with +eval+.
+    # This plugin is only supported when using tilt 2.1+, since it
+    # requires the compiled_path supported added in tilt 2.1. 
+    #
+    # By default, the render_coverage plugin will use +coverage/views+
+    # as the directory containing the compiled template files.  You can
+    # change this by passing the :dir option when loading the plugin.
+    # By default, the plugin will set the compiled_path by taking the
+    # template file path, stripping off any of the allowed_paths used
+    # by the render plugin, and converting slashes to dashes. You can
+    # override the allowed_paths to strip by passing the :strip_paths
+    # option when loading the plugin.  Paths outside :strip_paths (or
+    # the render plugin allowed_paths if :strip_paths is not set) will
+    # not have a compiled_path set.
+    #
+    # Due to how Ruby's coverage library works in regards to loading
+    # a compiled template file with identical code more than once,
+    # it may be beneficial to run coverage testing with the
+    # +RODA_RENDER_COMPILED_METHOD_SUPPORT+ environment variable set
+    # to +no+ if using this plugin.
+    module RenderCoverage
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :render
+      end
+
+      # Use the :dir option to set the directory to store the compiled
+      # template files, and the :strip_paths directory for paths to
+      # strip.
+      def self.configure(app, opts=OPTS)
+        app.opts[:render_coverage_strip_paths] = opts[:strip_paths].map{|f| File.expand_path(f)} if opts.has_key?(:strip_paths)
+        coverage_dir = app.opts[:render_coverage_dir] = opts[:dir] || app.opts[:render_coverage_dir] || 'coverage/views'
+        Dir.mkdir(coverage_dir) unless File.directory?(coverage_dir)
+      end
+
+      module ClassMethods
+        # Set a compiled path on the created template, if the path for
+        # the template is in one of the allowed_views.
+        def create_template(opts, template_opts)
+          template = super
+          return template if opts[:template_block]
+
+          path = File.expand_path(opts[:path])
+          (self.opts[:render_coverage_strip_paths] || render_opts[:allowed_paths]).each do |dir|
+            if path.start_with?(dir + '/')
+              template.compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].gsub('/', '-'))
+              break
+            end
+          end
+
+          template
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Convert template paths to real paths to try to ensure the same template is cached.
+        def template_path(opts)
+          path = super
+
+          if File.file?(path)
+            File.realpath(path)
+          else
+            path
+          end
+        end
+      end
+    end
+
+    register_plugin(:render_coverage, RenderCoverage)
+  end
+end

data/lib/roda/plugins/route_csrf.rb

@@ -90,7 +90,7 @@ class Roda
     #                      action attribute, and returns a path you can pass to csrf_token
     #                      that should be valid for the form submission.  The argument should
     #                      either be nil or a string representing a relative path, absolute
-    #                      path, or full URL.
+    #                      path, or full URL (using appropriate URL encoding).
     # csrf_tag(path=nil, method='POST') :: An HTML hidden input tag string containing the CSRF token, suitable
     #                                      for placing in an HTML form.  Takes the same arguments as csrf_token.
     # csrf_token(path=nil, method='POST') :: The value of the csrf token, in case it needs to be accessed

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 = 64
+  RodaMinorVersion = 66
 
   # 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.64.0
+  version: 3.66.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-12 00:00:00.000000000 Z
+date: 2023-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -237,6 +237,8 @@ extra_rdoc_files:
 - doc/release_notes/3.62.0.txt
 - doc/release_notes/3.63.0.txt
 - doc/release_notes/3.64.0.txt
+- doc/release_notes/3.65.0.txt
+- doc/release_notes/3.66.0.txt
 - doc/release_notes/3.7.0.txt
 - doc/release_notes/3.8.0.txt
 - doc/release_notes/3.9.0.txt
@@ -308,6 +310,8 @@ files:
 - doc/release_notes/3.62.0.txt
 - doc/release_notes/3.63.0.txt
 - doc/release_notes/3.64.0.txt
+- doc/release_notes/3.65.0.txt
+- doc/release_notes/3.66.0.txt
 - doc/release_notes/3.7.0.txt
 - doc/release_notes/3.8.0.txt
 - doc/release_notes/3.9.0.txt
@@ -325,6 +329,7 @@ files:
 - lib/roda/plugins/assets.rb
 - lib/roda/plugins/assets_preloading.rb
 - lib/roda/plugins/autoload_hash_branches.rb
+- lib/roda/plugins/autoload_named_routes.rb
 - lib/roda/plugins/backtracking_array.rb
 - lib/roda/plugins/branch_locals.rb
 - lib/roda/plugins/caching.rb
@@ -406,6 +411,7 @@ files:
 - lib/roda/plugins/recheck_precompiled_assets.rb
 - lib/roda/plugins/relative_path.rb
 - lib/roda/plugins/render.rb
+- lib/roda/plugins/render_coverage.rb
 - lib/roda/plugins/render_each.rb
 - lib/roda/plugins/render_locals.rb
 - lib/roda/plugins/request_aref.rb
@@ -463,7 +469,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Routing tree web toolkit