grape 1.2.5 → 1.3.1

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,61 @@
+# 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,
+
+          # unfortunately, a +Params+ scope doesn't contain String
+          String              => DryTypes::Coercible::String,
+          BigDecimal          => DryTypes::Coercible::Decimal
+        }.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?
+          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/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/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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class Base
@@ -17,6 +19,7 @@ module Grape
         @required = required
         @scope = scope
         @fail_fast = opts[:fail_fast] || false
+        @allow_blank = opts[:allow_blank] || false
       end
 
       # Validates a given request.
@@ -40,12 +43,12 @@ module Grape
         # there may be more than one error per field
         array_errors = []
 
-        attributes.each do |resource_params, attr_name|
-          next if !@scope.required? && resource_params.empty?
-          next unless @scope.meets_dependency?(resource_params, params)
+        attributes.each do |val, attr_name, empty_val|
+          next if !@scope.required? && empty_val
+          next unless @scope.meets_dependency?(val, params)
           begin
-            if @required || resource_params.respond_to?(:key?) && resource_params.key?(attr_name)
-              validate_param!(attr_name, resource_params)
+            if @required || val.respond_to?(:key?) && val.key?(attr_name)
+              validate_param!(attr_name, val)
             end
           rescue Grape::Exceptions::Validation => e
             array_errors << e

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

@@ -1,9 +1,17 @@
+# frozen_string_literal: true
+
 module Grape
   class API
-    Boolean = Virtus::Attribute::Boolean
+    class Boolean
+      def self.build(val)
+        return nil if val != true && val != false
+
+        new
+      end
+    end
 
     class Instance
-      Boolean = Virtus::Attribute::Boolean
+      Boolean = Grape::API::Boolean
     end
   end
 
@@ -11,7 +19,12 @@ module Grape
     class CoerceValidator < Base
       def initialize(*_args)
         super
-        @converter = Types.build_coercer(type, @option[:method])
+
+        @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
+                       type
+                     else
+                       Types.build_coercer(type, method: @option[:method])
+                     end
       end
 
       def validate(request)
@@ -19,11 +32,22 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash
-        return unless requires_coercion?(params[attr_name])
+        raise validation_exception(attr_name) unless params.is_a? Hash
+
         new_value = coerce_value(params[attr_name])
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless valid_type?(new_value)
-        params[attr_name] = new_value
+
+        raise validation_exception(attr_name) unless valid_type?(new_value)
+
+        # Don't assign a value if it is identical. It fixes a problem with Hashie::Mash
+        # which looses wrappers for hashes and arrays after reassigning values
+        #
+        #     h = Hashie::Mash.new(list: [1, 2, 3, 4])
+        #     => #<Hashie::Mash list=#<Hashie::Array [1, 2, 3, 4]>>
+        #     list = h.list
+        #     h[:list] = list
+        #     h
+        #     => #<Hashie::Mash list=[1, 2, 3, 4]>
+        params[attr_name] = new_value unless params[attr_name] == new_value
       end
 
       private
@@ -33,32 +57,26 @@ module Grape
       #
       # See {Types.build_coercer}
       #
-      # @return [Virtus::Attribute]
+      # @return [Object]
       attr_reader :converter
 
       def valid_type?(val)
-        # Special value to denote coercion failure
-        return false if val.instance_of?(Types::InvalidValue)
-
-        # Allow nil, to ignore when a parameter is absent
-        return true if val.nil?
-
-        converter.value_coerced? val
+        !val.is_a?(Types::InvalidValue)
       end
 
       def coerce_value(val)
-        # Don't coerce things other than nil to Arrays or Hashes
-        unless (@option[:method] && !val.nil?) || type.is_a?(Virtus::Attribute)
-          return val || []      if type == Array
-          return val || Set.new if type == Set
-          return val || {}      if type == Hash
+        # define default values for structures, the dry-types lib which is used
+        # for coercion doesn't accept nil as a value, so it would fail
+        if val.nil?
+          return []      if type == Array || type.is_a?(Array)
+          return Set.new if type == Set
+          return {}      if type == Hash
         end
 
-        converter.coerce(val)
+        converter.call(val)
 
-      # not the prettiest but some invalid coercion can currently trigger
-      # errors in Virtus (see coerce_spec.rb:75)
-      rescue
+      # Some custom types might fail, so it should be treated as an invalid value
+      rescue StandardError
         Types::InvalidValue.new
       end
 
@@ -69,9 +87,8 @@ module Grape
         @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
       end
 
-      def requires_coercion?(value)
-        # JSON types do not require coercion if value is valid
-        !valid_type?(value) || converter.coercer.respond_to?(:method) && !converter.is_a?(Grape::Validations::Types::Json)
+      def validation_exception(attr_name)
+        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:coerce))
       end
     end
   end

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

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

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

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
     class ExactlyOneOfValidator < MultipleParamsBase
       def validate_params!(params)
-        return if keys_in_common(params).length == 1
-        raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
+        keys = keys_in_common(params)
+        return if keys.length == 1
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
+        raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ExceptValuesValidator < Base
@@ -13,7 +15,7 @@ module Grape
         return if excepts.nil?
 
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:except_values) if param_array.any? { |param| excepts.include?(param) }
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:except_values)) if param_array.any? { |param| excepts.include?(param) }
       end
     end
   end

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

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

data/lib/grape/validations/validators/mutual_exclusion.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.length <= 1
-        raise Grape::Exceptions::Validation, params: keys, message: message(:mutual_exclusion)
+        raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
       end
     end
   end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class PresenceValidator < Base
       def validate_param!(attr_name, params)
         return if params.respond_to?(:key?) && params.key?(attr_name)
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence)
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
       end
     end
   end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
         return unless params.respond_to?(:key?) && params.key?(attr_name)
         return if Array.wrap(params[attr_name]).all? { |param| param.nil? || (param.to_s =~ (options_key?(:value) ? @option[:value] : @option)) }
-        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp)
+        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
       end
     end
   end

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

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class SameAsValidator < Base
       def validate_param!(attr_name, params)
         confirmation = options_key?(:value) ? @option[:value] : @option
         return if params[attr_name] == params[confirmation]
-        raise Grape::Exceptions::Validation,
-              params: [@scope.full_name(attr_name)],
-              message: build_message
+        raise Grape::Exceptions::Validation.new(
+          params: [@scope.full_name(attr_name)],
+          message: build_message
+        )
       end
 
       private