counter_culture 3.9.0 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f93d3d3e415f5d92e3870caf67067cdb75a6a76f68542b82c9ec2411987a0e4d
-  data.tar.gz: 89cf5171b549aab368a1dd87117afd429bf557d93f198e220fbe3b2a24e81f20
+  metadata.gz: dbbb4f3f637d653c94426d45846cb656d5f199db3706f9d0b2187ca6a67e2be0
+  data.tar.gz: 55d928ec95802a130b82b9c25b2a970eca01ee9c07d9b7346731b9e6fb17aaa0
 SHA512:
-  metadata.gz: 17b50c40207f615d0018c142062e536c3da69bebab209d4facb63ee03273363d97f83675d173f3096f98c68393f374e39aae0dba0db6364de9bc3c83d38af160
-  data.tar.gz: d7bef1c4214a30fa9888843c35fe2f074ea89e78b9341b5ed458471934576dea9ef8bf12fac72bd549a532fc50d34b9e327c4f2b943e7965720f3b12bef503b6
+  metadata.gz: 89d37375626c427c86481ea57f0de65e59939982436d13968e223956473d94ab29a5b270715c577348bc8b194f46d6beaae80d8a6fc5554f04e9bf221934bad2
+  data.tar.gz: f6a7886d1d5e72b8e0e414e1b83e47b24ff87d2214597565a526f8797c605ee662d2cd3c3fdc3f540368c424559a2eedad2c634e8713725ed2f7921ebab3b701

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 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:

data/lib/counter_culture/configuration.rb

@@ -11,6 +11,10 @@ module CounterCulture
     @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
 

data/lib/counter_culture/counter.rb

@@ -113,7 +113,9 @@ module CounterCulture
         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 +139,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 +177,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 +191,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 +314,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 +373,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.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 +446,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

@@ -111,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}"
           )
@@ -173,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
@@ -199,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
@@ -217,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
 
@@ -271,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') &&
@@ -289,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

data/lib/counter_culture/version.rb

@@ -1,3 +1,3 @@
 module CounterCulture
-  VERSION = '3.9.0'.freeze
+  VERSION = '3.11.0'.freeze
 end

data/lib/counter_culture.rb

@@ -35,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.9.0
+  version: 3.11.0
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-20 00:00:00.000000000 Z
+date: 2025-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord