roda 3.89.0 → 3.91.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c056e15afde950dcb27063296ba5b911fe3b900d16c121dd8833374731cdbaa
-  data.tar.gz: 95225a9c11b07979b50359df7451283eff570557c926f82c49cc34b67d1868fb
+  metadata.gz: e89aa3dd4e7c27d33d8b989c87a661a42e28c771aa8c96109279cc8131a4c5f5
+  data.tar.gz: e54282de7adf4827dcda2e29c82bbec6d8d76bbbefe29185d3d35b92f3390a50
 SHA512:
-  metadata.gz: e38354627d456f2b2bd593703d4ef64f5e934c071d439f1d9647cc8ef010de5fb463d001068ce2e06fd57b0cbccd926005d199b76761ebadefeda699937f5501
-  data.tar.gz: d542a024a5dd63bfa069baa38d2929bc0925d410641e303839f4a408139614249f223c3054f1f827550522aa21c0f52429184d3484001f7ed6996bbb9b366add
+  metadata.gz: a403baf3ca83c6e636c59c1a598319aa41254ad8bffb6e18ba0f81eebf1260674c30f3954b471da60be605d397496d0c2bb96ff286d5e094ea17a4745dc67f82
+  data.tar.gz: 2caeb451da13d935c1e14e7009304a16e256942926237704cd80baf32f9fa9d534b58830d8d4092cefec4940cc40fe90e01b33152183d43877900d479135e710

data/lib/roda/plugins/capture_erb.rb

@@ -21,26 +21,66 @@ class Roda
     # used as the template engine), this will call +capture+ on the
     # output buffer object, instead of setting the output buffer object
     # temporarily to a new object.
+    #
+    # By default, capture_erb returns the value of the block, converted
+    # to a string.  However, that can cause issues with code such as:
+    #
+    #   <% value = capture_erb do %>
+    #     Some content here.
+    #     <% if something %>
+    #       Some more content here.
+    #     <% end %>
+    #   <% end %>
+    #
+    # In this case, the block may return nil, instead of the content of
+    # the template.  To handle this case, you can provide the
+    # <tt>returns: :buffer</tt> option when calling the method (to handle
+    # that specific call, or when loading the plugin (to default to that
+    # behavior). Note that if the output buffer object responds to
+    # +capture+ and is not an instance of String, the <tt>returns: :buffer</tt>
+    # behavior is the default and cannot be changed.
     module CaptureERB
-      def self.load_dependencies(app)
+      def self.load_dependencies(app, opts=OPTS)
         app.plugin :render
       end
 
+      # Support <tt>returns: :buffer</tt> to default to returning buffer
+      # object.
+      def self.configure(app, opts=OPTS)
+        # RODA4: make returns: :buffer the default behavior
+        app.opts[:capture_erb_returns] = opts[:returns] if opts.has_key?(:returns)
+      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(&block)
+        #
+        # Options:
+        # :returns :: If set to :buffer, returns the value of the
+        #             template output variable, instead of the return
+        #             value of the block converted to a string. This
+        #             is the default behavior if the template output
+        #             variable supports the +capture+ method and is not
+        #             a String instance.
+        def capture_erb(opts=OPTS, &block)
           outvar = render_opts[:template_opts][:outvar]
           buf_was = instance_variable_get(outvar)
 
           if buf_was.respond_to?(:capture) && !buf_was.instance_of?(String)
             buf_was.capture(&block)
           else
+            returns = opts.fetch(:returns) { self.opts[:capture_erb_returns] }
+
             begin
               instance_variable_set(outvar, String.new)
-              yield.to_s
+              if returns == :buffer
+                yield
+                instance_variable_get(outvar).to_s
+              else
+                yield.to_s
+              end
             ensure
               instance_variable_set(outvar, buf_was) if outvar && buf_was
             end

data/lib/roda/plugins/common_logger.rb

@@ -56,14 +56,15 @@ class Roda
 
           env = @_request.env
 
-          line = "#{env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-"} - #{env["REMOTE_USER"] || "-"} [#{Time.now.strftime("%d/%b/%Y:%H:%M:%S %z")}] \"#{env["REQUEST_METHOD"]} #{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}#{"?#{env["QUERY_STRING"]}" if ((qs = env["QUERY_STRING"]) && !qs.empty?)} #{@_request.http_version}\" #{status} #{((length = headers[RodaResponseHeaders::CONTENT_LENGTH]) && (length unless length == '0')) || '-'} #{elapsed_time}\n"
+          line = "#{env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-"} - #{env["REMOTE_USER"] || "-"} [#{Time.now.strftime("%d/%b/%Y:%H:%M:%S %z")}] \"#{env["REQUEST_METHOD"]} #{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}#{"?#{env["QUERY_STRING"]}" if ((qs = env["QUERY_STRING"]) && !qs.empty?)} #{@_request.http_version}\" #{status} #{((length = headers[RodaResponseHeaders::CONTENT_LENGTH]) && (length unless length == '0')) || '-'} #{elapsed_time} "
           if MUTATE_LINE
-            line.gsub!(/[^[:print:]\n]/){|c| sprintf("\\x%x", c.ord)}
+            line.gsub!(/[^[:print:]]/){|c| sprintf("\\x%x", c.ord)}
           # :nocov:
           else
-            line = line.gsub(/[^[:print:]\n]/){|c| sprintf("\\x%x", c.ord)}
+            line = line.gsub(/[^[:print:]]/){|c| sprintf("\\x%x", c.ord)}
           # :nocov:
           end
+          line[-1] = "\n"
           opts[:common_logger_meth].call(line)
         end
 

data/lib/roda/plugins/middleware.rb

@@ -134,9 +134,7 @@ class Roda
         # and store +app+ as the next middleware to call.
         def initialize(mid, app, *args, &block)
           @mid = Class.new(mid)
-          # :nocov:
-          @mid.set_temporary_name("#{mid.name}(middleware)") if mid.name && RUBY_VERSION >= "3.3"
-          # :nocov:
+          RodaPlugins.set_temp_name(@mid){"#{mid}::middleware_subclass"}
           if @mid.opts[:middleware_next_if_not_found]
             @mid.plugin(:not_found, &NEXT_PROC)
           end

data/lib/roda/plugins/module_include.rb

@@ -79,6 +79,7 @@ class Roda
               mod = instance_variable_get(iv)
             else
               mod = instance_variable_set(iv, Module.new)
+              RodaPlugins.set_temp_name(mod){"#{klass}::module_include"}
               klass.send(:include, mod)
             end
 

data/lib/roda/plugins/render_each.rb

@@ -15,6 +15,38 @@ class Roda
     # is rendered, the local variable +foo+ will contain the given
     # value (e.g. on the first rendering +foo+ is 1).
     #
+    # If you provide a block when calling the method, it will yield
+    # each rendering instead of returning a concatentation of the
+    # renderings. This is useful if you want to wrap each rendering in
+    # something else.  For example, instead of calling +render+ multiple
+    # times in a loop:
+    #
+    #   <% [1,2,3].each do |v| %>
+    #     <p><%= render(:foo, locals: {foo: v}) %></p>
+    #   <% end %>
+    #  
+    # You can use +render_each+, allowing for simpler and more optimized
+    # code:
+    #
+    #   <% render_each([1,2,3], :foo) do |text| %>
+    #     <p><%= text %></p>
+    #   <% end %>
+    #
+    # You can also provide a block to avoid excess memory usage.  For
+    # example, if you are calling the method inside an erb template,
+    # instead of doing:
+    #
+    #   <%= render_each([1,2,3], :foo) %>
+    #
+    # You can do:
+    #
+    #   <% render_each([1,2,3], :foo) %><%= body %><% end %>
+    #
+    # This results in the same behavior, but avoids building a large
+    # intermediate string just to concatenate to the template result.
+    #
+    # When passing a block, +render_each+ returns +nil+.
+    #
     # You can pass additional render options via an options hash:
     #
     #   render_each([1,2,3], :foo, views: 'partials')
@@ -45,15 +77,15 @@ class Roda
         # :local :: The local variable to use for the current enum value
         #           inside the template.  An explicit +nil+ value does not
         #           set a local variable.  If not set, uses the template name.
-        def render_each(enum, template, opts=(no_opts = true; optimized_template = _cached_render_each_template_method(template); OPTS))
+        def render_each(enum, template, opts=(no_opts = true; optimized_template = _cached_render_each_template_method(template); OPTS), &block)
           if optimized_template
-            return _optimized_render_each(enum, optimized_template, render_each_default_local(template), {})
+            return _optimized_render_each(enum, optimized_template, render_each_default_local(template), {}, &block)
           elsif opts.has_key?(:local)
             as = opts[:local]
           else
             as = render_each_default_local(template)
             if no_opts && optimized_template.nil? && (optimized_template = _optimized_render_method_for_locals(template, (locals = {as=>nil})))
-              return _optimized_render_each(enum, optimized_template, as, locals)
+              return _optimized_render_each(enum, optimized_template, as, locals, &block)
             end
           end
 
@@ -67,14 +99,22 @@ class Roda
             locals[as] = nil
 
             if (opts.keys - ALLOWED_KEYS).empty? && (optimized_template = _optimized_render_method_for_locals(template, locals))
-              return _optimized_render_each(enum, optimized_template, as, locals)
+              return _optimized_render_each(enum, optimized_template, as, locals, &block)
             end
           end
 
-          enum.map do |v|
-            locals[as] = v if as
-            render_template(template, opts)
-          end.join
+          if defined?(yield)
+            enum.each do |v|
+              locals[as] = v if as
+              yield render_template(template, opts)
+            end
+            nil
+          else
+            enum.map do |v|
+              locals[as] = v if as
+              render_template(template, opts)
+            end.join
+          end
         end
         
         private
@@ -103,10 +143,18 @@ class Roda
 
           # Use an optimized render for each value in the enum.
           def _optimized_render_each(enum, optimized_template, as, locals)
-            enum.map do |v|
-              locals[as] = v
-              _call_optimized_template_method(optimized_template, locals)
-            end.join
+            if defined?(yield)
+              enum.each do |v|
+                locals[as] = v
+                yield _call_optimized_template_method(optimized_template, locals)
+              end
+              nil
+            else
+              enum.map do |v|
+                locals[as] = v
+                _call_optimized_template_method(optimized_template, locals)
+              end.join
+            end
           end
         else
           def _cached_render_each_template_method(template)

data/lib/roda/plugins/sinatra_helpers.rb

@@ -354,9 +354,7 @@ class Roda
           res.status = opts[:status] || s
           headers.delete(RodaResponseHeaders::CONTENT_LENGTH)
           headers.replace(h.merge!(headers))
-          res.body = b
-
-          halt
+          halt res.finish_with_body(b)
         rescue Errno::ENOENT
           not_found
         end

data/lib/roda/plugins.rb

@@ -49,5 +49,20 @@ class Roda
       end
       # :nocov:
     end
+
+    if RUBY_VERSION >= '3.3'
+      # Create a new module using the block, and set the temporary name
+      # on it using the given a containing module and name.
+      def self.set_temp_name(mod)
+        mod.set_temporary_name(yield)
+        mod
+      end
+    # :nocov:
+    else
+      def self.set_temp_name(mod)
+        mod
+      end
+    end
+    # :nocov:
   end
 end

data/lib/roda/session_middleware.rb

@@ -159,6 +159,7 @@ class RodaSessionMiddleware
   # Setup the middleware, passing +opts+ as the Roda sessions plugin options.
   def initialize(app, opts)
     mid = Class.new(Roda)
+    Roda::RodaPlugins.set_temp_name(mid){"RodaSessionMiddleware::_RodaSubclass"}
     mid.plugin :sessions, opts
     @req_class = mid::RodaRequest
     @req_class.send(:include, RequestMethods)

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 = 89
+  RodaMinorVersion = 91
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.89.0
+  version: 3.91.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-02-12 00:00:00.000000000 Z
+date: 2025-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack