grape 1.3.3 → 1.6.2

data/lib/grape/request.rb

@@ -8,13 +8,15 @@ module Grape
 
     alias rack_params params
 
-    def initialize(env, options = {})
+    def initialize(env, **options)
       extend options[:build_params_with] || Grape.config.param_builder
       super(env)
     end
 
     def params
       @params ||= build_params
+    rescue EOFError
+      raise Grape::Exceptions::EmptyMessageBody.new(content_type)
     end
 
     def headers
@@ -35,6 +37,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

data/lib/grape/router/attribute_translator.rb

@@ -4,7 +4,7 @@ module Grape
   class Router
     # this could be an OpenStruct, but doesn't work in Ruby 2.3.0, see https://bugs.ruby-lang.org/issues/12251
     class AttributeTranslator
-      attr_reader :attributes, :request_method, :requirements
+      attr_reader :attributes
 
       ROUTE_ATTRIBUTES = %i[
         prefix
@@ -23,7 +23,7 @@ module Grape
 
       ROUTER_ATTRIBUTES = %i[pattern index].freeze
 
-      def initialize(attributes = {})
+      def initialize(**attributes)
         @attributes = attributes
       end
 
@@ -37,7 +37,7 @@ module Grape
         attributes
       end
 
-      def method_missing(method_name, *args) # rubocop:disable Style/MethodMissing
+      def method_missing(method_name, *args)
         if setter?(method_name[-1])
           attributes[method_name[0..-1]] = *args
         else

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

@@ -7,20 +7,12 @@ module Grape
   class Router
     attr_reader :map, :compiled
 
-    class NormalizePathCache < Grape::Util::Cache
-      def initialize
-        @cache = Hash.new do |h, path|
-          normalized_path = +"/#{path}"
-          normalized_path.squeeze!('/')
-          normalized_path.sub!(%r{/+\Z}, '')
-          normalized_path = '/' if normalized_path.empty?
-          h[path] = -normalized_path
-        end
-      end
-    end
-
     def self.normalize_path(path)
-      NormalizePathCache[path]
+      path = +"/#{path}"
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
+      path
     end
 
     def self.supported_methods
@@ -36,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|
@@ -55,7 +48,7 @@ module Grape
 
     def associate_routes(pattern, **options)
       @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Grape::Router::AttributeTranslator.new(options.merge(pattern: pattern, index: @neutral_map.length))
+      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
     end
 
     def call(env)
@@ -68,6 +61,7 @@ module Grape
     def recognize_path(input)
       any = with_optimization { greedy_match?(input) }
       return if any == default_response
+
       any.endpoint
     end
 
@@ -88,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
@@ -99,37 +94,35 @@ module Grape
       response = yield(input, method)
 
       return response if response && !(cascade = cascade?(response))
-      neighbor = greedy_match?(input)
 
-      # If neighbor exists and request method is OPTIONS,
+      last_neighbor_route = greedy_match?(input)
+
+      # If last_neighbor_route exists and request method is OPTIONS,
       # return response by using #call_with_allow_headers.
-      return call_with_allow_headers(
-        env,
-        neighbor.allow_header,
-        neighbor.endpoint
-      ) if neighbor && method == Grape::Http::Headers::OPTIONS && !cascade
+      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Grape::Http::Headers::OPTIONS && !cascade
 
       route = match?(input, '*')
-      return neighbor.endpoint.call(env) if neighbor && cascade && route
+
+      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && cascade && route
 
       if route
         response = process_route(route, env)
         return response if response && !(cascade = cascade?(response))
       end
 
-      !cascade && neighbor ? call_with_allow_headers(env, neighbor.allow_header, neighbor.endpoint) : nil
+      return call_with_allow_headers(env, last_neighbor_route) if !cascade && last_neighbor_route
+
+      nil
     end
 
     def process_route(route, env)
-      input, = *extract_input_and_method(env)
-      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
-      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
+      prepare_env_from_route(env, route)
       route.exec(env)
     end
 
     def make_routing_args(default_args, route, input)
       args = default_args || { route_info: route }
-      args.merge(route.params(input))
+      args.merge(route.params(input) || {})
     end
 
     def extract_input_and_method(env)
@@ -150,19 +143,27 @@ 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
 
-    def call_with_allow_headers(env, methods, endpoint)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods.join(', ').freeze
-      endpoint.call(env)
+    def call_with_allow_headers(env, route)
+      prepare_env_from_route(env, route)
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header.join(', ').freeze
+      route.endpoint.call(env)
+    end
+
+    def prepare_env_from_route(env, route)
+      input, = *extract_input_and_method(env)
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
     end
 
     def cascade?(response)

data/lib/grape/{serve_file → serve_stream}/file_body.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Grape
-  module ServeFile
+  module ServeStream
     CHUNK_SIZE = 16_384
 
     # Class helps send file through API

data/lib/grape/{serve_file → serve_stream}/sendfile_response.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Grape
-  module ServeFile
+  module ServeStream
     # Response should respond to to_path method
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response

data/lib/grape/{serve_file/file_response.rb → serve_stream/stream_response.rb}

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 module Grape
-  module ServeFile
-    # A simple class used to identify responses which represent files and do not
+  module ServeStream
+    # A simple class used to identify responses which represent streams (or files) and do not
     # need to be formatted or pre-read by Rack::Response
-    class FileResponse
-      attr_reader :file
+    class StreamResponse
+      attr_reader :stream
 
-      # @param file [Object]
-      def initialize(file)
-        @file = file
+      # @param stream [Object]
+      def initialize(stream)
+        @stream = stream
       end
 
       # Equality provided mostly for tests.
       #
       # @return [Boolean]
       def ==(other)
-        file == other.file
+        stream == other.stream
       end
     end
   end

data/lib/grape/util/base_inheritable.rb

@@ -9,8 +9,8 @@ module Grape
 
       # @param inherited_values [Object] An object implementing an interface
       #   of the Hash class.
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
+      def initialize(inherited_values = nil)
+        @inherited_values = inherited_values || {}
         @new_values = {}
       end
 

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

@@ -4,6 +4,7 @@ module Grape
   module Util
     class LazyValue
       attr_reader :access_keys
+
       def initialize(value, access_keys = [])
         @value = value
         @access_keys = access_keys
@@ -48,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_iterator.rb

@@ -48,6 +48,14 @@ module Grape
       def yield_attributes(_resource_params, _attrs)
         raise NotImplementedError
       end
+
+      # This is a special case so that we can ignore tree's where option
+      # values are missing lower down. Unfortunately we can remove this
+      # are the parameter parsing stage as they are required to ensure
+      # the correct indexing is maintained
+      def skip?(val)
+        val == Grape::DSL::Parameters::EmptyOptionalValue
+      end
     end
   end
 end

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -6,7 +6,7 @@ module Grape
       private
 
       def yield_attributes(resource_params, _attrs)
-        yield resource_params
+        yield resource_params, skip?(resource_params)
       end
     end
   end

data/lib/grape/validations/params_scope.rb

@@ -13,6 +13,8 @@ module Grape
       # @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,23 +25,24 @@ 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
 
       def configuration
-        @api.configuration.evaluate
+        @api.configuration.respond_to?(:evaluate) ? @api.configuration.evaluate : @api.configuration
       end
 
       # @return [Boolean] whether or not this entire scope needs to be
@@ -50,18 +53,19 @@ 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)
-        if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
-          return false
-        end
-
         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)
-        return false unless params.respond_to?(:with_indifferent_access)
-        params = params.with_indifferent_access
+
+        # params might be anything what looks like a hash, so it must implement a `key?` method
+        return false unless params.respond_to?(:key?)
 
         @dependent_on.each do |dependency|
           if dependency.is_a?(Hash)
@@ -127,18 +131,35 @@ module Grape
         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
         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])
@@ -150,6 +171,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|
@@ -189,11 +211,12 @@ module Grape
         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
@@ -207,11 +230,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
         )
@@ -224,23 +247,25 @@ 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
           @api.namespace_stackable(:declared_params, @declared_params)
-
-          @api.route_setting(:declared_params, []) unless @api.route_setting(:declared_params)
-          @api.route_setting(:declared_params, @api.namespace_stackable(:declared_params).flatten)
         end
+
+        # params were stored in settings, it can be cleaned from the params scope
+        @declared_params = nil
       end
 
       def validates(attrs, validations)
@@ -281,16 +306,15 @@ module Grape
 
         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)
+        document_attribute(attrs, doc_attrs)
 
         opts = derive_validator_options(validations)
 
+        order_specific_validations = Set[:as]
+
         # 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)
+        validates_presence(validations, attrs, doc_attrs, opts) do |validation_type|
+          order_specific_validations << validation_type
         end
 
         # Before we run the rest of the validators, let's handle
@@ -299,6 +323,8 @@ module Grape
         coerce_type validations, attrs, doc_attrs, opts
 
         validations.each do |type, options|
+          next if order_specific_validations.include?(type)
+
           validate(type, options, attrs, doc_attrs, opts)
         end
       end
@@ -317,9 +343,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)
@@ -355,6 +379,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
 
@@ -382,6 +407,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?
@@ -392,14 +418,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)
@@ -413,11 +436,11 @@ module Grape
         raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
 
         validator_options = {
-          attributes:      attrs,
-          options:         options,
-          required:        doc_attrs[:required],
-          params_scope:    self,
-          opts:            opts,
+          attributes: attrs,
+          options: options,
+          required: doc_attrs[:required],
+          params_scope: self,
+          opts: opts,
           validator_class: validator_class
         }
         @api.namespace_stackable(:validations, validator_options)
@@ -425,21 +448,20 @@ 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)
         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 = 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
@@ -459,9 +481,22 @@ 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_attrs, 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)
+      end
     end
   end
 end