grape 1.2.5 → 1.4.0

data/lib/grape/util/strict_hash_configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     module StrictHashConfiguration

data/lib/grape/util/xml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   if Object.const_defined? :MultiXml
     Xml = ::MultiXml

data/lib/grape/validations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   # Registry to store and locate known Validators.
   module Validations

data/lib/grape/validations/attributes_iterator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AttributesIterator
@@ -29,9 +31,7 @@ module Grape
 
           if @scope.type == Array
             next unless @original_params.is_a?(Array) # do not validate content of array if it isn't array
-            inside_array = true
-          end
-          if inside_array
+
             # fill current and parent scopes with correct array indicies
             parent_scope = @scope.parent
             parent_indicies.each do |parent_index|

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class MultipleAttributesIterator < AttributesIterator

data/lib/grape/validations/params_scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ParamsScope
@@ -43,8 +45,10 @@ module Grape
       # @return [Boolean] whether or not this entire scope needs to be
       #   validated
       def should_validate?(parameters)
-        return false if @optional && (params(parameters).blank? || all_element_blank?(parameters))
-        return false unless meets_dependency?(params(parameters), parameters)
+        scoped_params = params(parameters)
+
+        return false if @optional && (scoped_params.blank? || all_element_blank?(scoped_params))
+        return false unless meets_dependency?(scoped_params, parameters)
         return true if parent.nil?
         parent.should_validate?(parameters)
       end
@@ -121,7 +125,7 @@ module Grape
       # @param attrs [Array] (see Grape::DSL::Parameters#requires)
       def push_declared_params(attrs, **opts)
         if lateral?
-          @parent.push_declared_params(attrs, opts)
+          @parent.push_declared_params(attrs, **opts)
         else
           if opts && opts[:as]
             @api.route_setting(:renamed_params, @api.route_setting(:renamed_params) || [])
@@ -233,14 +237,14 @@ module Grape
           @parent.push_declared_params [element => @declared_params]
         else
           @api.namespace_stackable(:declared_params, @declared_params)
-
-          @api.route_setting(:declared_params, []) unless @api.route_setting(:declared_params)
-          @api.route_setting(:declared_params, @api.namespace_stackable(:declared_params).flatten)
         end
+
+        # params were stored in settings, it can be cleaned from the params scope
+        @declared_params = nil
       end
 
       def validates(attrs, validations)
-        doc_attrs = { required: validations.keys.include?(:presence) }
+        doc_attrs = { required: validations.key?(:presence) }
 
         coerce_type = infer_coercion(validations)
 
@@ -280,9 +284,7 @@ module Grape
         full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
         @api.document_attribute(full_attrs, doc_attrs)
 
-        # slice out fail_fast attribute
-        opts = {}
-        opts[:fail_fast] = validations.delete(:fail_fast) || false
+        opts = derive_validator_options(validations)
 
         # Validate for presence before any other validators
         if validations.key?(:presence) && validations[:presence]
@@ -427,8 +429,8 @@ module Grape
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
           value_types = values.is_a?(Range) ? [values.begin, values.end] : values
-          if coerce_type == Virtus::Attribute::Boolean
-            value_types = value_types.map { |type| Virtus::Attribute.build(type) }
+          if coerce_type == Grape::API::Boolean
+            value_types = value_types.map { |type| Grape::API::Boolean.build(type) }
           end
           unless value_types.all? { |v| v.is_a? coerce_type }
             raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
@@ -446,8 +448,19 @@ module Grape
         validations[type].respond_to?(:key?) && validations[type].key?(key) && !validations[type][key].nil?
       end
 
-      def all_element_blank?(parameters)
-        params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
+      def all_element_blank?(scoped_params)
+        scoped_params.respond_to?(:all?) && scoped_params.all?(&:blank?)
+      end
+
+      # Validators don't have access to each other and they don't need, however,
+      # some validators might influence others, so their options should be shared
+      def derive_validator_options(validations)
+        allow_blank = validations[:allow_blank]
+
+        {
+          allow_blank: allow_blank.is_a?(Hash) ? allow_blank[:value] : allow_blank,
+          fail_fast:   validations.delete(:fail_fast) || false
+        }
       end
     end
   end

data/lib/grape/validations/single_attribute_iterator.rb

@@ -1,13 +1,24 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class SingleAttributeIterator < AttributesIterator
       private
 
-      def yield_attributes(resource_params, attrs)
+      def yield_attributes(val, attrs)
         attrs.each do |attr_name|
-          yield resource_params, attr_name
+          yield val, attr_name, empty?(val)
         end
       end
+
+      # Primitives like Integers and Booleans don't respond to +empty?+.
+      # It could be possible to use +blank?+ instead, but
+      #
+      #     false.blank?
+      #     => true
+      def empty?(val)
+        val.respond_to?(:empty?) ? val.empty? : val.nil?
+      end
     end
   end
 end

data/lib/grape/validations/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'types/build_coercer'
 require_relative 'types/custom_type_coercer'
 require_relative 'types/custom_type_collection_coercer'
@@ -6,10 +8,6 @@ require_relative 'types/variant_collection_coercer'
 require_relative 'types/json'
 require_relative 'types/file'
 
-# Patch for Virtus::Attribute::Collection
-# See the file for more details
-require_relative 'types/virtus_collection_patch'
-
 module Grape
   module Validations
     # Module for code related to grape's system for
@@ -27,8 +25,7 @@ module Grape
       # a parameter value could not be coerced.
       class InvalidValue; end
 
-      # Types representing a single value, which are coerced through Virtus
-      # or special logic in Grape.
+      # Types representing a single value, which are coerced.
       PRIMITIVES = [
         # Numerical
         Integer,
@@ -42,10 +39,11 @@ module Grape
         Time,
 
         # Misc
-        Virtus::Attribute::Boolean,
+        Grape::API::Boolean,
         String,
         Symbol,
-        Rack::Multipart::UploadedFile
+        TrueClass,
+        FalseClass
       ].freeze
 
       # Types representing data structures.
@@ -55,8 +53,7 @@ module Grape
         Set
       ].freeze
 
-      # Types for which Grape provides special coercion
-      # and type-checking logic.
+      # Special custom types provided by Grape.
       SPECIAL = {
         JSON => Json,
         Array[JSON] => JsonArray,
@@ -86,8 +83,6 @@ module Grape
       # @param type [Class] type to check
       # @return [Boolean] whether or not the type is known by Grape as a valid
       #   data structure type
-      # @note This method does not yet consider 'complex types', which inherit
-      #   Virtus.model.
       def self.structure?(type)
         STRUCTURES.include?(type)
       end
@@ -104,25 +99,6 @@ module Grape
         (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1
       end
 
-      # Does the given class implement a type system that Grape
-      # (i.e. the underlying virtus attribute system) supports
-      # out-of-the-box? Currently supported are +axiom-types+
-      # and +virtus+.
-      #
-      # The type will be passed to +Virtus::Attribute.build+,
-      # and the resulting attribute object will be expected to
-      # respond correctly to +coerce+ and +value_coerced?+.
-      #
-      # @param type [Class] type to check
-      # @return [Boolean] +true+ where the type is recognized
-      def self.recognized?(type)
-        return false if type.is_a?(Array) || type.is_a?(Set)
-
-        type.is_a?(Virtus::Attribute) ||
-          type.ancestors.include?(Axiom::Types::Type) ||
-          type.include?(Virtus::Model::Core)
-      end
-
       # Does Grape provide special coercion and validation
       # routines for the given class? This does not include
       # automatic handling for primitives, structures and
@@ -152,8 +128,6 @@ module Grape
         !primitive?(type) &&
           !structure?(type) &&
           !multiple?(type) &&
-          !recognized?(type) &&
-          !special?(type) &&
           type.respond_to?(:parse) &&
           type.method(:parse).arity == 1
       end
@@ -166,7 +140,11 @@ module Grape
       def self.collection_of_custom?(type)
         (type.is_a?(Array) || type.is_a?(Set)) &&
           type.length == 1 &&
-          custom?(type.first)
+          (custom?(type.first) || special?(type.first))
+      end
+
+      def self.map_special(type)
+        SPECIAL.fetch(type, type)
       end
     end
   end

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,            {})