Support Rails 7.2 counter_cache configuration

See rails/rails#51453

lib/shoulda/matchers/active_record/association_matchers/counter_cache_matcher.rb

@@ -19,10 +19,7 @@ def description
           def matches?(subject)
             self.subject = ModelReflector.new(subject, name)
 
-            if option_verifier.correct_for_string?(
-              :counter_cache,
-              counter_cache,
-            )
+            if correct_value?
               true
             else
               self.missing_option = "#{name} should have #{description}"
@@ -34,9 +31,42 @@ def matches?(subject)
 
           attr_accessor :subject, :counter_cache, :name
 
+          def correct_value?
+            expected = normalize_value
+
+            if expected.is_a?(Hash)
+              option_verifier.correct_for_hash?(
+                :counter_cache,
+                expected,
+              )
+            else
+              option_verifier.correct_for_string?(
+                :counter_cache,
+                expected,
+              )
+            end
+          end
+
           def option_verifier
             @_option_verifier ||= OptionVerifier.new(subject)
           end
+
+          def normalize_value
+            if Rails::VERSION::STRING >= '7.2'
+              case counter_cache
+              when true
+                { active: true, column: nil }
+              when String, Symbol
+                { active: true, column: counter_cache.to_s }
+              when Hash
+                { active: true, column: nil }.merge(counter_cache)
+              else
+                raise ArgumentError, 'Invalid counter_cache option'
+              end
+            else
+              counter_cache
+            end
+          end
         end
       end
     end

spec/unit/shoulda/matchers/active_record/association_matcher_spec.rb

@@ -113,6 +113,28 @@
       expect(belonging_to_parent).not_to belong_to(:parent).counter_cache
     end
 
+    if rails_version >= 7.2
+      it 'accepts :counter_cache with a hash' do
+        expect(belonging_to_parent(counter_cache: { active: true })).
+          to belong_to(:parent).counter_cache
+      end
+
+      it 'accepts :counter_cache with active false when passed' do
+        expect(belonging_to_parent(counter_cache: { active: false })).
+          to belong_to(:parent).counter_cache(active: false)
+      end
+
+      it 'rejects :counter_cache with active false when mismatch' do
+        expect(belonging_to_parent(counter_cache: { active: true })).
+          not_to belong_to(:parent).counter_cache(active: false)
+      end
+
+      it 'rejects :counter_cache with when column mismatch' do
+        expect(belonging_to_parent(counter_cache: { column: :attribute_count })).
+          not_to belong_to(:parent).counter_cache(true)
+      end
+    end
+
     it 'accepts an association with a valid :inverse_of option' do
       expect(belonging_to_with_inverse(:parent, :children)).
         to belong_to(:parent).inverse_of(:children)