grape 1.5.1 → 1.6.1

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

@@ -2,87 +2,93 @@
 
 module Grape
   module Validations
-    class Base
-      attr_reader :attrs
+    module Validators
+      class Base
+        attr_reader :attrs
 
-      # Creates a new Validator from options specified
-      # by a +requires+ or +optional+ directive during
-      # parameter definition.
-      # @param attrs [Array] names of attributes to which the Validator applies
-      # @param options [Object] implementation-dependent Validator options
-      # @param required [Boolean] attribute(s) are required or optional
-      # @param scope [ParamsScope] parent scope for this Validator
-      # @param opts [Hash] additional validation options
-      def initialize(attrs, options, required, scope, **opts)
-        @attrs = Array(attrs)
-        @option = options
-        @required = required
-        @scope = scope
-        @fail_fast = opts[:fail_fast] || false
-        @allow_blank = opts[:allow_blank] || false
-      end
+        # Creates a new Validator from options specified
+        # by a +requires+ or +optional+ directive during
+        # parameter definition.
+        # @param attrs [Array] names of attributes to which the Validator applies
+        # @param options [Object] implementation-dependent Validator options
+        # @param required [Boolean] attribute(s) are required or optional
+        # @param scope [ParamsScope] parent scope for this Validator
+        # @param opts [Array] additional validation options
+        def initialize(attrs, options, required, scope, *opts)
+          @attrs = Array(attrs)
+          @option = options
+          @required = required
+          @scope = scope
+          opts = opts.any? ? opts.shift : {}
+          @fail_fast = opts.fetch(:fail_fast, false)
+          @allow_blank = opts.fetch(:allow_blank, false)
+        end
 
-      # Validates a given request.
-      # @note Override #validate! unless you need to access the entire request.
-      # @param request [Grape::Request] the request currently being handled
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate(request)
-        return unless @scope.should_validate?(request.params)
-        validate!(request.params)
-      end
+        # Validates a given request.
+        # @note Override #validate! unless you need to access the entire request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate(request)
+          return unless @scope.should_validate?(request.params)
+
+          validate!(request.params)
+        end
 
-      # Validates a given parameter hash.
-      # @note Override #validate if you need to access the entire request.
-      # @param params [Hash] parameters to validate
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate!(params)
-        attributes = SingleAttributeIterator.new(self, @scope, params)
-        # we collect errors inside array because
-        # there may be more than one error per field
-        array_errors = []
+        # Validates a given parameter hash.
+        # @note Override #validate if you need to access the entire request.
+        # @param params [Hash] parameters to validate
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate!(params)
+          attributes = SingleAttributeIterator.new(self, @scope, params)
+          # we collect errors inside array because
+          # there may be more than one error per field
+          array_errors = []
 
-        attributes.each do |val, attr_name, empty_val, skip_value|
-          next if skip_value
-          next if !@scope.required? && empty_val
-          next unless @scope.meets_dependency?(val, params)
-          begin
-            validate_param!(attr_name, val) if @required || val.respond_to?(:key?) && val.key?(attr_name)
-          rescue Grape::Exceptions::Validation => e
-            array_errors << e
+          attributes.each do |val, attr_name, empty_val, skip_value|
+            next if skip_value
+            next if !@scope.required? && empty_val
+            next unless @scope.meets_dependency?(val, params)
+
+            begin
+              validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
+            end
           end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
-      end
+        def self.convert_to_short_name(klass)
+          ret = klass.name.gsub(/::/, '/')
+          ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          ret.tr!('-', '_')
+          ret.downcase!
+          File.basename(ret, '_validator')
+        end
 
-      def self.convert_to_short_name(klass)
-        ret = klass.name.gsub(/::/, '/')
-        ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        ret.tr!('-', '_')
-        ret.downcase!
-        File.basename(ret, '_validator')
-      end
+        def self.inherited(klass)
+          return unless klass.name.present?
 
-      def self.inherited(klass)
-        return unless klass.name.present?
-        Validations.register_validator(convert_to_short_name(klass), klass)
-      end
+          Validations.register_validator(convert_to_short_name(klass), klass)
+        end
 
-      def message(default_key = nil)
-        options = instance_variable_get(:@option)
-        options_key?(:message) ? options[:message] : default_key
-      end
+        def message(default_key = nil)
+          options = instance_variable_get(:@option)
+          options_key?(:message) ? options[:message] : default_key
+        end
 
-      def options_key?(key, options = nil)
-        options = instance_variable_get(:@option) if options.nil?
-        options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
-      end
+        def options_key?(key, options = nil)
+          options = instance_variable_get(:@option) if options.nil?
+          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+        end
 
-      def fail_fast?
-        @fail_fast
+        def fail_fast?
+          @fail_fast
+        end
       end
     end
   end

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

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

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

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

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

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

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

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

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

@@ -2,32 +2,36 @@
 
 module Grape
   module Validations
-    class MultipleParamsBase < Base
-      def validate!(params)
-        attributes = MultipleAttributesIterator.new(self, @scope, params)
-        array_errors = []
-
-        attributes.each do |resource_params, skip_value|
-          next if skip_value
-          begin
-            validate_params!(resource_params)
-          rescue Grape::Exceptions::Validation => e
-            array_errors << e
+    module Validators
+      class MultipleParamsBase < Base
+        def validate!(params)
+          attributes = MultipleAttributesIterator.new(self, @scope, params)
+          array_errors = []
+
+          attributes.each do |resource_params, skip_value|
+            next if skip_value
+
+            begin
+              validate_params!(resource_params)
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
+            end
           end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
-      end
+        private
 
-      private
+        def keys_in_common(resource_params)
+          return [] unless resource_params.is_a?(Hash)
 
-      def keys_in_common(resource_params)
-        return [] unless resource_params.is_a?(Hash)
-        all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
-      end
+          all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
+        end
 
-      def all_keys
-        attrs.map { |attr| @scope.full_name(attr) }
+        def all_keys
+          attrs.map { |attr| @scope.full_name(attr) }
+        end
       end
     end
   end

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

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

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

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

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

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

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

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

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

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

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '1.5.1'
+  VERSION = '1.6.1'
 end