roda 3.45.0 → 3.49.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dbdf55425a681a0cb32fa0b4a44cd50bf5be6f85c78c1ea1adbdd19e28c2d61
-  data.tar.gz: e91ee695e5f8648f4269a2c229b794ef2ee921f4291102519d4ca2cadd9bf13a
+  metadata.gz: 2d3b9688bae8b0013acedfc6a5bcb45c374e0a73fd30e56985f0ebeee942ef8c
+  data.tar.gz: acb8215250d1615f007a2ec01d2b6546376414d2fea23a4f2341af9efd951110
 SHA512:
-  metadata.gz: aa46429e09091c3cf0112c251a9863845c69d4245674dcaddaec030244213d8b9ac1aae96cfa6093680c33f87c732ee4464e4cbe2572d192eb0a9f7e09acd43b
-  data.tar.gz: 57cf84f7db6e6334918f0c01f7308c4c48db7e0ba9f2a14fe87420c3b2bd17471a229ec02a2ad9242ec6fd4aa67848f6dff04b319fea361a985dd264b52252ab
+  metadata.gz: 3a5434bdcb6926d6c5e656c25b46e16b035ad54d74ed16bdc1cf46005b8ef605b3371a628cae52d65803064aa3d2eac8a56c2e8e1e55b6f3a82c04a74c636855
+  data.tar.gz: 9dc3773fae04325373adb8a7a57d52166bb65c238b959999adf6f6f17a3be29fcdedcea677eeeaaa84f6a01b5accb4aff2594817165b8a77a45106a3d4a9dea3

data/CHANGELOG

@@ -1,3 +1,21 @@
+= 3.49.0 (2021-10-13)
+
+* Switch block_given? to defined?(yield) (jeremyevans)
+
+* Automatically optimize remaining r.is/r.get/r.post calls with a single argument (jeremyevans)
+
+= 3.48.0 (2021-09-13)
+
+* Extract named_routes plugin from multi_route plugin (jeremyevans)
+
+= 3.47.0 (2021-08-13)
+
+* Automatically optimize remaining r.on calls with a single argument (jeremyevans)
+
+= 3.46.0 (2021-07-12)
+
+* Automatically optimize r.on/r.is/r.get/r.post methods with a single string, String, Integer, or regexp argument (jeremyevans)
+
 = 3.45.0 (2021-06-14)
 
 * Make typecast_params plugin check for null bytes in strings by default, with :allow_null_bytes option for previous behavior (jeremyevans)

data/README.rdoc

@@ -13,7 +13,6 @@ 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
-IRC :: irc://chat.freenode.net/#roda
 
 == Goals
 
@@ -1110,7 +1109,8 @@ Roda's plugin system is based on the plugin system used by
 Roda fully supports the currently supported versions of Ruby (MRI) and JRuby.  It may
 support unsupported versions of Ruby or JRuby, but such support may be dropped in any
 minor version if keeping it becomes a support issue.  The minimum Ruby version
-required to run the current version of Roda is 1.9.2.
+required to run the current version of Roda is 1.9.2, and the minimum JRuby version is
+9.0.0.0.
 
 == License
 

data/doc/release_notes/3.46.0.txt

@@ -0,0 +1,19 @@
+= Improvements
+
+* The r.on, r.is, r.get and r.post methods (and other verb methods
+  if using the all_verbs plugin) have now been optimized when using
+  a single string or regexp matcher, or the String or Integer class
+  matcher.  Since those four matchers are the most common types of
+  matchers passed to the methods, this can significantly improve
+  routing performance (about 50% in the r10k benchmark).
+
+  This optimization is automatically applied when freezing
+  applications, if the related methods have not been modified by
+  plugins.
+
+  This optimization does come at the expense of a small decrease
+  in routing performance (3-4%) for unoptimized cases, but the
+  majority of applications will see a overall performance benefit
+  from this change.
+
+* Other minor performance improvements have been made.

data/doc/release_notes/3.47.0.txt

@@ -0,0 +1,13 @@
+= Improvements
+
+* The r.on optimization added in 3.46.0 has been extended to optimize
+  all single argument calls. This results in the following speedups
+  based on argument type:
+
+  * Hash matching: 10%
+  * Array/Symbol/Class matching: 15%
+  * Proc matching: 25%
+  * true matching: 45%
+  * false/nil matching: 65%
+
+* Other minor performance improvements have been made.

data/doc/release_notes/3.48.0.txt

@@ -0,0 +1,10 @@
+= New Features
+
+* A named_routes plugin has been added, for defining named route
+  blocks that you can dispatch to with r.route.  This feature was
+  previously available as part of the multi_route plugin, but there
+  are cases where the r.route method and support for named routes is
+  helpful even when the multi_route plugin is not used (such as when
+  the hash_routes plugin is used instead of the multi_route plugin).
+  The multi_route plugin now depends on the named_routes plugin, so
+  this change should not cause any backwards compatibility issues.

data/doc/release_notes/3.49.0.txt

@@ -0,0 +1,18 @@
+= Improvements
+
+* The r.is optimization added in 3.46.0 has been extended to optimize
+  all single argument calls. This results in the following speedups
+  based on argument type:
+
+  * Hash/Class matching: 20%
+  * Symbol matching: 25%
+  * Array matching: 35%
+  * Proc matching: 50%
+  * false/nil matching: 65%
+
+* Roda now uses defined?(yield) instead of block_given? internally
+  for better performance on CRuby.  defined?(yield) is faster as it is
+  built into the VM, while block_given? is a regular method and has
+  the overhead of calling a regular method.  Note that defined?(yield)
+  is not implemented correctly on JRuby before 9.0.0.0, so this
+  release of Roda drops support for JRuby versions before 9.0.0.0.

data/lib/roda/plugins/_optimized_matching.rb

@@ -0,0 +1,215 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The _optimized_matching plugin is automatically used internally to speed
+    # up matching when a single argument String instance, String class, Integer
+    # class, or Regexp matcher is passed to +r.on+, +r.is_+, or a verb method
+    # such as +r.get+ or +r.post+.
+    # 
+    # The optimization works by avoiding the +if_match+ method if possible.
+    # Instead of clearing the captures array on every call, and having the
+    # matching append to the captures, it checks directly for the match,
+    # and on succesful match, it yields directly to the block without using
+    # the captures array.
+    module OptimizedMatching 
+      TERM = Base::RequestMethods::TERM
+
+      module RequestMethods
+        # Optimize the r.is method handling of a single string, String, Integer,
+        # regexp, or true, argument.
+        def is(*args, &block)
+          case args.length
+          when 1
+            _is1(args, &block)
+          when 0
+            always(&block) if @remaining_path.empty?
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+
+        # Optimize the r.on method handling of a single string, String, Integer,
+        # or regexp argument.  Inline the related matching code to avoid the
+        # need to modify @captures.
+        def on(*args, &block)
+          case args.length
+          when 1
+            case matcher = args[0]
+            when String
+              always{yield} if _match_string(matcher)
+            when Class
+              if matcher == String
+                rp = @remaining_path
+                if rp.getbyte(0) == 47
+                  if last = rp.index('/', 1)
+                    @remaining_path = rp[last, rp.length]
+                    always{yield rp[1, last-1]}
+                  elsif (len = rp.length) > 1
+                    @remaining_path = ""
+                    always{yield rp[1, len]}
+                  end
+                end
+              elsif matcher == Integer
+                if matchdata = /\A\/(\d+)(?=\/|\z)/.match(@remaining_path)
+                  @remaining_path = matchdata.post_match
+                  always{yield(matchdata[1].to_i)}
+                end
+              else
+                path = @remaining_path
+                captures = @captures.clear
+                meth = :"_match_class_#{matcher}"
+                if respond_to?(meth, true)
+                  # Allow calling private methods, as match methods are generally private
+                  if send(meth, &block)
+                    block_result(yield(*captures))
+                    throw :halt, response.finish
+                  else
+                    @remaining_path = path
+                    false
+                  end
+                else
+                  unsupported_matcher(matcher)
+                end
+              end
+            when Regexp
+              if matchdata = self.class.cached_matcher(matcher){matcher}.match(@remaining_path)
+                @remaining_path = matchdata.post_match
+                always{yield(*matchdata.captures)}
+              end
+            when true
+              always(&block)
+            when false, nil
+              # nothing
+            else
+              path = @remaining_path
+              captures = @captures.clear
+
+              matched = case matcher
+              when Array
+                _match_array(matcher)
+              when Hash
+                _match_hash(matcher)
+              when Symbol
+                _match_symbol(matcher)
+              when Proc
+                matcher.call
+              else
+                unsupported_matcher(matcher)
+              end
+
+              if matched
+                block_result(yield(*captures))
+                throw :halt, response.finish
+              else
+                @remaining_path = path
+                false
+              end
+            end
+          when 0
+            always(&block)
+          else
+            if_match(args, &block)
+          end
+        end
+
+        private
+
+        # Optimize the r.get/r.post method handling of a single string, String, Integer,
+        # regexp, or true, argument.
+        def _verb(args, &block)
+          case args.length
+          when 0
+            always(&block)
+          when 1
+            _is1(args, &block)
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+
+        # Internals of r.is/r.get/r.post optimization.  Inline the related matching
+        # code to avoid the need to modify @captures.
+        def _is1(args, &block)
+          case matcher = args[0]
+          when String
+            rp = @remaining_path
+            if _match_string(matcher)
+              if @remaining_path.empty?
+                always{yield}
+              else
+                @remaining_path = rp
+                nil
+              end
+            end
+          when Class
+            if matcher == String
+              rp = @remaining_path
+              if rp.getbyte(0) == 47 && !rp.index('/', 1) && (len = rp.length) > 1
+                @remaining_path = ''
+                always{yield rp[1, len]}
+              end
+            elsif matcher == Integer
+              if matchdata = /\A\/(\d+)\z/.match(@remaining_path)
+                @remaining_path = ''
+                always{yield(matchdata[1].to_i)}
+              end
+            else
+              path = @remaining_path
+              captures = @captures.clear
+              meth = :"_match_class_#{matcher}"
+              if respond_to?(meth, true)
+                # Allow calling private methods, as match methods are generally private
+                if send(meth, &block) && @remaining_path.empty?
+                  block_result(yield(*captures))
+                  throw :halt, response.finish
+                else
+                  @remaining_path = path
+                  false
+                end
+              else
+                unsupported_matcher(matcher)
+              end
+            end
+          when Regexp
+            if (matchdata = self.class.cached_matcher(matcher){matcher}.match(@remaining_path)) && matchdata.post_match.empty?
+              @remaining_path = ''
+              always{yield(*matchdata.captures)}
+            end
+          when true
+            always(&block) if @remaining_path.empty?
+          when false, nil
+            # nothing
+          else
+            path = @remaining_path
+            captures = @captures.clear
+
+            matched = case matcher
+            when Array
+              _match_array(matcher)
+            when Hash
+              _match_hash(matcher)
+            when Symbol
+              _match_symbol(matcher)
+            when Proc
+              matcher.call
+            else
+              unsupported_matcher(matcher)
+            end
+
+            if matched && @remaining_path.empty?
+              block_result(yield(*captures))
+              throw :halt, response.finish
+            else
+              @remaining_path = path
+              false
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:_optimized_matching, OptimizedMatching)
+  end
+end

data/lib/roda/plugins/content_for.rb

@@ -62,8 +62,7 @@ class Roda
       end
 
       # Configure whether to append or overwrite if content_for
-      # is called multiple times to set data. Overwrite is default, use
-      # the :append option to append.
+      # is called multiple times with the same key.
       def self.configure(app, opts = OPTS)
         app.opts[:append_content_for] = opts.fetch(:append, true)
       end
@@ -76,8 +75,8 @@ class Roda
         def content_for(key, value=nil)
           append = opts[:append_content_for]
 
-          if block_given? || value
-            if block_given?
+          if defined?(yield) || value
+            if defined?(yield)
               outvar = render_opts[:template_opts][:outvar]
               buf_was = instance_variable_get(outvar)
 

data/lib/roda/plugins/content_security_policy.rb

@@ -278,7 +278,7 @@ class Roda
           Policy.new
         end
 
-        yield policy if block_given?
+        yield policy if defined?(yield)
         policy.freeze
       end
 
@@ -287,7 +287,7 @@ class Roda
         # current content security policy.
         def content_security_policy
           policy = @_response.content_security_policy
-          yield policy if block_given?
+          yield policy if defined?(yield)
           policy
         end
       end

data/lib/roda/plugins/mail_processor.rb

@@ -566,7 +566,7 @@ class Roda
             end
             false
           when Regexp
-            if md = content.match(val)
+            if md = val.match(content)
               @captures.concat(md.captures)
             end
           else

data/lib/roda/plugins/module_include.rb

@@ -72,7 +72,7 @@ class Roda
           end
 
           if mod
-            raise RodaError, "can't provide both argument and block to response_module" if block_given?
+            raise RodaError, "can't provide both argument and block to response_module" if defined?(yield)
             klass.send(:include, mod)
           else
             if instance_variable_defined?(iv)

data/lib/roda/plugins/multi_route.rb

@@ -3,15 +3,10 @@
 #
 class Roda
   module RodaPlugins
-    # The multi_route plugin allows for multiple named routes, which the
-    # main route block can dispatch to by name at any point by calling +route+.
-    # If the named route doesn't handle the request, execution will continue,
-    # and if the named route does handle the request, the response returned by
-    # the named route will be returned.
-    #
-    # In addition, this plugin adds the +r.multi_route+ method, which will check
-    # if the first segment in the path matches a named route, and dispatch
-    # to that named route.
+    # The multi_route plugin builds on the named_routes plugin and allows for
+    # dispatching to multiple named routes # by calling the +r.multi_route+ method,
+    # which will check # if the first segment in the path matches a named route,
+    # and dispatch to that named route.
     #
     # The hash_routes plugin offers a +r.hash_routes+ method that is similar to
     # and performs better than the +r.multi_route+ method, and it is recommended
@@ -35,23 +30,14 @@ class Roda
     #
     #   route do |r|
     #     r.multi_route
-    #
-    #     # or
-    #
-    #     r.on "foo" do
-    #       r.route 'foo'
-    #     end
-    #
-    #     r.on "bar" do
-    #       r.route 'bar'
-    #     end
     #   end
     #
-    # Note that in multi-threaded code, you should not attempt to add a
-    # named route after accepting requests.
+    # Note that only named routes with string names will be dispatched to by the
+    # +r.multi_route+ method. Named routes with other names can be dispatched to
+    # using the named_routes plugin API, but will not be automatically dispatched
+    # to by +r.multi_route+.
     #
-    # If you want to use the +r.multi_route+ method, use string names for the
-    # named routes.  Also, you can provide a block to +r.multi_route+ that is
+    # You can provide a block to +r.multi_route+ that is
     # called if the route matches but the named route did not handle the
     # request:
     #
@@ -62,20 +48,10 @@ class Roda
     # If a block is not provided to multi_route, the return value of the named
     # route block will be used.
     #
-    # == Routing Files
-    #
-    # The convention when using the multi_route plugin is to have a single
-    # named route per file, and these routing files should be stored in
-    # a routes subdirectory in your application.  So for the above example, you
-    # would use the following files:
-    #
-    #   routes/bar.rb
-    #   routes/foo.rb
-    #
     # == Namespace Support
     #
     # The multi_route plugin also has support for namespaces, allowing you to
-    # use r.multi_route at multiple levels in your routing tree.  Example:
+    # use +r.multi_route+ at multiple levels in your routing tree.  Example:
     #
     #   route('foo') do |r|
     #     r.multi_route('foo')
@@ -103,81 +79,38 @@ class Roda
     #
     #   route do |r|
     #     r.multi_route
-    #
-    #     # or
-    #
-    #     r.on "foo" do
-    #       r.on("baz"){r.route("baz", "foo")}
-    #       r.on("quux"){r.route("quux", "foo")}
-    #     end
-    #
-    #     r.on "bar" do
-    #       r.on("baz"){r.route("baz", "bar")}
-    #       r.on("quux"){r.route("quux", "bar")}
-    #     end
     #   end
-    #
-    # === Routing Files
-    #
-    # The convention when using namespaces with the multi_route plugin is to
-    # store the routing files in subdirectories per namespace. So for the
-    # above example, you would have the following routing files:
-    #
-    #   routes/bar.rb
-    #   routes/bar/baz.rb
-    #   routes/bar/quux.rb
-    #   routes/foo.rb
-    #   routes/foo/baz.rb
-    #   routes/foo/quux.rb
     module MultiRoute
+      def self.load_dependencies(app)
+        app.plugin :named_routes
+      end
+
       # Initialize storage for the named routes.
       def self.configure(app)
-        app.opts[:namespaced_routes] ||= {}
         app::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
       end
 
       module ClassMethods
-        # Freeze the namespaced routes and setup the regexp matchers so that there can be no thread safety issues at runtime.
+        # Freeze the multi_route regexp matchers so that there can be no thread safety issues at runtime.
         def freeze
-          opts[:namespaced_routes].freeze.each do |k,v|
-            v.freeze
+          super
+          opts[:namespaced_routes].each_key do |k|
             self::RodaRequest.named_route_regexp(k)
           end
           self::RodaRequest.instance_variable_get(:@namespaced_route_regexps).freeze
-          super
         end
 
         # Copy the named routes into the subclass when inheriting.
         def inherited(subclass)
           super
-          nsr = subclass.opts[:namespaced_routes]
-          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
           subclass::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
         end
 
-        # 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}"
-          end
-          routes.keys
-        end
-
-        # Return the named route with the given name.
-        def named_route(name, namespace=nil)
-          opts[:namespaced_routes][namespace][name]
-        end
-
-        # If the given route has a name, treat it as a named route and
-        # store the route block.  Otherwise, this is the main route, so
-        # call super.
+        # Clear the multi_route regexp matcher for the namespace.
         def route(name=nil, namespace=nil, &block)
+          super
           if name
-            routes = opts[:namespaced_routes][namespace] ||= {}
-            routes[name] = define_roda_method(routes[name] || "multi_route_#{namespace}_#{name}", 1, &convert_route_block(block))
             self::RodaRequest.clear_named_route_regexp!(namespace)
-          else
-            super(&block)
           end
         end
       end
@@ -206,19 +139,14 @@ class Roda
         # is given, yield to the block.
         def multi_route(namespace=nil)
           on self.class.named_route_regexp(namespace) do |section|
-            r = route(section, namespace)
-            if block_given?
+            res = route(section, namespace)
+            if defined?(yield)
               yield
             else
-              r
+              res
             end
           end
         end
-
-        # Dispatch to the named route with the given name.
-        def route(name, namespace=nil)
-          scope.send(roda_class.named_route(name, namespace), self)
-        end
       end
     end
 

data/lib/roda/plugins/multi_run.rb

@@ -91,7 +91,7 @@ class Roda
         # dispatch the request to the stored rack application.
         def multi_run
           on self.class.multi_run_regexp do |prefix|
-            yield prefix if block_given?
+            yield prefix if defined?(yield)
             run scope.class.multi_run_apps[prefix]
           end
         end

data/lib/roda/plugins/named_routes.rb

@@ -0,0 +1,160 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The named_routes plugin allows for multiple named routes, which the
+    # main route block can dispatch to by name at any point by calling +r.route+.
+    # If the named route doesn't handle the request, execution will continue,
+    # and if the named route does handle the request, the response returned by
+    # the named route will be returned.
+    #
+    # Example:
+    #
+    #   plugin :multi_route
+    #
+    #   route('foo') do |r|
+    #     r.is 'bar' do
+    #       '/foo/bar'
+    #     end
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.is 'foo' do
+    #       '/bar/foo'
+    #     end
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       r.route 'foo'
+    #     end
+    #
+    #     r.on "bar" do
+    #       r.route 'bar'
+    #     end
+    #   end
+    #
+    # Note that in multi-threaded code, you should not attempt to add a
+    # named route after accepting requests.
+    #
+    # == Routing Files
+    #
+    # The convention when using the named_routes plugin is to have a single
+    # named route per file, and these routing files should be stored in
+    # a routes subdirectory in your application.  So for the above example, you
+    # would use the following files:
+    #
+    #   routes/bar.rb
+    #   routes/foo.rb
+    #
+    # == Namespace Support
+    #
+    # The named_routes plugin also has support for namespaces, allowing you to
+    # use +r.route+ at multiple levels in your routing tree.  Example:
+    #
+    #   route('foo') do |r|
+    #     r.on("baz"){r.route("baz", "foo")}
+    #     r.on("quux"){r.route("quux", "foo")}
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.on("baz"){r.route("baz", "bar")}
+    #     r.on("quux"){r.route("quux", "bar")}
+    #   end
+    #
+    #   route('baz', 'foo') do |r|
+    #     # handles /foo/baz prefix
+    #   end
+    #
+    #   route('quux', 'foo') do |r|
+    #     # handles /foo/quux prefix
+    #   end
+    #
+    #   route('baz', 'bar') do |r|
+    #     # handles /bar/baz prefix
+    #   end
+    #
+    #   route('quux', 'bar') do |r|
+    #     # handles /bar/quux prefix
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       r.route("foo")
+    #     end
+    #
+    #     r.on "bar" do
+    #       r.route("bar")
+    #     end
+    #   end
+    #
+    # === Routing Files
+    #
+    # The convention when using namespaces with the multi_route plugin is to
+    # store the routing files in subdirectories per namespace. So for the
+    # above example, you would have the following routing files:
+    #
+    #   routes/bar.rb
+    #   routes/bar/baz.rb
+    #   routes/bar/quux.rb
+    #   routes/foo.rb
+    #   routes/foo/baz.rb
+    #   routes/foo/quux.rb
+    module NamedRoutes
+      # Initialize storage for the named routes.
+      def self.configure(app)
+        app.opts[:namespaced_routes] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:namespaced_routes].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Copy the named routes into the subclass when inheriting.
+        def inherited(subclass)
+          super
+          nsr = subclass.opts[:namespaced_routes]
+          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
+        end
+
+        # 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}"
+          end
+          routes.keys
+        end
+
+        # Return the named route with the given name.
+        def named_route(name, namespace=nil)
+          opts[:namespaced_routes][namespace][name]
+        end
+
+        # If the given route has a name, treat it as a named route and
+        # store the route block.  Otherwise, this is the main route, so
+        # call super.
+        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))
+          else
+            super(&block)
+          end
+        end
+      end
+
+      module RequestMethods
+        # Dispatch to the named route with the given name.
+        def route(name, namespace=nil)
+          scope.send(roda_class.named_route(name, namespace), self)
+        end
+      end
+    end
+
+    register_plugin(:named_routes, NamedRoutes)
+  end
+end

data/lib/roda/plugins/run_handler.rb

@@ -34,7 +34,7 @@ class Roda
         # routing normally.
         def run(app, opts=OPTS)
           res = catch(:halt){super(app)}
-          yield res if block_given?
+          yield res if defined?(yield)
           throw(:halt, res) unless opts[:not_found] == :pass && res[0] == 404
         end
       end

data/lib/roda/plugins/shared_vars.rb

@@ -61,7 +61,7 @@ class Roda
         def shared(vars=nil)
           h = env['roda.shared'] ||= {}
 
-          if block_given?
+          if defined?(yield)
             if vars
               begin
                 env['roda.shared'] = h.merge(vars)

data/lib/roda/plugins/sinatra_helpers.rb

@@ -384,7 +384,7 @@ class Roda
 
         # Set or retrieve the response body. When a block is given,
         # evaluation is deferred until the body is needed.
-        def body(value = (return @body unless block_given?; nil), &block)
+        def body(value = (return @body unless defined?(yield); nil), &block)
           if block
             @body = DelayedBody.new(&block)
           else

data/lib/roda/plugins/type_routing.rb

@@ -184,7 +184,7 @@ class Roda
           path = super
 
           if opts[:use_extension]
-            if m = path.match(opts[:extension_regexp])
+            if m = opts[:extension_regexp].match(path)
               @type_routing_extension =  @requested_type = m[2].to_sym
               path = m[1]
             end

data/lib/roda/plugins/typecast_params.rb

@@ -564,7 +564,7 @@ class Roda
           end
 
           v = @obj[key]
-          v = yield if v.nil? && block_given?
+          v = yield if v.nil? && defined?(yield)
 
           begin
             sub = self.class.nest(v, Array(@nesting) + [key])
@@ -580,7 +580,7 @@ class Roda
         # Return the nested value for key. If there is no nested_value for +key+,
         # calls the block to return the value, or returns nil if there is no block given.
         def fetch(key)
-          send(:[], key){return(yield if block_given?)}
+          send(:[], key){return(yield if defined?(yield))}
         end
 
         # Captures conversions inside the given block, and returns a hash of all conversions,

data/lib/roda/request.rb

@@ -24,7 +24,7 @@ class Roda
 
         # Return the cached pattern for the given object.  If the object is
         # not already cached, yield to get the basic pattern, and convert the
-        # basic pattern to a pattern that does not partial segments.
+        # basic pattern to a pattern that does not match partial segments.
         def cached_matcher(obj)
           cache = @match_pattern_cache
 
@@ -234,9 +234,7 @@ class Roda
 
         # An alias of remaining_path. If a plugin changes remaining_path then
         # it should override this method to return the untouched original.
-        def real_remaining_path
-          remaining_path
-        end
+        alias real_remaining_path remaining_path
 
         # Match POST requests.  If no arguments are provided, matches all POST
         # requests, otherwise, matches only POST requests where the arguments
@@ -336,7 +334,7 @@ class Roda
         # Use <tt>r.get true</tt> to handle +GET+ requests where the current
         # path is empty.
         def root(&block)
-          if remaining_path == "/" && is_get?
+          if @remaining_path == "/" && is_get?
             always(&block)
           end
         end
@@ -519,10 +517,10 @@ class Roda
         # SCRIPT_NAME to include the matched path, removes the matched
         # path from PATH_INFO, and updates captures with any regex captures.
         def consume(pattern)
-          if matchdata = remaining_path.match(pattern)
+          if matchdata = pattern.match(@remaining_path)
             @remaining_path = matchdata.post_match
             captures = matchdata.captures
-            captures = yield(*captures) if block_given?
+            captures = yield(*captures) if defined?(yield)
             @captures.concat(captures)
           end
         end
@@ -548,7 +546,7 @@ class Roda
 
         # Whether the current path is considered empty.
         def empty_path?
-          remaining_path.empty?
+          @remaining_path.empty?
         end
 
         # If all of the arguments match, yields to the match block and

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

data/lib/roda.rb

@@ -212,6 +212,10 @@ class Roda
             if @middleware.empty? && use_new_dispatch_api?
               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}
+              plugin :_optimized_matching
+            end
           end
 
           build_rack_app

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.45.0
+  version: 3.49.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-14 00:00:00.000000000 Z
+date: 2021-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -216,6 +216,10 @@ extra_rdoc_files:
 - doc/release_notes/3.43.0.txt
 - doc/release_notes/3.44.0.txt
 - doc/release_notes/3.45.0.txt
+- doc/release_notes/3.46.0.txt
+- doc/release_notes/3.47.0.txt
+- 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.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -268,6 +272,10 @@ files:
 - doc/release_notes/3.43.0.txt
 - doc/release_notes/3.44.0.txt
 - doc/release_notes/3.45.0.txt
+- doc/release_notes/3.46.0.txt
+- doc/release_notes/3.47.0.txt
+- 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.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -278,6 +286,7 @@ files:
 - lib/roda/plugins.rb
 - lib/roda/plugins/_after_hook.rb
 - lib/roda/plugins/_before_hook.rb
+- lib/roda/plugins/_optimized_matching.rb
 - lib/roda/plugins/_symbol_regexp_matchers.rb
 - lib/roda/plugins/all_verbs.rb
 - lib/roda/plugins/assets.rb
@@ -334,6 +343,7 @@ files:
 - lib/roda/plugins/multi_run.rb
 - lib/roda/plugins/multi_view.rb
 - lib/roda/plugins/multibyte_string_matcher.rb
+- lib/roda/plugins/named_routes.rb
 - lib/roda/plugins/named_templates.rb
 - lib/roda/plugins/not_allowed.rb
 - lib/roda/plugins/not_found.rb
@@ -409,7 +419,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Routing tree web toolkit