grape 2.0.0 → 2.4.0

data/lib/grape/validations/attributes_doc.rb

@@ -2,56 +2,58 @@
 
 module Grape
   module Validations
-    class ParamsScope
-      # Documents parameters of an endpoint. If documentation isn't needed (for instance, it is an
-      # internal API), the class only cleans up attributes to avoid junk in RAM.
-      class AttributesDoc
-        attr_accessor :type, :values
-
-        # @param api [Grape::API::Instance]
-        # @param scope [Validations::ParamsScope]
-        def initialize(api, scope)
-          @api = api
-          @scope = scope
-          @type = type
-        end
+    # Documents parameters of an endpoint. If documentation isn't needed (for instance, it is an
+    # internal API), the class only cleans up attributes to avoid junk in RAM.
+
+    class AttributesDoc
+      attr_accessor :type, :values
+
+      # @param api [Grape::API::Instance]
+      # @param scope [Validations::ParamsScope]
+      def initialize(api, scope)
+        @api = api
+        @scope = scope
+        @type = type
+      end
 
-        def extract_details(validations)
-          details[:required] = validations.key?(:presence)
+      def extract_details(validations)
+        details[:required] = validations.key?(:presence)
 
-          desc = validations.delete(:desc) || validations.delete(:description)
+        desc = validations.delete(:desc) || validations.delete(:description)
 
-          details[:desc] = desc if desc
+        details[:desc] = desc if desc
 
-          documentation = validations.delete(:documentation)
+        documentation = validations.delete(:documentation)
 
-          details[:documentation] = documentation if documentation
+        details[:documentation] = documentation if documentation
 
-          details[:default] = validations[:default] if validations.key?(:default)
-        end
+        details[:default] = validations[:default] if validations.key?(:default)
 
-        def document(attrs)
-          return if @api.namespace_inheritable(:do_not_document)
+        details[:min_length] = validations[:length][:min] if validations.key?(:length) && validations[:length].key?(:min)
+        details[:max_length] = validations[:length][:max] if validations.key?(:length) && validations[:length].key?(:max)
+      end
 
-          details[:type] = type.to_s if type
-          details[:values] = values if values
+      def document(attrs)
+        return if @api.namespace_inheritable(:do_not_document)
 
-          documented_attrs = attrs.each_with_object({}) do |name, memo|
-            memo[@scope.full_name(name)] = details
-          end
+        details[:type] = type.to_s if type
+        details[:values] = values if values
 
-          @api.namespace_stackable(:params, documented_attrs)
+        documented_attrs = attrs.each_with_object({}) do |name, memo|
+          memo[@scope.full_name(name)] = details
         end
 
-        def required
-          details[:required]
-        end
+        @api.namespace_stackable(:params, documented_attrs)
+      end
+
+      def required
+        details[:required]
+      end
 
-        protected
+      protected
 
-        def details
-          @details ||= {}
-        end
+      def details
+        @details ||= {}
       end
     end
   end

data/lib/grape/validations/attributes_iterator.rb

@@ -21,6 +21,7 @@ module Grape
       private
 
       def do_each(params_to_process, parent_indicies = [], &block)
+        @scope.reset_index # gets updated depending on the size of params_to_process
         params_to_process.each_with_index do |resource_params, index|
           # when we get arrays of arrays it means that target element located inside array
           # we need this because we want to know parent arrays indicies

data/lib/grape/validations/contract_scope.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class ContractScope
+      # Declare the contract to be used for the endpoint's parameters.
+      # @param api [API] the API endpoint to modify.
+      # @param contract the contract or schema to be used for validation. Optional.
+      # @yield a block yielding a new schema class. Optional.
+      def initialize(api, contract = nil, &block)
+        # When block is passed, the first arg is either schema or nil.
+        contract = Dry::Schema.Params(parent: contract, &block) if block
+
+        if contract.respond_to?(:schema)
+          # It's a Dry::Validation::Contract, then.
+          contract = contract.new
+          key_map = contract.schema.key_map
+        else
+          # Dry::Schema::Processor, hopefully.
+          key_map = contract.key_map
+        end
+
+        api.namespace_stackable(:contract_key_map, key_map)
+
+        validator_options = {
+          validator_class: Grape::Validations.require_validator(:contract_scope),
+          opts: { schema: contract, fail_fast: false }
+        }
+
+        api.namespace_stackable(:validations, validator_options)
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'attributes_doc'
-
 module Grape
   module Validations
     class ParamsScope
       attr_accessor :element, :parent, :index
-      attr_reader :type
+      attr_reader :type, :params_meeting_dependency
 
       include Grape::DSL::Parameters
 
@@ -69,6 +67,7 @@ module Grape
         @type             = opts[:type]
         @group            = opts[:group]
         @dependent_on     = opts[:dependent_on]
+        @params_meeting_dependency = []
         @declared_params = []
         @index = nil
 
@@ -95,17 +94,18 @@ module Grape
 
       def meets_dependency?(params, request_params)
         return true unless @dependent_on
-
         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)
+        if params.is_a?(Array)
+          @params_meeting_dependency = params.flatten.filter { |param| meets_dependency?(param, request_params) }
+          return @params_meeting_dependency.present?
+        end
 
         meets_hash_dependency?(params)
       end
 
       def attr_meets_dependency?(params)
         return true unless @dependent_on
-
         return false if @parent.present? && !@parent.attr_meets_dependency?(params)
 
         meets_hash_dependency?(params)
@@ -132,7 +132,7 @@ module Grape
       def full_name(name, index: nil)
         if nested?
           # Find our containing element's name, and append ours.
-          "#{@parent.full_name(@element)}#{brackets(@index || index)}#{brackets(name)}"
+          "#{@parent.full_name(@element)}#{brackets(index || @index)}#{brackets(name)}"
         elsif lateral?
           # Find the name of the element as if it was at the same nesting level
           # as our parent. We need to forward our index upward to achieve this.
@@ -171,27 +171,33 @@ module Grape
         !@optional
       end
 
+      def reset_index
+        @index = nil
+      end
+
       protected
 
       # Adds a parameter declaration to our list of validations.
       # @param attrs [Array] (see Grape::DSL::Parameters#requires)
-      def push_declared_params(attrs, **opts)
-        opts = opts.merge(declared_params_scope: self) unless opts.key?(:declared_params_scope)
-        if lateral?
-          @parent.push_declared_params(attrs, **opts)
-        else
-          push_renamed_param(full_path + [attrs.first], opts[:as]) \
-            if opts && opts[:as]
+      def push_declared_params(attrs, opts = {})
+        opts[:declared_params_scope] = self unless opts.key?(:declared_params_scope)
+        return @parent.push_declared_params(attrs, opts) if lateral?
 
-          @declared_params.concat(attrs.map { |attr| ::Grape::Validations::ParamsScope::Attr.new(attr, opts[:declared_params_scope]) })
-        end
+        push_renamed_param(full_path + [attrs.first], opts[:as]) if opts[:as]
+        @declared_params.concat(attrs.map { |attr| ::Grape::Validations::ParamsScope::Attr.new(attr, opts[:declared_params_scope]) })
       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] : []
+        if nested?
+          (@parent.full_path + [@element])
+        elsif lateral?
+          @parent.full_path
+        else
+          []
+        end
       end
 
       private
@@ -211,11 +217,11 @@ module Grape
 
       def require_required_and_optional_fields(context, opts)
         if context == :all
-          optional_fields = Array(opts[:except])
-          required_fields = opts[:using].keys - optional_fields
+          optional_fields = Array.wrap(opts[:except])
+          required_fields = opts[:using].keys.delete_if { |f| optional_fields.include?(f) }
         else # context == :none
-          required_fields = Array(opts[:except])
-          optional_fields = opts[:using].keys - required_fields
+          required_fields = Array.wrap(opts[:except])
+          optional_fields = opts[:using].keys.delete_if { |f| required_fields.include?(f) }
         end
         required_fields.each do |field|
           field_opts = opts[:using][field]
@@ -231,7 +237,10 @@ module Grape
 
       def require_optional_fields(context, opts)
         optional_fields = opts[:using].keys
-        optional_fields -= Array(opts[:except]) unless context == :all
+        unless context == :all
+          except_fields = Array.wrap(opts[:except])
+          optional_fields.delete_if { |f| except_fields.include?(f) }
+        end
         optional_fields.each do |field|
           field_opts = opts[:using][field]
           optional(field, field_opts) if field_opts
@@ -266,6 +275,7 @@ module Grape
           parent: self,
           optional: optional,
           type: type || Array,
+          group: @group,
           &block
         )
       end
@@ -295,12 +305,7 @@ module Grape
       #   `optional` invocation that opened this scope.
       # @yield parameter scope
       def new_group_scope(attrs, &block)
-        self.class.new(
-          api: @api,
-          parent: self,
-          group: attrs.first,
-          &block
-        )
+        self.class.new(api: @api, parent: self, group: attrs.first, &block)
       end
 
       # Pushes declared params to parent or settings
@@ -463,8 +468,7 @@ module Grape
         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) && Array(default).any? { |def_val| except_values.include?(def_val) }
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values) \
-
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values)
         end
 
         return unless excepts && !excepts.is_a?(Proc)
@@ -487,7 +491,7 @@ 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)
+        coerce_type = coerce_type.first if coerce_type.is_a?(Enumerable)
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
 
@@ -526,7 +530,7 @@ module Grape
       def validates_presence(validations, attrs, doc, opts)
         return unless validations.key?(:presence) && validations[:presence]
 
-        validate(:presence, validations.delete(:presence), attrs, doc, opts)
+        validate('presence', validations.delete(:presence), attrs, doc, opts)
         validations.delete(:message) if validations.key?(:message)
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry-types'
-
 module DryTypes
   # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
   # a container in this case. Check documentation for more information
@@ -24,24 +22,20 @@ module Grape
           #    collection_coercer_for(Array)
           #    #=> Grape::Validations::Types::ArrayCoercer
           def collection_coercer_for(type)
-            collection_coercers.fetch(type) do
-              DryTypeCoercer.collection_coercers[type] = Grape::Validations::Types.const_get("#{type.name.camelize}Coercer")
+            case type
+            when Array
+              ArrayCoercer
+            when Set
+              SetCoercer
+            else
+              raise ArgumentError, "Unknown type: #{type}"
             end
           end
 
           # Returns an instance of a coercer for a given type
           def coercer_instance_for(type, strict = false)
-            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
-            collection_coercer_for(type.class).new(type, strict)
-          end
-
-          protected
-
-          def collection_coercers
-            @collection_coercers ||= {}
+            klass = type.instance_of?(Class) ? PrimitiveCoercer : collection_coercer_for(type)
+            klass.new(type, strict)
           end
         end
 

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Grape
   module Validations
     module Types

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'array_coercer'
-
 module Grape
   module Validations
     module Types

data/lib/grape/validations/types.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/validations/types/json'
-require 'grape/validations/types/file'
-
 module Grape
   module Validations
     # Module for code related to grape's system for

data/lib/grape/validations/validator_factory.rb

@@ -3,12 +3,12 @@
 module Grape
   module Validations
     class ValidatorFactory
-      def self.create_validator(**options)
+      def self.create_validator(options)
         options[:validator_class].new(options[:attributes],
                                       options[:options],
                                       options[:required],
                                       options[:params_scope],
-                                      **options[:opts])
+                                      options[:opts])
       end
     end
   end

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

@@ -8,7 +8,7 @@ module Grape
           return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
 
           value = params[attr_name]
-          value = value.strip if value.respond_to?(:strip)
+          value = value.scrub if value.respond_to?(:scrub)
 
           return if value == false || value.present?
 

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

@@ -13,15 +13,14 @@ 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 [Array] additional validation options
-        def initialize(attrs, options, required, scope, *opts)
+        # @param opts [Hash] 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)
+          @fail_fast = opts[:fail_fast]
+          @allow_blank = opts[:allow_blank]
         end
 
         # Validates a given request.
@@ -50,7 +49,7 @@ module Grape
             next if !@scope.required? && empty_val
             next unless @scope.meets_dependency?(val, params)
 
-            validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+            validate_param!(attr_name, val) if @required || val.try(:key?, attr_name)
           rescue Grape::Exceptions::Validation => e
             array_errors << e
           end
@@ -59,10 +58,8 @@ module Grape
         end
 
         def self.inherited(klass)
-          return if klass.name.blank?
-
-          short_validator_name = klass.name.demodulize.underscore.delete_suffix('_validator')
-          Validations.register_validator(short_validator_name, klass)
+          super
+          Validations.register(klass)
         end
 
         def message(default_key = nil)
@@ -72,7 +69,7 @@ module Grape
 
         def options_key?(key, options = nil)
           options = instance_variable_get(:@option) if options.nil?
-          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+          options.try(:key?, key) && !options[key].nil?
         end
 
         def fail_fast?

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

@@ -4,7 +4,7 @@ module Grape
   module Validations
     module Validators
       class CoerceValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        def initialize(attrs, options, required, scope, opts)
           super
 
           @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ContractScopeValidator < Base
+        attr_reader :schema
+
+        def initialize(_attrs, _options, _required, _scope, opts)
+          super
+          @schema = opts.fetch(:schema)
+        end
+
+        # Validates a given request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
+        # @return [void]
+        def validate(request)
+          res = schema.call(request.params)
+
+          if res.success?
+            request.params.deep_merge!(res.to_h)
+            return
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(build_errors_from_messages(res.errors.messages))
+        end
+
+        private
+
+        def build_errors_from_messages(messages)
+          messages.map do |message|
+            full_name = message.path.first.to_s
+            full_name << "[#{message.path[1..].join('][')}]" if message.path.size > 1
+            Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,14 +4,18 @@ module Grape
   module Validations
     module Validators
       class DefaultValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        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
+                                if @default.parameters.empty?
+                                  @default.call
+                                else
+                                  @default.call(params)
+                                end
                               elsif @default.frozen? || !@default.duplicable?
                                 @default
                               else

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

@@ -7,7 +7,7 @@ module Grape
         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: all_keys, message: message(:exactly_one)) if keys.empty?
 
           raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
         end

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

@@ -4,13 +4,13 @@ module Grape
   module Validations
     module Validators
       class ExceptValuesValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        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)
+          return unless params.try(:key?, attr_name)
 
           excepts = @except.is_a?(Proc) ? @except.call : @except
           return if excepts.nil?

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class LengthValidator < Base
+        def initialize(attrs, options, required, scope, opts)
+          @min = options[:min]
+          @max = options[:max]
+          @is = options[:is]
+
+          super
+
+          raise ArgumentError, 'min must be an integer greater than or equal to zero' if !@min.nil? && (!@min.is_a?(Integer) || @min.negative?)
+          raise ArgumentError, 'max must be an integer greater than or equal to zero' if !@max.nil? && (!@max.is_a?(Integer) || @max.negative?)
+          raise ArgumentError, "min #{@min} cannot be greater than max #{@max}" if !@min.nil? && !@max.nil? && @min > @max
+
+          return if @is.nil?
+          raise ArgumentError, 'is must be an integer greater than zero' if !@is.is_a?(Integer) || !@is.positive?
+          raise ArgumentError, 'is cannot be combined with min or max' if !@min.nil? || !@max.nil?
+        end
+
+        def validate_param!(attr_name, params)
+          param = params[attr_name]
+
+          return unless param.respond_to?(:length)
+
+          return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max) || (!@is.nil? && param.length != @is)
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: build_message)
+        end
+
+        def build_message
+          if options_key?(:message)
+            @option[:message]
+          elsif @min && @max
+            format I18n.t(:length, scope: 'grape.errors.messages'), min: @min, max: @max
+          elsif @min
+            format I18n.t(:length_min, scope: 'grape.errors.messages'), min: @min
+          elsif @max
+            format I18n.t(:length_max, scope: 'grape.errors.messages'), max: @max
+          else
+            format I18n.t(:length_is, scope: 'grape.errors.messages'), is: @is
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Grape
     module Validators
       class PresenceValidator < Base
         def validate_param!(attr_name, params)
-          return if params.respond_to?(:key?) && params.key?(attr_name)
+          return if params.try(:key?, attr_name)
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
         end

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

@@ -5,8 +5,8 @@ module Grape
     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)) }
+          return unless params.try(:key?, attr_name)
+          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.scrub.match?((options_key?(:value) ? @option[:value] : @option)) }
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
         end