grape 1.2.5 → 1.3.0

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

@@ -1,12 +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, to handle collections of types that
-      # provide their own parsing (and optionally,
-      # type-checking) functionality.
-      #
       # See {CustomTypeCoercer} for details on types
       # that will be supported by this by this coercer.
       # This coercer works in the same way as +CustomTypeCoercer+
@@ -38,32 +34,21 @@ module Grape
           @set = set
         end
 
-        # This method is called from somewhere within
-        # +Virtus::Attribute::coerce+ in order to coerce
-        # the given value.
+        # Coerces the given value.
         #
         # @param value [Array<String>] an array of values to be coerced
         # @return [Array,Set] the coerced result. May be an +Array+ or a
         #   +Set+ depending on the setting given to the constructor
         def call(value)
-          coerced = value.map { |item| super(item) }
+          coerced = value.map do |item|
+            coerced_item = super(item)
 
-          @set ? Set.new(coerced) : coerced
-        end
+            return coerced_item if coerced_item.is_a?(InvalidValue)
 
-        # This method is called from somewhere within
-        # +Virtus::Attribute::value_coerced?+ in order to assert
-        # that the all of the values in the array have been coerced
-        # successfully.
-        #
-        # @param primitive [Axiom::Types::Type] primitive type for
-        #   the coercion as deteced by axiom-types' inference system.
-        # @param value [Enumerable] a coerced result returned from {#call}
-        # @return [true,false] whether or not all of the coerced values in
-        #   the collection satisfy type requirements.
-        def success?(primitive, value)
-          value.is_a?(@set ? Set : Array) &&
-            value.all? { |item| super(primitive, item) }
+            coerced_item
+          end
+
+          @set ? Set.new(coerced) : coerced
         end
       end
     end

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

@@ -0,0 +1,41 @@
+# 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/
+      class DryTypeCoercer
+        def initialize(type, strict = false)
+          @type = type
+          @scope = strict ? DryTypes::Strict : DryTypes::Params
+        end
+
+        # Coerces the given value to a type which was specified during
+        # initialization as a type argument.
+        #
+        # @param val [Object]
+        def call(val)
+          @coercer[val]
+        rescue Dry::Types::CoercionError => _e
+          InvalidValue.new
+        end
+
+        protected
+
+        attr_reader :scope, :type
+      end
+    end
+  end
+end

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

@@ -1,21 +1,22 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     module Types
-      # +Virtus::Attribute+ implementation for parameters
-      # that are multipart file objects. Actual handling
-      # of these objects is provided by +Rack::Request+;
-      # this class is here only to assert that rack's
-      # handling has succeeded, and to prevent virtus
-      # from interfering.
-      class File < Virtus::Attribute
-        def coerce(input)
+      # Implementation for parameters that are multipart file objects.
+      # Actual handling of these objects is provided by +Rack::Request+;
+      # this class is here only to assert that rack's handling has succeeded.
+      class File
+        def call(input)
+          return InvalidValue.new unless coerced?(input)
+
           # Processing of multipart file objects
           # is already taken care of by Rack::Request.
           # Nothing to do here.
           input
         end
 
-        def value_coerced?(value)
+        def coerced?(value)
           # Rack::Request creates a Hash with filename,
           # content type and an IO object. Do a bit of basic
           # duck-typing.

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

@@ -1,21 +1,24 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module Grape
   module Validations
     module Types
-      # +Virtus::Attribute+ implementation that handles coercion
-      # and type checking for parameters that are complex types
-      # given as JSON-encoded strings. It accepts both JSON objects
+      # Handles coercion and type checking for parameters that are complex
+      # types given as JSON-encoded strings. It accepts both JSON objects
       # and arrays of objects, and will coerce the input to a +Hash+
       # or +Array+ object respectively. In either case the Grape
       # validation system will apply nested validation rules to
       # all returned objects.
-      class Json < Virtus::Attribute
+      class Json
         # Coerce the input into a JSON-like data structure.
         #
         # @param input [String] a JSON-encoded parameter value
         # @return [Hash,Array<Hash>,nil]
-        def coerce(input)
+        def call(input)
+          return input if coerced?(input)
+
           # Allow nulls and blank strings
           return if input.nil? || input =~ /^\s*$/
           JSON.parse(input, symbolize_names: true)
@@ -26,7 +29,7 @@ module Grape
         #
         # @param value [Object] result of {#coerce}
         # @return [true,false]
-        def value_coerced?(value)
+        def coerced?(value)
           value.is_a?(::Hash) || coerced_collection?(value)
         end
 
@@ -50,13 +53,13 @@ module Grape
         #
         # @param input [String] JSON-encoded parameter value
         # @return [Array<Hash>]
-        def coerce(input)
+        def call(input)
           json = super
           Array.wrap(json) unless json.nil?
         end
 
         # See {Json#coerced_collection?}
-        def value_coerced?(value)
+        def coerced?(value)
           coerced_collection? value
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     module Types
@@ -22,53 +24,32 @@ module Grape
 
           @type_coercers = types.map do |type|
             if Types.multiple? type
-              VariantCollectionCoercer.new type
+              VariantCollectionCoercer.new type, @method
             else
-              Types.build_coercer type
+              Types.build_coercer type, strict: !@method.nil?
             end
           end
         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
+        # @param val [String] value to be coerced, in grape
         #   this should always be a string.
         # @return [Object,InvalidValue] the coerced result, or an instance
         #   of {InvalidValue} if the value could not be coerced.
-        def call(value)
-          return @method.call(value) if @method
+        def call(val)
+          # once the value is coerced by the custom method, its type should be checked
+          val = @method.call(val) if @method
+
+          coerced_val = InvalidValue.new
 
           @type_coercers.each do |coercer|
-            coerced = coercer.coerce(value)
+            coerced_val = coercer.call(val)
 
-            return coerced if coercer.value_coerced? coerced
+            return coerced_val unless coerced_val.is_a?(InvalidValue)
           end
 
-          # Declare that we couldn't coerce the value in such a way
-          # that Grape won't ask us again if the value is valid
-          InvalidValue.new
-        end
-
-        # This method is called from somewhere within
-        # +Virtus::Attribute::value_coerced?+ in order to
-        # assert that the value has been coerced successfully.
-        # Due to Grape's design this will in fact only be called
-        # if a custom coercion method is being used, since {#call}
-        # returns an {InvalidValue} object if the value could not
-        # be coerced.
-        #
-        # @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_coercers.any? { |coercer| coercer.value_coerced? value }
+          coerced_val
         end
       end
     end

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

@@ -0,0 +1,58 @@
+# 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.
+      class PrimitiveCoercer < DryTypeCoercer
+        MAPPING = {
+          Grape::API::Boolean => DryTypes::Params::Bool,
+
+          # unfortunatelly, a +Params+ scope doesn't contain String
+          String              => DryTypes::Coercible::String
+        }.freeze
+
+        STRICT_MAPPING = {
+          Grape::API::Boolean => DryTypes::Strict::Bool
+        }.freeze
+
+        def initialize(type, strict = false)
+          super
+
+          @type = type
+
+          @coercer = if strict
+                       STRICT_MAPPING.fetch(type) { scope.const_get(type.name) }
+                     else
+                       MAPPING.fetch(type) { scope.const_get(type.name) }
+                     end
+        end
+
+        def call(val)
+          return InvalidValue.new if reject?(val)
+          return nil if val.nil?
+          return '' if val == ''
+
+          super
+        end
+
+        protected
+
+        attr_reader :type
+
+        # This method maintaine 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'dry_type_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 < DryTypeCoercer
+        def initialize(type, strict = false)
+          super
+
+          @elem_coercer = PrimitiveCoercer.new(type.first, strict)
+        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,7 +32,7 @@ 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)
+        def call(value)
           return InvalidValue.new unless value.is_a? Array
 
           value =
@@ -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/validator_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ValidatorFactory

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
@@ -6,7 +8,7 @@ module Grape
       def validate_params!(params)
         keys = keys_in_common(params)
         return if keys.empty? || keys.length == all_keys.length
-        raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AllowBlankValidator < Base
@@ -9,7 +11,7 @@ module Grape
 
         return if value == false || value.present?
 
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:blank)
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
       end
     end
   end

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
@@ -5,7 +7,7 @@ module Grape
     class AtLeastOneOfValidator < MultipleParamsBase
       def validate_params!(params)
         return unless keys_in_common(params).empty?
-        raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
       end
     end
   end