counter_culture 3.13.2 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dcb5f1c57a5fda38de103fdcdf767e990f507b994c1d2e59debdbde0b1f3ef3
-  data.tar.gz: 8945d83862559fb693b79d1837507c23f978828e3d9c377f2d4cacf67d4843cc
+  metadata.gz: 55a968373b0c0e7f763a62f22c1fcee0156a27227a605d07d85dc464d9973873
+  data.tar.gz: b2c63fa6c9c9be56a8511e39663c82ede80e8a07d49d0991c2e7a0cd7c69d2c8
 SHA512:
-  metadata.gz: 398000f43d6feb9165c54ec2e3614b65bb9f384e8c8f9693d6956ee9e22d2e2eec6bad28b7cdab21b1fd2543fbee05f3f04d7f697a60a740fbdd00e20e960d9b
-  data.tar.gz: 7a8e5b137d1266161ff9cb3569005f2acd147829656fc66b1aabcb0bf0d3e0a823bc3398b0b6573c6b01e394f996436a53861949e09560ca5219b414ad67193b
+  metadata.gz: ba7889dd178c96cff2b98b111ff7129dbba01c5e73f419c5a68489850ddf0bca205dd03e23302994a517b82a592a2967db6c39598a5b286420dbb166bb04c977
+  data.tar.gz: e2261e735bccf84dd64549788facecd1fa7d240ef450852b69be596f57a4f93c3a9db63227e64bc9dd02380aab3c78c9c7d7decae12070187c242a3f96db14e6

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 3.14.0 (June 26, 2026)
+
+New features:
+  - Use the built-in `ActiveRecord.after_all_transactions_commit` API for `execute_after_commit` on Rails 7.2+, so the `after_commit_action` gem is no longer required on modern Rails. Older Rails versions keep using the gem as before.
+
+Changes:
+  - On Rails 7.2+, counter_culture no longer mixes the `after_commit_action` gem's `AfterCommitAction` module into models that use `execute_after_commit`. If your own code called the `execute_after_commit` instance method on those models (relying on counter_culture to make it available), add the `after_commit_action` gem and `include AfterCommitAction` yourself.
+
+## 3.13.3 (June 25, 2026)
+
+Bugfixes:
+  - Fix `counter_culture_fix_counts` raising a SQL syntax error for counter caches stored in reserved-word columns (e.g. `order`) by quoting identifiers in the reconciler (#434)
+
 ## 3.13.2 (June 25, 2026)
 
 Bugfixes:

data/README.md

@@ -1,4 +1,4 @@
-# counter_culture [![Build Status](https://circleci.com/gh/magnusvk/counter_culture/tree/master.svg?style=svg)](https://circleci.com/gh/magnusvk/counter_culture/tree/master)
+# counter_culture [![Build Status](https://circleci.com/gh/magnusvk/counter_culture/tree/main.svg?style=svg)](https://circleci.com/gh/magnusvk/counter_culture/tree/main)
 
 Turbo-charged counter caches for your Rails app. Huge improvements over the Rails standard counter caches:
 
@@ -272,7 +272,7 @@ Another option is to simply defer the update of counter caches to outside of the
 ```ruby
   counter_culture :category, execute_after_commit: true
 ```
-[NOTE] You need to manually specify the `after_commit_action` as dependency in the Gemfile to use this feature
+[NOTE] On Rails 7.2 and newer this uses the built-in `ActiveRecord.after_all_transactions_commit` API and requires no extra dependencies. On older Rails versions you need to manually specify the `after_commit_action` gem as a dependency in your Gemfile to use this feature:
 ```ruby
 ...
 gem "after_commit_action"

data/lib/counter_culture/configuration.rb

@@ -15,6 +15,13 @@ module CounterCulture
     Gem::Requirement.new('>= 7.2.0').satisfied_by?(ActiveRecord.version)
   end
 
+  # Rails 7.2+ ships `ActiveRecord.after_all_transactions_commit`, which lets
+  # `execute_after_commit` defer counter updates natively instead of relying on
+  # the `after_commit_action` gem.
+  def self.supports_native_after_commit?
+    Gem::Requirement.new('>= 7.2.0').satisfied_by?(ActiveRecord.version)
+  end
+
   class Configuration
     attr_reader :use_read_replica
 

data/lib/counter_culture/counter.rb

@@ -21,7 +21,10 @@ module CounterCulture
       @execute_after_commit = options.fetch(:execute_after_commit, false)
       @include_soft_deleted = options.fetch(:include_soft_deleted, false)
 
-      if @execute_after_commit
+      # Rails 7.2+ ships `ActiveRecord.after_all_transactions_commit`, which
+      # does everything we need the `after_commit_action` gem for. Only fall
+      # back to the gem on older Rails versions.
+      if @execute_after_commit && !CounterCulture.supports_native_after_commit?
         begin
           require 'after_commit_action'
         rescue LoadError
@@ -390,7 +393,18 @@ module CounterCulture
       execute_after_commit = @execute_after_commit.is_a?(Proc) ? @execute_after_commit.call : @execute_after_commit
 
       if execute_after_commit
-        obj.execute_after_commit(&block)
+        if CounterCulture.supports_native_after_commit?
+          # NOTE: `after_all_transactions_commit` waits for *every* open
+          # transaction across *all* database connections and skips the block if
+          # any of them roll back, whereas `after_commit_action` tied the block to
+          # this record's own connection only. The two are equivalent for a
+          # single database; they differ only when a record is saved inside
+          # transactions that span multiple databases (which Rails itself
+          # discourages).
+          ActiveRecord.after_all_transactions_commit(&block)
+        else
+          obj.execute_after_commit(&block)
+        end
       else
         block.call
       end

data/lib/counter_culture/reconciler.rb

@@ -108,13 +108,15 @@ module CounterCulture
           next unless column_name
 
           relation_class_table_name = quote_table_name(relation_class.table_name)
+          # quote the cache column so reserved-word/quoting-sensitive names work
+          quoted_column_name = quote_column_name(column_name)
 
           # select join column and count (from above) as well as cache column ('column_name') for later comparison
           counts_query = scope.select(
             "#{primary_key_select}, " \
             "#{association_primary_key_select}, " \
             "#{count_select} AS count, " \
-            "MAX(#{relation_class_table_name}.#{column_name}) AS #{column_name}"
+            "MAX(#{relation_class_table_name}.#{quoted_column_name}) AS #{quoted_column_name}"
           )
 
           # we need to join together tables until we get back to the table this class itself lives in
@@ -155,9 +157,20 @@ module CounterCulture
 
             track_change(record, column_name, count)
 
-            updates = []
-            # this updates the actual counter
-            updates << "#{column_name} = #{count}"
+            # Build a Hash of column => value updates and let Rails (Arel) qualify
+            # and escape the column names and cast/quote the values, consistent with
+            # the Arel-based updates used in Counter (see #425). This updates the
+            # actual counter.
+            updates = { column_name => count }
+
+            # Set lock_version = lock_version (no-op) to skip Rails auto-increment,
+            # just as Counter does (see #429); a Hash update_all would otherwise
+            # bump the optimistic locking column.
+            if relation_class.locking_enabled?
+              lock_column = relation_class.locking_column
+              updates[lock_column] = relation_class.arel_table[lock_column]
+            end
+
             # and here we update the timestamp, if so desired
             if options[:touch]
               current_time = record.send(:current_time_from_proper_timezone)
@@ -168,13 +181,13 @@ module CounterCulture
                 timestamp_columns << options[:touch]
               end
               timestamp_columns.each do |timestamp_column|
-                updates << "#{timestamp_column} = '#{current_time.to_formatted_s(:db)}'"
+                updates[timestamp_column] = current_time
               end
             end
 
             with_writing_db_connection do
               conditions = Array.wrap(relation_class.primary_key).map { |key| [key, record.send(key)] }.to_h
-              relation_class.where(conditions).distinct(false).update_all(updates.join(', '))
+              relation_class.where(conditions).distinct(false).update_all(updates)
             end
           end
         end
@@ -351,6 +364,12 @@ module CounterCulture
         end
       end
 
+      def quote_column_name(column_name)
+        @connection_handler.call do |connection|
+          connection.quote_column_name(column_name)
+        end
+      end
+
       def parameterize(string)
         if ACTIVE_RECORD_VERSION < Gem::Version.new("5.0")
           string.parameterize('_')

data/lib/counter_culture/version.rb

@@ -1,3 +1,3 @@
 module CounterCulture
-  VERSION = '3.13.2'.freeze
+  VERSION = '3.14.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: counter_culture
 version: !ruby/object:Gem::Version
-  version: 3.13.2
+  version: 3.14.0
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-25 00:00:00.000000000 Z
+date: 2026-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord