grape 1.6.0 → 1.6.1

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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'array_coercer'
-require_relative 'set_coercer'
-require_relative 'primitive_coercer'
-
-module Grape
-  module Validations
-    module Types
-      # 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 self.build_coercer(type, method: nil, strict: false)
-        cache_instance(type, method, strict) do
-          create_coercer_instance(type, method, strict)
-        end
-      end
-
-      def self.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 self.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 self.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/validators/all_or_none.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'grape/validations/validators/multiple_params_base'
-
-module Grape
-  module Validations
-    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

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    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

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    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

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'grape/validations/validators/multiple_params_base'
-
-module Grape
-  module Validations
-    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

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  class API
-    class Boolean
-      def self.build(val)
-        return nil if val != true && val != false
-
-        new
-      end
-    end
-
-    class Instance
-      Boolean = Grape::API::Boolean
-    end
-  end
-
-  module Validations
-    class CoerceValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        super
-
-        @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
-                       type
-                     else
-                       Types.build_coercer(type, method: @option[:method])
-                     end
-      end
-
-      def validate_param!(attr_name, params)
-        raise validation_exception(attr_name) unless params.is_a? Hash
-
-        new_value = coerce_value(params[attr_name])
-
-        raise validation_exception(attr_name, new_value.message) 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]>
-        return if params[attr_name].instance_of?(new_value.class) && params[attr_name] == new_value
-
-        params[attr_name] = new_value
-      end
-
-      private
-
-      # @!attribute [r] converter
-      # Object that will be used for parameter coercion and type checking.
-      #
-      # See {Types.build_coercer}
-      #
-      # @return [Object]
-      attr_reader :converter
-
-      def valid_type?(val)
-        !val.is_a?(Types::InvalidValue)
-      end
-
-      def coerce_value(val)
-        converter.call(val)
-      # Some custom types might fail, so it should be treated as an invalid value
-      rescue StandardError
-        Types::InvalidValue.new
-      end
-
-      # Type to which the parameter will be coerced.
-      #
-      # @return [Class]
-      def type
-        @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
-      end
-
-      def validation_exception(attr_name, custom_msg = nil)
-        Grape::Exceptions::Validation.new(
-          params: [@scope.full_name(attr_name)],
-          message: custom_msg || message(:coerce)
-        )
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    class DefaultValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        @default = options
-        super
-      end
-
-      def validate_param!(attr_name, params)
-        params[attr_name] = if @default.is_a? Proc
-                              @default.call
-                            elsif @default.frozen? || !duplicatable?(@default)
-                              @default
-                            else
-                              duplicate(@default)
-                            end
-      end
-
-      def validate!(params)
-        attrs = SingleAttributeIterator.new(self, @scope, params)
-        attrs.each do |resource_params, attr_name|
-          next unless @scope.meets_dependency?(resource_params, params)
-
-          validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
-        end
-      end
-
-      private
-
-      # return true if we might be able to dup this object
-      def duplicatable?(obj)
-        !obj.nil? &&
-          obj != true &&
-          obj != false &&
-          !obj.is_a?(Symbol) &&
-          !obj.is_a?(Numeric)
-      end
-
-      # make a best effort to dup the object
-      def duplicate(obj)
-        obj.dup
-      rescue TypeError
-        obj
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'grape/validations/validators/multiple_params_base'
-
-module Grape
-  module Validations
-    class ExactlyOneOfValidator < MultipleParamsBase
-      def validate_params!(params)
-        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
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    class ExceptValuesValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        @except = options.is_a?(Hash) ? options[:value] : options
-        super
-      end
-
-      def validate_param!(attr_name, params)
-        return unless params.respond_to?(:key?) && params.key?(attr_name)
-
-        excepts = @except.is_a?(Proc) ? @except.call : @except
-        return if excepts.nil?
-
-        param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-        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
-end

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

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

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

@@ -1,13 +0,0 @@
-# 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.new(params: [@scope.full_name(attr_name)], message: message(:presence))
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# 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.match?((options_key?(:value) ? @option[:value] : @option)) }
-
-        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# 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.new(
-          params: [@scope.full_name(attr_name)],
-          message: build_message
-        )
-      end
-
-      private
-
-      def build_message
-        if options_key?(:message)
-          @option[:message]
-        else
-          format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    class ValuesValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        if options.is_a?(Hash)
-          @excepts = options[:except]
-          @values = options[:value]
-          @proc = options[:proc]
-
-          warn '[DEPRECATION] The values validator except option is deprecated. ' \
-               'Use the except validator instead.' if @excepts
-
-          raise ArgumentError, 'proc must be a Proc' if @proc && !@proc.is_a?(Proc)
-
-          warn '[DEPRECATION] The values validator proc option is deprecated. ' \
-               'The lambda expression can now be assigned directly to values.' if @proc
-        else
-          @excepts = nil
-          @values = nil
-          @proc = nil
-          @values = options
-        end
-        super
-      end
-
-      def validate_param!(attr_name, params)
-        return unless params.is_a?(Hash)
-
-        val = params[attr_name]
-
-        return if val.nil? && !required_for_root_scope?
-
-        # don't forget that +false.blank?+ is true
-        return if val != false && val.blank? && @allow_blank
-
-        param_array = val.nil? ? [nil] : Array.wrap(val)
-
-        raise validation_exception(attr_name, except_message) \
-          unless check_excepts(param_array)
-
-        raise validation_exception(attr_name, message(:values)) \
-          unless check_values(param_array, attr_name)
-
-        raise validation_exception(attr_name, message(:values)) \
-          if @proc && !param_array.all? { |param| @proc.call(param) }
-      end
-
-      private
-
-      def check_values(param_array, attr_name)
-        values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
-        return true if values.nil?
-
-        begin
-          return param_array.all? { |param| values.call(param) } if values.is_a? Proc
-        rescue StandardError => e
-          warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
-          return false
-        end
-        param_array.all? { |param| values.include?(param) }
-      end
-
-      def check_excepts(param_array)
-        excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
-        return true if excepts.nil?
-
-        param_array.none? { |param| excepts.include?(param) }
-      end
-
-      def except_message
-        options = instance_variable_get(:@option)
-        options_key?(:except_message) ? options[:except_message] : message(:except_values)
-      end
-
-      def required_for_root_scope?
-        @required && @scope.root?
-      end
-
-      def validation_exception(attr_name, message)
-        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
-      end
-    end
-  end
-end