grape 1.1.0 → 1.5.3

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'dry_type_coercer'
+
+module Grape
+  module Validations
+    module Types
+      # Coerces elements in an array. It might be an array of strings or integers or
+      # an array of arrays of integers.
+      #
+      # It could've been possible to use an +of+
+      # method (https://dry-rb.org/gems/dry-types/1.2/array-with-member/)
+      # provided by dry-types. Unfortunately, it doesn't work for Grape because of
+      # behavior of Virtus which was used earlier, a `Grape::Validations::Types::PrimitiveCoercer`
+      # maintains Virtus behavior in coercing.
+      class ArrayCoercer < DryTypeCoercer
+        register_collection Array
+
+        def initialize(type, strict = false)
+          super
+
+          @coercer = scope::Array
+          @subtype = type.first
+        end
+
+        def call(_val)
+          collection = super
+          return collection if collection.is_a?(InvalidValue)
+
+          coerce_elements collection
+        end
+
+        protected
+
+        attr_reader :subtype
+
+        def coerce_elements(collection)
+          return if collection.nil?
+
+          collection.each_with_index do |elem, index|
+            return InvalidValue.new if reject?(elem)
+
+            coerced_elem = elem_coercer.call(elem)
+
+            return coerced_elem if coerced_elem.is_a?(InvalidValue)
+
+            collection[index] = coerced_elem
+          end
+
+          collection
+        end
+
+        # This method maintains logic which was defined by Virtus for arrays.
+        # Virtus doesn't allow nil in arrays.
+        def reject?(val)
+          val.nil?
+        end
+
+        def elem_coercer
+          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict)
+        end
+      end
+    end
+  end
+end

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

@@ -1,78 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'array_coercer'
+require_relative 'set_coercer'
+require_relative 'primitive_coercer'
+
 module Grape
   module Validations
     module Types
-      # Work out the +Virtus::Attribute+ object to
-      # use for coercing strings to the given +type+.
-      # Coercion +method+ will be inferred if none is
-      # supplied.
+      # Chooses the best coercer for the given type. For example, if the type
+      # is Integer, it will return a coercer which will be able to coerce a value
+      # to the integer.
+      #
+      # There are a few very special coercers which might be returned.
+      #
+      # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
+      # the given type implies values in an array with different types.
+      # For example, +[Integer, String]+ allows integer and string values in
+      # an array.
+      #
+      # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
+      # a method is specified by a user with +coerce_with+ option or the user
+      # specifies a custom type which implements requirments of
+      # +Grape::Types::CustomTypeCoercer+.
       #
-      # If a +Virtus::Attribute+ object already built
-      # with +Virtus::Attribute.build+ is supplied as
-      # the +type+ it will be returned and +method+
-      # will be ignored.
+      # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
+      # previous one, but it expects an array or set of values having a custom
+      # type implemented by the user.
       #
-      # See {CustomTypeCoercer} for further details
-      # about coercion and type-checking inference.
+      # There is also a group of custom types implemented by Grape, check
+      # +Grape::Validations::Types::SPECIAL+ to get the full list.
       #
       # @param type [Class] the type to which input strings
       #   should be coerced
       # @param method [Class,#call] the coercion method to use
-      # @return [Virtus::Attribute] object to be used
+      # @return [Object] object to be used
       #   for coercion and type validation
-      def self.build_coercer(type, method = nil)
-        cache_instance(type, method) do
-          create_coercer_instance(type, method)
+      def self.build_coercer(type, method: nil, strict: false)
+        cache_instance(type, method, strict) do
+          create_coercer_instance(type, method, strict)
         end
       end
 
-      def self.create_coercer_instance(type, method = nil)
-        # Accept pre-rolled virtus attributes without interference
-        return type if type.is_a? Virtus::Attribute
-
-        converter_options = {
-          nullify_blank: true
-        }
-        conversion_type = if method == JSON
-                            Object
-                            # because we want just parsed JSON content:
-                            # if type is Array and data is `"{}"`
-                            # result will be [] because Virtus converts hashes
-                            # to arrays
-                          else
-                            type
-                          end
+      def self.create_coercer_instance(type, method, strict)
+        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
+        type = Types.map_special(type)
 
         # Use a special coercer for multiply-typed parameters.
         if Types.multiple?(type)
-          converter_options[:coercer] = Types::MultipleTypeCoercer.new(type, method)
-          conversion_type = Object
+          MultipleTypeCoercer.new(type, method)
 
         # Use a special coercer for custom types and coercion methods.
         elsif method || Types.custom?(type)
-          converter_options[:coercer] = Types::CustomTypeCoercer.new(type, method)
+          CustomTypeCoercer.new(type, method)
 
         # Special coercer for collections of types that implement a parse method.
         # CustomTypeCoercer (above) already handles such types when an explicit coercion
         # method is supplied.
         elsif Types.collection_of_custom?(type)
-          converter_options[:coercer] = Types::CustomTypeCollectionCoercer.new(
-            type.first, type.is_a?(Set)
+          Types::CustomTypeCollectionCoercer.new(
+            Types.map_special(type.first), type.is_a?(Set)
           )
-
-        # Grape swaps in its own Virtus::Attribute implementations
-        # for certain special types that merit first-class support
-        # (but not if a custom coercion method has been supplied).
-        elsif Types.special?(type)
-          conversion_type = Types::SPECIAL[type]
+        else
+          DryTypeCoercer.coercer_instance_for(type, strict)
         end
-
-        # Virtus will infer coercion and validation rules
-        # for many common ruby types.
-        Virtus::Attribute.build(conversion_type, converter_options)
       end
 
-      def self.cache_instance(type, method, &_block)
-        key = cache_key(type, method)
+      def self.cache_instance(type, method, strict, &_block)
+        key = cache_key(type, method, strict)
 
         return @__cache[key] if @__cache.key?(key)
 
@@ -85,8 +79,12 @@ module Grape
         instance
       end
 
-      def self.cache_key(type, method)
-        [type, method].compact.map(&:to_s).join('_')
+      def self.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,            {})

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

@@ -1,21 +1,8 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     module Types
-      # Instances of this class may be passed to
-      # +Virtus::Attribute.build+ as the +:coercer+
-      # option for custom types that do not otherwise
-      # satisfy the requirements for +Virtus::Attribute::coerce+
-      # and +Virtus::Attribute::value_coerced?+ to work
-      # as expected.
-      #
-      # Subclasses of +Virtus::Attribute+ or +Axiom::Types::Type+
-      # (or for which an axiom type can be inferred, i.e. the
-      # primitives, +Date+, +Time+, etc.) do not need any such
-      # coercer to be passed with them.
-      #
-      # Coercion
-      # --------
-      #
       # This class will detect type classes that implement
       # a class-level +parse+ method. The method should accept one
       # +String+ argument and should return the value coerced to
@@ -30,14 +17,14 @@ module Grape
       # Type Checking
       # -------------
       #
-      # Calls to +value_coerced?+ will consult this class to check
+      # Calls to +coerced?+ will consult this class to check
       # that the coerced value produced above is in fact of the
       # expected type. By default this class performs a basic check
       # against the type supplied, but this behaviour will be
       # overridden if the class implements a class-level
       # +coerced?+ or +parsed?+ method. This method
       # will receive a single parameter that is the coerced value
-      # and should return +true+ iff the value meets type expectations.
+      # and should return +true+ if the value meets type expectations.
       # Arbitrary assertions may be made here but the grape validation
       # system should be preferred.
       #
@@ -46,15 +33,6 @@ module Grape
       # contract as +coerced?+, and must be supplied with a coercion
       # +method+.
       class CustomTypeCoercer
-        # Uses +Virtus::Attribute.build+ to build a new
-        # attribute that makes use of this class for
-        # coercion and type validation logic.
-        #
-        # @return [Virtus::Attribute]
-        def self.build(type, method = nil)
-          Virtus::Attribute.build(type, coercer: new(type, method))
-        end
-
         # A new coercer for the given type specification
         # and coercion method.
         #
@@ -64,37 +42,25 @@ module Grape
         #   optional coercion method. See class docs.
         def initialize(type, method = nil)
           coercion_method = infer_coercion_method type, method
-
           @method = enforce_symbolized_keys type, coercion_method
-
           @type_check = infer_type_check(type)
         end
 
-        # This method is called from somewhere within
-        # +Virtus::Attribute::coerce+ in order to coerce
-        # the given value.
+        # Coerces the given value.
         #
         # @param value [String] value to be coerced, in grape
         #   this should always be a string.
         # @return [Object] the coerced result
-        def call(value)
-          @method.call value
+        def call(val)
+          coerced_val = @method.call(val)
+
+          return coerced_val if coerced_val.is_a?(InvalidValue)
+          return InvalidValue.new unless coerced?(coerced_val)
+          coerced_val
         end
 
-        # This method is called from somewhere within
-        # +Virtus::Attribute::value_coerced?+ in order to
-        # assert that the value has been coerced successfully.
-        #
-        # @param _primitive [Axiom::Types::Type] primitive type
-        #   for the coercion as detected by axiom-types' inference
-        #   system. For custom types this is typically not much use
-        #   (i.e. it is +Axiom::Types::Object+) unless special
-        #   inference rules have been declared for the type.
-        # @param value [Object] a coerced result returned from {#call}
-        # @return [true,false] whether or not the coerced value
-        #   satisfies type requirements.
-        def success?(_primitive, value)
-          @type_check.call value
+        def coerced?(val)
+          val.nil? || @type_check.call(val)
         end
 
         private
@@ -137,13 +103,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
@@ -158,10 +136,10 @@ module Grape
         #   necessary.
         def enforce_symbolized_keys(type, method)
           # Collections have all values processed individually
-          if type == Array || type == Set
+          if [Array, Set].include?(type)
             lambda do |val|
-              method.call(val).tap do |new_value|
-                new_value.map do |item|
+              method.call(val).tap do |new_val|
+                new_val.map do |item|
                   item.is_a?(Hash) ? symbolize_keys(item) : item
                 end
               end

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

@@ -1,12 +1,8 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     module Types
-      # Instances of this class may be passed to
-      # +Virtus::Attribute.build+ as the +:coercer+
-      # option, to handle collections of types that
-      # provide their own parsing (and optionally,
-      # type-checking) functionality.
-      #
       # See {CustomTypeCoercer} for details on types
       # that will be supported by this by this coercer.
       # This coercer works in the same way as +CustomTypeCoercer+
@@ -38,32 +34,21 @@ module Grape
           @set = set
         end
 
-        # This method is called from somewhere within
-        # +Virtus::Attribute::coerce+ in order to coerce
-        # the given value.
+        # Coerces the given value.
         #
         # @param value [Array<String>] an array of values to be coerced
         # @return [Array,Set] the coerced result. May be an +Array+ or a
         #   +Set+ depending on the setting given to the constructor
         def call(value)
-          coerced = value.map { |item| super(item) }
+          coerced = value.map do |item|
+            coerced_item = super(item)
 
-          @set ? Set.new(coerced) : coerced
-        end
+            return coerced_item if coerced_item.is_a?(InvalidValue)
 
-        # This method is called from somewhere within
-        # +Virtus::Attribute::value_coerced?+ in order to assert
-        # that the all of the values in the array have been coerced
-        # successfully.
-        #
-        # @param primitive [Axiom::Types::Type] primitive type for
-        #   the coercion as deteced by axiom-types' inference system.
-        # @param value [Enumerable] a coerced result returned from {#call}
-        # @return [true,false] whether or not all of the coerced values in
-        #   the collection satisfy type requirements.
-        def success?(primitive, value)
-          value.is_a?(@set ? Set : Array) &&
-            value.all? { |item| super(primitive, item) }
+            coerced_item
+          end
+
+          @set ? Set.new(coerced) : coerced
         end
       end
     end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module DryTypes
+  # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
+  # a container in this case. Check documentation for more information
+  # https://dry-rb.org/gems/dry-types/1.2/getting-started/
+  include Dry.Types()
+end
+
+module Grape
+  module Validations
+    module Types
+      # A base class for classes which must identify a coercer to be used.
+      # If the +strict+ argument is true, it won't coerce the given value
+      # but check its type. More information there
+      # https://dry-rb.org/gems/dry-types/1.2/built-in-types/
+      class DryTypeCoercer
+        class << self
+          # Registers a collection coercer which could be found by a type,
+          # see +collection_coercer_for+ method below. This method is meant for inheritors.
+          def register_collection(type)
+            DryTypeCoercer.collection_coercers[type] = self
+          end
+
+          # Returns a collection coercer which corresponds to a given type.
+          # Example:
+          #
+          #    collection_coercer_for(Array)
+          #    #=> Grape::Validations::Types::ArrayCoercer
+          def collection_coercer_for(type)
+            collection_coercers[type]
+          end
+
+          # 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
+
+            # in case of a collection (Array[Integer]) the type is an instance of a collection,
+            # so we need to figure out the actual type
+            collection_coercer_for(type.class).new(type, strict)
+          end
+
+          protected
+
+          def collection_coercers
+            @collection_coercers ||= {}
+          end
+        end
+
+        def initialize(type, strict = false)
+          @type = type
+          @strict = strict
+          @scope = strict ? DryTypes::Strict : DryTypes::Params
+        end
+
+        # Coerces the given value to a type which was specified during
+        # initialization as a type argument.
+        #
+        # @param val [Object]
+        def call(val)
+          return if val.nil?
+
+          @coercer[val]
+        rescue Dry::Types::CoercionError => _e
+          InvalidValue.new
+        end
+
+        protected
+
+        attr_reader :scope, :type, :strict
+      end
+    end
+  end
+end