roda 3.49.0 → 3.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d3b9688bae8b0013acedfc6a5bcb45c374e0a73fd30e56985f0ebeee942ef8c
-  data.tar.gz: acb8215250d1615f007a2ec01d2b6546376414d2fea23a4f2341af9efd951110
+  metadata.gz: 90bdf6d366ffc4bff40aa51721176291fadb80f56d7904965fe46a1385fe4172
+  data.tar.gz: ab1bea5320b4049e918ebb23d1b081c26d5401000f11b02c5f85a1e1b30899c3
 SHA512:
-  metadata.gz: 3a5434bdcb6926d6c5e656c25b46e16b035ad54d74ed16bdc1cf46005b8ef605b3371a628cae52d65803064aa3d2eac8a56c2e8e1e55b6f3a82c04a74c636855
-  data.tar.gz: 9dc3773fae04325373adb8a7a57d52166bb65c238b959999adf6f6f17a3be29fcdedcea677eeeaaa84f6a01b5accb4aff2594817165b8a77a45106a3d4a9dea3
+  metadata.gz: 13bc3beb138174dc8cadfc309458bd1821cbe8b6f80f1cb704752979bf085710181d5fd9df71a3cc1fba2be3b258721f36c8758e202961f9389f23b7555ee78b
+  data.tar.gz: 7129008315908bf7ebd6c0115cd8eb531a6357617a5f9ce3a0ffae3703a5cd68793af0d43ac4703752e280a5cc6090234b60640fe25384c4fa8aabe8e04b94af

data/CHANGELOG

@@ -1,3 +1,37 @@
+= 3.53.0 (2022-02-14)
+
+* Make indifferent_params plugin support rack main branch (jeremyevans)
+
+* Add additional_view_directories plugin, for checking multiple view directories for templates (jeremyevans) (#229)
+
+= 3.52.0 (2022-01-14)
+
+* Fix return value of Roda.freeze when multi_route plugin is used (jeremyevans) (#240)
+
+* Use faster OpenSSL::Digest instead of Digest for assets plugin SRI support (jeremyevans)
+
+* Drop development dependency on haml (jeremyevans)
+
+* Make the path method in the path plugin handle blocks that accept keyword arguments in Ruby 3+ (adam12) (#227)
+
+* Support typecast_params :date_parse_input_handler plugin option for handling input to date parsing methods (jeremyevans)
+
+= 3.51.0 (2021-12-15)
+
+* Avoid method redefinition warning in error_handler plugin in verbose warning mode (jeremyevans)
+
+* Allow run in multi_run plugin to be called without an app to remove existing handler (jeremyevans)
+
+* Allow route in named_routes plugin to be called without a block to remove existing handler (jeremyevans)
+
+= 3.50.0 (2021-11-12)
+
+* Add capture_erb plugin for capturing ERB template blocks, instead of injecting them into the template output (jeremyevans)
+
+* Add inject_erb plugin for injecting content directly into ERB template output (jeremyevans)
+
+* Allow hash_branch and hash_path in hash_routes plugin to be called without a block to remove existing handler (jeremyevans)
+
 = 3.49.0 (2021-10-13)
 
 * Switch block_given? to defined?(yield) (jeremyevans)

data/MIT-LICENSE

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

data/README.rdoc

@@ -12,7 +12,8 @@ maintainable web applications in ruby.
 Website :: http://roda.jeremyevans.net
 Source :: http://github.com/jeremyevans/roda
 Bugs :: http://github.com/jeremyevans/roda/issues
-Google Group :: http://groups.google.com/group/ruby-roda
+Discussion Forum (GitHub Discussions) :: https://github.com/jeremyevans/roda/discussions
+Alternate Discussion Forum (Google Group) :: http://groups.google.com/group/ruby-roda
 
 == Goals
 

data/doc/release_notes/3.50.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* An inject_erb plugin has been added, adding an inject_erb method
+  that allows for injecting content directly into the template output
+  for the template currently being rendered.  This allows you to more
+  easily wrap blocks in templates, by calling methods that accept
+  template blocks and injecting content before and after the block.
+
+* A capture_erb plugin has been added, adding a capture_erb method
+  for capturing a template block in an erb template and returning
+  the content appended during the block as a string, instead of
+  having the content of the template block be included directly into
+  the template output.  This can be combined with the inject_erb
+  plugin to inject modified versions of captured blocks into template
+  output.
+
+* The hash_routes plugin now allows calling hash_branch and hash_path
+  without a block in order to remove the existing route handler. This
+  is designed to be used with code reloading libraries, so that if a
+  route file is deleted, the related hash branches/paths are also
+  removed, without having to reload all route files.

data/doc/release_notes/3.51.0.txt

@@ -0,0 +1,20 @@
+= New Features
+
+* The named_routes plugin now allows calling route without a block
+  to remove the existing route handler.  The multi_run plugin
+  now allows calling run without an app to remove an existing handler.
+  These changes are designed to better support code reloading
+  libraries, so that if the related file is deleted, the related
+  handlers are also removed, without having to reload the entire
+  application.
+
+= Other Improvements
+
+* The error_handler plugin now avoids a method redefinition warning
+  in verbose warning mode.
+
+= Other
+
+* Roda's primary discussion forum is now GitHub Discussions. The
+  ruby-roda Google Group is still available for users who would
+  prefer to use that instead.

data/doc/release_notes/3.52.0.txt

@@ -0,0 +1,20 @@
+= New Features
+
+* The typecast_params plugin now supports a :date_parse_input_handler
+  option that will be called with all input that will be passed to
+  the date parsing methods.  You can use this option to automatically
+  truncate input, if that is perferable to raising an error (which is
+  how recent versions of Ruby handle too-long input).
+
+= Other Improvements
+
+* The path helper methods added by the path plugin now support
+  blocks that use keyword arguments on Ruby 3+.
+
+* The assets plugin now uses OpenSSL::Digest instead of Digest (if
+  available) for calculating SRI digests.  This is faster on Ruby 3+,
+  where Digest no longer uses the faster OpenSSL::Digest automatically
+  if available.
+
+* Roda.freeze now returns self when the multi_route plugin is used.
+  This was broken (not returning self) starting in 3.48.0.

data/doc/release_notes/3.53.0.txt

@@ -0,0 +1,14 @@
+= New Features
+
+* An additional_view_directories plugin has been added, which allows
+  you to specify additional directories to look in for templates.
+  If the template path does not exist when using the default view
+  directory, then each additional view directory will be checked,
+  returning the first path that exists:
+
+    plugin :additional_view_directories, ['admin_views', 'public_views']
+
+= Other Improvements
+
+* The indifferent_params plugin now avoids a deprecation warning when
+  using the rack main branch, which will become Rack 3.

data/lib/roda/plugins/additional_view_directories.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The additional_view_directories plugin allows for specifying additional view
+    # directories to look in for templates.  When rendering a template, it will
+    # first try the :views directory specified in the render plugin.  If the template
+    # file to be rendered does not exist in that directory, it will try each additional
+    # view directory specified in this plugin, in order, using the path to the first
+    # template file that exists in the file system.  If no such path is found, it
+    # uses the default path specified by the render plugin.
+    #
+    # Example:
+    #
+    #   plugin :render, :views=>'dir'
+    #   plugin :additional_view_directories, ['dir1', 'dir2', 'dir3']
+    #
+    #   route do |r|
+    #     # Will check the following in order, using path for first
+    #     # template file that exists:
+    #     # * dir/t.erb
+    #     # * dir1/t.erb
+    #     # * dir2/t.erb
+    #     # * dir3/t.erb
+    #     render :t
+    #   end
+    module AdditionalViewDirectories
+      # Depend on the render plugin, since this plugin only makes
+      # sense when the render plugin is used.
+      def self.load_dependencies(app, view_dirs)
+        app.plugin :render
+      end
+
+      # Set the additional view directories to look in. Each additional view directory
+      # is also added as an allowed path.
+      def self.configure(app, view_dirs)
+        view_dirs = app.opts[:additional_view_directories] = view_dirs.map{|f| app.expand_path(f, nil)}.freeze
+        opts = app.opts[:render]
+        app.opts[:render] = opts.merge(:allowed_paths=>(opts[:allowed_paths] + view_dirs).uniq.freeze)
+        opts.freeze
+      end
+
+      module InstanceMethods
+        private
+
+        # If the template path does not exist, try looking for the template
+        # in each of the additional view directories, in order, returning
+        # the first path that exists. If no additional directory includes
+        # the template, return the original path.
+        def template_path(opts)
+          orig_path = super
+
+          unless File.file?(orig_path)
+            self.opts[:additional_view_directories].each do |view_dir|
+              path = super(opts.merge(:views=>view_dir))
+              return path if File.file?(path)
+            end
+          end
+
+          orig_path
+        end
+      end
+    end
+
+    register_plugin(:additional_view_directories, AdditionalViewDirectories)
+  end
+end

data/lib/roda/plugins/assets.rb

@@ -641,9 +641,17 @@ class Roda
         # a different digest type or to return a static string if you don't
         # want to use a unique value.
         def asset_digest(content)
-          require 'digest/sha2'
           algo = assets_opts[:sri] || :sha256
-          ::Digest.const_get(algo.to_s.upcase).hexdigest(content)
+          digest = begin
+            require 'openssl'
+            ::OpenSSL::Digest
+          # :nocov:
+          rescue LoadError
+            require 'digest/sha2'
+            ::Digest
+          # :nocov:
+          end
+          digest.const_get(algo.to_s.upcase).hexdigest(content)
         end
       end
 

data/lib/roda/plugins/capture_erb.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The capture_erb plugin allows you to capture the content of a block
+    # in an ERB template, and return it as a value, instead of
+    # injecting the template block into the template output.
+    #
+    #   <% value = capture_erb do %>
+    #     Some content here.
+    #   <% end %>
+    #
+    # +capture_erb+ can be used inside other methods that are called
+    # inside templates.  It can be combined with the inject_erb plugin
+    # to wrap template blocks with arbitrary output and then inject the
+    # wrapped output into the template.
+    module CaptureERB
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module InstanceMethods
+        # Temporarily replace the ERB output buffer
+        # with an empty string, and then yield to the block.
+        # Return the value of the block, converted to a string.
+        # Restore the previous ERB output buffer before returning.
+        def capture_erb
+          outvar = render_opts[:template_opts][:outvar]
+          buf_was = instance_variable_get(outvar)
+          instance_variable_set(outvar, String.new)
+          yield.to_s
+        ensure
+          instance_variable_set(outvar, buf_was) if outvar && buf_was
+        end
+      end
+    end
+
+    register_plugin(:capture_erb, CaptureERB)
+  end
+end

data/lib/roda/plugins/content_for.rb

@@ -55,10 +55,10 @@ class Roda
     #
     #   plugin :content_for, append: false
     module ContentFor
-      # Depend on the render plugin, since this plugin only makes
-      # sense when the render plugin is used.
+      # Depend on the capture_erb plugin, since it uses capture_erb
+      # to capture the content.
       def self.load_dependencies(app, _opts = OPTS)
-        app.plugin :render
+        app.plugin :capture_erb
       end
 
       # Configure whether to append or overwrite if content_for
@@ -72,18 +72,12 @@ class Roda
         # under the given key.  If called without a block, retrieve
         # stored content with the given key, or return nil if there
         # is no content stored with that key.
-        def content_for(key, value=nil)
+        def content_for(key, value=nil, &block)
           append = opts[:append_content_for]
 
-          if defined?(yield) || value
-            if defined?(yield)
-              outvar = render_opts[:template_opts][:outvar]
-              buf_was = instance_variable_get(outvar)
-
-              # Use temporary output buffer for ERB-based rendering systems
-              instance_variable_set(outvar, String.new)
-              value = yield.to_s
-              instance_variable_set(outvar, buf_was)
+          if block || value
+            if block
+              value = capture_erb(&block)
             end
 
             @_content_for ||= {}

data/lib/roda/plugins/error_handler.rb

@@ -62,6 +62,7 @@ class Roda
         # the exception in the scope of the Roda instance.
         def error(&block)
           define_method(:handle_error, &block)
+          alias_method(:handle_error, :handle_error)
           private :handle_error
         end
       end

data/lib/roda/plugins/hash_routes.rb

@@ -394,20 +394,32 @@ class Roda
           dsl
         end
 
-        # Add branch handler for the given namespace and segment.
+        # Add branch handler for the given namespace and segment. If called without
+        # a block, removes the existing branch handler if it exists.
         def hash_branch(namespace='', segment, &block)
           segment = "/#{segment}"
           routes = opts[:hash_branches][namespace] ||= {}
-          routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1, &convert_route_block(block))
+          if block
+            routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1, &convert_route_block(block))
+          elsif meth = routes[segment]
+            routes.delete(segment)
+            remove_method(meth)
+          end
         end
 
         # Add path handler for the given namespace and path. When the
         # r.hash_paths method is called, checks the matching namespace
         # for the full remaining path, and dispatch to that block if
-        # there is one.
+        # there is one.  If called without a block, removes the existing
+        # path handler if it exists.
         def hash_path(namespace='', path, &block)
           routes = opts[:hash_paths][namespace] ||= {}
-          routes[path] = define_roda_method(routes[path] || "hash_path_#{namespace}_#{path}", 1, &convert_route_block(block))
+          if block
+            routes[path] = define_roda_method(routes[path] || "hash_path_#{namespace}_#{path}", 1, &convert_route_block(block))
+          elsif meth = routes[path]
+            routes.delete(path)
+            remove_method(meth)
+          end
         end
       end
 

data/lib/roda/plugins/indifferent_params.rb

@@ -52,17 +52,29 @@ class Roda
           end
           
           class Params < Rack::QueryParser::Params
-            def initialize(limit = Rack::Utils.key_space_limit)
-              @limit  = limit
-              @size   = 0
-              @params = Hash.new(&INDIFFERENT_PROC)
+            # :nocov:
+            if Rack.release >= '2.3'
+              def initialize
+                @size   = 0
+                @params = Hash.new(&INDIFFERENT_PROC)
+              end
+            else
+            # :nocov:
+              def initialize(limit = Rack::Utils.key_space_limit)
+                @limit  = limit
+                @size   = 0
+                @params = Hash.new(&INDIFFERENT_PROC)
+              end
             end
           end
 
         end
 
         module RequestMethods
-          QUERY_PARSER = Rack::Utils.default_query_parser = QueryParser.new(QueryParser::Params, 65536, 100)
+          # :nocov:
+          query_parser = Rack.release >= '2.3' ? QueryParser.new(QueryParser::Params, 32) : QueryParser.new(QueryParser::Params, 65536, 32)
+          # :nocov:
+          QUERY_PARSER = Rack::Utils.default_query_parser = query_parser
 
           private
 

data/lib/roda/plugins/inject_erb.rb

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The inject_erb plugin allows you to inject content directly
+    # into the template output:
+    #
+    #   <% inject_erb("Some HTML Here") %>
+    #
+    # This will inject <tt>Some HTML Here</tt> into the template output,
+    # even though the tag being used is <tt><%</tt> and not <tt><%=</tt>.
+    #
+    # This method can be used inside methods, such as to wrap calls to
+    # methods that accept template blocks, to inject code before and after
+    # the template blocks.
+    module InjectERB
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module InstanceMethods
+        # Inject into the template output for the template currently being
+        # rendered.
+        def inject_erb(value)
+          instance_variable_get(render_opts[:template_opts][:outvar]) << value.to_s
+        end
+      end
+    end
+
+    register_plugin(:inject_erb, InjectERB)
+  end
+end

data/lib/roda/plugins/multi_route.rb

@@ -98,6 +98,7 @@ class Roda
             self::RodaRequest.named_route_regexp(k)
           end
           self::RodaRequest.instance_variable_get(:@namespaced_route_regexps).freeze
+          self
         end
 
         # Copy the named routes into the subclass when inheriting.

data/lib/roda/plugins/multi_run.rb

@@ -45,6 +45,9 @@ class Roda
     # subtrees, multi_run is a better approach, but it does not let you set instance
     # variables in the main Roda app and have those instance variables usable in
     # the routing subtrees.
+    #
+    # To handle development environments that reload code, you can call the
+    # +run+ class method without an app to remove dispatching for the prefix.
     module MultiRun
       # Initialize the storage for the dispatched applications
       def self.configure(app)
@@ -67,8 +70,12 @@ class Roda
 
         # Add a rack application to dispatch to for the given prefix when
         # r.multi_run is called.
-        def run(prefix, app)
-          multi_run_apps[prefix.to_s] = app
+        def run(prefix, app=nil)
+          if app
+            multi_run_apps[prefix.to_s] = app
+          else
+            multi_run_apps.delete(prefix.to_s)
+          end
           self::RodaRequest.refresh_multi_run_regexp!
         end
       end

data/lib/roda/plugins/named_routes.rb

@@ -38,6 +38,9 @@ class Roda
     # Note that in multi-threaded code, you should not attempt to add a
     # named route after accepting requests.
     #
+    # To handle development environments that reload code, you can call the
+    # +route+ class method without a block to remove an existing named route.
+    #
     # == Routing Files
     #
     # The convention when using the named_routes plugin is to have a single
@@ -124,7 +127,7 @@ class Roda
         # The names for the currently stored named routes
         def named_routes(namespace=nil)
           unless routes = opts[:namespaced_routes][namespace]
-            raise RodaError, "unsupported multi_route namespace used: #{namespace.inspect}"
+            raise RodaError, "unsupported named_routes namespace used: #{namespace.inspect}"
           end
           routes.keys
         end
@@ -140,7 +143,12 @@ class Roda
         def route(name=nil, namespace=nil, &block)
           if name
             routes = opts[:namespaced_routes][namespace] ||= {}
-            routes[name] = define_roda_method(routes[name] || "multi_route_#{namespace}_#{name}", 1, &convert_route_block(block))
+            if block
+              routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1, &convert_route_block(block))
+            elsif meth = routes[name]
+              routes.delete(name)
+              remove_method(meth)
+            end
           else
             super(&block)
           end

data/lib/roda/plugins/path.rb

@@ -41,12 +41,12 @@ class Roda
     #     end
     #
     #     r.post 'baz' do
-    #       bar = Baz[1]
+    #       baz = Baz[1]
     #       r.redirect path(baz, 'c', 'd') # /baz/1/c/d
     #     end
     #
     #     r.post 'quux' do
-    #       bar = Quux[1]
+    #       quux = Quux[1]
     #       r.redirect url(quux, '/bar') # http://example.com/quux/1/bar
     #     end
     #   end
@@ -148,11 +148,17 @@ class Roda
                 # Allow calling private _method to get path
                 relative_path(request.script_name.to_s + send(_meth, *a, &blk))
               end
+              # :nocov:
+              ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+              # :nocov:
             elsif add_script_name
               define_method(meth) do |*a, &blk|
                 # Allow calling private _method to get path
                 request.script_name.to_s + send(_meth, *a, &blk)
               end
+              # :nocov:
+              ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+              # :nocov:
             else
               define_method(meth, &block)
             end
@@ -171,6 +177,9 @@ class Roda
             end
 
             define_method(url_meth, &url_block)
+            # :nocov:
+            ruby2_keywords(url_meth) if respond_to?(:ruby2_keywords, true)
+            # :nocov:
           end
 
           nil

data/lib/roda/plugins/render.rb

@@ -47,7 +47,7 @@ class Roda
     # The following plugin options are supported:
     #
     # :allowed_paths :: Set the template paths to allow.  Attempts to render paths outside
-    #                   of this directory will raise an error.  Defaults to the +:views+ directory.
+    #                   of these paths will raise an error.  Defaults to the +:views+ directory.
     # :cache :: nil/false to explicitly disable premanent template caching.  By default, permanent
     #           template caching is disabled by default if RACK_ENV is development.  When permanent
     #           template caching is disabled, for templates with paths in the file system, the
@@ -59,9 +59,9 @@ class Roda
     #            templates, defaults to 'erb'.
     # :escape :: Use Erubi as the ERB template engine, and enable escaping by default,
     #            which makes <tt><%= %></tt> escape output and  <tt><%== %></tt> not escape output.
-    #            If given, sets the <tt>:escape=>true</tt> option for all template engines, which
+    #            If given, sets the <tt>escape: true</tt> option for all template engines, which
     #            can break some non-ERB template engines.  You can use a string or array of strings
-    #            as the value for this option to only set the <tt>:escape=>true</tt> option for those
+    #            as the value for this option to only set the <tt>escape: true</tt> option for those
     #            specific template engines.
     # :layout :: The base name of the layout file, defaults to 'layout'.  This can be provided as a hash
     #            with the :template or :inline options.
@@ -130,6 +130,84 @@ class Roda
     # only argument, you can speed things up by specifying a +:cache_key+ option in
     # the hash, making sure the +:cache_key+ is unique to the template you are
     # rendering.
+    #
+    # = Accepting Template Blocks in Methods
+    #
+    # If you are used to Rails, you may be surprised that this type of template code
+    # doesn't work in Roda:
+    #
+    #   <%= some_method do %>
+    #     Some HTML
+    #   <% end %>
+    #
+    # The reason this doesn't work is that this is not valid ERB syntax, it is Rails syntax,
+    # and requires attempting to parse the <tt>some_method do</tt> Ruby code with a regular
+    # expression.  Since Roda uses ERB syntax, it does not support this.
+    #
+    # In general, these methods are used to wrap the content of the block and
+    # inject the content into the output. To get similar behavior with Roda, you have
+    # a few different options you can use.
+    #
+    # == Directly Inject Template Output
+    #
+    # You can switch from a <tt><%=</tt> tag to using a <tt><%</tt> tag:
+    #
+    #   <% some_method do %>
+    #     Some HTML
+    #   <% end %>
+    #
+    # While this would output <tt>Some HTML</tt> into the template, it would not be able
+    # to inject content before or after the block.  However, you can use the inject_erb_plugin
+    # to handle the injection:
+    #
+    #   def some_method
+    #     inject_erb "content before block"
+    #     yield
+    #     inject_erb "content after block"
+    #   end
+    #
+    # If you need to modify the captured block before injecting it, you can use the
+    # capture_erb plugin to capture content from the template block, and modify that content,
+    # then use inject_erb to inject it into the template output:
+    #
+    #   def some_method(&block)
+    #     inject_erb "content before block"
+    #     inject_erb capture_erb(&block).upcase
+    #     inject_erb "content after block"
+    #   end
+    #
+    # This is the recommended approach for handling this type of method, if you want to keep
+    # the template block in the same template.
+    #
+    # == Separate Block Output Into Separate Template
+    #
+    # By moving the <tt>Some HTML</tt> into a separate template, you can render that
+    # template inside the block:
+    #
+    #  <%= some_method{render('template_name')} %>
+    #
+    # It's also possible to use an inline template:
+    #
+    #   <%= some_method do render(:inline=><<-END)
+    #     Some HTML
+    #     END
+    #   end %>
+    #
+    # This approach is useful if it makes sense to separate the template block into its
+    # own template. You lose the ability to use local variable from outside the
+    # template block inside the template block with this approach.
+    #
+    # == Separate Header and Footer
+    #
+    # You can define two separate methods, one that outputs the content before the block,
+    # and one that outputs the content after the block, and use those instead of a single
+    # call:
+    #
+    #   <%= some_method_before %>
+    #     Some HTML
+    #   <%= some_method_after %>
+    #
+    # This is the simplest option to setup, but it is fairly tedious to use.
     module Render
       # Support for using compiled methods directly requires Ruby 2.3 for the
       # method binding to work, and Tilt 1.2 for Tilt::Template#compiled_method.

data/lib/roda/plugins/status_303.rb

@@ -6,8 +6,7 @@ class Roda
     # The status_303 plugin sets the default redirect status to be 303
     # rather than 302 when the request is not a GET and the
     # redirection occurs on an HTTP 1.1 connection as per RFC 7231.
-    # The author knows of no cases where this actually matters in
-    # practice.
+    # There are some frontend frameworks that require this behavior.
     #
     # Example:
     #

data/lib/roda/plugins/typecast_params.rb

@@ -265,6 +265,23 @@ class Roda
     # If you would like to skip this check and allow null bytes in param string values,
     # you can do by passing the <tt>:allow_null_bytes</tt> option when loading the plugin.
     #
+    # You can use the :date_parse_input_handler option to specify custom handling of date
+    # parsing input.  Modern versions of Ruby and the date gem internally raise if the input to
+    # date parsing methods is too large to prevent denial of service.  If you are using an
+    # older version of Ruby, you can use this option to enforce the same check:
+    #
+    #   plugin :typecast_params, date_parse_input_handler: proc {|string|
+    #       raise ArgumentError, "too big" if string.bytesize > 128
+    #       string
+    #     }
+    #
+    # You can also use this option to modify the input, such as truncating it to the first
+    # 128 bytes:
+    #
+    #   plugin :typecast_params, date_parse_input_handler: proc {|string|
+    #       string.b[0, 128]
+    #     }
+    #
     # By design, typecast_params only deals with string keys, it is not possible to use
     # symbol keys as arguments to the conversion methods and have them converted.
     module TypecastParams
@@ -384,6 +401,14 @@ class Roda
         end
       end
 
+      module DateParseInputHandler
+        # Pass input string to date parsing through handle_date_parse_input.
+        def _string_parse!(klass, v)
+          v = handle_date_parse_input(v)
+          super
+        end
+      end
+
       # Class handling conversion of submitted parameters to desired types.
       class Params
         # Handle conversions for the given type using the given block.
@@ -999,11 +1024,16 @@ class Roda
           when ''
             nil
           when String
-            klass.parse(v)
+            _string_parse!(klass, v)
           else
             raise Error, "unexpected value received: #{v.inspect}"
           end
         end
+
+        # Handle parsing for string values passed to parse!.
+        def _string_parse!(klass, v)
+          klass.parse(v)
+        end
       end
 
       # Set application-specific Params subclass unless one has been set,
@@ -1019,6 +1049,14 @@ class Roda
         if opts[:allow_null_bytes]
           app::TypecastParams.send(:include, AllowNullByte)
         end
+        if opts[:date_parse_input_handler]
+          app::TypecastParams.class_eval do
+            include DateParseInputHandler
+            define_method(:handle_date_parse_input, &opts[:date_parse_input_handler])
+            private :handle_date_parse_input
+            alias handle_date_parse_input handle_date_parse_input
+          end
+        end
       end
 
       module ClassMethods

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 = 49
+  RodaMinorVersion = 53
 
   # 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.49.0
+  version: 3.53.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-13 00:00:00.000000000 Z
+date: 2022-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -94,20 +94,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: haml
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack_csrf
   requirement: !ruby/object:Gem::Requirement
@@ -221,6 +207,10 @@ extra_rdoc_files:
 - doc/release_notes/3.48.0.txt
 - doc/release_notes/3.49.0.txt
 - doc/release_notes/3.5.0.txt
+- doc/release_notes/3.50.0.txt
+- doc/release_notes/3.51.0.txt
+- doc/release_notes/3.52.0.txt
+- doc/release_notes/3.53.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
 - doc/release_notes/3.8.0.txt
@@ -277,6 +267,10 @@ files:
 - doc/release_notes/3.48.0.txt
 - doc/release_notes/3.49.0.txt
 - doc/release_notes/3.5.0.txt
+- doc/release_notes/3.50.0.txt
+- doc/release_notes/3.51.0.txt
+- doc/release_notes/3.52.0.txt
+- doc/release_notes/3.53.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
 - doc/release_notes/3.8.0.txt
@@ -288,12 +282,14 @@ files:
 - lib/roda/plugins/_before_hook.rb
 - lib/roda/plugins/_optimized_matching.rb
 - lib/roda/plugins/_symbol_regexp_matchers.rb
+- lib/roda/plugins/additional_view_directories.rb
 - lib/roda/plugins/all_verbs.rb
 - lib/roda/plugins/assets.rb
 - lib/roda/plugins/assets_preloading.rb
 - lib/roda/plugins/backtracking_array.rb
 - lib/roda/plugins/branch_locals.rb
 - lib/roda/plugins/caching.rb
+- lib/roda/plugins/capture_erb.rb
 - lib/roda/plugins/chunked.rb
 - lib/roda/plugins/class_level_routing.rb
 - lib/roda/plugins/class_matchers.rb
@@ -329,6 +325,7 @@ files:
 - lib/roda/plugins/hooks.rb
 - lib/roda/plugins/host_authorization.rb
 - lib/roda/plugins/indifferent_params.rb
+- lib/roda/plugins/inject_erb.rb
 - lib/roda/plugins/json.rb
 - lib/roda/plugins/json_parser.rb
 - lib/roda/plugins/mail_processor.rb
@@ -402,7 +399,7 @@ metadata:
   bug_tracker_uri: https://github.com/jeremyevans/roda/issues
   changelog_uri: http://roda.jeremyevans.net/rdoc/files/CHANGELOG.html
   documentation_uri: http://roda.jeremyevans.net/documentation.html
-  mailing_list_uri: https://groups.google.com/forum/#!forum/ruby-roda
+  mailing_list_uri: https://github.com/jeremyevans/roda/discussions
   source_code_uri: https://github.com/jeremyevans/roda
 post_install_message: 
 rdoc_options: []
@@ -419,7 +416,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: Routing tree web toolkit