grape 1.2.5 → 1.4.0

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'dry_type_coercer'
+
+module Grape
+  module Validations
+    module Types
+      # Coerces the given value to a type defined via a +type+ argument during
+      # initialization. When +strict+ is true, it doesn't coerce a value but check
+      # that it has the proper type.
+      class PrimitiveCoercer < DryTypeCoercer
+        MAPPING = {
+          Grape::API::Boolean => DryTypes::Params::Bool,
+          BigDecimal          => DryTypes::Params::Decimal,
+
+          # unfortunately, a +Params+ scope doesn't contain String
+          String              => DryTypes::Coercible::String
+        }.freeze
+
+        STRICT_MAPPING = {
+          Grape::API::Boolean => DryTypes::Strict::Bool,
+          BigDecimal          => DryTypes::Strict::Decimal
+        }.freeze
+
+        def initialize(type, strict = false)
+          super
+
+          @type = type
+
+          @coercer = if strict
+                       STRICT_MAPPING.fetch(type) { scope.const_get(type.name) }
+                     else
+                       MAPPING.fetch(type) { scope.const_get(type.name) }
+                     end
+        end
+
+        def call(val)
+          return InvalidValue.new if reject?(val)
+          return nil if val.nil? || treat_as_nil?(val)
+
+          super
+        end
+
+        protected
+
+        attr_reader :type
+
+        # This method maintains logic which was defined by Virtus. For example,
+        # dry-types is ok to convert an array or a hash to a string, it is supported,
+        # but Virtus wouldn't accept it. So, this method only exists to not introduce
+        # breaking changes.
+        def reject?(val)
+          (val.is_a?(Array) && type == String) ||
+            (val.is_a?(String) && type == Hash) ||
+            (val.is_a?(Hash) && type == String)
+        end
+
+        # Dry-Types treats an empty string as invalid. However, Grape considers an empty string as
+        # 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 != String
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'array_coercer'
+
+module Grape
+  module Validations
+    module Types
+      # Takes the given array and converts it to a set. Every element of the set
+      # is also coerced.
+      class SetCoercer < ArrayCoercer
+        register_collection Set
+
+        def initialize(type, strict = false)
+          super
+
+          @coercer = nil
+        end
+
+        def call(value)
+          return InvalidValue.new unless value.is_a?(Array)
+
+          coerce_elements(value)
+        end
+
+        protected
+
+        def coerce_elements(collection)
+          collection.each_with_object(Set.new) do |elem, memo|
+            coerced_elem = elem_coercer.call(elem)
+
+            return coerced_elem if coerced_elem.is_a?(InvalidValue)
+
+            memo.add(coerced_elem)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     module Types
       # This class wraps {MultipleTypeCoercer}, for use with collections
       # that allow members of more than one type.
-      class VariantCollectionCoercer < Virtus::Attribute
+      class VariantCollectionCoercer
         # Construct a new coercer that will attempt to coerce
         # a list of values such that all members are of one of
         # the given types. The container may also optionally be
@@ -30,8 +32,8 @@ module Grape
         # @return [Array<Object>,Set<Object>,InvalidValue]
         #   the coerced result, or an instance
         #   of {InvalidValue} if the value could not be coerced.
-        def coerce(value)
-          return InvalidValue.new unless value.is_a? Array
+        def call(value)
+          return unless value.is_a? Array
 
           value =
             if @method
@@ -43,16 +45,6 @@ module Grape
 
           value
         end
-
-        # Assert that the value has been coerced successfully.
-        #
-        # @param value [Object] a coerced result returned from {#coerce}
-        # @return [true,false] whether or not the coerced value
-        #   satisfies type requirements.
-        def value_coerced?(value)
-          value.is_a?(@types.class) &&
-            value.all? { |v| @member_coercer.success?(@types, v) }
-        end
       end
     end
   end

data/lib/grape/validations/validator_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ValidatorFactory

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
@@ -6,7 +8,7 @@ module Grape
       def validate_params!(params)
         keys = keys_in_common(params)
         return if keys.empty? || keys.length == all_keys.length
-        raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
       end
     end
   end

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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AsValidator < Base

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
@@ -5,7 +7,7 @@ module Grape
     class AtLeastOneOfValidator < MultipleParamsBase
       def validate_params!(params)
         return unless keys_in_common(params).empty?
-        raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
+        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
@@ -17,6 +19,7 @@ module Grape
         @required = required
         @scope = scope
         @fail_fast = opts[:fail_fast] || false
+        @allow_blank = opts[:allow_blank] || false
       end
 
       # Validates a given request.
@@ -40,12 +43,12 @@ module Grape
         # 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 @scope.meets_dependency?(resource_params, params)
+        attributes.each do |val, attr_name, empty_val|
+          next if !@scope.required? && empty_val
+          next unless @scope.meets_dependency?(val, params)
           begin
-            if @required || resource_params.respond_to?(:key?) && resource_params.key?(attr_name)
-              validate_param!(attr_name, resource_params)
+            if @required || val.respond_to?(:key?) && val.key?(attr_name)
+              validate_param!(attr_name, val)
             end
           rescue Grape::Exceptions::Validation => e
             array_errors << e

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

@@ -1,9 +1,17 @@
+# 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 = Virtus::Attribute::Boolean
+      Boolean = Grape::API::Boolean
     end
   end
 
@@ -11,7 +19,12 @@ module Grape
     class CoerceValidator < Base
       def initialize(*_args)
         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)
@@ -19,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) 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
 
@@ -33,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
 
@@ -69,9 +80,8 @@ 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)
+        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:coerce))
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class DefaultValidator < Base
@@ -7,7 +9,6 @@ module Grape
       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)

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

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
     class ExactlyOneOfValidator < MultipleParamsBase
       def validate_params!(params)
-        return if keys_in_common(params).length == 1
-        raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
+        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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ExceptValuesValidator < Base
@@ -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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class MultipleParamsBase < Base

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
@@ -6,7 +8,7 @@ module Grape
       def validate_params!(params)
         keys = keys_in_common(params)
         return if keys.length <= 1
-        raise Grape::Exceptions::Validation, params: keys, message: message(:mutual_exclusion)
+        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