grape 1.8.0 → 3.3.5

data/lib/grape/validations/shared_options.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Immutable value object holding the two options every validator reads at
+    # construction time: +allow_blank+ and +fail_fast+. Internal to
+    # {Validators::Base}, which builds it from the +opts+ Hash so the public
+    # 5th-argument contract stays a plain Hash — not part of any wire contract.
+    #
+    # Defaults mirror the prior +opts.values_at+ behaviour: +allow_blank+ is
+    # +nil+ when the declaration didn't supply it (validators treat nil as
+    # "not set"), +fail_fast+ defaults to +false+.
+    SharedOptions = Data.define(:allow_blank, :fail_fast) do
+      def initialize(allow_blank: nil, fail_fast: false)
+        super
+      end
+    end
+  end
+end

data/lib/grape/validations/single_attribute_iterator.rb

@@ -5,10 +5,10 @@ module Grape
     class SingleAttributeIterator < AttributesIterator
       private
 
-      def yield_attributes(val, attrs)
+      def yield_attributes(val)
         return if skip?(val)
 
-        attrs.each do |attr_name|
+        @attrs.each do |attr_name|
           yield val, attr_name, empty?(val)
         end
       end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types
@@ -9,15 +7,14 @@ module Grape
       # 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/)
+      # method (https://dry-rb.org/gems/dry-types/main/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
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           super
-
-          @coercer = scope::Array
+          @coercer = strict ? DryTypes::Strict::Array : DryTypes::Params::Array
           @subtype = type.first
         end
 
@@ -55,7 +52,7 @@ module Grape
         end
 
         def elem_coercer
-          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict)
+          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict:)
         end
       end
     end

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

@@ -33,6 +33,10 @@ module Grape
       # contract as +coerced?+, and must be supplied with a coercion
       # +method+.
       class CustomTypeCoercer
+        TYPE_CHECK_METHODS = %i[coerced? parsed?].freeze
+        COLLECTION_TYPES = [Array, Set].freeze
+        private_constant :TYPE_CHECK_METHODS, :COLLECTION_TYPES
+
         # A new coercer for the given type specification
         # and coercion method.
         #
@@ -41,8 +45,7 @@ module Grape
         # @param method [#parse,#call]
         #   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
+          @method = build_coercion_method(type, method)
           @type_check = infer_type_check(type)
         end
 
@@ -66,97 +69,50 @@ module Grape
 
         private
 
-        # Determine the coercion method we're expected to use
-        # based on the parameters given.
-        #
-        # @param type see #new
-        # @param method see #new
-        # @return [#call] coercion method
+        def build_coercion_method(type, method)
+          coercion_method = infer_coercion_method(type, method)
+          return hash_symbolizer(coercion_method) if type == Hash
+          return collection_symbolizer(coercion_method) if COLLECTION_TYPES.include?(type)
+
+          coercion_method
+        end
+
         def infer_coercion_method(type, method)
-          if method
-            if method.respond_to? :parse
-              method.method :parse
-            else
-              method
-            end
-          else
-            # Try to use parse() declared on the target type.
-            # This may raise an exception, but we are out of ideas anyway.
-            type.method :parse
-          end
+          return type.method(:parse) unless method
+          return method unless method.respond_to?(:parse)
+
+          method.method(:parse)
+        end
+
+        def hash_symbolizer(method)
+          ->(val) { method.call(val).deep_symbolize_keys }
+        end
+
+        def collection_symbolizer(method)
+          ->(val) { method.call(val).map! { |item| symbolize_if_hash(item) } }
+        end
+
+        def symbolize_if_hash(item)
+          item.is_a?(Hash) ? item.deep_symbolize_keys : item
         end
 
-        # Determine how the type validity of a coerced
-        # value should be decided.
-        #
-        # @param type see #new
-        # @return [#call] a procedure which accepts a single parameter
-        #   and returns +true+ if the passed object is of the correct type.
         def infer_type_check(type)
-          # First check for special class methods
-          if type.respond_to? :coerced?
-            type.method :coerced?
-          elsif type.respond_to? :parsed?
-            type.method :parsed?
-          elsif type.respond_to? :call
-            # Arbitrary proc passed for type validation.
-            # Note that this will fail unless a method is also
-            # passed, or if the type also implements a parse() method.
-            type
-          elsif type.is_a?(Enumerable)
-            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
+          method_name = TYPE_CHECK_METHODS.detect { |m| type.respond_to?(m) }
+          return type.method(method_name) if method_name
+          return type if type.respond_to?(:call)
+          return enumerable_type_check(type) if type.is_a?(Enumerable)
+
+          ->(value) { value.is_a? type }
         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
+        def enumerable_type_check(type)
+          ->(value) { value.is_a?(Enumerable) && value.all? { |val| recursive_type_check(type.first, val) } }
         end
 
-        # Enforce symbolized keys for complex types
-        # by wrapping the coercion method such that
-        # any Hash objects in the immediate heirarchy
-        # have their keys recursively symbolized.
-        # This helps common libs such as JSON to work easily.
-        #
-        # @param type see #new
-        # @param method see #infer_coercion_method
-        # @return [#call] +method+ wrapped in an additional
-        #   key-conversion step, or just returns +method+
-        #   itself if no conversion is deemed to be
-        #   necessary.
-        def enforce_symbolized_keys(type, method)
-          # Collections have all values processed individually
-          if [Array, Set].include?(type)
-            lambda do |val|
-              method.call(val).tap do |new_val|
-                new_val.map do |item|
-                  item.is_a?(Hash) ? item.deep_symbolize_keys : item
-                end
-              end
-            end
-
-          # Hash objects are processed directly
-          elsif type == Hash
-            lambda do |val|
-              method.call(val).deep_symbolize_keys
-            end
-
-          # Simple types are not processed.
-          # This includes Array<primitive> types.
-          else
-            method
-          end
+        def recursive_type_check(type, value)
+          return value.all? { |val| recursive_type_check(type.first, val) } if type.is_a?(Enumerable) && value.is_a?(Enumerable)
+
+          !type.is_a?(Enumerable) && value.is_a?(type)
         end
       end
     end

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

@@ -29,7 +29,7 @@ module Grape
         # @param set [Boolean]
         #   when true, a +Set+ will be returned by {#call} instead
         #   of an +Array+ and duplicate items will be discarded.
-        def initialize(type, set = false)
+        def initialize(type, set: false)
           super(type)
           @set = set
         end

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

@@ -1,21 +1,12 @@
 # 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/
+      # https://dry-rb.org/gems/dry-types/main/built-in-types/
       class DryTypeCoercer
         class << self
           # Returns a collection coercer which corresponds to a given type.
@@ -24,31 +15,27 @@ module Grape
           #    collection_coercer_for(Array)
           #    #=> Grape::Validations::Types::ArrayCoercer
           def collection_coercer_for(type)
-            collection_coercers.fetch(type) do
-              DryTypeCoercer.collection_coercers[type] = Grape::Validations::Types.const_get("#{type.name.camelize}Coercer")
+            case type
+            when Array
+              ArrayCoercer
+            when Set
+              SetCoercer
+            else
+              raise ArgumentError, "Unknown type: #{type}"
             end
           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.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
-            collection_coercer_for(type.class).new(type, strict)
-          end
-
-          protected
-
-          def collection_coercers
-            @collection_coercers ||= {}
+          def coercer_instance_for(type, strict: false)
+            klass = type.instance_of?(Class) ? PrimitiveCoercer : collection_coercer_for(type)
+            klass.new(type, strict:)
           end
         end
 
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           @type = type
           @strict = strict
-          @scope = strict ? DryTypes::Strict : DryTypes::Params
+          @cache_coercer = strict ? DryTypes::StrictCache : DryTypes::ParamsCache
         end
 
         # Coerces the given value to a type which was specified during
@@ -59,13 +46,13 @@ module Grape
           return if val.nil?
 
           @coercer[val]
-        rescue Dry::Types::CoercionError => _e
+        rescue Dry::Types::CoercionError
           InvalidValue.new
         end
 
         protected
 
-        attr_reader :scope, :type, :strict
+        attr_reader :type, :strict, :cache_coercer
       end
     end
   end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Grape
   module Validations
     module Types

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types
@@ -9,42 +7,15 @@ module Grape
       # 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,
-          Numeric => DryTypes::Params::Integer | DryTypes::Params::Float | DryTypes::Params::Decimal,
-          TrueClass => DryTypes::Params::Bool.constrained(eql: true),
-          FalseClass => DryTypes::Params::Bool.constrained(eql: false),
-
-          # 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,
-          Numeric => DryTypes::Strict::Integer | DryTypes::Strict::Float | DryTypes::Strict::Decimal,
-          TrueClass => DryTypes::Strict::Bool.constrained(eql: true),
-          FalseClass => DryTypes::Strict::Bool.constrained(eql: false)
-        }.freeze
-
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           super
 
-          @type = type
-
-          @coercer = (strict ? STRICT_MAPPING : MAPPING).fetch(type) do
-            scope.const_get(type.name, false)
-          rescue NameError
-            raise ArgumentError, "type #{type} should support coercion via `[]`" unless type.respond_to?(:[])
-
-            type
-          end
+          @coercer = cache_coercer[type]
         end
 
         def call(val)
           return InvalidValue.new if reject?(val)
-          return nil if val.nil? || treat_as_nil?(val)
+          return if val.nil? || treat_as_nil?(val)
 
           super
         end
@@ -58,9 +29,14 @@ module Grape
         # 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)
+          case val
+          when Array, Hash
+            type == String
+          when String
+            type == Hash
+          else
+            false
+          end
         end
 
         # Dry-Types treats an empty string as invalid. However, Grape considers an empty string as

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

@@ -1,15 +1,12 @@
 # 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
-        def initialize(type, strict = false)
+        def initialize(type, strict: false)
           super
 
           @coercer = nil

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

@@ -6,6 +6,9 @@ module Grape
       # This class wraps {MultipleTypeCoercer}, for use with collections
       # that allow members of more than one type.
       class VariantCollectionCoercer
+        # @return [Array<Class>,Set<Class>] the member types as declared in the DSL
+        attr_reader :types
+
         # 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
@@ -26,6 +29,14 @@ module Grape
           @member_coercer = MultipleTypeCoercer.new types, method
         end
 
+        # Returns the Grape DSL notation for this coercer, e.g. "Array[Integer, String]".
+        # Distinct from the plain-array string "[Integer, String]" produced by the
+        # +types:+ keyword, which lets documentation tools tell the two apart.
+        def to_s
+          container = @types.is_a?(Set) ? 'Set' : 'Array'
+          "#{container}[#{@types.join(', ')}]"
+        end
+
         # Coerce the given value.
         #
         # @param value [Array<String>] collection of values to be coerced

data/lib/grape/validations/types.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/validations/types/json'
-require 'grape/validations/types/file'
-
 module Grape
   module Validations
     # Module for code related to grape's system for
@@ -78,7 +75,7 @@ module Grape
       # @return [Boolean] +true+ if the given value will be treated as
       #   a list of types.
       def multiple?(type)
-        (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1
+        array_or_set?(type) && type.size > 1
       end
 
       # Does Grape provide special coercion and validation
@@ -101,17 +98,18 @@ module Grape
         GROUPS.include? type
       end
 
+      def array_or_set?(type)
+        type.is_a?(Array) || type.is_a?(Set)
+      end
+
       # A valid custom type must implement a class-level `parse` method, taking
       # one String argument and returning the parsed value in its correct type.
       #
       # @param type [Class] type to check
       # @return [Boolean] whether or not the type can be used as a custom type
       def custom?(type)
-        !primitive?(type) &&
-          !structure?(type) &&
-          !multiple?(type) &&
-          type.respond_to?(:parse) &&
-          type.method(:parse).arity == 1
+        !(primitive?(type) || structure?(type) || multiple?(type)) &&
+          type.respond_to?(:parse) && type.method(:parse).arity == 1
       end
 
       # Is the declared type an +Array+ or +Set+ of a {#custom?} type?
@@ -120,9 +118,7 @@ module Grape
       # @return [Boolean] true if +type+ is a collection of a type that implements
       #   its own +#parse+ method.
       def collection_of_custom?(type)
-        (type.is_a?(Array) || type.is_a?(Set)) &&
-          type.length == 1 &&
-          (custom?(type.first) || special?(type.first))
+        array_or_set?(type) && type.length == 1 && (custom?(type.first) || special?(type.first))
       end
 
       def map_special(type)
@@ -158,59 +154,38 @@ 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
-      end
+        # no cache since unique
+        return create_coercer_instance(type, method, strict) if method.respond_to?(:call)
 
-      def 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)
-          MultipleTypeCoercer.new(type, method)
-
-          # Use a special coercer for custom types and coercion methods.
-        elsif method || Types.custom?(type)
-          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)
-          Types::CustomTypeCollectionCoercer.new(
-            Types.map_special(type.first), type.is_a?(Set)
-          )
-        else
-          DryTypeCoercer.coercer_instance_for(type, strict)
-        end
+        CoercerCache[[type, method, strict]]
       end
 
-      def cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
+      def create_coercer_instance(type, method, strict)
+        # map_special doesn't recurse into collections — applied only to the top-level type here.
+        type = map_special(type)
 
-        return @__cache[key] if @__cache.key?(key)
+        # Multiply-typed parameters, e.g. types: [Integer, String].
+        return MultipleTypeCoercer.new(type, method) if multiple?(type)
 
-        instance = yield
+        # User-supplied coercion method, or a custom type with its own #parse.
+        return CustomTypeCoercer.new(type, method) if method || custom?(type)
 
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
-        end
+        # Array/Set of a custom type — CustomTypeCoercer already handles single
+        # custom types when an explicit coercion method is supplied.
+        return CustomTypeCollectionCoercer.new(map_special(type.first), set: type.is_a?(Set)) if collection_of_custom?(type)
 
-        instance
+        # Fallback: let dry-types handle primitives, structures, and known specials.
+        DryTypeCoercer.coercer_instance_for(type, strict:)
       end
 
-      def cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
-
-          memo << '_' << val.to_s
+      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
       end
-
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end