counter_culture 3.8.2 → 3.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f043a04b7cca0b364e7692c19425b049b45b4e965ed5caac0dbac2f91622c1
-  data.tar.gz: 50dfedf030e3c3823829aedc5e3b2a08fe65b63b50fc439d229afb5ab3fa5d5d
+  metadata.gz: c568fc84225757b834a008eb60dbadfe5dea148078c855fe76a2b5711b0c5b1e
+  data.tar.gz: 3abc94f197b60fb6778eadb98ad402e6b961155c492970111b85bbf1bd171237
 SHA512:
-  metadata.gz: 604bd858a6660d3e83b74b339a2675366b5d7908c87c37241ed9eb9a2b245ddb4d02b19d6782d3c30df793cd895be45e22455e34f9aca88e5fee462f472c2a48
-  data.tar.gz: a5828bb5f0bd66b6717401b47f8494687a371546c6f3df89c93dd9a524a055e074aeffc3fa6c02e0b2e2cd25c3e706e76c2ef654e22a0b3f48cfb3d0c0c401b7
+  metadata.gz: adfd25e90ca300e1d6bc19296b343a8fbd9a272076e48591dddc513ffa4173dff10ef2d26cec6bd08bdfbc372ccf1b94e97cee7d7827205523efe0278d1bffea
+  data.tar.gz: 733126919913da347057de9c81cbbdf7b4b45e9ea1bbbecad12586a06432801e37b1c8833078cc93ce11fdc0ad3b201c5484822dcebc708f970d2106c022d35b

data/.circleci/config.yml

@@ -49,7 +49,7 @@ workflows:
           matrix:
             parameters:
               ruby-version: ["2.6", "2.7", "3.0", "3.1", "3.2", "3.3"]
-              rails-version: ["5.2", "6.0", "6.1", "7.0", "7.1", "7.2"]
+              rails-version: ["5.2", "6.0", "6.1", "7.0", "7.1", "7.2", "8.0"]
               database: ["postgresql", "sqlite3", "mysql2"]
             exclude:
               - ruby-version: "3.0"
@@ -133,3 +133,39 @@ workflows:
               - ruby-version: "3.0"
                 rails-version: "7.2"
                 database: "mysql2"
+              - ruby-version: "2.6"
+                rails-version: "8.0"
+                database: "postgresql"
+              - ruby-version: "2.6"
+                rails-version: "8.0"
+                database: "sqlite3"
+              - ruby-version: "2.6"
+                rails-version: "8.0"
+                database: "mysql2"
+              - ruby-version: "2.7"
+                rails-version: "8.0"
+                database: "postgresql"
+              - ruby-version: "2.7"
+                rails-version: "8.0"
+                database: "sqlite3"
+              - ruby-version: "2.7"
+                rails-version: "8.0"
+                database: "mysql2"
+              - ruby-version: "3.0"
+                rails-version: "8.0"
+                database: "postgresql"
+              - ruby-version: "3.0"
+                rails-version: "8.0"
+                database: "sqlite3"
+              - ruby-version: "3.0"
+                rails-version: "8.0"
+                database: "mysql2"
+              - ruby-version: "3.1"
+                rails-version: "8.0"
+                database: "postgresql"
+              - ruby-version: "3.1"
+                rails-version: "8.0"
+                database: "sqlite3"
+              - ruby-version: "3.1"
+                rails-version: "8.0"
+                database: "mysql2"

data/Appraisals

@@ -5,6 +5,7 @@
   7.0
   7.1
   7.2
+  8.0
 ].each do |rails_version|
   appraise "rails-#{rails_version}" do
     gem 'activerecord', "~> #{rails_version}.0"

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 3.11.2 (July 10, 2025)
+
+Bugfixes:
+  - Fix regression for foreign_key_values by adding support for composite primary keys (#417)
+
+## 3.11.1 (June 27, 2025)
+
+Bugfixes:
+  - Don't attempt to modify frozen association object (#416)
+
+## 3.11.0 (June 26, 2025)
+
+New features:
+  - Support for composite primary keys in Rails v7.2+ (#413)
+
+## 3.10.2 (June 24, 2025)
+
+Bugfixes:
+  - Fix incorrect in-memory counter updates on `belongs_to` association (#415)
+
+## 3.10.1 (April 30, 2025)
+
+Bugfixes:
+  - Fix issue when using `delegate` instead of `has_many :through` (#411)
+
+## 3.10.0 (April 15, 2025)
+
+New features:
+  - Update counter cache values without requiring a reload (#407)
+
+## 3.9.0 (March 20, 2025)
+
+New features:
+  - Add global configuration for using a read replica (#405)
+
 ## 3.8.2 (October 21, 2024)
 
 Bugfixes:

data/README.md

@@ -7,7 +7,7 @@ Turbo-charged counter caches for your Rails app. Huge improvements over the Rail
 * Supports dynamic column names, making it possible to split up the counter cache for different types of objects
 * Can keep a running count, or a running total
 
-Tested against Ruby 2.6, 2.7, 3.0, 3.1, 3.2 and 3.3 and against the latest patch releases of Rails 5.2, 6.0, 6.1, 7.0 and 7.1.
+Tested against Ruby 2.6, 2.7, 3.0, 3.1, 3.2 and 3.3 and against the latest patch releases of Rails 5.2, 6.0, 6.1, 7.0, 7.1, 7.2 and 8.0.
 
 Please note that -- unlike Rails' built-in counter-caches -- counter_culture does not currently change the behavior of the `.size` method on ActiveRecord associations. If you want to avoid a database query and read the cached value, please use the attribute name containing the counter cache directly.
 
@@ -232,7 +232,7 @@ The ```:delta_column``` option supports all numeric column types, not just ```:i
 class Product < ActiveRecord::Base
   belongs_to :category
   counter_culture :category, foreign_key_values:
-      proc {|category_id| [category_id, Category.find_by_id(category_id).try(:parent_category).try(:id)] }
+      proc {|category_id| [category_id, Category.find_by(id: category_id)&.parent_category&.id] }
 end
 
 class Category < ActiveRecord::Base
@@ -618,6 +618,39 @@ Image.counter_culture_fix_counts(polymorphic_classes: Product)
 Image.counter_culture_fix_counts(polymorphic_classes: [Product, Employee])
 ```
 
+## Using Read Replicas
+
+When using `counter_culture_fix_counts`, you can configure counter_culture to use read replicas for counting operations, which can help reduce load on your primary database. Write operations will still use the primary database.
+
+### Global Configuration
+
+You can enable read replica support globally:
+
+```ruby
+# config/initializers/counter_culture.rb
+CounterCulture.configure do |config|
+  config.use_read_replica = true
+end
+```
+
+### Per-Call Configuration
+
+You can also specify read replica usage per call (this takes precedence over global configuration):
+
+```ruby
+Model.counter_culture_fix_counts(
+  db_connection_builder: proc { |reading, block|
+    if reading
+      ApplicationRecord.connected_to(role: :reading, &block)
+    else
+      ApplicationRecord.connected_to(role: :writing, &block)
+    end
+  }
+)
+```
+
+Note: This feature requires Rails 7.1 or higher for full read replica support. On older versions, it will fall back to using the primary database.
+
 ## Contributing to counter_culture
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.

data/gemfiles/rails_8.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 8.0.0"
+
+gemspec path: "../"

data/lib/counter_culture/configuration.rb

@@ -0,0 +1,38 @@
+module CounterCulture
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.reset_configuration
+    @configuration = Configuration.new
+  end
+
+  def self.supports_composite_keys?
+    Gem::Requirement.new('>= 7.2.0').satisfied_by?(ActiveRecord.version)
+  end
+
+  class Configuration
+    attr_reader :use_read_replica
+
+    def initialize
+      @use_read_replica = false
+    end
+
+    def use_read_replica=(value)
+      if value && !rails_supports_read_replica?
+        raise "Counter Culture's read replica support requires Rails 7.1 or higher"
+      end
+      @use_read_replica = value
+    end
+
+    private
+
+    def rails_supports_read_replica?
+      Gem::Requirement.new('>= 7.1.0').satisfied_by?(ActiveRecord.version)
+    end
+  end
+end

data/lib/counter_culture/counter.rb

@@ -108,12 +108,23 @@ module CounterCulture
 
         primary_key = relation_primary_key(relation, source: obj, was: options[:was])
 
+        if foreign_key_values && id_to_change.is_a?(Enumerable) && id_to_change.count > 1 &&
+            Array.wrap(primary_key).count == 1
+          # To keep this feature backwards compatible, we need to accommodate a case where
+          # `foreign_key_values` returns an array, but we're _not_ using composite primary
+          # keys. In that case, we need to wrap the `id_to_change` in one more array to keep
+          # it compatible with the `.zip` call in `primary_key_conditions`.
+          id_to_change = [id_to_change]
+        end
+
         if Thread.current[:aggregate_counter_updates]
           Thread.current[:primary_key_map][klass] ||= primary_key
         end
 
         if @with_papertrail
-          instance = klass.where(primary_key => id_to_change).first
+          conditions = primary_key_conditions(primary_key, id_to_change)
+          instance = klass.where(conditions).first
+
           if instance
             if instance.paper_trail.respond_to?(:save_with_version)
               # touch_with_version is deprecated starting in PaperTrail 9.0.0
@@ -137,7 +148,11 @@ module CounterCulture
 
         unless Thread.current[:aggregate_counter_updates]
           execute_now_or_after_commit(obj) do
-            klass.where(primary_key => id_to_change).update_all updates.join(', ')
+            conditions = primary_key_conditions(primary_key, id_to_change)
+            klass.where(conditions).update_all updates.join(', ')
+            unless options[:was]
+              assign_to_associated_object(obj, relation, change_counter_column, operator, delta_magnitude)
+            end
           end
         end
       end
@@ -171,7 +186,7 @@ module CounterCulture
 
     # the string to pass to order() in order to sort by primary key
     def full_primary_key(klass)
-      "#{klass.quoted_table_name}.#{klass.quoted_primary_key}"
+      Array.wrap(klass.quoted_primary_key).map { |pk| "#{klass.quoted_table_name}.#{pk}" }.join(', ')
     end
 
     # gets the value of the foreign key on the given relation
@@ -185,23 +200,24 @@ module CounterCulture
       original_relation = relation
       relation = relation.is_a?(Enumerable) ? relation.dup : [relation]
 
-      if was
+      value = if was
         first = relation.shift
         foreign_key_value = attribute_was(obj, relation_foreign_key(first))
         klass = relation_klass(first, source: obj, was: was)
         if foreign_key_value
-          value = klass.where(
-            "#{klass.table_name}.#{relation_primary_key(first, source: obj, was: was)} = ?",
-            foreign_key_value).first
+          primary_key = relation_primary_key(first, source: obj, was: was)
+          conditions = primary_key_conditions(primary_key, foreign_key_value)
+          klass.where(conditions).first
         end
       else
-        value = obj
+        obj
       end
       while !value.nil? && relation.size > 0
         value = value.send(relation.shift)
       end
 
-      return value.try(relation_primary_key(original_relation, source: obj, was: was).try(:to_sym))
+      primary_key = relation_primary_key(original_relation, source: obj, was: was)
+      Array.wrap(primary_key).map { |pk| value.try(pk&.to_sym) }.compact.presence
     end
 
     # gets the reflect object on the given relation
@@ -307,6 +323,7 @@ module CounterCulture
         return reflect.options[:primary_key] if reflect.options.key?(:primary_key)
         return relation_klass(relation, source: source, was: was).try(:primary_key)
       end
+
       reflect.association_primary_key(klass)
     end
 
@@ -365,6 +382,49 @@ module CounterCulture
       obj.public_send("#{attr}#{changes_method}")
     end
 
+    # update associated object counter attribute
+    def assign_to_associated_object(obj, relation, change_counter_column, operator, delta_magnitude)
+      association_name = relation_reflect(relation).name
+
+      association_object = association_object_for_assign(obj, association_name)
+      return if association_object.blank? || association_object.frozen?
+
+      association_object.assign_attributes(
+        change_counter_column =>
+          association_object_new_counter(association_object, change_counter_column, operator, delta_magnitude)
+      )
+      association_object_clear_change(association_object, change_counter_column)
+    end
+
+    def association_object_for_assign(obj, association_name)
+      if obj.class.reflect_on_all_associations.
+          find { |assoc| assoc.name.to_sym == association_name.to_sym }.
+          blank?
+        # This means that this isn't defined as an association; either it
+        # doesn't exist at all, or it uses delegate. In either case, we can't
+        # update the count this way.
+        return
+      end
+      if !obj.association(association_name).loaded?
+        # If the association isn't loaded, no need to update the count
+        return
+      end
+
+      obj.public_send(association_name)
+    end
+
+    def association_object_clear_change(association_object, change_counter_column)
+      if ACTIVE_RECORD_VERSION >= Gem::Version.new("6.1.0")
+        association_object.public_send(:"clear_#{change_counter_column}_change")
+      else
+        association_object.send(:clear_attribute_change, change_counter_column)
+      end
+    end
+
+    def association_object_new_counter(association_object, change_counter_column, operator, delta_magnitude)
+      (association_object.public_send(change_counter_column) || 0).public_send(operator, delta_magnitude)
+    end
+
     def assemble_money_counter_update(klass, id_to_change, quoted_column, operator, delta_magnitude)
       counter_update_snippet(
         "#{quoted_column} = COALESCE(CAST(#{quoted_column} as NUMERIC), 0)",
@@ -395,6 +455,12 @@ module CounterCulture
       end
     end
 
+    def primary_key_conditions(primary_key, fk_value)
+      Array.wrap(primary_key)
+          .zip(Array.wrap(fk_value))
+          .to_h
+    end
+
     def counter_update_snippet(update, klass, id_to_change, operator, delta_magnitude)
       if Thread.current[:aggregate_counter_updates]
         remember_counter_update(

data/lib/counter_culture/reconciler.rb

@@ -66,6 +66,7 @@ module CounterCulture
         @counter, @options, = counter, options
         @relation_class = relation_class
         @changes_holder = changes_holder
+        @connection_handler = WithConnection.new(relation_class)
       end
 
       def perform
@@ -110,8 +111,8 @@ module CounterCulture
 
           # select join column and count (from above) as well as cache column ('column_name') for later comparison
           counts_query = scope.select(
-            "#{relation_class_table_name}.#{relation_class.primary_key}, " \
-            "#{relation_class_table_name}.#{relation_reflect(relation).association_primary_key(relation_class)}, " \
+            "#{primary_key_select}, " \
+            "#{association_primary_key_select}, " \
             "#{count_select} AS count, " \
             "MAX(#{relation_class_table_name}.#{column_name}) AS #{column_name}"
           )
@@ -172,7 +173,8 @@ module CounterCulture
             end
 
             with_writing_db_connection do
-              relation_class.where(relation_class.primary_key => record.send(relation_class.primary_key)).update_all(updates.join(', '))
+              conditions = Array.wrap(relation_class.primary_key).map { |key| [key, record.send(key)] }.to_h
+              relation_class.where(conditions).update_all(updates.join(', '))
             end
           end
         end
@@ -198,11 +200,12 @@ module CounterCulture
       def track_change(record, column_name, count)
         @changes_holder << {
           :entity => relation_class.name,
-          relation_class.primary_key.to_sym => record.send(relation_class.primary_key),
           :what => column_name,
           :wrong => record.send(column_name),
           :right => count
-        }
+        }.tap do |h|
+          Array.wrap(relation_class.primary_key).each { |pk| h[pk.to_sym] = record.send(pk) }
+        end
       end
 
       def count_select
@@ -216,10 +219,23 @@ module CounterCulture
             @count_select = "SUM(COALESCE(#{self_table_name}.#{delta_column}, 0))"
           end
         else
-          @count_select = "COUNT(#{self_table_name}.#{model.primary_key})*#{delta_magnitude}"
+          primary_key = Array.wrap(model.primary_key).first
+          count_column = "#{self_table_name}.#{primary_key}"
+          @count_select = "COUNT(#{count_column})*#{delta_magnitude}"
         end
       end
 
+      def primary_key_select
+        relation_class_table_name = quote_table_name(relation_class.table_name)
+        Array.wrap(relation_class.primary_key).map { |pk| "#{relation_class_table_name}.#{pk}" }.join(', ')
+      end
+
+      def association_primary_key_select
+        relation_class_table_name = quote_table_name(relation_class.table_name)
+        association_primary_key = relation_reflect(relation).association_primary_key(relation_class)
+        Array.wrap(association_primary_key).map { |apk| "#{relation_class_table_name}.#{apk}" }.join(', ')
+      end
+
       def self_table_name
         return @self_table_name if @self_table_name
 
@@ -270,8 +286,17 @@ module CounterCulture
               [target_table_key, source_table_key]
           end
 
+          source_table_key = Array.wrap(source_table_key)
+          target_table_key = Array.wrap(target_table_key)
+
+          join_conditions =
+            source_table_key
+              .zip(target_table_key).map do |source_key, target_key|
+                "#{source_table}.#{source_key} = #{target_table_alias}.#{target_key}"
+              end.join(' AND ')
           joins_sql = "LEFT JOIN #{target_table} AS #{target_table_alias} "\
-            "ON #{source_table}.#{source_table_key} = #{target_table_alias}.#{target_table_key}"
+            "ON #{join_conditions}"
+
           # adds 'type' condition to JOIN clause if the current model is a
           # child in a Single Table Inheritance
           if reflect.active_record.column_names.include?('type') &&
@@ -288,7 +313,9 @@ module CounterCulture
             # conditions must be applied to the join on which we are counting
             if where
               if where.respond_to?(:to_sql)
-                joins_sql += " AND #{target_table_alias}.#{model.primary_key} IN (#{where.select(model.primary_key).to_sql})"
+                model_primary_key = Array.wrap(model.primary_key)
+                where_select = model_primary_key.map { |pk| "#{model.table_name}.#{pk}" }.join(', ')
+                joins_sql += " AND (#{target_table_alias}.#{model_primary_key.first}) IN (#{where.select(where_select).to_sql})"
               else
                 joins_sql += " AND (#{model.send(:sanitize_sql_for_conditions, where)})"
               end
@@ -314,7 +341,7 @@ module CounterCulture
       # using Postgres with schema-namespaced tables. But then it's required,
       # and otherwise it's just a no-op, so why not do it?
       def quote_table_name(table_name)
-        WithConnection.new(relation_class).call do |connection|
+        @connection_handler.call do |connection|
           connection.quote_table_name(table_name)
         end
       end
@@ -331,7 +358,9 @@ module CounterCulture
         if builder = options[:db_connection_builder]
           builder.call(true, block)
         else
-          yield
+          @connection_handler.call(reading: true) do |_conn|
+            yield
+          end
         end
       end
 
@@ -339,7 +368,9 @@ module CounterCulture
         if builder = options[:db_connection_builder]
           builder.call(false, block)
         else
-          yield
+          @connection_handler.call(reading: false) do |_conn|
+            yield
+          end
         end
       end
     end

data/lib/counter_culture/version.rb

@@ -1,3 +1,3 @@
 module CounterCulture
-  VERSION = '3.8.2'.freeze
+  VERSION = '3.11.2'.freeze
 end

data/lib/counter_culture/with_connection.rb

@@ -6,28 +6,42 @@ module CounterCulture
 
     attr_reader :recipient
 
-    def call
-      if rails_7_2_or_greater?
-        recipient.with_connection do |connection|
-          yield connection
-        end
-      elsif rails_7_1?
-        recipient.connection_pool.with_connection do |connection|
-          yield connection
+    def call(reading: false)
+      if rails_7_1_or_greater?
+        use_read_replica = CounterCulture.configuration.use_read_replica && reading
+        role = use_read_replica ? :reading : :writing
+
+        ActiveRecord::Base.connected_to(role: role) do
+          yield_with_connection { |conn| yield conn }
         end
       else
-        yield recipient.connection
+        # For older Rails versions, just use normal connection
+        yield_with_connection { |conn| yield conn }
       end
     end
 
     private
 
-    def rails_7_1?
-      Gem::Requirement.new('~> 7.1.0').satisfied_by?(ActiveRecord.version)
+    def yield_with_connection
+      if rails_7_2_or_greater?
+        recipient.with_connection { |conn| yield conn }
+      elsif rails_7_1?
+        recipient.connection_pool.with_connection { |conn| yield conn }
+      else
+        yield recipient.connection
+      end
+    end
+
+    def rails_7_1_or_greater?
+      Gem::Requirement.new('>= 7.1.0').satisfied_by?(ActiveRecord.version)
     end
 
     def rails_7_2_or_greater?
       Gem::Requirement.new('>= 7.2.0').satisfied_by?(ActiveRecord.version)
     end
+
+    def rails_7_1?
+      Gem::Requirement.new('~> 7.1.0').satisfied_by?(ActiveRecord.version)
+    end
   end
 end

data/lib/counter_culture.rb

@@ -3,6 +3,7 @@ require 'active_support/lazy_load_hooks'
 
 require 'counter_culture/version'
 require 'counter_culture/extensions'
+require 'counter_culture/configuration'
 require 'counter_culture/counter'
 require 'counter_culture/reconciler'
 require 'counter_culture/skip_updates'
@@ -34,9 +35,14 @@ module CounterCulture
         end.compact
 
         if update_snippets.any?
-          klass
-            .where(Thread.current[:primary_key_map][klass] => rec_id)
-            .update_all(update_snippets.join(', '))
+          primary_key = Thread.current[:primary_key_map][klass]
+
+          conditions =
+            Array.wrap(primary_key)
+                .zip(Array.wrap(rec_id))
+                .to_h
+
+          klass.where(conditions).update_all(update_snippets.join(', '))
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: counter_culture
 version: !ruby/object:Gem::Version
-  version: 3.8.2
+  version: 3.11.2
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-21 00:00:00.000000000 Z
+date: 2025-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -319,7 +319,9 @@ files:
 - gemfiles/rails_7.0.gemfile
 - gemfiles/rails_7.1.gemfile
 - gemfiles/rails_7.2.gemfile
+- gemfiles/rails_8.0.gemfile
 - lib/counter_culture.rb
+- lib/counter_culture/configuration.rb
 - lib/counter_culture/counter.rb
 - lib/counter_culture/extensions.rb
 - lib/counter_culture/reconciler.rb