grape 1.3.1 → 1.5.1

data/lib/grape.rb

@@ -206,12 +206,12 @@ module Grape
     end
   end
 
-  module ServeFile
+  module ServeStream
     extend ::ActiveSupport::Autoload
     eager_autoload do
-      autoload :FileResponse
       autoload :FileBody
       autoload :SendfileResponse
+      autoload :StreamResponse
     end
   end
 end

data/lib/grape/api.rb

@@ -30,7 +30,7 @@ module Grape
       # an instance that will be used to create the set up but will not be mounted
       def initial_setup(base_instance_parent)
         @instances = []
-        @setup = []
+        @setup = Set.new
         @base_parent = base_instance_parent
         @base_instance = mount_instance
       end
@@ -90,7 +90,7 @@ module Grape
       # For instance, a descripcion could be done using: `desc configuration[:description]` if it may vary
       # depending on where the endpoint is mounted. Use with care, if you find yourself using configuration
       # too much, you may actually want to provide a new API rather than remount it.
-      def mount_instance(opts = {})
+      def mount_instance(**opts)
         instance = Class.new(@base_parent)
         instance.configuration = Grape::Util::EndpointConfiguration.new(opts[:configuration] || {})
         instance.base = self

data/lib/grape/api/instance.rb

@@ -192,36 +192,15 @@ module Grape
       # will return an HTTP 405 response for any HTTP method that the resource
       # cannot handle.
       def add_head_not_allowed_methods_and_options_methods
-        routes_map = {}
-
-        self.class.endpoints.each do |endpoint|
-          routes = endpoint.routes
-          routes.each do |route|
-            # using the :any shorthand produces [nil] for route methods, substitute all manually
-            route_key = route.pattern.to_regexp
-            routes_map[route_key] ||= {}
-            route_settings = routes_map[route_key]
-            route_settings[:pattern] = route.pattern
-            route_settings[:requirements] = route.requirements
-            route_settings[:path] = route.origin
-            route_settings[:methods] ||= []
-            route_settings[:methods] << route.request_method
-            route_settings[:endpoint] = route.app
-
-            # using the :any shorthand produces [nil] for route methods, substitute all manually
-            route_settings[:methods] = Grape::Http::Headers::SUPPORTED_METHODS if route_settings[:methods].include?('*')
-          end
-        end
-
+        versioned_route_configs = collect_route_config_per_pattern
         # The paths we collected are prepared (cf. Path#prepare), so they
         # contain already versioning information when using path versioning.
         # Disable versioning so adding a route won't prepend versioning
         # informations again.
         without_root_prefix do
           without_versioning do
-            routes_map.each_value do |config|
-              methods = config[:methods]
-              allowed_methods = methods.dup
+            versioned_route_configs.each do |config|
+              allowed_methods = config[:methods].dup
 
               unless self.class.namespace_inheritable(:do_not_route_head)
                 allowed_methods |= [Grape::Http::Headers::HEAD] if allowed_methods.include?(Grape::Http::Headers::GET)
@@ -240,14 +219,36 @@ module Grape
         end
       end
 
+      def collect_route_config_per_pattern
+        all_routes       = self.class.endpoints.map(&:routes).flatten
+        routes_by_regexp = all_routes.group_by { |route| route.pattern.to_regexp }
+
+        # Build the configuration based on the first endpoint and the collection of methods supported.
+        routes_by_regexp.values.map do |routes|
+          last_route        = routes.last # Most of the configuration is taken from the last endpoint
+          matching_wildchar = routes.any? { |route| route.request_method == '*' }
+          {
+            options: {},
+            pattern: last_route.pattern,
+            requirements: last_route.requirements,
+            path: last_route.origin,
+            endpoint: last_route.app,
+            methods: matching_wildchar ? Grape::Http::Headers::SUPPORTED_METHODS : routes.map(&:request_method)
+          }
+        end
+      end
+
       # Generate a route that returns an HTTP 405 response for a user defined
       # path on methods not specified
       def generate_not_allowed_method(pattern, allowed_methods: [], **attributes)
-        not_allowed_methods = %w[GET PUT POST DELETE PATCH HEAD] - allowed_methods
-        not_allowed_methods << Grape::Http::Headers::OPTIONS if self.class.namespace_inheritable(:do_not_route_options)
-
+        supported_methods =
+          if self.class.namespace_inheritable(:do_not_route_options)
+            Grape::Http::Headers::SUPPORTED_METHODS
+          else
+            Grape::Http::Headers::SUPPORTED_METHODS_WITHOUT_OPTIONS
+          end
+        not_allowed_methods = supported_methods - allowed_methods
         return if not_allowed_methods.empty?
-
         @router.associate_routes(pattern, not_allowed_methods: not_allowed_methods, **attributes)
       end
 

data/lib/grape/dsl/helpers.rb

@@ -81,6 +81,7 @@ module Grape
       # to provide some API-specific functionality.
       module BaseHelper
         attr_accessor :api
+
         def params(name, &block)
           @named_params ||= {}
           @named_params[name] = block

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
@@ -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
-          instance_variable_defined?(:@file) ? @file : nil
+          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
@@ -388,7 +421,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/parameters.rb

@@ -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/routing.rb

@@ -79,7 +79,7 @@ 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)
@@ -170,9 +170,7 @@ module Grape
               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

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/http/headers.rb

@@ -21,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'

data/lib/grape/middleware/base.rb

@@ -8,6 +8,7 @@ module Grape
       include Helpers
 
       attr_reader :app, :env, :options
+
       TEXT_HTML = 'text/html'
 
       include Grape::DSL::Headers
@@ -16,7 +17,7 @@ module Grape
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
       def initialize(app, **options)
         @app = app
-        @options = default_options.merge(**options)
+        @options = default_options.merge(options)
         @app_response = nil
       end