counter_culture 3.11.2 → 3.11.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c568fc84225757b834a008eb60dbadfe5dea148078c855fe76a2b5711b0c5b1e
-  data.tar.gz: 3abc94f197b60fb6778eadb98ad402e6b961155c492970111b85bbf1bd171237
+  metadata.gz: 4978dfaab9ec73c8b3215c2d2f811093cc00cdf7daccfe877749f301a09ae11a
+  data.tar.gz: e2e1322882fdeab8c7239c7cf16e4019b5450d3f435c478ad1d9e2d33cf5a251
 SHA512:
-  metadata.gz: adfd25e90ca300e1d6bc19296b343a8fbd9a272076e48591dddc513ffa4173dff10ef2d26cec6bd08bdfbc372ccf1b94e97cee7d7827205523efe0278d1bffea
-  data.tar.gz: 733126919913da347057de9c81cbbdf7b4b45e9ea1bbbecad12586a06432801e37b1c8833078cc93ce11fdc0ad3b201c5484822dcebc708f970d2106c022d35b
+  metadata.gz: a60b46c8b713dbbb7f2969c9b6885e9975a1c5723eb3566a04b011380eafb077c3051386586cff7c77b5ba171888ef577aa5d1dd6be4a4d97ea8e1db1fdca91d
+  data.tar.gz: 51feccb08cf927e8fc6f1d41f39f91269411db70d96d3b44d57ddf35c67130790c1340cb27aff0e0f4701934b40bc17485345667d1bffcbfb145eb4a5d98bea6

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 3.11.4 (November 5, 2025)
+
+Bugfixes:
+  - Fix counter cache not using the correct type with multiple STI models in the association chain (#421)
+
+## 3.11.3 (October 22, 2025)
+
+Bugfixes:
+  - Fix in-memory counter updates for conditional counters when condition changes (#420)
+
 ## 3.11.2 (July 10, 2025)
 
 Bugfixes:

data/lib/counter_culture/counter.rb

@@ -150,7 +150,27 @@ module CounterCulture
           execute_now_or_after_commit(obj) do
             conditions = primary_key_conditions(primary_key, id_to_change)
             klass.where(conditions).update_all updates.join(', ')
-            unless options[:was]
+            # Determine if we should update the in-memory counter on the associated object.
+            # When updating the old counter (was: true), we need to carefully consider two scenarios:
+            # 1) The belongs_to relation changed (e.g., moving a child from parent A to parent B):
+            #    In this case, obj.association now points to parent B, but we're decrementing parent A's
+            #    counter. We should NOT update the in-memory counter because it would incorrectly
+            #    modify parent B's cached value.
+            # 2) A conditional counter's condition changed (e.g., condition: true → false):
+            #    In this case, obj.association still points to the same parent, but the counter column
+            #    name changed (e.g., from 'conditional_count' to nil). We SHOULD update the in-memory
+            #    counter so the parent object reflects the decremented value without requiring a reload.
+            # We distinguish these cases by comparing foreign keys: if the current and previous foreign
+            # keys are identical, we're in scenario 2 and should update the in-memory counter.
+            should_update_counter = if options[:was]
+              current_fk = foreign_key_value(obj, relation, false)
+              previous_fk = foreign_key_value(obj, relation, true)
+              current_fk == previous_fk && current_fk.present?
+            else
+              true
+            end
+
+            if should_update_counter
               assign_to_associated_object(obj, relation, change_counter_column, operator, delta_magnitude)
             end
           end
@@ -220,11 +240,11 @@ module CounterCulture
       Array.wrap(primary_key).map { |pk| value.try(pk&.to_sym) }.compact.presence
     end
 
-    # gets the reflect object on the given relation
+    # gets the reflect object on the given relation and the model that defines this reflect
     #
     # relation: a symbol or array of symbols; specifies the relation
     #   that has the counter cache column
-    def relation_reflect(relation)
+    def relation_reflect_and_model(relation)
       relation = relation.is_a?(Enumerable) ? relation.dup : [relation]
 
       # go from one relation to the next until we hit the last reflect object
@@ -242,7 +262,16 @@ module CounterCulture
         end
       end
 
-      return reflect
+      return [reflect, klass]
+    end
+
+
+    # gets the reflect object on the given relation
+    #
+    # relation: a symbol or array of symbols; specifies the relation
+    #   that has the counter cache column
+    def relation_reflect(relation)
+      relation_reflect_and_model(relation).first
     end
 
     # gets the class of the given relation

data/lib/counter_culture/reconciler.rb

@@ -59,7 +59,7 @@ module CounterCulture
     class Reconciliation
       attr_reader :counter, :options, :relation_class
 
-      delegate :model, :relation, :full_primary_key, :relation_reflect, :polymorphic?, :to => :counter
+      delegate :model, :relation, :full_primary_key, :relation_reflect_and_model, :relation_reflect, :polymorphic?, :to => :counter
       delegate *CounterCulture::Counter::CONFIG_OPTIONS, :to => :counter
 
       def initialize(counter, changes_holder, options, relation_class)
@@ -257,11 +257,11 @@ module CounterCulture
         # store joins in an array so that we can later apply column-specific
         # conditions
         join_clauses = reverse_relation.each_with_index.map do |cur_relation, index|
-          reflect = relation_reflect(cur_relation)
+          reflect, model = relation_reflect_and_model(cur_relation)
 
-          target_table = quote_table_name(reflect.active_record.table_name)
+          target_table = quote_table_name(model.table_name)
           target_table_alias = parameterize(target_table)
-          if relation_class.table_name == reflect.active_record.table_name
+          if relation_class.table_name == model.table_name
             # join with alias to avoid ambiguous table name in
             # self-referential models
             target_table_alias += "_#{target_table_alias}"
@@ -299,8 +299,8 @@ module CounterCulture
 
           # 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') &&
-              !model.descends_from_active_record?
+          if model.column_names.include?('type') &&
+             !model.descends_from_active_record?
             joins_sql += " AND #{target_table_alias}.type IN ('#{model.name}')"
           end
           if polymorphic?

data/lib/counter_culture/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: counter_culture
 version: !ruby/object:Gem::Version
-  version: 3.11.2
+  version: 3.11.4
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-10 00:00:00.000000000 Z
+date: 2025-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord