grape 3.1.1 → 3.2.0

data/lib/grape/validations/validators/coerce_validator.rb

@@ -4,22 +4,27 @@ module Grape
   module Validations
     module Validators
       class CoerceValidator < Base
+        default_message_key :coerce
+
         def initialize(attrs, options, required, scope, opts)
           super
 
-          @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
-                         type
-                       else
-                         Types.build_coercer(type, method: @option[:method])
-                       end
+          raw_type = @options[:type]
+          type = hash_like?(raw_type) ? raw_type[:value] : raw_type
+          @converter =
+            if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
+              type
+            else
+              Types.build_coercer(type, method: @options[:method])
+            end
         end
 
         def validate_param!(attr_name, params)
-          raise validation_exception(attr_name) unless params.is_a? Hash
+          validation_error!(attr_name) unless hash_like?(params)
 
           new_value = coerce_value(params[attr_name])
 
-          raise validation_exception(attr_name, new_value.message) unless valid_type?(new_value)
+          validation_error!(attr_name, new_value.message || @exception_message) if new_value.is_a?(Types::InvalidValue)
 
           # Don't assign a value if it is identical. It fixes a problem with Hashie::Mash
           # which looses wrappers for hashes and arrays after reassigning values
@@ -37,38 +42,13 @@ module Grape
 
         private
 
-        # @!attribute [r] converter
-        # Object that will be used for parameter coercion and type checking.
-        #
-        # See {Types.build_coercer}
-        #
-        # @return [Object]
-        attr_reader :converter
-
-        def valid_type?(val)
-          !val.is_a?(Types::InvalidValue)
-        end
-
+        # Calls the converter built at definition time.
+        # Custom coercers may raise; any StandardError is treated as an invalid value.
         def coerce_value(val)
-          converter.call(val)
-          # Some custom types might fail, so it should be treated as an invalid value
+          @converter.call(val)
         rescue StandardError
           Types::InvalidValue.new
         end
-
-        # Type to which the parameter will be coerced.
-        #
-        # @return [Class]
-        def type
-          @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
-        end
-
-        def validation_exception(attr_name, custom_msg = nil)
-          Grape::Exceptions::Validation.new(
-            params: [@scope.full_name(attr_name)],
-            message: custom_msg || message(:coerce)
-          )
-        end
       end
     end
   end

data/lib/grape/validations/validators/contract_scope_validator.rb

@@ -3,12 +3,10 @@
 module Grape
   module Validations
     module Validators
-      class ContractScopeValidator < Base
-        attr_reader :schema
-
-        def initialize(_attrs, _options, _required, _scope, opts)
-          super
-          @schema = opts.fetch(:schema)
+      class ContractScopeValidator
+        def initialize(schema:)
+          @schema = schema
+          freeze
         end
 
         # Validates a given request.
@@ -16,7 +14,7 @@ module Grape
         # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
         # @return [void]
         def validate(request)
-          res = schema.call(request.params)
+          res = @schema.call(request.params)
 
           if res.success?
             request.params.deep_merge!(res.to_h)
@@ -26,13 +24,17 @@ module Grape
           raise Grape::Exceptions::ValidationArrayErrors.new(build_errors_from_messages(res.errors.messages))
         end
 
+        def fail_fast?
+          false
+        end
+
         private
 
         def build_errors_from_messages(messages)
           messages.map do |message|
             full_name = message.path.first.to_s
             full_name << "[#{message.path[1..].join('][')}]" if message.path.size > 1
-            Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
+            Grape::Exceptions::Validation.new(params: full_name, message: message.text)
           end
         end
       end

data/lib/grape/validations/validators/default_validator.rb

@@ -4,31 +4,25 @@ module Grape
   module Validations
     module Validators
       class DefaultValidator < Base
-        def initialize(attrs, options, required, scope, opts = {})
-          @default = options
+        def initialize(attrs, options, required, scope, opts)
           super
-        end
-
-        def validate_param!(attr_name, params)
-          params[attr_name] = if @default.is_a? Proc
-                                if @default.parameters.empty?
-                                  @default.call
-                                else
-                                  @default.call(params)
-                                end
-                              elsif @default.frozen? || !@default.duplicable?
-                                @default
-                              else
-                                @default.dup
-                              end
+          # !important, lazy call at runtime
+          @default_call =
+            if @options.is_a?(Proc)
+              @options.arity.zero? ? proc { @options.call } : @options
+            elsif @options.duplicable?
+              proc { @options.dup }
+            else
+              proc { @options }
+            end
         end
 
         def validate!(params)
-          attrs = SingleAttributeIterator.new(self, @scope, params)
+          attrs = SingleAttributeIterator.new(@attrs, @scope, params)
           attrs.each do |resource_params, attr_name|
             next unless @scope.meets_dependency?(resource_params, params)
 
-            validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
+            resource_params[attr_name] = @default_call.call(resource_params) if hash_like?(resource_params) && resource_params[attr_name].nil?
           end
         end
       end

data/lib/grape/validations/validators/exactly_one_of_validator.rb

@@ -4,12 +4,19 @@ module Grape
   module Validations
     module Validators
       class ExactlyOneOfValidator < MultipleParamsBase
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @exactly_one_exception_message = message(:exactly_one)
+          @mutual_exclusion_exception_message = message(:mutual_exclusion)
+        end
+
         def validate_params!(params)
-          keys = keys_in_common(params)
+          known_keys = all_keys
+          keys = keys_in_common(params, known_keys)
           return if keys.length == 1
-          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.empty?
 
-          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+          validation_error!(known_keys, @exactly_one_exception_message) if keys.empty?
+          validation_error!(keys, @mutual_exclusion_exception_message)
         end
       end
     end

data/lib/grape/validations/validators/except_values_validator.rb

@@ -4,19 +4,28 @@ module Grape
   module Validations
     module Validators
       class ExceptValuesValidator < Base
+        default_message_key :except_values
+
         def initialize(attrs, options, required, scope, opts)
-          @except = options.is_a?(Hash) ? options[:value] : options
           super
+          except = option_value
+          raise ArgumentError, 'except_values Proc must have arity of zero (use values: with a one-arity predicate for per-element checks)' if except.is_a?(Proc) && !except.arity.zero?
+
+          # Zero-arity procs (e.g. -> { User.pluck(:role) }) must be called per-request,
+          # not at definition time, so they are wrapped in a lambda to defer execution.
+          @excepts_call = except.is_a?(Proc) ? except : -> { except }
         end
 
         def validate_param!(attr_name, params)
-          return unless params.respond_to?(:key?) && params.key?(attr_name)
+          return unless hash_like?(params) && params.key?(attr_name)
 
-          excepts = @except.is_a?(Proc) ? @except.call : @except
+          excepts = @excepts_call.call
           return if excepts.nil?
 
           param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:except_values)) if param_array.any? { |param| excepts.include?(param) }
+          return if param_array.none? { |param| excepts.include?(param) }
+
+          validation_error!(attr_name)
         end
       end
     end

data/lib/grape/validations/validators/length_validator.rb

@@ -5,19 +5,16 @@ module Grape
     module Validators
       class LengthValidator < Base
         def initialize(attrs, options, required, scope, opts)
-          @min = options[:min]
-          @max = options[:max]
-          @is = options[:is]
-
           super
 
-          raise ArgumentError, 'min must be an integer greater than or equal to zero' if !@min.nil? && (!@min.is_a?(Integer) || @min.negative?)
-          raise ArgumentError, 'max must be an integer greater than or equal to zero' if !@max.nil? && (!@max.is_a?(Integer) || @max.negative?)
-          raise ArgumentError, "min #{@min} cannot be greater than max #{@max}" if !@min.nil? && !@max.nil? && @min > @max
+          @min, @max, @is = @options.values_at(:min, :max, :is)
+          validate_boundary!(:min, @min)
+          validate_boundary!(:max, @max)
+          raise ArgumentError, "min #{@min} cannot be greater than max #{@max}" if @min && @max && @min > @max
 
           return if @is.nil?
-          raise ArgumentError, 'is must be an integer greater than zero' if !@is.is_a?(Integer) || !@is.positive?
-          raise ArgumentError, 'is cannot be combined with min or max' if !@min.nil? || !@max.nil?
+          raise ArgumentError, 'is must be an integer greater than zero' unless @is.is_a?(Integer) && @is.positive?
+          raise ArgumentError, 'is cannot be combined with min or max' unless @min.nil? && @max.nil?
         end
 
         def validate_param!(attr_name, params)
@@ -27,21 +24,23 @@ module Grape
 
           return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max) || (!@is.nil? && param.length != @is)
 
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: build_message)
+          validation_error!(attr_name, message do
+            if @min && @max
+              translate(:length, min: @min, max: @max)
+            elsif @min
+              translate(:length_min, min: @min)
+            elsif @max
+              translate(:length_max, max: @max)
+            else
+              translate(:length_is, is: @is)
+            end
+          end)
         end
 
-        def build_message
-          if options_key?(:message)
-            @option[:message]
-          elsif @min && @max
-            format I18n.t(:length, scope: 'grape.errors.messages'), min: @min, max: @max
-          elsif @min
-            format I18n.t(:length_min, scope: 'grape.errors.messages'), min: @min
-          elsif @max
-            format I18n.t(:length_max, scope: 'grape.errors.messages'), max: @max
-          else
-            format I18n.t(:length_is, scope: 'grape.errors.messages'), is: @is
-          end
+        private
+
+        def validate_boundary!(name, val)
+          raise ArgumentError, "#{name} must be an integer greater than or equal to zero" if !val.nil? && (!val.is_a?(Integer) || val.negative?)
         end
       end
     end

data/lib/grape/validations/validators/multiple_params_base.rb

@@ -5,7 +5,7 @@ module Grape
     module Validators
       class MultipleParamsBase < Base
         def validate!(params)
-          attributes = MultipleAttributesIterator.new(self, @scope, params)
+          attributes = MultipleAttributesIterator.new(@attrs, @scope, params)
           array_errors = []
 
           attributes.each do |resource_params|
@@ -19,14 +19,14 @@ module Grape
 
         private
 
-        def keys_in_common(resource_params)
-          return [] unless resource_params.is_a?(Hash)
+        def keys_in_common(resource_params, known_keys = all_keys)
+          return [] unless hash_like?(resource_params)
 
-          all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
+          known_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
         end
 
         def all_keys
-          attrs.map { |attr| @scope.full_name(attr) }
+          @attrs.map { |attr| @scope.full_name(attr) }
         end
       end
     end

data/lib/grape/validations/validators/mutually_exclusive_validator.rb

@@ -4,11 +4,13 @@ module Grape
   module Validations
     module Validators
       class MutuallyExclusiveValidator < MultipleParamsBase
+        default_message_key :mutual_exclusion
+
         def validate_params!(params)
           keys = keys_in_common(params)
           return if keys.length <= 1
 
-          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+          validation_error!(keys)
         end
       end
     end

data/lib/grape/validations/validators/presence_validator.rb

@@ -4,10 +4,12 @@ module Grape
   module Validations
     module Validators
       class PresenceValidator < Base
+        default_message_key :presence
+
         def validate_param!(attr_name, params)
-          return if params.respond_to?(:key?) && params.key?(attr_name)
+          return if hash_like?(params) && params.key?(attr_name)
 
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
+          validation_error!(attr_name)
         end
       end
     end

data/lib/grape/validations/validators/regexp_validator.rb

@@ -4,21 +4,19 @@ module Grape
   module Validations
     module Validators
       class RegexpValidator < Base
-        def validate_param!(attr_name, params)
-          return unless params.respond_to?(:key) && params.key?(attr_name)
-
-          value = options_key?(:value) ? @option[:value] : @option
-          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || scrub(param.to_s).match?(value) }
+        default_message_key :regexp
 
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @value = option_value
         end
 
-        private
+        def validate_param!(attr_name, params)
+          return unless hash_like?(params) && params.key?(attr_name)
 
-        def scrub(param)
-          return param if param.valid_encoding?
+          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || scrub(param.to_s).match?(@value) }
 
-          param.scrub
+          validation_error!(attr_name)
         end
       end
     end

data/lib/grape/validations/validators/same_as_validator.rb

@@ -4,24 +4,15 @@ module Grape
   module Validations
     module Validators
       class SameAsValidator < Base
-        def validate_param!(attr_name, params)
-          confirmation = options_key?(:value) ? @option[:value] : @option
-          return if params[attr_name] == params[confirmation]
-
-          raise Grape::Exceptions::Validation.new(
-            params: [@scope.full_name(attr_name)],
-            message: build_message
-          )
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @value = option_value
         end
 
-        private
+        def validate_param!(attr_name, params)
+          return if params[attr_name] == params[@value]
 
-        def build_message
-          if options_key?(:message)
-            @option[:message]
-          else
-            format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
-          end
+          validation_error!(attr_name, message { translate(:same_as, parameter: @value) })
         end
       end
     end

data/lib/grape/validations/validators/values_validator.rb

@@ -4,45 +4,53 @@ module Grape
   module Validations
     module Validators
       class ValuesValidator < Base
+        default_message_key :values
+
         def initialize(attrs, options, required, scope, opts)
-          @values = options.is_a?(Hash) ? options[:value] : options
           super
+          values = option_value
+
+          # Zero-arity procs return a collection per-request (e.g. DB-backed lists).
+          # Non-zero-arity procs are per-element predicates, called directly at validation time.
+          # Non-Proc values are wrapped in a zero-arity lambda for a uniform call interface.
+          if values.is_a?(Proc)
+            @values_call = values
+            @values_is_predicate = !values.arity.zero?
+          else
+            @values_call = -> { values }
+            @values_is_predicate = false
+          end
         end
 
         def validate_param!(attr_name, params)
-          return unless params.is_a?(Hash)
+          return unless hash_like?(params)
 
-          val = params[attr_name]
+          val = scrub(params[attr_name])
 
           return if val.nil? && !required_for_root_scope?
-
-          val = val.scrub if val.respond_to?(:valid_encoding?) && !val.valid_encoding?
-
-          # don't forget that +false.blank?+ is true
           return if val != false && val.blank? && @allow_blank
-
           return if check_values?(val, attr_name)
 
-          raise Grape::Exceptions::Validation.new(
-            params: [@scope.full_name(attr_name)],
-            message: message(:values)
-          )
+          validation_error!(attr_name)
         end
 
         private
 
         def check_values?(val, attr_name)
-          values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
-          return true if values.nil?
-
           param_array = val.nil? ? [nil] : Array.wrap(val)
-          return param_array.all? { |param| values.include?(param) } unless values.is_a?(Proc)
 
-          begin
-            param_array.all? { |param| values.call(param) }
-          rescue StandardError => e
-            warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
-            false
+          if @values_is_predicate
+            begin
+              param_array.all? { |param| @values_call.call(param) }
+            rescue StandardError => e
+              warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
+              false
+            end
+          else
+            values = @values_call.call
+            return true if values.nil?
+
+            param_array.all? { |param| values.include?(param) }
           end
         end
 

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '3.1.1'
+  VERSION = '3.2.0'
 end

data/lib/grape.rb

@@ -33,7 +33,6 @@ require 'rack'
 require 'rack/auth/basic'
 require 'rack/builder'
 require 'rack/head'
-require 'set'
 require 'singleton'
 require 'zeitwerk'
 
@@ -64,6 +63,24 @@ module Grape
     Rack::OPTIONS
   ].freeze
 
+  # Rack errors that should be rescued and wrapped as Grape::Exceptions::RequestError.
+  # Rack 3.1.0 introduced Rack::BadRequest as a marker module included by all bad request
+  # exception classes, allowing a single rescue entry to cover them all.
+  # Before, these errors are raised as individual exception classes.
+  RACK_ERRORS =
+    if Gem::Version.new(Rack.release) >= Gem::Version.new('3.1.0')
+      [EOFError, Rack::BadRequest]
+    else
+      [
+        EOFError,
+        Rack::Multipart::MultipartPartLimitError,
+        Rack::Multipart::MultipartTotalPartLimitError,
+        Rack::Utils::ParameterTypeError,
+        Rack::Utils::InvalidParameterError,
+        Rack::QueryParser::ParamsTooDeepError
+      ]
+    end.freeze
+
   def self.deprecator
     @deprecator ||= ActiveSupport::Deprecation.new('2.0', 'Grape')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
@@ -136,13 +136,10 @@ files:
 - lib/grape/error_formatter/txt.rb
 - lib/grape/error_formatter/xml.rb
 - lib/grape/exceptions/base.rb
-- lib/grape/exceptions/conflicting_types.rb
-- lib/grape/exceptions/empty_message_body.rb
 - lib/grape/exceptions/incompatible_option_values.rb
 - lib/grape/exceptions/invalid_accept_header.rb
 - lib/grape/exceptions/invalid_formatter.rb
 - lib/grape/exceptions/invalid_message_body.rb
-- lib/grape/exceptions/invalid_parameters.rb
 - lib/grape/exceptions/invalid_response.rb
 - lib/grape/exceptions/invalid_version_header.rb
 - lib/grape/exceptions/invalid_versioner_option.rb
@@ -151,8 +148,7 @@ files:
 - lib/grape/exceptions/missing_group_type.rb
 - lib/grape/exceptions/missing_mime_type.rb
 - lib/grape/exceptions/missing_vendor_option.rb
-- lib/grape/exceptions/too_deep_parameters.rb
-- lib/grape/exceptions/too_many_multipart_files.rb
+- lib/grape/exceptions/request_error.rb
 - lib/grape/exceptions/unknown_auth_strategy.rb
 - lib/grape/exceptions/unknown_parameter.rb
 - lib/grape/exceptions/unknown_params_builder.rb
@@ -210,6 +206,7 @@ files:
 - lib/grape/util/api_description.rb
 - lib/grape/util/base_inheritable.rb
 - lib/grape/util/cache.rb
+- lib/grape/util/deep_freeze.rb
 - lib/grape/util/endpoint_configuration.rb
 - lib/grape/util/header.rb
 - lib/grape/util/inheritable_setting.rb
@@ -223,10 +220,12 @@ files:
 - lib/grape/util/registry.rb
 - lib/grape/util/reverse_stackable_values.rb
 - lib/grape/util/stackable_values.rb
+- lib/grape/util/translation.rb
 - lib/grape/validations.rb
 - lib/grape/validations/attributes_iterator.rb
 - lib/grape/validations/contract_scope.rb
 - lib/grape/validations/multiple_attributes_iterator.rb
+- lib/grape/validations/param_scope_tracker.rb
 - lib/grape/validations/params_documentation.rb
 - lib/grape/validations/params_scope.rb
 - lib/grape/validations/single_attribute_iterator.rb
@@ -242,7 +241,6 @@ files:
 - lib/grape/validations/types/primitive_coercer.rb
 - lib/grape/validations/types/set_coercer.rb
 - lib/grape/validations/types/variant_collection_coercer.rb
-- lib/grape/validations/validator_factory.rb
 - lib/grape/validations/validators/all_or_none_of_validator.rb
 - lib/grape/validations/validators/allow_blank_validator.rb
 - lib/grape/validations/validators/as_validator.rb
@@ -267,9 +265,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/ruby-grape/grape/issues
-  changelog_uri: https://github.com/ruby-grape/grape/blob/v3.1.1/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/grape/3.1.1
-  source_code_uri: https://github.com/ruby-grape/grape/tree/v3.1.1
+  changelog_uri: https://github.com/ruby-grape/grape/blob/v3.2.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/grape/3.2.0
+  source_code_uri: https://github.com/ruby-grape/grape/tree/v3.2.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -278,7 +276,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/grape/exceptions/conflicting_types.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Exceptions
-    class ConflictingTypes < Base
-      def initialize
-        super(message: compose_message(:conflicting_types), status: 400)
-      end
-    end
-  end
-end

data/lib/grape/exceptions/empty_message_body.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Exceptions
-    class EmptyMessageBody < Base
-      def initialize(body_format)
-        super(message: compose_message(:empty_message_body, body_format: body_format), status: 400)
-      end
-    end
-  end
-end

data/lib/grape/exceptions/invalid_parameters.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Exceptions
-    class InvalidParameters < Base
-      def initialize
-        super(message: compose_message(:invalid_parameters), status: 400)
-      end
-    end
-  end
-end