grape 4.0.1 → 4.1.0

data/lib/grape/dsl/parameters.rb

@@ -6,18 +6,13 @@ module Grape
     # and describe the parameters accepted by an endpoint, or all endpoints
     # within a namespace.
     module Parameters
-      # Set the module used to build the request.params.
+      # Set the builder used to build the request.params.
       #
-      # @param build_with the ParamBuilder module to use when building request.params
-      #   Available builders are:
-      #
-      #     * Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder (default)
-      #     * Grape::Extensions::Hash::ParamBuilder
-      #     * Grape::Extensions::Hashie::Mash::ParamBuilder
+      # @param build_with [Symbol] +:hash_with_indifferent_access+ (default,
+      #   see +Grape.config.param_builder+), +:hash+ or +:hashie_mash+
       #
       # @example
       #
-      #     require 'grape/extenstions/hashie_mash'
       #     class API < Grape::API
       #       desc "Get collection"
       #       params do
@@ -72,80 +67,78 @@ module Grape
       alias use_scope use
       alias includes use
 
-      # Require one or more parameters for the current endpoint.
+      # @!method requires(*attrs, using: nil, except: nil, as: nil, **opts, &block)
+      #   Require one or more parameters for the current endpoint.
       #
-      # @param attrs list of parameters names, or, if :using is
-      #   passed as an option, which keys to include (:all or :none) from
-      #   the :using hash. Passing the options as a trailing positional Hash
-      #   is deprecated; pass them as keyword arguments instead.
-      # @option attrs :type [Class] the type to coerce this parameter to before
-      #   passing it to the endpoint. See {Grape::Validations::Types} for a list of
-      #   types that are supported automatically. Custom classes may be used
-      #   where they define a class-level `::parse` method, or in conjunction
-      #   with the `:coerce_with` parameter. `JSON` may be supplied to denote
-      #   `JSON`-formatted objects or arrays of objects. `Array[JSON]` accepts
-      #   the same values as `JSON` but will wrap single objects in an `Array`.
-      # @option attrs :types [Array<Class>] may be supplied in place of +:type+
-      #   to declare an attribute that has multiple allowed types. See
-      #   {Validations::Types::MultipleTypeCoercer} for more details on coercion
-      #   and validation rules for variant-type parameters.
-      # @option attrs :desc [String] description to document this parameter
-      # @option attrs :default [Object] default value, if parameter is optional
-      # @option attrs :values [Array] permissable values for this field. If any
-      #   other value is given, it will be handled as a validation error
-      # @option attrs :using [Hash[Symbol => Hash]] a hash defining keys and
-      #   options, like that returned by {Grape::Entity#documentation}. The value
-      #   of each key is an options hash accepting the same parameters
-      # @option attrs :except [Array[Symbol]] a list of keys to exclude from
-      #   the :using Hash. The meaning of this depends on if :all or :none was
-      #   passed; :all + :except will make the :except fields optional, whereas
-      #   :none + :except will make the :except fields required
-      # @option attrs :coerce_with [#parse, #call] method to be used when coercing
-      #   the parameter to the type named by `attrs[:type]`. Any class or object
-      #   that defines `::parse` or `::call` may be used.
+      #   @param attrs list of parameters names, or, if :using is
+      #     passed as an option, which keys to include (:all or :none) from
+      #     the :using hash. Passing the options as a trailing positional Hash
+      #     is deprecated; pass them as keyword arguments instead.
+      #   @option attrs :type [Class] the type to coerce this parameter to before
+      #     passing it to the endpoint. See {Grape::Validations::Types} for a list of
+      #     types that are supported automatically. Custom classes may be used
+      #     where they define a class-level `::parse` method, or in conjunction
+      #     with the `:coerce_with` parameter. `JSON` may be supplied to denote
+      #     `JSON`-formatted objects or arrays of objects. `Array[JSON]` accepts
+      #     the same values as `JSON` but will wrap single objects in an `Array`.
+      #   @option attrs :types [Array<Class>] may be supplied in place of +:type+
+      #     to declare an attribute that has multiple allowed types. See
+      #     {Validations::Types::MultipleTypeCoercer} for more details on coercion
+      #     and validation rules for variant-type parameters.
+      #   @option attrs :desc [String] description to document this parameter
+      #   @option attrs :default [Object] default value, if parameter is optional
+      #   @option attrs :values [Array] permissible values for this field. If any
+      #     other value is given, it will be handled as a validation error
+      #   @option attrs :using [Hash[Symbol => Hash]] a hash defining keys and
+      #     options, like that returned by {Grape::Entity#documentation}. The value
+      #     of each key is an options hash accepting the same parameters
+      #   @option attrs :except [Array[Symbol]] a list of keys to exclude from
+      #     the :using Hash. The meaning of this depends on if :all or :none was
+      #     passed; :all + :except will make the :except fields optional, whereas
+      #     :none + :except will make the :except fields required
+      #   @option attrs :coerce_with [#parse, #call] method to be used when coercing
+      #     the parameter to the type named by `attrs[:type]`. Any class or object
+      #     that defines `::parse` or `::call` may be used.
       #
-      # @example
+      #   @example
       #
-      #     params do
-      #       # Basic usage: require a parameter of a certain type
-      #       requires :user_id, type: Integer
+      #       params do
+      #         # Basic usage: require a parameter of a certain type
+      #         requires :user_id, type: Integer
       #
-      #       # You don't need to specify type; String is default
-      #       requires :foo
+      #         # Without a type, the value is not coerced
+      #         requires :foo
       #
-      #       # Multiple params can be specified at once if they share
-      #       # the same options.
-      #       requires :x, :y, :z, type: Date
+      #         # Multiple params can be specified at once if they share
+      #         # the same options.
+      #         requires :x, :y, :z, type: Date
       #
-      #       # Nested parameters can be handled as hashes. You must
-      #       # pass in a block, within which you can use any of the
-      #       # parameters DSL methods.
-      #       requires :user, type: Hash do
-      #         requires :name, type: String
+      #         # Nested parameters can be handled as hashes. You must
+      #         # pass in a block, within which you can use any of the
+      #         # parameters DSL methods.
+      #         requires :user, type: Hash do
+      #           requires :name, type: String
+      #         end
       #       end
-      #     end
-      def requires(*attrs, using: nil, except: nil, as: nil, **opts, &)
-        return redispatch_legacy_options(:requires, attrs, { using:, except:, as: }.compact.merge(opts), &) if legacy_options?(attrs)
-
-        declare(attrs, opts, required: true, using:, except:, as:, &)
-      end
-
-      # Allow, but don't require, one or more parameters for the current
-      #   endpoint.
-      # @param (see #requires)
-      # @option (see #requires)
-      def optional(*attrs, using: nil, except: nil, as: nil, **opts, &)
-        return redispatch_legacy_options(:optional, attrs, { using:, except:, as: }.compact.merge(opts), &) if legacy_options?(attrs)
-
-        declare(attrs, opts, required: false, using:, except:, as:, &)
+      #
+      # @!method optional(*attrs, using: nil, except: nil, as: nil, **opts, &block)
+      #   Allow, but don't require, one or more parameters for the current
+      #     endpoint.
+      #   @param (see Grape::DSL::Parameters#requires)
+      #   @option (see Grape::DSL::Parameters#requires)
+      { requires: true, optional: false }.each do |method_name, required|
+        define_method(method_name) do |*attrs, using: nil, except: nil, as: nil, **opts, &block|
+          return redispatch_legacy_options(method_name, attrs, { using:, except:, as: }.compact.merge(opts), &block) if legacy_options?(attrs)
+
+          declare(attrs, opts, required:, using:, except:, as:, &block)
+        end
       end
 
       # Define common settings for one or more parameters
       # @param (see #requires)
       # @option (see #requires)
       def with(**opts, &)
-        new_group_attrs = @group&.deep_merge(opts) || opts
-        new_group_scope(new_group_attrs, &)
+        new_group_scope(with_group_options(opts), &)
       end
 
       %i[mutually_exclusive exactly_one_of at_least_one_of all_or_none_of].each do |validator|
@@ -156,9 +149,9 @@ module Grape
 
       # Define a block of validations which should be applied if and only if
       # the given parameter is present. The parameters are not nested.
-      # @param attr [Symbol] the parameter which, if present, triggers the
-      #   validations
-      # @raise Grape::Exceptions::UnknownParameter if `attr` has not been
+      # @param attrs [Array<Symbol, Hash>] the parameters which, if present (or
+      #   passing the Proc they map to), trigger the validations
+      # @raise Grape::Exceptions::UnknownParameter if one has not been
       #   defined in this scope yet
       # @yield a parameter definition DSL
       def given(*attrs, &)
@@ -176,8 +169,7 @@ module Grape
         # Elements of @declared_params of lateral scope are pushed in @parent. So check them in @parent.
         return @parent.declared_param?(param) if lateral?
 
-        # @declared_params also includes hashes of options and such, but those
-        # won't be flattened out.
+        # A nested scope is recorded as an Attr keyed by { element => children }.
         @declared_params.flatten.any? do |declared_param_attr|
           first_hash_key_or_param(declared_param_attr.key) == param
         end
@@ -185,22 +177,8 @@ module Grape
 
       alias group requires
 
-      EmptyOptionalValue = Object.new.freeze
-
-      # @param params [Hash] initial hash of parameters
-      # @return hash of parameters relevant for the current scope
-      # @api private
-      def params(params)
-        scoped = @parent ? (@parent.qualifying_params.presence || @parent.params(params)) : params
-        @element ? map_params(scoped, @element) : scoped
-      end
-
       private
 
-      # @deprecated A trailing positional options Hash is deprecated; pass keyword
-      #   arguments instead. Before Ruby 3 keyword separation this Hash was pulled
-      #   off the argument list by `extract_options!`; now it lands in the splat and
-      #   would silently be treated as a parameter name.
       # +requires+ and +optional+ differ only in whether what they declare is
       # required, so the declaration itself lives here.
       #
@@ -209,7 +187,7 @@ module Grape
       # other bucket", while +optional+ has no other bucket — +:all+ ignores
       # +except+ and +:none+ uses it to drop fields entirely.
       def declare(attrs, opts, required:, using:, except:, as:, &block)
-        merged_opts = @group&.deep_merge(opts) || opts
+        merged_opts = with_group_options(opts)
         declared_as = as || merged_opts[:as]
 
         if using
@@ -218,12 +196,23 @@ module Grape
           return require_optional_fields(attrs.first, using:, except:)
         end
 
+        # A block declares the keys of one param. Without a name its params
+        # landed one level up; with several, only the first got them.
+        raise ArgumentError, "a params block needs exactly one parameter name, got `#{attrs.size}`" if block && attrs.size != 1
+
         validates(attrs, merged_opts, required:)
         return push_declared_params(attrs, as: declared_as) unless block
 
         new_scope(attrs.first, type: merged_opts[:type], as: declared_as, optional: !required, &block)
       end
 
+      # +opts+ over the options of the +with+ blocks enclosing the declaration.
+      def with_group_options(opts)
+        @group&.deep_merge(opts) || opts
+      end
+
+      # A trailing positional options Hash (deprecated): since Ruby 3 keyword
+      # separation it lands in the splat and would be read as a parameter name.
       def legacy_options?(args)
         args.size > 1 && args.last.is_a?(Hash)
       end
@@ -239,21 +228,6 @@ module Grape
       def first_hash_key_or_param(parameter)
         parameter.is_a?(Hash) ? parameter.keys.first : parameter
       end
-
-      def map_params(params, element, is_array: false)
-        case params
-        when Array
-          params.map do |el|
-            map_params(el, element, is_array: true)
-          end
-        when Hash
-          params[element] || (@optional && is_array ? EmptyOptionalValue : {})
-        when EmptyOptionalValue
-          EmptyOptionalValue
-        else
-          {}
-        end
-      end
     end
   end
 end

data/lib/grape/dsl/request_response.rb

@@ -4,7 +4,7 @@ module Grape
   module DSL
     module RequestResponse
       # Specify the default format for the API's serializers.
-      # May be `:json` or `:txt` (default).
+      # e.g. `:json`, `:xml` or `:txt` (default).
       def default_format(new_format = nil)
         return inheritable_setting.default_format if new_format.nil?
 
@@ -13,16 +13,18 @@ module Grape
 
       # Specify the format for the API's serializers.
       # May be `:json`, `:xml`, `:txt`, etc.
+      # A format no content type is registered for used to be assigned before
+      # the check that rejects it, so a rescued call left the API formatting
+      # with a format it had just refused, and no default error formatter.
       def format(new_format = nil)
         return inheritable_setting.format if new_format.nil?
 
         symbolic_new_format = new_format.to_sym
-        inheritable_setting.format = symbolic_new_format
-        inheritable_setting.default_error_formatter = Grape::ErrorFormatter.formatter_for(symbolic_new_format)
-
         content_type = content_types[symbolic_new_format]
         raise Grape::Exceptions::MissingMimeType.new(new_format) unless content_type
 
+        inheritable_setting.format = symbolic_new_format
+        inheritable_setting.default_error_formatter = Grape::ErrorFormatter.formatter_for(symbolic_new_format)
         inheritable_setting.add_content_type(symbolic_new_format, content_type)
       end
 
@@ -78,6 +80,9 @@ module Grape
         inheritable_setting.default_error_status = new_status
       end
 
+      META_RESCUE_SELECTORS = %i[all grape_exceptions internal_grape_exceptions].freeze
+      private_constant :META_RESCUE_SELECTORS
+
       # Allows you to rescue certain exceptions that occur to return
       # a grape error rather than raising all the way to the
       # server level.
@@ -89,17 +94,15 @@ module Grape
       #       rescue_from CustomError
       #     end
       #
-      META_RESCUE_SELECTORS = %i[all grape_exceptions internal_grape_exceptions].freeze
-      private_constant :META_RESCUE_SELECTORS
-
       # @overload rescue_from(*exception_classes, **options)
       #   @param [Array] exception_classes A list of classes that you want to rescue, or
       #     one of the meta selectors +:all+, +:grape_exceptions+,
       #     +:internal_grape_exceptions+. Meta selectors must be used alone;
       #     mixing with exception classes raises +ArgumentError+.
-      #   @param [Block] block Execution block to handle the given exception.
-      #   @param [Proc] with Execution proc to handle the given exception as an alternative
-      #     to passing a block.
+      #   @param [Block] block Execution block to handle the given exception; a
+      #     trailing Proc argument works too.
+      #   @param [Proc, Symbol, String] with Alternative to a block; a Symbol or
+      #     String names an endpoint method.
       #   @param [Boolean] rescue_subclasses Also rescue subclasses of exception classes;
       #     defaults to +true+.
       #   @param [Boolean] backtrace Include the rescued exception's backtrace in the
@@ -111,17 +114,7 @@ module Grape
         meta_selector = (args & META_RESCUE_SELECTORS).first
         raise ArgumentError, "rescue_from `#{meta_selector.inspect}` does not accept additional arguments" if meta_selector && args.size > 1
 
-        case meta_selector
-        when :all
-          inheritable_setting.add_all_rescue_handler(handler)
-        when :grape_exceptions
-          inheritable_setting.add_grape_exceptions_rescue_handler(handler)
-        when :internal_grape_exceptions
-          inheritable_setting.add_internal_grape_exceptions_rescue_handler(handler)
-        else
-          inheritable_setting.add_rescue_handlers(args.to_h { |klass| [klass, handler] }, subclasses: rescue_subclasses)
-        end
-
+        add_rescue_handler(meta_selector, args, handler, rescue_subclasses)
         inheritable_setting.add_rescue_options(RescueOptions.new(backtrace:, original_exception:))
       end
 
@@ -158,8 +151,28 @@ module Grape
 
         return args.pop if args.last.is_a?(Proc)
         return block if block
-        return unless with
 
+        with_handler(with) if with
+      end
+
+      # Registers +handler+ under +meta_selector+, or for each of the
+      # +exception_classes+ when there is none.
+      def add_rescue_handler(meta_selector, exception_classes, handler, rescue_subclasses)
+        case meta_selector
+        when :all
+          inheritable_setting.add_all_rescue_handler(handler)
+        when :grape_exceptions
+          inheritable_setting.add_grape_exceptions_rescue_handler(handler)
+        when :internal_grape_exceptions
+          inheritable_setting.add_internal_grape_exceptions_rescue_handler(handler)
+        else
+          inheritable_setting.add_rescue_handlers(exception_classes.to_h { |klass| [klass, handler] }, subclasses: rescue_subclasses)
+        end
+      end
+
+      # A +with:+ handler as +rescue_from+ stores it: a Proc, or the name of a
+      # method to call.
+      def with_handler(with)
         case with
         when Proc, Symbol then with
         when String then with.to_sym

data/lib/grape/dsl/routing.rb

@@ -5,85 +5,6 @@ module Grape
     module Routing
       attr_reader :endpoints
 
-      def given(conditional_option, &)
-        return unless conditional_option
-
-        mounted(&)
-      end
-
-      def mounted(&block)
-        evaluate_as_instance_with_configuration(block, lazy: true)
-      end
-
-      def cascade(value = nil)
-        return inheritable_setting.cascade_defined? ? inheritable_setting.cascade : true if value.nil?
-
-        inheritable_setting.cascade = value
-      end
-
-      # Specify an API version.
-      #
-      # Called without arguments, returns the most recently declared version
-      # (or +nil+). Called with one or more version strings, registers them
-      # and stores a {Grape::DSL::VersionOptions} value object on the
-      # inheritable settings; when given a block, the registration applies
-      # within a nested namespace.
-      #
-      # @example API with legacy support.
-      #   class MyAPI < Grape::API
-      #     version 'v2'
-      #
-      #     get '/main' do
-      #       {some: 'data'}
-      #     end
-      #
-      #     version 'v1' do
-      #       get '/main' do
-      #         {legacy: 'data'}
-      #       end
-      #     end
-      #   end
-      #
-      # @param args [Array<String, Symbol>] one or more version identifiers.
-      # @param using [Symbol] versioning strategy — one of +:path+ (default),
-      #   +:header+, +:param+, or +:accept_version_header+.
-      # @param cascade [Boolean] forward to subsequent routes via the
-      #   +X-Cascade+ header on version mismatch. Defaults to +true+.
-      # @param parameter [String] name of the query/body parameter that
-      #   carries the version when +using: :param+. Defaults to +'apiver'+.
-      # @param strict [Boolean] reject requests that don't supply a usable
-      #   version (header strategies). Defaults to +false+.
-      # @param vendor [String, nil] vendor segment for the +:header+
-      #   strategy (+application/vnd.<vendor>-<version>+); required when
-      #   +using: :header+.
-      # @yield optional block to scope routes under this version.
-      # @return [String, nil] the most recently declared version.
-      # @raise [Grape::Exceptions::MissingVendorOption] when +using: :header+
-      #   is supplied without a +:vendor+.
-      def version(*args, using: :path, cascade: true, parameter: 'apiver', strict: false, vendor: nil, &block)
-        return @versions&.last if args.empty?
-
-        raise Grape::Exceptions::MissingVendorOption.new if using == :header && vendor.nil?
-
-        requested_versions = args.flatten.map(&:to_s)
-        options = VersionOptions.new(using:, cascade:, parameter:, strict:, vendor:)
-
-        @versions = versions | requested_versions
-
-        if block
-          within_namespace do
-            inheritable_setting.version = requested_versions
-            inheritable_setting.version_options = options
-            instance_eval(&block)
-          end
-        else
-          inheritable_setting.version = requested_versions
-          inheritable_setting.version_options = options
-        end
-
-        @versions&.last
-      end
-
       # Define a root URL prefix for your entire API.
       def prefix(prefix = nil)
         return inheritable_setting.root_prefix if prefix.nil?
@@ -96,9 +17,7 @@ module Grape
       # @param _name [Symbol] Purely placebo, just allows to name the scope to
       # make the code more readable.
       def scope(_name = nil, &block)
-        within_namespace do
-          nest(block)
-        end
+        within_namespace { nest(block) }
       end
 
       def build_with(build_with)
@@ -123,48 +42,6 @@ module Grape
         inheritable_setting.do_not_document!
       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
-          in_setting = inheritable_setting
-
-          # Past the mount_instance branch above, a Grape app here is an already
-          # instantiated Grape::API::Instance (vs. a bare Rack app).
-          if app.is_a?(Grape::Mountable)
-            mount_path = Grape::Util::PathNormalizer.call(path)
-            app.top_level_setting.add_mount_path(mount_path)
-
-            app.inherit_settings(inheritable_setting)
-
-            in_setting = app.top_level_setting
-
-            app.change!
-            change!
-          end
-
-          endpoints << Grape::Endpoint.new(
-            in_setting,
-            http_methods: :any,
-            path:,
-            app:,
-            anchor: false,
-            api: self
-          )
-        end
-      end
-
       # Defines a route that will be recognized
       # by the Grape API.
       #
@@ -189,19 +66,15 @@ module Grape
         # +params+, +requirements+ and +anchor+ each travel as their own endpoint
         # input; the route-options bag keeps the description's other keys
         # (+success+, +tags+, …) plus any custom options.
-        params = prepare_params(endpoint_description[:params])
-        all_route_options = endpoint_description.except(:params)
-        all_route_options.deep_merge!(route_options) if route_options.present?
-
         new_endpoint = Grape::Endpoint.new(
           inheritable_setting,
           http_methods:,
           path: paths,
           api: self,
-          params:,
+          params: prepare_params(endpoint_description[:params]),
           requirements:,
           anchor:,
-          route_options: all_route_options,
+          route_options: prepare_route_options(endpoint_description, route_options),
           &
         )
         endpoints << new_endpoint unless endpoints.include?(new_endpoint)
@@ -228,14 +101,14 @@ module Grape
       #         # defines the endpoint: GET /foo/bar
       #       end
       #     end
-      def namespace(space = nil, requirements: nil, **options, &block)
+      def namespace(space = nil, requirements: nil, **, &block)
         return inheritable_setting.namespace_path unless space || block
 
         validate_requirements!(requirements)
 
         within_namespace do
           nest(block) do
-            inheritable_setting.add_namespace(Grape::Namespace.new(space, requirements:, **options)) if space
+            inheritable_setting.add_namespace(Grape::Namespace.new(space, requirements:, **)) if space
           end
         end
       end
@@ -247,14 +120,15 @@ module Grape
 
       # An array of API routes.
       def routes
-        @routes ||= endpoints.map(&:routes).flatten
+        @routes ||= endpoints.flat_map(&:routes)
       end
 
       # This method allows you to quickly define a parameter route segment
       # in your API.
       #
       # @param param [Symbol] The name of the parameter you wish to declare.
-      # @option options [Regexp, Class, Symbol] The constraint the declared parameter must meet — a Regexp, or a capture type such as +Integer+.
+      # @param requirements [Regexp, Class, Symbol] The constraint the parameter must meet.
+      # @param type [Class] Declares the parameter with this type.
       def route_param(param, requirements: nil, type: nil, **, &)
         # The param is named here, so the constraint is its own: nest whatever
         # it is, not just a Regexp. A Hash would name the param twice, or key a
@@ -270,11 +144,6 @@ module Grape
         namespace(":#{param}", requirements: param_requirements, **, &)
       end
 
-      # @return array of defined versions
-      def versions
-        @versions ||= []
-      end
-
       private
 
       # Requirements are keyed by param name and merged across namespaces, so
@@ -295,6 +164,15 @@ module Grape
         endpoint_params.deep_merge(description_params)
       end
 
+      # The route's description (+desc+) less its +params+, with any custom
+      # +route_options+ deep-merged over it.
+      def prepare_route_options(description, route_options)
+        description_options = description.except(:params)
+        return description_options if route_options.empty?
+
+        description_options.deep_merge!(route_options)
+      end
+
       # Remove all defined routes.
       def reset_routes!
         endpoints.each(&:reset_routes!)
@@ -305,45 +183,6 @@ module Grape
         @endpoints = []
       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.
-      def refresh_mounted_api(mounts, opts = {})
-        drop_endpoints_mounted_for(mounts)
-        mount(mounts, opts)
-      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.
-      def drop_endpoints_mounted_for(mounts)
-        normalize_mounts(mounts).each_key do |app|
-          endpoints.delete_if { |endpoint| same_mounted_app?(endpoint.mounted_app, app) }
-        end
-      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
-
-      # 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
-
       # Execute first the provided block, then each of the
       # block passed in. Allows for simple 'before' setups
       # of settings stack pushes.
@@ -355,19 +194,6 @@ module Grape
         blocks.each { |b| evaluate_as_instance_with_configuration(b) }
         reset_validations!
       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

data/lib/grape/dsl/settings.rb

@@ -47,7 +47,7 @@ module Grape
       private
 
       # Execute the block within a context where our inheritable settings are forked
-      # to a new copy (see #namespace_start).
+      # to a new child scope.
       def within_namespace
         new_inheritable_settings = Grape::Util::InheritableSetting.new
         new_inheritable_settings.inherit_from inheritable_setting