Merge pull request #2605 from ruby-grape/add_rack_3_2_gemfile

dblock · web-flow · commit 6dc01a7e0dfc · 2025-09-25T11:25:14.000-04:00
Add Rack 3.2 Support
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -24,7 +24,7 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ['3.0', '3.1', '3.2', '3.3', '3.4']
-        gemfile: [Gemfile, gemfiles/rack_2_0.gemfile, gemfiles/rack_3_0.gemfile, gemfiles/rack_3_1.gemfile, gemfiles/rails_7_0.gemfile, gemfiles/rails_7_1.gemfile, gemfiles/rails_7_2.gemfile, gemfiles/rails_8_0.gemfile]
+        gemfile: [Gemfile, gemfiles/rack_2_0.gemfile, gemfiles/rack_3_0.gemfile, gemfiles/rack_3_1.gemfile, gemfiles/rack_3_2.gemfile, gemfiles/rails_7_0.gemfile, gemfiles/rails_7_1.gemfile, gemfiles/rails_7_2.gemfile, gemfiles/rails_8_0.gemfile]
         specs: ['spec --exclude-pattern=spec/integration/**/*_spec.rb']
         include:
           - ruby: '3.3'
diff --git a/.rubocop.yml b/.rubocop.yml
@@ -35,7 +35,7 @@ Style/Send:
   Enabled: true
 
 Metrics/AbcSize:
-  Max: 45
+  Max: 50
 
 Metrics/BlockLength:
   Max: 30
diff --git a/.simplecov b/.simplecov
@@ -11,5 +11,6 @@ if ENV['GITHUB_USER'] # only when running CI
 end
 
 SimpleCov.start do
+  enable_coverage :branch
   add_filter '/spec/'
 end
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,10 @@
 * [#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).
+* [#2603](https://github.com/ruby-grape/grape/pull/2603): Remove `namespace_stackable_with_hash` from public interface and move to internal InheritableSetting - [@ericproulx](https://github.com/ericproulx).
+* [#2604](https://github.com/ruby-grape/grape/pull/2604): Enable branch coverage  - [@ericproulx](https://github.com/ericproulx).
+* [#2605](https://github.com/ruby-grape/grape/pull/2605): Add Rack 3.2 support with new gemfile and CI integration - [@ericproulx](https://github.com/ericproulx).
 * Your contribution here.
 
 #### Fixes
diff --git a/gemfiles/rack_3_2.gemfile b/gemfiles/rack_3_2.gemfile
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+eval_gemfile '../Gemfile'
+
+gem 'rack', '~> 3.2'
diff --git a/lib/grape/dsl/desc.rb b/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
diff --git a/lib/grape/dsl/inside_route.rb b/lib/grape/dsl/inside_route.rb
@@ -389,22 +389,22 @@ def route
       # @return [Class] the located Entity class, or nil if none is found
       def entity_class_for_obj(object, options)
         entity_class = options.delete(:with)
-
-        if entity_class.nil?
-          # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
-          object_class = if object.respond_to?(:klass)
-                           object.klass
-                         else
-                           object.respond_to?(:first) ? object.first.class : object.class
-                         end
-
-          object_class.ancestors.each do |potential|
-            entity_class ||= (namespace_stackable_with_hash(:representations) || {})[potential]
-          end
-
-          entity_class ||= object_class.const_get(:Entity) if object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)
+        return entity_class if entity_class
+
+        # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
+        object_class = if object.respond_to?(:klass)
+                         object.klass
+                       else
+                         object.respond_to?(:first) ? object.first.class : object.class
+                       end
+
+        representations = inheritable_setting.namespace_stackable_with_hash(:representations)
+        if representations
+          potential = object_class.ancestors.detect { |potential| representations.key?(potential) }
+          entity_class = representations[potential] if potential
         end
 
+        entity_class = object_class.const_get(:Entity) if !entity_class && object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)
         entity_class
       end
 
diff --git a/lib/grape/dsl/parameters.rb b/lib/grape/dsl/parameters.rb
@@ -54,7 +54,7 @@ def build_with(build_with)
       #       end
       #     end
       def use(*names)
-        named_params = @api.namespace_stackable_with_hash(:named_params) || {}
+        named_params = @api.inheritable_setting.namespace_stackable_with_hash(:named_params) || {}
         options = names.extract_options!
         names.each do |name|
           params_block = named_params.fetch(name) do
diff --git a/lib/grape/dsl/request_response.rb b/lib/grape/dsl/request_response.rb
@@ -60,7 +60,7 @@ def content_type(key, val)
 
       # All available content types.
       def content_types
-        c_types = namespace_stackable_with_hash(:content_types)
+        c_types = inheritable_setting.namespace_stackable_with_hash(:content_types)
         Grape::ContentTypes.content_types_for c_types
       end
 
@@ -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)
diff --git a/lib/grape/dsl/routing.rb b/lib/grape/dsl/routing.rb
@@ -142,14 +142,17 @@ def mount(mounts, *opts)
       #   end
       def route(methods, paths = ['/'], route_options = {}, &block)
         method = methods == :any ? '*' : methods
-        description = inheritable_setting.route[:description] || {}
+        endpoint_params = inheritable_setting.namespace_stackable_with_hash(:params) || {}
+        endpoint_description = inheritable_setting.route[:description]
+        all_route_options = { params: endpoint_params }
+        all_route_options.deep_merge!(endpoint_description) if endpoint_description
+        all_route_options.deep_merge!(route_options) if route_options&.any?
+
         endpoint_options = {
           method: method,
           path: paths,
           for: self,
-          route_options: {
-            params: namespace_stackable_with_hash(:params) || {}
-          }.deep_merge(description).deep_merge(route_options || {})
+          route_options: all_route_options
         }
 
         new_endpoint = Grape::Endpoint.new(inheritable_setting, endpoint_options, &block)
diff --git a/lib/grape/dsl/settings.rb b/lib/grape/dsl/settings.rb
@@ -46,17 +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?
-
-        settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
-      end
-
       private
 
       # Execute the block within a context where our inheritable settings are forked
diff --git a/lib/grape/endpoint.rb b/lib/grape/endpoint.rb
@@ -321,7 +321,7 @@ def options?
     def build_stack
       stack = Grape::Middleware::Stack.new
 
-      content_types = namespace_stackable_with_hash(:content_types)
+      content_types = inheritable_setting.namespace_stackable_with_hash(:content_types)
       format = namespace_inheritable(:format)
 
       stack.use Rack::Head
@@ -333,10 +333,10 @@ def build_stack
                 rescue_all: namespace_inheritable(:rescue_all),
                 rescue_grape_exceptions: namespace_inheritable(:rescue_grape_exceptions),
                 default_error_formatter: namespace_inheritable(:default_error_formatter),
-                error_formatters: namespace_stackable_with_hash(:error_formatters),
-                rescue_options: namespace_stackable_with_hash(:rescue_options),
+                error_formatters: inheritable_setting.namespace_stackable_with_hash(:error_formatters),
+                rescue_options: inheritable_setting.namespace_stackable_with_hash(:rescue_options),
                 rescue_handlers: rescue_handlers,
-                base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers),
+                base_only_rescue_handlers: inheritable_setting.namespace_stackable_with_hash(:base_only_rescue_handlers),
                 all_rescue_handler: namespace_inheritable(:all_rescue_handler),
                 grape_exceptions_rescue_handler: namespace_inheritable(:grape_exceptions_rescue_handler)
 
@@ -354,8 +354,8 @@ def build_stack
                 format: format,
                 default_format: namespace_inheritable(:default_format) || :txt,
                 content_types: content_types,
-                formatters: namespace_stackable_with_hash(:formatters),
-                parsers: namespace_stackable_with_hash(:parsers)
+                formatters: inheritable_setting.namespace_stackable_with_hash(:formatters),
+                parsers: inheritable_setting.namespace_stackable_with_hash(:parsers)
 
       builder = stack.build
       builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
diff --git a/lib/grape/util/inheritable_setting.rb b/lib/grape/util/inheritable_setting.rb
@@ -95,6 +95,13 @@ def to_hash
           namespace_reverse_stackable: namespace_reverse_stackable.to_hash
         }
       end
+
+      def namespace_stackable_with_hash(key)
+        data = namespace_stackable[key]
+        return if data.blank?
+
+        data.each_with_object({}) { |value, result| result.deep_merge!(value) }
+      end
     end
   end
 end
diff --git a/spec/grape/api_spec.rb b/spec/grape/api_spec.rb
@@ -116,9 +116,10 @@
     end
 
     it 'adds the association to the :representations setting' do
-      klass = Class.new
-      subject.represent Object, with: klass
-      expect(subject.namespace_stackable_with_hash(:representations)[Object]).to eq(klass)
+      dummy_presenter_klass = Class.new
+      represent_object = Class.new
+      subject.represent represent_object, with: dummy_presenter_klass
+      expect(subject.inheritable_setting.namespace_stackable[:representations]).to eq([represent_object => dummy_presenter_klass])
     end
   end
 
diff --git a/spec/grape/dsl/inside_route_spec.rb b/spec/grape/dsl/inside_route_spec.rb
@@ -6,37 +6,14 @@
   let(:dummy_class) do
     Class.new do
       include Grape::DSL::InsideRoute
+      include Grape::DSL::Settings
 
       attr_reader :env, :request, :new_settings
 
       def initialize
         @env = {}
         @header = {}
-        @new_settings = { namespace_inheritable: namespace_inheritable_hash, namespace_stackable: namespace_stackable_hash }
-      end
-
-      def namespace_inheritable(key, value = nil)
-        if value
-          namespace_inheritable_hash[key] = value
-        else
-          namespace_inheritable_hash[key]
-        end
-      end
-
-      def self.namespace_stackable(key, value = nil)
-        if value
-          namespace_stackable_hash[key] << value
-        else
-          namespace_stackable_hash[key]
-        end
-      end
-
-      def namespace_stackable_with_hash(key, value = nil)
-        if value
-          namespace_stackable_with_hash_hash[key] = value
-        else
-          namespace_stackable_with_hash_hash[key]
-        end
+        @new_settings = { namespace_inheritable: inheritable_setting.namespace_inheritable, namespace_stackable: inheritable_setting.namespace_stackable }
       end
 
       def header(key = nil, val = nil)
@@ -46,20 +23,6 @@ def header(key = nil, val = nil)
           @header ||= Grape::Util::Header.new
         end
       end
-
-      private
-
-      def namespace_inheritable_hash
-        @namespace_inheritable_hash ||= {}
-      end
-
-      def namespace_stackable_hash
-        @namespace_stackable_hash ||= Hash.new { [] }
-      end
-
-      def namespace_stackable_with_hash_hash
-        @namespace_stackable_with_hash_hash ||= {}
-      end
     end
   end
 
diff --git a/spec/grape/dsl/parameters_spec.rb b/spec/grape/dsl/parameters_spec.rb
@@ -68,13 +68,14 @@ def extract_message_option(attrs)
     let(:named_params) { { params_group: proc {} } }
 
     it 'calls processes associated with named params' do
-      allow(subject.api).to receive(:namespace_stackable_with_hash).and_return(named_params)
+      subject.api = Class.new { include Grape::DSL::Settings }.new
+      subject.api.inheritable_setting.namespace_stackable[:named_params] = named_params
       expect(subject).to receive(:instance_exec).with(options).and_yield
       subject.use :params_group, options
     end
 
     it 'raises error when non-existent named param is called' do
-      allow(subject.api).to receive(:namespace_stackable_with_hash).and_return({})
+      subject.api = Class.new { include Grape::DSL::Settings }.new
       expect { subject.use :params_group }.to raise_error('Params :params_group not found!')
     end
   end
diff --git a/spec/grape/dsl/request_response_spec.rb b/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
