custom_counter_cache 0.2.8 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccba1337c291259711f6a18d6604a72c9be6a8a858342b345dab51f434d05816
-  data.tar.gz: 97d0e479eb6900a090449243a326a5a3572597219bb119af248dade70adc188b
+  metadata.gz: b86370bc27fe59b1bafc3f2160e69843c9650e58b6c9e980010eb5f88fb229cd
+  data.tar.gz: 0aeccd374cf039a73f248fa4440f3d472859f73f83b4a0f991b432eaba7bf10e
 SHA512:
-  metadata.gz: 6d342ee7e3857b846c66f3183ce2010c0f5c9fc9719060c3d542669fd66ca0266dd2caa77b972013ed01b516bf48799b62ffe32188124900ce8ae74bdb0ef2e9
-  data.tar.gz: c5b2d8ee7b87e16b04cd62c85d358787126112c8781775a9648aec8f31f5d7f808c363a282a27d6713ec4f6bd452f9a4c4f69998980df95befe84f745d1c3c34
+  metadata.gz: f0de231b5e888db121d43d3a37909e37b8e3cb1fd4bf0c58ad0195bda8030f4937a1aba70729716c6c23f3ec1aa48888f68308bb998d6e50fe8bcb71529d9bde
+  data.tar.gz: 721794ae2b6cb35349209392f390d42352d3f0fa31a10599b7c13e7dd98e00bdba7c29c96ccfd9033d99e4c508aeab845ec2db9e653bd93f21238fb899892d12

data/lib/custom_counter_cache/model.rb

@@ -9,17 +9,21 @@ 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 }
             counter.value
           else
-            counters.find_by_key(cache_column.to_s).try(:value).to_i
+            counters.find_by(key: cache_column.to_s).try(:value).to_i
           end
         end
         define_method "#{cache_column}=" do |count|
-          if ( counter = counters.find_by_key(cache_column.to_s) )
+          if ( counter = counters.find_by(key: cache_column.to_s) )
             counter.update_attribute :value, count.to_i
           else
             counters.create key: cache_column.to_s, value: count.to_i
@@ -53,18 +57,22 @@ module CustomCounterCache::Model
       # define callback
       define_method method_name do
         # update old association
-        rails_5_1_or_newer = ActiveModel.version >= Gem::Version.new('5.1.0')
-        target_key = reflection.options[:polymorphic] ? "#{association}_type" : foreign_key
-        target_changed = rails_5_1_or_newer ? send("saved_change_to_#{target_key}?") : send("#{target_key}_changed?")
-        if target_changed
-          old_id = rails_5_1_or_newer ? send("#{target_key}_before_last_save") : send("#{target_key}_was")
-          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
@@ -79,9 +87,10 @@ module CustomCounterCache::Model
       }
 
       # set callbacks
-      after_create  method_name, options unless skip_callback.call(:create, options)
-      after_update  method_name, options unless skip_callback.call(:update, options)
-      after_destroy method_name, options unless skip_callback.call(:destroy, options)
+      callback_opts = options.slice(:if, :unless, :prepend)
+      after_create  method_name, **callback_opts unless skip_callback.call(:create, options)
+      after_update  method_name, **callback_opts unless skip_callback.call(:update, options)
+      after_destroy method_name, **callback_opts unless skip_callback.call(:destroy, options)
 
     rescue StandardError => e
       # Support Heroku's database-less assets:precompile pre-deploy step:

data/lib/custom_counter_cache/version.rb

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

data/test/counter_test.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class CounterTest < MiniTest::Unit::TestCase
+class CounterTest < Minitest::Test
 
   def setup
     @user = User.create
@@ -36,7 +36,7 @@ class CounterTest < MiniTest::Unit::TestCase
     assert_equal 1, @user.published_count
     3.times { |i| @user.articles.create(state: 'published') }
     assert_equal 4, @user.published_count
-    @user.articles.each {|a| a.update_attributes(state: 'unpublished') }
+    @user.articles.each {|a| a.update(state: 'unpublished') }
     assert_equal 0, @user.published_count
   end
 
@@ -48,7 +48,7 @@ class CounterTest < MiniTest::Unit::TestCase
     assert_equal 1, @article.comments_count
     3.times { |i| @article.comments.create(state: "published") }
     assert_equal 4, @article.comments_count
-    @article.comments.each { |c| c.update_attributes(state: "unpublished") }
+    @article.comments.each { |c| c.update(state: 'unpublished') }
     assert_equal 0, @article.comments_count
   end
 
@@ -59,7 +59,7 @@ class CounterTest < MiniTest::Unit::TestCase
     assert_equal 1, @box.reload.green_balls_count
     3.times { |i| @box.balls.create(color: 'green') }
     assert_equal 4, @box.reload.green_balls_count
-    @box.balls.each {|b| b.update_attributes(color: 'red') }
+    @box.balls.each {|b| b.update(color: 'red') }
     assert_equal 0, @box.reload.green_balls_count
   end
 
@@ -95,4 +95,188 @@ class CounterTest < MiniTest::Unit::TestCase
     assert_equal 1, @box.reload.destroyed_balls_count
   end
 
+  def test_reassigning_article_to_different_user_updates_both_counters
+    @user2 = User.create
+    @article = @user.articles.create(state: 'unpublished')
+    assert_equal 0, @user.reload.published_count
+    assert_equal 0, @user2.reload.published_count
+    # Changing both user and state triggers the :if condition (state changed)
+    # and the reassignment logic inside the callback updates the old user's counter too
+    @article.update(user: @user2, state: 'published')
+    assert_equal 0, @user.reload.published_count
+    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,24 +39,24 @@ 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
   self.abstract_class = true
   include CustomCounterCache::Model
-  @@rails_5_1_or_newer = ActiveModel.version >= Gem::Version.new('5.1.0')
-
-  def saved_change_to_attribute_compat?(attr)
-    if @@rails_5_1_or_newer
-      saved_change_to_attribute?(attr)
-    else
-      attribute_changed?(attr)
-    end
-  end
 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
@@ -64,7 +64,7 @@ end
 
 class Article < ApplicationRecord
   belongs_to :user
-  update_counter_cache :user, :published_count, if: Proc.new { |article| article.saved_change_to_attribute_compat?(:state) }
+  update_counter_cache :user, :published_count, if: Proc.new { |article| article.saved_change_to_attribute?(:state) }
   has_many :comments, as: :commentable, dependent: :destroy
   define_counter_cache :comments_count do |article|
     article.comments.where(state: "published").count
@@ -73,11 +73,15 @@ end
 
 class Comment < ApplicationRecord
   belongs_to :commentable, polymorphic: true
-  update_counter_cache :commentable, :comments_count, if: Proc.new { |comment| comment.saved_change_to_attribute_compat?(:state) }
+  update_counter_cache :commentable, :comments_count, if: Proc.new { |comment| comment.saved_change_to_attribute?(:state) }
 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
@@ -91,12 +95,44 @@ 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
   belongs_to :box
   scope :green, lambda { where(color: 'green') }
-  update_counter_cache :box, :green_balls_count, if: Proc.new { |ball| ball.saved_change_to_attribute_compat?(:color) }
+  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.2.8
+  version: 0.3.1
 platform: ruby
 authors:
 - Cedric Howe
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,34 +16,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.3
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.3
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2.0'
 description: ''
 email: cedric@howe.net
 executables: []
@@ -59,7 +59,7 @@ homepage: http://github.com/cedric/custom_counter_cache/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -67,18 +67,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Custom counter_cache functionality that supports conditions and multiple
   models.
 test_files:
-- test/test_helper.rb
 - test/counter_test.rb
+- test/test_helper.rb