Remove namespace_reverse_stackable from public DSL interface

- Remove namespace_reverse_stackable method from Grape::DSL::Settings
- Replace direct calls to namespace_reverse_stackable with inheritable_setting.namespace_reverse_stackable
- Update rescue_from implementation to use direct inheritable_setting access
- Update tests to verify actual behavior instead of mocking internal methods
- Simplify test setup by extending Grape::DSL::Settings instead of manually stubbing methods

Author: ericproulx

CHANGELOG.md

@@ -15,6 +15,7 @@
 * [#2599](https://github.com/ruby-grape/grape/pull/2599): Simplify settings DSL get_or_set method and optimize logger implementation - [@ericproulx](https://github.com/ericproulx).
 * [#2600](https://github.com/ruby-grape/grape/pull/2600): Refactor versioner middleware: simplify base class and improve consistency - [@ericproulx](https://github.com/ericproulx).
 * [#2601](https://github.com/ruby-grape/grape/pull/2601): Refactor route_setting internal usage to use inheritable_setting.route for improved consistency and performance - [@ericproulx](https://github.com/ericproulx).
+* [#2602](https://github.com/ruby-grape/grape/pull/2602): Remove `namespace_reverse_stackable` from public DSL interface and use direct inheritable_setting access - [@ericproulx](https://github.com/ericproulx).
 * Your contribution here.
 
 #### Fixes

lib/grape/dsl/desc.rb

@@ -57,7 +57,7 @@ def desc(description, options = {}, &config_block)
           else
             options.merge(description: description)
           end
-        namespace_setting :description, settings
+        inheritable_setting.namespace[:description] = settings
         inheritable_setting.route[:description] = settings
       end
     end

lib/grape/dsl/request_response.rb

@@ -117,7 +117,7 @@ def rescue_from(*args, &block)
               :base_only_rescue_handlers
             end
 
-          namespace_reverse_stackable(handler_type, args.to_h { |arg| [arg, handler] })
+          inheritable_setting.namespace_reverse_stackable[handler_type] = args.to_h { |arg| [arg, handler] }
         end
 
         namespace_stackable(:rescue_options, options)

lib/grape/dsl/settings.rb

@@ -46,10 +46,6 @@ def namespace_setting(key, value = nil)
         get_or_set(inheritable_setting.namespace, key, value)
       end
 
-      def namespace_reverse_stackable(key, value = nil)
-        get_or_set(inheritable_setting.namespace_reverse_stackable, key, value)
-      end
-
       def namespace_stackable_with_hash(key)
         settings = namespace_stackable(key)
         return if settings.blank?

spec/grape/dsl/request_response_spec.rb

@@ -6,36 +6,7 @@
   let(:dummy_class) do
     Class.new do
       extend Grape::DSL::RequestResponse
-
-      def self.namespace_stackable_with_hash(_key)
-        {}
-      end
-
-      def self.namespace_stackable(key, value = nil)
-        if value
-          namespace_stackable_hash[key] << value
-        else
-          namespace_stackable_hash[key]
-        end
-      end
-
-      def self.namespace_inheritable(key, value = nil)
-        if value
-          namespace_inheritable_hash[key] = value
-        else
-          namespace_inheritable_hash[key]
-        end
-      end
-
-      def self.namespace_stackable_hash
-        @namespace_stackable_hash ||= Hash.new do |hash, key|
-          hash[key] = []
-        end
-      end
-
-      def self.namespace_inheritable_hash
-        @namespace_inheritable_hash ||= {}
-      end
+      extend Grape::DSL::Settings
     end
   end
 
@@ -147,7 +118,7 @@ def self.namespace_inheritable_hash
       it 'sets a rescue handler declared through :with option' do
         with_block = -> { 'hello' }
         expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-        expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, an_instance_of(Proc))
+        expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, with_block)
         subject.rescue_from :all, with: with_block
       end
 
@@ -192,43 +163,43 @@ def self.namespace_inheritable_hash
         with_block = -> { 'hello' }
         expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
         expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
-        expect(subject).to receive(:namespace_inheritable).with(:grape_exceptions_rescue_handler, an_instance_of(Proc))
+        expect(subject).to receive(:namespace_inheritable).with(:grape_exceptions_rescue_handler, with_block)
         subject.rescue_from :grape_exceptions, with: with_block
       end
     end
 
     describe 'list of exceptions is passed' do
       it 'sets hash of exceptions as rescue handlers' do
-        expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => nil })
         expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
         subject.rescue_from StandardError
+        expect(subject.inheritable_setting.namespace_reverse_stackable[:rescue_handlers]).to eq([StandardError => nil])
       end
 
       it 'rescues only base handlers if rescue_subclasses: false option is passed' do
-        expect(subject).to receive(:namespace_reverse_stackable).with(:base_only_rescue_handlers, { StandardError => nil })
         expect(subject).to receive(:namespace_stackable).with(:rescue_options, { rescue_subclasses: false })
         subject.rescue_from StandardError, rescue_subclasses: false
+        expect(subject.inheritable_setting.namespace_reverse_stackable[:base_only_rescue_handlers]).to eq([StandardError => nil])
       end
 
       it 'sets given proc as rescue handler for each key in hash' do
         rescue_handler_proc = proc {}
-        expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => rescue_handler_proc })
         expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
         subject.rescue_from StandardError, rescue_handler_proc
+        expect(subject.inheritable_setting.namespace_reverse_stackable[:rescue_handlers]).to eq([StandardError => rescue_handler_proc])
       end
 
       it 'sets given block as rescue handler for each key in hash' do
         rescue_handler_proc = proc {}
-        expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => rescue_handler_proc })
         expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
         subject.rescue_from StandardError, &rescue_handler_proc
+        expect(subject.inheritable_setting.namespace_reverse_stackable[:rescue_handlers]).to eq([StandardError => rescue_handler_proc])
       end
 
       it 'sets a rescue handler declared through :with option for each key in hash' do
         with_block = -> { 'hello' }
-        expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => an_instance_of(Proc) })
         expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
         subject.rescue_from StandardError, with: with_block
+        expect(subject.inheritable_setting.namespace_reverse_stackable[:rescue_handlers]).to eq([StandardError => with_block])
       end
     end
   end