grape 1.3.0 → 1.5.2

data/lib/grape/dsl/inside_route.rb

@@ -28,36 +28,38 @@ module Grape
       # Methods which should not be available in filters until the before filter
       # has completed
       module PostBeforeFilter
-        def declared(passed_params, options = {}, declared_params = nil)
+        def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
           options = options.reverse_merge(include_missing: true, include_parent_namespaces: true)
           declared_params ||= optioned_declared_params(**options)
 
           if passed_params.is_a?(Array)
-            declared_array(passed_params, options, declared_params)
+            declared_array(passed_params, options, declared_params, params_nested_path)
           else
-            declared_hash(passed_params, options, declared_params)
+            declared_hash(passed_params, options, declared_params, params_nested_path)
           end
         end
 
         private
 
-        def declared_array(passed_params, options, declared_params)
+        def declared_array(passed_params, options, declared_params, params_nested_path)
           passed_params.map do |passed_param|
-            declared(passed_param || {}, options, declared_params)
+            declared(passed_param || {}, options, declared_params, params_nested_path)
           end
         end
 
-        def declared_hash(passed_params, options, declared_params)
+        def declared_hash(passed_params, options, declared_params, params_nested_path)
           declared_params.each_with_object(passed_params.class.new) do |declared_param, memo|
             if declared_param.is_a?(Hash)
               declared_param.each_pair do |declared_parent_param, declared_children_params|
+                params_nested_path_dup = params_nested_path.dup
+                params_nested_path_dup << declared_parent_param.to_s
                 next unless options[:include_missing] || passed_params.key?(declared_parent_param)
 
                 passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
                 memo_key = optioned_param_key(declared_parent_param, options)
 
-                memo[memo_key] = handle_passed_param(declared_parent_param, passed_children_params) do
-                  declared(passed_children_params, options, declared_children_params)
+                memo[memo_key] = handle_passed_param(params_nested_path_dup, passed_children_params.any?) do
+                  declared(passed_children_params, options, declared_children_params, params_nested_path_dup)
                 end
               end
             else
@@ -68,30 +70,37 @@ module Grape
 
               next unless options[:include_missing] || passed_params.key?(declared_param) || (param_renaming && passed_params.key?(param_renaming))
 
-              if param_renaming
-                memo[optioned_param_key(param_renaming, options)] = passed_params[param_renaming]
-              else
-                memo[optioned_param_key(declared_param, options)] = passed_params[declared_param]
+              memo_key = optioned_param_key(param_renaming || declared_param, options)
+              passed_param = passed_params[param_renaming || declared_param]
+
+              params_nested_path_dup = params_nested_path.dup
+              params_nested_path_dup << declared_param.to_s
+              memo[memo_key] = passed_param || handle_passed_param(params_nested_path_dup) do
+                passed_param
               end
             end
           end
         end
 
-        def handle_passed_param(declared_param, passed_children_params, &_block)
-          should_be_empty_array?(declared_param, passed_children_params) ? [] : yield
-        end
+        def handle_passed_param(params_nested_path, has_passed_children = false, &_block)
+          return yield if has_passed_children
 
-        def should_be_empty_array?(declared_param, passed_children_params)
-          declared_param_is_array?(declared_param) && passed_children_params.empty?
-        end
+          key = params_nested_path[0]
+          key += '[' + params_nested_path[1..-1].join('][') + ']' if params_nested_path.size > 1
 
-        def declared_param_is_array?(declared_param)
-          key = declared_param.to_s
-          route_options_params[key] && route_options_params[key][:type] == 'Array'
-        end
+          route_options_params = options[:route_options][:params] || {}
+          type = route_options_params.dig(key, :type)
+          has_children = route_options_params.keys.any? { |k| k != key && k.start_with?(key) }
 
-        def route_options_params
-          options[:route_options][:params] || {}
+          if type == 'Hash' && !has_children
+            {}
+          elsif type == 'Array' || type&.start_with?('[') && !type&.include?(',')
+            []
+          elsif type == 'Set' || type&.start_with?('#<Set')
+            Set.new
+          else
+            yield
+          end
         end
 
         def optioned_param_key(declared_param, options)
@@ -101,10 +110,10 @@ module Grape
         def optioned_declared_params(**options)
           declared_params = if options[:include_parent_namespaces]
                               # Declared params including parent namespaces
-                              route_setting(:saved_declared_params).flatten | Array(route_setting(:declared_params))
+                              route_setting(:declared_params)
                             else
                               # Declared params at current namespace
-                              route_setting(:saved_declared_params).last & Array(route_setting(:declared_params))
+                              namespace_stackable(:declared_params).last || []
                             end
 
           raise ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
@@ -177,17 +186,17 @@ module Grape
       def status(status = nil)
         case status
         when Symbol
-          raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.include?(status)
+          raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(status)
           @status = Rack::Utils.status_code(status)
         when Integer
           @status = status
         when nil
-          return @status if @status
+          return @status if instance_variable_defined?(:@status) && @status
           case request.request_method.to_s.upcase
           when Grape::Http::Headers::POST
             201
           when Grape::Http::Headers::DELETE
-            if @body.present?
+            if instance_variable_defined?(:@body) && @body.present?
               200
             else
               204
@@ -238,7 +247,7 @@ module Grape
           @body = ''
           status 204
         else
-          @body
+          instance_variable_defined?(:@body) ? @body : nil
         end
       end
 
@@ -256,23 +265,36 @@ module Grape
         body false
       end
 
-      # Allows you to define the response as a file-like object.
+      # Deprecated method to send files to the client. Use `sendfile` or `stream`
+      def file(value = nil)
+        if value.is_a?(String)
+          warn '[DEPRECATION] Use sendfile or stream to send files.'
+          sendfile(value)
+        elsif !value.is_a?(NilClass)
+          warn '[DEPRECATION] Use stream to use a Stream object.'
+          stream(value)
+        else
+          warn '[DEPRECATION] Use sendfile or stream to send files.'
+          sendfile
+        end
+      end
+
+      # Allows you to send a file to the client via sendfile.
       #
       # @example
       #   get '/file' do
-      #     file FileStreamer.new(...)
+      #     sendfile FileStreamer.new(...)
       #   end
       #
       #   GET /file # => "contents of file"
-      def file(value = nil)
+      def sendfile(value = nil)
         if value.is_a?(String)
-          file_body = Grape::ServeFile::FileBody.new(value)
-          @file = Grape::ServeFile::FileResponse.new(file_body)
+          file_body = Grape::ServeStream::FileBody.new(value)
+          @stream = Grape::ServeStream::StreamResponse.new(file_body)
         elsif !value.is_a?(NilClass)
-          warn '[DEPRECATION] Argument as FileStreamer-like object is deprecated. Use path to file instead.'
-          @file = Grape::ServeFile::FileResponse.new(value)
+          raise ArgumentError, 'Argument must be a file path'
         else
-          @file
+          stream
         end
       end
 
@@ -292,10 +314,21 @@ module Grape
       # * https://github.com/rack/rack/blob/99293fa13d86cd48021630fcc4bd5acc9de5bdc3/lib/rack/chunked.rb
       # * https://github.com/rack/rack/blob/99293fa13d86cd48021630fcc4bd5acc9de5bdc3/lib/rack/etag.rb
       def stream(value = nil)
+        return if value.nil? && @stream.nil?
+
         header 'Content-Length', nil
         header 'Transfer-Encoding', nil
         header 'Cache-Control', 'no-cache' # Skips ETag generation (reading the response up front)
-        file(value)
+        if value.is_a?(String)
+          file_body = Grape::ServeStream::FileBody.new(value)
+          @stream = Grape::ServeStream::StreamResponse.new(file_body)
+        elsif value.respond_to?(:each)
+          @stream = Grape::ServeStream::StreamResponse.new(value)
+        elsif !value.is_a?(NilClass)
+          raise ArgumentError, 'Stream object must respond to :each.'
+        else
+          @stream
+        end
       end
 
       # Allows you to make use of Grape Entities by setting
@@ -331,11 +364,12 @@ module Grape
                          end
 
         representation = { root => representation } if root
+
         if key
-          representation = (@body || {}).merge(key => representation)
-        elsif entity_class.present? && @body
+          representation = (body || {}).merge(key => representation)
+        elsif entity_class.present? && body
           raise ArgumentError, "Representation of type #{representation.class} cannot be merged." unless representation.respond_to?(:merge)
-          representation = @body.merge(representation)
+          representation = body.merge(representation)
         end
 
         body representation
@@ -365,7 +399,7 @@ module Grape
         entity_class = options.delete(:with)
 
         if entity_class.nil?
-          # entity class not explicitely defined, auto-detect from relation#klass or first object in the collection
+          # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
           object_class = if object.respond_to?(:klass)
                            object.klass
                          else

data/lib/grape/dsl/parameters.rb

@@ -72,7 +72,7 @@ module Grape
 
       # Require one or more parameters for the current endpoint.
       #
-      # @param attrs list of parameter names, or, if :using is
+      # @param attrs list of parameters names, or, if :using is
       #   passed as an option, which keys to include (:all or :none) from
       #   the :using hash. The last key can be a hash, which specifies
       #   options for the parameters
@@ -127,7 +127,7 @@ module Grape
 
         opts = attrs.extract_options!.clone
         opts[:presence] = { value: true, message: opts[:message] }
-        opts = @group.merge(opts) if @group
+        opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
 
         if opts[:using]
           require_required_and_optional_fields(attrs.first, opts)
@@ -146,7 +146,7 @@ module Grape
 
         opts = attrs.extract_options!.clone
         type = opts[:type]
-        opts = @group.merge(opts) if @group
+        opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
 
         # check type for optional parameter group
         if attrs && block_given?
@@ -227,13 +227,17 @@ module Grape
 
       alias group requires
 
-      def map_params(params, element)
+      class EmptyOptionalValue; end
+
+      def map_params(params, element, is_array = false)
         if params.is_a?(Array)
           params.map do |el|
-            map_params(el, element)
+            map_params(el, element, true)
           end
         elsif params.is_a?(Hash)
-          params[element] || {}
+          params[element] || (@optional && is_array ? EmptyOptionalValue : {})
+        elsif params == EmptyOptionalValue
+          EmptyOptionalValue
         else
           {}
         end
@@ -243,8 +247,8 @@ module Grape
       # @return hash of parameters relevant for the current scope
       # @api private
       def params(params)
-        params = @parent.params(params) if @parent
-        params = map_params(params, @element) if @element
+        params = @parent.params(params) if instance_variable_defined?(:@parent) && @parent
+        params = map_params(params, @element) if instance_variable_defined?(:@element) && @element
         params
       end
 

data/lib/grape/dsl/routing.rb

@@ -51,7 +51,7 @@ module Grape
             end
           end
 
-          @versions.last unless @versions.nil?
+          @versions.last if instance_variable_defined?(:@versions) && @versions
         end
 
         # Define a root URL prefix for your entire API.
@@ -79,11 +79,12 @@ module Grape
           namespace_inheritable(:do_not_route_options, true)
         end
 
-        def mount(mounts, opts = {})
+        def mount(mounts, *opts)
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|
             if app.respond_to?(:mount_instance)
-              mount(app.mount_instance(configuration: opts[:with] || {}) => path)
+              opts_with = opts.any? ? opts.shift[:with] : {}
+              mount({ app.mount_instance(configuration: opts_with) => path })
               next
             end
             in_setting = inheritable_setting
@@ -142,16 +143,16 @@ module Grape
           reset_validations!
         end
 
-        %w[get post put head delete options patch].each do |meth|
-          define_method meth do |*args, &block|
+        Grape::Http::Headers::SUPPORTED_METHODS.each do |supported_method|
+          define_method supported_method.downcase do |*args, &block|
             options = args.extract_options!
             paths = args.first || ['/']
-            route(meth.upcase, paths, options, &block)
+            route(supported_method, paths, options, &block)
           end
         end
 
         # Declare a "namespace", which prefixes all subordinate routes with its
-        # name. Any endpoints within a namespace, or group, resource, segment,
+        # name. Any endpoints within a namespace, group, resource or segment,
         # etc., will share their parent context as well as any configuration
         # done in the namespace context.
         #
@@ -163,14 +164,14 @@ module Grape
         #       end
         #     end
         def namespace(space = nil, options = {}, &block)
+          @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description
+
           if space || block_given?
             within_namespace do
               previous_namespace_description = @namespace_description
               @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {})
               nest(block) do
-                if space
-                  namespace_stackable(:namespace, Namespace.new(space, **options))
-                end
+                namespace_stackable(:namespace, Namespace.new(space, **options)) if space
               end
               @namespace_description = previous_namespace_description
             end
@@ -199,7 +200,7 @@ module Grape
           @endpoints = []
         end
 
-        # Thie method allows you to quickly define a parameter route segment
+        # This method allows you to quickly define a parameter route segment
         # in your API.
         #
         # @param param [Symbol] The name of the parameter you wish to declare.

data/lib/grape/dsl/validations.rb

@@ -10,7 +10,24 @@ module Grape
       include Grape::DSL::Configuration
 
       module ClassMethods
-        # Clears all defined parameters and validations.
+        # Clears all defined parameters and validations. The main purpose of it is to clean up
+        # settings, so next endpoint won't interfere with previous one.
+        #
+        #    params do
+        #      # params for the endpoint below this block
+        #    end
+        #    post '/current' do
+        #      # whatever
+        #    end
+        #
+        #    # somewhere between them the reset_validations! method gets called
+        #
+        #    params do
+        #      # params for the endpoint below this block
+        #    end
+        #    post '/next' do
+        #      # whatever
+        #    end
         def reset_validations!
           unset_namespace_stackable :declared_params
           unset_namespace_stackable :validations

data/lib/grape/eager_load.rb

@@ -16,5 +16,5 @@ Grape::Parser.eager_load!
 Grape::DSL.eager_load!
 Grape::API.eager_load!
 Grape::Presenters.eager_load!
-Grape::ServeFile.eager_load!
+Grape::ServeStream.eager_load!
 Rack::Head # AutoLoads the Rack::Head

data/lib/grape/endpoint.rb

@@ -80,7 +80,10 @@ module Grape
 
       self.inheritable_setting = new_settings.point_in_time_copy
 
-      route_setting(:saved_declared_params, namespace_stackable(:declared_params))
+      # now +namespace_stackable(:declared_params)+ contains all params defined for
+      # this endpoint and its parents, but later it will be cleaned up,
+      # see +reset_validations!+ in lib/grape/dsl/validations.rb
+      route_setting(:declared_params, namespace_stackable(:declared_params).flatten)
       route_setting(:saved_validations, namespace_stackable(:validations))
 
       namespace_stackable(:representations, []) unless namespace_stackable(:representations)
@@ -99,7 +102,7 @@ module Grape
       @block = nil
 
       @status = nil
-      @file = nil
+      @stream = nil
       @body = nil
       @proc = nil
 
@@ -116,7 +119,6 @@ module Grape
       parent_declared_params = namespace_stackable[:declared_params]
 
       if parent_declared_params
-        inheritable_setting.route[:declared_params] ||= []
         inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten)
       end
 
@@ -190,7 +192,7 @@ module Grape
         requirements: prepare_routes_requirements,
         prefix: namespace_inheritable(:root_prefix),
         anchor: options[:route_options].fetch(:anchor, true),
-        settings: inheritable_setting.route.except(:saved_declared_params, :saved_validations),
+        settings: inheritable_setting.route.except(:declared_params, :saved_validations),
         forward_match: options[:forward_match]
       }
     end
@@ -271,8 +273,8 @@ module Grape
           # status verifies body presence when DELETE
           @body ||= response_object
 
-          # The body commonly is an Array of Strings, the application instance itself, or a File-like object
-          response_object = file || [body]
+          # The body commonly is an Array of Strings, the application instance itself, or a Stream-like object
+          response_object = stream || [body]
 
           [status, header, response_object]
         ensure

data/lib/grape/exceptions/base.rb

@@ -57,10 +57,6 @@ module Grape
         end.join(', ')
       end
 
-      def translate_attribute(key, **options)
-        translate("#{BASE_ATTRIBUTES_KEY}.#{key}", default: key, **options)
-      end
-
       def translate_message(key, **options)
         case key
         when Symbol

data/lib/grape/exceptions/validation.rb

@@ -17,7 +17,7 @@ module Grape
         super(**args)
       end
 
-      # remove all the unnecessary stuff from Grape::Exceptions::Base like status
+      # Remove all the unnecessary stuff from Grape::Exceptions::Base like status
       # and headers when converting a validation error to json or string
       def as_json(*_args)
         to_s

data/lib/grape/exceptions/validation_errors.rb

@@ -5,6 +5,9 @@ require 'grape/exceptions/base'
 module Grape
   module Exceptions
     class ValidationErrors < Grape::Exceptions::Base
+      ERRORS_FORMAT_KEY = 'grape.errors.format'
+      DEFAULT_ERRORS_FORMAT = '%{attributes} %{message}'
+
       include Enumerable
 
       attr_reader :errors
@@ -36,26 +39,22 @@ module Grape
         end
       end
 
-      def to_json(**_opts)
+      def to_json(*_opts)
         as_json.to_json
       end
 
       def full_messages
-        messages = map { |attributes, error| full_message(attributes, error) }
+        messages = map do |attributes, error|
+          I18n.t(
+            ERRORS_FORMAT_KEY,
+            default: DEFAULT_ERRORS_FORMAT,
+            attributes: translate_attributes(attributes),
+            message: error.message
+          )
+        end
         messages.uniq!
         messages
       end
-
-      private
-
-      def full_message(attributes, error)
-        I18n.t(
-          'grape.errors.format',
-          default: '%{attributes} %{message}',
-          attributes: attributes.count == 1 ? translate_attribute(attributes.first) : translate_attributes(attributes),
-          message: error.message
-        )
-      end
     end
   end
 end

data/lib/grape/http/headers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/lazy_object'
+
 module Grape
   module Http
     module Headers
@@ -19,6 +21,7 @@ module Grape
       OPTIONS = 'OPTIONS'
 
       SUPPORTED_METHODS = [GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS].freeze
+      SUPPORTED_METHODS_WITHOUT_OPTIONS = Grape::Util::LazyObject.new { [GET, POST, PUT, PATCH, DELETE, HEAD].freeze }
 
       HTTP_ACCEPT_VERSION    = 'HTTP_ACCEPT_VERSION'
       X_CASCADE              = 'X-Cascade'
@@ -27,6 +30,29 @@ module Grape
 
       FORMAT                 = 'format'
 
+      HTTP_HEADERS = Grape::Util::LazyObject.new do
+        common_http_headers = %w[
+          Version
+          Host
+          Connection
+          Cache-Control
+          Dnt
+          Upgrade-Insecure-Requests
+          User-Agent
+          Sec-Fetch-Dest
+          Accept
+          Sec-Fetch-Site
+          Sec-Fetch-Mode
+          Sec-Fetch-User
+          Accept-Encoding
+          Accept-Language
+          Cookie
+        ].freeze
+        common_http_headers.each_with_object({}) do |header, response|
+          response["HTTP_#{header.upcase.tr('-', '_')}"] = header
+        end.freeze
+      end
+
       def self.find_supported_method(route_method)
         Grape::Http::Headers::SUPPORTED_METHODS.detect { |supported_method| supported_method.casecmp(route_method).zero? }
       end

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

@@ -10,9 +10,9 @@ module Grape
 
         attr_accessor :options, :app, :env
 
-        def initialize(app, **options)
+        def initialize(app, *options)
           @app = app
-          @options = options
+          @options = options.shift
         end
 
         def call(env)
@@ -23,7 +23,7 @@ module Grape
           self.env = env
 
           if options.key?(:type)
-            auth_proc         = options[:proc]
+            auth_proc = options[:proc]
             auth_proc_context = context
 
             strategy_info = Grape::Middleware::Auth::Strategies[options[:type]]

data/lib/grape/middleware/base.rb

@@ -8,15 +8,16 @@ module Grape
       include Helpers
 
       attr_reader :app, :env, :options
+
       TEXT_HTML = 'text/html'
 
       include Grape::DSL::Headers
 
       # @param [Rack Application] app The standard argument for a Rack middleware.
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
-      def initialize(app, **options)
+      def initialize(app, *options)
         @app = app
-        @options = default_options.merge(**options)
+        @options = options.any? ? default_options.merge(options.shift) : default_options
         @app_response = nil
       end
 
@@ -74,11 +75,9 @@ module Grape
       end
 
       def mime_types
-        types_without_params = {}
-        content_types.each_pair do |k, v|
+        @mime_type ||= content_types.each_pair.with_object({}) do |(k, v), types_without_params|
           types_without_params[v.split(';').first] = k
         end
-        types_without_params
       end
 
       private