grape 1.1.0 → 1.5.3

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)
+          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/invalid_value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Types
+      # Instances of this class may be used as tokens to denote that a parameter value could not be
+      # coerced. The given message will be used as a validation error.
+      class InvalidValue
+        attr_reader :message
+
+        def initialize(message = nil)
+          @message = message
+        end
+      end
+    end
+  end
+end
+
+# only exists to make it shorter for external use
+module Grape
+  module Types
+    InvalidValue = Class.new(Grape::Validations::Types::InvalidValue)
+  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

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

@@ -0,0 +1,67 @@
+# 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,
+
+          # 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
+        }.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? || 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,40 @@
+# 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
+        register_collection Set
+
+        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/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.rb

@@ -1,19 +1,14 @@
+# frozen_string_literal: true
+
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class AllOrNoneOfValidator < MultipleParamsBase
-      def validate!(params)
-        super
-        if scope_requires_params && only_subset_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
-        end
-        params
-      end
-
-      private
-
-      def only_subset_present
-        scoped_params.any? { |resource_params| !keys_in_common(resource_params).empty? && keys_in_common(resource_params).length < attrs.length }
+      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