roda 3.104.0 → 3.105.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ea3b3c7c8ffcfffa22412e123d09e718e876c13bdfcddbfae461daa813d81bd
-  data.tar.gz: 275d90d97fa2893654e368316c1233092ae5fcd60ac7e76ac026a45d2200582b
+  metadata.gz: 4f6f16557b167cdca71f0005ed7b4e40c4465b6400874e05a8ece95e7dad7b68
+  data.tar.gz: decd44332e836e46bc4bb2a6f93e7d40730fbf9f016c83b8a6ae99169c74efd3
 SHA512:
-  metadata.gz: 546ee3b7cb9d6c8eac9eb6bbc40272a1a5760f522bbe94b38bb78afa3f552a61dd23496d2dfcf4e65fe490b1cad67b229fed4c31ac22b9d25409e501f6bb5c82
-  data.tar.gz: f9e94f7612706155c60db6f9a14bb9b130386875f1c86e6a65bc29bf9fdb789719c08f5398f58708ac862ab8b3ec41fb34f11b21d7454878be4364fceb50ce91
+  metadata.gz: 768134a23ee25d9f9d41641b1bf3dd5d499624b05adf9261f90300407a5dcd55d1535f080547d573b11e19d161c4563eb8538d998ee627d11329e6b59223db88
+  data.tar.gz: 00aa1dfbbc81b5754a824fa668324886338f4a4827d27a2de6cfff5b6318c8e4aba1c8c93afb8e96f80b214b4ba6b96917b3df77108f1eaa60153fa5fc5add5e

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

data/lib/roda.rb

@@ -217,7 +217,7 @@ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.104.0
+  version: 3.105.0
 platform: ruby
 authors:
 - Jeremy Evans