grape 3.3.4 → 4.0.0

data/lib/grape/endpoint.rb

@@ -17,11 +17,19 @@ module Grape
     def_delegators :request, :params, :headers, :cookies
     def_delegator :cookies, :response_cookies
 
+    # The API (a +Grape::API+ instance) this endpoint belongs to.
+    def_delegator :@config, :api
+
     # 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
+    def_delegator :api, :logger
+
+    # The Rack app or Grape API mounted at this endpoint, or +nil+ for a plain
+    # block endpoint. Prefer this over +options[:app]+, which is retained only
+    # for backwards compatibility.
+    def mounted_app
+      config.app
     end
 
     class << self
@@ -38,33 +46,34 @@ module Grape
     # Create a new endpoint.
     # @param new_settings [InheritableSetting] settings to determine the params,
     #   validations, and other properties from.
+    # @param http_methods [String or Array] which HTTP method(s) can be used to
+    #   reach this endpoint.
+    # @param path [String or Array] the path to this endpoint, within the
+    #   current scope.
+    # @param api [Grape::API] the API this endpoint belongs to. Exposed as
+    #   {#api}.
+    # @param app [#call, nil] the Rack app or Grape API mounted at this
+    #   endpoint; +nil+ for a plain block endpoint. Exposed as {#mounted_app}.
+    # @param params [Hash] the declared params for this endpoint, keyed by name.
+    #   Kept out of +route_options+ and read via +config.params+.
+    # @param requirements [Hash, nil] regular-expression constraints for named
+    #   path params. Read via +config.requirements+.
+    # @param anchor [Boolean] whether the route anchors to the whole path
+    #   (default +true+). Read via +config.anchor+.
     # @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
-    #   to reach this endpoint.
     # @option options route_options [Hash]
     # @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)
-      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
-      inheritable_setting.route[:declared_params] = inheritable_setting.namespace_stackable[:declared_params].flatten
-      inheritable_setting.route[:saved_validations] = inheritable_setting.namespace_stackable[:validations].dup
-
-      inheritable_setting.namespace_stackable[:representations] ||= []
-      inheritable_setting.namespace_inheritable[:default_error_status] ||= 500
+    def initialize(new_settings, http_methods:, path:, api:, app: nil, params: {}, requirements: nil, anchor: true, **options, &block)
+      self.inheritable_setting = new_settings.point_in_time_copy_for_endpoint
 
       @options = options
-      @options[:path] = Array(@options[:path])
-      @options[:path] << '/' if @options[:path].empty?
-      @options[:method] = Array(@options[:method])
-      @config = Options.new(**options)
+      @config = Options.new(http_methods:, path:, api:, app:, params:, requirements:, anchor:, **options)
+      # +:app+ is still surfaced on the public options Hash for backwards
+      # compatibility (e.g. grape-swagger); prefer the +mounted_app+ reader.
+      @options[:app] = app if app
 
       @status = nil
       @stream = nil
@@ -75,15 +84,12 @@ module Grape
       @endpoints = @config.app.endpoints if @config.app.respond_to?(:endpoints)
     end
 
-    # Update our settings from a given set of stackable parameters. Used when
+    # Update our settings from a given parent settings instance. Used when
     # the endpoint's API is mounted under another one.
-    def inherit_settings(namespace_stackable)
-      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.any?
-
-      endpoints&.each { |e| e.inherit_settings(namespace_stackable) }
+    # @param settings [Grape::Util::InheritableSetting]
+    def inherit_settings(settings)
+      inheritable_setting.inherit_route_params(settings)
+      endpoints&.each { |e| e.inherit_settings(settings) }
     end
 
     def routes
@@ -106,28 +112,23 @@ module Grape
       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
+        next if inheritable_setting.do_not_route_head? || route.request_method != Rack::GET
 
-        route.dup.then do |head_route|
-          head_route.convert_to_head_request!
-          router.append(head_route.apply(self))
-        end
+        router.append(route.to_head.apply(self))
       end
     end
 
     def namespace
-      @namespace ||= Namespace.joined_space_path(inheritable_setting.namespace_stackable[:namespace])
+      @namespace ||= inheritable_setting.namespace_path
     end
 
     def call(env)
-      dup.call!(env)
+      @prototype.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
 
@@ -138,6 +139,14 @@ module Grape
     end
     alias eql? ==
 
+    # Mirrors #==. The class stays out: #== admits a subclass instance
+    # through is_a?, and such a pair must hash alike. The block (#source) is
+    # not part of either, matching the long-standing duplicate-route check in
+    # DSL::Routing#route.
+    def hash
+      [config, inheritable_setting].hash
+    end
+
     # 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.
@@ -194,7 +203,7 @@ module Grape
     end
 
     def run_validators(request:)
-      validators = inheritable_setting.route[:saved_validations]
+      validators = inheritable_setting.route_validations
       return if validators.blank?
 
       validation_exceptions = nil
@@ -263,34 +272,80 @@ module Grape
       @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]
+      callbacks = inheritable_setting.callbacks
+      @befores            = callbacks.fetch(:before)
+      @before_validations = callbacks.fetch(:before_validation)
+      @after_validations  = callbacks.fetch(:after_validation)
+      @afters             = callbacks.fetch(:after)
+      @finallies          = callbacks.fetch(:finally)
+      @build_params_with  = inheritable_setting.build_params_with
+      @prototype          = build_prototype
+    end
+
+    # The object each request is copied from.
+    #
+    # Helpers reach an endpoint by module inclusion, and +Object#dup+ does not
+    # carry a singleton class over — so including them on the per-request copy
+    # meant giving every request a brand-new singleton class, whose method
+    # cache then started cold for the helpers, the route block and every DSL
+    # method the endpoint answers. Include them once into a subclass owned by
+    # this endpoint instead, and copy this endpoint's state onto an instance of
+    # it: the per-request copy already answers to the helpers, against a class
+    # that has been warm since boot. It also keeps request handling free of
+    # class mutation.
+    #
+    # Endpoints with no helpers are their own prototype, exactly as before.
+    #
+    # +allocate+ rather than +new+ because the constructor rebuilds state from
+    # the DSL's arguments — a fresh settings copy, a fresh +@config+, another
+    # +block_to_unbound_method+ — and would still not hold what +compile!+ has
+    # just computed. What is wanted is what +dup+ itself does (allocate, then
+    # copy the ivars over) across a class boundary, which neither +dup+ nor
+    # +initialize_copy+ will do: both insist on the receiver's own class. So
+    # the copy is written out here. Taking all of them is safe because
+    # everything set past this point (+routes+, +namespace+) is route-building
+    # memoization the request path never reads.
+    def build_prototype
+      return self unless @helpers
+
+      klass = Class.new(self.class)
+      # Anonymous classes answer nil to +name+ and render as a bare address,
+      # which would reach anything that reports on the endpoint — +inspect+
+      # here, a logger or an error tracker elsewhere. The annotation is what
+      # +set_temporary_name+ is for; a plain constant path is rejected, which
+      # is right, since this class is not reachable under that name.
+      klass.set_temporary_name("#{self.class}(helpers)")
+      klass.include(@helpers)
+      prototype = klass.allocate
+      # Everything but the prototype slot itself, so that recompiling (a
+      # remount) does not leave the new prototype holding the one it replaces.
+      (instance_variables - [:@prototype]).each { |name| prototype.instance_variable_set(name, instance_variable_get(name)) }
+      prototype
     end
 
     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
+      params = config.params
+      path_settings = inheritable_setting.path_settings
+      forward_match = bare_rack_app?
+      version = prepare_version(inheritable_setting.version)
+      prefix = inheritable_setting.root_prefix
+      requirements = prepare_routes_requirements(config.requirements)
+      anchor = config.anchor
+      settings = inheritable_setting.route_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]
+          pattern = Grape::Router::Pattern.build(
+            path:,
+            namespace:,
+            settings: path_settings,
+            anchor:,
+            params:,
+            version:,
+            requirements:
           )
-          Grape::Router::Route.new(self, method, pattern, complete_route_options)
+          Grape::Router::Route.new(self, method, pattern, route_options, forward_match:, params:, namespace:, prefix:, settings:)
         end
       end
     end
@@ -302,26 +357,8 @@ module Grape
       config.app && !config.app.is_a?(Grape::Mountable)
     end
 
-    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 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 prepare_routes_requirements(route_options_requirements)
-      namespace_requirements = inheritable_setting.namespace_stackable[:namespace].filter_map(&:requirements)
+      namespace_requirements = inheritable_setting.namespace_requirements
       namespace_requirements << route_options_requirements if route_options_requirements.present?
       namespace_requirements.reduce({}, :merge)
     end
@@ -335,30 +372,30 @@ module Grape
     def build_stack
       stack = Grape::Middleware::Stack.new
 
-      content_types = inheritable_setting.namespace_stackable_with_hash(:content_types)
-      format = inheritable_setting.namespace_inheritable[:format]
+      content_types = inheritable_setting.content_types
+      format = inheritable_setting.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]
+      stack.concat inheritable_setting.middleware
 
-      if inheritable_setting.namespace_inheritable[:version].present?
-        version_options = inheritable_setting.namespace_inheritable[:version_options]
+      if inheritable_setting.version.present?
+        version_options = inheritable_setting.version_options
         stack.use Grape::Middleware::Versioner.using(version_options.using),
-                  versions: inheritable_setting.namespace_inheritable[:version].flatten,
+                  versions: inheritable_setting.version.flatten,
                   version_options:,
-                  prefix: inheritable_setting.namespace_inheritable[:root_prefix],
-                  mount_path: inheritable_setting.namespace_stackable[:mount_path].first
+                  prefix: inheritable_setting.root_prefix,
+                  mount_path: inheritable_setting.mount_path
       end
 
       stack.use Grape::Middleware::Formatter,
                 format:,
-                default_format: inheritable_setting.namespace_inheritable[:default_format] || :txt,
+                default_format: inheritable_setting.default_format || :txt,
                 content_types:,
-                formatters: inheritable_setting.namespace_stackable_with_hash(:formatters),
-                parsers: inheritable_setting.namespace_stackable_with_hash(:parsers)
+                formatters: inheritable_setting.formatters,
+                parsers: inheritable_setting.parsers
 
       builder = stack.build
       builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
@@ -366,27 +403,26 @@ module Grape
     end
 
     def error_middleware_options(format, content_types)
-      ns_inh = inheritable_setting.namespace_inheritable
-      ns_stack = inheritable_setting
+      setting = 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]
+        default_status: setting.default_error_status,
+        rescue_all: setting.rescue_all?,
+        rescue_grape_exceptions: setting.rescue_grape_exceptions?,
+        default_error_formatter: setting.default_error_formatter,
+        error_formatters: setting.error_formatters,
+        rescue_options: setting.rescue_options,
+        rescue_handlers: setting.rescue_handlers,
+        base_only_rescue_handlers: setting.base_only_rescue_handlers,
+        all_rescue_handler: setting.all_rescue_handler,
+        grape_exceptions_rescue_handler: setting.grape_exceptions_rescue_handler,
+        internal_grape_exceptions_rescue_handler: setting.internal_grape_exceptions_rescue_handler
       }
     end
 
     def build_helpers
-      helpers = inheritable_setting.namespace_stackable[:helpers]
+      helpers = inheritable_setting.helpers
       return if helpers.empty?
 
       Module.new { helpers.each { |mod_to_include| include mod_to_include } }
@@ -399,7 +435,7 @@ module Grape
     # 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]
+      return unless inheritable_setting.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.'
@@ -415,20 +451,7 @@ module Grape
     end
 
     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
+      inheritable_setting.lint? || Grape.config.lint
     end
   end
 end

data/lib/grape/env.rb

@@ -11,8 +11,15 @@ module Grape
     API_VENDOR = 'api.vendor'
     API_FORMAT = 'api.format'
 
+    GRAPE_NORMALIZED_PATH = 'grape.normalized_path'
     GRAPE_ROUTING_ARGS = 'grape.routing_args'
     GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'
     GRAPE_EXCEPTION = 'grape.exception'
+
+    # Not a Grape-owned key: the de-facto convention for an exception that was
+    # handled rather than raised, which is how error trackers find one they
+    # never saw propagate. sentry-ruby, for one, collects
+    # +env['rack.exception'] || env['sinatra.error']+.
+    RACK_EXCEPTION = 'rack.exception'
   end
 end

data/lib/grape/error_formatter/base.rb

@@ -26,12 +26,13 @@ module Grape
           # Extract it here so the presenter can be resolved and the key is not serialized in the response.
           # See spec/integration/grape_entity/entity_spec.rb for examples.
           with = nil
+          payload = message
           if message.is_a?(Hash) && message.key?(:with)
-            message = message.dup
-            with = message.delete(:with)
+            payload = message.dup
+            with = payload.delete(:with)
           end
 
-          presenter = with || env[Grape::Env::API_ENDPOINT].entity_class_for_obj(message)
+          presenter = with || env[Grape::Env::API_ENDPOINT].entity_class_for_obj(payload)
 
           unless presenter || env[Grape::Env::GRAPE_ROUTING_ARGS].nil?
             # env['api.endpoint'].route does not work when the error occurs within a middleware
@@ -44,11 +45,11 @@ module Grape
             presenter = found_code[2] if found_code
           end
 
-          return message unless presenter
+          return payload unless presenter
 
           embeds = { env: }
           embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
-          presenter.represent(message, embeds).serializable_hash
+          presenter.represent(payload, embeds).serializable_hash
         end
 
         def wrap_message(message)

data/lib/grape/error_formatter.rb

@@ -6,10 +6,14 @@ module Grape
 
     module_function
 
-    def formatter_for(format, error_formatters = nil, default_error_formatter = nil)
+    # Answers nil when nothing is registered for the format, the way
+    # +Parser.parser_for+ does. What to fall back to then is the API's own
+    # +default_error_formatter+, which is the caller's state rather than the
+    # registry's: +Middleware::Error+ holds it and applies it.
+    def formatter_for(format, error_formatters = nil)
       return error_formatters[format] if error_formatters&.key?(format)
 
-      registry[format] || default_error_formatter || Grape::ErrorFormatter::Txt
+      registry[format]
     end
   end
 end

data/lib/grape/exceptions/error_response.rb

@@ -15,12 +15,15 @@ module Grape
         "#<#{self.class.name} status=#{status.inspect} message=#{message.inspect} headers=#{headers.inspect}>"
       end
 
+      # The backtrace is deliberately left unset: +Exception#backtrace+ builds
+      # the whole Array of location strings, and the response only renders one
+      # when the API asked for it. The exception travels along, so
+      # +Middleware::Error#error_response+ can still materialize it there.
       def self.from_exception(exception)
         new(
           status: exception.status,
           message: exception.message,
           headers: exception.headers,
-          backtrace: exception.backtrace,
           original_exception: exception
         )
       end

data/lib/grape/exceptions/unknown_error_formatter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class UnknownErrorFormatter < Base
+      def initialize(error_formatter_type)
+        super(message: compose_message(:unknown_error_formatter, error_formatter_type:))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/validation.rb

@@ -9,15 +9,16 @@ module Grape
 
       def initialize(params:, message: nil, status: nil, headers: nil)
         @params = Array(params)
-        if message
-          @message_key = case message
-                         when Symbol then message
-                         when Hash then message[:key]
-                         end
-          message = translate_message(message)
-        end
+        translated =
+          if message
+            @message_key = case message
+                           when Symbol then message
+                           when Hash then message[:key]
+                           end
+            translate_message(message)
+          end
 
-        super(status:, message:, headers:)
+        super(status:, message: translated, headers:)
         # Pre-seed the backtrace so Ruby's raise skips capture. Validation errors are
         # a hot path (raised per bad attribute) and end up as 400 Bad Request responses;
         # backtraces here point into Grape internals and have no diagnostic value.

data/lib/grape/formatter/json.rb

@@ -4,6 +4,7 @@ module Grape
   module Formatter
     class Json < Base
       def self.call(object, _env)
+        return object.to_s if object.is_a?(Grape::PrecompiledJson)
         return object.to_json if object.respond_to?(:to_json)
 
         ::Grape::Json.dump(object)

data/lib/grape/formatter/serializable_hash.rb

@@ -5,6 +5,7 @@ module Grape
     class SerializableHash < Base
       class << self
         def call(object, _env)
+          return object.to_s if object.is_a?(Grape::PrecompiledJson)
           return object if object.is_a?(String)
           return ::Grape::Json.dump(serialize(object)) if serializable?(object)
           return object.to_json if object.respond_to?(:to_json)

data/lib/grape/locale/en.yml

@@ -48,6 +48,7 @@ en:
         regexp: 'is invalid'
         same_as: 'is not the same as %{parameter}'
         unknown_auth_strategy: 'unknown auth strategy: %{strategy}'
+        unknown_error_formatter: 'unknown error formatter: %{error_formatter_type}'
         unknown_options: 'unknown options: %{options}'
         unknown_parameter: 'unknown parameter: %{param}'
         unknown_params_builder: 'unknown params_builder: %{params_builder_type}'

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

@@ -4,49 +4,21 @@ module Grape
   module Middleware
     module Auth
       module DSL
-        def auth(type = nil, *legacy_options, **options, &block)
-          namespace_inheritable = inheritable_setting.namespace_inheritable
-          return namespace_inheritable[:auth] unless type
+        def auth(type = nil, **options, &block)
+          return inheritable_setting.auth unless type
 
-          options = merge_legacy_auth_options(:auth, legacy_options, options)
-          namespace_inheritable[:auth] = { type: type.to_sym, proc: block }.merge!(options)
-          use Grape::Middleware::Auth::Base, namespace_inheritable[:auth]
+          inheritable_setting.auth = { type: type.to_sym, proc: block }.merge!(options)
+          use Grape::Middleware::Auth::Base, inheritable_setting.auth
         end
 
         # Add HTTP Basic authorization to the API.
         #
         # @param options [Hash] a hash of options
         # @option options [String] :realm "API Authorization" the HTTP Basic realm
-        def http_basic(*legacy_options, **options, &)
-          options = merge_legacy_auth_options(:http_basic, legacy_options, options)
+        def http_basic(**options, &)
           options[:realm] ||= 'API Authorization'
           auth(:http_basic, **options, &)
         end
-
-        def http_digest(*legacy_options, **options, &)
-          options = merge_legacy_auth_options(:http_digest, legacy_options, options)
-          options[:realm] ||= 'API Authorization'
-
-          if options[:realm].respond_to?(:values_at)
-            options[:realm][:opaque] ||= 'secret'
-          else
-            options[:opaque] ||= 'secret'
-          end
-
-          auth(:http_digest, **options, &)
-        end
-
-        private
-
-        # @deprecated Passing a positional options Hash is deprecated; pass
-        #   keyword arguments instead. Kept so downstream callers keep working
-        #   through the deprecation cycle.
-        def merge_legacy_auth_options(method_name, legacy_options, options)
-          return options if legacy_options.empty?
-
-          Grape.deprecator.warn("Passing a positional options Hash to `#{method_name}` is deprecated. Pass keyword arguments instead.")
-          legacy_options.first.merge(options)
-        end
       end
     end
   end