grape 1.5.3 → 1.7.1

data/lib/grape/path.rb

@@ -91,6 +91,7 @@ module Grape
 
     def split_setting(key)
       return if settings[key].nil?
+
       settings[key].to_s.split('/')
     end
   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
@@ -37,6 +39,7 @@ module Grape
       Grape::Util::LazyObject.new do
         env.each_pair.with_object({}) do |(k, v), headers|
           next unless k.to_s.start_with? HTTP_PREFIX
+
           transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
           headers[transformed_header] = v
         end
@@ -44,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/router/pattern.rb

@@ -41,7 +41,7 @@ module Grape
         end
 
         pattern = -pattern.split('/').tap do |parts|
-          parts[parts.length - 1] = '?' + parts.last
+          parts[parts.length - 1] = "?#{parts.last}"
         end.join('/') if pattern.end_with?('*path')
 
         PatternCache[[pattern, suffix]]

data/lib/grape/router/route.rb

@@ -84,8 +84,8 @@ module Grape
         path, line = *location.scan(SOURCE_LOCATION_REGEXP).first
         path = File.realpath(path) if Pathname.new(path).relative?
         expected ||= name
-        warn <<-WARNING
-#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
+        warn <<~WARNING
+          #{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
         WARNING
       end
     end

data/lib/grape/router.rb

@@ -28,6 +28,7 @@ module Grape
 
     def compile!
       return if compiled
+
       @union = Regexp.union(@neutral_regexes)
       @neutral_regexes = nil
       self.class.supported_methods.each do |method|
@@ -60,6 +61,7 @@ module Grape
     def recognize_path(input)
       any = with_optimization { greedy_match?(input) }
       return if any == default_response
+
       any.endpoint
     end
 
@@ -80,6 +82,7 @@ module Grape
       map[method].each do |route|
         next if exact_route == route
         next unless route.match?(input)
+
         response = process_route(route, env)
         break unless cascade?(response)
       end
@@ -91,6 +94,7 @@ module Grape
       response = yield(input, method)
 
       return response if response && !(cascade = cascade?(response))
+
       last_neighbor_route = greedy_match?(input)
 
       # If last_neighbor_route exists and request method is OPTIONS,
@@ -139,12 +143,14 @@ module Grape
     def match?(input, method)
       current_regexp = @optimized_map[method]
       return unless current_regexp.match(input)
+
       last_match = Regexp.last_match
       @map[method].detect { |route| last_match["_#{route.index}"] }
     end
 
     def greedy_match?(input)
       return unless @union.match(input)
+
       last_match = Regexp.last_match
       @neutral_map.detect { |route| last_match["_#{route.index}"] }
     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/inheritable_setting.rb

@@ -5,9 +5,7 @@ module Grape
     # A branchable, inheritable settings object which can store both stackable
     # and inheritable values (see InheritableValues and StackableValues).
     class InheritableSetting
-      attr_accessor :route, :api_class, :namespace
-      attr_accessor :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable
-      attr_accessor :parent, :point_in_time_copies
+      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
 
       # Retrieve global settings.
       def self.global

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/util/lazy_value.rb

@@ -49,9 +49,10 @@ module Grape
       end
 
       def []=(key, value)
-        @value_hash[key] = if value.is_a?(Hash)
+        @value_hash[key] = case value
+                           when Hash
                              LazyValueHash.new(value)
-                           elsif value.is_a?(Array)
+                           when Array
                              LazyValueArray.new(value)
                            else
                              LazyValue.new(value)

data/lib/grape/util/strict_hash_configuration.rb

@@ -65,7 +65,7 @@ module Grape
             end
           end
 
-          define_method 'to_hash' do
+          define_method :to_hash do
             merge_hash = {}
             setting_name.each_key { |k| merge_hash[k] = send("#{k}_context").to_hash }
 

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,11 +10,42 @@ 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
       # @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,17 +56,18 @@ 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
@@ -50,18 +84,29 @@ 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)
 
+        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?)
 
@@ -126,21 +171,39 @@ 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
-          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
+          @declared_params.concat(attrs.map { |attr| ::Grape::Validations::ParamsScope::Attr.new(attr, opts[:declared_params_scope]) })
         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])
@@ -152,6 +215,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|
@@ -186,16 +250,17 @@ 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(
-          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
@@ -209,11 +274,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
         )
@@ -226,15 +291,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
@@ -246,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]
@@ -265,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]
 
@@ -281,27 +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)
-
-        full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
-        @api.document_attribute(full_attrs, doc_attrs)
+        doc.document attrs
 
         opts = derive_validator_options(validations)
 
         # 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)
-        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|
-          validate(type, options, attrs, doc_attrs, opts)
+          next if type == :as
+
+          validate(type, options, attrs, doc, opts)
         end
       end
 
@@ -319,9 +379,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)
@@ -357,6 +415,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
 
@@ -366,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)
@@ -376,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)
@@ -384,6 +443,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?
@@ -394,14 +454,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)
@@ -409,39 +466,34 @@ 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],
-          params_scope:    self,
-          opts:            opts,
-          validator_class: validator_class
+          attributes: attrs,
+          options: options,
+          required: doc.required,
+          params_scope: self,
+          opts: opts,
+          validator_class: Validations.require_validator(type)
         }
         @api.namespace_stackable(:validations, validator_options)
       end
 
       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 = 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
       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
@@ -461,9 +513,16 @@ 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, opts)
+        return unless validations.key?(:presence) && validations[:presence]
+
+        validate(:presence, validations.delete(:presence), attrs, doc, opts)
+        validations.delete(:message) if validations.key?(:message)
+      end
     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/custom_type_coercer.rb

@@ -56,6 +56,7 @@ module Grape
 
           return coerced_val if coerced_val.is_a?(InvalidValue)
           return InvalidValue.new unless coerced?(coerced_val)
+
           coerced_val
         end