grape 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f57d6d494fcd9459d437ca723a988bfe68c7059accaec1ea2e01ddba66b0958
-  data.tar.gz: 84aebfa13e7591da6a520b3f3287bc479371be55afa3ee7bbc06ed1c12b5089c
+  metadata.gz: a5d4ecfd73b009cc3c4bcfd0ed50048d70d15a20c48e5282571ef5d9dc717316
+  data.tar.gz: 60de796e7e411513df39ac636750d9ce22ac5f43bec24dce48627d672d63a9d8
 SHA512:
-  metadata.gz: 58cd9a65cadb03008d053fa4f1e5259079942cf39f714ddf54d1d9f7cd2b9e1d81a2c2cddb346270e24b6a424c3adff9664e1627eb0d03f5bf6bf67d5b0b3b6f
-  data.tar.gz: d73cb08a47287b24044aefa037ebf5e85850a4bc1e41859247416537cf5ce720936f69da42974dd2fa661a042292ed9a51b2e46d1091a221f08dc198ecb4fb27
+  metadata.gz: 8cedc8302caa250302cde57047e45fb20d6dcd7f03cc71aa0f5cc1544e548a9d13745264f11c6c1dbd17dc82c8cf80165a4a803877a1c8fce4e96912bfdb3c06
+  data.tar.gz: 25f407f60587fc6ebed6e10fc91ea74f5bf3e23846b52a20f188a755fa0caa9f224b7d03b07542855f7894b99e078441bc0556d9ed41bc89ffde0c042dc8cd50

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+### 3.1.0 (2026-01-25)
+
+#### Features
+
+* [#2629](https://github.com/ruby-grape/grape/pull/2629): Refactor Router Architecture - [@ericproulx](https://github.com/ericproulx).
+* [#2633](https://github.com/ruby-grape/grape/pull/2633): Refactor API::Instance and reorganize DSL modules - [@ericproulx](https://github.com/ericproulx).
+* [#2636](https://github.com/ruby-grape/grape/pull/2636): Refactor router to simplify method signatures and reduce duplication - [@ericproulx](https://github.com/ericproulx).
+* [#2640](https://github.com/ruby-grape/grape/pull/2640): Compute available_media_types once - [@ericproulx](https://github.com/ericproulx).
+* [#2637](https://github.com/ruby-grape/grape/pull/2637): Refactor declared method - [@ericproulx](https://github.com/ericproulx).
+* [#2639](https://github.com/ruby-grape/grape/pull/2639): Refactor mime_types_for - [@ericproulx](https://github.com/ericproulx).
+* [#2638](https://github.com/ruby-grape/grape/pull/2638): Remove unnecessary path string duplication - [@ericproulx](https://github.com/ericproulx).
+* [#2643](https://github.com/ruby-grape/grape/pull/2638): Remove `try` method in codebase - [@ericproulx](https://github.com/ericproulx).
+* [#2646](https://github.com/ruby-grape/grape/pull/2646): Call `valid_encoding?` before scrub - [@ericproulx](https://github.com/ericproulx).
+* [#2644](https://github.com/ruby-grape/grape/pull/2644): Clean useless/not valuable dependencies - [@ericproulx](https://github.com/ericproulx).
+* [#2649](https://github.com/ruby-grape/grape/pull/2644): Drop support Ruby 3.0 and ActiveSupport 7.0 - [@ericproulx](https://github.com/ericproulx).
+* [#2648](https://github.com/ruby-grape/grape/pull/2648): Remove deprecated ParamsBuilders extensions - [@ericproulx](https://github.com/ericproulx).
+* [#2645](https://github.com/ruby-grape/grape/pull/2645): Endpoints are compiled when API is compiled - [@ericproulx](https://github.com/ericproulx).
+* [#2647](https://github.com/ruby-grape/grape/pull/2647): Explicit kwargs for `namespace` and `route_param` - [@ericproulx](https://github.com/ericproulx).
+* [#2651](https://github.com/ruby-grape/grape/pull/2651): Migrate Danger to use danger-pr-comment workflow - [@dblock](https://github.com/dblock).
+
+#### Fixes
+    
+* [#2633](https://github.com/ruby-grape/grape/pull/2633): Fix cascade reading - [@ericproulx](https://github.com/ericproulx).
+* [#2641](https://github.com/ruby-grape/grape/pull/2641): Restore support for `return` in endpoint blocks - [@ericproulx](https://github.com/ericproulx).
+* [#2642](https://github.com/ruby-grape/grape/pull/2642): Fix array allocation in base_route.rb - [@ericproulx](https://github.com/ericproulx).
+
 ### 3.0.1 (2025-11-24)
 
 #### Features

data/CONTRIBUTING.md

@@ -48,8 +48,8 @@ Here are some examples:
 - running rspec on a specific file `docker-compose run --rm --build grape rspec spec/:file_path`
 - running task `docker-compose run --rm --build grape rake <task_name>`
 - running rubocop `docker-compose run --rm --build grape rubocop`
-- running all specs on a specific ruby version (e.g 3.0) `RUBY_VERSION=3.0 docker-compose run --rm --build grape rspec`
-- running specs on a specific gemfile (e.g rails_7_0.gemfile) `docker-compose run -e GEMFILE=rails_7_0 --rm --build grape rspec`
+- running all specs on a specific ruby version (e.g 3.4) `RUBY_VERSION=3.4 docker-compose run --rm --build grape rspec`
+- running specs on a specific gemfile (e.g rails_8_1.gemfile) `docker-compose run -e GEMFILE=rails_8_1 --rm --build grape rspec`
 
 #### Bundle Install and Test
 

data/README.md

@@ -160,7 +160,7 @@ Grape is a REST-like API framework for Ruby. It's designed to run on Rack or com
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Grape, 3.0.1.
+You're reading the documentation for the stable release of Grape, 3.1.0.
 
 ## Project Resources
 
@@ -177,7 +177,7 @@ The maintainers of Grape are working with Tidelift to deliver commercial support
 
 ## Installation
 
-Ruby 3.0 or newer is required.
+Ruby 3.1 or newer is required.
 
 Grape is available as a gem, to install it run:
 

data/UPGRADING.md

@@ -1,6 +1,20 @@
 Upgrading Grape
 ===============
 
+### Upgrading to >= 3.1
+
+#### Explicit kwargs for `namespace` and `route_param`
+
+The `API#namespace` and `route_param` methods are now defined with `**options` instead of `options = {}`. In addtion, `requirements` in explicitly defined so it's not in `options` anymore. You can still call `requirements` like before but `options[:requirements]` will be empty. For `route_param`, `type` is also an explicit parameter so it's not in `options` anymore. See [#2647](https://github.com/ruby-grape/grape/pull/2647) for more information.
+
+#### ParamsBuilder Grape::Extensions
+
+Deprecated [ParamsBuilder's extensions](https://github.com/ruby-grape/grape/blob/master/UPGRADING.md#params-builder) have been removed.
+
+#### Enhanced API compile!
+
+Endpoints are now "compiled" instead of lazy loaded. Historically, when calling `YourAPI.compile!` in `config.ru` (or just receiving the first API call), only routing was compiled see [Grape::Router#compile!](https://github.com/ruby-grape/grape/blob/bf90e95c3b17c415c944363b1c07eb9727089ee7/lib/grape/router.rb#L41-L54) and endpoints were lazy loaded. Now, it's part of the API compilation. See [#2645](https://github.com/ruby-grape/grape/pull/2645) for more information.
+
 ### Upgrading to >= 3.0.0
 
 #### Ruby 3+ Argument Delegation Modernization

data/grape.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
     'rubygems_mfa_required' => 'true'
   }
 
-  s.add_dependency 'activesupport', '>= 7.0'
+  s.add_dependency 'activesupport', '>= 7.1'
   s.add_dependency 'dry-configurable'
   s.add_dependency 'dry-types', '>= 1.1'
   s.add_dependency 'mustermann-grape', '~> 1.1.0'
@@ -29,5 +29,5 @@ Gem::Specification.new do |s|
 
   s.files = Dir['lib/**/*', 'CHANGELOG.md', 'CONTRIBUTING.md', 'README.md', 'grape.png', 'UPGRADING.md', 'LICENSE', 'grape.gemspec']
   s.require_paths = ['lib']
-  s.required_ruby_version = '>= 3.0'
+  s.required_ruby_version = '>= 3.1'
 end

data/lib/grape/api/instance.rb

@@ -21,20 +21,9 @@ module Grape
       class << self
         extend Forwardable
 
-        attr_reader :instance, :base
         attr_accessor :configuration
 
-        def_delegators :base, :to_s
-
-        def given(conditional_option, &block)
-          return unless conditional_option
-
-          mounted(&block)
-        end
-
-        def mounted(&block)
-          evaluate_as_instance_with_configuration(block, lazy: true)
-        end
+        def_delegators :@base, :to_s
 
         def base=(grape_api)
           @base = grape_api
@@ -42,7 +31,7 @@ module Grape
         end
 
         def base_instance?
-          self == base.base_instance
+          self == @base.base_instance
         end
 
         # A class-level lock to ensure the API is not compiled by multiple
@@ -56,43 +45,30 @@ module Grape
           reset_validations!
         end
 
-        # Parses the API's definition and compiles it into an instance of
-        # Grape::API.
-        def compile
-          @instance ||= new # rubocop:disable Naming/MemoizedInstanceVariableName
-        end
-
         # This is the interface point between Rack and Grape; it accepts a request
         # from Rack and ultimately returns an array of three values: the status,
         # the headers, and the body. See [the rack specification]
         # (http://www.rubydoc.info/github/rack/rack/master/file/SPEC) for more.
         def call(env)
           compile!
-          call!(env)
-        end
-
-        # A non-synchronized version of ::call.
-        def call!(env)
-          instance.call(env)
-        end
-
-        # (see #cascade?)
-        def cascade(value = nil)
-          return inheritable_setting.namespace_inheritable.key?(:cascade) ? !inheritable_setting.namespace_inheritable(:cascade).nil? : true if value.nil?
-
-          inheritable_setting.namespace_inheritable[:cascade] = value
+          @instance.call(env)
         end
 
         def compile!
-          return if instance
+          return if @instance
 
-          LOCK.synchronize { compile unless instance }
+          LOCK.synchronize { @instance ||= new }
         end
 
         # see Grape::Router#recognize_path
         def recognize_path(path)
           compile!
-          instance.router.recognize_path(path)
+          @instance.router.recognize_path(path)
+        end
+
+        # Wipe the compiled API so we can recompile after changes were made.
+        def change!
+          @instance = nil
         end
 
         protected
@@ -110,11 +86,6 @@ module Grape
           reset_routes!
         end
 
-        # Wipe the compiled API so we can recompile after changes were made.
-        def change!
-          @instance = nil
-        end
-
         private
 
         def inherited(subclass)
@@ -177,7 +148,7 @@ module Grape
       def add_head_not_allowed_methods_and_options_methods
         # The paths we collected are prepared (cf. Path#prepare), so they
         # contain already versioning information when using path versioning.
-        all_routes = self.class.endpoints.map(&:routes).flatten
+        all_routes = self.class.endpoints.flat_map(&:routes)
 
         # Disable versioning so adding a route won't prepend versioning
         # informations again.
@@ -186,23 +157,21 @@ module Grape
 
       def collect_route_config_per_pattern(all_routes)
         routes_by_regexp = all_routes.group_by(&:pattern_regexp)
+        namespace_inheritable = self.class.inheritable_setting.namespace_inheritable
 
         # Build the configuration based on the first endpoint and the collection of methods supported.
         routes_by_regexp.each_value do |routes|
-          last_route = routes.last # Most of the configuration is taken from the last endpoint
           next if routes.any? { |route| route.request_method == '*' }
 
-          namespace_inheritable = self.class.inheritable_setting.namespace_inheritable
+          last_route = routes.last # Most of the configuration is taken from the last endpoint
           allowed_methods = routes.map(&:request_method)
           allowed_methods |= [Rack::HEAD] if !namespace_inheritable[:do_not_route_head] && allowed_methods.include?(Rack::GET)
 
           allow_header = namespace_inheritable[:do_not_route_options] ? allowed_methods : [Rack::OPTIONS] | allowed_methods
           last_route.app.options[:options_route_enabled] = true unless namespace_inheritable[:do_not_route_options] || allowed_methods.include?(Rack::OPTIONS)
 
-          @router.associate_routes(last_route.pattern, {
-                                     endpoint: last_route.app,
-                                     allow_header: allow_header
-                                   })
+          greedy_route = Grape::Router::GreedyRoute.new(last_route.pattern, endpoint: last_route.app, allow_header: allow_header)
+          @router.associate_routes(greedy_route)
         end
       end
 

data/lib/grape/api.rb

@@ -5,7 +5,7 @@ module Grape
   # should subclass this class in order to build an API.
   class API
     # Class methods that we want to call on the API rather than on the API object
-    NON_OVERRIDABLE = %i[call call! configuration compile! inherited recognize_path routes].freeze
+    NON_OVERRIDABLE = %i[base= base_instance? call change! configuration compile! inherit_settings recognize_path reset! routes top_level_setting= top_level_setting].freeze
 
     Helpers = Grape::DSL::Helpers::BaseHelper
 
@@ -29,7 +29,7 @@ module Grape
       # the headers, and the body. See [the rack specification]
       # (https://github.com/rack/rack/blob/main/SPEC.rdoc) for more.
       # NOTE: This will only be called on an API directly mounted on RACK
-      def_delegators :base_instance, :new, :configuration, :call, :compile!
+      def_delegators :base_instance, :new, :configuration, :call, :change!, :compile!, :recognize_path, :routes
 
       # Initialize the instance variables on the remountable class, and the base_instance
       # an instance that will be used to create the set up but will not be mounted
@@ -140,12 +140,12 @@ module Grape
       end
 
       def any_lazy?(args)
-        args.any? { |argument| argument.try(:lazy?) }
+        args.any? { |argument| argument_lazy?(argument) }
       end
 
       def evaluate_arguments(configuration, *args)
         args.map do |argument|
-          if argument.try(:lazy?)
+          if argument_lazy?(argument)
             argument.evaluate_from(configuration)
           elsif argument.is_a?(Hash)
             argument.transform_values { |value| evaluate_arguments(configuration, value).first }
@@ -157,12 +157,8 @@ module Grape
         end
       end
 
-      def never_mounted?
-        mounted_instances.empty?
-      end
-
-      def mounted_instances
-        instances - [base_instance]
+      def argument_lazy?(argument)
+        argument.respond_to?(:lazy?) && argument.lazy?
       end
     end
   end

data/lib/grape/content_types.rb

@@ -22,10 +22,7 @@ module Grape
     def mime_types_for(from_settings)
       return MIME_TYPES if from_settings == Grape::ContentTypes::DEFAULTS
 
-      from_settings.each_with_object({}) do |(k, v), types_without_params|
-        # remove optional parameter
-        types_without_params[v.split(';', 2).first] = k
-      end
+      from_settings.invert.transform_keys! { |k| k.include?(';') ? k.split(';', 2).first : k }
     end
   end
 end

data/lib/grape/declared_params_handler.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Grape
+  class DeclaredParamsHandler
+    def initialize(include_missing: true, evaluate_given: false, stringify: false, contract_key_map: nil)
+      @include_missing = include_missing
+      @evaluate_given = evaluate_given
+      @stringify = stringify
+      @contract_key_map = contract_key_map
+    end
+
+    def call(passed_params, declared_params, route_params, renamed_params)
+      recursive_declared(
+        passed_params,
+        declared_params: declared_params,
+        route_params: route_params,
+        renamed_params: renamed_params
+      )
+    end
+
+    private
+
+    def recursive_declared(passed_params, declared_params:, route_params:, renamed_params:, params_nested_path: [])
+      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:)
+              end
+            else
+              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) }
+
+      res
+    end
+
+    def declared_hash(passed_params, declared_params:, params_nested_path:, renamed_params:, route_params:)
+      declared_params.each_with_object(passed_params.class.new) do |declared_param_attr, memo|
+        next if @evaluate_given && !declared_param_attr.scope.attr_meets_dependency?(passed_params)
+
+        declared_hash_attr(
+          passed_params,
+          declared_param: declared_param_attr.key,
+          params_nested_path:,
+          memo:,
+          renamed_params:,
+          route_params:
+        )
+      end
+    end
+
+    def declared_hash_attr(passed_params, declared_param:, params_nested_path:, memo:, renamed_params:, route_params:)
+      if declared_param.is_a?(Hash)
+        declared_param.each_pair do |declared_parent_param, declared_children_params|
+          next unless @include_missing || passed_params.key?(declared_parent_param)
+
+          memo_key = build_memo_key(params_nested_path, declared_parent_param, renamed_params)
+          passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
+
+          params_nested_path_dup = params_nested_path.dup
+          params_nested_path_dup << declared_parent_param.to_s
+
+          memo[memo_key] = handle_passed_param(params_nested_path_dup, route_params:, has_passed_children: passed_children_params.any?) do
+            recursive_declared(
+              passed_children_params,
+              declared_params: declared_children_params,
+              params_nested_path: params_nested_path_dup,
+              renamed_params:,
+              route_params:
+            )
+          end
+        end
+      else
+        # If it is not a Hash then it does not have children.
+        # Find its value or set it to nil.
+        return unless @include_missing || (passed_params.respond_to?(:key?) && passed_params.key?(declared_param))
+
+        memo_key = build_memo_key(params_nested_path, declared_param, renamed_params)
+        passed_param = passed_params[declared_param]
+
+        params_nested_path_dup = params_nested_path.dup
+        params_nested_path_dup << declared_param.to_s
+
+        memo[memo_key] = passed_param || handle_passed_param(params_nested_path_dup, route_params:) do
+          passed_param
+        end
+      end
+    end
+
+    def build_memo_key(params_nested_path, declared_param, renamed_params)
+      rename_path = params_nested_path + [declared_param.to_s]
+      renamed_param_name = renamed_params[rename_path]
+
+      param = renamed_param_name || declared_param
+      @stringify ? param.to_s : param.to_sym
+    end
+
+    def handle_passed_param(params_nested_path, route_params:, has_passed_children: false, &_block)
+      return yield if has_passed_children
+
+      key = params_nested_path[0]
+      key += "[#{params_nested_path[1..].join('][')}]" if params_nested_path.size > 1
+
+      type = route_params.dig(key, :type)
+      has_children = route_params.keys.any? { |k| k != key && k.start_with?("#{key}[") }
+
+      if type == 'Hash' && !has_children
+        {}
+      elsif type == 'Array' || (type&.start_with?('[') && !type.include?(','))
+        []
+      elsif type == 'Set' || type&.start_with?('#<Set', 'Set')
+        Set.new
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/grape/dsl/declared.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Grape
+  module DSL
+    module Declared
+      # Denotes a situation where a DSL method has been invoked in a
+      # filter which it should not yet be available in
+      class MethodNotYetAvailable < StandardError
+        def initialize(msg = '#declared is not available prior to parameter validation')
+          super
+        end
+      end
+
+      # A filtering method that will return a hash
+      # 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.
+      def declared(passed_params, include_parent_namespaces: true, include_missing: true, evaluate_given: false, stringify: false)
+        raise MethodNotYetAvailable unless before_filter_passed
+
+        contract_key_map = inheritable_setting.namespace_stackable[:contract_key_map]
+        handler = DeclaredParamsHandler.new(include_missing:, evaluate_given:, stringify:, contract_key_map: contract_key_map)
+        declared_params = include_parent_namespaces ? inheritable_setting.route[:declared_params] : (inheritable_setting.namespace_stackable[:declared_params].last || [])
+        renamed_params = inheritable_setting.route[:renamed_params] || {}
+        route_params = options.dig(:route_options, :params) || {} # options = endpoint's option
+
+        handler.call(passed_params, declared_params, route_params, renamed_params)
+      end
+    end
+  end
+end

data/lib/grape/dsl/helpers.rb

@@ -50,9 +50,9 @@ module Grape
         end
       end
 
-      def make_inclusion(mod, &block)
+      def make_inclusion(mod, &)
         define_boolean_in_mod(mod)
-        inject_api_helpers_to_mod(mod, &block)
+        inject_api_helpers_to_mod(mod, &)
         inheritable_setting.namespace_stackable[:helpers] = mod
       end
 

data/lib/grape/dsl/inside_route.rb

@@ -3,148 +3,10 @@
 module Grape
   module DSL
     module InsideRoute
-      # Denotes a situation where a DSL method has been invoked in a
-      # filter which it should not yet be available in
-      class MethodNotYetAvailable < StandardError; end
+      include Declared
 
-      # @param type [Symbol] The type of filter for which evaluation has been
-      #   completed
-      # @return [Module] A module containing method overrides suitable for the
-      #   position in the filter evaluation sequence denoted by +type+.  This
-      #   defaults to an empty module if no overrides are defined for the given
-      #   filter +type+.
-      def self.post_filter_methods(type)
-        @post_filter_modules ||= { before: PostBeforeFilter }
-        @post_filter_modules[type]
-      end
-
-      # Methods which should not be available in filters until the before filter
-      # has completed
-      module PostBeforeFilter
-        def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
-          options.reverse_merge!(include_missing: true, include_parent_namespaces: true, evaluate_given: false)
-          declared_params ||= optioned_declared_params(options[:include_parent_namespaces])
-
-          res = if passed_params.is_a?(Array)
-                  declared_array(passed_params, options, declared_params, params_nested_path)
-                else
-                  declared_hash(passed_params, options, declared_params, params_nested_path)
-                end
-
-          if (key_maps = inheritable_setting.namespace_stackable[:contract_key_map])
-            key_maps.each { |key_map| key_map.write(passed_params, res) }
-          end
-
-          res
-        end
-
-        private
-
-        def declared_array(passed_params, options, declared_params, params_nested_path)
-          passed_params.map do |passed_param|
-            declared(passed_param || {}, options, declared_params, params_nested_path)
-          end
-        end
-
-        def declared_hash(passed_params, options, declared_params, params_nested_path)
-          declared_params.each_with_object(passed_params.class.new) do |declared_param_attr, memo|
-            next if options[:evaluate_given] && !declared_param_attr.scope.attr_meets_dependency?(passed_params)
-
-            declared_hash_attr(passed_params, options, declared_param_attr.key, params_nested_path, memo)
-          end
-        end
-
-        def declared_hash_attr(passed_params, options, declared_param, params_nested_path, memo)
-          renamed_params = inheritable_setting.route[:renamed_params] || {}
-          if declared_param.is_a?(Hash)
-            declared_param.each_pair do |declared_parent_param, declared_children_params|
-              params_nested_path_dup = params_nested_path.dup
-              params_nested_path_dup << declared_parent_param.to_s
-              next unless options[:include_missing] || passed_params.key?(declared_parent_param)
-
-              rename_path = params_nested_path + [declared_parent_param.to_s]
-              renamed_param_name = renamed_params[rename_path]
-
-              memo_key = optioned_param_key(renamed_param_name || declared_parent_param, options)
-              passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
-
-              memo[memo_key] = handle_passed_param(params_nested_path_dup, passed_children_params.any?) do
-                declared(passed_children_params, options, declared_children_params, params_nested_path_dup)
-              end
-            end
-          else
-            # If it is not a Hash then it does not have children.
-            # Find its value or set it to nil.
-            return unless options[:include_missing] || passed_params.try(:key?, declared_param)
-
-            rename_path = params_nested_path + [declared_param.to_s]
-            renamed_param_name = renamed_params[rename_path]
-
-            memo_key = optioned_param_key(renamed_param_name || declared_param, options)
-            passed_param = passed_params[declared_param]
-
-            params_nested_path_dup = params_nested_path.dup
-            params_nested_path_dup << declared_param.to_s
-            memo[memo_key] = passed_param || handle_passed_param(params_nested_path_dup) do
-              passed_param
-            end
-          end
-        end
-
-        def handle_passed_param(params_nested_path, has_passed_children = false, &_block)
-          return yield if has_passed_children
-
-          key = params_nested_path[0]
-          key += "[#{params_nested_path[1..].join('][')}]" if params_nested_path.size > 1
-
-          route_options_params = options[:route_options][:params] || {}
-          type = route_options_params.dig(key, :type)
-          has_children = route_options_params.keys.any? { |k| k != key && k.start_with?("#{key}[") }
-
-          if type == 'Hash' && !has_children
-            {}
-          elsif type == 'Array' || (type&.start_with?('[') && type.exclude?(','))
-            []
-          elsif type == 'Set' || type&.start_with?('#<Set')
-            Set.new
-          else
-            yield
-          end
-        end
-
-        def optioned_param_key(declared_param, options)
-          options[:stringify] ? declared_param.to_s : declared_param.to_sym
-        end
-
-        def optioned_declared_params(include_parent_namespaces)
-          declared_params = if include_parent_namespaces
-                              # Declared params including parent namespaces
-                              inheritable_setting.route[:declared_params]
-                            else
-                              # Declared params at current namespace
-                              inheritable_setting.namespace_stackable[:declared_params].last || []
-                            end
-
-          raise ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
-
-          declared_params
-        end
-      end
-
-      # A filtering method that will return a hash
-      # consisting only of keys that have been declared by a
-      # `params` statement against the current/target endpoint or parent
-      # namespaces.
-      #
-      # @see +PostBeforeFilter#declared+
-      #
-      # @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.
-      def declared(*)
-        raise MethodNotYetAvailable, '#declared is not available prior to parameter validation.'
-      end
+      # Backward compatibility: alias exception class to previous location
+      MethodNotYetAvailable = Declared::MethodNotYetAvailable
 
       # The API version as specified in the URL.
       def version