grape 2.4.0 → 3.2.1

data/lib/grape/validations/types.rb

@@ -155,9 +155,10 @@ module Grape
       # @return [Object] object to be used
       #   for coercion and type validation
       def build_coercer(type, method: nil, strict: false)
-        cache_instance(type, method, strict) do
-          create_coercer_instance(type, method, strict)
-        end
+        # no cache since unique
+        return create_coercer_instance(type, method, strict) if method.respond_to?(:call)
+
+        CoercerCache[[type, method, strict]]
       end
 
       def create_coercer_instance(type, method, strict)
@@ -184,30 +185,14 @@ module Grape
         end
       end
 
-      def cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
-
-        return @__cache[key] if @__cache.key?(key)
-
-        instance = yield
-
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
+      class CoercerCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, (type, method, strict)|
+            h[[type, method, strict]] = Grape::Validations::Types.create_coercer_instance(type, method, strict)
+          end
         end
-
-        instance
       end
-
-      def cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
-
-          memo << '_' << val.to_s
-        end
-      end
-
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end

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

@@ -4,11 +4,14 @@ module Grape
   module Validations
     module Validators
       class AllOrNoneOfValidator < MultipleParamsBase
+        default_message_key :all_or_none
+
         def validate_params!(params)
-          keys = keys_in_common(params)
-          return if keys.empty? || keys.length == all_keys.length
+          known_keys = all_keys
+          keys = keys_in_common(params, known_keys)
+          return if keys.empty? || keys.length == @attrs.length
 
-          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
+          validation_error!(known_keys)
         end
       end
     end

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

@@ -4,15 +4,20 @@ module Grape
   module Validations
     module Validators
       class AllowBlankValidator < Base
-        def validate_param!(attr_name, params)
-          return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
+        default_message_key :blank
+
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @value = option_value
+        end
 
-          value = params[attr_name]
-          value = value.scrub if value.respond_to?(:scrub)
+        def validate_param!(attr_name, params)
+          return if @value || !hash_like?(params)
 
+          value = scrub(params[attr_name])
           return if value == false || value.present?
 
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
+          validation_error!(attr_name)
         end
       end
     end

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

@@ -4,10 +4,13 @@ module Grape
   module Validations
     module Validators
       class AtLeastOneOfValidator < MultipleParamsBase
+        default_message_key :at_least_one
+
         def validate_params!(params)
-          return unless keys_in_common(params).empty?
+          known_keys = all_keys
+          return if hash_like?(params) && known_keys.intersect?(params.keys.map { |attr| @scope.full_name(attr) })
 
-          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
+          validation_error!(known_keys)
         end
       end
     end

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

@@ -3,24 +3,64 @@
 module Grape
   module Validations
     module Validators
+      # Base class for all parameter validators.
+      #
+      # == Freeze contract
+      # Validator instances are shared across requests and are frozen after
+      # initialization (via +.new+). All inputs (+options+, +opts+, +attrs+)
+      # arrive pre-frozen from the DSL boundary, so subclass ivars derived
+      # from them are frozen by construction. Lazy ivar assignment
+      # (e.g. +memoize+, <tt>||=</tt>) will raise +FrozenError+ at request time.
       class Base
+        include Grape::Util::Translation
+
         attr_reader :attrs
 
+        class << self
+          # Declares the default I18n message key used by +validation_error!+.
+          # Subclasses that only need a single fixed error message can declare it
+          # at the class level instead of overriding +initialize+:
+          #
+          #   class MyValidator < Grape::Validations::Validators::Base
+          #     default_message_key :my_error
+          #   end
+          #
+          # The key is resolved through +message+, so a per-option +:message+
+          # override still takes precedence.
+          def default_message_key(key = nil)
+            if key
+              @default_message_key = key
+            else
+              @default_message_key || (superclass.respond_to?(:default_message_key) ? superclass.default_message_key : nil)
+            end
+          end
+
+          def new(...)
+            super.freeze
+          end
+
+          def inherited(klass)
+            super
+            Validations.register(klass)
+          end
+        end
+
         # Creates a new Validator from options specified
         # by a +requires+ or +optional+ directive during
         # parameter definition.
         # @param attrs [Array] names of attributes to which the Validator applies
-        # @param options [Object] implementation-dependent Validator options
+        # @param options [Object] implementation-dependent Validator options; deep-frozen on assignment
         # @param required [Boolean] attribute(s) are required or optional
         # @param scope [ParamsScope] parent scope for this Validator
         # @param opts [Hash] additional validation options
         def initialize(attrs, options, required, scope, opts)
-          @attrs = Array(attrs)
-          @option = options
+          @attrs = Array(attrs).freeze
+          @options = Grape::Util::DeepFreeze.deep_freeze(options)
+          @option = @options # TODO: remove in next major release
           @required = required
           @scope = scope
-          @fail_fast = opts[:fail_fast]
-          @allow_blank = opts[:allow_blank]
+          @fail_fast, @allow_blank = opts.values_at(:fail_fast, :allow_blank)
+          @exception_message = message(self.class.default_message_key) if self.class.default_message_key
         end
 
         # Validates a given request.
@@ -34,13 +74,18 @@ module Grape
           validate!(request.params)
         end
 
+        def fail_fast?
+          @fail_fast
+        end
+
         # Validates a given parameter hash.
-        # @note Override #validate if you need to access the entire request.
+        # @note Override #validate_param! for per-parameter validation,
+        #   or #validate if you need access to the entire request.
         # @param params [Hash] parameters to validate
         # @raise [Grape::Exceptions::Validation] if validation failed
         # @return [void]
         def validate!(params)
-          attributes = SingleAttributeIterator.new(self, @scope, params)
+          attributes = SingleAttributeIterator.new(@attrs, @scope, params)
           # we collect errors inside array because
           # there may be more than one error per field
           array_errors = []
@@ -49,7 +94,7 @@ module Grape
             next if !@scope.required? && empty_val
             next unless @scope.meets_dependency?(val, params)
 
-            validate_param!(attr_name, val) if @required || val.try(:key?, attr_name)
+            validate_param!(attr_name, val) if @required || (hash_like?(val) && val.key?(attr_name))
           rescue Grape::Exceptions::Validation => e
             array_errors << e
           end
@@ -57,32 +102,57 @@ module Grape
           raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        def self.inherited(klass)
-          super
-          Validations.register(klass)
+        protected
+
+        # Validates a single attribute. Override in subclasses.
+        # @param attr_name [Symbol, String] the attribute name
+        # @param params [Hash] the parameter hash containing the attribute
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate_param!(attr_name, params)
+          raise NotImplementedError
         end
 
-        def message(default_key = nil)
-          options = instance_variable_get(:@option)
-          options_key?(:message) ? options[:message] : default_key
+        private
+
+        def validation_error!(attr_name_or_params, message = @exception_message)
+          params = attr_name_or_params.is_a?(Array) ? attr_name_or_params : @scope.full_name(attr_name_or_params)
+          raise Grape::Exceptions::Validation.new(params:, message:)
+        end
+
+        def hash_like?(obj)
+          obj.respond_to?(:key?)
         end
 
         def options_key?(key, options = nil)
-          options = instance_variable_get(:@option) if options.nil?
-          options.try(:key?, key) && !options[key].nil?
+          current_options = options || @options
+          hash_like?(current_options) && current_options.key?(key) && !current_options[key].nil?
         end
 
-        def fail_fast?
-          @fail_fast
+        # Returns the effective message for a validation error.
+        # Prefers an explicit +:message+ option, then +default_key+.
+        # If both are nil, the block (if given) is called to compute a fallback —
+        # useful for validators that build a message Hash for deferred i18n interpolation.
+        # @example
+        #   @exception_message = message(:presence)             # symbol key or custom message
+        #   @exception_message = message { build_hash_message } # computed fallback
+        def message(default_key = nil)
+          key = options_key?(:message) ? @options[:message] : default_key
+          return key unless key.nil?
+
+          yield if block_given?
+        end
+
+        def option_value
+          options_key?(:value) ? @options[:value] : @options
+        end
+
+        def scrub(value)
+          return value unless value.respond_to?(:valid_encoding?) && !value.valid_encoding?
+
+          value.scrub
         end
       end
     end
   end
 end
-
-Grape::Validations::Base = Class.new(Grape::Validations::Validators::Base) do
-  def self.inherited(*)
-    Grape.deprecator.warn 'Grape::Validations::Base is deprecated! Use Grape::Validations::Validators::Base instead.'
-    super
-  end
-end

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,12 @@
 module Grape
   module Validations
     module Validators
-      class ContractScopeValidator < Base
+      class ContractScopeValidator
         attr_reader :schema
 
-        def initialize(_attrs, _options, _required, _scope, opts)
-          super
-          @schema = opts.fetch(:schema)
+        def initialize(schema:)
+          @schema = schema
+          freeze
         end
 
         # Validates a given request.
@@ -26,13 +26,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.try(: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/{mutual_exclusion_validator.rb → mutually_exclusive_validator.rb}

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