roda 3.109.0 → 3.110.0

data/lib/roda/plugins/assets_preloading.rb

@@ -11,11 +11,11 @@ class Roda
     # For a list of compatible browsers, see
     # http://caniuse.com/#search=link-rel-preload
     #
-    # The plugin provides two functions - preload_assets_link_header and
-    # preload_assets_link_tags. The resulting preloading should be
-    # identical, it is up to you which system you prefer.
+    # The plugin provides two functions: +preload_assets_link_header+ and
+    # +preload_assets_link_tags+. The resulting preloading should be
+    # identical, it is up to you which approach you prefer.
     #
-    # preload_assets_link_header returns a string suitable for populating
+    # +preload_assets_link_header+ returns a string suitable for populating
     # the response Link header:
     #
     #   response.headers['Link'] = preload_assets_link_header(:css)
@@ -43,7 +43,6 @@ class Roda
     #
     #   # generate Link header for css assets and js asset groups app and bar
     #   preload_assets_link_header(:css, [:js, :app])
-    #
     module AssetsPreloading
       TYPE_AS = {
         :css => 'style'.freeze,
@@ -59,27 +58,44 @@ class Roda
         # Return a string of <link> tags for the given asset
         # types/groups.
         def preload_assets_link_tags(*args)
-          _preload_assets_array(args).map{|path, as| "<link href=\"#{h(path)}\" rel=\"preload\" as=\"#{as}\">"}.join("\n")
+          _each_preload_asset(args, "\n") do |path, as|
+            "<link href=\"#{h(path)}\" rel=\"preload\" as=\"#{as}\">"
+          end
         end
 
         # Return a string suitable for a Link header for the
         # given asset types/groups.
         def preload_assets_link_header(*args)
-          _preload_assets_array(args).map{|path, as| "<#{path}>;rel=preload;as=#{as}"}.join(",")
+          _each_preload_asset(args, ",") do |path, as|
+            "<#{path}>;rel=preload;as=#{as}"
+          end
         end
 
         private
 
         # Return an array of paths/as pairs for the given asset
         # types and/or groups.
-        def _preload_assets_array(assets)
-          assets.flat_map do |type|
+        def _each_preload_asset(assets, sep)
+          output = String.new
+          append_sep = false
+
+          assets.each do |type|
+            if append_sep
+              output << sep
+            else
+              append_sep = sep
+            end
+
             paths = assets_paths(type)
             type = type[0] if type.is_a?(Array)
             as = TYPE_AS[type]
 
-            paths.map{|path| [path, as]}
+            paths.each do |path|
+              output << yield(path, as)
+            end
           end
+
+          output
         end
       end
     end

data/lib/roda/plugins/backtracking_array.rb

@@ -16,8 +16,8 @@ class Roda
     # This is because the <tt>'a'</tt> entry in the array matches, which
     # makes the array match.  However, the next matcher is the
     # terminal matcher (since +r.is+ was used), and since the
-    # path is not terminal as it still contains +/b+ after
-    # matching <tt>'a'</tt>.
+    # remaining path is not empty as it still contains +/b+ after
+    # matching <tt>'a'</tt>, matching fails.
     #
     # With the backtracking_array plugin, when the terminal matcher
     # fails, matching will go on to the next entry in the array,

data/lib/roda/plugins/branch_locals.rb

@@ -17,9 +17,9 @@ class Roda
     #     end
     #   end
     #
-    # The locals you specify in the set_layout_locals and set_view_locals methods
+    # The locals you specify in the +set_layout_locals+ and +set_view_locals+ methods
     # have higher precedence than the render_locals plugin options, but lower precedence
-    # than options you directly pass to the view/render methods.
+    # than options you directly pass to the +view+/+render+ methods.
     module BranchLocals
       SCOPE_INSTANCE_VARIABLES = [:@_layout_locals, :@_view_locals].freeze
 
@@ -54,7 +54,7 @@ class Roda
         def render_locals
           locals = super
           if @_view_locals
-            locals = Hash[locals].merge!(@_view_locals)
+            locals = locals.merge(@_view_locals)
           end
           locals
         end
@@ -63,7 +63,7 @@ class Roda
         def layout_locals
           locals = super
           if @_layout_locals
-            locals = Hash[locals].merge!(@_layout_locals)
+            locals = locals.merge(@_layout_locals)
           end
           locals
         end

data/lib/roda/plugins/break.rb

@@ -3,7 +3,7 @@
 #
 class Roda
   module RodaPlugins
-    # The break plugin supports calling break inside a match block, to
+    # The break plugin supports calling +break+ inside a match block, to
     # return from the block and continue in the routing tree, restoring
     # the remaining path so that future matchers operating on the path
     # operate as expected.
@@ -28,7 +28,7 @@ class Roda
       module RequestMethods
         private
 
-        # Handle passing inside the match block.
+        # Handle break inside match blocks, restoring remaining path.
         def always
           rp = @remaining_path
           super

data/lib/roda/plugins/caching.rb

@@ -100,33 +100,31 @@ class Roda
           end
         end
 
-        # Set the response entity tag using the ETag header.
+        # Set the response entity tag using the +ETag+ header.
         #
         # The +value+ argument is an identifier that uniquely
         # identifies the current version of the resource.
-        # Options:
-        # :weak :: Use a weak cache validator (a strong cache validator is the default)
-        # :new_resource :: Whether this etag should match an etag of * (true for POST, false otherwise)
+        # Keyword Arguments:
+        # +weak+ :: Use a weak cache validator (a strong cache validator is the default)
+        # +new_resource+ :: Whether this etag should match an etag of * (true for POST, false otherwise)
         #
-        # When the current request includes an If-None-Match header with a
+        # When the current request includes an <tt>If-None-Match</tt> header with a
         # matching etag, immediately returns a response with a 304 or 412 status,
         # depending on the request method.
         #
-        # When the current request includes an If-Match header with an etag that
-        # doesn't match, or where the :weak option was used, immediately returns a
+        # When the current request includes an <tt>If-Match</tt> header with an etag that
+        # doesn't match, or where the +weak+ argument was used, immediately returns a
         # response with a 412 status.
-        def etag(value, opts=OPTS)
-          # Before touching this code, please double check RFC 2616 14.24 and 14.26.
-          weak = opts[:weak]
-          new_resource = opts.fetch(:new_resource){post?}
-
+        def etag(value, opts=(no_positional_opts = true; OPTS), weak: opts[:weak], new_resource: opts.fetch(:new_resource){post?}, **kw)
+          RodaPlugins.check_keywords(__callee__, no_positional_opts, opts, kw)
+          
           res = response
           e = env
           res[RodaResponseHeaders::ETAG] = etag = "#{'W/' if weak}\"#{value}\""
           status = res.status
 
           if (!status || (status >= 200 && status < 300) || status == 304)
-            if etag_matches?(e['HTTP_IF_NONE_MATCH'], etag, new_resource)
+            if etag_matches?(e['HTTP_IF_NONE_MATCH'], etag, new_resource, weak: true)
               res.status = (request_method =~ /\AGET|HEAD|OPTIONS|TRACE\z/i ? 304 : 412)
               halt
             end
@@ -143,10 +141,21 @@ class Roda
         private
 
         # Helper method checking if a ETag value list includes the current ETag.
-        def etag_matches?(list, etag, new_resource)
+        # If +weak+ is true, uses the weak comparison that <tt>If-None-Match</tt> requires
+        # (RFC 9110 section 13.1.2), which ignores a W/ prefix on both sides.
+        def etag_matches?(list, etag, new_resource, weak: false)
           return unless list
           return !new_resource if list == '*'
-          list.to_s.split(/\s*,\s*/).include?(etag)
+          list = list.to_s.split(/\s*,\s*/)
+          if weak
+            etag = etag.sub(/\AW\//, '')
+            list.any? do |tag|
+              tag.sub!(/\AW\//, '')
+              tag == etag
+            end
+          else
+            list.include?(etag)
+          end
         end
 
         # Helper method parsing a time value from an HTTP header, returning the
@@ -154,11 +163,12 @@ class Roda
         def time_from_header(t)
           Time.httpdate(t).to_i if t
         rescue ArgumentError
+          nil
         end
       end
 
       module ResponseMethods
-        # Specify response freshness policy for using the Cache-Control header.
+        # Specify response freshness policy for using the <tt>Cache-Control</tt> header.
         # Options can can any non-value directives (:public, :private, :no_cache,
         # :no_store, :must_revalidate, :proxy_revalidate), with true as the value.
         # Options can also contain value directives (:max_age, :s_maxage).
@@ -184,7 +194,7 @@ class Roda
         # cached for.  Also sets the Expires header, useful if you have
         # HTTP 1.0 clients (Cache-Control is an HTTP 1.1 header).
         def expires(max_age, opts=OPTS)
-          cache_control(Hash[opts].merge!(:max_age=>max_age))
+          cache_control(opts.merge(:max_age=>max_age))
           @headers[RodaResponseHeaders::EXPIRES] = (Time.now + max_age).httpdate
         end
 

data/lib/roda/plugins/capture_erb.rb

@@ -34,7 +34,7 @@ class Roda
     #
     # 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
+    # <tt>returns: :buffer</tt> argument 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>
@@ -46,9 +46,10 @@ class Roda
 
       # Support <tt>returns: :buffer</tt> to default to returning buffer
       # object.
-      def self.configure(app, opts=OPTS)
+      def self.configure(app, opts=(no_positional_opts = true; OPTS), returns: (opts.has_key?(:returns) ? opts[:returns] : (returns_not_set = true; nil)), **kw)
+        RodaPlugins.check_keywords("the capture_erb plugin", no_positional_opts, opts, kw)
         # RODA4: make returns: :buffer the default behavior
-        app.opts[:capture_erb_returns] = opts[:returns] if opts.has_key?(:returns)
+        app.opts[:capture_erb_returns] = returns unless returns_not_set
       end
 
       module ClassMethods
@@ -61,21 +62,23 @@ class Roda
         # Return the value of the block, converted to a string.
         # Restore the previous ERB output buffer before returning.
         #
-        # 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)
+        # Keyword arguments:
+        # +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=(no_positional_opts = true; OPTS), returns: (opts.has_key?(:returns) ? opts[:returns] : (returns_not_set = true; nil)), **kw, &block)
+          RodaPlugins.check_keywords(__callee__, no_positional_opts, opts, kw)
+
           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.class.capture_erb_returns }
+            returns = self.class.capture_erb_returns if returns_not_set
 
             begin
               instance_variable_set(outvar, String.new)

data/lib/roda/plugins/chunked.rb

@@ -23,7 +23,7 @@ class Roda
     # handling is reduced, since if an error occurs while rendering a template,
     # a successful response code has already been sent.
     #
-    # To use chunked encoding for a response, just call the chunked method
+    # To use chunked encoding for a response, call the +chunked+ method
     # instead of view:
     #
     #   r.root do
@@ -32,7 +32,7 @@ class Roda
     #
     # If you want to execute code after flushing the top part of the layout
     # template, but before rendering the content template, pass a block to
-    # chunked:
+    # +chunked+:
     #
     #   r.root do
     #     chunked(:index) do
@@ -40,7 +40,7 @@ class Roda
     #     end
     #   end
     #
-    # You can also call delay manually with a block, and the execution of the
+    # You can also call +delay+ manually with a block, and the execution of the
     # block will be delayed until rendering the content template.  This is
     # useful if you want to delay execution for all routes under a branch:
     #
@@ -56,12 +56,12 @@ class Roda
     #     end
     #   end
     #
-    # If you want to chunk all responses, pass the :chunk_by_default option
+    # If you want to chunk all responses, pass the +chunk_by_default+ argument
     # when loading the plugin:
     #
     #   plugin :chunked, chunk_by_default: true
     #
-    # then you can just use the normal view method:
+    # then you can just use the normal +view+ method:
     #
     #   r.root do
     #     view(:index)
@@ -73,17 +73,17 @@ class Roda
     # enable chunking by default, you need to make sure that none of your
     # content templates make state changes that affect the layout template.
     # Additionally, make sure nowhere in your app are you doing any processing
-    # after the call to view.
+    # after the call to +view+.
     #
-    # If you use :chunk_by_default, but want to turn off chunking for a view,
-    # call no_chunk!:
+    # If you use +chunk_by_default+, but want to turn off chunking for a view,
+    # call +no_chunk!+:
     #
     #   r.root do
     #     no_chunk!
     #     view(:index)
     #   end
     #
-    # Inside your layout or content templates, you can call the flush method
+    # Inside your layout or content templates, you can call the +flush+ method
     # to flush the current result of the template to the user, useful for
     # streaming large datasets.
     #
@@ -103,7 +103,7 @@ class Roda
     #   <% flush %><%= render(:subtemplate) %>
     #
     # If you want to use chunked encoding when rendering a template, but don't
-    # want to use a layout, pass the <tt>layout: false</tt> option to chunked.
+    # want to use a layout, pass the <tt>layout: false</tt> option to +chunked+.
     #
     #   r.root do
     #     chunked(:index, layout: false)
@@ -116,8 +116,8 @@ class Roda
     #     env['rack.logger'].error(e)
     #   end
     #
-    # It is possible to set @_out_buf to an error notification and call
-    # flush to output the message to the client inside handle_chunk_error.
+    # It is possible to set +@_out_buf+ to an error notification and call
+    # +flush+ to output the message to the client inside handle_chunk_error.
     #
     # In order for chunking to work, you must make sure that no proxies between
     # the application and the client buffer responses.
@@ -125,22 +125,22 @@ class Roda
     # If you are using nginx and have it set to buffer proxy responses by
     # default, you can turn this off on a per response basis using the
     # X-Accel-Buffering header.  To set this header or similar headers for
-    # all chunked responses, pass a :headers option when loading the plugin:
+    # all chunked responses, pass a +headers+ argument when loading the plugin:
     #
     #   plugin :chunked, headers: {'X-Accel-Buffering'=>'no'}
     #
-    # By default, this plugin does not use Transfer-Encoding: chunked, it only
+    # By default, this plugin does not use <tt>Transfer-Encoding: chunked</tt>, it only
     # returns a body that will stream the response in chunks.  If you would like
-    # to force the use of Transfer-Encoding: chunked, you can use the
-    # :force_chunked_encoding plugin option.  If using the
-    # :force_chunked_encoding plugin option, chunking will only be used for 
-    # HTTP/1.1 requests since Transfer-Encoding: chunked is only supported
+    # to force the use of <tt>Transfer-Encoding: chunked</tt>, you can use the
+    # +force_chunked_encoding+ plugin argument.  If using the
+    # +force_chunked_encoding+ argument, chunking will only be used for 
+    # HTTP/1.1 requests since <tt>Transfer-Encoding: chunked</tt> is only supported
     # in HTTP/1.1 (non-HTTP/1.1 requests will have behavior similar to
-    # calling no_chunk!).
+    # calling +no_chunk!+).
     #
     # The chunked plugin requires the render plugin, and only works for
     # template engines that store their template output variable in
-    # @_out_buf.  Also, it only works if the content template is directly
+    # +@_out_buf+.  Also, it only works if the content template is directly
     # injected into the layout template without modification.
     #
     # If using the chunked plugin with the flash plugin, make sure you
@@ -155,14 +155,16 @@ class Roda
         app.plugin :render
       end
 
-      # Set plugin specific options.  Options:
-      # :chunk_by_default :: chunk all calls to view by default
-      # :headers :: Set default additional headers to use when calling view
-      def self.configure(app, opts=OPTS)
-        app.opts[:chunk_by_default] = opts[:chunk_by_default]
-        app.opts[:force_chunked_encoding] = opts[:force_chunked_encoding]
-        if opts[:headers]
-          app.opts[:chunk_headers] = (app.chunk_headers || {}).merge(opts[:headers]).freeze
+      # Set plugin specific arguments.  Keyword arguments:
+      # +chunk_by_default+ :: chunk all calls to view by default
+      # +force_chunked_encoding+ :: force the use of Transfer-Encoding: chunked for HTTP 1.1 requests
+      # +headers+ :: Set default additional headers to use when calling view
+      def self.configure(app, opts=(no_positional_opts = true; OPTS), chunk_by_default: opts[:chunk_by_default], force_chunked_encoding: opts[:force_chunked_encoding], headers: opts[:headers], **kw)
+        RodaPlugins.check_keywords("the chunked plugin", no_positional_opts, opts, kw)
+        app.opts[:chunk_by_default] = chunk_by_default
+        app.opts[:force_chunked_encoding] = force_chunked_encoding
+        if headers
+          app.opts[:chunk_headers] = (app.chunk_headers || {}).merge(headers).freeze
         end
       end
 
@@ -251,7 +253,7 @@ class Roda
             if opts.empty?
               opts = template
             else
-              opts = Hash[opts].merge!(template)
+              opts = opts.merge(template)
             end
           end
           
@@ -295,7 +297,7 @@ class Roda
             @_out_buf = String.new
           end
 
-          if layout_opts  = view_layout_opts(opts)
+          if layout_opts = view_layout_opts(opts)
             @_out_buf = render_template(layout_opts) do
               flush
               run_delayed_blocks

data/lib/roda/plugins/class_level_routing.rb

@@ -45,13 +45,16 @@ class Roda
     #
     # When using the class_level_routing plugin with nested routes, you may also want to use the
     # delegate plugin to delegate certain instance methods to the request object, so you don't have
-    # to continually use +request.+ in your routing blocks.
+    # to continually use +request.+ in your routing blocks, or use the r plugin so you can use +r+
+    # instead of +request+.
     #
     # Note that class level routing is implemented via a simple array of routes, so routing performance
     # will degrade linearly as the number of routes increases.  For best performance, you should use
     # the normal +route+ class method to define your routing tree.  This plugin does make it simpler to
     # add additional routes after the routing tree has already been defined, though.
     module ClassLevelRouting
+      SCOPE_INSTANCE_VARIABLES = [:@_original_remaining_path].freeze
+
       # Initialize the class_routes array when the plugin is loaded.  Also, if the application doesn't
       # currently have a routing block, setup an empty routing block so that things will still work if
       # a routing block isn't added.
@@ -63,7 +66,7 @@ class Roda
         RodaPlugins.opt_attr_reader(self, :class_level_routes)
 
         # Define routing methods that will store class level routes.
-        [:root, :on, :is, :get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |request_meth|
+        %i[root on is get post delete head options link patch put trace unlink query].each do |request_meth|
           define_method(request_meth) do |*args, &block|
             meth = define_roda_method("class_level_routing_#{request_meth}", :any, &block)
             class_level_routes << [request_meth, args, meth].freeze

data/lib/roda/plugins/class_matchers.rb

@@ -67,8 +67,8 @@ class Roda
     # Blocks passed to the class_matchers plugin are evaluated in route
     # block context.
     #
-    # When passing a regexp as a matcher, to class_matcher, you can provide a
-    # <tt>segment: true</tt> option to speed up the matching on Ruby 2.4+:
+    # When passing a regexp as a matcher to class_matcher, you can provide a
+    # <tt>segment: true</tt> argument to speed up the matching on Ruby 2.4+:
     #
     #   symbol_matcher(:employee_id, /E-(\d{6})/, segment: true) do |employee_id|
     #     employee_id.to_i
@@ -103,10 +103,13 @@ class Roda
         # If providing a registered class or symbol, the block will be called with the
         # captures returned by the block for the registered class or symbol, or the regexp
         # captures if no block was registered with the class or symbol. In either case,
-        # if a block is given, it should return an array with the captures to yield to
-        # the match block.
-        def class_matcher(klass, matcher, opts=OPTS, &block)
-          _symbol_class_matcher(Class, klass, matcher, block, opts) do |meth, (_, regexp, convert_meth, consume_meth)|
+        # if a block is given, it should return an object to yield to the match block,
+        # or an array to yield multiple arguments to the match block. If the block returns
+        # nil or false, it will be treated as not matching.
+        def class_matcher(klass, matcher, opts=(no_positional_opts = true; OPTS), segment: opts[:segment], **kw, &block)
+          RodaPlugins.check_keywords(__callee__, no_positional_opts, opts, kw)
+
+          _symbol_class_matcher(Class, klass, matcher, block, segment: segment) do |meth, (_, regexp, convert_meth, consume_meth)|
             if regexp
               if consume_meth == :_consume_single_segment
                 define_method(meth){_consume_single_segment(regexp, convert_meth)}
@@ -117,6 +120,8 @@ class Roda
               define_method(meth){_consume_segment(convert_meth)}
             end
           end
+
+          nil
         end
 
         # Freeze the class_matchers hash when freezing the app.

data/lib/roda/plugins/common_logger.rb

@@ -19,20 +19,31 @@ class Roda
     #   plugin :common_logger, $stdout
     #   plugin :common_logger, Logger.new('filename')
     #   plugin :common_logger, Logger.new('filename'), method: :debug
+    #   plugin :common_logger, use_request_ip: true
+    #
+    # Keyword Arguments:
+    # +method+ :: Specifies the method to call on the logger object when logging.
+    # +use_request_ip+ :: Use +request.ip+ to get the IP address, instead of the default
+    #                     of checking +HTTP_X_FORWARDED_FOR+ and then +REMOTE_ADDR+. This
+    #                     will become the default behavior starting in Roda 4.
     module CommonLogger
       SCOPE_INSTANCE_VARIABLES = [:@_request_timer].freeze
 
       MUTATE_LINE = RUBY_VERSION < '2.3' || RUBY_VERSION >= '3'
       private_constant :MUTATE_LINE
 
-      def self.configure(app, logger=nil, opts=OPTS)
+      def self.configure(app, logger=nil, opts=(no_positional_opts = true; OPTS), method: opts[:method], use_request_ip: false, **kw)
+        RodaPlugins.check_keywords("the common_logger plugin", no_positional_opts, opts, kw)
+
         common_logger = app.opts[:common_logger] = logger || app.opts[:common_logger] || $stderr # RODA4: drop setting of option, no longer used
-        app.opts[:common_logger_meth] = common_logger.method(opts.fetch(:method){logger.respond_to?(:write) ? :write : :<<})
+        app.opts[:common_logger_meth] = common_logger.method(method || (common_logger.respond_to?(:write) ? :write : :<<))
+        app.opts[:common_logger_use_request_ip] = use_request_ip # RODA4: Deefault to true
       end
 
       if RUBY_VERSION >= '2.1'
         # A timer object for calculating elapsed time.
         def self.start_timer
+          # RODA4.1: Remove
           Process.clock_gettime(Process::CLOCK_MONOTONIC)
         end
       else
@@ -45,6 +56,7 @@ class Roda
 
       module ClassMethods
         RodaPlugins.opt_attr_reader(self, :common_logger_meth)
+        RodaPlugins.opt_attr_reader(self, :common_logger_use_request_ip, name: :common_logger_use_request_ip?)
       end
 
       module InstanceMethods
@@ -62,7 +74,13 @@ 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} "
+          ip = if self.class.common_logger_use_request_ip?
+            @_request.ip
+          else
+            env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"]
+          end
+
+          line = "#{ip || "-"} - #{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:]]/){|c| sprintf("\\x%x", c.ord)}
           # simplecov:disable

data/lib/roda/plugins/conditional_sessions.rb

@@ -8,15 +8,15 @@ class Roda
     # use in applications that want to use sessions for some requests,
     # and want to be sure that sessions are not used for other requests.
     # For example, if you want to make sure that sessions are not used for
-    # requests with paths starting with /static, you could do:
+    # requests with paths starting with +/static+, you could do:
     #
     #   plugin :conditional_sessions, secret: ENV["SECRET"] do
     #     !path_info.start_with?('/static')
     #   end
     #
-    # The the request session, session_created_at, and session_updated_at methods
+    # Then the request +session+, +session_created_at+, and +session_updated_at+ methods
     # raise a RodaError exception when sessions are not allowed.  The request
-    # persist_session and route scope clear_session methods do nothing when
+    # +persist_session+ and route scope +clear_session+ methods do nothing when
     # sessions are not allowed.
     module ConditionalSessions
       # Pass all options to the sessions block, and use the block to define

data/lib/roda/plugins/content_for.rb

@@ -11,7 +11,7 @@ class Roda
     # of the normal content pane.
     #
     # In the template in which you want to store content, call
-    # content_for with a block:
+    # +content_for+ with a block:
     #
     #   <% content_for :foo do %>
     #     Some content here.
@@ -27,11 +27,11 @@ class Roda
     #   <% content_for :foo, "Some content" %>
     #
     # In the template in which you want to retrieve content,
-    # call content_for without the block or argument:
+    # call +content_for+ without the block or argument:
     #
     #   <%= content_for :foo %>
     #
-    # Note that when storing content by calling content_for
+    # Note that when storing content by calling +content_for+
     # with a block and embedding template code, the return
     # value of the block is used as the content (after being
     # converted to a string).  This can cause issues in some
@@ -51,7 +51,7 @@ class Roda
     # If content_for is used multiple times with the same key,
     # by default, the last call will append previous calls.
     # If you want to overwrite the previous content, pass the
-    # <tt>append: false</tt> option when loading the plugin:
+    # <tt>append: false</tt> argument when loading the plugin:
     #
     #   plugin :content_for, append: false
     module ContentFor
@@ -65,8 +65,9 @@ class Roda
 
       # Configure whether to append or overwrite if content_for
       # is called multiple times with the same key.
-      def self.configure(app, opts = OPTS)
-        app.opts[:append_content_for] = opts.fetch(:append, true)
+      def self.configure(app, opts=(no_positional_opts = true; OPTS), append: opts.fetch(:append, true), **kw)
+        RodaPlugins.check_keywords("the content_for plugin", no_positional_opts, opts, kw)
+        app.opts[:append_content_for] = append
       end
 
       module ClassMethods