grape 1.6.2 → 1.7.1

data/lib/grape/dsl/parameters.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     # Defines DSL methods, meant to be applied to a ParamsScope, which define
@@ -64,7 +62,12 @@ module Grape
           params_block = named_params.fetch(name) do
             raise "Params :#{name} not found!"
           end
-          instance_exec(options, &params_block)
+
+          if options.empty?
+            instance_exec(options, &params_block)
+          else
+            instance_exec(**options, &params_block)
+          end
         end
       end
       alias use_scope use
@@ -150,8 +153,8 @@ module Grape
 
         # check type for optional parameter group
         if attrs && block
-          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
 
         if opts[:using]
@@ -219,8 +222,8 @@ module Grape
         else
           # @declared_params also includes hashes of options and such, but those
           # won't be flattened out.
-          @declared_params.flatten.any? do |declared_param|
-            first_hash_key_or_param(declared_param) == param
+          @declared_params.flatten.any? do |declared_param_attr|
+            first_hash_key_or_param(declared_param_attr.key) == param
           end
         end
       end

data/lib/grape/dsl/request_response.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     module RequestResponse
@@ -127,7 +125,7 @@ module Grape
                 :base_only_rescue_handlers
               end
 
-            namespace_reverse_stackable handler_type, args.map { |arg| [arg, handler] }.to_h
+            namespace_reverse_stackable(handler_type, args.to_h { |arg| [arg, handler] })
           end
 
           namespace_stackable(:rescue_options, options)

data/lib/grape/dsl/routing.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     module Routing
@@ -79,6 +77,10 @@ module Grape
           namespace_inheritable(:do_not_route_options, true)
         end
 
+        def do_not_document!
+          namespace_inheritable(:do_not_document, true)
+        end
+
         def mount(mounts, *opts)
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|

data/lib/grape/dsl/settings.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     # Keeps track of settings (implemented as key-value pairs, grouped by

data/lib/grape/dsl/validations.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     module Validations
@@ -32,7 +30,6 @@ module Grape
           unset_namespace_stackable :declared_params
           unset_namespace_stackable :validations
           unset_namespace_stackable :params
-          unset_description_field :params
         end
 
         # Opens a root-level ParamsScope, defining parameter coercions and
@@ -41,18 +38,6 @@ module Grape
         def params(&block)
           Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
         end
-
-        def document_attribute(names, opts)
-          setting = description_field(:params)
-          setting ||= description_field(:params, {})
-          Array(names).each do |name|
-            full_name = name[:full_name].to_s
-            setting[full_name] ||= {}
-            setting[full_name].merge!(opts)
-
-            namespace_stackable(:params, full_name => opts)
-          end
-        end
       end
     end
   end

data/lib/grape/endpoint.rb

@@ -299,7 +299,7 @@ module Grape
 
       if namespace_inheritable(:version)
         stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
-                  versions: namespace_inheritable(:version) ? namespace_inheritable(:version).flatten : nil,
+                  versions: namespace_inheritable(:version)&.flatten,
                   version_options: namespace_inheritable(:version_options),
                   prefix: namespace_inheritable(:root_prefix),
                   mount_path: namespace_stackable(:mount_path).first
@@ -325,7 +325,7 @@ module Grape
     private :build_stack, :build_helpers
 
     def execute
-      @block ? @block.call(self) : nil
+      @block&.call(self)
     end
 
     def helpers

data/lib/grape/error_formatter/json.rb

@@ -21,9 +21,15 @@ module Grape
           if message.is_a?(Exceptions::ValidationErrors) || message.is_a?(Hash)
             message
           else
-            { error: message }
+            { error: ensure_utf8(message) }
           end
         end
+
+        def ensure_utf8(message)
+          return message unless message.respond_to? :encode
+
+          message.encode('UTF-8', invalid: :replace, undef: :replace)
+        end
       end
     end
   end

data/lib/grape/exceptions/base.rb

@@ -7,11 +7,12 @@ module Grape
       BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'
       FALLBACK_LOCALE = :en
 
-      attr_reader :status, :message, :headers
+      attr_reader :status, :headers
 
       def initialize(status: nil, message: nil, headers: nil, **_options)
+        super(message)
+
         @status  = status
-        @message = message
         @headers = headers
       end
 

data/lib/grape/exceptions/missing_group_type.rb

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

data/lib/grape/exceptions/too_many_multipart_files.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class TooManyMultipartFiles < Base
+      def initialize(limit)
+        super(message: compose_message(:too_many_multipart_files, limit: limit), status: 413)
+      end
+    end
+  end
+end

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/middleware/stack.rb

@@ -95,7 +95,7 @@ module Grape
 
       # @return [Rack::Builder] the builder object with our middlewares applied
       def build(builder = Rack::Builder.new)
-        others.shift(others.size).each(&method(:merge_with))
+        others.shift(others.size).each { |m| merge_with(m) }
         middlewares.each do |m|
           m.use_in(builder)
         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
@@ -45,7 +47,7 @@ module Grape
     end
 
     def transform_header(header)
-      -header[5..-1].split('_').each(&:capitalize!).join('-')
+      -header[5..].split('_').each(&:capitalize!).join('-')
     end
   end
 end

data/lib/grape/router/attribute_translator.rb

@@ -39,7 +39,7 @@ module Grape
 
       def method_missing(method_name, *args)
         if setter?(method_name[-1])
-          attributes[method_name[0..-1]] = *args
+          attributes[method_name[0..]] = *args
         else
           attributes[method_name]
         end

data/lib/grape/types/invalid_value.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# 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/util/cache.rb

@@ -1,4 +1,4 @@
-# frozen_String_literal: true
+# frozen_string_literal: true
 
 require 'singleton'
 require 'forwardable'

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
@@ -453,7 +485,7 @@ module Grape
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
 
-          value_types = values.is_a?(Range) ? [values.begin, values.end] : values
+          value_types = values.is_a?(Range) ? [values.begin, values.end].compact : values
           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
@@ -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