roda 3.63.0 → 3.65.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e19674abcd02c79572ada44fe13fc8188a4cc91b780a3fbaa39da206cf7457f
-  data.tar.gz: ffd0e850b4aab5e82b3f5cf307145853df9d420389ff8eb6170ec53d3e29ca57
+  metadata.gz: d1c9c4301b4c90cb2f2c7a2d190986b4b6c68c4e1eb4b0be59bdba2aebdf6780
+  data.tar.gz: 576b15ba70cdab634638bce683ba8ee8ac93feb9fe5f3ae8982cf6ae07c6d686
 SHA512:
-  metadata.gz: d91087a996b037de3c0ecc3ca5e029f6b4bb40c5da1618048d70c0aa42ac5dcc581b6ed67e55cd9236da5463c3c224c62b09f85797daeffcb9a8fb98a16bca03
-  data.tar.gz: 62d2e2fdb0efa867299a764d4f7b36fc1a1e680147d32703d29451e29d2e3090a0f337c2c87ac46929a5a504b6461f92d18b50a14c62f422de4c114e43892c91
+  metadata.gz: 91b24c2bbcb2d2c27c14f242d620fab9d5e838f68bc102887018e41e4e05f5eb93718ab312c727a32ac4ab6df0dbcf4d0bb134499674dee71e991e953ecac85b
+  data.tar.gz: 9fe4592c67425c171926368d1121841dcafae686eb6822439536c24040788049041f34dffae22fde1ba2905f63c0e3abd13a5938ea263f4b143fdb94219e66f1

data/CHANGELOG

@@ -1,3 +1,19 @@
+= 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)
+
+* Make autoload_hash_branches plugin eagerly load the branches when freezing the application (jeremyevans)
+
+* Add erb_h plugin for faster (if slightly less safe) html escaping using erb/escape (jeremyevans)
+
 = 3.63.0 (2022-12-16)
 
 * Make mailer plugin set configured content type for body part for emails with attachments when using mail 2.8+ (jeremyevans)

data/MIT-LICENSE

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

data/doc/release_notes/3.64.0.txt

@@ -0,0 +1,26 @@
+= New Features
+
+* An erb_h plugin has been added for faster HTML escaping using
+  erb/escape.  erb 4 added erb/escape and it is included in Ruby 3.2.
+
+  The erb_h plugin is added as a separate plugin because it changes
+  the behavior of the h method. The h method added by the h plugin
+  will always return a new string, but the h method added by the
+  erb_h plugin will return the argument if the argument is a
+  string that does not need escaping.  By avoiding unnecessary
+  string allocations, use of the erb_h plugin can speed up HTML
+  escaping.
+
+= Other Improvements
+
+* The autoload_hash_branches plugin added in Roda 3.63.0 will now
+  eagerly load the hash branches when freezing the application,
+  allowing the application to continue to work after being frozen.
+  Additionally, file paths for the hash branches will now be
+  automatically expanded, allowing the use of relative file paths.
+
+= Backwards Compatibility
+
+* The expanding of file paths in the autoload_hash_branches plugin
+  can break applications that were providing relative paths and
+  expecting them to be looked up using the Ruby load path.

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/lib/roda/plugins/autoload_hash_branches.rb

@@ -13,8 +13,8 @@ class Roda
     # You can specify a single hash branch for autoloading:
     #
     #   plugin :autoload_hash_branches
-    #   autoload_hash_branch('branch_name', '/path/to/file')
-    #   autoload_hash_branch('namespace', 'branch_name', '/path/to/file')
+    #   autoload_hash_branch('branch_name', '/absolute/path/to/file')
+    #   autoload_hash_branch('namespace', 'branch_name', 'relative/path/to/file')
     #
     # You can also set the plugin to autoload load all hash branch files in a given directory.
     # This will look at each .rb file in the directory, and add an autoload for it, using the
@@ -26,18 +26,24 @@ class Roda
     # In both cases, when the autoloaded file is required, it should redefine the same
     # hash branch.  If it does not, requests to the hash branch will result in a 404 error.
     #
-    # This plugin will not work correctly when freezing applications, because it requires
-    # modifying the class at runtime as hash branches are autoloaded.
+    # When freezing an application, all hash branches are automatically loaded, because
+    # autoloading hash branches does not work for frozen applications.
     module AutoloadHashBranches
       def self.load_dependencies(app)
         app.plugin :hash_branches
       end
 
+      def self.configure(app)
+        app.opts[:autoload_hash_branch_files] ||= []
+      end
+
       module ClassMethods
         # Autoload the given file when there is request for the hash branch.
         # The given file should configure the hash branch specified.
         def autoload_hash_branch(namespace='', segment, file)
           segment = "/#{segment}"
+          file = File.expand_path(file)
+          opts[:autoload_hash_branch_files] << file
           routes = opts[:hash_branches][namespace] ||= {}
           meth = routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1) do |r|
             loc = method(routes[segment]).source_location
@@ -59,6 +65,12 @@ class Roda
             end
           end
         end
+
+        # Eagerly load all hash branches when freezing the application.
+        def freeze
+          opts.delete(:autoload_hash_branch_files).each{|file| require file}
+          super
+        end
       end
     end
 

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

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+require 'erb/escape'
+
+#
+class Roda
+  module RodaPlugins
+    # The erb_h plugin adds an +h+ instance method that will HTML
+    # escape the input and return it. This is similar to the h
+    # plugin, but it uses erb/escape to implement the HTML escaping,
+    # which offers faster performance.
+    #
+    # To make sure that this speeds up applications using the h
+    # plugin, this depends on the h plugin, and overrides the
+    # h method.
+    #
+    # The following example will return "<foo>" as the body.
+    #
+    #   plugin :erb_h
+    #
+    #   route do |r|
+    #     h('<foo>')
+    #   end
+    #
+    # The faster performance offered by the erb_h plugin is due
+    # to erb/escape avoiding allocations if not needed (returning the
+    # input object if no escaping is needed).  That behavior change
+    # can cause problems if you mutate the result of the h method
+    # (which can mutate the input), or mutate the input of the h
+    # method after calling it (which can mutate the result).
+    module ErbH
+      def self.load_dependencies(app)
+        app.plugin :h
+      end
+
+      module InstanceMethods
+        define_method(:h, ERB::Escape.instance_method(:html_escape))
+      end
+    end
+
+    register_plugin(:erb_h, ErbH)
+  end
+end

data/lib/roda/plugins/exception_page.rb

@@ -401,7 +401,6 @@ END
 
         private
 
-        # :nocov:
         if RUBY_VERSION >= '3.2'
           def exception_page_exception_message(exception)
             exception.detailed_message(highlight: false).to_s
@@ -413,6 +412,7 @@ END
             exception.message.to_s
           end
         end
+        # :nocov:
       end
 
       module RequestMethods

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

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 3
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 63
+  RodaMinorVersion = 65
 
   # 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.63.0
+  version: 3.65.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-16 00:00:00.000000000 Z
+date: 2023-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -236,6 +236,8 @@ extra_rdoc_files:
 - doc/release_notes/3.61.0.txt
 - 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.7.0.txt
 - doc/release_notes/3.8.0.txt
 - doc/release_notes/3.9.0.txt
@@ -306,6 +308,8 @@ files:
 - doc/release_notes/3.61.0.txt
 - 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.7.0.txt
 - doc/release_notes/3.8.0.txt
 - doc/release_notes/3.9.0.txt
@@ -323,6 +327,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
@@ -347,6 +352,7 @@ files:
 - lib/roda/plugins/early_hints.rb
 - lib/roda/plugins/empty_root.rb
 - lib/roda/plugins/environments.rb
+- lib/roda/plugins/erb_h.rb
 - lib/roda/plugins/error_email.rb
 - lib/roda/plugins/error_handler.rb
 - lib/roda/plugins/error_mail.rb
@@ -460,7 +466,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Routing tree web toolkit