custom_counter_cache 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e36d2910a85a7b6354c086adad83820f1503947aba48f3caeb3c09b424b565d5
-  data.tar.gz: 6e8892f7c9a9d447117ff9ae0c7c23f16afc00739e93e4b1fd407631989fa0eb
+  metadata.gz: c9162e152f23f2e1bcbe16bc8eac89109fb42e3710f056e280ffc7e2509972ea
+  data.tar.gz: 48a92f691a0d60be81222f930ee511cf7cc5af62b90a2d6dbb940d2bd6c40e83
 SHA512:
-  metadata.gz: 7986c0f65fd6c43a38a71f4acfd6d62a7bd36e9aeeb03dbe613dff4553d1c0119cd88b48a1c6d19adffd06e4cfd214462202fc8aafe84e8e05d2034288219750
-  data.tar.gz: f52a1259232d2ae16a2117ea42f0950a41f81379892387c7f4191ec595918750b87b4f9b482223faaac03d19c50f459cd4af610523c89428bd38635c25ac0f41
+  metadata.gz: a5140b21c810447e0f8593b57252ef42064cecfc26168a46df39fa2f813f042e54aabb32c602f275c6ead13f30fc4c05b929db0cb2ffbb557367be1a4b628ef9
+  data.tar.gz: 8a0101a516d27d8b076d97173fa1733b6d4b53f85877448229c30afaa60ea78bb7059fda11e41602de505148497f79a36622bb394f968340f8947fc788b68725

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## 0.3.2
+
+### Fixed
+
+- Moving a record between owners now recounts the old owner when `belongs_to` uses a custom
+  `primary_key:`.
+- Polymorphic `belongs_to` with custom `foreign_key:`/`foreign_type:` no longer raises
+  `NoMethodError` on save.
+- Moving a record away from a polymorphic type whose class no longer exists no longer raises
+  `NameError`; the new owner is still recounted.
+- With `includes(:counters)`, counters stay current after an update, and a missing counter
+  returns 0 without a query.
+- Two saves creating the same virtual counter at once no longer fail with
+  `ActiveRecord::RecordNotUnique`; the second updates the row instead.
+- `update_counter_cache` without its `belongs_to` raises a clear `ArgumentError` instead of
+  `NoMethodError ... for nil`.
+
+### Changed
+
+- Depend on `activerecord` and `activesupport` instead of all of `rails`.
+- Require Ruby >= 3.1 in the gemspec, matching the README and Rails 7.2.
+- Test against every non-EOL Ruby (3.3, 3.4, 4.0) and Rails (8.0, 8.1).
+- Expand the test suite to cover all branches.
+- README: fix the `:if` example (`state_changed?` is always false in after callbacks)
+  and note that `:if` also applies to `after_destroy`.

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2011-2026 Cedric Howe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,87 @@
+{rdoc-image:https://github.com/cedric/custom_counter_cache/actions/workflows/ci.yml/badge.svg}[https://github.com/cedric/custom_counter_cache/actions/workflows/ci.yml]
+
+== Custom Counter Cache
+
+This is a simple approach to creating a custom counter cache in Rails that can be used across multiple models.
+
+=== Requirements
+
+* Ruby >= 3.1
+* Rails (Active Record) >= 7.2
+
+CI covers the Ruby and Rails versions that are not yet end-of-life.
+
+=== Installation
+
+Add the following to your Gemfile:
+
+  gem 'custom_counter_cache'
+
+=== Example
+
+== Class with counter cache
+
+This is the block that will be used to calculate the value for the counter cache. It will be called by other models through their association via an after_save or after_destroy callback.
+
+  include CustomCounterCache::Model
+  define_counter_cache :articles_count do |user|
+    user.articles.where(state: 'published').count
+  end
+
+== Class with callbacks
+
+This will define the after_create, after_update and after_destroy callbacks. An :if option can be provided to limit when these callbacks get triggered.
+
+  include CustomCounterCache::Model
+  update_counter_cache :user, :articles_count, if: -> (article) { article.destroyed? || article.saved_change_to_state? }
+
+The callbacks run after the record is saved, so use <tt>saved_change_to_state?</tt> rather than
+<tt>state_changed?</tt> (which is always false by then). The :if condition also applies to
+after_destroy, where there are no saved changes, hence the <tt>destroyed?</tt> check.
+
+Other options: <tt>:unless</tt>, <tt>:only</tt> / <tt>:except</tt> (e.g. <tt>only: [:create, :destroy]</tt>)
+and <tt>:prepend</tt>.
+
+These callbacks can be added to any number of models that might need to change the counter cache.
+
+== Counter Cache
+
+To store the counter cache you need to create a column for the model with the counter cache (example: articles_count).
+
+If you would like to store all of your counter caches in a single table, you can use this migration:
+
+  create_table :counters do |t|
+    t.references :countable, polymorphic: true
+    t.string :key, null: false
+    t.integer :value, null: false, default: 0
+    t.timestamps
+  end
+  add_index :counters, [ :countable_id, :countable_type, :key ], unique: true
+
+Here is the example model to go with:
+
+  class Counter < ActiveRecord::Base
+    belongs_to :countable, polymorphic: true
+    validates :countable, presence: true
+  end
+
+Note: do not add <tt>dependent: :destroy</tt> to that +belongs_to+. On a
++belongs_to+, <tt>dependent: :destroy</tt> means "when this Counter is
+destroyed, also destroy the record it belongs to" -- the opposite of what you
+want, and it creates a destroy loop: destroying a countable record cascades
+into destroying its Counters (via the <tt>has_many :counters, dependent:
+:delete_all</tt> this gem defines), and a wrongly-configured +belongs_to+ would
+then cascade back into destroying the same countable record again. The
+countable side's <tt>dependent: :delete_all</tt> already handles cleanup and
+skips Counter's own callbacks entirely, so no +dependent+ option belongs on
+the +belongs_to+ side at all.
+
+If you would like to store your counter cache in an existing table, you can use this migration:
+
+  def change
+    add_column :users, :articles_count, :integer, default: 0, null: false
+  end
+
+To backfill your counters, run something like this either in a migration or in the console:
+
+  User.select(:id).find_each(batch_size: 100) { |u| u.update_articles_count }

data/lib/custom_counter_cache/model.rb

@@ -9,20 +9,30 @@ module CustomCounterCache::Model
 
       # counter accessors
       unless column_names.include?(cache_column.to_s)
-        has_many :counters, as: :countable, dependent: :destroy
+        # Declare once per class: redeclaring for each virtual counter triggers method-redefinition warnings.
+        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
+          # Once loaded (e.g. includes(:counters)), a missing row means 0, not a query.
+          if counters.loaded?
+            counters.detect { |c| c.key == cache_column.to_s }.try(:value).to_i
           else
             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) )
+          # Update the loaded Counter itself, or the reader keeps returning its stale value.
+          counter = counters.loaded? ? counters.detect { |c| c.key == cache_column.to_s } : counters.find_by(key: cache_column.to_s)
+          if counter
             counter.update_attribute :value, count.to_i
           else
-            counters.create key: cache_column.to_s, value: count.to_i
+            begin
+              # Savepoint: on PostgreSQL a failed INSERT would otherwise abort the caller's whole transaction.
+              self.class.transaction(requires_new: true) { counters.create key: cache_column.to_s, value: count.to_i }
+            rescue ActiveRecord::RecordNotUnique
+              # Lost a create race. A locking read sees the winner's row even under REPEATABLE READ (MySQL).
+              counters.reset
+              counters.lock.find_by!(key: cache_column.to_s).update_attribute :value, count.to_i
+            end
           end
         end
       end
@@ -48,21 +58,30 @@ module CustomCounterCache::Model
       cache_column = cache_column.to_sym
       method_name  = "callback_#{association}_#{cache_column}".to_sym
       reflection   = reflect_on_association(association)
-      foreign_key  = reflection.try(:foreign_key) || reflection.association_foreign_key
+      raise ArgumentError, "#{self} must declare belongs_to :#{association} before update_counter_cache" unless reflection
+      foreign_key  = reflection.foreign_key
 
       # 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.polymorphic?
+          type_key = reflection.foreign_type
+          id_key   = foreign_key
+          if saved_change_to_attribute?(id_key) || saved_change_to_attribute?(type_key)
+            old_type = saved_change_to_attribute?(type_key) ? attribute_before_last_save(type_key) : self[type_key]
+            old_id   = saved_change_to_attribute?(id_key)   ? attribute_before_last_save(id_key)   : self[id_key]
+            # safe_: the stored type may name a class that has since been renamed or removed.
+            old_klass = old_type&.safe_constantize
+            if ( old_klass && old_id && record = old_klass.find_by(reflection.association_primary_key(old_klass) => 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 saved_change_to_attribute?(foreign_key)
+            old_id = attribute_before_last_save(foreign_key)
+            if ( old_id && record = reflection.klass.find_by(reflection.association_primary_key => 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.2'
 
 end

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: custom_counter_cache
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Cedric Howe
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -30,6 +29,60 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        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: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -44,22 +97,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: ''
+description: Define counter caches computed by an arbitrary block (e.g. a scoped count),
+  refreshed by callbacks on any number of associated models, and stored in a column
+  or a shared polymorphic counters table.
 email: cedric@howe.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
+- README.rdoc
 - lib/custom_counter_cache.rb
 - lib/custom_counter_cache/model.rb
 - lib/custom_counter_cache/version.rb
-- test/counter_test.rb
-- test/test_helper.rb
-homepage: http://github.com/cedric/custom_counter_cache/
+homepage: https://github.com/cedric/custom_counter_cache
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/cedric/custom_counter_cache
+  changelog_uri: https://github.com/cedric/custom_counter_cache/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -67,18 +124,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.21
 specification_version: 4
 summary: Custom counter_cache functionality that supports conditions and multiple
   models.
-test_files:
-- test/counter_test.rb
-- test/test_helper.rb
+test_files: []

data/test/counter_test.rb

@@ -1,110 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class CounterTest < Minitest::Test
-
-  def setup
-    @user = User.create
-    @box = Box.create
-    Counter.destroy_all
-  end
-
-  def test_default_counter_value
-    assert_equal 0, @user.published_count
-    assert_equal 0, @box.green_balls_count
-  end
-
-  def test_create_and_destroy_counter
-    @user.articles.create(state: 'published')
-    assert_equal 1, Counter.count
-    @user.destroy
-    assert_equal 0, Counter.count
-  end
-
-  def test_create_and_destroy_polymorphic_association_counter
-    @article = @user.articles.create(state: "published")
-    assert_equal 0, @article.comments.size
-    @comment = @article.comments.create(state: "published")
-    assert_equal 1, @article.comments.size
-    @article.destroy
-    assert_equal 0, @article.comments.size
-  end
-
-  def test_increment_and_decrement_counter_with_conditions
-    @article = @user.articles.create(state: 'unpublished')
-    assert_equal 0, @user.published_count
-    @article.update_attribute :state, 'published'
-    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(state: 'unpublished') }
-    assert_equal 0, @user.published_count
-  end
-
-  def test_increment_and_decrement_polymorphic_counter_with_conditions
-    @article = @user.articles.create(state: "published")
-    @comment = @article.comments.create(state: "unpublished")
-    assert_equal 0, @article.comments_count
-    @comment.update_attribute :state, "published"
-    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(state: 'unpublished') }
-    assert_equal 0, @article.comments_count
-  end
-
-  def test_increment_and_decrement_counter_with_conditions_on_model_with_counter_column
-    @ball = @box.balls.create(color: 'red')
-    assert_equal 0, @box.reload.green_balls_count
-    @ball.update_attribute :color, 'green'
-    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(color: 'red') }
-    assert_equal 0, @box.reload.green_balls_count
-  end
-
-  # Test that an eager loaded
-  def test_eager_loading_with_no_counter
-    @article = @user.articles.create(state: 'unpublished')
-    user = User.includes(:counters).first
-    assert_equal 0, user.published_count
-
-  end
-
-  def test_eager_loading_with_counter
-    @article = @user.articles.create(state: 'published')
-    @user = User.includes(:counters).find(@user.id)
-    assert_equal 1, @user.published_count
-  end
-
-  def test_except_option
-    @ball = @box.balls.create
-    assert_equal 1, @box.reload.lifetime_balls_count
-    @ball.update(color: 'green')
-    assert_equal 1, @box.reload.lifetime_balls_count
-    @ball.destroy
-    assert_equal 1, @box.reload.lifetime_balls_count
-  end
-
-  def test_only_option
-    @ball = @box.balls.create
-    assert_equal 0, @box.reload.destroyed_balls_count
-    @ball.update(color: 'green')
-    assert_equal 0, @box.reload.destroyed_balls_count
-    @ball.destroy
-    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
-
-end

data/test/test_helper.rb

@@ -1,93 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'sqlite3'
-require 'action_view'
-require 'active_record'
-require 'custom_counter_cache'
-
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-
-ActiveRecord::Schema.define(version: 1) do
-  create_table :users do |t|
-  end
-
-  create_table :articles do |t|
-    t.belongs_to :user
-    t.string :state, default: 'unpublished'
-  end
-
-  create_table :comments do |t|
-    t.belongs_to :user
-    t.references :commentable, polymorphic: true
-    t.string :state, default: "unpublished"
-  end
-
-  create_table :counters do |t|
-    t.references :countable, polymorphic: true
-    t.string :key, null: false
-    t.integer :value, null: false, default: 0
-  end
-  add_index :counters, [ :countable_id, :countable_type, :key ], unique: true
-
-  create_table :boxes do |t|
-    t.integer :green_balls_count, default: 0
-    t.integer :lifetime_balls_count, default: 0
-    t.integer :destroyed_balls_count, default: 0
-  end
-
-  create_table :balls do |t|
-    t.belongs_to :box
-    t.string :color, default: 'red'
-  end
-end
-
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-  include CustomCounterCache::Model
-end
-
-class User < ApplicationRecord
-  has_many :articles, dependent: :destroy
-  define_counter_cache :published_count do |user|
-    user.articles.where(articles: { state: 'published' }).count
-  end
-end
-
-class Article < ApplicationRecord
-  belongs_to :user
-  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
-  end
-end
-
-class Comment < ApplicationRecord
-  belongs_to :commentable, polymorphic: true
-  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
-end
-
-class Box < ApplicationRecord
-  has_many :balls
-  define_counter_cache :green_balls_count do |box|
-    box.balls.green.count
-  end
-  define_counter_cache :lifetime_balls_count do |box|
-    box.lifetime_balls_count + 1
-  end
-  define_counter_cache :destroyed_balls_count do |box|
-    box.destroyed_balls_count + 1
-  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?(:color) }
-  update_counter_cache :box, :lifetime_balls_count, except: [:update, :destroy]
-  update_counter_cache :box, :destroyed_balls_count, only: [:destroy]
-end