grape 1.2.5 → 1.4.0

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)
+          val.nil? || @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

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,76 @@
+# 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
+        class << self
+          # Registers a collection coercer which could be found by a type,
+          # see +collection_coercer_for+ method below. This method is meant for inheritors.
+          def register_collection(type)
+            DryTypeCoercer.collection_coercers[type] = self
+          end
+
+          # Returns a collection coercer which corresponds to a given type.
+          # Example:
+          #
+          #    collection_coercer_for(Array)
+          #    #=> Grape::Validations::Types::ArrayCoercer
+          def collection_coercer_for(type)
+            collection_coercers[type]
+          end
+
+          # Returns an instance of a coercer for a given type
+          def coercer_instance_for(type, strict = false)
+            return PrimitiveCoercer.new(type, strict) if type.class == Class
+
+            # in case of a collection (Array[Integer]) the type is an instance of a collection,
+            # so we need to figure out the actual type
+            collection_coercer_for(type.class).new(type, strict)
+          end
+
+          protected
+
+          def collection_coercers
+            @collection_coercers ||= {}
+          end
+        end
+
+        def initialize(type, strict = false)
+          @type = type
+          @strict = strict
+          @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)
+          return if val.nil?
+
+          @coercer[val]
+        rescue Dry::Types::CoercionError => _e
+          InvalidValue.new
+        end
+
+        protected
+
+        attr_reader :scope, :type, :strict
+      end
+    end
+  end
+end

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

@@ -1,25 +1,29 @@
+# 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)
-          # Processing of multipart file objects
-          # is already taken care of by Rack::Request.
-          # Nothing to do here.
-          input
-        end
+      # 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
+        class << self
+          def parse(input)
+            return if input.nil?
+            return InvalidValue.new unless parsed?(input)
+
+            # Processing of multipart file objects
+            # is already taken care of by Rack::Request.
+            # Nothing to do here.
+            input
+          end
 
-        def value_coerced?(value)
-          # Rack::Request creates a Hash with filename,
-          # content type and an IO object. Do a bit of basic
-          # duck-typing.
-          value.is_a?(::Hash) && value.key?(:tempfile) && value[:tempfile].is_a?(Tempfile)
+          def parsed?(value)
+            # Rack::Request creates a Hash with filename,
+            # content type and an IO object. Do a bit of basic
+            # duck-typing.
+            value.is_a?(::Hash) && value.key?(:tempfile) && value[:tempfile].is_a?(Tempfile)
+          end
         end
       end
     end

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

@@ -1,43 +1,48 @@
+# 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
-        # 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)
-          # Allow nulls and blank strings
-          return if input.nil? || input =~ /^\s*$/
-          JSON.parse(input, symbolize_names: true)
-        end
+      class Json
+        class << self
+          # Coerce the input into a JSON-like data structure.
+          #
+          # @param input [String] a JSON-encoded parameter value
+          # @return [Hash,Array<Hash>,nil]
+          def parse(input)
+            return input if parsed?(input)
 
-        # Checks that the input was parsed successfully
-        # and isn't something odd such as an array of primitives.
-        #
-        # @param value [Object] result of {#coerce}
-        # @return [true,false]
-        def value_coerced?(value)
-          value.is_a?(::Hash) || coerced_collection?(value)
-        end
+            # Allow nulls and blank strings
+            return if input.nil? || input.match?(/^\s*$/)
+            JSON.parse(input, symbolize_names: true)
+          end
 
-        protected
+          # Checks that the input was parsed successfully
+          # and isn't something odd such as an array of primitives.
+          #
+          # @param value [Object] result of {#parse}
+          # @return [true,false]
+          def parsed?(value)
+            value.is_a?(::Hash) || coerced_collection?(value)
+          end
 
-        # Is the value an array of JSON-like objects?
-        #
-        # @param value [Object] result of {#coerce}
-        # @return [true,false]
-        def coerced_collection?(value)
-          value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash }
+          protected
+
+          # Is the value an array of JSON-like objects?
+          #
+          # @param value [Object] result of {#parse}
+          # @return [true,false]
+          def coerced_collection?(value)
+            value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash }
+          end
         end
       end
 
@@ -46,18 +51,20 @@ module Grape
       # objects and arrays of objects, but wraps single objects
       # in an Array.
       class JsonArray < Json
-        # See {Json#coerce}. Wraps single objects in an array.
-        #
-        # @param input [String] JSON-encoded parameter value
-        # @return [Array<Hash>]
-        def coerce(input)
-          json = super
-          Array.wrap(json) unless json.nil?
-        end
+        class << self
+          # See {Json#parse}. Wraps single objects in an array.
+          #
+          # @param input [String] JSON-encoded parameter value
+          # @return [Array<Hash>]
+          def parse(input)
+            json = super
+            Array.wrap(json) unless json.nil?
+          end
 
-        # See {Json#coerced_collection?}
-        def value_coerced?(value)
-          coerced_collection? value
+          # See {Json#coerced_collection?}
+          def parsed?(value)
+            coerced_collection? value
+          end
         end
       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