roda 3.61.0 → 3.62.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 337e7cc074ffe0c300a4dbf9a14f72552caa5b9446fdf0ca04b9f22d9117c9c7
-  data.tar.gz: 53a8b4ec124df8ef0efdc7efcc7bec3e0e7ea7d13fa60fb5d6adf06f50ed081e
+  metadata.gz: 912f354ffcb4440bf7955d4db8546f9eccbee3f3a3f91b77604a91228a2433c4
+  data.tar.gz: 8df8254014b7e8e9b6db623fa2b8269ac5485b5087ee53978080a81ba344a60c
 SHA512:
-  metadata.gz: 78671d90145cf431a7deff333e6b75ad681252cae159b5ff09dfaba70d4b3fc17ec1f7362c52454c3f8e94e2343bd4b4d419a5c23738a6b525e9fdd79dc8846c
-  data.tar.gz: 55b5bc0be878d58d66e0834110b47313f522e1f109b95c23348b2cb09430b01383595197db8f8db6587f10d3d9e4a7a353a2d70fb1ed4a099573309a5aabcae6
+  metadata.gz: bb43bcbad6e5421935d62a11abc3da27c40559ef1f55b9791d71ab22bd8cc4a73933f85bb68d77feb26efd6bf84f840bd5a202c80938ede330ca67cf9b51ca8b
+  data.tar.gz: 6f3234b37c506e3037864e7a7b79280f5b190758e8dada8f213b141cd1e4826a03a98017ddccb806082fa551580af9683088c94080157811867c0a3a1ec92b04

data/CHANGELOG

@@ -1,3 +1,13 @@
+= 3.62.0 (2022-11-14)
+
+* Add typecast_params_sized_integers plugin for converting parameters to sized integers (jeremyevans)
+
+* Add Integer_matcher_max plugin for setting maximum integer value matched by the Integer matcher (jeremyevans)
+
+* Allow class matchers in the class_matchers plugin to skip matching based on regexp match values (jeremyevans)
+
+* Fix RodaRequest#matched_path when using unescape_path plugin (jeremyevans) (#286)
+
 = 3.61.0 (2022-10-12)
 
 * Make Integer matcher limit integer segments to 100 characters by default (jeremyevans)

data/doc/release_notes/3.62.0.txt

@@ -0,0 +1,41 @@
+= New Features
+
+* An Integer_matcher_max plugin has been added for setting the
+  maximum value matched by the Integer matcher (the minimum is
+  always 0, since the Integer matcher does not match negative
+  integers).  The default maximum value when using the plugin
+  is 2**63-1, the maximum value for a signed 64-bit integer.
+  You can specify a different maximum value by passing an argument
+  when loading the plugin.
+
+* A typecast_params_sized_integers plugin has been added for
+  converting parameters to integers only if the integer is within a
+  specific size.  By default, the plugin supports 8-bit, 16-bit,
+  32-bit, and 64-bit signed and unsigned integer types, with the
+  following typecast_params methods added by the plugin:
+
+    * int8, uint8, pos_int8, pos_uint8, Integer8, Integeru8
+    * int16, uint16, pos_int16, pos_uint16, Integer16, Integeru16
+    * int32, uint32, pos_int32, pos_uint32, Integer32, Integeru32
+    * int64, uint64, pos_int64, pos_uint64, Integer64, Integeru64
+
+  You can override what sizes are added by default by using the
+  :sizes option.  You can also specify a :default_size option,
+  in which case the default int, pos_int, and Integer conversions
+  will use the given size.  So if you want to change the default
+  typecast_params integer conversion behavior to only support
+  integer values that can fit in 64-bit signed integers, you can
+  use:
+
+    plugin :typecast_params_sized_integers, sizes: [64],
+      default_size: 64
+
+= Other Improvements
+
+* The block passed to the class_matcher method in the class_matchers
+  plugin can now return nil/false to signal that it should not match.
+  This is useful when the regexp argument provided matches segments
+  not valid for the class.
+
+* RodaRequest#matched_path now works correctly when using the
+  unescape_path plugin.

data/lib/roda/plugins/Integer_matcher_max.rb

@@ -0,0 +1,54 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The Integer_matcher_max plugin sets the maximum integer value
+    # value that the Integer class matcher will match by default.
+    # By default, loading this plugin sets the maximum value to
+    # 2**63-1, the largest signed 64-bit integer value:
+    #
+    #   plugin :Integer_matcher_max
+    #   route do |r|
+    #     r.is Integer do
+    #       # Matches /9223372036854775807
+    #       # Does not match /9223372036854775808
+    #     end
+    #   end
+    #
+    # To specify a different maximum value, you can pass a different
+    # maximum value when loading the plugin:
+    # 
+    #   plugin :Integer_matcher_max, 2**64-1
+    module IntegerMatcherMax
+      def self.configure(app, max=nil)
+        if max
+          app::RodaRequest.class_eval do
+            define_method(:_match_class_max_Integer){max}
+            alias_method :_match_class_max_Integer, :_match_class_max_Integer
+            private :_match_class_max_Integer
+          end
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Do not have the Integer matcher max when over the maximum
+        # configured Integer value.
+        def _match_class_convert_Integer(value)
+          value = super
+          value if value <= _match_class_max_Integer
+        end
+
+        # Use 2**63-1 as the default maximum value for the Integer
+        # matcher.
+        def _match_class_max_Integer
+          9223372036854775807
+        end
+      end
+    end
+
+    register_plugin(:Integer_matcher_max, IntegerMatcherMax)
+  end
+end

data/lib/roda/plugins/_optimized_matching.rb

@@ -52,9 +52,9 @@ class Roda
                   end
                 end
               elsif matcher == Integer
-                if matchdata = /\A\/(\d{1,100})(?=\/|\z)/.match(@remaining_path)
+                if (matchdata = /\A\/(\d{1,100})(?=\/|\z)/.match(@remaining_path)) && (value = _match_class_convert_Integer(matchdata[1]))
                   @remaining_path = matchdata.post_match
-                  always{yield(matchdata[1].to_i)}
+                  always{yield(value)}
                 end
               else
                 path = @remaining_path
@@ -151,9 +151,9 @@ class Roda
                 always{yield rp[1, len]}
               end
             elsif matcher == Integer
-              if matchdata = /\A\/(\d{1,100})\z/.match(@remaining_path)
+              if (matchdata = /\A\/(\d{1,100})\z/.match(@remaining_path)) && (value = _match_class_convert_Integer(matchdata[1]))
                 @remaining_path = ''
-                always{yield(matchdata[1].to_i)}
+                always{yield(value)}
               end
             else
               path = @remaining_path

data/lib/roda/plugins/class_matchers.rb

@@ -28,6 +28,18 @@ class Roda
     # This is useful to DRY up code if you are using the same type of pattern and
     # type conversion in multiple places in your application.
     #
+    # If you have a segment match the passed regexp, but decide during block
+    # processing that you do not want to treat it as a match, you can have the
+    # block return nil or false.  This is useful if you want to make sure you
+    # are using valid data:
+    #
+    #   class_matcher(Date, /(\dd\d)-(\d\d)-(\d\d)/) do |y, m, d|
+    #     y = y.to_i
+    #     m = m.to_i
+    #     d = d.to_i
+    #     [Date.new(y, m, d)] if Date.valid_date?(y, m, d)
+    #   end
+    #
     # 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

data/lib/roda/plugins/halt.rb

@@ -56,7 +56,7 @@ class Roda
     #     r.halt(:template) if r.params['a']
     #
     #     # symbol_views plugin, specifying status code, headers, and template file to render as body
-    #     r.halt(500, 'header=>'value', :other_template) if r.params['c']
+    #     r.halt(500, {'header'=>'value'}, :other_template) if r.params['c']
     #
     #     # json plugin, specifying status code and JSON body
     #     r.halt(500, [{'error'=>'foo'}]) if r.params['b']

data/lib/roda/plugins/typecast_params.rb

@@ -526,9 +526,10 @@ class Roda
         handle_type(:int, :max_input_bytesize=>100) do |v|
           string_or_numeric!(v) && v.to_i
         end
+        alias base_convert_int convert_int
 
         handle_type(:pos_int, :max_input_bytesize=>100) do |v|
-          if (v = convert_int(v)) && v > 0
+          if (v = base_convert_int(v)) && v > 0
             v
           end
         end
@@ -547,6 +548,7 @@ class Roda
             end
           end
         end
+        alias base_convert_Integer convert_Integer
 
         handle_type(:float, :max_input_bytesize=>1000) do |v|
           string_or_numeric!(v) && v.to_f

data/lib/roda/plugins/typecast_params_sized_integers.rb

@@ -0,0 +1,107 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The typecast_params_sized_integers plugin adds sized integer conversion
+    # methods to typecast_params:
+    #
+    # * int8, uint8, pos_int8, pos_uint8, Integer8, Integeru8
+    # * int16, uint16, pos_int16, pos_uint16, Integer16, Integeru16
+    # * int32, uint32, pos_int32, pos_uint32, Integer32, Integeru32
+    # * int64, uint64, pos_int64, pos_uint64, Integer64, Integeru64
+    #
+    # The int*, pos_int*, and Integer* methods operate the same as the
+    # standard int, pos_int, and Integer methods in typecast_params,
+    # except that they will only handle parameter values in the given
+    # range for the signed integer type.  The uint*, pos_int*, and
+    # Integeru* methods are similar to the int*, pos_int*, and
+    # Integer* methods, except they use the range of the unsigned
+    # integer type instead of the range of the signed integer type.
+    #
+    # Here are the signed and unsigned integer type ranges:
+    # 8 :: [-128, 127], [0, 255]
+    # 16 :: [-32768, 32767], [0, 65535]
+    # 32 :: [-2147483648, 2147483647], [0, 4294967295]
+    # 64 :: [-9223372036854775808, 9223372036854775807], [0, 18446744073709551615]
+    #
+    # To only create methods for certain integer sizes, you can pass a
+    # :sizes option when loading the plugin, and it will only create
+    # methods for the sizes you specify.
+    #
+    # You can provide a :default_size option when loading the plugin,
+    # in which case the int, uint, pos_int, pos_uint, Integer, and Integeru,
+    # typecast_params conversion methods will be aliases to the conversion
+    # methods for the given sized type:
+    #
+    #  plugin :typecast_params_sized_integers, default_size: 64
+    #
+    #  route do |r|
+    #    # Returns nil unless param.to_i > 0 && param.to_i <= 9223372036854775807
+    #    typecast_params.pos_int('param_name')
+    #  end
+    module TypecastParamsSizedIntegers
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :typecast_params do
+          (opts[:sizes] || [8, 16, 32, 64]).each do |i|
+            # Avoid defining the same methods more than once
+            next if method_defined?(:"pos_int#{i}")
+
+            min_signed = -(2**(i-1))
+            max_signed = 2**(i-1)-1
+            max_unsigned = 2**i-1
+
+            handle_type(:"int#{i}", :max_input_bytesize=>100) do |v|
+              if (v = base_convert_int(v)) && v >= min_signed && v <= max_signed
+                v
+              end
+            end
+
+            handle_type(:"uint#{i}", :max_input_bytesize=>100) do |v|
+              if (v = base_convert_int(v)) && v >= 0 && v <= max_unsigned
+                v
+              end
+            end
+
+            handle_type(:"pos_int#{i}", :max_input_bytesize=>100) do |v|
+              if (v = base_convert_int(v)) && v > 0 && v <= max_signed
+                v
+              end
+            end
+
+            handle_type(:"pos_uint#{i}", :max_input_bytesize=>100) do |v|
+              if (v = base_convert_int(v)) && v > 0 && v <= max_unsigned
+                v
+              end
+            end
+
+            handle_type(:"Integer#{i}", :max_input_bytesize=>100) do |v|
+              if (v = base_convert_Integer(v)) && v >= min_signed && v <= max_signed
+                v
+              end
+            end
+
+            handle_type(:"Integeru#{i}", :max_input_bytesize=>100) do |v|
+              if (v = base_convert_Integer(v)) && v >= 0 && v <= max_unsigned
+                v
+              end
+            end
+          end
+        end
+
+        if default = opts[:default_size]
+          app::TypecastParams.class_eval do
+            %w[int uint pos_int pos_uint Integer Integeru].each do |type|
+              ['', 'convert_', '_convert_array_', '_max_input_bytesize_for_'].each do |prefix|
+                alias_method :"#{prefix}#{type}", :"#{prefix}#{type}#{default}"
+              end
+              alias_method :"#{type}!", :"#{type}#{default}!"
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:typecast_params_sized_integers, TypecastParamsSizedIntegers)
+  end
+end

data/lib/roda/plugins/unescape_path.rb

@@ -20,6 +20,13 @@ class Roda
     #   end
     module UnescapePath
       module RequestMethods
+        # Make sure the matched path calculation handles the unescaping
+        # of the remaining path.
+        def matched_path
+          e = @env
+          Rack::Utils.unescape(e["SCRIPT_NAME"] + e["PATH_INFO"]).chomp(@remaining_path)
+        end
+
         private
 
         # Unescape the path.

data/lib/roda/request.rb

@@ -443,7 +443,16 @@ 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)/){|i| [i.to_i]}
+          consume(/\A\/(\d{1,100})(?=\/|\z)/) do |i|
+            if i = _match_class_convert_Integer(i)
+              [i]
+            end
+          end
+        end
+
+        # Convert the segment matched by the Integer matcher to an integer.
+        def _match_class_convert_Integer(value)
+          value.to_i
         end
 
         # Match only if all of the arguments in the given array match.
@@ -548,9 +557,11 @@ class Roda
         # path from PATH_INFO, and updates captures with any regex captures.
         def consume(pattern)
           if matchdata = pattern.match(@remaining_path)
-            @remaining_path = matchdata.post_match
             captures = matchdata.captures
-            captures = yield(*captures) if defined?(yield)
+            if defined?(yield)
+              return unless captures = yield(*captures)
+            end
+            @remaining_path = matchdata.post_match
             @captures.concat(captures)
           end
         end

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.61.0
+  version: 3.62.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-12 00:00:00.000000000 Z
+date: 2022-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -234,6 +234,7 @@ extra_rdoc_files:
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.60.0.txt
 - doc/release_notes/3.61.0.txt
+- doc/release_notes/3.62.0.txt
 - doc/release_notes/3.7.0.txt
 - doc/release_notes/3.8.0.txt
 - doc/release_notes/3.9.0.txt
@@ -302,12 +303,14 @@ files:
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.60.0.txt
 - doc/release_notes/3.61.0.txt
+- doc/release_notes/3.62.0.txt
 - doc/release_notes/3.7.0.txt
 - doc/release_notes/3.8.0.txt
 - doc/release_notes/3.9.0.txt
 - lib/roda.rb
 - lib/roda/cache.rb
 - lib/roda/plugins.rb
+- lib/roda/plugins/Integer_matcher_max.rb
 - lib/roda/plugins/_after_hook.rb
 - lib/roda/plugins/_before_hook.rb
 - lib/roda/plugins/_optimized_matching.rb
@@ -423,6 +426,7 @@ files:
 - lib/roda/plugins/timestamp_public.rb
 - lib/roda/plugins/type_routing.rb
 - lib/roda/plugins/typecast_params.rb
+- lib/roda/plugins/typecast_params_sized_integers.rb
 - lib/roda/plugins/unescape_path.rb
 - lib/roda/plugins/view_options.rb
 - lib/roda/request.rb