grape 1.2.5 → 1.3.0

data/lib/grape/util/reverse_stackable_values.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'stackable_values'
 
 module Grape

data/lib/grape/util/stackable_values.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base_inheritable'
 
 module Grape
@@ -11,6 +13,7 @@ module Grape
         @frozen_values = {}
       end
 
+      # Even if there is no value, an empty array will be returned.
       def [](name)
         return @frozen_values[name] if @frozen_values.key? name
 

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) || [])
@@ -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,12 @@ module Grape
         Time,
 
         # Misc
-        Virtus::Attribute::Boolean,
+        Grape::API::Boolean,
         String,
         Symbol,
-        Rack::Multipart::UploadedFile
+        Rack::Multipart::UploadedFile,
+        TrueClass,
+        FalseClass
       ].freeze
 
       # Types representing data structures.
@@ -86,8 +85,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 +101,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,7 +130,6 @@ module Grape
         !primitive?(type) &&
           !structure?(type) &&
           !multiple?(type) &&
-          !recognized?(type) &&
           !special?(type) &&
           type.respond_to?(:parse) &&
           type.method(:parse).arity == 1

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

@@ -0,0 +1,56 @@
+# 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
+      # anything else.
+      #
+      # 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
+        def initialize(type, strict = false)
+          super
+
+          @coercer = scope::Array
+          @elem_coercer = PrimitiveCoercer.new(type.first, strict)
+        end
+
+        def call(_val)
+          collection = super
+
+          return collection if collection.is_a?(InvalidValue)
+
+          coerce_elements collection
+        end
+
+        protected
+
+        def coerce_elements(collection)
+          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 maintaine logic which was defined by Virtus for arrays.
+        # Virtus doesn't allow nil in arrays.
+        def reject?(val)
+          val.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -1,78 +1,75 @@
+# 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.
       #
-      # 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::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.
       #
-      # See {CustomTypeCoercer} for further details
-      # about coercion and type-checking inference.
+      # +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+.
+      #
+      # +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.
+      #
+      # 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)
         # 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(
+          Types::CustomTypeCollectionCoercer.new(
             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]
+          Types::SPECIAL[type].new
+        elsif type.is_a?(Array)
+          ArrayCoercer.new type, strict
+        elsif type.is_a?(Set)
+          SetCoercer.new type, strict
+        else
+          PrimitiveCoercer.new 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 +82,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)
+          return if val.nil?
+
+          coerced_val = @method.call(val)
+          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)
+          @type_check.call val
         end
 
         private
@@ -160,8 +126,8 @@ module Grape
           # Collections have all values processed individually
           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