grape 2.0.0 → 2.1.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/contract_scope.rb

@@ -0,0 +1,71 @@
+# 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: Validator,
+          opts: { schema: contract }
+        }
+
+        api.namespace_stackable(:validations, validator_options)
+      end
+
+      class Validator
+        attr_reader :schema
+
+        def initialize(*_args, schema:)
+          @schema = 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
+
+          errors = []
+
+          res.errors.messages.each do |message|
+            full_name = message.path.first.to_s
+
+            full_name += "[#{message.path[1..].join('][')}]" if message.path.size > 1
+
+            errors << Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(errors)
+        end
+
+        def fail_fast?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'attributes_doc'
-
 module Grape
   module Validations
     class ParamsScope
@@ -211,11 +209,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 +229,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 +267,7 @@ module Grape
           parent: self,
           optional: optional,
           type: type || Array,
+          group: @group,
           &block
         )
       end
@@ -463,8 +465,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)

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/build_coercer.rb

@@ -1,94 +1,92 @@
 # 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)
+      module BuildCoercer
+        # 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
-      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)
+        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 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)
+            # 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)
+            # 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
-      end
 
-      def self.cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
+        def self.cache_instance(type, method, strict, &_block)
+          key = cache_key(type, method, strict)
 
-        return @__cache[key] if @__cache.key?(key)
+          return @__cache[key] if @__cache.key?(key)
 
-        instance = yield
+          instance = yield
 
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
-        end
+          @__cache_write_lock.synchronize do
+            @__cache[key] = instance
+          end
 
-        instance
-      end
+          instance
+        end
 
-      def self.cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
+        def self.cache_key(type, method, strict)
+          [type, method, strict].each_with_object(+'_') do |val, memo|
+            next if val.nil?
 
-          memo << '_' << val.to_s
+            memo << '_' << val.to_s
+          end
         end
-      end
 
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
+        instance_variable_set(:@__cache,            {})
+        instance_variable_set(:@__cache_write_lock, Mutex.new)
+      end
     end
   end
 end

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,9 +22,7 @@ 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")
-            end
+            Grape::Validations::Types.const_get(:"#{type.name.camelize}Coercer")
           end
 
           # Returns an instance of a coercer for a given type
@@ -37,12 +33,6 @@ module Grape
             # so we need to figure out the actual type
             collection_coercer_for(type.class).new(type, strict)
           end
-
-          protected
-
-          def collection_coercers
-            @collection_coercers ||= {}
-          end
         end
 
         def initialize(type, strict = false)

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/validators/base.rb

@@ -59,6 +59,7 @@ module Grape
         end
 
         def self.inherited(klass)
+          super
           return if klass.name.blank?
 
           short_validator_name = klass.name.demodulize.underscore.delete_suffix('_validator')

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

@@ -11,7 +11,11 @@ module Grape
 
         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/length_validator.rb

@@ -0,0 +1,42 @@
+# 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]
+
+          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
+        end
+
+        def validate_param!(attr_name, params)
+          param = params[attr_name]
+
+          raise ArgumentError, "parameter #{param} does not support #length" unless param.respond_to?(:length)
+
+          return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max)
+
+          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
+          else
+            format I18n.t(:length_max, scope: 'grape.errors.messages'), max: @max
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -85,7 +85,12 @@ module Grape
         end
 
         def required_for_root_scope?
-          @required && @scope.root?
+          return false unless @required
+
+          scope = @scope
+          scope = scope.parent while scope.lateral?
+
+          scope.root?
         end
 
         def validation_exception(attr_name, message)

data/lib/grape/validations.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Grape
-  # Registry to store and locate known Validators.
   module Validations
     module_function
 
@@ -12,7 +11,7 @@ module Grape
     # Register a new validator, so it can be used to validate parameters.
     # @param short_name [String] all lower-case, no spaces
     # @param klass [Class] the validator class. Should inherit from
-    #   Validations::Base.
+    #   Grape::Validations::Validators::Base.
     def register_validator(short_name, klass)
       validators[short_name] = klass
     end
@@ -21,14 +20,11 @@ module Grape
       validators.delete(short_name)
     end
 
-    # Find a validator and if not found will try to load it
     def require_validator(short_name)
       str_name = short_name.to_s
-      validators.fetch(str_name) do
-        Grape::Validations::Validators.const_get("#{str_name.camelize}Validator")
-      end
+      validators.fetch(str_name) { Grape::Validations::Validators.const_get(:"#{str_name.camelize}Validator") }
     rescue NameError
-      raise Grape::Exceptions::UnknownValidator.new(short_name)
+      raise Grape::Exceptions::UnknownValidator, short_name
     end
   end
 end

data/lib/grape/version.rb

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

data/lib/grape/{util/xml.rb → xml.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Grape
-  if Object.const_defined? :MultiXml
+  if defined?(::MultiXml)
     Xml = ::MultiXml
   else
     Xml = ::ActiveSupport::XmlMini