grape 2.2.0 → 2.4.0

data/lib/grape/api.rb

@@ -5,7 +5,7 @@ module Grape
   # should subclass this class in order to build an API.
   class API
     # Class methods that we want to call on the API rather than on the API object
-    NON_OVERRIDABLE = %i[call call! configuration compile! inherited].freeze
+    NON_OVERRIDABLE = %i[call call! configuration compile! inherited recognize_path].freeze
 
     class Boolean
       def self.build(val)
@@ -20,12 +20,18 @@ module Grape
     end
 
     class << self
+      extend Forwardable
       attr_accessor :base_instance, :instances
 
-      # Rather than initializing an object of type Grape::API, create an object of type Instance
-      def new(...)
-        base_instance.new(...)
-      end
+      delegate_missing_to :base_instance
+      def_delegators :base_instance, :new, :configuration
+
+      # This is the interface point between Rack and Grape; it accepts a request
+      # from Rack and ultimately returns an array of three values: the status,
+      # the headers, and the body. See [the rack specification]
+      # (http://www.rubydoc.info/github/rack/rack/master/file/SPEC) for more.
+      # NOTE: This will only be called on an API directly mounted on RACK
+      def_delegators :instance_for_rack, :call, :compile!
 
       # When inherited, will create a list of all instances (times the API was mounted)
       # It will listen to the setup required to mount that endpoint, and replicate it on any new instance
@@ -40,7 +46,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 = Set.new
+        @setup = []
         @base_parent = base_instance_parent
         @base_instance = mount_instance
       end
@@ -49,7 +55,7 @@ module Grape
       def override_all_methods!
         (base_instance.methods - Class.methods - NON_OVERRIDABLE).each do |method_override|
           define_singleton_method(method_override) do |*args, &block|
-            add_setup(method_override, *args, &block)
+            add_setup(method: method_override, args: args, block: block)
           end
         end
       end
@@ -69,67 +75,28 @@ module Grape
         end
       end
 
-      # This is the interface point between Rack and Grape; it accepts a request
-      # from Rack and ultimately returns an array of three values: the status,
-      # the headers, and the body. See [the rack specification]
-      # (http://www.rubydoc.info/github/rack/rack/master/file/SPEC) for more.
-      # NOTE: This will only be called on an API directly mounted on RACK
-      def call(...)
-        instance_for_rack.call(...)
-      end
-
-      # Alleviates problems with autoloading by tring to search for the constant
-      def const_missing(*args)
-        if base_instance.const_defined?(*args)
-          base_instance.const_get(*args)
-        else
-          super
-        end
-      end
-
       # The remountable class can have a configuration hash to provide some dynamic class-level variables.
       # For instance, a description 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)
-        instance = Class.new(@base_parent)
-        instance.configuration = Grape::Util::EndpointConfiguration.new(opts[:configuration] || {})
-        instance.base = self
-        replay_setup_on(instance)
-        instance
+      def mount_instance(configuration: nil)
+        Class.new(@base_parent).tap do |instance|
+          instance.configuration = Grape::Util::EndpointConfiguration.new(configuration || {})
+          instance.base = self
+          replay_setup_on(instance)
+        end
       end
 
+      private
+
       # Replays the set up to produce an API as defined in this class, can be called
       # on classes that inherit from Grape::API
       def replay_setup_on(instance)
         @setup.each do |setup_step|
-          replay_step_on(instance, setup_step)
-        end
-      end
-
-      def respond_to?(method, include_private = false)
-        super || base_instance.respond_to?(method, include_private)
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        base_instance.respond_to?(method, include_private)
-      end
-
-      def method_missing(method, *args, &block)
-        # If there's a missing method, it may be defined on the base_instance instead.
-        if respond_to_missing?(method)
-          base_instance.send(method, *args, &block)
-        else
-          super
+          replay_step_on(instance, **setup_step)
         end
       end
 
-      def compile!
-        instance_for_rack.compile! # See API::Instance.compile!
-      end
-
-      private
-
       def instance_for_rack
         if never_mounted?
           base_instance
@@ -139,34 +106,35 @@ module Grape
       end
 
       # Adds a new stage to the set up require to get a Grape::API up and running
-      def add_setup(method, *args, &block)
-        setup_step = { method: method, args: args, block: block }
-        @setup += [setup_step]
+      def add_setup(step)
+        @setup << step
         last_response = nil
         @instances.each do |instance|
-          last_response = replay_step_on(instance, setup_step)
+          last_response = replay_step_on(instance, **step)
         end
 
-        # Updating all previously mounted classes in the case that new methods have been executed.
-        if method != :mount && @setup.any?
-          previous_mount_steps = @setup.select { |step| step[:method] == :mount }
-          previous_mount_steps.each do |mount_step|
-            refresh_mount_step = mount_step.merge(method: :refresh_mounted_api)
-            @setup += [refresh_mount_step]
-            @instances.each do |instance|
-              replay_step_on(instance, refresh_mount_step)
-            end
+        refresh_mount_step if step[:method] != :mount
+        last_response
+      end
+
+      # Updating all previously mounted classes in the case that new methods have been executed.
+      def refresh_mount_step
+        @setup.each do |setup_step|
+          next if setup_step[:method] != :mount
+
+          refresh_mount_step = setup_step.merge(method: :refresh_mounted_api)
+          @setup << refresh_mount_step
+          @instances.each do |instance|
+            replay_step_on(instance, **refresh_mount_step)
           end
         end
-
-        last_response
       end
 
-      def replay_step_on(instance, setup_step)
-        return if skip_immediate_run?(instance, setup_step[:args])
+      def replay_step_on(instance, method:, args:, block:)
+        return if skip_immediate_run?(instance, args)
 
-        args = evaluate_arguments(instance.configuration, *setup_step[:args])
-        response = instance.send(setup_step[:method], *args, &setup_step[:block])
+        eval_args = evaluate_arguments(instance.configuration, *args)
+        response = instance.send(method, *eval_args, &block)
         if skip_immediate_run?(instance, [response])
           response
         else
@@ -181,12 +149,12 @@ module Grape
       end
 
       def any_lazy?(args)
-        args.any? { |argument| argument.respond_to?(:lazy?) && argument.lazy? }
+        args.any? { |argument| argument.try(:lazy?) }
       end
 
       def evaluate_arguments(configuration, *args)
         args.map do |argument|
-          if argument.respond_to?(:lazy?) && argument.lazy?
+          if argument.try(:lazy?)
             argument.evaluate_from(configuration)
           elsif argument.is_a?(Hash)
             argument.transform_values { |value| evaluate_arguments(configuration, value).first }

data/lib/grape/cookies.rb

@@ -2,43 +2,49 @@
 
 module Grape
   class Cookies
-    def initialize
-      @cookies = {}
-      @send_cookies = {}
-    end
+    extend Forwardable
 
-    def read(request)
-      request.cookies.each do |name, value|
-        @cookies[name.to_s] = value
-      end
+    DELETED_COOKIES_ATTRS = {
+      max_age: '0',
+      value: '',
+      expires: Time.at(0)
+    }.freeze
+
+    def_delegators :cookies, :[], :each
+
+    def initialize(rack_cookies)
+      @cookies = rack_cookies
+      @send_cookies = nil
     end
 
-    def write(header)
-      @cookies.select { |key, _value| @send_cookies[key] == true }.each do |name, value|
-        cookie_value = value.is_a?(Hash) ? value : { value: value }
-        Rack::Utils.set_cookie_header! header, name, cookie_value
+    def response_cookies
+      return unless @send_cookies
+
+      send_cookies.each do |name|
+        yield name, cookies[name]
       end
     end
 
-    def [](name)
-      @cookies[name.to_s]
+    def []=(name, value)
+      cookies[name] = value
+      send_cookies << name
     end
 
-    def []=(name, value)
-      @cookies[name.to_s] = value
-      @send_cookies[name.to_s] = true
+    # see https://github.com/rack/rack/blob/main/lib/rack/utils.rb#L338-L340
+    def delete(name, **opts)
+      self.[]=(name, opts.merge(DELETED_COOKIES_ATTRS))
     end
 
-    def each(&block)
-      @cookies.each(&block)
+    private
+
+    def cookies
+      return @cookies unless @cookies.is_a?(Proc)
+
+      @cookies = @cookies.call.with_indifferent_access
     end
 
-    # see https://github.com/rack/rack/blob/main/lib/rack/utils.rb#L338-L340
-    # rubocop:disable Layout/SpaceBeforeBrackets
-    def delete(name, **opts)
-      options = opts.merge(max_age: '0', value: '', expires: Time.at(0))
-      self.[]=(name, options)
+    def send_cookies
+      @send_cookies ||= Set.new
     end
-    # rubocop:enable Layout/SpaceBeforeBrackets
   end
 end

data/lib/grape/dsl/api.rb

@@ -5,8 +5,6 @@ module Grape
     module API
       extend ActiveSupport::Concern
 
-      include Grape::Middleware::Auth::DSL
-
       include Grape::DSL::Validations
       include Grape::DSL::Callbacks
       include Grape::DSL::Configuration

data/lib/grape/dsl/desc.rb

@@ -70,33 +70,23 @@ module Grape
       #       # ...
       #     end
       #
-      def desc(description, options = {}, &config_block)
-        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)
-                                       configuration.evaluate
-                                     # Within `given` or `mounted blocks` the configuration is already evaluated
-                                     elsif configuration.is_a?(Hash)
-                                       configuration
-                                     end
-                                   end
-          endpoint_configuration ||= {}
-          config_class = desc_container(endpoint_configuration)
+      def desc(description, options = nil, &config_block)
+        opts =
+          if config_block
+            desc_container(endpoint_configuration).then do |config_class|
+              config_class.configure do
+                description(description)
+              end
 
-          config_class.configure do
-            description description
+              config_class.configure(&config_block)
+              config_class.settings
+            end
+          else
+            options&.merge(description: description) || { description: description }
           end
 
-          config_class.configure(&config_block)
-          Grape.deprecator.warn('Passing a options hash and a block to `desc` is deprecated. Move all hash options to block.') if options.any?
-          options = config_class.settings
-        else
-          options = options.merge(description: description)
-        end
-
-        namespace_setting :description, options
-        route_setting :description, options
+        namespace_setting :description, opts
+        route_setting :description, opts
       end
 
       # Returns an object which configures itself via an instance-context DSL.
@@ -116,6 +106,19 @@ module Grape
           end
         end
       end
+
+      private
+
+      def endpoint_configuration
+        return {} unless defined?(configuration)
+
+        if configuration.respond_to?(:evaluate)
+          configuration.evaluate
+          # Within `given` or `mounted blocks` the configuration is already evaluated
+        elsif configuration.is_a?(Hash)
+          configuration
+        end
+      end
     end
   end
 end

data/lib/grape/dsl/headers.rb

@@ -10,7 +10,7 @@ module Grape
       # 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)
+          val ? header[key] = val : header.delete(key)
         else
           @header ||= Grape::Util::Header.new
         end

data/lib/grape/dsl/helpers.rb

@@ -98,7 +98,7 @@ module Grape
         protected
 
         def process_named_params
-          return unless instance_variable_defined?(:@named_params) && @named_params && @named_params.any?
+          return if @named_params.blank?
 
           api.namespace_stackable(:named_params, @named_params)
         end

data/lib/grape/dsl/inside_route.rb

@@ -26,8 +26,8 @@ module Grape
       # has completed
       module PostBeforeFilter
         def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
-          options = options.reverse_merge(include_missing: true, include_parent_namespaces: true, evaluate_given: false)
-          declared_params ||= optioned_declared_params(**options)
+          options.reverse_merge!(include_missing: true, include_parent_namespaces: true, evaluate_given: false)
+          declared_params ||= optioned_declared_params(options[:include_parent_namespaces])
 
           res = if passed_params.is_a?(Array)
                   declared_array(passed_params, options, declared_params, params_nested_path)
@@ -79,7 +79,7 @@ module Grape
           else
             # If it is not a Hash then it does not have children.
             # Find its value or set it to nil.
-            return unless options[:include_missing] || passed_params.key?(declared_param)
+            return unless options[:include_missing] || passed_params.try(:key?, declared_param)
 
             rename_path = params_nested_path + [declared_param.to_s]
             renamed_param_name = renamed_params[rename_path]
@@ -107,7 +107,7 @@ module Grape
 
           if type == 'Hash' && !has_children
             {}
-          elsif type == 'Array' || (type&.start_with?('[') && type&.exclude?(','))
+          elsif type == 'Array' || (type&.start_with?('[') && type.exclude?(','))
             []
           elsif type == 'Set' || type&.start_with?('#<Set')
             Set.new
@@ -120,8 +120,8 @@ module Grape
           options[:stringify] ? declared_param.to_s : declared_param.to_sym
         end
 
-        def optioned_declared_params(**options)
-          declared_params = if options[:include_parent_namespaces]
+        def optioned_declared_params(include_parent_namespaces)
+          declared_params = if include_parent_namespaces
                               # Declared params including parent namespaces
                               route_setting(:declared_params)
                             else
@@ -199,10 +199,9 @@ module Grape
       # Redirect to a new url.
       #
       # @param url [String] The url to be redirect.
-      # @param options [Hash] The options used when redirect.
-      #                       :permanent, default false.
-      #                       :body, default a short message including the URL.
-      def redirect(url, permanent: false, body: nil, **_options)
+      # @param permanent [Boolean] default false.
+      # @param body default a short message including the URL.
+      def redirect(url, permanent: false, body: nil)
         body_message = body
         if permanent
           status 301
@@ -214,7 +213,7 @@ module Grape
           status 302
           body_message ||= "This resource has been moved temporarily to #{url}."
         end
-        header Grape::Http::Headers::LOCATION, url
+        header 'Location', url
         content_type 'text/plain'
         body body_message
       end
@@ -258,18 +257,6 @@ module Grape
         end
       end
 
-      # Set or get a cookie
-      #
-      # @example
-      #   cookies[:mycookie] = 'mycookie val'
-      #   cookies['mycookie-string'] = 'mycookie string val'
-      #   cookies[:more] = { value: '123', expires: Time.at(0) }
-      #   cookies.delete :more
-      #
-      def cookies
-        @cookies ||= Cookies.new
-      end
-
       # Allows you to define the response body as something other than the
       # return value.
       #
@@ -305,20 +292,6 @@ module Grape
         body false
       end
 
-      # Deprecated method to send files to the client. Use `sendfile` or `stream`
-      def file(value = nil)
-        if value.is_a?(String)
-          Grape.deprecator.warn('Use sendfile or stream to send files.')
-          sendfile(value)
-        elsif !value.is_a?(NilClass)
-          Grape.deprecator.warn('Use stream to use a Stream object.')
-          stream(value)
-        else
-          Grape.deprecator.warn('Use sendfile or stream to send files.')
-          sendfile
-        end
-      end
-
       # Allows you to send a file to the client via sendfile.
       #
       # @example
@@ -357,7 +330,7 @@ module Grape
         return if value.nil? && @stream.nil?
 
         header Rack::CONTENT_LENGTH, nil
-        header Grape::Http::Headers::TRANSFER_ENCODING, nil
+        header 'Transfer-Encoding', nil
         header Rack::CACHE_CONTROL, 'no-cache' # Skips ETag generation (reading the response up front)
         if value.is_a?(String)
           file_body = Grape::ServeStream::FileBody.new(value)
@@ -462,11 +435,15 @@ module Grape
       def entity_representation_for(entity_class, object, options)
         embeds = { env: env }
         embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
-        entity_class.represent(object, **embeds.merge(options))
+        entity_class.represent(object, **embeds, **options)
       end
 
       def http_version
-        env['HTTP_VERSION'] || env[Rack::SERVER_PROTOCOL]
+        env.fetch('HTTP_VERSION') { env[Rack::SERVER_PROTOCOL] }
+      end
+
+      def api_format(format)
+        env[Grape::Env::API_FORMAT] = format
       end
 
       def context

data/lib/grape/dsl/parameters.rb

@@ -23,14 +23,14 @@ module Grape
       #     class API < Grape::API
       #       desc "Get collection"
       #       params do
-      #         build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+      #         build_with :hashie_mash
       #         requires :user_id, type: Integer
       #       end
       #       get do
       #         params['user_id']
       #       end
       #     end
-      def build_with(build_with = nil)
+      def build_with(build_with)
         @api.namespace_inheritable(:build_params_with, build_with)
       end
 
@@ -136,7 +136,7 @@ module Grape
           require_required_and_optional_fields(attrs.first, opts)
         else
           validate_attributes(attrs, opts, &block)
-          block ? 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
 
@@ -162,7 +162,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block ? 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
 
@@ -251,7 +251,7 @@ module Grape
       # @return hash of parameters relevant for the current scope
       # @api private
       def params(params)
-        params = @parent.params(params) if instance_variable_defined?(:@parent) && @parent
+        params = @parent.params_meeting_dependency.presence || @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

@@ -67,6 +67,10 @@ module Grape
           end
         end
 
+        def build_with(build_with)
+          namespace_inheritable(:build_params_with, build_with)
+        end
+
         # Do not route HEAD requests to GET requests automatically.
         def do_not_route_head!
           namespace_inheritable(:do_not_route_head, true)
@@ -77,6 +81,10 @@ module Grape
           namespace_inheritable(:do_not_route_options, true)
         end
 
+        def lint!
+          namespace_inheritable(:lint, true)
+        end
+
         def do_not_document!
           namespace_inheritable(:do_not_document, true)
         end
@@ -154,7 +162,7 @@ module Grape
           reset_validations!
         end
 
-        Grape::Http::Headers::SUPPORTED_METHODS.each do |supported_method|
+        Grape::HTTP_SUPPORTED_METHODS.each do |supported_method|
           define_method supported_method.downcase do |*args, &block|
             options = args.extract_options!
             paths = args.first || ['/']
@@ -175,19 +183,12 @@ module Grape
         #       end
         #     end
         def namespace(space = nil, options = {}, &block)
-          @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description
-
-          if space || block
-            within_namespace do
-              previous_namespace_description = @namespace_description
-              @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {})
-              nest(block) do
-                namespace_stackable(:namespace, Namespace.new(space, **options)) if space
-              end
-              @namespace_description = previous_namespace_description
+          return Namespace.joined_space_path(namespace_stackable(:namespace)) unless space || block
+
+          within_namespace do
+            nest(block) do
+              namespace_stackable(:namespace, Namespace.new(space, options)) if space
             end
-          else
-            Namespace.joined_space_path(namespace_stackable(:namespace))
           end
         end