counter_culture 3.12.2 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2241a3df22872b2a70afc2aa0ccb59c51e970723b77e2deeb268ea45f5c4554
-  data.tar.gz: d67da1eaa6efed0026e482a120e8a187258ffbdf661b143823a7327781ccf2f2
+  metadata.gz: ce955a1cc71481d0223d0477b44823a9ed539e2209a77a0db5a5f90f09d87259
+  data.tar.gz: 68e564d152930f8fd663acbb99e64c0b5ed7ff451358b4f8439364d807b672c8
 SHA512:
-  metadata.gz: 2b09f1e9ff6362a0096d5f80ecf6ba8ae58942ebe67eac8387566d98b7abf902555184f5ba017f543b1fe16ca44a58f07f87669b4190f039cf028d95cff02484
-  data.tar.gz: 95b4f2da40553da3481bf7024155259b6268965a9a176738f90403c6aff341ecb079b7e9fe545db65843a44c77c99f879b595b4483c71e977ba733aa3a136400
+  metadata.gz: f77b8bece6b1242b3402c08cfece835f59d721ecef1f8330c66dc65a42a2ba6797c605f062e414a9d9a2f55d9113f6aa597176fd0e422221c16ee8f9a2648aaa
+  data.tar.gz: be715fdc0be1bfa8be1b555fcb28630f770012eee35459865520469a5211ab9f37e0894816cfcbd2d6f015d2704aa0b59eea44ed77a2c2cccdef230c373eac1e

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 3.13.0 (April 9, 2026)
+
+New features:
+  - Add `include_soft_deleted` option to keep soft-deleted records in the count (#428)
+
 ## 3.12.2 (February 25, 2026)
 
 Bugfixes:

data/README.md

@@ -587,6 +587,25 @@ class SoftDelete < ActiveRecord::Base
 end
 ```
 
+#### Counting soft-deleted records
+
+By default, soft-deleted records are excluded from counter caches. If you want a
+counter that includes soft-deleted records, use the `include_soft_deleted` option:
+
+```ruby
+class SoftDelete < ActiveRecord::Base
+  acts_as_paranoid # or: include Discard::Model
+
+  belongs_to :company
+  counter_culture :company, column_name: 'all_records_count', include_soft_deleted: true
+end
+```
+
+With this option, soft-delete and restore operations will not change the counter.
+Only hard-destroying a record (`really_destroy!` for Paranoia, `destroy` for
+Discard) will decrement the counter. `counter_culture_fix_counts` will also
+correctly include soft-deleted records when reconciling.
+
 ### PaperTrail integration
 
 If you are using the [`paper_trail` gem](https://github.com/airblade/paper_trail)

data/lib/counter_culture/counter.rb

@@ -2,7 +2,7 @@ require_relative './with_connection'
 
 module CounterCulture
   class Counter
-    CONFIG_OPTIONS = [ :column_names, :counter_cache_name, :delta_column, :foreign_key_values, :touch, :delta_magnitude, :execute_after_commit ]
+    CONFIG_OPTIONS = [ :column_names, :counter_cache_name, :delta_column, :foreign_key_values, :touch, :delta_magnitude, :execute_after_commit, :include_soft_deleted ]
     ACTIVE_RECORD_VERSION = Gem.loaded_specs["activerecord"].version
 
     attr_reader :model, :relation, *CONFIG_OPTIONS
@@ -19,6 +19,7 @@ module CounterCulture
       @delta_magnitude = options[:delta_magnitude] || 1
       @with_papertrail = options.fetch(:with_papertrail, false)
       @execute_after_commit = options.fetch(:execute_after_commit, false)
+      @include_soft_deleted = options.fetch(:include_soft_deleted, false)
 
       if @execute_after_commit
         begin

data/lib/counter_culture/extensions.rb

@@ -17,28 +17,21 @@ module CounterCulture
         unless @after_commit_counter_cache
           # initialize callbacks only once
           after_create :_update_counts_after_create
-
-          before_destroy :_update_counts_after_destroy, unless: :destroyed_for_counter_culture?
+          before_destroy :_update_counts_before_destroy
+          after_update :_update_counts_after_update
 
           if respond_to?(:before_real_destroy) &&
               instance_methods.include?(:paranoia_destroyed?)
-            before_real_destroy :_update_counts_after_destroy,
-              if: -> (model) { !model.paranoia_destroyed? }
+            before_real_destroy :_update_counts_before_real_destroy
           end
 
-          after_update :_update_counts_after_update, unless: :destroyed_for_counter_culture?
-
           if respond_to?(:before_restore)
-            before_restore :_update_counts_after_create,
-              if: -> (model) { model.deleted? }
+            before_restore :_update_counts_before_restore
           end
 
           if defined?(Discard::Model) && include?(Discard::Model)
-            before_discard :_update_counts_after_destroy,
-              if: ->(model) { !model.discarded? }
-
-            before_undiscard :_update_counts_after_create,
-              if: ->(model) { model.discarded? }
+            before_discard :_update_counts_before_discard
+            before_undiscard :_update_counts_before_undiscard
           end
 
           # we keep a list of all counter caches we must maintain
@@ -104,29 +97,77 @@ module CounterCulture
     end
 
     private
-    # called by after_create callback
+
     def _update_counts_after_create
       self.class.after_commit_counter_cache.each do |counter|
-        # increment counter cache
         counter.change_counter_cache(self, :increment => true)
       end
     end
 
-    # called by after_destroy callback
-    def _update_counts_after_destroy
-      self.class.after_commit_counter_cache.each do |counter|
-        unless destroyed?
-          # decrement counter cache
-          counter.change_counter_cache(self, :increment => false)
-        end
+    # before_destroy: For Paranoia models this is a soft-delete; for all others
+    # (including Discard) it is a hard-destroy.
+    def _update_counts_before_destroy
+      # If destroy is called again on an already-destroyed record, don't double-decrement
+      return if destroyed?
+
+      if respond_to?(:paranoia_destroyed?)
+        # Paranoia: destroy = soft-delete
+        # If already soft-deleted, this is a redundant destroy call — don't decrement again
+        return if paranoia_destroyed?
+        _decrement_counters(skip_include_soft_deleted: true)
+        _handle_include_soft_deleted_column_transition
+      elsif destroyed_for_counter_culture?
+        # Discard: hard-destroy of already-discarded record
+        _decrement_counters(only_include_soft_deleted: true)
+      else
+        # Regular model or undiscarded Discard: hard-destroy
+        _decrement_counters
+      end
+    end
+
+    # before_real_destroy (Paranoia only)
+    def _update_counts_before_real_destroy
+      if paranoia_destroyed?
+        # Was already soft-deleted: only include_soft_deleted counters remain
+        _decrement_counters(only_include_soft_deleted: true)
+      else
+        # Not soft-deleted: decrement all counters
+        _decrement_counters
       end
     end
 
-    # called by after_update callback
+    # before_restore (Paranoia only)
+    def _update_counts_before_restore
+      # Only increment if the record is currently soft-deleted (idempotency guard)
+      return unless deleted?
+      _increment_counters(skip_include_soft_deleted: true)
+      _handle_include_soft_deleted_column_transition
+    end
+
+    # before_discard (Discard only)
+    # Note: Discard's discard/undiscard use update_attribute which triggers
+    # after_update, so include_soft_deleted column transitions are handled
+    # there via the normal column_name change detection — no need to call
+    # _handle_include_soft_deleted_column_transition here.
+    def _update_counts_before_discard
+      # Only decrement if not already discarded (idempotency guard)
+      return if discarded?
+      _decrement_counters(skip_include_soft_deleted: true)
+    end
+
+    # before_undiscard (Discard only)
+    def _update_counts_before_undiscard
+      # Only increment if currently discarded (idempotency guard)
+      return unless discarded?
+      _increment_counters(skip_include_soft_deleted: true)
+    end
+
     def _update_counts_after_update
       self.class.after_commit_counter_cache.each do |counter|
-        # figure out whether the applicable counter cache changed (this can happen
-        # with dynamic column names)
+        # Don't update regular counters for soft-deleted records, but
+        # include_soft_deleted counters must still track association changes
+        next if destroyed_for_counter_culture? && !counter.include_soft_deleted
+
         counter_cache_name_was = counter.counter_cache_name_for(counter.previous_model(self))
         counter_cache_name = counter.counter_cache_name_for(self)
 
@@ -142,7 +183,53 @@ module CounterCulture
       end
     end
 
-    # check if record is soft-deleted
+    def _decrement_counters(skip_include_soft_deleted: false, only_include_soft_deleted: false)
+      self.class.after_commit_counter_cache.each do |counter|
+        next if skip_include_soft_deleted && counter.include_soft_deleted
+        next if only_include_soft_deleted && !counter.include_soft_deleted
+        counter.change_counter_cache(self, :increment => false)
+      end
+    end
+
+    def _increment_counters(skip_include_soft_deleted: false)
+      self.class.after_commit_counter_cache.each do |counter|
+        next if skip_include_soft_deleted && counter.include_soft_deleted
+        counter.change_counter_cache(self, :increment => true)
+      end
+    end
+
+    # For include_soft_deleted counters with dynamic column_name Procs,
+    # evaluate the Proc on both the current state and the projected future
+    # state (after soft-delete/restore completes) to detect column transitions.
+    def _handle_include_soft_deleted_column_transition
+      future = _soft_delete_future_model
+      self.class.after_commit_counter_cache.each do |counter|
+        next unless counter.include_soft_deleted
+        column_was = counter.counter_cache_name_for(self)
+        column_now = counter.counter_cache_name_for(future)
+        next if column_was == column_now
+        counter.change_counter_cache(self, :increment => true, :counter_column => column_now) if column_now
+        counter.change_counter_cache(self, :increment => false, :counter_column => column_was) if column_was
+      end
+    end
+
+    # Creates a dup of the model with the soft-delete column toggled,
+    # so dynamic column_name Procs can be evaluated against the future state.
+    def _soft_delete_future_model
+      future = self.dup
+      if respond_to?(:paranoia_destroyed?)
+        col = 'deleted_at'
+        val = paranoia_destroyed? ? nil : Time.current
+      elsif defined?(Discard::Model) && self.class.include?(Discard::Model)
+        col = self.class.discard_column.to_s
+        val = discarded? ? nil : Time.current
+      else
+        return future
+      end
+      future.instance_variable_get(:@attributes).write_from_user(col, val)
+      future
+    end
+
     def destroyed_for_counter_culture?
       if respond_to?(:paranoia_destroyed?)
         paranoia_destroyed?

data/lib/counter_culture/reconciler.rb

@@ -312,7 +312,9 @@ module CounterCulture
 
           # respect the deleted_at column if it exists
           if model.column_names.include?('deleted_at')
-            joins_sql += " AND #{target_table_alias}.deleted_at IS NULL"
+            unless include_soft_deleted
+              joins_sql += " AND #{target_table_alias}.deleted_at IS NULL"
+            end
           end
 
           # respect the discard column if it exists
@@ -320,7 +322,9 @@ module CounterCulture
              model.include?(Discard::Model) &&
              model.column_names.include?(model.discard_column.to_s)
 
-            joins_sql += " AND #{target_table_alias}.#{model.discard_column} IS NULL"
+            unless include_soft_deleted
+              joins_sql += " AND #{target_table_alias}.#{model.discard_column} IS NULL"
+            end
           end
           if index == reverse_relation.size - 1
             # conditions must be applied to the join on which we are counting

data/lib/counter_culture/skip_updates.rb

@@ -2,24 +2,20 @@ module CounterCulture
   module SkipUpdates
     private
 
-    # called by after_create callback
-    def _update_counts_after_create
-      unless Array(Thread.current[:skip_counter_culture_updates]).include?(self.class)
-        super
-      end
-    end
-
-    # called by after_destroy callback
-    def _update_counts_after_destroy
-      unless Array(Thread.current[:skip_counter_culture_updates]).include?(self.class)
-        super
-      end
-    end
-
-    # called by after_update callback
-    def _update_counts_after_update
-      unless Array(Thread.current[:skip_counter_culture_updates]).include?(self.class)
-        super
+    %i[
+      _update_counts_after_create
+      _update_counts_before_destroy
+      _update_counts_after_update
+      _update_counts_before_real_destroy
+      _update_counts_before_restore
+      _update_counts_before_discard
+      _update_counts_before_undiscard
+      _handle_include_soft_deleted_column_transition
+    ].each do |method_name|
+      define_method(method_name) do
+        unless Array(Thread.current[:skip_counter_culture_updates]).include?(self.class)
+          super()
+        end
       end
     end
   end

data/lib/counter_culture/version.rb

@@ -1,3 +1,3 @@
 module CounterCulture
-  VERSION = '3.12.2'.freeze
+  VERSION = '3.13.0'.freeze
 end

metadata

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