grape 1.3.3 → 1.6.2

data/lib/grape/validations/single_attribute_iterator.rb

@@ -7,7 +7,7 @@ module Grape
 
       def yield_attributes(val, attrs)
         attrs.each do |attr_name|
-          yield val, attr_name, empty?(val)
+          yield val, attr_name, empty?(val), skip?(val)
         end
       end
 

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -52,10 +52,11 @@ module Grape
         #   this should always be a string.
         # @return [Object] the coerced result
         def call(val)
-          return if val.nil?
-
           coerced_val = @method.call(val)
+
+          return coerced_val if coerced_val.is_a?(InvalidValue)
           return InvalidValue.new unless coerced?(coerced_val)
+
           coerced_val
         end
 
@@ -103,13 +104,25 @@ module Grape
             # passed, or if the type also implements a parse() method.
             type
           elsif type.is_a?(Enumerable)
-            ->(value) { value.respond_to?(:all?) && value.all? { |item| item.is_a? type[0] } }
+            lambda do |value|
+              value.is_a?(Enumerable) && value.all? do |val|
+                recursive_type_check(type.first, val)
+              end
+            end
           else
             # By default, do a simple type check
             ->(value) { value.is_a? type }
           end
         end
 
+        def recursive_type_check(type, value)
+          if type.is_a?(Enumerable) && value.is_a?(Enumerable)
+            value.all? { |val| recursive_type_check(type.first, val) }
+          else
+            !type.is_a?(Enumerable) && value.is_a?(type)
+          end
+        end
+
         # Enforce symbolized keys for complex types
         # by wrapping the coercion method such that
         # any Hash objects in the immediate heirarchy

data/lib/grape/validations/types/dry_type_coercer.rb

@@ -35,7 +35,7 @@ module Grape
 
           # Returns an instance of a coercer for a given type
           def coercer_instance_for(type, strict = false)
-            return PrimitiveCoercer.new(type, strict) if type.class == Class
+            return PrimitiveCoercer.new(type, strict) if type.instance_of?(Class)
 
             # in case of a collection (Array[Integer]) the type is an instance of a collection,
             # so we need to figure out the actual type

data/lib/grape/validations/types/invalid_value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Types
+      # Instances of this class may be used as tokens to denote that a parameter value could not be
+      # coerced. The given message will be used as a validation error.
+      class InvalidValue
+        attr_reader :message
+
+        def initialize(message = nil)
+          @message = message
+        end
+      end
+    end
+  end
+end
+
+# only exists to make it shorter for external use
+module Grape
+  module Types
+    InvalidValue = Class.new(Grape::Validations::Types::InvalidValue)
+  end
+end

data/lib/grape/validations/types/json.rb

@@ -22,6 +22,7 @@ module Grape
 
             # Allow nulls and blank strings
             return if input.nil? || input.match?(/^\s*$/)
+
             JSON.parse(input, symbolize_names: true)
           end
 
@@ -41,7 +42,7 @@ module Grape
           # @param value [Object] result of {#parse}
           # @return [true,false]
           def coerced_collection?(value)
-            value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash }
+            value.is_a?(::Array) && value.all?(::Hash)
           end
         end
       end

data/lib/grape/validations/types/primitive_coercer.rb

@@ -11,15 +11,15 @@ module Grape
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
           Grape::API::Boolean => DryTypes::Params::Bool,
-          BigDecimal          => DryTypes::Params::Decimal,
+          BigDecimal => DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String              => DryTypes::Coercible::String
+          String => DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {
           Grape::API::Boolean => DryTypes::Strict::Bool,
-          BigDecimal          => DryTypes::Strict::Decimal
+          BigDecimal => DryTypes::Strict::Decimal
         }.freeze
 
         def initialize(type, strict = false)
@@ -37,7 +37,6 @@ module Grape
         def call(val)
           return InvalidValue.new if reject?(val)
           return nil if val.nil? || treat_as_nil?(val)
-          return '' if val == ''
 
           super
         end
@@ -60,7 +59,7 @@ module Grape
         # absence of a value and coerces it into nil. See a discussion there
         # https://github.com/ruby-grape/grape/pull/2045
         def treat_as_nil?(val)
-          val == '' && type == Grape::API::Boolean
+          val == '' && type != String
         end
       end
     end

data/lib/grape/validations/types.rb

@@ -7,6 +7,7 @@ require_relative 'types/multiple_type_coercer'
 require_relative 'types/variant_collection_coercer'
 require_relative 'types/json'
 require_relative 'types/file'
+require_relative 'types/invalid_value'
 
 module Grape
   module Validations
@@ -21,10 +22,6 @@ module Grape
     # and {Grape::Dsl::Parameters#optional}. The main
     # entry point for this process is {Types.build_coercer}.
     module Types
-      # Instances of this class may be used as tokens to denote that
-      # a parameter value could not be coerced.
-      class InvalidValue; end
-
       # Types representing a single value, which are coerced.
       PRIMITIVES = [
         # Numerical

data/lib/grape/validations/validator_factory.rb

@@ -8,7 +8,7 @@ module Grape
                                       options[:options],
                                       options[:required],
                                       options[:params_scope],
-                                      options[:opts])
+                                      **options[:opts])
       end
     end
   end

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

@@ -4,11 +4,14 @@ require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
-    class AllOrNoneOfValidator < MultipleParamsBase
-      def validate_params!(params)
-        keys = keys_in_common(params)
-        return if keys.empty? || keys.length == all_keys.length
-        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
+    module Validators
+      class AllOrNoneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          return if keys.empty? || keys.length == all_keys.length
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
+        end
       end
     end
   end

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

@@ -2,16 +2,18 @@
 
 module Grape
   module Validations
-    class AllowBlankValidator < Base
-      def validate_param!(attr_name, params)
-        return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
+    module Validators
+      class AllowBlankValidator < Base
+        def validate_param!(attr_name, params)
+          return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
 
-        value = params[attr_name]
-        value = value.strip if value.respond_to?(:strip)
+          value = params[attr_name]
+          value = value.strip if value.respond_to?(:strip)
 
-        return if value == false || value.present?
+          return if value == false || value.present?
 
-        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
+        end
       end
     end
   end

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

@@ -2,14 +2,12 @@
 
 module Grape
   module Validations
-    class AsValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
-        @renamed_options = options
-        super
-      end
-
-      def validate_param!(attr_name, params)
-        params[@renamed_options] = params[attr_name]
+    module Validators
+      class AsValidator < Base
+        # We use a validator for renaming parameters. This is just a marker for
+        # the parameter scope to handle the renaming. No actual validation
+        # happens here.
+        def validate_param!(*); end
       end
     end
   end

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

@@ -4,10 +4,13 @@ require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
-    class AtLeastOneOfValidator < MultipleParamsBase
-      def validate_params!(params)
-        return unless keys_in_common(params).empty?
-        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
+    module Validators
+      class AtLeastOneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          return unless keys_in_common(params).empty?
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
+        end
       end
     end
   end

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

@@ -2,88 +2,93 @@
 
 module Grape
   module Validations
-    class Base
-      attr_reader :attrs
+    module Validators
+      class Base
+        attr_reader :attrs
 
-      # 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 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
-        @required = required
-        @scope = scope
-        @fail_fast = opts[:fail_fast] || false
-        @allow_blank = opts[:allow_blank] || false
-      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 required [Boolean] attribute(s) are required or optional
+        # @param scope [ParamsScope] parent scope for this Validator
+        # @param opts [Array] additional validation options
+        def initialize(attrs, options, required, scope, *opts)
+          @attrs = Array(attrs)
+          @option = options
+          @required = required
+          @scope = scope
+          opts = opts.any? ? opts.shift : {}
+          @fail_fast = opts.fetch(:fail_fast, false)
+          @allow_blank = opts.fetch(:allow_blank, false)
+        end
 
-      # Validates a given request.
-      # @note Override #validate! unless you need to access the entire request.
-      # @param request [Grape::Request] the request currently being handled
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate(request)
-        return unless @scope.should_validate?(request.params)
-        validate!(request.params)
-      end
+        # Validates a given request.
+        # @note Override #validate! unless you need to access the entire request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate(request)
+          return unless @scope.should_validate?(request.params)
+
+          validate!(request.params)
+        end
 
-      # Validates a given parameter hash.
-      # @note Override #validate if you need to access 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)
-        # we collect errors inside array because
-        # there may be more than one error per field
-        array_errors = []
+        # Validates a given parameter hash.
+        # @note Override #validate if you need to access 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)
+          # we collect errors inside array because
+          # there may be more than one error per field
+          array_errors = []
 
-        attributes.each do |val, attr_name, empty_val|
-          next if !@scope.required? && empty_val
-          next unless @scope.meets_dependency?(val, params)
-          begin
-            if @required || val.respond_to?(:key?) && val.key?(attr_name)
-              validate_param!(attr_name, val)
+          attributes.each do |val, attr_name, empty_val, skip_value|
+            next if skip_value
+            next if !@scope.required? && empty_val
+            next unless @scope.meets_dependency?(val, params)
+
+            begin
+              validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
             end
-          rescue Grape::Exceptions::Validation => e
-            array_errors << e
           end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
-      end
+        def self.convert_to_short_name(klass)
+          ret = klass.name.gsub(/::/, '/')
+          ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          ret.tr!('-', '_')
+          ret.downcase!
+          File.basename(ret, '_validator')
+        end
 
-      def self.convert_to_short_name(klass)
-        ret = klass.name.gsub(/::/, '/')
-        ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        ret.tr!('-', '_')
-        ret.downcase!
-        File.basename(ret, '_validator')
-      end
+        def self.inherited(klass)
+          return unless klass.name.present?
 
-      def self.inherited(klass)
-        return unless klass.name.present?
-        Validations.register_validator(convert_to_short_name(klass), klass)
-      end
+          Validations.register_validator(convert_to_short_name(klass), klass)
+        end
 
-      def message(default_key = nil)
-        options = instance_variable_get(:@option)
-        options_key?(:message) ? options[:message] : default_key
-      end
+        def message(default_key = nil)
+          options = instance_variable_get(:@option)
+          options_key?(:message) ? options[:message] : default_key
+        end
 
-      def options_key?(key, options = nil)
-        options = instance_variable_get(:@option) if options.nil?
-        options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
-      end
+        def options_key?(key, options = nil)
+          options = instance_variable_get(:@option) if options.nil?
+          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+        end
 
-      def fail_fast?
-        @fail_fast
+        def fail_fast?
+          @fail_fast
+        end
       end
     end
   end

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

@@ -1,87 +1,74 @@
 # frozen_string_literal: true
 
 module Grape
-  class API
-    class Boolean
-      def self.build(val)
-        return nil if val != true && val != false
-
-        new
-      end
-    end
-
-    class Instance
-      Boolean = Grape::API::Boolean
-    end
-  end
-
   module Validations
-    class CoerceValidator < Base
-      def initialize(*_args)
-        super
-
-        @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
-                       type
-                     else
-                       Types.build_coercer(type, method: @option[:method])
-                     end
-      end
-
-      def validate(request)
-        super
-      end
-
-      def validate_param!(attr_name, params)
-        raise validation_exception(attr_name) unless params.is_a? Hash
-
-        new_value = coerce_value(params[attr_name])
-
-        raise validation_exception(attr_name) unless valid_type?(new_value)
-
-        # 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
+    module Validators
+      class CoerceValidator < Base
+        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
+        end
+
+        def validate_param!(attr_name, params)
+          raise validation_exception(attr_name) unless params.is_a? Hash
+
+          new_value = coerce_value(params[attr_name])
+
+          raise validation_exception(attr_name, new_value.message) unless valid_type?(new_value)
+
+          # 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
+          #
+          #     h = Hashie::Mash.new(list: [1, 2, 3, 4])
+          #     => #<Hashie::Mash list=#<Hashie::Array [1, 2, 3, 4]>>
+          #     list = h.list
+          #     h[:list] = list
+          #     h
+          #     => #<Hashie::Mash list=[1, 2, 3, 4]>
+          return if params[attr_name].instance_of?(new_value.class) && params[attr_name] == new_value
+
+          params[attr_name] = new_value
+        end
+
+        private
+
+        # @!attribute [r] converter
+        # Object that will be used for parameter coercion and type checking.
         #
-        #     h = Hashie::Mash.new(list: [1, 2, 3, 4])
-        #     => #<Hashie::Mash list=#<Hashie::Array [1, 2, 3, 4]>>
-        #     list = h.list
-        #     h[:list] = list
-        #     h
-        #     => #<Hashie::Mash list=[1, 2, 3, 4]>
-        return if params[attr_name].class == new_value.class && params[attr_name] == new_value
-
-        params[attr_name] = new_value
-      end
-
-      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
+        # See {Types.build_coercer}
+        #
+        # @return [Object]
+        attr_reader :converter
 
-      def coerce_value(val)
-        converter.call(val)
-      # Some custom types might fail, so it should be treated as an invalid value
-      rescue StandardError
-        Types::InvalidValue.new
-      end
+        def valid_type?(val)
+          !val.is_a?(Types::InvalidValue)
+        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 coerce_value(val)
+          converter.call(val)
+          # Some custom types might fail, so it should be treated as an invalid value
+        rescue StandardError
+          Types::InvalidValue.new
+        end
 
-      def validation_exception(attr_name)
-        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:coerce))
+        # 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/default.rb

@@ -2,47 +2,49 @@
 
 module Grape
   module Validations
-    class DefaultValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
-        @default = options
-        super
-      end
+    module Validators
+      class DefaultValidator < Base
+        def initialize(attrs, options, required, scope, **opts)
+          @default = options
+          super
+        end
 
-      def validate_param!(attr_name, params)
-        params[attr_name] = if @default.is_a? Proc
-                              @default.call
-                            elsif @default.frozen? || !duplicatable?(@default)
-                              @default
-                            else
-                              duplicate(@default)
-                            end
-      end
+        def validate_param!(attr_name, params)
+          params[attr_name] = if @default.is_a? Proc
+                                @default.call
+                              elsif @default.frozen? || !duplicatable?(@default)
+                                @default
+                              else
+                                duplicate(@default)
+                              end
+        end
+
+        def validate!(params)
+          attrs = SingleAttributeIterator.new(self, @scope, params)
+          attrs.each do |resource_params, attr_name|
+            next unless @scope.meets_dependency?(resource_params, params)
 
-      def validate!(params)
-        attrs = SingleAttributeIterator.new(self, @scope, params)
-        attrs.each do |resource_params, attr_name|
-          if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
-            validate_param!(attr_name, resource_params)
+            validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
           end
         end
-      end
 
-      private
+        private
 
-      # return true if we might be able to dup this object
-      def duplicatable?(obj)
-        !obj.nil? &&
-          obj != true &&
-          obj != false &&
-          !obj.is_a?(Symbol) &&
-          !obj.is_a?(Numeric)
-      end
+        # return true if we might be able to dup this object
+        def duplicatable?(obj)
+          !obj.nil? &&
+            obj != true &&
+            obj != false &&
+            !obj.is_a?(Symbol) &&
+            !obj.is_a?(Numeric)
+        end
 
-      # make a best effort to dup the object
-      def duplicate(obj)
-        obj.dup
-      rescue TypeError
-        obj
+        # make a best effort to dup the object
+        def duplicate(obj)
+          obj.dup
+        rescue TypeError
+          obj
+        end
       end
     end
   end