grape 2.4.0 → 4.0.1

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,12 +5,14 @@ module Grape
     class SingleAttributeIterator < AttributesIterator
       private
 
-      def yield_attributes(val, attrs)
+      def yield_attributes(val)
         return if skip?(val)
 
-        attrs.each do |attr_name|
-          yield val, attr_name, empty?(val)
-        end
+        # The emptiness of the scope's params is the same answer for every
+        # attribute in it, and answering it costs a +respond_to?+, so it is
+        # asked once for the whole list rather than once per attribute.
+        empty_val = empty?(val)
+        @attrs.each { |attr_name| yield val, attr_name, empty_val }
       end
 
       # Primitives like Integers and Booleans don't respond to +empty?+.

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

@@ -7,16 +7,17 @@ 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
-          @subtype = type.first
+          @coercer = strict ? DryTypes::Strict::Array : DryTypes::Params::Array
+          # Built eagerly: instances are shared across requests (and cached in
+          # Types::CoercerCache), so no lazy state may be created at call time.
+          @elem_coercer = DryTypeCoercer.coercer_instance_for(type.first, strict:)
         end
 
         def call(_val)
@@ -28,7 +29,7 @@ module Grape
 
         protected
 
-        attr_reader :subtype
+        attr_reader :elem_coercer
 
         def coerce_elements(collection)
           return if collection.nil?
@@ -51,10 +52,6 @@ module Grape
         def reject?(val)
           val.nil?
         end
-
-        def elem_coercer
-          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict)
-        end
       end
     end
   end

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

@@ -33,6 +33,12 @@ module Grape
       # contract as +coerced?+, and must be supplied with a coercion
       # +method+.
       class CustomTypeCoercer
+        extend Grape::Util::FreezeOnNew
+
+        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 +47,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 +71,54 @@ 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
+
+        # +dup+ before +map!+: the collection is whatever the user's coercion
+        # method returned — possibly frozen, possibly the input itself — so we
+        # must not mutate it in place. +dup+ also preserves the class, keeping a
+        # +Set+ a +Set+ (unlike +map+, which would return an +Array+).
+        def collection_symbolizer(method)
+          ->(val) { method.call(val).dup.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,20 +1,15 @@
 # frozen_string_literal: true
 
-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
+        extend Grape::Util::FreezeOnNew
+
         class << self
           # Returns a collection coercer which corresponds to a given type.
           # Example:
@@ -28,21 +23,21 @@ module Grape
             when Set
               SetCoercer
             else
-              raise ArgumentError, "Unknown type: #{type}"
+              raise ArgumentError, "unknown type: `#{type}`"
             end
           end
 
           # Returns an instance of a coercer for a given type
-          def coercer_instance_for(type, strict = false)
+          def coercer_instance_for(type, strict: false)
             klass = type.instance_of?(Class) ? PrimitiveCoercer : collection_coercer_for(type)
-            klass.new(type, strict)
+            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
@@ -53,13 +48,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

@@ -17,9 +17,7 @@ module Grape
           # @return [Hash,Array<Hash>,nil]
           def parse(input)
             return input if parsed?(input)
-
-            # Allow nulls and blank strings
-            return if input.nil? || input.match?(/^\s*$/)
+            return if input.blank?
 
             JSON.parse(input, symbolize_names: true)
           end

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

@@ -13,6 +13,8 @@ module Grape
       # an allowed type it should be declared last, since it will always
       # successfully "coerce" the value.
       class MultipleTypeCoercer
+        extend Grape::Util::FreezeOnNew
+
         # Construct a new coercer that will attempt to coerce
         # values to the given list of types in the given order.
         #
@@ -28,7 +30,7 @@ module Grape
             else
               Types.build_coercer type, strict: !@method.nil?
             end
-          end
+          end.freeze
         end
 
         # Coerces the given value.
@@ -39,12 +41,12 @@ module Grape
         #   of {InvalidValue} if the value could not be coerced.
         def call(val)
           # once the value is coerced by the custom method, its type should be checked
-          val = @method.call(val) if @method
+          candidate = @method ? @method.call(val) : val
 
           coerced_val = InvalidValue.new
 
           @type_coercers.each do |coercer|
-            coerced_val = coercer.call(val)
+            coerced_val = coercer.call(candidate)
 
             return coerced_val unless coerced_val.is_a?(InvalidValue)
           end

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

@@ -7,42 +7,23 @@ 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),
+        # The input classes Virtus refused for a given declared type, keyed by
+        # that type. Resolved once in #initialize rather than re-derived from
+        # +type+ on every value: the answer only ever depends on the
+        # declaration, and every coerced attribute of every request asks.
+        REJECTED_INPUTS = { String => [Array, Hash].freeze, Hash => [String].freeze }.freeze
 
-          # 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]
+          @rejected_inputs = REJECTED_INPUTS[type]
+          @treat_empty_as_nil = type != String
         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
@@ -56,16 +37,16 @@ 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)
+          return false unless @rejected_inputs
+
+          @rejected_inputs.any? { |klass| val.is_a?(klass) }
         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
+          @treat_empty_as_nil && val == ''
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Grape
       # 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,11 @@ module Grape
       # This class wraps {MultipleTypeCoercer}, for use with collections
       # that allow members of more than one type.
       class VariantCollectionCoercer
+        extend Grape::Util::FreezeOnNew
+
+        # @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 +31,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
@@ -35,15 +48,15 @@ module Grape
         def call(value)
           return unless value.is_a? Array
 
-          value =
+          coerced =
             if @method
               @method.call(value)
             else
               value.map { |v| @member_coercer.call(v) }
             end
-          return Set.new value if @types.is_a? Set
+          return Set.new coerced if @types.is_a? Set
 
-          value
+          coerced
         end
       end
     end

data/lib/grape/validations/types.rb

@@ -75,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
@@ -98,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?
@@ -117,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)
@@ -155,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.
+        mapped = map_special(type)
 
-        return @__cache[key] if @__cache.key?(key)
+        # Multiply-typed parameters, e.g. types: [Integer, String].
+        return MultipleTypeCoercer.new(mapped, method) if multiple?(mapped)
 
-        instance = yield
+        # User-supplied coercion method, or a custom type with its own #parse.
+        return CustomTypeCoercer.new(mapped, method) if method || custom?(mapped)
 
-        @__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(mapped.first), set: mapped.is_a?(Set)) if collection_of_custom?(mapped)
 
-        instance
+        # Fallback: let dry-types handle primitives, structures, and known specials.
+        DryTypeCoercer.coercer_instance_for(mapped, 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