grape 1.5.0 → 1.6.0

data/lib/grape/validations/params_scope.rb

@@ -13,6 +13,8 @@ module Grape
       # @param opts [Hash] options for this scope
       # @option opts :element [Symbol] the element that contains this scope; for
       #   this to be relevant, @parent must be set
+      # @option opts :element_renamed [Symbol, nil] whenever this scope should
+      #   be renamed and to what, given +nil+ no renaming is done
       # @option opts :parent [ParamsScope] the scope containing this scope
       # @option opts :api [API] the API endpoint to modify
       # @option opts :optional [Boolean] whether or not this scope needs to have
@@ -23,23 +25,24 @@ module Grape
       #   validate if this param is present in the parent scope
       # @yield the instance context, open for parameter definitions
       def initialize(opts, &block)
-        @element      = opts[:element]
-        @parent       = opts[:parent]
-        @api          = opts[:api]
-        @optional     = opts[:optional] || false
-        @type         = opts[:type]
-        @group        = opts[:group] || {}
-        @dependent_on = opts[:dependent_on]
+        @element          = opts[:element]
+        @element_renamed  = opts[:element_renamed]
+        @parent           = opts[:parent]
+        @api              = opts[:api]
+        @optional         = opts[:optional] || false
+        @type             = opts[:type]
+        @group            = opts[:group] || {}
+        @dependent_on     = opts[:dependent_on]
         @declared_params = []
         @index = nil
 
-        instance_eval(&block) if block_given?
+        instance_eval(&block) if block
 
         configure_declared_params
       end
 
       def configuration
-        @api.configuration.evaluate
+        @api.configuration.respond_to?(:evaluate) ? @api.configuration.evaluate : @api.configuration
       end
 
       # @return [Boolean] whether or not this entire scope needs to be
@@ -50,19 +53,19 @@ module Grape
         return false if @optional && (scoped_params.blank? || all_element_blank?(scoped_params))
         return false unless meets_dependency?(scoped_params, parameters)
         return true if parent.nil?
+
         parent.should_validate?(parameters)
       end
 
       def meets_dependency?(params, request_params)
         return true unless @dependent_on
 
-        if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
-          return false
-        end
+        return false if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
 
         return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
-        return false unless params.respond_to?(:with_indifferent_access)
-        params = params.with_indifferent_access
+
+        # params might be anything what looks like a hash, so it must implement a `key?` method
+        return false unless params.respond_to?(:key?)
 
         @dependent_on.each do |dependency|
           if dependency.is_a?(Hash)
@@ -128,18 +131,35 @@ module Grape
         if lateral?
           @parent.push_declared_params(attrs, **opts)
         else
-          if opts && opts[:as]
-            @api.route_setting(:renamed_params, @api.route_setting(:renamed_params) || [])
-            @api.route_setting(:renamed_params) << { attrs.first => opts[:as] }
-            attrs = [opts[:as]]
-          end
+          push_renamed_param(full_path + [attrs.first], opts[:as]) \
+            if opts && opts[:as]
 
           @declared_params.concat attrs
         end
       end
 
+      # Get the full path of the parameter scope in the hierarchy.
+      #
+      # @return [Array<Symbol>] the nesting/path of the current parameter scope
+      def full_path
+        nested? ? @parent.full_path + [@element] : []
+      end
+
       private
 
+      # Add a new parameter which should be renamed when using the +#declared+
+      # method.
+      #
+      # @param path [Array<String, Symbol>] the full path of the parameter
+      #   (including the parameter name as last array element)
+      # @param new_name [String, Symbol] the new name of the parameter (the
+      #   renamed name, with the +as: ...+ semantic)
+      def push_renamed_param(path, new_name)
+        base = @api.route_setting(:renamed_params) || {}
+        base[Array(path).map(&:to_s)] = new_name.to_s
+        @api.route_setting(:renamed_params, base)
+      end
+
       def require_required_and_optional_fields(context, opts)
         if context == :all
           optional_fields = Array(opts[:except])
@@ -151,6 +171,7 @@ module Grape
         required_fields.each do |field|
           field_opts = opts[:using][field]
           raise ArgumentError, "required field not exist: #{field}" unless field_opts
+
           requires(field, field_opts)
         end
         optional_fields.each do |field|
@@ -190,11 +211,12 @@ module Grape
         end
 
         self.class.new(
-          api:      @api,
-          element:  attrs[1][:as] || attrs.first,
-          parent:   self,
+          api: @api,
+          element: attrs.first,
+          element_renamed: attrs[1][:as],
+          parent: self,
           optional: optional,
-          type:     type || Array,
+          type: type || Array,
           &block
         )
       end
@@ -208,11 +230,11 @@ module Grape
       # @yield parameter scope
       def new_lateral_scope(options, &block)
         self.class.new(
-          api:          @api,
-          element:      nil,
-          parent:       self,
-          options:      @optional,
-          type:         type == Array ? Array : Hash,
+          api: @api,
+          element: nil,
+          parent: self,
+          options: @optional,
+          type: type == Array ? Array : Hash,
           dependent_on: options[:dependent_on],
           &block
         )
@@ -225,15 +247,17 @@ module Grape
       # @yield parameter scope
       def new_group_scope(attrs, &block)
         self.class.new(
-          api:          @api,
-          parent:       self,
-          group:        attrs.first,
+          api: @api,
+          parent: self,
+          group: attrs.first,
           &block
         )
       end
 
       # Pushes declared params to parent or settings
       def configure_declared_params
+        push_renamed_param(full_path, @element_renamed) if @element_renamed
+
         if nested?
           @parent.push_declared_params [element => @declared_params]
         else
@@ -282,16 +306,15 @@ module Grape
 
         doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation)
 
-        full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
-        @api.document_attribute(full_attrs, doc_attrs)
+        document_attribute(attrs, doc_attrs)
 
         opts = derive_validator_options(validations)
 
+        order_specific_validations = Set[:as]
+
         # Validate for presence before any other validators
-        if validations.key?(:presence) && validations[:presence]
-          validate('presence', validations[:presence], attrs, doc_attrs, opts)
-          validations.delete(:presence)
-          validations.delete(:message) if validations.key?(:message)
+        validates_presence(validations, attrs, doc_attrs, opts) do |validation_type|
+          order_specific_validations << validation_type
         end
 
         # Before we run the rest of the validators, let's handle
@@ -300,6 +323,8 @@ module Grape
         coerce_type validations, attrs, doc_attrs, opts
 
         validations.each do |type, options|
+          next if order_specific_validations.include?(type)
+
           validate(type, options, attrs, doc_attrs, opts)
         end
       end
@@ -318,9 +343,7 @@ module Grape
       # @return [class-like] type to which the parameter will be coerced
       # @raise [ArgumentError] if the given type options are invalid
       def infer_coercion(validations)
-        if validations.key?(:type) && validations.key?(:types)
-          raise ArgumentError, ':type may not be supplied with :types'
-        end
+        raise ArgumentError, ':type may not be supplied with :types' if validations.key?(:type) && validations.key?(:types)
 
         validations[:coerce] = (options_key?(:type, :value, validations) ? validations[:type][:value] : validations[:type]) if validations.key?(:type)
         validations[:coerce_message] = (options_key?(:type, :message, validations) ? validations[:type][:message] : nil) if validations.key?(:type)
@@ -356,6 +379,7 @@ module Grape
         # but not special JSON types, which
         # already imply coercion method
         return unless [JSON, Array[JSON]].include? validations[:coerce]
+
         raise ArgumentError, 'coerce_with disallowed for type: JSON'
       end
 
@@ -383,6 +407,7 @@ module Grape
 
       def guess_coerce_type(coerce_type, *values_list)
         return coerce_type unless coerce_type == Array
+
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
           return values.first.class if values.is_a?(Range) || !values.empty?
@@ -393,14 +418,11 @@ module Grape
       def check_incompatible_option_values(default, values, except_values, excepts)
         return unless default && !default.is_a?(Proc)
 
-        if values && !values.is_a?(Proc)
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) \
-            unless Array(default).all? { |def_val| values.include?(def_val) }
-        end
+        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) if values && !values.is_a?(Proc) && !Array(default).all? { |def_val| values.include?(def_val) }
 
-        if except_values && !except_values.is_a?(Proc)
+        if except_values && !except_values.is_a?(Proc) && Array(default).any? { |def_val| except_values.include?(def_val) }
           raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values) \
-            unless Array(default).none? { |def_val| except_values.include?(def_val) }
+
         end
 
         return unless excepts && !excepts.is_a?(Proc)
@@ -414,11 +436,11 @@ module Grape
         raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
 
         validator_options = {
-          attributes:      attrs,
-          options:         options,
-          required:        doc_attrs[:required],
-          params_scope:    self,
-          opts:            opts,
+          attributes: attrs,
+          options: options,
+          required: doc_attrs[:required],
+          params_scope: self,
+          opts: opts,
           validator_class: validator_class
         }
         @api.namespace_stackable(:validations, validator_options)
@@ -426,21 +448,20 @@ module Grape
 
       def validate_value_coercion(coerce_type, *values_list)
         return unless coerce_type
+
         coerce_type = coerce_type.first if coerce_type.is_a?(Array)
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
+
           value_types = values.is_a?(Range) ? [values.begin, values.end] : values
-          if coerce_type == Grape::API::Boolean
-            value_types = value_types.map { |type| Grape::API::Boolean.build(type) }
-          end
-          unless value_types.all? { |v| v.is_a? coerce_type }
-            raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
-          end
+          value_types = value_types.map { |type| Grape::API::Boolean.build(type) } if coerce_type == Grape::API::Boolean
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values) unless value_types.all?(coerce_type)
         end
       end
 
       def extract_message_option(attrs)
         return nil unless attrs.is_a?(Array)
+
         opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
         opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil
       end
@@ -460,9 +481,22 @@ module Grape
 
         {
           allow_blank: allow_blank.is_a?(Hash) ? allow_blank[:value] : allow_blank,
-          fail_fast:   validations.delete(:fail_fast) || false
+          fail_fast: validations.delete(:fail_fast) || false
         }
       end
+
+      def validates_presence(validations, attrs, doc_attrs, opts)
+        return unless validations.key?(:presence) && validations[:presence]
+
+        validate(:presence, validations[:presence], attrs, doc_attrs, opts)
+        yield :presence
+        yield :message if validations.key?(:message)
+      end
+
+      def document_attribute(attrs, doc_attrs)
+        full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
+        @api.document_attribute(full_attrs, doc_attrs)
+      end
     end
   end
 end

data/lib/grape/validations/single_attribute_iterator.rb

@@ -7,7 +7,7 @@ module Grape
 
       def yield_attributes(val, attrs)
         attrs.each do |attr_name|
-          yield val, attr_name, empty?(val)
+          yield val, attr_name, empty?(val), skip?(val)
         end
       end
 

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

@@ -52,10 +52,11 @@ module Grape
         #   this should always be a string.
         # @return [Object] the coerced result
         def call(val)
-          return if val.nil?
-
           coerced_val = @method.call(val)
+
+          return coerced_val if coerced_val.is_a?(InvalidValue)
           return InvalidValue.new unless coerced?(coerced_val)
+
           coerced_val
         end
 

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

@@ -35,7 +35,7 @@ module Grape
 
           # 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
+            return PrimitiveCoercer.new(type, strict) if type.instance_of?(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

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

@@ -22,6 +22,7 @@ module Grape
 
             # Allow nulls and blank strings
             return if input.nil? || input.match?(/^\s*$/)
+
             JSON.parse(input, symbolize_names: true)
           end
 
@@ -41,7 +42,7 @@ module Grape
           # @param value [Object] result of {#parse}
           # @return [true,false]
           def coerced_collection?(value)
-            value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash }
+            value.is_a?(::Array) && value.all?(::Hash)
           end
         end
       end

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

@@ -11,15 +11,15 @@ module Grape
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
           Grape::API::Boolean => DryTypes::Params::Bool,
-          BigDecimal          => DryTypes::Params::Decimal,
+          BigDecimal => DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String              => DryTypes::Coercible::String
+          String => DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {
           Grape::API::Boolean => DryTypes::Strict::Bool,
-          BigDecimal          => DryTypes::Strict::Decimal
+          BigDecimal => DryTypes::Strict::Decimal
         }.freeze
 
         def initialize(type, strict = false)

data/lib/grape/validations/types.rb

@@ -7,6 +7,7 @@ require_relative 'types/multiple_type_coercer'
 require_relative 'types/variant_collection_coercer'
 require_relative 'types/json'
 require_relative 'types/file'
+require_relative 'types/invalid_value'
 
 module Grape
   module Validations
@@ -21,10 +22,6 @@ module Grape
     # and {Grape::Dsl::Parameters#optional}. The main
     # entry point for this process is {Types.build_coercer}.
     module Types
-      # Instances of this class may be used as tokens to denote that
-      # a parameter value could not be coerced.
-      class InvalidValue; end
-
       # Types representing a single value, which are coerced.
       PRIMITIVES = [
         # Numerical

data/lib/grape/validations/validator_factory.rb

@@ -8,7 +8,7 @@ module Grape
                                       options[:options],
                                       options[:required],
                                       options[:params_scope],
-                                      options[:opts])
+                                      **options[:opts])
       end
     end
   end

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

@@ -8,6 +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.new(params: all_keys, message: message(:all_or_none))
       end
     end

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

@@ -3,14 +3,10 @@
 module Grape
   module Validations
     class AsValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        @renamed_options = options
-        super
-      end
-
-      def validate_param!(attr_name, params)
-        params[@renamed_options] = params[attr_name]
-      end
+      # 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

@@ -7,6 +7,7 @@ module Grape
     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

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

@@ -12,14 +12,15 @@ module Grape
       # @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)
+      # @param opts [Array] 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
+        opts = opts.any? ? opts.shift : {}
+        @fail_fast = opts.fetch(:fail_fast, false)
+        @allow_blank = opts.fetch(:allow_blank, false)
       end
 
       # Validates a given request.
@@ -29,6 +30,7 @@ module Grape
       # @return [void]
       def validate(request)
         return unless @scope.should_validate?(request.params)
+
         validate!(request.params)
       end
 
@@ -43,17 +45,19 @@ module Grape
         # there may be more than one error per field
         array_errors = []
 
-        attributes.each do |val, attr_name, empty_val|
+        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)
+            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, array_errors if array_errors.any?
+        raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
       end
 
       def self.convert_to_short_name(klass)
@@ -67,6 +71,7 @@ module Grape
 
       def self.inherited(klass)
         return unless klass.name.present?
+
         Validations.register_validator(convert_to_short_name(klass), klass)
       end
 

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

@@ -17,7 +17,7 @@ module Grape
 
   module Validations
     class CoerceValidator < Base
-      def initialize(*_args)
+      def initialize(attrs, options, required, scope, **opts)
         super
 
         @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
@@ -27,16 +27,12 @@ module Grape
                      end
       end
 
-      def validate(request)
-        super
-      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) unless valid_type?(new_value)
+        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
@@ -47,7 +43,7 @@ module Grape
         #     h[:list] = list
         #     h
         #     => #<Hashie::Mash list=[1, 2, 3, 4]>
-        return if params[attr_name].class == new_value.class && params[attr_name] == new_value
+        return if params[attr_name].instance_of?(new_value.class) && params[attr_name] == new_value
 
         params[attr_name] = new_value
       end
@@ -80,8 +76,11 @@ module Grape
         @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
       end
 
-      def validation_exception(attr_name)
-        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:coerce))
+      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

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

@@ -22,6 +22,7 @@ module Grape
         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

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

@@ -9,6 +9,7 @@ module Grape
         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

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

@@ -7,7 +7,9 @@ module Grape
         attributes = MultipleAttributesIterator.new(self, @scope, params)
         array_errors = []
 
-        attributes.each do |resource_params|
+        attributes.each do |resource_params, skip_value|
+          next if skip_value
+
           begin
             validate_params!(resource_params)
           rescue Grape::Exceptions::Validation => e
@@ -15,13 +17,14 @@ module Grape
           end
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
+        raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
       end
 
       private
 
       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
 

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

@@ -8,6 +8,7 @@ module Grape
       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

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

@@ -5,6 +5,7 @@ module Grape
     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

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

@@ -6,6 +6,7 @@ module Grape
       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

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

@@ -6,6 +6,7 @@ module Grape
       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