grape 1.8.0 → 3.3.5

data/lib/grape/endpoint.rb

@@ -6,65 +6,40 @@ module Grape
   # on the instance level of this class may be called
   # from inside a `get`, `post`, etc.
   class Endpoint
+    extend Forwardable
     include Grape::DSL::Settings
+    include Grape::DSL::Headers
     include Grape::DSL::InsideRoute
 
-    attr_accessor :block, :source, :options
-    attr_reader :env, :request, :headers, :params
+    attr_reader :env, :request, :source, :options, :endpoints
+    attr_accessor :options_route_enabled
 
-    class << self
-      def new(*args, &block)
-        self == Endpoint ? Class.new(Endpoint).new(*args, &block) : super
-      end
+    def_delegators :request, :params, :headers, :cookies
+    def_delegator :cookies, :response_cookies
 
-      def before_each(new_setup = false, &block)
-        @before_each ||= []
-        if new_setup == false
-          return @before_each unless block
-
-          @before_each << block
-        else
-          @before_each = [new_setup]
-        end
-      end
+    # The logger configured on the API this endpoint belongs to. Available
+    # inside route handlers, +before+/+after+/+after_validation+/+finally+
+    # filters, and +rescue_from+ blocks.
+    def logger
+      config.for.logger
+    end
 
-      def run_before_each(endpoint)
-        superclass.run_before_each(endpoint) unless self == Endpoint
-        before_each.each { |blk| blk.call(endpoint) if blk.respond_to?(:call) }
-      end
+    class << self
+      def block_to_unbound_method(block)
+        return unless block
 
-      # @api private
-      #
-      # Create an UnboundMethod that is appropriate for executing an endpoint
-      # route.
-      #
-      # The unbound method allows explicit calls to +return+ without raising a
-      # +LocalJumpError+. The method will be removed, but a +Proc+ reference to
-      # it will be returned. The returned +Proc+ expects a single argument: the
-      # instance of +Endpoint+ to bind to the method during the call.
-      #
-      # @param [String, Symbol] method_name
-      # @return [Proc]
-      # @raise [NameError] an instance method with the same name already exists
-      def generate_api_method(method_name, &block)
-        raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name") if method_defined?(method_name)
-
-        define_method(method_name, &block)
-        method = instance_method(method_name)
-        remove_method(method_name)
-
-        proc do |endpoint_instance|
-          ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do
-            method.bind(endpoint_instance).call
-          end
-        end
+        define_method :temp_unbound_method, block
+        method = instance_method(:temp_unbound_method)
+        remove_method :temp_unbound_method
+        method
       end
     end
 
     # Create a new endpoint.
     # @param new_settings [InheritableSetting] settings to determine the params,
     #   validations, and other properties from.
-    # @param options [Hash] attributes of this endpoint
+    # @param options [Hash] attributes of this endpoint, normalized into a
+    #   +Grape::Endpoint::Options+ value object.
     # @option options path [String or Array] the path to this endpoint, within
     #   the current scope.
     # @option options method [String or Array] which HTTP method(s) can be used
@@ -73,69 +48,46 @@ module Grape
     # @note This happens at the time of API definition, so in this context the
     # endpoint does not know if it will be mounted under a different endpoint.
     # @yield a block defining what your API should do when this endpoint is hit
-    def initialize(new_settings, options = {}, &block)
-      require_option(options, :path)
-      require_option(options, :method)
-
+    def initialize(new_settings, **options, &block)
       self.inheritable_setting = new_settings.point_in_time_copy
 
       # 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))
+      inheritable_setting.route[:declared_params] = inheritable_setting.namespace_stackable[:declared_params].flatten
+      inheritable_setting.route[:saved_validations] = inheritable_setting.namespace_stackable[:validations].dup
 
-      namespace_stackable(:representations, []) unless namespace_stackable(:representations)
-      namespace_inheritable(:default_error_status, 500) unless namespace_inheritable(:default_error_status)
+      inheritable_setting.namespace_stackable[:representations] ||= []
+      inheritable_setting.namespace_inheritable[:default_error_status] ||= 500
 
       @options = options
-
-      @options[:path] = Array(options[:path])
-      @options[:path] << '/' if options[:path].empty?
-
-      @options[:method] = Array(options[:method])
-      @options[:route_options] ||= {}
-
-      @lazy_initialize_lock = Mutex.new
-      @lazy_initialized = nil
-      @block = nil
+      @options[:path] = Array(@options[:path])
+      @options[:path] << '/' if @options[:path].empty?
+      @options[:method] = Array(@options[:method])
+      @config = Options.new(**options)
 
       @status = nil
       @stream = nil
       @body = nil
-      @proc = nil
-
-      return unless block
-
-      @source = block
-      @block = self.class.generate_api_method(method_name, &block)
+      @source = self.class.block_to_unbound_method(block)
+      @before_filter_passed = false
+      @options_route_enabled = false
+      @endpoints = @config.app.endpoints if @config.app.respond_to?(:endpoints)
     end
 
     # Update our settings from a given set of stackable parameters. Used when
     # the endpoint's API is mounted under another one.
     def inherit_settings(namespace_stackable)
-      inheritable_setting.route[:saved_validations] += namespace_stackable[:validations]
+      parent_validations = namespace_stackable[:validations]
+      inheritable_setting.route[:saved_validations].concat(parent_validations) if parent_validations.any?
       parent_declared_params = namespace_stackable[:declared_params]
-
-      inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten) if parent_declared_params
+      inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten) if parent_declared_params.any?
 
       endpoints&.each { |e| e.inherit_settings(namespace_stackable) }
     end
 
-    def require_option(options, key)
-      raise Grape::Exceptions::MissingOption.new(key) unless options.key?(key)
-    end
-
-    def method_name
-      [options[:method],
-       Namespace.joined_space(namespace_stackable(:namespace)),
-       (namespace_stackable(:mount_path) || []).join('/'),
-       options[:path].join('/')]
-        .join(' ')
-    end
-
     def routes
-      @routes ||= endpoints ? endpoints.collect(&:routes).flatten : to_routes
+      @routes ||= endpoints&.flat_map(&:routes) || to_routes
     end
 
     def reset_routes!
@@ -146,122 +98,79 @@ module Grape
 
     def mount_in(router)
       if endpoints
-        endpoints.each { |e| e.mount_in(router) }
-      else
-        reset_routes!
-        routes.each do |route|
-          methods = [route.request_method]
-          methods << Grape::Http::Headers::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
-          methods.each do |method|
-            route = Grape::Router::Route.new(method, route.origin, **route.attributes.to_h) unless route.request_method == method
-            router.append(route.apply(self))
-          end
-        end
-      end
-    end
-
-    def to_routes
-      route_options = prepare_default_route_attributes
-      map_routes do |method, path|
-        path = prepare_path(path)
-        params = merge_route_options(**route_options.merge(suffix: path.suffix))
-        route = Router::Route.new(method, path.path, **params)
-        route.apply(self)
-      end.flatten
-    end
-
-    def prepare_routes_requirements
-      {}.merge!(*namespace_stackable(:namespace).map(&:requirements)).tap do |requirements|
-        endpoint_requirements = options.dig(:route_options, :requirements)
-        requirements.merge!(endpoint_requirements) if endpoint_requirements
+        compile!
+        return endpoints.each { |e| e.mount_in(router) }
       end
-    end
-
-    def prepare_default_route_attributes
-      {
-        namespace: namespace,
-        version: prepare_version,
-        requirements: prepare_routes_requirements,
-        prefix: namespace_inheritable(:root_prefix),
-        anchor: options[:route_options].fetch(:anchor, true),
-        settings: inheritable_setting.route.except(:declared_params, :saved_validations),
-        forward_match: options[:forward_match]
-      }
-    end
 
-    def prepare_version
-      version = namespace_inheritable(:version) || []
-      return if version.empty?
-
-      version.length == 1 ? version.first.to_s : version
-    end
-
-    def merge_route_options(**default)
-      options[:route_options].clone.merge!(**default)
-    end
-
-    def map_routes
-      options[:method].map { |method| options[:path].map { |path| yield method, path } }
-    end
+      reset_routes!
+      compile!
+      routes.each do |route|
+        router.append(route.apply(self))
+        next if inheritable_setting.namespace_inheritable[:do_not_route_head] || route.request_method != Rack::GET
 
-    def prepare_path(path)
-      path_settings = inheritable_setting.to_hash[:namespace_stackable].merge(inheritable_setting.to_hash[:namespace_inheritable])
-      Path.prepare(path, namespace, path_settings)
+        route.dup.then do |head_route|
+          head_route.convert_to_head_request!
+          router.append(head_route.apply(self))
+        end
+      end
     end
 
     def namespace
-      @namespace ||= Namespace.joined_space_path(namespace_stackable(:namespace))
+      @namespace ||= Namespace.joined_space_path(inheritable_setting.namespace_stackable[:namespace])
     end
 
     def call(env)
-      lazy_initialize!
       dup.call!(env)
     end
 
     def call!(env)
       env[Grape::Env::API_ENDPOINT] = self
       @env = env
+      # this adds the helpers only to the instance
+      singleton_class.include(@helpers) if @helpers
       @app.call(env)
     end
 
-    # Return the collection of endpoints within this endpoint.
-    # This is the case when an Grape::API mounts another Grape::API.
-    def endpoints
-      options[:app].endpoints if options[:app].respond_to?(:endpoints)
+    def ==(other)
+      other.is_a?(self.class) &&
+        config == other.config &&
+        inheritable_setting == other.inheritable_setting
     end
+    alias eql? ==
 
-    def equals?(e)
-      (options == e.options) && (inheritable_setting.to_hash == e.inheritable_setting.to_hash)
+    # The purpose of this override is solely for stripping internals when an error occurs while calling
+    # an endpoint through an api. See https://github.com/ruby-grape/grape/issues/2398
+    # Otherwise, it calls super.
+    def inspect
+      return super unless env
+
+      "#{self.class} in '#{route.origin}' endpoint"
     end
 
     protected
 
     def run
-      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
-        @header = {}
-        @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
-        @params = @request.params
-        @headers = @request.headers
+      instrument_run do
+        @request = Grape::Request.new(env, build_params_with: @build_params_with)
         begin
-          cookies.read(@request)
-          self.class.run_before_each(self)
           run_filters befores, :before
+          @before_filter_passed = true
 
-          if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
-            raise Grape::Exceptions::MethodNotAllowed.new(header.merge('Allow' => allowed_methods)) unless options?
+          if env.key?(Grape::Env::GRAPE_ALLOWED_METHODS)
+            header['Allow'] = env[Grape::Env::GRAPE_ALLOWED_METHODS].join(', ')
+            raise Grape::Exceptions::MethodNotAllowed.new(header) unless options?
 
-            header 'Allow', allowed_methods
             response_object = ''
             status 204
           else
             run_filters before_validations, :before_validation
-            run_validators validations, request
+            run_validators(request:)
             run_filters after_validations, :after_validation
             response_object = execute
           end
 
           run_filters afters, :after
-          cookies.write(header)
+          build_response_cookies
 
           # status verifies body presence when DELETE
           @body ||= response_object
@@ -276,132 +185,250 @@ module Grape
       end
     end
 
-    def build_stack(helpers)
-      stack = Grape::Middleware::Stack.new
+    def execute
+      return unless source
 
-      stack.use Rack::Head
-      stack.use Class.new(Grape::Middleware::Error),
-                helpers: helpers,
-                format: namespace_inheritable(:format),
-                content_types: namespace_stackable_with_hash(:content_types),
-                default_status: namespace_inheritable(:default_error_status),
-                rescue_all: namespace_inheritable(:rescue_all),
-                rescue_grape_exceptions: namespace_inheritable(:rescue_grape_exceptions),
-                default_error_formatter: namespace_inheritable(:default_error_formatter),
-                error_formatters: namespace_stackable_with_hash(:error_formatters),
-                rescue_options: namespace_stackable_with_hash(:rescue_options) || {},
-                rescue_handlers: namespace_reverse_stackable_with_hash(:rescue_handlers) || {},
-                base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {},
-                all_rescue_handler: namespace_inheritable(:all_rescue_handler),
-                grape_exceptions_rescue_handler: namespace_inheritable(:grape_exceptions_rescue_handler)
-
-      stack.concat namespace_stackable(:middleware)
-
-      if namespace_inheritable(:version)
-        stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
-                  versions: namespace_inheritable(:version)&.flatten,
-                  version_options: namespace_inheritable(:version_options),
-                  prefix: namespace_inheritable(:root_prefix),
-                  mount_path: namespace_stackable(:mount_path).first
+      instrument_render do
+        source.bind_call(self)
       end
+    end
 
-      stack.use Grape::Middleware::Formatter,
-                format: namespace_inheritable(:format),
-                default_format: namespace_inheritable(:default_format) || :txt,
-                content_types: namespace_stackable_with_hash(:content_types),
-                formatters: namespace_stackable_with_hash(:formatters),
-                parsers: namespace_stackable_with_hash(:parsers)
+    def run_validators(request:)
+      validators = inheritable_setting.route[:saved_validations]
+      return if validators.blank?
 
-      builder = stack.build
-      builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
-      builder.to_app
+      validation_exceptions = nil
+
+      Grape::Validations::ParamScopeTracker.track do
+        instrument_run_validators(validators, request) do
+          validators.each do |validator|
+            validator.validate(request)
+          rescue Grape::Exceptions::Validation, Grape::Exceptions::ValidationArrayErrors => e
+            (validation_exceptions ||= []) << e
+            break if validator.fail_fast?
+          end
+        end
+      end
+
+      raise Grape::Exceptions::ValidationErrors.new(exceptions: validation_exceptions, headers: header) if validation_exceptions
     end
 
-    def build_helpers
-      helpers = namespace_stackable(:helpers)
-      Module.new { helpers&.each { |mod_to_include| include mod_to_include } }
+    def run_filters(filters, type = :other)
+      return if filters.blank?
+
+      instrument_run_filters(filters, type) do
+        filters.each { |filter| instance_eval(&filter) }
+      end
     end
 
-    private :build_stack, :build_helpers
+    attr_reader :befores, :before_validations, :after_validations, :afters, :finallies, :config
 
-    def execute
-      @block&.call(self)
+    def options?
+      options_route_enabled && env[Rack::REQUEST_METHOD] == Rack::OPTIONS
+    end
+
+    private
+
+    attr_reader :before_filter_passed
+
+    # Instrument helpers. Each guards on +listening?+ so that with no subscriber
+    # the payload Hash and notification machinery are skipped and the block runs
+    # directly (no added allocations); the block is forwarded anonymously so
+    # nothing is allocated unless a subscriber is present.
+    def instrument_run(&)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_run.grape')
+
+      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env:, &)
     end
 
-    def helpers
-      lazy_initialize! && @helpers
+    def instrument_render(&)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_render.grape')
+
+      ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: self, &)
     end
 
-    def lazy_initialize!
-      return true if @lazy_initialized
+    def instrument_run_validators(validators, request, &)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_run_validators.grape')
 
-      @lazy_initialize_lock.synchronize do
-        return true if @lazy_initialized
+      ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators:, request:, &)
+    end
 
-        @helpers = build_helpers.tap { |mod| self.class.send(:include, mod) }
-        @app = options[:app] || build_stack(@helpers)
+    def instrument_run_filters(filters, type, &)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_run_filters.grape')
 
-        @lazy_initialized = true
-      end
+      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters:, type:, &)
     end
 
-    def run_validators(validators, request)
-      validation_errors = []
+    def compile!
+      @app = config.app || build_stack
+      warn_unauthenticated_mounted_app
+      @helpers = build_helpers
+      stackable = inheritable_setting.namespace_stackable
+      @befores            = stackable[:befores]
+      @before_validations = stackable[:before_validations]
+      @after_validations  = stackable[:after_validations]
+      @afters             = stackable[:afters]
+      @finallies          = stackable[:finallies]
+      @build_params_with  = inheritable_setting.namespace_inheritable[:build_params_with]
+    end
 
-      ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators: validators, request: request) do
-        validators.each do |validator|
-          validator.validate(request)
-        rescue Grape::Exceptions::Validation => e
-          validation_errors << e
-          break if validator.fail_fast?
-        rescue Grape::Exceptions::ValidationArrayErrors => e
-          validation_errors.concat e.errors
-          break if validator.fail_fast?
+    def to_routes
+      route_options = config.route_options
+      default_route_options = prepare_default_route_attributes(route_options)
+      complete_route_options = route_options.merge(default_route_options)
+      path_settings = prepare_default_path_settings
+
+      config.http_methods.flat_map do |method|
+        config.path.map do |path|
+          prepared_path = Path.new(path, default_route_options[:namespace], path_settings)
+          pattern = Grape::Router::Pattern.new(
+            origin: prepared_path.origin,
+            suffix: prepared_path.suffix,
+            anchor: default_route_options[:anchor],
+            params: route_options[:params],
+            format: config.format,
+            version: default_route_options[:version],
+            requirements: default_route_options[:requirements]
+          )
+          Grape::Router::Route.new(self, method, pattern, complete_route_options)
         end
       end
+    end
 
-      validation_errors.any? && raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header))
+    # True when a bare Rack app (anything that isn't a Grape app) is mounted at
+    # this endpoint. Such an app is called directly and matched by path prefix
+    # rather than an anchored route.
+    def bare_rack_app?
+      config.app && !config.app.is_a?(Grape::Mountable)
     end
 
-    def run_filters(filters, type = :other)
-      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
-        filters&.each { |filter| instance_eval(&filter) }
-      end
-      post_extension = DSL::InsideRoute.post_filter_methods(type)
-      extend post_extension if post_extension
+    def prepare_default_route_attributes(route_options)
+      {
+        namespace:,
+        version: prepare_version(inheritable_setting.namespace_inheritable[:version]),
+        requirements: prepare_routes_requirements(route_options[:requirements]),
+        prefix: inheritable_setting.namespace_inheritable[:root_prefix],
+        anchor: route_options.fetch(:anchor, true),
+        settings: inheritable_setting.route.except(:declared_params, :saved_validations),
+        forward_match: config.forward_match
+      }
     end
 
-    def befores
-      namespace_stackable(:befores)
+    def prepare_default_path_settings
+      namespace_stackable_hash = inheritable_setting.namespace_stackable.to_hash
+      namespace_inheritable_hash = inheritable_setting.namespace_inheritable.to_hash
+      namespace_stackable_hash.merge!(namespace_inheritable_hash)
     end
 
-    def before_validations
-      namespace_stackable(:before_validations)
+    def prepare_routes_requirements(route_options_requirements)
+      namespace_requirements = inheritable_setting.namespace_stackable[:namespace].filter_map(&:requirements)
+      namespace_requirements << route_options_requirements if route_options_requirements.present?
+      namespace_requirements.reduce({}, :merge)
     end
 
-    def after_validations
-      namespace_stackable(:after_validations)
+    def prepare_version(namespace_inheritable_version)
+      return if namespace_inheritable_version.blank?
+
+      namespace_inheritable_version.length == 1 ? namespace_inheritable_version.first : namespace_inheritable_version
     end
 
-    def afters
-      namespace_stackable(:afters)
+    def build_stack
+      stack = Grape::Middleware::Stack.new
+
+      content_types = inheritable_setting.namespace_stackable_with_hash(:content_types)
+      format = inheritable_setting.namespace_inheritable[:format]
+
+      stack.use Rack::Head
+      stack.use Rack::Lint if lint?
+      stack.use Grape::Middleware::Error, **error_middleware_options(format, content_types)
+
+      stack.concat inheritable_setting.namespace_stackable[:middleware]
+
+      if inheritable_setting.namespace_inheritable[:version].present?
+        version_options = inheritable_setting.namespace_inheritable[:version_options]
+        stack.use Grape::Middleware::Versioner.using(version_options.using),
+                  versions: inheritable_setting.namespace_inheritable[:version].flatten,
+                  version_options:,
+                  prefix: inheritable_setting.namespace_inheritable[:root_prefix],
+                  mount_path: inheritable_setting.namespace_stackable[:mount_path].first
+      end
+
+      stack.use Grape::Middleware::Formatter,
+                format:,
+                default_format: inheritable_setting.namespace_inheritable[:default_format] || :txt,
+                content_types:,
+                formatters: inheritable_setting.namespace_stackable_with_hash(:formatters),
+                parsers: inheritable_setting.namespace_stackable_with_hash(:parsers)
+
+      builder = stack.build
+      builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
+      builder.to_app
     end
 
-    def finallies
-      namespace_stackable(:finallies)
+    def error_middleware_options(format, content_types)
+      ns_inh = inheritable_setting.namespace_inheritable
+      ns_stack = inheritable_setting
+      {
+        format:,
+        content_types:,
+        default_status: ns_inh[:default_error_status],
+        rescue_all: ns_inh[:rescue_all],
+        rescue_grape_exceptions: ns_inh[:rescue_grape_exceptions],
+        default_error_formatter: ns_inh[:default_error_formatter],
+        error_formatters: ns_stack.namespace_stackable_with_hash(:error_formatters),
+        rescue_options: ns_stack.namespace_stackable[:rescue_options]&.last,
+        rescue_handlers: merged_reverse_stackable(:rescue_handlers),
+        base_only_rescue_handlers: merged_reverse_stackable(:base_only_rescue_handlers),
+        all_rescue_handler: ns_inh[:all_rescue_handler],
+        grape_exceptions_rescue_handler: ns_inh[:grape_exceptions_rescue_handler],
+        internal_grape_exceptions_rescue_handler: ns_inh[:internal_grape_exceptions_rescue_handler]
+      }
     end
 
-    def validations
-      return enum_for(:validations) unless block_given?
+    def build_helpers
+      helpers = inheritable_setting.namespace_stackable[:helpers]
+      return if helpers.empty?
+
+      Module.new { helpers.each { |mod_to_include| include mod_to_include } }
+    end
+
+    # A bare Rack app mounted with +mount+ is called directly (see +compile!+):
+    # it does not go through +build_stack+, so the API's authentication
+    # middleware never runs and the mount is reachable unauthenticated. Mounted
+    # Grape APIs are unaffected because they rebuild their own stack from the
+    # inherited settings. Warn so this bypass isn't silent.
+    def warn_unauthenticated_mounted_app
+      return unless bare_rack_app?
+      return unless inheritable_setting.namespace_inheritable[:auth]
+
+      warn "Grape: #{config.app} is mounted under an API that declares authentication, but authentication " \
+           'middleware does not wrap mounted Rack applications. Requests to this mount are not authenticated by Grape.'
+    end
 
-      route_setting(:saved_validations)&.each do |saved_validation|
-        yield Grape::Validations::ValidatorFactory.create_validator(**saved_validation)
+    def build_response_cookies
+      return unless request.cookies?
+
+      response_cookies do |name, value|
+        cookie_value = value.is_a?(Hash) ? value : { value: }
+        Rack::Utils.set_cookie_header! header, name, cookie_value
       end
     end
 
-    def options?
-      options[:options_route_enabled] &&
-        env[Grape::Http::Headers::REQUEST_METHOD] == Grape::Http::Headers::OPTIONS
+    def lint?
+      inheritable_setting.namespace_inheritable[:lint] || Grape.config.lint
+    end
+
+    # Merge a reverse-stackable handler map (as written by +rescue_from+) into a
+    # single Hash. The reverse store lists child-scope handlers before inherited
+    # ones, and the first-wins merge keeps the child's handler for a given
+    # class, so a nested +rescue_from+ overrides an outer one.
+    def merged_reverse_stackable(key)
+      handlers = inheritable_setting.namespace_reverse_stackable[key]
+      return if handlers.blank?
+
+      handlers.each_with_object({}) do |handler, result|
+        result.merge!(handler) { |_k, s1, _s2| s1 }
+      end
     end
   end
 end