grape 4.0.1 → 4.1.0

data/lib/grape/content_types.rb

@@ -15,14 +15,31 @@ module Grape
 
     MIME_TYPES = Grape::ContentTypes::DEFAULTS.except(:serializable_hash).invert.freeze
 
+    # Formats known by more than one name. A request naming one of them -- by
+    # extension, +?format=+ or +default_format+ -- is served under whichever
+    # the API declared, so declaring +:md+ answers +.markdown+ too, through
+    # the formatter, parser and error formatter declared for +:md+. Both
+    # spellings are keys: an extension arrives as a String, +default_format+
+    # as a Symbol.
+    FORMAT_SYNONYMS = {
+      md: :markdown, 'md' => :markdown,
+      markdown: :md, 'markdown' => :md
+    }.freeze
+
     def content_types_for(from_settings)
       from_settings.presence || DEFAULTS
     end
 
+    # Identity rather than +==+ for the defaults, and the pairs rather than
+    # the registry for the cache key, because Hash equality ignores order and
+    # this table's order is the API's preference: the +*/*+ every browser
+    # sends picks the first media type declared. Compared by value, the first
+    # registry built with a set of content types fixed that order for every
+    # later one declaring the same set in another order.
     def mime_types_for(from_settings)
-      return MIME_TYPES if from_settings == Grape::ContentTypes::DEFAULTS
+      return MIME_TYPES if from_settings.equal?(Grape::ContentTypes::DEFAULTS)
 
-      MimeTypesCache[from_settings]
+      MimeTypesCache[from_settings.to_a]
     end
 
     # Every format under both spellings in one plain Hash, so a lookup is a
@@ -51,11 +68,11 @@ module Grape
     end
 
     # Both tables below are derived from nothing but the content-type registry,
-    # and one content-type-aware middleware is built per API instance — so an
-    # app mounting N APIs held N copies of tables it only ever reads. Keying
-    # the cache on the registry itself collapses them: Hash keys compare by
-    # value, so every API that registers the same content types shares one
-    # table.
+    # and every endpoint builds its own content-type-aware middlewares — so an
+    # app held one copy per endpoint of tables it only ever reads. Keying the
+    # cache on the registry collapses them: keys compare by value, so every
+    # registry with the same content types shares one table -- declared in
+    # the same order, for MimeTypesCache (see #mime_types_for).
     #
     # Both the key and the table are frozen: the caller's registry stays
     # reachable (through +middleware.options[:content_types]+, among others)
@@ -65,8 +82,8 @@ module Grape
     class MimeTypesCache < Grape::Util::Cache
       def initialize
         super
-        @cache = Hash.new do |h, from_settings|
-          h[from_settings.dup.freeze] = from_settings.invert.transform_keys! { |mime_type| Grape::ContentTypes.media_type(mime_type) }.freeze
+        @cache = Hash.new do |h, content_types|
+          h[content_types.freeze] = content_types.to_h.invert.transform_keys! { |mime_type| Grape::ContentTypes.media_type(mime_type) }.freeze
         end
       end
     end

data/lib/grape/cookies.rb

@@ -30,7 +30,7 @@ module Grape
       send_cookies << name
     end
 
-    # see https://github.com/rack/rack/blob/main/lib/rack/utils.rb#L338-L340
+    # Same attributes Rack::Utils uses to delete a cookie
     def delete(name, **opts)
       self.[]=(name, opts.merge(DELETED_COOKIES_ATTRS))
     end

data/lib/grape/declared_params_handler.rb

@@ -2,7 +2,7 @@
 
 module Grape
   class DeclaredParamsHandler
-    def initialize(include_missing: true, evaluate_given: false, stringify: false, contract_key_map: nil)
+    def initialize(include_missing: true, evaluate_given: false, stringify: false, contract_key_map: [])
       @include_missing = include_missing
       @evaluate_given = evaluate_given
       @stringify = stringify
@@ -20,7 +20,16 @@ module Grape
 
     private
 
+    # An element of an Array scope that is not a Hash has no keys to filter,
+    # so it is returned as it came in, the way a leaf value is. Validation
+    # lets one through wherever nothing in the scope is required of it: an
+    # optional scope passes over blank elements, and a scope whose params are
+    # all optional checks nothing on an element that is not a Hash. Filtering
+    # it anyway meant building an empty copy of it, which raised for +nil+,
+    # +false+ and numbers and indexed a String with a Symbol.
     def recursive_declared(passed_params, declared_params:, route_params:, renamed_params:, params_nested_path: [])
+      return passed_params unless passed_params.is_a?(Array) || passed_params.respond_to?(:key?)
+
       res = if passed_params.is_a?(Array)
               passed_params.map do |passed_param|
                 recursive_declared(passed_param, declared_params:, params_nested_path:, renamed_params:, route_params:)
@@ -29,7 +38,7 @@ module Grape
               declared_hash(passed_params, declared_params:, params_nested_path:, renamed_params:, route_params:)
             end
 
-      @contract_key_map&.each { |key_map| key_map.write(passed_params, res) }
+      @contract_key_map.each { |key_map| key_map.write(passed_params, res) }
 
       res
     end
@@ -63,8 +72,13 @@ module Grape
       memo_key = build_memo_key(params_nested_path, parent, renamed_params)
       passed_children = passed_params[parent] || passed_params.class.new
       nested_path = nested_path_for(params_nested_path, parent)
+      # A value that is neither a Hash nor an Array where children are declared
+      # -- left unvalidated by a +given+ whose dependency is not met, say -- is
+      # returned as it came in, as #recursive_declared returns an element like
+      # it.
+      has_passed_children = !passed_children.respond_to?(:any?) || passed_children.any?
 
-      memo[memo_key] = handle_passed_param(nested_path, route_params:, has_passed_children: passed_children.any?) do
+      memo[memo_key] = handle_passed_param(nested_path, route_params:, has_passed_children:) do
         recursive_declared(
           passed_children,
           declared_params: children,
@@ -87,8 +101,11 @@ module Grape
       end
     end
 
+    # The lookup key is the param's whole path, built fresh -- two Arrays and a
+    # String per declared param -- and only an API using +as:+ has anything to
+    # find with it, so the common empty table is not asked.
     def build_memo_key(params_nested_path, declared_param, renamed_params)
-      renamed_param_name = renamed_params[nested_path_for(params_nested_path, declared_param)]
+      renamed_param_name = renamed_params[nested_path_for(params_nested_path, declared_param)] unless renamed_params.empty?
       param = renamed_param_name || declared_param
       @stringify ? param.to_s : param.to_sym
     end
@@ -106,11 +123,22 @@ module Grape
       type = route_params.dig(key, :type)
       return yield if type.nil?
 
-      return {} if type == 'Hash' && route_params.keys.none? { |k| k != key && k.start_with?("#{key}[") }
+      empty_value_for(type, key, route_params) || yield
+    end
+
+    # The empty value a param of +type+ declares when it was not passed, or
+    # nil when +type+ has none. A fresh one every time: the caller may fill it.
+    def empty_value_for(type, key, route_params)
+      return {} if type == 'Hash' && no_child_params?(route_params, "#{key}[")
       return [] if type == 'Array' || (type.start_with?('[') && !type.include?(','))
-      return Set.new if type == 'Set' || type.start_with?('#<Set', 'Set')
 
-      yield
+      Set.new if type.start_with?('#<Set', 'Set')
+    end
+
+    # The prefix is built once by the caller: interpolated inside the block, it
+    # was a new String for every param on the route.
+    def no_child_params?(route_params, prefix)
+      route_params.keys.none? { |k| k.start_with?(prefix) }
     end
   end
 end

data/lib/grape/dsl/declared.rb

@@ -15,10 +15,11 @@ module Grape
       # consisting only of keys that have been declared by a
       # `params` statement against the current/target endpoint or parent
       # namespaces.
-      # @param params [Hash] The initial hash to filter. Usually this will just be `params`
-      # @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces`
-      # options. `:include_parent_namespaces` defaults to true, hence must be set to false if
-      # you want only to return params declared against the current/target endpoint.
+      # @param passed_params [Hash] The initial hash to filter. Usually this will just be `params`
+      # @param include_parent_namespaces [Boolean] false to only return params declared against the current/target endpoint
+      # @param include_missing [Boolean] include declared params that were not passed
+      # @param evaluate_given [Boolean] drop params whose +given+ condition is not met
+      # @param stringify [Boolean] return String keys
       def declared(passed_params, include_parent_namespaces: true, include_missing: true, evaluate_given: false, stringify: false)
         raise MethodNotYetAvailable unless before_filter_passed
 

data/lib/grape/dsl/desc.rb

@@ -9,8 +9,7 @@ module Grape
       # @param description [String] descriptive string for this endpoint
       #   or namespace
       # @param options [Hash] other properties you can set to describe the
-      #   endpoint or namespace. Optional. Pass these as keyword arguments;
-      #   passing a positional options Hash is deprecated.
+      #   endpoint or namespace, as keyword arguments. Optional.
       # @option options :detail [String] additional detail about this endpoint
       # @option options :summary [String] summary for this endpoint
       # @option options :params [Hash] param types and info. normally, you set

data/lib/grape/dsl/entity.rb

@@ -26,35 +26,41 @@ module Grape
       #       admin: current_user.admin?
       #   end
       def present(*args, root: nil, with: nil, **options)
-        key, object = args.count == 2 && args.first.is_a?(Symbol) ? args : [nil, args.first]
+        # No [nil, object] Array to destructure for the one-argument form.
+        object = args.first
+        key, object = args if args.count == 2 && object.is_a?(Symbol)
         entity_class = with || entity_class_for_obj(object)
         representation = entity_class ? entity_representation_for(entity_class, object, options) : object
         representation = { root => representation } if root
 
-        if key
-          representation = body&.merge(key => representation) || { key => representation }
-        elsif entity_class.present? && body
-          raise ArgumentError, "representation of type `#{representation.class}` cannot be merged" unless representation.respond_to?(:merge)
-
-          representation = body.merge(representation)
-        end
-
-        body representation
+        body merged_with_body(representation, key, entity_class)
       end
 
       # Attempt to locate the Entity class for a given object, if not given
-      # explicitly. This is done by looking for the presence of Klass::Entity,
-      # where Klass is the class of the `object` parameter, or one of its
-      # ancestors. Object is excluded from the search: top-level constants
-      # live on it, so a global ::Entity class is not a representer.
+      # explicitly: a +represent+ registration or Klass::Entity for the object's
+      # class or an ancestor, then the same for its element class. Object is
+      # excluded: a global ::Entity class is not a representer.
       # @param object [Object] the object to locate the Entity class for
       # @return [Class] the located Entity class, or nil if none is found
       def entity_class_for_obj(object)
-        entity_for_class(object.class) || entity_for_class(element_class(object))
+        # Read once for both lookups: it walks every scope up to the API's root,
+        # and any object that answers #first (a Hash among them) needs both.
+        representations = inheritable_setting.representations
+        entity_for_class(object.class, representations) || entity_for_class(element_class(object), representations)
       end
 
       private
 
+      # +representation+ merged into the body an earlier +present+ set: under
+      # +key+ when there is one, and whole when it came from an entity.
+      def merged_with_body(representation, key, entity_class)
+        return body&.merge(key => representation) || { key => representation } if key
+        return representation unless entity_class && body
+        raise ArgumentError, "representation of type `#{representation.class}` cannot be merged" unless representation.respond_to?(:merge)
+
+        body.merge(representation)
+      end
+
       # The class standing in for a collection or wrapper: ActiveRecord::Relation
       # and the like expose #klass, anything else falls back to the class of its
       # first element.
@@ -76,16 +82,22 @@ module Grape
       end
 
       # @param klass [Class, nil] the class to look an entity up for.
+      # @param representations [Hash, nil] the +represent+ registrations in scope.
       # @return [Class, nil] the registered or conventionally named entity.
-      def entity_for_class(klass)
+      def entity_for_class(klass, representations)
         return if klass.nil?
 
-        representations = inheritable_setting.representations
         if representations
           potential = klass.ancestors.detect { |ancestor| representations.key?(ancestor) }
           return representations[potential] if potential && representations[potential]
         end
 
+        conventional_entity_for(klass) if klass.const_defined?(:Entity)
+      end
+
+      # The +Entity+ constant of the nearest of +klass+'s ancestors defining
+      # one, when it can represent.
+      def conventional_entity_for(klass)
         owner = klass.ancestors.detect { |ancestor| ancestor != Object && ancestor.const_defined?(:Entity, false) }
         return unless owner
 
@@ -93,13 +105,17 @@ module Grape
         entity if entity.respond_to?(:represent)
       end
 
+      # The embeds go straight into the call: collected into a Hash of their
+      # own and splatted, they cost every +present+ a second Hash.
+      #
       # @param entity_class [Class] the entity class to use for representation.
       # @param object [Object] the object to represent.
       # @param options [Hash] additional options forwarded to the entity's `represent` call.
       # @return the representation of the given object as done through the given entity_class.
       def entity_representation_for(entity_class, object, options)
-        embeds = env.key?(Grape::Env::API_VERSION) ? { env:, version: env[Grape::Env::API_VERSION] } : { env: }
-        entity_class.represent(object, **embeds, **options)
+        return entity_class.represent(object, env:, **options) unless env.key?(Grape::Env::API_VERSION)
+
+        entity_class.represent(object, env:, version: env[Grape::Env::API_VERSION], **options)
       end
     end
   end

data/lib/grape/dsl/headers.rb

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

data/lib/grape/dsl/helpers.rb

@@ -6,8 +6,8 @@ module Grape
       # Add helper methods that will be accessible from any
       # endpoint within this namespace (and child namespaces).
       #
-      # When called without a block, all known helpers within this scope
-      # are included.
+      # When called with neither modules nor a block, returns a module
+      # including all known helpers within this scope.
       #
       # @param [Array] new_modules optional array of modules to include
       # @param [Block] block optional block of methods to include
@@ -77,11 +77,8 @@ module Grape
 
       # When +Grape.config.warn_on_helper_overrides+ is enabled, emit a
       # warning to +$stderr+ for any helper method that masks an instance
-      # method on +Grape::Endpoint+. Helpers are mixed into the endpoint's
-      # singleton class and therefore take precedence over +Endpoint+
-      # instance methods — usually intentional, but a common source of
-      # surprise when the framework gains a method that already collides
-      # with an existing helper name.
+      # method on +Grape::Endpoint+. Helpers are included into a subclass of
+      # the endpoint (see Endpoint#build_prototype), so they take precedence.
       def warn_on_endpoint_overrides(mod)
         overridden = mod.instance_methods(false).select { |m| Grape::Endpoint.method_defined?(m) }
         return if overridden.empty?
@@ -113,7 +110,7 @@ module Grape
         protected
 
         def process_named_params
-          return if @named_params.blank?
+          return unless @named_params
 
           api.inheritable_setting.add_named_params(@named_params)
         end

data/lib/grape/dsl/inside_route.rb

@@ -9,7 +9,15 @@ module Grape
       # Backward compatibility: alias exception class to previous location
       MethodNotYetAvailable = Declared::MethodNotYetAvailable
 
-      # The API version as specified in the URL.
+      # The body #redirect renders when the caller gives none, by status.
+      REDIRECT_MESSAGES = {
+        301 => 'This resource has been moved permanently to %<url>s.',
+        302 => 'This resource has been moved temporarily to %<url>s.',
+        303 => 'An alternate resource is located at %<url>s.'
+      }.freeze
+      private_constant :REDIRECT_MESSAGES
+
+      # The API version negotiated for this request.
       def version
         env[Grape::Env::API_VERSION]
       end
@@ -23,13 +31,14 @@ module Grape
       #
       # @param message [String] The message to display.
       # @param status [Integer] The HTTP Status Code. Defaults to default_error_status, 500 if not set.
-      # @param additional_headers [Hash] Addtional headers for the response.
+      # @param additional_headers [Hash] Additional headers for the response.
       # @param backtrace [Array<String>] The backtrace of the exception that caused the error.
       # @param original_exception [Exception] The original exception that caused the error.
+      # @raise [Grape::Exceptions::Halt] always, carrying the response.
       def error!(message, status = nil, additional_headers = nil, backtrace = nil, original_exception = nil)
         resolved_status = self.status(status || inheritable_setting.default_error_status)
         headers = additional_headers.present? ? header.merge(additional_headers) : header
-        throw :error, Grape::Exceptions::ErrorResponse.new(
+        raise Grape::Exceptions::Halt.new(
           message:, status: resolved_status, headers:, backtrace:, original_exception:
         )
       end
@@ -40,26 +49,27 @@ module Grape
       # @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
-          body_message ||= "This resource has been moved permanently to #{url}."
-        elsif http_version == 'HTTP/1.1' && !request.get?
-          status 303
-          body_message ||= "An alternate resource is located at #{url}."
-        else
-          status 302
-          body_message ||= "This resource has been moved temporarily to #{url}."
-        end
+        code = if permanent
+                 301
+               elsif http_version == 'HTTP/1.1' && !request.get?
+                 303
+               else
+                 302
+               end
+        status code
         header 'Location', url
-        content_type 'text/plain'
+        # A caller-supplied body keeps the API's format, and the content type
+        # that goes with it: it may be structured, and the txt formatter would
+        # render a Hash through `to_s`.
+        return body(body) if body
+
         # Render the message Grape generated as the plain text it is. Setting
         # only the header left it to the API's own formatter, which on a JSON
         # API returned the sentence wrapped in quotes under a text/plain content
-        # type. A caller-supplied body keeps the API's format: it may be
-        # structured, and the txt formatter would render a Hash through `to_s`.
-        api_format :txt unless body
-        body body_message
+        # type.
+        content_type 'text/plain'
+        api_format :txt
+        body format(REDIRECT_MESSAGES.fetch(code), url:)
       end
 
       # Set or retrieve the HTTP status code.
@@ -67,13 +77,9 @@ module Grape
       # @param status [Integer] The HTTP Status Code to return for this request.
       def status(status = nil)
         return @status || default_status if status.nil?
+        raise ArgumentError, 'status code must be Integer or Symbol' unless status.is_a?(Symbol) || status.is_a?(Integer)
 
-        case status
-        when Symbol, Integer
-          @status = Rack::Utils.status_code(status)
-        else
-          raise ArgumentError, 'status code must be Integer or Symbol'
-        end
+        @status = Rack::Utils.status_code(status)
       end
 
       # Set response content-type
@@ -121,7 +127,7 @@ module Grape
       #
       # @example
       #   get '/file' do
-      #     sendfile FileStreamer.new(...)
+      #     sendfile '/path/to/file'
       #   end
       #
       #   GET /file # => "contents of file"
@@ -205,7 +211,7 @@ module Grape
       def default_status
         request_method = env[Rack::REQUEST_METHOD]
         return 201 if request_method == Rack::POST
-        return 204 if request_method == Rack::DELETE && @body.blank?
+        return 204 if request_method == Rack::DELETE && Grape::Util::Scrub.blank?(@body)
 
         200
       end

data/lib/grape/dsl/logger.rb

@@ -3,14 +3,20 @@
 module Grape
   module DSL
     module Logger
-      # Set or retrive the configured logger. If none was configured, this
+      # Set or retrieve the configured logger. If none was configured, this
       # method will create a new one, logging to stdout.
+      #
+      # A logger belongs to the API it is set on, and to the APIs mounted
+      # under it that set none of their own. It used to be kept in the
+      # process-wide settings, so setting one on any API replaced it on every
+      # other. Only the default is still shared: an API that sets a level on
+      # it at class level reads it off its base instance, and has to find
+      # that level again on each instance it is mounted as.
       # @param logger [Object] the new logger to use
       def logger(logger = nil)
-        global_settings = inheritable_setting.global
-        return global_settings[:logger] = logger if logger
+        return top_level_setting.logger = logger if logger
 
-        global_settings[:logger] || global_settings[:logger] = ::Logger.new($stdout)
+        top_level_setting.logger || (inheritable_setting.global[:logger] ||= ::Logger.new($stdout))
       end
     end
   end

data/lib/grape/dsl/middleware.rb

@@ -10,24 +10,19 @@ module Grape
       # @param middleware_class [Class] The class of the middleware you'd like
       #   to inject.
       def use(middleware_class, *args, &block)
-        arr = [:use, middleware_class, *args]
-        arr << block if block
-
-        inheritable_setting.add_middleware(arr)
+        inheritable_setting.add_middleware([:use, middleware_class, *args, block])
       end
 
       %i[insert insert_before insert_after].each do |method_name|
         define_method method_name do |*args, &block|
-          arr = [method_name, *args]
-          arr << block if block
-
-          inheritable_setting.add_middleware(arr)
+          inheritable_setting.add_middleware([method_name, *args, block])
         end
       end
 
       # Retrieve an array of the middleware classes
       # and arguments that are currently applied to the
-      # application.
+      # application, each ending in the block it was
+      # given, +nil+ when none.
       def middleware
         inheritable_setting.middleware
       end

data/lib/grape/dsl/mounting.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Grape
+  module DSL
+    module Mounting
+      def given(conditional_option, &)
+        return unless conditional_option
+
+        mounted(&)
+      end
+
+      def mounted(&block)
+        evaluate_as_instance_with_configuration(block, lazy: true)
+      end
+
+      def mount(mounts, opts = {})
+        mount_opts = opts
+        if opts[:refresh_already_mounted]
+          Grape.deprecator.warn('`refresh_already_mounted` is not a `mount` option and will be ignored in a future release.')
+          drop_endpoints_mounted_for(mounts)
+          # Dropped before the recursion below re-enters with the same options,
+          # so a Grape API does not warn once per mount and once per instance.
+          mount_opts = opts.except(:refresh_already_mounted)
+        end
+
+        normalize_mounts(mounts).each_pair do |app, path|
+          if app.respond_to?(:mount_instance)
+            mount({ app.mount_instance(configuration: mount_opts[:with] || {}) => path }, mount_opts)
+            next
+          end
+
+          endpoints << Grape::Endpoint.new(
+            mounted_setting(app, path),
+            http_methods: '*',
+            path:,
+            app:,
+            anchor: false,
+            api: self
+          )
+        end
+      end
+
+      private
+
+      # The settings the endpoint mounting +app+ at +path+ is built with. Past
+      # #mount's +mount_instance+ branch, a Grape app is an already instantiated
+      # Grape::API::Instance (vs. a bare Rack app): it inherits this API's
+      # settings and is built from its own.
+      def mounted_setting(app, path)
+        return inheritable_setting unless app.is_a?(Grape::Mountable)
+
+        app.top_level_setting.add_mount_path(Grape::Util::PathNormalizer.call(path))
+        app.inherit_settings(inheritable_setting)
+        app.change!
+        change!
+        app.top_level_setting
+      end
+
+      # Re-mount +mounts+, replacing any endpoint already mounted for the same
+      # base API rather than adding a second one. Called by
+      # {Grape::API.refresh_mount_step} when a class-level method runs after the
+      # API was mounted.
+      #
+      # A bare Rack app is put back where it was mounted. It is routed as an
+      # ANY route, and those are tried in the order they were declared, so
+      # re-mounting it last let a catch-all declared after it answer first. A
+      # mounted Grape API still moves to the end: its routes answer for
+      # specific methods, where moving them would change which of two
+      # routes on the same path answers.
+      def refresh_mounted_api(mounts, opts = {})
+        namespace = inheritable_setting.namespace_path
+        normalize_mounts(mounts).each_pair do |app, path|
+          position = endpoints.index { |endpoint| mounted_at?(endpoint, app, Array(path), namespace) } unless app.respond_to?(:mount_instance)
+          drop_endpoints_mounted_for(app => path)
+          mount({ app => path }, opts)
+          endpoints.insert(position, endpoints.pop) if position
+        end
+      end
+
+      # A mounted Grape API is stored as the throwaway instance +mount+ built
+      # for it, never as the class that was written, so endpoints are matched on
+      # the base API both of them share -- and on where it was mounted, the
+      # path and the current namespace: the same API mounted at two paths, or
+      # in two namespaces, is two mounts, and refreshing one must leave the
+      # other in place.
+      def drop_endpoints_mounted_for(mounts)
+        namespace = inheritable_setting.namespace_path
+        normalize_mounts(mounts).each_pair do |app, path|
+          paths = Array(path)
+          endpoints.delete_if do |endpoint|
+            dropped = mounted_at?(endpoint, app, paths, namespace)
+            release_mount_instance(endpoint.mounted_app) if dropped
+            dropped
+          end
+        end
+      end
+
+      # A Grape API keeps every instance +mount+ builds for it, so that steps
+      # recorded later replay onto each (see Grape::API::Instance.base=). Once
+      # the endpoint serving one is dropped, nothing serves it: its API lets go
+      # of it, and of the instances built for the APIs mounted inside it.
+      # Otherwise every refresh left another copy of each mounted API behind.
+      def release_mount_instance(mounted)
+        return unless mounted.respond_to?(:base) && mounted.base.respond_to?(:instances)
+
+        mounted.base.instances.delete(mounted)
+        mounted.endpoints.each { |endpoint| release_mount_instance(endpoint.mounted_app) }
+      end
+
+      # A bare app mounts at the root. The test is +Hash+ rather than
+      # +respond_to?(:each_pair)+ because a Struct or an OpenStruct answers that
+      # too, and neither can express an app => path mapping — their keys are
+      # member names. Reading one as a mapping would silently mount nonsense
+      # instead of mounting the app itself.
+      def normalize_mounts(mounts)
+        mounts.is_a?(Hash) ? mounts : { mounts => '/' }
+      end
+
+      def mounted_at?(endpoint, app, paths, namespace)
+        same_mounted_app?(endpoint.mounted_app, app) && endpoint.path == paths && endpoint.namespace == namespace
+      end
+
+      # Two mounts refer to the same app when they share the same base Grape
+      # API. +mount+ turns every mounted Grape API into a throwaway
+      # +mount_instance+ (a fresh +Class.new+ per mount), so object identity
+      # never holds across mounts; comparing the base is the real signal.
+      # Plain Rack apps have no base and are mounted as-is, so they fall back
+      # to object identity.
+      def same_mounted_app?(mounted, app)
+        return mounted.base.equal?(app.base) if mounted.respond_to?(:base) && app.respond_to?(:base)
+
+        mounted.equal?(app)
+      end
+
+      def evaluate_as_instance_with_configuration(block, lazy: false)
+        lazy_block = Grape::Util::Lazy::Block.new do |configuration|
+          value_for_configuration = configuration
+          self.configuration = value_for_configuration.evaluate if value_for_configuration.is_a?(Grape::Util::Lazy::Base)
+          response = instance_eval(&block)
+          self.configuration = value_for_configuration
+          response
+        end
+        return lazy_block if @base && base_instance? && lazy
+
+        lazy_block.evaluate_from(configuration)
+      end
+    end
+  end
+end