grape 1.1.0 → 1.7.1

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'dry_type_coercer'
+
+module Grape
+  module Validations
+    module Types
+      # Coerces the given value to a type defined via a +type+ argument during
+      # 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)
+          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
+        end
+
+        def call(val)
+          return InvalidValue.new if reject?(val)
+          return nil if val.nil? || treat_as_nil?(val)
+
+          super
+        end
+
+        protected
+
+        attr_reader :type
+
+        # This method maintains logic which was defined by Virtus. For example,
+        # dry-types is ok to convert an array or a hash to a string, it is supported,
+        # 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)
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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)
+          super
+
+          @coercer = nil
+        end
+
+        def call(value)
+          return InvalidValue.new unless value.is_a?(Array)
+
+          coerce_elements(value)
+        end
+
+        protected
+
+        def coerce_elements(collection)
+          collection.each_with_object(Set.new) do |elem, memo|
+            coerced_elem = elem_coercer.call(elem)
+
+            return coerced_elem if coerced_elem.is_a?(InvalidValue)
+
+            memo.add(coerced_elem)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     module Types
       # This class wraps {MultipleTypeCoercer}, for use with collections
       # that allow members of more than one type.
-      class VariantCollectionCoercer < Virtus::Attribute
+      class VariantCollectionCoercer
         # 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
@@ -30,8 +32,8 @@ module Grape
         # @return [Array<Object>,Set<Object>,InvalidValue]
         #   the coerced result, or an instance
         #   of {InvalidValue} if the value could not be coerced.
-        def coerce(value)
-          return InvalidValue.new unless value.is_a? Array
+        def call(value)
+          return unless value.is_a? Array
 
           value =
             if @method
@@ -43,16 +45,6 @@ module Grape
 
           value
         end
-
-        # Assert that the value has been coerced successfully.
-        #
-        # @param value [Object] a coerced result returned from {#coerce}
-        # @return [true,false] whether or not the coerced value
-        #   satisfies type requirements.
-        def value_coerced?(value)
-          value.is_a?(@types.class) &&
-            value.all? { |v| @member_coercer.success?(@types, v) }
-        end
       end
     end
   end

data/lib/grape/validations/types.rb

@@ -1,14 +1,7 @@
-require_relative 'types/build_coercer'
-require_relative 'types/custom_type_coercer'
-require_relative 'types/custom_type_collection_coercer'
-require_relative 'types/multiple_type_coercer'
-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'
+# frozen_string_literal: true
+
+require 'grape/validations/types/json'
+require 'grape/validations/types/file'
 
 module Grape
   module Validations
@@ -23,12 +16,8 @@ module Grape
     # and {Grape::Dsl::Parameters#optional}. The main
     # entry point for this process is {Types.build_coercer}.
     module Types
-      # Instances of this class may be used as tokens to denote that
-      # a parameter value could not be coerced.
-      class InvalidValue; end
+      module_function
 
-      # Types representing a single value, which are coerced through Virtus
-      # or special logic in Grape.
       PRIMITIVES = [
         # Numerical
         Integer,
@@ -42,41 +31,31 @@ module Grape
         Time,
 
         # Misc
-        Virtus::Attribute::Boolean,
+        Grape::API::Boolean,
         String,
         Symbol,
-        Rack::Multipart::UploadedFile
+        TrueClass,
+        FalseClass
       ].freeze
 
       # Types representing data structures.
-      STRUCTURES = [
-        Hash,
-        Array,
-        Set
-      ].freeze
+      STRUCTURES = [Hash, Array, Set].freeze
 
-      # Types for which Grape provides special coercion
-      # and type-checking logic.
       SPECIAL = {
-        JSON => Json,
+        ::JSON => Json,
         Array[JSON] => JsonArray,
         ::File => File,
         Rack::Multipart::UploadedFile => File
       }.freeze
 
-      GROUPS = [
-        Array,
-        Hash,
-        JSON,
-        Array[JSON]
-      ].freeze
+      GROUPS = [Array, Hash, JSON, Array[JSON]].freeze
 
       # Is the given class a primitive type as recognized by Grape?
       #
       # @param type [Class] type to check
       # @return [Boolean] whether or not the type is known by Grape as a valid
       #   type for a single value
-      def self.primitive?(type)
+      def primitive?(type)
         PRIMITIVES.include?(type)
       end
 
@@ -86,9 +65,7 @@ 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)
+      def structure?(type)
         STRUCTURES.include?(type)
       end
 
@@ -100,29 +77,10 @@ module Grape
       # @param type [Array<Class>,Set<Class>] type (or type list!) to check
       # @return [Boolean] +true+ if the given value will be treated as
       #   a list of types.
-      def self.multiple?(type)
+      def multiple?(type)
         (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
@@ -130,7 +88,7 @@ module Grape
       #
       # @param type [Class] type to check
       # @return [Boolean] +true+ if special routines are available
-      def self.special?(type)
+      def special?(type)
         SPECIAL.key? type
       end
 
@@ -139,7 +97,7 @@ module Grape
       #
       # @param type [Array<Class>,Class] type to check
       # @return [Boolean] +true+ if the type is a supported group type
-      def self.group?(type)
+      def group?(type)
         GROUPS.include? type
       end
 
@@ -148,12 +106,10 @@ module Grape
       #
       # @param type [Class] type to check
       # @return [Boolean] whether or not the type can be used as a custom type
-      def self.custom?(type)
+      def custom?(type)
         !primitive?(type) &&
           !structure?(type) &&
           !multiple?(type) &&
-          !recognized?(type) &&
-          !special?(type) &&
           type.respond_to?(:parse) &&
           type.method(:parse).arity == 1
       end
@@ -163,11 +119,98 @@ module Grape
       # @param type [Array<Class>,Class] type to check
       # @return [Boolean] true if +type+ is a collection of a type that implements
       #   its own +#parse+ method.
-      def self.collection_of_custom?(type)
+      def 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 map_special(type)
+        SPECIAL.fetch(type, type)
       end
+
+      # 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+.
+      #
+      # +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 [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
+
+      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
+      end
+
+      def cache_instance(type, method, strict, &_block)
+        key = cache_key(type, method, strict)
+
+        return @__cache[key] if @__cache.key?(key)
+
+        instance = yield
+
+        @__cache_write_lock.synchronize do
+          @__cache[key] = instance
+        end
+
+        instance
+      end
+
+      def 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,            {})
+      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end

data/lib/grape/validations/validator_factory.rb

@@ -1,17 +1,14 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ValidatorFactory
-      def initialize(**options)
-        @validator_class = options.delete(:validator_class)
-        @options         = options
-      end
-
-      def create_validator
-        @validator_class.new(@options[:attributes],
-                             @options[:options],
-                             @options[:required],
-                             @options[:params_scope],
-                             @options[:opts])
+      def self.create_validator(**options)
+        options[:validator_class].new(options[:attributes],
+                                      options[:options],
+                                      options[:required],
+                                      options[:params_scope],
+                                      **options[:opts])
       end
     end
   end

data/lib/grape/validations/validators/all_or_none_of_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AllOrNoneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          return if keys.empty? || keys.length == all_keys.length
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/allow_blank_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AllowBlankValidator < Base
+        def validate_param!(attr_name, params)
+          return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
+
+          value = params[attr_name]
+          value = value.strip if value.respond_to?(:strip)
+
+          return if value == false || value.present?
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/as_validator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AsValidator < Base
+        # We use a validator for renaming parameters. This is just a marker for
+        # the parameter scope to handle the renaming. No actual validation
+        # happens here.
+        def validate_param!(*); end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/at_least_one_of_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AtLeastOneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          return unless keys_in_common(params).empty?
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/base.rb

@@ -1,86 +1,102 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
-    class Base
-      attr_reader :attrs
+    module Validators
+      class Base
+        attr_reader :attrs
 
-      # Creates a new Validator from options specified
-      # by a +requires+ or +optional+ directive during
-      # parameter definition.
-      # @param attrs [Array] names of attributes to which the Validator applies
-      # @param options [Object] implementation-dependent Validator options
-      # @param required [Boolean] attribute(s) are required or optional
-      # @param scope [ParamsScope] parent scope for this Validator
-      # @param opts [Hash] additional validation options
-      def initialize(attrs, options, required, scope, opts = {})
-        @attrs = Array(attrs)
-        @option = options
-        @required = required
-        @scope = scope
-        @fail_fast = opts[:fail_fast] || false
-      end
+        # Creates a new Validator from options specified
+        # by a +requires+ or +optional+ directive during
+        # parameter definition.
+        # @param attrs [Array] names of attributes to which the Validator applies
+        # @param options [Object] implementation-dependent Validator options
+        # @param required [Boolean] attribute(s) are required or optional
+        # @param scope [ParamsScope] parent scope for this Validator
+        # @param opts [Array] additional validation options
+        def initialize(attrs, options, required, scope, *opts)
+          @attrs = Array(attrs)
+          @option = options
+          @required = required
+          @scope = scope
+          opts = opts.any? ? opts.shift : {}
+          @fail_fast = opts.fetch(:fail_fast, false)
+          @allow_blank = opts.fetch(:allow_blank, false)
+        end
 
-      # Validates a given request.
-      # @note Override #validate! unless you need to access the entire request.
-      # @param request [Grape::Request] the request currently being handled
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate(request)
-        return unless @scope.should_validate?(request.params)
-        validate!(request.params)
-      end
+        # Validates a given request.
+        # @note Override #validate! unless you need to access the entire request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate(request)
+          return unless @scope.should_validate?(request.params)
+
+          validate!(request.params)
+        end
 
-      # Validates a given parameter hash.
-      # @note Override #validate if you need to access the entire request.
-      # @param params [Hash] parameters to validate
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate!(params)
-        attributes = AttributesIterator.new(self, @scope, params)
-        array_errors = []
-        attributes.each do |resource_params, attr_name|
-          next if !@scope.required? && resource_params.empty?
-          next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
-          next unless @scope.meets_dependency?(resource_params, params)
+        # Validates a given parameter hash.
+        # @note Override #validate if you need to access the entire request.
+        # @param params [Hash] parameters to validate
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate!(params)
+          attributes = SingleAttributeIterator.new(self, @scope, params)
+          # we collect errors inside array because
+          # there may be more than one error per field
+          array_errors = []
 
-          begin
-            validate_param!(attr_name, resource_params)
-          rescue Grape::Exceptions::Validation => e
-            # we collect errors inside array because
-            # there may be more than one error per field
-            array_errors << e
+          attributes.each do |val, attr_name, empty_val, skip_value|
+            next if skip_value
+            next if !@scope.required? && empty_val
+            next unless @scope.meets_dependency?(val, params)
+
+            begin
+              validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
+            end
           end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
-      end
+        def self.convert_to_short_name(klass)
+          ret = klass.name.gsub(/::/, '/')
+          ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          ret.tr!('-', '_')
+          ret.downcase!
+          File.basename(ret, '_validator')
+        end
 
-      def self.convert_to_short_name(klass)
-        ret = klass.name.gsub(/::/, '/')
-                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                   .tr('-', '_')
-                   .downcase
-        File.basename(ret, '_validator')
-      end
+        def self.inherited(klass)
+          return unless klass.name.present?
 
-      def self.inherited(klass)
-        return unless klass.name.present?
-        Validations.register_validator(convert_to_short_name(klass), klass)
-      end
+          Validations.register_validator(convert_to_short_name(klass), klass)
+        end
 
-      def message(default_key = nil)
-        options = instance_variable_get(:@option)
-        options_key?(:message) ? options[:message] : default_key
-      end
+        def message(default_key = nil)
+          options = instance_variable_get(:@option)
+          options_key?(:message) ? options[:message] : default_key
+        end
 
-      def options_key?(key, options = nil)
-        options = instance_variable_get(:@option) if options.nil?
-        options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
-      end
+        def options_key?(key, options = nil)
+          options = instance_variable_get(:@option) if options.nil?
+          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+        end
 
-      def fail_fast?
-        @fail_fast
+        def fail_fast?
+          @fail_fast
+        end
       end
     end
   end
 end
+
+Grape::Validations::Base = Class.new(Grape::Validations::Validators::Base) do
+  def initialize(*)
+    super
+    warn '[DEPRECATION] `Grape::Validations::Base` is deprecated. Use `Grape::Validations::Validators::Base` instead.'
+  end
+end