grape 1.3.3 → 1.6.2

data/lib/grape/dsl/desc.rb

@@ -50,7 +50,7 @@ module Grape
       #     end
       #
       def desc(description, options = {}, &config_block)
-        if block_given?
+        if config_block
           endpoint_configuration = if defined?(configuration)
                                      # When the instance is mounted - the configuration is executed on mount time
                                      if configuration.respond_to?(:evaluate)
@@ -68,9 +68,7 @@ module Grape
           end
 
           config_class.configure(&config_block)
-          unless options.empty?
-            warn '[DEPRECATION] Passing a options hash and a block to `desc` is deprecated. Move all hash options to block.'
-          end
+          warn '[DEPRECATION] Passing a options hash and a block to `desc` is deprecated. Move all hash options to block.' unless options.empty?
           options = config_class.settings
         else
           options = options.merge(description: description)
@@ -92,7 +90,7 @@ module Grape
 
       def unset_description_field(field)
         description = route_setting(:description)
-        description.delete(field) if description
+        description&.delete(field)
       end
 
       # Returns an object which configures itself via an instance-context DSL.

data/lib/grape/dsl/headers.rb

@@ -3,8 +3,11 @@
 module Grape
   module DSL
     module Headers
-      # Set an individual header or retrieve
-      # all headers that have been set.
+      # This method has four responsibilities:
+      # 1. Set a specifc header value by key
+      # 2. Retrieve a specifc header value by key
+      # 3. Retrieve all headers that have been set
+      # 4. Delete a specifc header key-value pair
       def header(key = nil, val = nil)
         if key
           val ? header[key.to_s] = val : header.delete(key.to_s)

data/lib/grape/dsl/helpers.rb

@@ -36,8 +36,8 @@ module Grape
         #
         def helpers(*new_modules, &block)
           include_new_modules(new_modules) if new_modules.any?
-          include_block(block) if block_given?
-          include_all_in_scope if !block_given? && new_modules.empty?
+          include_block(block) if block
+          include_all_in_scope if !block && new_modules.empty?
         end
 
         protected
@@ -67,12 +67,13 @@ module Grape
 
         def define_boolean_in_mod(mod)
           return if defined? mod::Boolean
-          mod.const_set('Boolean', Grape::API::Boolean)
+
+          mod.const_set(:Boolean, Grape::API::Boolean)
         end
 
-        def inject_api_helpers_to_mod(mod, &_block)
+        def inject_api_helpers_to_mod(mod, &block)
           mod.extend(BaseHelper) unless mod.is_a?(BaseHelper)
-          yield if block_given?
+          yield if block
           mod.api_changed(self)
         end
       end
@@ -81,6 +82,7 @@ module Grape
       # to provide some API-specific functionality.
       module BaseHelper
         attr_accessor :api
+
         def params(name, &block)
           @named_params ||= {}
           @named_params[name] = block
@@ -95,6 +97,7 @@ module Grape
 
         def process_named_params
           return unless instance_variable_defined?(:@named_params) && @named_params && @named_params.any?
+
           api.namespace_stackable(:named_params, @named_params)
         end
       end

data/lib/grape/dsl/inside_route.rb

@@ -48,6 +48,8 @@ module Grape
         end
 
         def declared_hash(passed_params, options, declared_params, params_nested_path)
+          renamed_params = route_setting(:renamed_params) || {}
+
           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|
@@ -55,82 +57,72 @@ module Grape
                 params_nested_path_dup << declared_parent_param.to_s
                 next unless options[:include_missing] || passed_params.key?(declared_parent_param)
 
+                rename_path = params_nested_path + [declared_parent_param.to_s]
+                renamed_param_name = renamed_params[rename_path]
+
+                memo_key = optioned_param_key(renamed_param_name || declared_parent_param, options)
                 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(passed_children_params, params_nested_path_dup) do
+                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
               # If it is not a Hash then it does not have children.
               # Find its value or set it to nil.
-              has_renaming = route_setting(:renamed_params) && route_setting(:renamed_params).find { |current| current[declared_param] }
-              param_renaming = has_renaming[declared_param] if has_renaming
+              next unless options[:include_missing] || passed_params.key?(declared_param)
+
+              rename_path = params_nested_path + [declared_param.to_s]
+              renamed_param_name = renamed_params[rename_path]
 
-              next unless options[:include_missing] || passed_params.key?(declared_param) || (param_renaming && passed_params.key?(param_renaming))
+              memo_key = optioned_param_key(renamed_param_name || declared_param, options)
+              passed_param = passed_params[declared_param]
 
-              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]
+              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(passed_children_params, params_nested_path, &_block)
-          if should_be_empty_hash?(passed_children_params, params_nested_path)
+        def handle_passed_param(params_nested_path, has_passed_children = false, &_block)
+          return yield if has_passed_children
+
+          key = params_nested_path[0]
+          key += "[#{params_nested_path[1..-1].join('][')}]" if params_nested_path.size > 1
+
+          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) }
+
+          if type == 'Hash' && !has_children
             {}
-          elsif should_be_empty_array?(passed_children_params, params_nested_path)
+          elsif type == 'Array' || (type&.start_with?('[') && !type&.include?(','))
             []
+          elsif type == 'Set' || type&.start_with?('#<Set')
+            Set.new
           else
             yield
           end
         end
 
-        def should_be_empty_array?(passed_children_params, params_nested_path)
-          passed_children_params.empty? && declared_param_is_array?(params_nested_path)
-        end
-
-        def declared_param_is_array?(params_nested_path)
-          key = route_options_params_key(params_nested_path)
-          route_options_params[key] && route_options_params[key][:type] == 'Array'
-        end
-
-        def should_be_empty_hash?(passed_children_params, params_nested_path)
-          passed_children_params.empty? && declared_param_is_hash?(params_nested_path)
-        end
-
-        def declared_param_is_hash?(params_nested_path)
-          key = route_options_params_key(params_nested_path)
-          route_options_params[key] && route_options_params[key][:type] == 'Hash'
-        end
-
-        def route_options_params
-          options[:route_options][:params] || {}
-        end
-
         def optioned_param_key(declared_param, options)
           options[:stringify] ? declared_param.to_s : declared_param.to_sym
         end
 
-        def route_options_params_key(params_nested_path)
-          key = params_nested_path[0]
-          key += '[' + params_nested_path[1..-1].join('][') + ']' if params_nested_path.size > 1
-          key
-        end
-
         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
+
           declared_params
         end
       end
@@ -201,11 +193,13 @@ module Grape
         case status
         when Symbol
           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 instance_variable_defined?(:@status) && @status
+
           case request.request_method.to_s.upcase
           when Grape::Http::Headers::POST
             201
@@ -279,23 +273,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
-          instance_variable_defined?(:@file) ? @file : nil
+          stream
         end
       end
 
@@ -315,10 +322,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
@@ -359,6 +377,7 @@ module Grape
           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)
         end
 
@@ -389,7 +408,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
@@ -411,7 +430,7 @@ module Grape
       def entity_representation_for(entity_class, object, options)
         embeds = { env: env }
         embeds[:version] = env[Grape::Env::API_VERSION] if env[Grape::Env::API_VERSION]
-        entity_class.represent(object, embeds.merge(options))
+        entity_class.represent(object, **embeds.merge(options))
       end
     end
   end

data/lib/grape/dsl/middleware.rb

@@ -18,28 +18,28 @@ module Grape
         #   to inject.
         def use(middleware_class, *args, &block)
           arr = [:use, middleware_class, *args]
-          arr << block if block_given?
+          arr << block if block
 
           namespace_stackable(:middleware, arr)
         end
 
         def insert(*args, &block)
           arr = [:insert, *args]
-          arr << block if block_given?
+          arr << block if block
 
           namespace_stackable(:middleware, arr)
         end
 
         def insert_before(*args, &block)
           arr = [:insert_before, *args]
-          arr << block if block_given?
+          arr << block if block
 
           namespace_stackable(:middleware, arr)
         end
 
         def insert_after(*args, &block)
           arr = [:insert_after, *args]
-          arr << block if block_given?
+          arr << block if block
 
           namespace_stackable(:middleware, arr)
         end

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
@@ -133,7 +133,7 @@ module Grape
           require_required_and_optional_fields(attrs.first, opts)
         else
           validate_attributes(attrs, opts, &block)
-          block_given? ? new_scope(orig_attrs, &block) : push_declared_params(attrs, **opts.slice(:as))
+          block ? new_scope(orig_attrs, &block) : push_declared_params(attrs, **opts.slice(:as))
         end
       end
 
@@ -149,7 +149,7 @@ module Grape
         opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
 
         # check type for optional parameter group
-        if attrs && block_given?
+        if attrs && block
           raise Grape::Exceptions::MissingGroupTypeError.new if type.nil?
           raise Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
@@ -159,7 +159,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block_given? ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, **opts.slice(:as))
+          block ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, **opts.slice(:as))
         end
       end
 
@@ -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

data/lib/grape/dsl/request_response.rb

@@ -26,6 +26,7 @@ module Grape
             # define a single mime type
             mime_type = content_types[new_format.to_sym]
             raise Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
+
             namespace_stackable(:content_types, new_format.to_sym => mime_type)
           else
             namespace_inheritable(:format)
@@ -102,14 +103,13 @@ module Grape
         def rescue_from(*args, &block)
           if args.last.is_a?(Proc)
             handler = args.pop
-          elsif block_given?
+          elsif block
             handler = block
           end
 
           options = args.extract_options!
-          if block_given? && options.key?(:with)
-            raise ArgumentError, 'both :with option and block cannot be passed'
-          end
+          raise ArgumentError, 'both :with option and block cannot be passed' if block && options.key?(:with)
+
           handler ||= extract_with(options)
 
           if args.include?(:all)
@@ -127,7 +127,7 @@ module Grape
                 :base_only_rescue_handlers
               end
 
-            namespace_reverse_stackable handler_type, Hash[args.map { |arg| [arg, handler] }]
+            namespace_reverse_stackable handler_type, args.map { |arg| [arg, handler] }.to_h
           end
 
           namespace_stackable(:rescue_options, options)
@@ -154,7 +154,8 @@ module Grape
         # @param model_class [Class] The model class that will be represented.
         # @option options [Class] :with The entity class that will represent the model.
         def represent(model_class, options)
-          raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
+          raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with].is_a?(Class)
+
           namespace_stackable(:representations, model_class => options[:with])
         end
 
@@ -162,9 +163,11 @@ module Grape
 
         def extract_with(options)
           return unless options.key?(:with)
+
           with_option = options.delete(:with)
           return with_option if with_option.instance_of?(Proc)
           return with_option.to_sym if with_option.instance_of?(Symbol) || with_option.instance_of?(String)
+
           raise ArgumentError, "with: #{with_option.class}, expected Symbol, String or Proc"
         end
       end

data/lib/grape/dsl/routing.rb

@@ -38,7 +38,7 @@ module Grape
 
             @versions = versions | requested_versions
 
-            if block_given?
+            if block
               within_namespace do
                 namespace_inheritable(:version, requested_versions)
                 namespace_inheritable(:version_options, options)
@@ -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
@@ -151,7 +152,7 @@ module Grape
         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.
         #
@@ -165,14 +166,12 @@ module Grape
         def namespace(space = nil, options = {}, &block)
           @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description
 
-          if space || block_given?
+          if space || block
             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
@@ -201,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/settings.rb

@@ -103,12 +103,14 @@ module Grape
       def namespace_stackable_with_hash(key)
         settings = get_or_set :namespace_stackable, key, nil
         return if settings.blank?
+
         settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
       end
 
       def namespace_reverse_stackable_with_hash(key)
         settings = get_or_set :namespace_reverse_stackable, key, nil
         return if settings.blank?
+
         result = {}
         settings.each do |setting|
           setting.each do |field, value|
@@ -154,10 +156,10 @@ module Grape
 
       # Execute the block within a context where our inheritable settings are forked
       # to a new copy (see #namespace_start).
-      def within_namespace(&_block)
+      def within_namespace(&block)
         namespace_start
 
-        result = yield if block_given?
+        result = yield if block
 
         namespace_end
         reset_validations!
@@ -175,9 +177,7 @@ module Grape
           # +inheritable_setting+, however, it doesn't contain any user-defined settings.
           # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
           # in the chain for every endpoint.
-          if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
-            setting.inherit_from superclass.inheritable_setting
-          end
+          setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
         end
       end
     end

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