grape 1.6.2 → 1.7.0

data/lib/grape/exceptions/unsupported_group_type.rb

@@ -2,10 +2,17 @@
 
 module Grape
   module Exceptions
-    class UnsupportedGroupTypeError < Base
+    class UnsupportedGroupType < Base
       def initialize
         super(message: compose_message(:unsupported_group_type))
       end
     end
   end
 end
+
+Grape::Exceptions::UnsupportedGroupTypeError = Class.new(Grape::Exceptions::UnsupportedGroupType) do
+  def initialize(*)
+    super
+    warn '[DEPRECATION] `Grape::Exceptions::UnsupportedGroupTypeError` is deprecated. Use `Grape::Exceptions::UnsupportedGroupType` instead.'
+  end
+end

data/lib/grape/exceptions/validation.rb

@@ -21,10 +21,6 @@ module Grape
       def as_json(*_args)
         to_s
       end
-
-      def to_s
-        message
-      end
     end
   end
 end

data/lib/grape/locale/en.yml

@@ -11,8 +11,8 @@ en:
         except_values: 'has a value not allowed'
         same_as: 'is not the same as %{parameter}'
         missing_vendor_option:
-          problem: 'missing :vendor option.'
-          summary: 'when version using header, you must specify :vendor option. '
+          problem: 'missing :vendor option'
+          summary: 'when version using header, you must specify :vendor option'
           resolution: "eg: version 'v1', using: :header, vendor: 'twitter'"
         missing_mime_type:
           problem: 'missing mime type for %{new_format}'
@@ -21,12 +21,12 @@ en:
             or add your own with content_type :%{new_format}, 'application/%{new_format}'
             "
         invalid_with_option_for_represent:
-          problem: 'You must specify an entity class in the :with option.'
+          problem: 'you must specify an entity class in the :with option'
           resolution: 'eg: represent User, :with => Entity::User'
-        missing_option: 'You must specify :%{option} options.'
+        missing_option: 'you must specify :%{option} options'
         invalid_formatter: 'cannot convert %{klass} to %{to_format}'
         invalid_versioner_option:
-          problem: 'Unknown :using for versioner: %{strategy}'
+          problem: 'unknown :using for versioner: %{strategy}'
           resolution: 'available strategy for :using is :path, :header, :accept_version_header, :param'
         unknown_validator: 'unknown validator: %{validator_type}'
         unknown_options: 'unknown options: %{options}'
@@ -44,11 +44,12 @@ en:
             "when specifying %{body_format} as content-type, you must pass valid
             %{body_format} in the request's 'body'
             "
-        empty_message_body: 'Empty message body supplied with %{body_format} content-type'
+        empty_message_body: 'empty message body supplied with %{body_format} content-type'
+        too_many_multipart_files: "the number of uploaded files exceeded the system's configured limit (%{limit})"
         invalid_accept_header:
-          problem: 'Invalid accept header'
+          problem: 'invalid accept header'
           resolution: '%{message}'
         invalid_version_header:
-          problem: 'Invalid version header'
+          problem: 'invalid version header'
           resolution: '%{message}'
         invalid_response: 'Invalid response'

data/lib/grape/middleware/auth/dsl.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rack/auth/basic'
-require 'active_support/concern'
 
 module Grape
   module Middleware

data/lib/grape/middleware/error.rb

@@ -72,7 +72,7 @@ module Grape
 
       def rack_response(message, status = options[:default_status], headers = { Grape::Http::Headers::CONTENT_TYPE => content_type })
         message = ERB::Util.html_escape(message) if headers[Grape::Http::Headers::CONTENT_TYPE] == TEXT_HTML
-        Rack::Response.new([message], status, headers)
+        Rack::Response.new([message], Rack::Utils.status_code(status), headers)
       end
 
       def format_message(message, backtrace, original_exception = nil)
@@ -121,7 +121,7 @@ module Grape
 
       def run_rescue_handler(handler, error)
         if handler.instance_of?(Symbol)
-          raise NoMethodError, "undefined method `#{handler}'" unless respond_to?(handler)
+          raise NoMethodError, "undefined method '#{handler}'" unless respond_to?(handler)
 
           handler = public_method(handler)
         end

data/lib/grape/request.rb

@@ -17,6 +17,8 @@ module Grape
       @params ||= build_params
     rescue EOFError
       raise Grape::Exceptions::EmptyMessageBody.new(content_type)
+    rescue Rack::Multipart::MultipartPartLimitError
+      raise Grape::Exceptions::TooManyMultipartFiles.new(Rack::Utils.multipart_part_limit)
     end
 
     def headers

data/lib/grape/util/json.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Grape
   if Object.const_defined? :MultiJson
     Json = ::MultiJson

data/lib/grape/validations/attributes_doc.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+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
+
+        def extract_details(validations)
+          details[:required] = validations.key?(:presence)
+
+          desc = validations.delete(:desc) || validations.delete(:description)
+
+          details[:desc] = desc if desc
+
+          documentation = validations.delete(:documentation)
+
+          details[:documentation] = documentation if documentation
+
+          details[:default] = validations[:default] if validations.key?(:default)
+        end
+
+        def document(attrs)
+          return if @api.namespace_inheritable(:do_not_document)
+
+          details[:type] = type.to_s if type
+          details[:values] = values if values
+
+          documented_attrs = attrs.each_with_object({}) do |name, memo|
+            memo[@scope.full_name(name)] = details
+          end
+
+          @api.namespace_stackable(:params, documented_attrs)
+        end
+
+        def required
+          details[:required]
+        end
+
+        protected
+
+        def details
+          @details ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'attributes_doc'
+
 module Grape
   module Validations
     class ParamsScope
@@ -8,6 +10,35 @@ module Grape
 
       include Grape::DSL::Parameters
 
+      class Attr
+        attr_accessor :key, :scope
+
+        # Open up a new ParamsScope::Attr
+        # @param key [Hash, Symbol] key of attr
+        # @param scope [Grape::Validations::ParamsScope] scope of attr
+        def initialize(key, scope)
+          @key = key
+          @scope = scope
+        end
+
+        # @return Array[Symbol, Hash[Symbol => Array]] declared_params with symbol instead of Attr
+        def self.attrs_keys(declared_params)
+          declared_params.map do |declared_param_attr|
+            attr_key(declared_param_attr)
+          end
+        end
+
+        def self.attr_key(declared_param_attr)
+          return attr_key(declared_param_attr.key) if declared_param_attr.is_a?(self)
+
+          if declared_param_attr.is_a?(Hash)
+            declared_param_attr.transform_values { |value| attrs_keys(value) }
+          else
+            declared_param_attr
+          end
+        end
+      end
+
       # Open up a new ParamsScope, allowing parameter definitions per
       #   Grape::DSL::Params.
       # @param opts [Hash] options for this scope
@@ -31,7 +62,7 @@ module Grape
         @api              = opts[:api]
         @optional         = opts[:optional] || false
         @type             = opts[:type]
-        @group            = opts[:group] || {}
+        @group            = opts[:group]
         @dependent_on     = opts[:dependent_on]
         @declared_params = []
         @index = nil
@@ -64,6 +95,18 @@ module Grape
 
         return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
 
+        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)
+      end
+
+      def meets_hash_dependency?(params)
         # params might be anything what looks like a hash, so it must implement a `key?` method
         return false unless params.respond_to?(:key?)
 
@@ -128,13 +171,14 @@ module Grape
       # 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]
 
-          @declared_params.concat attrs
+          @declared_params.concat(attrs.map { |attr| ::Grape::Validations::ParamsScope::Attr.new(attr, opts[:declared_params_scope]) })
         end
       end
 
@@ -206,8 +250,8 @@ module Grape
         # if required params are grouped and no type or unsupported type is provided, raise an error
         type = attrs[1] ? attrs[1][:type] : nil
         if attrs.first && !optional
-          raise Grape::Exceptions::MissingGroupTypeError.new if type.nil?
-          raise Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
+          raise Grape::Exceptions::MissingGroupType if type.nil?
+          raise Grape::Exceptions::UnsupportedGroupType unless Grape::Validations::Types.group?(type)
         end
 
         self.class.new(
@@ -269,17 +313,14 @@ module Grape
       end
 
       def validates(attrs, validations)
-        doc_attrs = { required: validations.key?(:presence) }
+        doc = AttributesDoc.new @api, self
+        doc.extract_details validations
 
         coerce_type = infer_coercion(validations)
 
-        doc_attrs[:type] = coerce_type.to_s if coerce_type
-
-        desc = validations.delete(:desc) || validations.delete(:description)
-        doc_attrs[:desc] = desc if desc
+        doc.type = coerce_type
 
         default = validations[:default]
-        doc_attrs[:default] = default if validations.key?(:default)
 
         if (values_hash = validations[:values]).is_a? Hash
           values = values_hash[:value]
@@ -288,7 +329,8 @@ module Grape
         else
           values = validations[:values]
         end
-        doc_attrs[:values] = values if values
+
+        doc.values = values
 
         except_values = options_key?(:except_values, :value, validations) ? validations[:except_values][:value] : validations[:except_values]
 
@@ -304,28 +346,22 @@ module Grape
         # type should be compatible with values array, if both exist
         validate_value_coercion(coerce_type, values, except_values, excepts)
 
-        doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation)
-
-        document_attribute(attrs, doc_attrs)
+        doc.document attrs
 
         opts = derive_validator_options(validations)
 
-        order_specific_validations = Set[:as]
-
         # Validate for presence before any other validators
-        validates_presence(validations, attrs, doc_attrs, opts) do |validation_type|
-          order_specific_validations << validation_type
-        end
+        validates_presence(validations, attrs, doc, opts)
 
         # Before we run the rest of the validators, let's handle
         # whatever coercion so that we are working with correctly
         # type casted values
-        coerce_type validations, attrs, doc_attrs, opts
+        coerce_type validations, attrs, doc, opts
 
         validations.each do |type, options|
-          next if order_specific_validations.include?(type)
+          next if type == :as
 
-          validate(type, options, attrs, doc_attrs, opts)
+          validate(type, options, attrs, doc, opts)
         end
       end
 
@@ -389,7 +425,7 @@ module Grape
       # composited from more than one +requires+/+optional+
       # parameter, and needs to be run before most other
       # validations.
-      def coerce_type(validations, attrs, doc_attrs, opts)
+      def coerce_type(validations, attrs, doc, opts)
         check_coerce_with(validations)
 
         return unless validations.key?(:coerce)
@@ -399,7 +435,7 @@ module Grape
           method: validations[:coerce_with],
           message: validations[:coerce_message]
         }
-        validate('coerce', coerce_options, attrs, doc_attrs, opts)
+        validate('coerce', coerce_options, attrs, doc, opts)
         validations.delete(:coerce_with)
         validations.delete(:coerce)
         validations.delete(:coerce_message)
@@ -430,18 +466,14 @@ module Grape
           unless Array(default).none? { |def_val| excepts.include?(def_val) }
       end
 
-      def validate(type, options, attrs, doc_attrs, opts)
-        validator_class = Validations.validators[type.to_s]
-
-        raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
-
+      def validate(type, options, attrs, doc, opts)
         validator_options = {
           attributes: attrs,
           options: options,
-          required: doc_attrs[:required],
+          required: doc.required,
           params_scope: self,
           opts: opts,
-          validator_class: validator_class
+          validator_class: Validations.require_validator(type)
         }
         @api.namespace_stackable(:validations, validator_options)
       end
@@ -485,17 +517,11 @@ module Grape
         }
       end
 
-      def validates_presence(validations, attrs, doc_attrs, opts)
+      def validates_presence(validations, attrs, doc, 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)
+        validate(:presence, validations.delete(:presence), attrs, doc, opts)
+        validations.delete(:message) if validations.key?(:message)
       end
     end
   end

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

@@ -14,8 +14,6 @@ module Grape
       # behavior of Virtus which was used earlier, a `Grape::Validations::Types::PrimitiveCoercer`
       # maintains Virtus behavior in coercing.
       class ArrayCoercer < DryTypeCoercer
-        register_collection Array
-
         def initialize(type, strict = false)
           super
 

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

@@ -18,19 +18,15 @@ module Grape
       # https://dry-rb.org/gems/dry-types/1.2/built-in-types/
       class DryTypeCoercer
         class << self
-          # Registers a collection coercer which could be found by a type,
-          # see +collection_coercer_for+ method below. This method is meant for inheritors.
-          def register_collection(type)
-            DryTypeCoercer.collection_coercers[type] = self
-          end
-
           # Returns a collection coercer which corresponds to a given type.
           # Example:
           #
           #    collection_coercer_for(Array)
           #    #=> Grape::Validations::Types::ArrayCoercer
           def collection_coercer_for(type)
-            collection_coercers[type]
+            collection_coercers.fetch(type) do
+              DryTypeCoercer.collection_coercers[type] = Grape::Validations::Types.const_get("#{type.name.camelize}Coercer")
+            end
           end
 
           # Returns an instance of a coercer for a given type

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

@@ -12,6 +12,9 @@ module Grape
         MAPPING = {
           Grape::API::Boolean => DryTypes::Params::Bool,
           BigDecimal => DryTypes::Params::Decimal,
+          Numeric => DryTypes::Params::Integer | DryTypes::Params::Float | DryTypes::Params::Decimal,
+          TrueClass => DryTypes::Params::Bool.constrained(eql: true),
+          FalseClass => DryTypes::Params::Bool.constrained(eql: false),
 
           # unfortunately, a +Params+ scope doesn't contain String
           String => DryTypes::Coercible::String
@@ -19,7 +22,10 @@ module Grape
 
         STRICT_MAPPING = {
           Grape::API::Boolean => DryTypes::Strict::Bool,
-          BigDecimal => DryTypes::Strict::Decimal
+          BigDecimal => DryTypes::Strict::Decimal,
+          Numeric => DryTypes::Strict::Integer | DryTypes::Strict::Float | DryTypes::Strict::Decimal,
+          TrueClass => DryTypes::Strict::Bool.constrained(eql: true),
+          FalseClass => DryTypes::Strict::Bool.constrained(eql: false)
         }.freeze
 
         def initialize(type, strict = false)
@@ -27,11 +33,13 @@ module Grape
 
           @type = type
 
-          @coercer = if strict
-                       STRICT_MAPPING.fetch(type) { scope.const_get(type.name) }
-                     else
-                       MAPPING.fetch(type) { scope.const_get(type.name) }
-                     end
+          @coercer = (strict ? STRICT_MAPPING : MAPPING).fetch(type) do
+            scope.const_get(type.name, false)
+          rescue NameError
+            raise ArgumentError, "type #{type} should support coercion via `[]`" unless type.respond_to?(:[])
+
+            type
+          end
         end
 
         def call(val)

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

@@ -9,8 +9,6 @@ module Grape
       # Takes the given array and converts it to a set. Every element of the set
       # is also coerced.
       class SetCoercer < ArrayCoercer
-        register_collection Set
-
         def initialize(type, strict = false)
           super