roda 3.92.0 → 3.93.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e0c8b5dc16e1652a1bbe309c046b681c8f11a90a31c2b2bd8368baa1b85f43
-  data.tar.gz: b81857ea9bc5ac7667f19fb730982d7b1259e95e1ff1b049d0c619fddf08a1be
+  metadata.gz: d1e04d3df576ad873687f27895cf5100f34a6142ee2204d4e74372d8da03ffe0
+  data.tar.gz: 6b4f577746d682fc763c765d6d9f787a251db3c392072d1fa123fe5bddab7e20
 SHA512:
-  metadata.gz: ca7712b09048602d91378cdb22ecf30e2d03cf43a215ad52d6aa697151abd88fe4873f4e162b617782f89b434f733d0230f7a3b8bacf252880450dc65308e4ac
-  data.tar.gz: 625b03ba51df7bc895b69e09a739584ae5ff6c15f7701e98a5e55fec301ed0e97353f503565811ae335534c1e6e0634916246fae99493851e472148c5c666789
+  metadata.gz: 845525a607910671a61b61645ecfa7243ab8565963169aff78e7908cd5a982c8cbd5f8420e9e53e6689488be5fa57bfba9fc7da714d5e892f79f205c0a895ccf
+  data.tar.gz: 37fe2d01f609363e382b0fffe45b2dc13c5c04d0467890db334417a44d42b8a906a3d95f0ec68e465b17b0c8c54667cd7ef93fe866e0ef48d0afdbf5916c5aaa

data/lib/roda/plugins/assets.rb

@@ -871,11 +871,11 @@ class Roda
         def unnest_assets_hash(h)
           case h
           when Hash
-            h.map do |k,v|
+            h.flat_map do |k,v|
               assets = unnest_assets_hash(v)
               assets = assets.map{|x| "#{k}/#{x}"} if roda_class.assets_opts[:group_subdirs]
               assets
-            end.flatten(1)
+            end
           else
             Array(h)
           end

data/lib/roda/plugins/assets_preloading.rb

@@ -73,13 +73,13 @@ class Roda
         # Return an array of paths/as pairs for the given asset
         # types and/or groups.
         def _preload_assets_array(assets)
-          assets.map do |type|
+          assets.flat_map do |type|
             paths = assets_paths(type)
             type = type[0] if type.is_a?(Array)
             as = TYPE_AS[type]
 
             paths.map{|path| [path, as]}
-          end.flatten(1)
+          end
         end
       end
     end

data/lib/roda/plugins/content_security_policy.rb

@@ -135,7 +135,7 @@ class Roda
         style-src
         worker-src
         '.split.each(&:freeze).each do |setting|
-          meth = setting.gsub('-', '_').freeze
+          meth = setting.tr('-', '_').freeze
 
           # Setting method name sets the setting value, or removes it if no args are given.
           define_method(meth) do |*args|
@@ -165,7 +165,7 @@ class Roda
         end
 
         %w'block-all-mixed-content upgrade-insecure-requests'.each(&:freeze).each do |setting|
-          meth = setting.gsub('-', '_').freeze
+          meth = setting.tr('-', '_').freeze
 
           # Setting method name turns on setting if true or no argument given,
           # or removes setting if false is given.
@@ -258,7 +258,7 @@ class Roda
               raise RodaError, "unsupported CSP value used: #{v.inspect}"
             end
           when Symbol
-            s << " '" << v.to_s.gsub('_', '-') << "'"
+            s << " '" << v.to_s.tr('_', '-') << "'"
           else
             raise RodaError, "unsupported CSP value used: #{v.inspect}"
           end

data/lib/roda/plugins/mail_processor.rb

@@ -467,7 +467,10 @@ class Roda
             end
           END
 
-          next if [:rcpt, :text, :body, :subject].include?(field)
+          case field
+          when :rcpt, :text, :body, :subject
+            next
+          end
 
           class_eval(<<-END, __FILE__, __LINE__+1)
             private

data/lib/roda/plugins/permissions_policy.rb

@@ -138,7 +138,7 @@ class Roda
       # Represents a permissions policy.
       class Policy
         SUPPORTED_SETTINGS.each do |setting|
-          meth = setting.gsub('-', '_').freeze
+          meth = setting.tr('-', '_').freeze
 
           # Setting method name sets the setting value, or removes it if no args are given.
           define_method(meth) do |*args|
@@ -284,7 +284,7 @@ class Roda
 
         if default = opts[:default]
           SUPPORTED_SETTINGS.each do |setting|
-            policy.send(setting.gsub('-', '_'), *default)
+            policy.send(setting.tr('-', '_'), *default)
           end
         end
 

data/lib/roda/plugins/render_coverage.rb

@@ -56,7 +56,7 @@ class Roda
           compiled_path = nil
           (self.opts[:render_coverage_strip_paths] || render_opts[:allowed_paths]).each do |dir|
             if path.start_with?(dir + '/')
-              compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].gsub('/', '-'))
+              compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].tr('/', '-'))
               break
             end
           end

data/lib/roda/plugins/route_csrf.rb

@@ -186,7 +186,7 @@ class Roda
           options[:csrf_failure] = :csrf_failure_method
           app.define_roda_method(:_roda_route_csrf_failure, 1, &app.send(:convert_route_block, block))
         end
-        options[:env_header] = "HTTP_#{options[:header].to_s.gsub('-', '_').upcase}".freeze
+        options[:env_header] = "HTTP_#{options[:header].to_s.tr('-', '_').upcase}".freeze
         options.freeze
       end
 

data/lib/roda/plugins/strip_path_prefix.rb

@@ -16,7 +16,7 @@ class Roda
     module StripPathPrefix
       # Set the regexp to use when stripping prefixes from internal paths.
       def self.configure(app, prefix=Dir.pwd)
-        prefix += '/' unless prefix=~ /\/\z/
+        prefix += '/' unless prefix.end_with?("/")
         app.opts[:strip_path_prefix] = /\A#{Regexp.escape(prefix)}/
       end
 

data/lib/roda/plugins/typecast_params.rb

@@ -244,17 +244,24 @@ class Roda
     # when loading the typecast_params plugin.  This block is executed in the context of the
     # subclass, and calling +handle_type+ in the block can be used to add conversion methods.
     # +handle_type+ accepts a type name, an options hash, and the block used to convert the type.
-    # The only currently supported option is +:max_input_bytesize+, specifying the maximum bytesize of
-    # string input.  You can also override the max input bytesize of an existing type using the
-    # +max_input_bytesize+ method.
+    # Supported options are:
+    # +:invalid_value_message+ :: The message to use for type conversions that result in a nil value
+    #                             (a space and the parameter name is appended to this).
+    # +:max_input_bytesize+ :: The maximum bytesize of string input.
+    # 
+    # You can override the invalid value message of an existing type using the
+    # +invalid_value_message+ method.  You can also override the max input bytesize of an existing
+    # type using the +max_input_bytesize+ method.
     #
     #   plugin :typecast_params do
-    #     handle_type(:album, max_input_bytesize: 100) do |value|
+    #     handle_type(:album, max_input_bytesize: 100,
+    #                 invalid_value_message: "invalid album id in parameter") do |value|
     #       if id = convert_pos_int(val)
     #         Album[id]
     #       end
     #     end
     #     max_input_bytesize(:date, 256)
+    #     invalid_value_message(:pos_int, "value must be greater than 0 for parameter")
     #   end
     #
     # By default, the typecast_params conversion procs are passed the parameter value directly
@@ -441,6 +448,8 @@ class Roda
         # * foo!(key)
         # * convert_foo(value) # private
         # * _convert_array_foo(value) # private
+        # * _invalid_value_message_for_foo # private
+        # * _max_input_bytesize_for_foo # private
         #
         # This method is used to define all type conversions, even the built
         # in ones.  It can be called in subclasses to setup subclass-specific
@@ -449,25 +458,23 @@ class Roda
           convert_meth = :"convert_#{type}"
           define_method(convert_meth, &block)
 
-          max_input_bytesize = opts[:max_input_bytesize]
-          max_input_bytesize_meth = :"_max_input_bytesize_for_#{type}"
-          define_method(max_input_bytesize_meth){max_input_bytesize}
-
           convert_array_meth = :"_convert_array_#{type}"
           define_method(convert_array_meth) do |v|
             raise Error, "expected array but received #{v.inspect}" unless v.is_a?(Array)
             v.map! do |val|
-              check_allowed_bytesize(val, send(max_input_bytesize_meth))
+              check_allowed_bytesize(val, _max_input_bytesize_for(type))
               check_null_byte(val)
               send(convert_meth, val)
             end
           end
 
-          private convert_meth, convert_array_meth, max_input_bytesize_meth
-          alias_method max_input_bytesize_meth, max_input_bytesize_meth
+          private convert_meth, convert_array_meth
+
+          invalid_value_message(type, opts[:invalid_value_message])
+          max_input_bytesize(type, opts[:max_input_bytesize])
 
           define_method(type) do |key, default=nil|
-            process_arg(convert_meth, key, default, send(max_input_bytesize_meth)) if require_hash!
+            process_arg(convert_meth, key, default, type) if require_hash!
           end
 
           define_method(:"#{type}!") do |key|
@@ -475,8 +482,15 @@ class Roda
           end
         end
 
-        # Override the maximum input bytesize for the given type. This is mostly useful
-        # for overriding the sizes for the default input types.
+        # Set the invalid message for the given type.
+        def self.invalid_value_message(type, message)
+          invalid_value_message_meth = :"_invalid_value_message_for_#{type}"
+          define_method(invalid_value_message_meth){message}
+          private invalid_value_message_meth
+          alias_method invalid_value_message_meth, invalid_value_message_meth
+        end
+
+        # Set the maximum input bytesize for the given type.
         def self.max_input_bytesize(type, bytesize)
           max_input_bytesize_meth = :"_max_input_bytesize_for_#{type}"
           define_method(max_input_bytesize_meth){bytesize}
@@ -504,13 +518,13 @@ class Roda
           v
         end
 
-        handle_type(:nonempty_str) do |v|
+        handle_type(:nonempty_str, :invalid_value_message=>"empty string provided for parameter") do |v|
           if (v = convert_str(v)) && !v.strip.empty?
             v
           end
         end
 
-        handle_type(:bool) do |v|
+        handle_type(:bool, :invalid_value_message=>"empty string provided for parameter") do |v|
           case v
           when ''
             nil
@@ -523,18 +537,18 @@ class Roda
           end
         end
 
-        handle_type(:int, :max_input_bytesize=>100) do |v|
+        handle_type(:int, :max_input_bytesize=>100, :invalid_value_message=>"empty string provided for parameter") 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|
+        handle_type(:pos_int, :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, or non-positive integer provided for parameter") do |v|
           if (v = base_convert_int(v)) && v > 0
             v
           end
         end
 
-        handle_type(:Integer, :max_input_bytesize=>100) do |v|
+        handle_type(:Integer, :max_input_bytesize=>100, :invalid_value_message=>"empty string provided for parameter") do |v|
           if string_or_numeric!(v)
             case v
             when String
@@ -550,11 +564,11 @@ class Roda
         end
         alias base_convert_Integer convert_Integer
 
-        handle_type(:float, :max_input_bytesize=>1000) do |v|
+        handle_type(:float, :max_input_bytesize=>1000, :invalid_value_message=>"empty string provided for parameter") do |v|
           string_or_numeric!(v) && v.to_f
         end
 
-        handle_type(:Float, :max_input_bytesize=>1000) do |v|
+        handle_type(:Float, :max_input_bytesize=>1000, :invalid_value_message=>"empty string provided for parameter") do |v|
           string_or_numeric!(v) && ::Kernel::Float(v)
         end
 
@@ -752,7 +766,7 @@ class Roda
         def array(type, key, default=nil)
           meth = :"_convert_array_#{type}"
           raise ProgrammerError, "no typecast_params type registered for #{type.inspect}" unless respond_to?(meth, true)
-          process_arg(meth, key, default, send(:"_max_input_bytesize_for_#{type}")) if require_hash!
+          process_arg(meth, key, default, type) if require_hash!
         end
 
         # Call +array+ with the +type+, +key+, and +default+, but if the return value is nil or any value in
@@ -985,10 +999,10 @@ class Roda
 
         # If +key+ is not an array, convert the value at the given +key+ using the +meth+ method and +default+
         # value.  If +key+ is an array, return an array with the conversion done for each respective member of +key+.
-        def process_arg(meth, key, default, max_input_bytesize=nil)
+        def process_arg(meth, key, default, type)
           case key
           when String
-            v = process(meth, key, default, max_input_bytesize)
+            v = process(meth, key, default, type)
 
             if @capture
               key = key.to_sym if symbolize?
@@ -1001,13 +1015,23 @@ class Roda
           when Array
             key.map do |k|
               raise ProgrammerError, "non-String element in array argument passed to typecast_params: #{k.inspect}" unless k.is_a?(String)
-              process_arg(meth, k, default, max_input_bytesize)
+              process_arg(meth, k, default, type)
             end
           else
             raise ProgrammerError, "Unsupported argument for typecast_params conversion method: #{key.inspect}"
           end
         end
 
+        # The invalid message to use if the given type conversion fails, which may be nil to use the default.
+        def _invalid_value_message_for(type)
+          send(:"_invalid_value_message_for_#{type}")
+        end
+
+        # The maximum input bytesize for the given type, which may be nil.
+        def _max_input_bytesize_for(type)
+          send(:"_max_input_bytesize_for_#{type}")
+        end
+
         # Raise an Error if the value is a string with bytesize over max (if max is given)
         def check_allowed_bytesize(v, max)
           if max && v.is_a?(String) && v.bytesize > max
@@ -1024,18 +1048,24 @@ class Roda
 
         # Get the value of +key+ for the object, and convert it to the expected type using +meth+.
         # If the value either before or after conversion is nil, return the +default+ value.
-        def process(meth, key, default, max_input_bytesize=nil)
-          v = param_value(key)
+        def process(meth, key, default, type)
+          orig_v = v = param_value(key)
 
-          unless v.nil?
-            check_allowed_bytesize(v, max_input_bytesize)
+          if v.nil?
+            if default == CHECK_NIL
+              handle_error(key, :missing, "missing parameter for #{param_name(key)}")
+            end
+          else
+            check_allowed_bytesize(v, _max_input_bytesize_for(type))
             check_null_byte(v)
             v = send(meth, v)
           end
 
           if v.nil?
-            if default == CHECK_NIL
-              handle_error(key, :missing, "missing parameter for #{param_name(key)}")
+            if !orig_v.nil? && default == CHECK_NIL
+              invalid_value_message = _invalid_value_message_for(type)
+              invalid_value_message ||= "invalid parameter value for"
+              handle_error(key, :invalid_value, "#{invalid_value_message} #{param_name(key)}")
             end
 
             default

data/lib/roda/plugins/typecast_params_sized_integers.rb

@@ -51,37 +51,37 @@ class Roda
             max_signed = 2**(i-1)-1
             max_unsigned = 2**i-1
 
-            handle_type(:"int#{i}", :max_input_bytesize=>100) do |v|
+            handle_type(:"int#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, or too-large integer provided for parameter") 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|
+            handle_type(:"uint#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, negative integer, or too-large integer provided for parameter") 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|
+            handle_type(:"pos_int#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, non-positive integer, or too-large integer provided for parameter") 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|
+            handle_type(:"pos_uint#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, non-positive integer, or too-large integer provided for parameter") 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|
+            handle_type(:"Integer#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, or too-large integer provided for parameter") 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|
+            handle_type(:"Integeru#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, negative integer, or too-large integer provided for parameter") do |v|
               if (v = base_convert_Integer(v)) && v >= 0 && v <= max_unsigned
                 v
               end
@@ -91,8 +91,9 @@ class Roda
 
         if default = opts[:default_size]
           app::TypecastParams.class_eval do
+            meths = ['', 'convert_', '_convert_array_', '_max_input_bytesize_for_', '_invalid_value_message_for_']
             %w[int uint pos_int pos_uint Integer Integeru].each do |type|
-              ['', 'convert_', '_convert_array_', '_max_input_bytesize_for_'].each do |prefix|
+              meths.each do |prefix|
                 alias_method :"#{prefix}#{type}", :"#{prefix}#{type}#{default}"
               end
               alias_method :"#{type}!", :"#{type}#{default}!"

data/lib/roda/plugins/view_options.rb

@@ -182,7 +182,7 @@ class Roda
         # contain a slash.
         def template_name(opts)
           name = super
-          if (v = @_view_subdir) && name !~ /\//
+          if (v = @_view_subdir) && !name.include?('/')
             "#{v}/#{name}"
           else
             name

data/lib/roda/response.rb

@@ -18,7 +18,7 @@ class Roda
        Permissions-Policy Permissions-Policy-Report-Only Strict-Transport-Security'.
       each do |value|
         value = value.downcase if downcase
-        const_set(value.gsub('-', '_').upcase!.to_sym, value.freeze)
+        const_set(value.tr('-', '_').upcase!.to_sym, value.freeze)
       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 = 92
+  RodaMinorVersion = 93
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

metadata

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