roda 3.104.0 → 3.106.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ea3b3c7c8ffcfffa22412e123d09e718e876c13bdfcddbfae461daa813d81bd
-  data.tar.gz: 275d90d97fa2893654e368316c1233092ae5fcd60ac7e76ac026a45d2200582b
+  metadata.gz: 90404574f8af3e952feb444cabe5bb01430e2d7c3658daee9f22f0c22e25d5f6
+  data.tar.gz: 347ba47cf4c3b9e280848ba717a1a4a9f57f8ac0712d2aaa8e5942020c22cb29
 SHA512:
-  metadata.gz: 546ee3b7cb9d6c8eac9eb6bbc40272a1a5760f522bbe94b38bb78afa3f552a61dd23496d2dfcf4e65fe490b1cad67b229fed4c31ac22b9d25409e501f6bb5c82
-  data.tar.gz: f9e94f7612706155c60db6f9a14bb9b130386875f1c86e6a65bc29bf9fdb789719c08f5398f58708ac862ab8b3ec41fb34f11b21d7454878be4364fceb50ce91
+  metadata.gz: 00e03ccebd8d48c4c1576ae0da2929d85a30430114b9a292bd8b9029fba31b4a7fa10767d7fb59a643c4280fb659e9afa90dacde27c7a5bdbc98fc5ee1df40a6
+  data.tar.gz: 7867f8da5bad9db4102f09fc692158feee7605c8021b5d01bb07ebfe57d3a82ca0b18d7fc1341d6e5cdf9ff534736a6c9c3ce2420b2078abe96209ad423bce92

data/lib/roda/plugins/_optimized_matching.rb

@@ -52,9 +52,20 @@ class Roda
                   end
                 end
               elsif matcher == Integer
-                if (matchdata = /\A\/(\d{1,100})(?=\/|\z)/.match(@remaining_path)) && (value = scope.send(:_convert_class_Integer, matchdata[1]))
-                  @remaining_path = matchdata.post_match
-                  always{yield(value)}
+                rp = @remaining_path
+                if /\A\/(\d{1,100})(?=\/|\z)/.match?(rp)
+                  if last = rp.index('/', 1)
+                    value = rp[1, last-1]
+                    rp = rp[last, rp.length]
+                  else
+                    value = rp[1, rp.length]
+                    rp = ""
+                  end
+
+                  if value = scope.send(:_convert_class_Integer, value)
+                    @remaining_path = rp
+                    always{yield(value)}
+                  end
                 end
               else
                 path = @remaining_path
@@ -151,10 +162,11 @@ class Roda
                 always{yield rp[1, len]}
               end
             elsif matcher == Integer
-              if (matchdata = /\A\/(\d{1,100})\z/.match(@remaining_path)) && (value = scope.send(:_convert_class_Integer, matchdata[1]))
-                @remaining_path = ''
-                always{yield(value)}
-              end
+                rp = @remaining_path
+                if /\A\/(\d{1,100})\z/.match?(rp) && (value = scope.send(:_convert_class_Integer, rp[1, 101])) 
+                  @remaining_path = ''
+                  always{yield(value)}
+                end
             else
               path = @remaining_path
               captures = @captures.clear

data/lib/roda/plugins/_symbol_class_matchers.rb

@@ -8,7 +8,7 @@ class Roda
         private
 
         # Backend of symbol_matcher and class_matcher.
-        def _symbol_class_matcher(expected_class, obj, matcher, block, &request_class_block)
+        def _symbol_class_matcher(expected_class, obj, matcher, block, options=OPTS, &request_class_block)
           unless obj.is_a?(expected_class)
             raise RodaError, "Invalid type passed to class_matcher or symbol_matcher: #{matcher.inspect}"
           end
@@ -30,23 +30,23 @@ class Roda
               raise RodaError, "cannot provide Symbol matcher to class_matcher unless using symbol_matchers plugin: #{matcher.inspect}"
             end
 
-            regexp, consume_regexp, matcher_block = opts[:symbol_matchers][matcher]
+            regexp, consume_regexp, convert_meth, consume_meth = opts[:symbol_matchers][matcher]
 
             unless regexp
               raise RodaError, "unregistered symbol matcher given to #{type}_matcher: #{matcher.inspect}"
             end
 
-            block = _merge_matcher_blocks(type, obj, block, matcher_block)
+            block = _merge_matcher_blocks(type, obj, block, convert_meth)
           when Class
             unless opts[:class_matchers]
               raise RodaError, "cannot provide Class matcher to symbol_matcher unless using class_matchers plugin: #{matcher.inspect}"
             end
 
-            regexp, consume_regexp, matcher_block = opts[:class_matchers][matcher]
+            regexp, consume_regexp, convert_meth, consume_meth = opts[:class_matchers][matcher]
             unless regexp
               raise RodaError, "unregistered class matcher given to #{type}_matcher: #{matcher.inspect}"
             end
-            block = _merge_matcher_blocks(type, obj, block, matcher_block)
+            block = _merge_matcher_blocks(type, obj, block, convert_meth)
           else
             raise RodaError, "unsupported matcher given to #{type}_matcher: #{matcher.inspect}"
           end
@@ -59,7 +59,8 @@ class Roda
             private convert_meth
           end
 
-          array = opts[:"#{type}_matchers"][obj] = [regexp, consume_regexp, convert_meth].freeze
+          consume_meth ||= options[:segment] ? :_consume_single_segment : :consume
+          array = opts[:"#{type}_matchers"][obj] = [regexp, consume_regexp, convert_meth, consume_meth].freeze
 
           self::RodaRequest.class_eval do
             class_exec(meth, array, &request_class_block)
@@ -69,30 +70,30 @@ class Roda
           nil
         end
 
-        # If both block and matche_meth are given, 
+        # If both block and convert_meth are given, 
         # define a method for block, and then return a
-        # proc that calls matcher_meth first, and only calls
-        # the newly defined method with the return values of matcher_meth
+        # proc that calls convert_meth first, and only calls
+        # the newly defined method with the return values of convert_meth
         # if matcher_method returns a truthy value.
-        # Otherwise, return matcher_meth or block.
-        def _merge_matcher_blocks(type, obj, block, matcher_meth)
-          if matcher_meth
+        # Otherwise, return convert_meth or block.
+        def _merge_matcher_blocks(type, obj, block, convert_meth)
+          if convert_meth
             if block
-              convert_meth = :"_convert_merge_#{type}_#{obj}"
-              define_method(convert_meth, &block)
-              private convert_meth
+              convert_merge_meth = :"_convert_merge_#{type}_#{obj}"
+              define_method(convert_merge_meth, &block)
+              private convert_merge_meth
 
               proc do |*a|
-                if captures = send(matcher_meth, *a)
+                if captures = send(convert_meth, *a)
                   if captures.is_a?(Array)
-                    send(convert_meth, *captures)
+                    send(convert_merge_meth, *captures)
                   else
-                    send(convert_meth, captures)
+                    send(convert_merge_meth, captures)
                   end
                 end
               end
             else
-              matcher_meth
+              convert_meth
             end
           else
             block

data/lib/roda/plugins/branch_locals.rb

@@ -21,6 +21,8 @@ class Roda
     # have higher precedence than the render_locals plugin options, but lower precedence
     # than options you directly pass to the view/render methods.
     module BranchLocals
+      SCOPE_INSTANCE_VARIABLES = [:@_layout_locals, :@_view_locals].freeze
+
       # Load the render_locals plugin before this plugin, since this plugin
       # works by overriding methods in the render_locals plugin.
       def self.load_dependencies(app)

data/lib/roda/plugins/chunked.rb

@@ -148,6 +148,8 @@ class Roda
     # method is not called until template rendering, the flash may not be
     # rotated.
     module Chunked
+      SCOPE_INSTANCE_VARIABLES = [:@_chunked, :@_each_chunk_args, :@_delays, :@_flusher].freeze
+
       # Depend on the render plugin
       def self.load_dependencies(app, opts=OPTS)
         app.plugin :render
@@ -215,7 +217,7 @@ class Roda
         # If chunking by default, call chunked if it hasn't yet been
         # called and chunking is not specifically disabled.
         def view(*a)
-          if opts[:chunk_by_default] && !defined?(@_chunked) && !defined?(yield)
+          if opts[:chunk_by_default] && @_chunked != false && !defined?(yield)
             chunked(*a)
           else
             super
@@ -225,7 +227,7 @@ class Roda
         # Render a response to the user in chunks.  See Chunked for
         # an overview.  If a block is given, it is passed to #delay.
         def chunked(template, opts=OPTS, &block)
-          unless defined?(@_chunked)
+          if @_chunked.nil?
             @_chunked = !self.opts[:force_chunked_encoding] || @_request.http_version == "HTTP/1.1" 
           end
 

data/lib/roda/plugins/class_matchers.rb

@@ -67,6 +67,17 @@ 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+:
+    #
+    #   symbol_matcher(:employee_id, /E-(\d{6})/, segment: true) do |employee_id|
+    #     employee_id.to_i
+    #   end
+    #
+    # Use of <tt>segment: true</tt> requires that the regexp not match more than
+    # one segment (i.e. it cannot match +/+). Additionally, the entire segment will
+    # be captured, so any capture groups in the regexp will be ignored.
+    #
     # This plugin does not work with the params_capturing plugin, as it does not
     # offer the ability to associate block arguments with named keys.
     module ClassMatchers
@@ -92,10 +103,14 @@ class Roda
         # 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, &block)
-          _symbol_class_matcher(Class, klass, matcher, block) do |meth, (_, regexp, convert_meth)|
+        def class_matcher(klass, matcher, opts=OPTS, &block)
+          _symbol_class_matcher(Class, klass, matcher, block, opts) do |meth, (_, regexp, convert_meth, consume_meth)|
             if regexp
-              define_method(meth){consume(regexp, convert_meth)}
+              if consume_meth == :_consume_single_segment
+                define_method(meth){_consume_single_segment(regexp, convert_meth)}
+              else
+                define_method(meth){consume(regexp, convert_meth)}
+              end
             else
               define_method(meth){_consume_segment(convert_meth)}
             end

data/lib/roda/plugins/common_logger.rb

@@ -20,6 +20,8 @@ class Roda
     #   plugin :common_logger, Logger.new('filename')
     #   plugin :common_logger, Logger.new('filename'), method: :debug
     module CommonLogger
+      SCOPE_INSTANCE_VARIABLES = [:@_request_timer].freeze
+
       MUTATE_LINE = RUBY_VERSION < '2.3' || RUBY_VERSION >= '3'
       private_constant :MUTATE_LINE
 

data/lib/roda/plugins/content_for.rb

@@ -55,6 +55,8 @@ class Roda
     #
     #   plugin :content_for, append: false
     module ContentFor
+      SCOPE_INSTANCE_VARIABLES = [:@_content_for].freeze
+
       # Depend on the capture_erb plugin, since it uses capture_erb
       # to capture the content.
       def self.load_dependencies(app, _opts = OPTS)

data/lib/roda/plugins/content_security_policy.rb

@@ -111,6 +111,8 @@ class Roda
     # is given.  Also, there is a +report_only?+ method for returning whether report only
     # mode is enabled.
     module ContentSecurityPolicy
+      RESPONSE_INSTANCE_VARIABLES = [:@content_security_policy, :@skip_content_security_policy].freeze
+
       # Represents a content security policy.
       class Policy
         '
@@ -192,6 +194,8 @@ class Roda
         # Clear all settings, useful to remove any inherited settings.
         def clear
           @opts = {}
+          @report_only = nil
+          @header_value = nil
         end
 
         # Do not allow future modifications to any settings.

data/lib/roda/plugins/flash.rb

@@ -36,6 +36,8 @@ class Roda
     #     flash['a'] # = >'b'
     #   end
     module Flash
+      SCOPE_INSTANCE_VARIABLES = [:@_flash].freeze
+
       # Simple flash hash, where assiging to the hash updates the flash
       # used in the following request.
       class FlashHash < DelegateClass(Hash)

data/lib/roda/plugins/host_routing.rb

@@ -71,6 +71,8 @@ class Roda
     # This plugin uses the host method on the request to get the hostname (this method
     # is defined by Rack).
     module HostRouting
+      REQUEST_INSTANCE_VARIABLES = [:@_host_routing_host].freeze
+
       # Setup the host routing support.  The block yields an object used to
       # configure the plugin.  Options:
       #
@@ -110,6 +112,8 @@ class Roda
         def initialize
           @hosts = []
           @host_hash = {}
+          @default_host = nil
+          @default_block = nil
         end
 
         # Run the DSL for the given block.

data/lib/roda/plugins/indifferent_params.rb

@@ -39,6 +39,8 @@ class Roda
     # it affects all rack applications instead of just the Roda app that
     # you load the plugin into.
     module IndifferentParams
+      SCOPE_INSTANCE_VARIABLES = [:@_params].freeze
+
       INDIFFERENT_PROC = lambda{|h,k| h[k.to_s] if k.is_a?(Symbol)}
 
       if Rack.release > '2'

data/lib/roda/plugins/mailer.rb

@@ -127,6 +127,8 @@ class Roda
     # Roda application if you want your helper methods to automatically be
     # available in your email views.
     module Mailer
+      RESPONSE_INSTANCE_VARIABLES = [:@mail, :@mail_attachments].freeze
+
       # Error raised when the using the mail class method, but the routing
       # tree doesn't return the mail object. 
       class Error < ::Roda::RodaError; end

data/lib/roda/plugins/not_allowed.rb

@@ -68,6 +68,8 @@ class Roda
     #
     # This plugin depends on the all_verbs plugin.
     module NotAllowed
+      REQUEST_INSTANCE_VARIABLES = [:@_is_verbs].freeze
+
       # Depend on the all_verbs plugin, as this plugin overrides methods
       # defined by it and calls super.
       def self.load_dependencies(app)

data/lib/roda/plugins/params_capturing.rb

@@ -55,6 +55,8 @@ class Roda
     # the symbol_matchers plugin with custom symbol matching and are using
     # symbols that capture multiple values or no values.
     module ParamsCapturing
+      REQUEST_INSTANCE_VARIABLES = [:@_params_captures].freeze
+
       module RequestMethods
         # Lazily initialize captures entry when params is called.
         def params

data/lib/roda/plugins/permissions_policy.rb

@@ -104,6 +104,8 @@ class Roda
     # setting a policy.  This is faster than calling +permissions_policy.clear+, since
     # it does not duplicate the default policy.
     module PermissionsPolicy
+      RESPONSE_INSTANCE_VARIABLES = [:@permissions_policy, :@skip_permissions_policy].freeze
+
       SUPPORTED_SETTINGS = %w'
       accelerometer
       ambient-light-sensor
@@ -180,6 +182,8 @@ class Roda
         # Clear all settings, useful to remove any inherited settings.
         def clear
           @opts = {}
+          @report_only = nil
+          @header_value = nil
         end
 
         # Do not allow future modifications to any settings.

data/lib/roda/plugins/relative_path.rb

@@ -31,6 +31,8 @@ class Roda
     # This plugin is mostly designed for applications using Roda as a static
     # site generator, where the generated site can be hosted at any subpath.
     module RelativePath
+      SCOPE_INSTANCE_VARIABLES = [:@_relative_prefix].freeze
+
       module InstanceMethods
         # Return a relative path for the absolute path based on the current path
         # of the request by adding the appropriate prefix.

data/lib/roda/plugins/request_headers.rb

@@ -25,6 +25,8 @@ class Roda
     #
     #   plugin :request_headers
     module RequestHeaders
+      REQUEST_INSTANCE_VARIABLES = [:@request_headers].freeze
+
       module RequestMethods
         # Provide access to the request headers while normalizing indexes.
         def headers

data/lib/roda/plugins/response_request.rb

@@ -10,6 +10,13 @@ class Roda
     #
     #   plugin :response_request
     module ResponseRequest
+      # This isn't set because it breaks usage with the error_handler/class_level_routing
+      # plugins and the shape_friendly plugin, due to those calling RodaResponse#initialize,
+      # which would reset @request to nil. It isn't strictly necessary to set this for
+      # shape friendliness, as the Roda#initialize sets it directly after creating the
+      # RodaRequest, so in normal use, the instance variable will already be set.
+      # RESPONSE_INSTANCE_VARIABLES = [:@request].freeze
+
       module InstanceMethods
         # Set the response's request to the current request.
         def initialize(env)

data/lib/roda/plugins/sec_fetch_site_csrf.rb

@@ -2,16 +2,16 @@
 
 class Roda
   module RodaPlugins
-    # The sec_fetch_site plugin allows for CSRF protection using the
+    # The sec_fetch_site_csrf plugin allows for CSRF protection using the
     # Sec-Fetch-Site header added in modern browsers. It allows for CSRF
     # protection without the use of CSRF tokens, which can simplify
     # form creation.
     #
-    # The protection offered by the sec_fetch_site plugin is weaker than
+    # The protection offered by the sec_fetch_site_csrf plugin is weaker than
     # the protection offered by the route_csrf plugin with default settings,
     # since it doesn't support per-request tokens. Be aware you are trading
-    # security for simplicity when using the sec_fetch_site plugin instead
-    # of the route_csrf plugin.  Other caveats in using the sec_fetch_site
+    # security for simplicity when using the sec_fetch_site_csrf plugin instead
+    # of the route_csrf plugin.  Other caveats in using the sec_fetch_site_csrf
     # plugin:
     #
     # * Not all browsers set the Sec-Fetch-Site header. Some browsers

data/lib/roda/plugins/shape_friendly.rb

@@ -0,0 +1,232 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The shape_friendly plugin makes the scope, request, and response objects
+    # used by Roda friendly to object shapes, which can result in better
+    # performance on modern versions of Ruby, especially when the JIT compiler
+    # is enabled. All plugins shipped with Roda integrate with this plugin.
+    #
+    # In order for this behavior to be beneficial for your application, you
+    # need to either avoid setting instance variables inside your routing
+    # tree, or you need to register each instance variable used, to ensure
+    # that all instances have the same shape.
+    #
+    # If you want to avoid using instance variables in your routing tree, you
+    # can switch to using local variables. If using the render plugin, you can
+    # pass data from your routing tree to your views using the +:locals+ option.
+    # When passing data from your routing tree to other routing trees, such as
+    # when using the hash_branches plugin, you can use the shared_vars plugin,
+    # which stores the data in the Rack environment.
+    #
+    # To register instance variables set in your applications routing tree,
+    # use a +:scope_instance_variables+ option when loading the plugin,
+    # listing the instance variable symbols you are setting in the route
+    # block scope:
+    #
+    #   class MyApp < Roda
+    #     plugin :shape_friendly, scope_instance_variables: [:@var1, @:var2]
+    #
+    #     route do |r|
+    #       r.root do
+    #         @var1 = "a"
+    #         @var1.inspect
+    #       end
+    #
+    #       @var2 = "b"
+    #       @var2.inspect
+    #     end
+    #   end
+    #
+    # When developing external plugins, you can set one of three constants in
+    # the plugin module to integrate with this plugin to support shape friendly
+    # behavior:
+    #
+    # * +SCOPE_INSTANCE_VARIABLES+: For instance variables set in +InstanceMethods+.
+    # * +REQUEST_INSTANCE_VARIABLES+: For instance variables set in +RequestMethods+.
+    # * +RESPONSE_INSTANCE_VARIABLES+: For instance variables set in +ResponseMethods+.
+    #
+    # These constants are set in the plugin module, not in the plugin's
+    # +InstanceMethods+, +RequestMethods+, or +ResponseMethods+ modules, to
+    # avoid pollution of the related namespaces in the class loading the plugin.
+    module ShapeFriendly
+      # This is used by the base support and not by this plugin.
+      RESPONSE_INSTANCE_VARIABLES = [:@status].freeze
+
+      # Set the Roda application to create the private
+      # _initialize_nil_instance_variables for the plugin to use.
+      def self.configure(app, opts=OPTS)
+        if scope_ivs = opts[:scope_instance_variables]
+          app.opts[:shape_friendly_scope_instance_variables] = Array(scope_ivs).dup.freeze
+        end
+
+        app.instance_exec do
+          def_initialize_nil_instance_variables(app, :SCOPE_INSTANCE_VARIABLES)
+          def_initialize_nil_instance_variables(app::RodaRequest, :REQUEST_INSTANCE_VARIABLES)
+          def_initialize_nil_instance_variables(app::RodaResponse, :RESPONSE_INSTANCE_VARIABLES)
+
+          # Avoid overhead of super call if possible
+          include(instance_method(:initialize).owner == Roda::RodaPlugins::Base::InstanceMethods ? OptimizedInstanceMethods : UnoptimizedInstanceMethods)
+          app::RodaRequest.send(:include, app::RodaRequest.instance_method(:initialize).owner == Roda::RodaPlugins::Base::RequestMethods ? OptimizedRequestMethods : UnoptimizedRequestMethods)
+          app::RodaResponse.send(:include, app::RodaResponse.instance_method(:initialize).owner == Roda::RodaPlugins::Base::ResponseMethods ? OptimizedResponseMethods : UnoptimizedResponseMethods)
+        end
+      end
+
+      module ClassMethods
+        # Automatically refresh the instance variables used if the plugin
+        # sets instance variables.
+        def plugin(plugin, *args, &block)
+          super
+          plugin = RodaPlugins.load_plugin(plugin) if plugin.is_a?(Symbol)
+          [
+            [self, :SCOPE_INSTANCE_VARIABLES],
+            [self::RodaRequest, :REQUEST_INSTANCE_VARIABLES],
+            [self::RodaResponse, :RESPONSE_INSTANCE_VARIABLES],
+          ].each do |klass, ivs_const|
+            if plugin.const_defined?(ivs_const)
+              def_initialize_nil_instance_variables(klass, ivs_const)
+            end
+          end
+          nil
+        end
+        # :nocov:
+        ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
+
+        private
+
+        # If there are any intance variables configured in one of the plugins
+        # (looking for the +const+ constant in the plugin), override the
+        # private _initialize_nil_instance_variables method for the class,
+        # and have it initialize each instance variable to nil. 
+        def def_initialize_nil_instance_variables(klass, const)
+          ivs = []
+
+          plugins.each do |mod|
+            ivs.concat(mod.const_get(const)) if mod.const_defined?(const)
+          end
+
+          if const == :SCOPE_INSTANCE_VARIABLES && (scope_ivs = opts[:shape_friendly_scope_instance_variables])
+            ivs.concat(scope_ivs)
+          end
+
+          ivs.each do |iv|
+            unless /\A@[a-z_][a-z0-9_]*\z/.match(iv)
+              raise RodaError, "invalid scope instance variable used"
+            end
+          end
+
+          unless ivs.empty?
+            ivs.uniq!
+
+            klass.class_eval(<<-RUBY, __FILE__, __LINE__+1)
+              def _initialize_nil_instance_variables
+                #{ivs.reverse.join(" = ")} = nil
+              end
+              private :_initialize_nil_instance_variables
+              alias _initialize_nil_instance_variables _initialize_nil_instance_variables
+            RUBY
+            nil
+          end
+        end
+      end
+
+      # :nocov:
+      if RUBY_VERSION >= '4.0'
+      # :nocov:
+        module InstanceMethods
+          private
+
+          def instance_variables_to_inspect
+            instance_variables.reject{|v| instance_variable_get(v).nil?}
+          end
+        end
+      end
+
+      module OptimizedInstanceMethods
+        # Initialize configured instance variables to nil.
+        def initialize(env)
+          _initialize_nil_instance_variables
+          klass = self.class
+          @_request = klass::RodaRequest.new(self, env)
+          @_response = klass::RodaResponse.new
+        end
+
+        private
+
+        def _initialize_nil_instance_variables
+          nil
+        end
+      end
+
+      module UnoptimizedInstanceMethods
+        # Initialize configured instance variables to nil.
+        def initialize(env)
+          _initialize_nil_instance_variables
+          super
+        end
+
+        private
+
+        def _initialize_nil_instance_variables
+          nil
+        end
+      end
+
+      module OptimizedRequestMethods
+        # Initialize configured instance variables to nil.
+        def initialize(scope, env)
+          _initialize_nil_instance_variables
+          @scope = scope
+          @captures = []
+          @remaining_path = _remaining_path(env)
+          @env = env
+        end
+
+        private
+
+        def _initialize_nil_instance_variables
+          nil
+        end
+      end
+
+      module UnoptimizedRequestMethods
+        # Initialize configured instance variables to nil.
+        def initialize(scope, env)
+          _initialize_nil_instance_variables
+          super
+        end
+
+        private
+
+        def _initialize_nil_instance_variables
+          nil
+        end
+      end
+
+      module OptimizedResponseMethods
+        def initialize
+          _initialize_nil_instance_variables
+          @headers = _initialize_headers
+          @body    = []
+          @length  = 0
+        end
+      end
+
+      module UnoptimizedResponseMethods
+        # Initialize configured instance variables to nil.
+        def initialize
+          _initialize_nil_instance_variables
+          super
+        end
+      end
+
+      # For response methods, there is no default definition for
+      # _initialize_nil_instance_variables, as the plugin will always
+      # define a method in the class it is loaded into.
+    end
+
+    register_plugin(:shape_friendly, ShapeFriendly)
+  end
+end

data/lib/roda/plugins/sinatra_helpers.rb

@@ -213,6 +213,7 @@ class Roda
         # called until the body is needed.
         def initialize(&block)
           @block = block
+          @value = nil
         end
 
         # If the body is a String, yield it, otherwise yield each string

data/lib/roda/plugins/symbol_matchers.rb

@@ -19,6 +19,15 @@ class Roda
     # Then the route will only if the path is +/foobar123+, but not if it is
     # +/foo+, +/FooBar123+, or +/foobar_123+.
     #
+    # You can provide a <tt>segment: true</tt> option to symbol_matcher to speed up
+    # the matching on Ruby 2.4+:
+    #
+    #   symbol_matcher :username, /([a-z0-9]{6,20})/, segment: true
+    #
+    # Use of <tt>segment: true</tt> requires that the regexp not match more than
+    # one segment (i.e. it cannot match +/+). Additionally, the entire segment will
+    # be captured, so any capture groups in the regexp will be ignored.
+    #
     # By default, this plugin sets up the following symbol matchers:
     #
     # :d :: <tt>/(\d+)/</tt>, a decimal segment
@@ -106,8 +115,8 @@ class Roda
 
       def self.configure(app)
         app.opts[:symbol_matchers] ||= {}
-        app.symbol_matcher(:d, /(\d+)/)
-        app.symbol_matcher(:w, /(\w+)/)
+        app.symbol_matcher(:d, /(\d+)/, segment: true)
+        app.symbol_matcher(:w, /(\w+)/, segment: true)
         app.symbol_matcher(:rest, /(.*)/)
       end
 
@@ -122,8 +131,8 @@ class Roda
         # captures if no block was registered with the symbol or class. In either case,
         # if a block is given, it should return an array with the captures to yield to
         # the match block.
-        def symbol_matcher(s, matcher, &block)
-          _symbol_class_matcher(Symbol, s, matcher, block) do |meth, array|
+        def symbol_matcher(s, matcher, opts=OPTS, &block)
+          _symbol_class_matcher(Symbol, s, matcher, block, opts) do |meth, array|
             define_method(meth){array}
           end
 
@@ -147,9 +156,9 @@ class Roda
           meth = :"match_symbol_#{s}"
           if respond_to?(meth, true)
             # Allow calling private match methods
-            _, re, convert_meth = send(meth)
+            _, re, convert_meth, consume_meth = send(meth)
             if re
-              consume(re, convert_meth)
+              send(consume_meth, re, convert_meth)
             else
               # defined in class_matchers plugin
               _consume_segment(convert_meth)

data/lib/roda/plugins/type_routing.rb

@@ -89,6 +89,8 @@ class Roda
     # :use_header :: Whether to take the +Accept+ header into account.
     #                Default is +true+.
     module TypeRouting
+      REQUEST_INSTANCE_VARIABLES = [:@requested_type, :@type_routing_extension].freeze
+
       CONFIGURATION = {
         :mimes => {
           'text/json' => :json,
@@ -158,7 +160,7 @@ class Roda
 
         # Returns the data type the client requests.
         def requested_type
-          return @requested_type if defined?(@requested_type)
+          return @requested_type if @requested_type
 
           opts = @scope.opts[:type_routing]
           @requested_type = accept_response_type if opts[:use_header]
@@ -168,7 +170,7 @@ class Roda
         # Append the type routing extension back to the path if it was
         # removed before routing.
         def real_remaining_path
-          if defined?(@type_routing_extension)
+          if @type_routing_extension
             "#{super}.#{@type_routing_extension}"
           else
             super

data/lib/roda/plugins/typecast_params.rb

@@ -307,6 +307,8 @@ class Roda
     # 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
+      SCOPE_INSTANCE_VARIABLES = [:@_typecast_params, :@_typecast_query_params, :@_typecast_body_params].freeze
+
       # Sentinal value for whether to raise exception during #process
       CHECK_NIL = Object.new.freeze
 

data/lib/roda/plugins/view_options.rb

@@ -80,6 +80,8 @@ class Roda
     #     end
     #   end
     module ViewOptions
+      SCOPE_INSTANCE_VARIABLES = [:@_view_subdir, :@_view_options, :@_layout_options].freeze
+
       # Load the render plugin before this plugin, since this plugin
       # works by overriding methods in the render plugin.
       def self.load_dependencies(app)

data/lib/roda/request.rb

@@ -444,7 +444,7 @@ class Roda
         # Match integer segment of up to 100 decimal characters, and yield resulting value as an
         # integer.
         def _match_class_Integer
-          consume(/\A\/(\d{1,100})(?=\/|\z)/, :_convert_class_Integer)
+          _consume_single_segment(/\A\/(\d{1,100})(?=\/|\z)/, :_convert_class_Integer)
         end
 
         # Match only if all of the arguments in the given array match.
@@ -585,6 +585,39 @@ class Roda
           end
         end
 
+        if RUBY_VERSION >= "2.4"
+          # A faster version of consume that can be used if you are sure the regexp
+          # will match a single segment if it matches, capturing the entire segment.
+          def _consume_single_segment(regexp, meth=nil)
+            rp = @remaining_path
+            if regexp.match?(rp)
+              if last = rp.index('/', 1)
+                val = rp[1, last-1]
+                @remaining_path = rp[last, rp.length]
+              else
+                val = rp[1, rp.length]
+                @remaining_path = ""
+              end
+
+              if meth
+                if captures = scope.send(meth, val)
+                  if captures.is_a?(Array)
+                    @captures.concat(captures)
+                  else
+                    @captures << captures
+                  end
+                end
+              else
+                @captures << val
+              end
+            end
+          end
+        # :nocov:
+        else
+          alias _consume_single_segment consume
+        # :nocov:
+        end
+
         # The default path to use for redirects when a path is not given.
         # For non-GET requests, redirects to the current path, which will
         # trigger a GET request.  This is to make the common case where

data/lib/roda/session_middleware.rb

@@ -29,6 +29,7 @@ class RodaSessionMiddleware
 
     def initialize(req)
       @req = req
+      @data = nil
     end
 
     # The Roda sessions plugin options used by the middleware for this
@@ -124,7 +125,7 @@ class RodaSessionMiddleware
 
     # Whether the session has already been loaded from the cookie yet.
     def loaded?
-      !!defined?(@data)
+      !!@data
     end
 
     def empty?

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

data/lib/roda.rb

@@ -17,6 +17,7 @@ class Roda
   @app = nil
   @inherit_middleware = true
   @middleware = []
+  @plugins = []
   @opts = {}
   @raw_route_block = nil
   @route_block = nil
@@ -42,6 +43,9 @@ class Roda
         # The settings/options hash for the current class.
         attr_reader :opts
 
+        # The plugins loaded into the current class.
+        attr_reader :plugins
+
         # The route block that this class uses.
         attr_reader :route_block
 
@@ -217,13 +221,14 @@ class Roda
               plugin :direct_call
             end
 
-            if ([:on, :is, :_verb, :_match_class_String, :_match_class_Integer, :_match_string, :_match_regexp, :empty_path?, :if_match, :match, :_match_class]).all?{|m| self::RodaRequest.instance_method(m).owner == RequestMethods}
+            if RUBY_VERSION > "2.4" && ([:on, :is, :_verb, :_match_class_String, :_match_class_Integer, :_match_string, :_match_regexp, :empty_path?, :if_match, :match, :_match_class]).all?{|m| self::RodaRequest.instance_method(m).owner == RequestMethods}
               plugin :_optimized_matching
             end
           end
 
           build_rack_app
           @opts.freeze
+          @plugins.freeze
           @middleware.freeze
 
           super
@@ -250,6 +255,7 @@ class Roda
           super
           subclass.instance_variable_set(:@inherit_middleware, @inherit_middleware)
           subclass.instance_variable_set(:@middleware, @inherit_middleware ? @middleware.dup : [])
+          subclass.instance_variable_set(:@plugins, @plugins.dup)
           subclass.instance_variable_set(:@opts, opts.dup)
           subclass.opts.delete(:subclassed)
           subclass.opts.to_a.each do |k,v|
@@ -291,6 +297,7 @@ class Roda
           end
 
           plugin.load_dependencies(self, *args, &block) if plugin.respond_to?(:load_dependencies)
+          @plugins << plugin unless @plugins.include?(plugin)
           include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
           extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)
           self::RodaRequest.send(:include, plugin::RequestMethods) if defined?(plugin::RequestMethods)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.104.0
+  version: 3.106.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -292,6 +292,7 @@ files:
 - lib/roda/plugins/sec_fetch_site_csrf.rb
 - lib/roda/plugins/send_file.rb
 - lib/roda/plugins/sessions.rb
+- lib/roda/plugins/shape_friendly.rb
 - lib/roda/plugins/shared_vars.rb
 - lib/roda/plugins/sinatra_helpers.rb
 - lib/roda/plugins/slash_path_empty.rb