grape 1.1.0 → 1.5.3

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AllowBlankValidator < Base
@@ -9,7 +11,7 @@ module Grape
 
         return if value == false || value.present?
 
-        raise Grape::Exceptions::Validation, 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

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

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AsValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
-        @alias = options
+      def initialize(attrs, options, required, scope, **opts)
+        @renamed_options = options
         super
       end
 
       def validate_param!(attr_name, params)
-        params[@alias] = params[attr_name]
-        params.delete(attr_name)
+        params[@renamed_options] = params[attr_name]
       end
     end
   end

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

@@ -1,19 +1,13 @@
+# frozen_string_literal: true
+
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class AtLeastOneOfValidator < MultipleParamsBase
-      def validate!(params)
-        super
-        if scope_requires_params && no_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
-        end
-        params
-      end
-
-      private
-
-      def no_exclusive_params_are_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? }
+      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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class Base
@@ -10,13 +12,15 @@ module Grape
       # @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 = {})
+      # @param opts [Array] 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
+        opts = opts.any? ? opts.shift : {}
+        @fail_fast = opts.fetch(:fail_fast, false)
+        @allow_blank = opts.fetch(:allow_blank, false)
       end
 
       # Validates a given request.
@@ -35,31 +39,31 @@ module Grape
       # @raise [Grape::Exceptions::Validation] if validation failed
       # @return [void]
       def validate!(params)
-        attributes = AttributesIterator.new(self, @scope, 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 |resource_params, attr_name|
-          next if !@scope.required? && resource_params.empty?
-          next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
-          next unless @scope.meets_dependency?(resource_params, params)
 
+        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, resource_params)
+            validate_param!(attr_name, val) if @required || val.respond_to?(:key?) && val.key?(attr_name)
           rescue Grape::Exceptions::Validation => e
-            # we collect errors inside array because
-            # there may be more than one error per field
             array_errors << e
           end
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
+        raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
       end
 
       def self.convert_to_short_name(klass)
         ret = klass.name.gsub(/::/, '/')
-                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                   .tr('-', '_')
-                   .downcase
+        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
 

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

@@ -1,13 +1,30 @@
+# frozen_string_literal: true
+
 module Grape
   class API
-    Boolean = Virtus::Attribute::Boolean
+    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)
+      def initialize(attrs, options, required, scope, **opts)
         super
-        @converter = Types.build_coercer(type, @option[:method])
+
+        @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
+                       type
+                     else
+                       Types.build_coercer(type, method: @option[:method])
+                     end
       end
 
       def validate(request)
@@ -15,10 +32,23 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash
-        return unless requires_coercion?(params[attr_name])
+        raise validation_exception(attr_name) unless params.is_a? Hash
+
         new_value = coerce_value(params[attr_name])
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless valid_type?(new_value)
+
+        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].class == new_value.class && params[attr_name] == new_value
+
         params[attr_name] = new_value
       end
 
@@ -29,32 +59,17 @@ module Grape
       #
       # See {Types.build_coercer}
       #
-      # @return [Virtus::Attribute]
+      # @return [Object]
       attr_reader :converter
 
       def valid_type?(val)
-        # Special value to denote coercion failure
-        return false if val.instance_of?(Types::InvalidValue)
-
-        # Allow nil, to ignore when a parameter is absent
-        return true if val.nil?
-
-        converter.value_coerced? val
+        !val.is_a?(Types::InvalidValue)
       end
 
       def coerce_value(val)
-        # Don't coerce things other than nil to Arrays or Hashes
-        unless (@option[:method] && !val.nil?) || type.is_a?(Virtus::Attribute)
-          return val || []      if type == Array
-          return val || Set.new if type == Set
-          return val || {}      if type == Hash
-        end
-
-        converter.coerce(val)
-
-      # not the prettiest but some invalid coercion can currently trigger
-      # errors in Virtus (see coerce_spec.rb:75)
-      rescue
+        converter.call(val)
+      # Some custom types might fail, so it should be treated as an invalid value
+      rescue StandardError
         Types::InvalidValue.new
       end
 
@@ -65,9 +80,11 @@ module Grape
         @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
       end
 
-      def requires_coercion?(value)
-        # JSON types do not require coercion if value is valid
-        !valid_type?(value) || converter.coercer.respond_to?(:method) && !converter.is_a?(Grape::Validations::Types::Json)
+      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

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

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class DefaultValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @default = options
         super
       end
 
       def validate_param!(attr_name, params)
-        return if params.key? attr_name
         params[attr_name] = if @default.is_a? Proc
                               @default.call
                             elsif @default.frozen? || !duplicatable?(@default)
@@ -18,11 +19,10 @@ module Grape
       end
 
       def validate!(params)
-        attrs = AttributesIterator.new(self, @scope, 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)
-          end
+          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?
         end
       end
 

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

@@ -1,28 +1,15 @@
-module Grape
-  module Validations
-    require 'grape/validations/validators/mutual_exclusion'
-    class ExactlyOneOfValidator < MutualExclusionValidator
-      def validate!(params)
-        super
-        if scope_requires_params && none_of_restricted_params_is_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
-        end
-        params
-      end
+# frozen_string_literal: true
 
-      def message(default_key = nil)
-        options = instance_variable_get(:@option)
-        if options_key?(:message)
-          (options_key?(default_key, options[:message]) ? options[:message][default_key] : options[:message])
-        else
-          default_key
-        end
-      end
+require 'grape/validations/validators/multiple_params_base'
 
-      private
-
-      def none_of_restricted_params_is_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? }
+module Grape
+  module Validations
+    class ExactlyOneOfValidator < MultipleParamsBase
+      def validate_params!(params)
+        keys = keys_in_common(params)
+        return if keys.length == 1
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
+        raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
       end
     end
   end

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ExceptValuesValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @except = options.is_a?(Hash) ? options[:value] : options
         super
       end
@@ -13,7 +15,7 @@ module Grape
         return if excepts.nil?
 
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:except_values) if param_array.any? { |param| excepts.include?(param) }
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:except_values)) if param_array.any? { |param| excepts.include?(param) }
       end
     end
   end

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

@@ -1,26 +1,33 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class MultipleParamsBase < Base
-      attr_reader :scoped_params
-
       def validate!(params)
-        @scoped_params = [@scope.params(params)].flatten
-        params
-      end
+        attributes = MultipleAttributesIterator.new(self, @scope, params)
+        array_errors = []
 
-      private
+        attributes.each do |resource_params, skip_value|
+          next if skip_value
+          begin
+            validate_params!(resource_params)
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
+          end
+        end
 
-      def scope_requires_params
-        @scope.required? || scoped_params.any?(&:any?)
+        raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
       end
 
+      private
+
       def keys_in_common(resource_params)
         return [] unless resource_params.is_a?(Hash)
-        (all_keys & resource_params.stringify_keys.keys).map(&:to_s)
+        all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
       end
 
       def all_keys
-        attrs.map(&:to_s)
+        attrs.map { |attr| @scope.full_name(attr) }
       end
     end
   end

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

@@ -1,24 +1,14 @@
+# frozen_string_literal: true
+
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class MutualExclusionValidator < MultipleParamsBase
-      attr_reader :processing_keys_in_common
-
-      def validate!(params)
-        super
-        if two_or_more_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion)
-        end
-        params
-      end
-
-      private
-
-      def two_or_more_exclusive_params_are_present
-        scoped_params.any? do |resource_params|
-          @processing_keys_in_common = keys_in_common(resource_params)
-          @processing_keys_in_common.length > 1
-        end
+      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))
       end
     end
   end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class PresenceValidator < Base
       def validate_param!(attr_name, params)
         return if params.respond_to?(:key?) && params.key?(attr_name)
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence)
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
       end
     end
   end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
         return unless params.respond_to?(:key?) && params.key?(attr_name)
-        return if Array.wrap(params[attr_name]).all? { |param| param.nil? || (param.to_s =~ (options_key?(:value) ? @option[:value] : @option)) }
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp)
+        return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
       end
     end
   end