custom_counter_cache 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e36d2910a85a7b6354c086adad83820f1503947aba48f3caeb3c09b424b565d5
-  data.tar.gz: 6e8892f7c9a9d447117ff9ae0c7c23f16afc00739e93e4b1fd407631989fa0eb
+  metadata.gz: b86370bc27fe59b1bafc3f2160e69843c9650e58b6c9e980010eb5f88fb229cd
+  data.tar.gz: 0aeccd374cf039a73f248fa4440f3d472859f73f83b4a0f991b432eaba7bf10e
 SHA512:
-  metadata.gz: 7986c0f65fd6c43a38a71f4acfd6d62a7bd36e9aeeb03dbe613dff4553d1c0119cd88b48a1c6d19adffd06e4cfd214462202fc8aafe84e8e05d2034288219750
-  data.tar.gz: f52a1259232d2ae16a2117ea42f0950a41f81379892387c7f4191ec595918750b87b4f9b482223faaac03d19c50f459cd4af610523c89428bd38635c25ac0f41
+  metadata.gz: f0de231b5e888db121d43d3a37909e37b8e3cb1fd4bf0c58ad0195bda8030f4937a1aba70729716c6c23f3ec1aa48888f68308bb998d6e50fe8bcb71529d9bde
+  data.tar.gz: 721794ae2b6cb35349209392f390d42352d3f0fa31a10599b7c13e7dd98e00bdba7c29c96ccfd9033d99e4c508aeab845ec2db9e653bd93f21238fb899892d12

data/lib/custom_counter_cache/model.rb

@@ -9,7 +9,11 @@ module CustomCounterCache::Model
 
       # counter accessors
       unless column_names.include?(cache_column.to_s)
-        has_many :counters, as: :countable, dependent: :destroy
+        # Only declare the :counters association once per class -- a model
+        # can have multiple virtual (non-column) counter caches, and
+        # redeclaring has_many :counters for each one just redefines the
+        # same reader/writer methods again, which Ruby warns about under -w.
+        has_many :counters, as: :countable, dependent: :delete_all unless reflect_on_association(:counters)
         define_method "#{cache_column}" do
           # check if the counter is loaded
           if counters.loaded? && counter = counters.detect{|c| c.key == cache_column.to_s }
@@ -53,16 +57,22 @@ module CustomCounterCache::Model
       # define callback
       define_method method_name do
         # update old association
-        target_key = reflection.options[:polymorphic] ? "#{association}_type" : foreign_key
-        if send("saved_change_to_#{target_key}?")
-          old_id = send("#{target_key}_before_last_save")
-          klass = if reflection.options[:polymorphic]
-            ( old_id || send("#{association}_type") ).constantize
-          else
-            reflection.klass
+        if reflection.options[:polymorphic]
+          type_key = "#{association}_type"
+          id_key   = "#{association}_id"
+          if send("saved_change_to_#{id_key}?") || send("saved_change_to_#{type_key}?")
+            old_type = send("saved_change_to_#{type_key}?") ? send("#{type_key}_before_last_save") : send(type_key)
+            old_id   = send("saved_change_to_#{id_key}?")   ? send("#{id_key}_before_last_save")   : send(id_key)
+            if ( old_type && old_id && record = old_type.constantize.find_by(id: old_id) )
+              record.send("update_#{cache_column}")
+            end
           end
-          if ( old_id && record = klass.find_by(id: old_id) )
-            record.send("update_#{cache_column}")
+        else
+          if send("saved_change_to_#{foreign_key}?")
+            old_id = send("#{foreign_key}_before_last_save")
+            if ( old_id && record = reflection.klass.find_by(id: old_id) )
+              record.send("update_#{cache_column}")
+            end
           end
         end
         # update new association

data/lib/custom_counter_cache/version.rb

@@ -1,5 +1,5 @@
 module CustomCounterCache
 
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 
 end

data/test/counter_test.rb

@@ -107,4 +107,176 @@ class CounterTest < Minitest::Test
     assert_equal 1, @user2.reload.published_count
   end
 
+  # -- destroy loop regression --
+  #
+  # A consumer's Counter model might mistakenly add `dependent: :destroy` to
+  # its `belongs_to :countable` (see test_helper.rb's Counter class and the
+  # README "Note" on this). On a belongs_to, dependent: :destroy means "when
+  # I am destroyed, also destroy the record I belong to" -- the opposite of
+  # what a counter cache needs. Combined with the has_many :counters this gem
+  # defines on the countable side, that mistake used to create a destroy
+  # loop: destroying a countable record cascaded into destroying its
+  # Counters, and each Counter's (wrongly configured) belongs_to cascaded
+  # back into destroying the same countable record again, re-running its
+  # full before_destroy chain against already-destroyed associations.
+  #
+  # has_many :counters now uses dependent: :delete_all, which deletes Counter
+  # rows with a single SQL statement and never instantiates them or runs
+  # their callbacks -- so a misconfigured Counter#belongs_to (like the one in
+  # this test suite's fixtures, deliberately) can no longer cause the loop.
+
+  def test_destroying_a_countable_record_with_a_dependent_association_does_not_recurse
+    @user.articles.create!(state: 'published') # gives the user a real Counter row
+    note = UserNote.create!(user: @user)
+
+    @user.destroy!
+
+    assert @user.destroyed?
+    refute UserNote.exists?(note.id)
+  end
+
+  def test_counters_are_removed_via_a_single_delete_without_instantiating_them
+    @user.articles.create!(state: 'published')
+    assert_equal 1, Counter.where(countable: @user).count
+
+    # dependent: :delete_all must never call Counter#destroy -- prove it by
+    # making Counter#destroy raise, then destroying the user anyway.
+    Counter.define_method(:destroy) { raise 'Counter#destroy should not be called' }
+
+    @user.destroy!
+
+    assert_equal 0, Counter.where(countable_type: 'User', countable_id: @user.id).count
+  ensure
+    Counter.send(:remove_method, :destroy) if Counter.instance_methods(false).include?(:destroy)
+  end
+
+  # -- update_counter_cache: polymorphic reassignment --
+  #
+  # For a polymorphic association, the old owner must be looked up by its
+  # old *type* and old *id* together -- either can change independently
+  # (moving to a different record of the same type only changes the id;
+  # moving to a different type changes both).
+
+  def test_reassigning_a_polymorphic_association_updates_both_old_and_new_owner_counters
+    article1 = @user.articles.create!(state: 'unpublished')
+    article2 = @user.articles.create!(state: 'unpublished')
+    comment = article1.comments.create!(state: 'unpublished')
+    comment.update!(state: 'published')
+    assert_equal 1, article1.reload.comments_count
+    assert_equal 0, article2.reload.comments_count
+
+    # The :if condition only fires the callback on a state change, so toggle
+    # state alongside the reassignment -- same pattern as
+    # test_reassigning_article_to_different_user_updates_both_counters above.
+    comment.update!(commentable: article2, state: 'unpublished')
+    comment.update!(state: 'published')
+
+    assert_equal 0, article1.reload.comments_count
+    assert_equal 1, article2.reload.comments_count
+  end
+
+  # -- rescue StandardError / Heroku DATABASE_URL guard --
+  #
+  # Both class methods wrap their body in a rescue that swallows any
+  # StandardError raised while table_exists? can't reach a database (e.g.
+  # during `assets:precompile` on Heroku, where there is no DB connection at
+  # all), but only when DATABASE_URL matches Heroku's placeholder value.
+  # Anywhere else, the error must still propagate.
+
+  def with_stubbed_table_exists(klass, error)
+    klass.define_singleton_method(:table_exists?) { raise error }
+    yield
+  ensure
+    klass.singleton_class.send(:remove_method, :table_exists?)
+  end
+
+  def test_define_counter_cache_reraises_when_database_url_is_not_the_heroku_placeholder
+    klass = Class.new(ApplicationRecord) { self.table_name = 'users' }
+    with_stubbed_table_exists(klass, 'no database connection') do
+      assert_raises(RuntimeError) { klass.define_counter_cache(:whatever) { |r| 0 } }
+    end
+  end
+
+  def test_define_counter_cache_swallows_error_when_database_url_is_the_heroku_placeholder
+    klass = Class.new(ApplicationRecord) { self.table_name = 'users' }
+    with_env('DATABASE_URL', 'postgres://user:pass@127.0.0.1/dbname') do
+      with_stubbed_table_exists(klass, 'no database connection') do
+        klass.define_counter_cache(:whatever) { |r| 0 } # must not raise
+      end
+    end
+    refute klass.method_defined?(:whatever)
+  end
+
+  def test_update_counter_cache_reraises_when_database_url_is_not_the_heroku_placeholder
+    klass = Class.new(ApplicationRecord) { self.table_name = 'articles' }
+    with_stubbed_table_exists(klass, 'no database connection') do
+      assert_raises(RuntimeError) { klass.update_counter_cache(:user, :whatever) }
+    end
+  end
+
+  def test_update_counter_cache_swallows_error_when_database_url_is_the_heroku_placeholder
+    klass = Class.new(ApplicationRecord) { self.table_name = 'articles' }
+    with_env('DATABASE_URL', 'postgres://user:pass@127.0.0.1/dbname') do
+      with_stubbed_table_exists(klass, 'no database connection') do
+        klass.update_counter_cache(:user, :whatever) # must not raise
+      end
+    end
+  end
+
+  def with_env(key, value)
+    original = ENV[key]
+    ENV[key] = value
+    yield
+  ensure
+    ENV[key] = original
+  end
+
+  # -- table_exists? early return (no error, just a missing table) --
+
+  def test_define_counter_cache_is_a_no_op_when_the_table_does_not_exist
+    klass = Class.new(ApplicationRecord) { self.table_name = 'nonexistent_table_xyz' }
+    klass.define_counter_cache(:whatever) { |r| 0 }
+    refute klass.method_defined?(:whatever)
+    refute klass.method_defined?(:update_whatever)
+  end
+
+  def test_update_counter_cache_is_a_no_op_when_the_table_does_not_exist
+    klass = Class.new(ApplicationRecord) { self.table_name = 'nonexistent_table_xyz' }
+    klass.update_counter_cache(:user, :whatever)
+    refute klass.method_defined?(:callback_user_whatever)
+  end
+
+  # -- update_counter_cache: :unless option --
+
+  def test_unless_option_skips_the_callback_when_true
+    @ball = @box.balls.create(color: 'red')
+    assert_equal 1, @box.reload.non_green_balls_count
+    @ball.update(color: 'green')
+    # :unless suppresses the callback here, so the count is stale (still 1)
+    # rather than recomputed to 0 -- proving the callback did not run.
+    assert_equal 1, @box.reload.non_green_balls_count
+  end
+
+  def test_unless_option_runs_the_callback_when_false
+    @ball = @box.balls.create(color: 'green')
+    @ball.update(color: 'red')
+    assert_equal 1, @box.reload.non_green_balls_count
+  end
+
+  # -- update_counter_cache: :prepend option --
+  #
+  # NOTE: this checks that :prepend is forwarded to the after_create callback
+  # chain (the gem's own responsibility), not that it changes visible
+  # execution order -- that's a separate, Rails-internals quirk: plain
+  # sequential after_* callbacks in this Rails version don't necessarily run
+  # in chain order just because one was prepended (confirmed with a bare
+  # `after_create ..., prepend: true` outside this gem entirely).
+
+  def test_prepend_option_is_forwarded_to_the_callback_chain
+    after_create_filters = Ball._create_callbacks.select { |cb| cb.kind == :after }.map(&:filter)
+    assert_operator after_create_filters.index(:callback_box_marker_b_count),
+      :<, after_create_filters.index(:callback_box_marker_a_count),
+      'expected the prepend: true callback (marker_b) to be ordered before the non-prepended one (marker_a)'
+  end
+
 end

data/test/test_helper.rb

@@ -39,6 +39,14 @@ ActiveRecord::Schema.define(version: 1) do
     t.belongs_to :box
     t.string :color, default: 'red'
   end
+
+  create_table :user_notes do |t|
+    t.belongs_to :user
+  end
+
+  create_table :user_note_logs do |t|
+    t.belongs_to :user_note
+  end
 end
 
 class ApplicationRecord < ActiveRecord::Base
@@ -48,6 +56,7 @@ end
 
 class User < ApplicationRecord
   has_many :articles, dependent: :destroy
+  has_one :user_note, dependent: :destroy
   define_counter_cache :published_count do |user|
     user.articles.where(articles: { state: 'published' }).count
   end
@@ -68,7 +77,11 @@ class Comment < ApplicationRecord
 end
 
 class Counter < ApplicationRecord
-  belongs_to :countable, polymorphic: true
+  # Deliberately mirrors a real-world consumer mistake: adding dependent: :destroy
+  # to this belongs_to (see README "Note"). It must NOT cause destroying a
+  # countable record to recurse back into destroying itself a second time --
+  # see DestroyLoopTest, which is what actually guards against this.
+  belongs_to :countable, polymorphic: true, dependent: :destroy
 end
 
 class Box < ApplicationRecord
@@ -82,6 +95,15 @@ class Box < ApplicationRecord
   define_counter_cache :destroyed_balls_count do |box|
     box.destroyed_balls_count + 1
   end
+  define_counter_cache :non_green_balls_count do |box|
+    box.balls.where.not(color: 'green').count
+  end
+  define_counter_cache :marker_a_count do |box|
+    0
+  end
+  define_counter_cache :marker_b_count do |box|
+    0
+  end
 end
 
 class Ball < ApplicationRecord
@@ -90,4 +112,27 @@ class Ball < ApplicationRecord
   update_counter_cache :box, :green_balls_count, if: Proc.new { |ball| ball.saved_change_to_attribute?(:color) }
   update_counter_cache :box, :lifetime_balls_count, except: [:update, :destroy]
   update_counter_cache :box, :destroyed_balls_count, only: [:destroy]
+  update_counter_cache :box, :non_green_balls_count, unless: Proc.new { |ball| ball.color == 'green' }
+  update_counter_cache :box, :marker_a_count, only: [:create]
+  update_counter_cache :box, :marker_b_count, only: [:create], prepend: true
+end
+
+# Stands in for something like the `audited` gem: a has_one association whose
+# own destroy writes a dependent log record from a before_destroy callback
+# (matching how `audited` hooks in -- before_destroy, not after_destroy, so
+# the record is still persisted? while the callback runs). If destroying the
+# owner (User) ever recurses back into destroying itself a second time, this
+# fails the second time around because the UserNote is no longer persisted.
+class UserNote < ApplicationRecord
+  belongs_to :user
+  has_many :logs, class_name: 'UserNoteLog', foreign_key: :user_note_id, dependent: :destroy
+  before_destroy :write_log
+
+  def write_log
+    logs.create!
+  end
+end
+
+class UserNoteLog < ApplicationRecord
+  belongs_to :user_note
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: custom_counter_cache
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Cedric Howe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails