counter_culture 1.8.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d2851375f488ec2d44fad34f75bc463cc7b6d30e
-  data.tar.gz: e8cee5f97368554bd04a0acc97b9feffb7e9fe5c
+SHA256:
+  metadata.gz: 74fff95505913ba522b3ec93bc9101c375c7de5678744145a0e4959f2c267361
+  data.tar.gz: bc284f87da6f949e7d875b7f30c43accbe23ce5716601af9fc4143eb6346954d
 SHA512:
-  metadata.gz: b6af5865d97f22a07be30100266b5b2ee67778c9447c3e74e45c82d21e268912f83d295431cc4ad5ed26d3cc86eee95277a846044b9247ef61b238e6b98ac411
-  data.tar.gz: f8ac7e975612ddb98bb955b090db7d29511b602797fa3d684a1743a1d000f95e8a5bd8d2c0b6092c8a6cec236cd932a7437517e2da33c2e39c5e64e69d21fbca
+  metadata.gz: e63708745c4ffbb727a1b4da61a0d027de76d7256ee5d9669fa0f18dfcc2b183f26ddc109f45d6af6fb68a79c040e73872f647e8453c7b801e390036601878eb
+  data.tar.gz: c58c36d4aaf450450d913ad93487c7012de5de0ba8bb4f99c83a3994b64e8aed19f04a0d62c0df21ceda862312b9c010af042857709d891f746e20403ef893f2

data/.gitignore

@@ -0,0 +1,65 @@
+# appraisal lockfiles
+gemfiles/*.lock
+
+# spec coverage
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# this changes all the time when we change multiple Rails versions
+Gemfile.lock
+
+# allow people to manage their own Ruby versions / gemsets
+.ruby-version
+.ruby-gemset
+
+# rspec pass/fail status
+.rspec_status
+
+# sqlite3 db
+db
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/.travis.yml

@@ -1,14 +1,32 @@
 language: ruby
+services:
+  - postgresql
+  - mysql
+addons:
+  postgresql: "9.6"
 rvm:
-  - "2.2.5"
-  - "2.3.1"
+  - "2.5.7"
+  - "2.6.5"
+  - "2.7.0"
+gemfile:
+  - gemfiles/rails_4.2.gemfile
+  - gemfiles/rails_5.0.gemfile
+  - gemfiles/rails_5.1.gemfile
+  - gemfiles/rails_5.2.gemfile
+  - gemfiles/rails_6.0.gemfile
+matrix:
+  exclude:
+    - rvm: "2.7.0"
+      gemfile: gemfiles/rails_4.2.gemfile
 env:
-  - "RAILS_VERSION=3.2.0"
-  - "RAILS_VERSION=4.0.0"
-  - "RAILS_VERSION=4.1.0"
-  - "RAILS_VERSION=4.2.0"
-  - "RAILS_VERSION=5.0.0"
-  - "RAILS_VERSION=5.1.0"
+  - DB=postgresql
+  - DB=sqlite3
+  - DB=mysql2
+before_install:
+  - gem install bundler -v '1.17.3'
 install:
-  - bundle update
+  - bundle _1.17.3_ update
+before_script:
+  - psql -c 'create database counter_culture_test;' -U postgres
+  - mysql -e 'CREATE DATABASE counter_culture_test;'
 script: TRAVIS=true bundle exec rake spec

data/Appraisals

@@ -0,0 +1,22 @@
+%w[
+  4.2
+  5.0
+  5.1
+  5.2
+  6.0
+].each do |rails_version|
+  gem_rails_version = Gem::Version.new(rails_version)
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.5.0') &&
+      gem_rails_version >= Gem::Version.new('6.0.0.beta')
+
+    # Rails 6 requires Ruby >= 2.5
+    next
+  end
+  appraise "rails-#{rails_version}" do
+    gem 'rails', "~> #{rails_version}.0"
+
+    gem 'pg', gem_rails_version < Gem::Version.new('5.0') ? '~> 0.15' : '~> 1.0'
+    gem 'mysql2'
+    gem 'sqlite3', gem_rails_version < Gem::Version.new(5.2) ? '~> 1.3.0' : '~> 1.4'
+  end
+end

data/CHANGELOG.md

@@ -1,3 +1,172 @@
+## 2.7.0 (November 16, 2020)
+
+Improvements:
+  - New `column_name` option for `counter_culture_fix_counts` (#300)
+
+## 2.6.2 (October 21, 2020)
+
+Improvements:
+  - Remove superfluous dependency to after_commit_action gem (#297)
+
+## 2.6.1 (September 8, 2020)
+
+Bugfixes:
+  - Address Ruby 2.7.0 deprecation warning (#292)
+
+## 2.6.0 (July 29, 2020)
+
+Improvements:
+  - Use []= method instead of attribute writer method internally to avoid conflicts with read-only attributes (#287)
+  - More detailed logging when performing reconciliation (#288)
+
+## 2.5.1 (May 18, 2020)
+
+Bugfixes:
+  - Fix migration generation in Rails 6+ (#281)
+
+## 2.5.0 (May 12, 2020)
+
+Bugfixes:
+  - Fix `counter_culture_fix_counts` with Rails 4.2
+
+Changes:
+  - Dropped support for Ruby 2.3 and 2.4
+
+## 2.4.0 (May 9, 2020)
+
+Improvements:
+  - Allow specifying `start` and `finish` options to `counter_culture_fix_counts` (#279)
+
+## 2.3.0 (January 28, 2020)
+
+Improvements:
+  - Allow using scopes in `column_names` (#272)
+
+## 2.2.4 (August 21, 2019)
+
+Bugfixes:
+  - Test and fix behavior in Rails 6.0.0 release (#268)
+
+## 2.2.3 (June 20, 2019)
+
+Improvements:
+  - Start testing against MySQL and PostgreSQL as well as sqlite3 (#257)
+
+Bugfixes:
+  - Fix edge cases in MySQL (#257)
+
+## 2.2.2 (May 5, 2019)
+
+Bugfixes:
+  - Don't fail reconciliation in PostgreSQL if the Rails-level primary key is not a DB primary key (#254)
+
+## 2.2.1 (April 17, 2019)
+
+Improvements:
+  - Improve logging when `verbose` is set (#256)
+
+## 2.2.0 (April 9, 2019)
+
+Improvements:
+  - Add `where` option to `counter_culture_fix_counts` (#250)
+  - Add `verbose` option to `counter_culture_fix_counts` (#251)
+
+Changes:
+  - Dropped support for Ruby 2.2
+  - Dropped support for Rails 3.2, 4.0 and 4.1
+
+## 2.1.4 (January 21, 2019)
+
+Improvements:
+  - Avoid instantiating model class during `counter_culture` call (#246)
+
+## 2.1.3 (January 19, 2019)
+
+Bugfixes:
+  - Don't update running total on soft-deleted records (#244)
+
+## 2.1.2 (December 7, 2018)
+
+Bugfixes:
+  - Properly handle `destroy` and `really_destroy` when using Paranoia (#239)
+
+## 2.1.1 (November 7, 2018)
+
+Bugfixes:
+  - Don't double-decrement when discarding and then hard-destroying a record (#237)
+
+## 2.1.0 (October 19, 2018)
+
+Bugfixes:
+  - Fix behavior with Models that are part of a module (ex: `Users::Admin`) (#234)
+
+## 2.0.1 (August 19, 2018)
+
+Bugfixes:
+  - Properly set timestamps of PaperTrail versions (#224, #225, #226)
+
+## 2.0.0 (June 12, 2018)
+
+Breaking changes:
+  - execute_after_commit was removed
+  - Removed workaround for incorrect counts when triggering updates from an `after_create` hook. Your options if this applies to you:
+    * continue using counter_culture 1.12.0
+    * upgrade to Rails 5.1.5 which fixes the underlying issue in Rails
+    * avoid triggering further updates on the same model in `after_create`; simply set the attribute in `before_create` instead
+
+Bugfixes:
+  - Multiple updates in one transaction will now be processed correctly (#222)
+
+## 1.12.0 (June 8, 2018)
+
+Improvements:
+  - Adds support for the [Discard](https://github.com/jhawthorn/discard) soft-delete gem (#220)
+
+## 1.11.0 (May 4, 2018)
+
+Bugfixes:
+  - Fix `with_papertrail` behavior while still addressing the deprecation warning, and actually recording the correct counts (#218, see [airblade/paper_trail#1076](https://github.com/airblade/paper_trail/issues/1076))
+
+## 1.10.1 (April 20, 2018)
+
+Improvements:
+  - Added the ability to update timestamps while fixing count by passing `touch: true` to `counter_culture_fix_counts` (#212)
+
+## 1.9.2 (April 13, 2018)
+
+Bugfixes:
+  - When using paranoia, call increment / decrement only once when calling destroy or restore on the same model multiple times
+
+Improvements:
+  - Address deprecation warning when enabling paper_trail touch in paper_trail version 9.0
+  - Address `Arel` deprecation warnings in Rails 5.2
+
+Changes:
+  - Test against Ruby 2.2 through 2.5, Rails 3.2 through 5.2
+  - Don't test Rails 3.2 through 4.1 against Ruby 2.4 or 2.5 as those versions of Rails will not work with those versions of Ruby
+  - Avoid various deprecation warnings being triggered in the test
+
+## 1.9.1 (March 1, 2018)
+
+Bugfixes:
+  - Address an edge-case test regression caused by Rails 5.1.5 that was causing counts to be off when saving changes from an `after_create` callback
+
+## 1.9.0 (November 29, 2017)
+
+Improvements:
+  - Switch generated migration files to use new hash syntax
+  - Support for Rails 5 migration file format for generated migrations
+
+## 1.8.2 (September 27, 2017)
+
+Bugfixes:
+  - Actually use `batch_size` parameter in `counter_culture_fix_counts` (#200)
+
+## 1.8.1 (September 5, 2017)
+
+Improvements:
+  - Use ActiveRecord version, not Rails version, in `Reconciler`, makeing it possible to use `counter_culture_fix_counts` without Rails
+
 ## 1.8.0 (August 30, 2017)
 
 Improvements:

data/Gemfile

@@ -1,44 +1,9 @@
-source "https://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
+source 'https://rubygems.org'
 
-gem "after_commit_action", "~> 1.0"
-gem "activerecord", ">= 3.0.0"
-gem "activesupport", ">= 3.0.0"
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
-group :development, :test do
-  gem "rake"
+# Specify the gem's dependencies in counter_culture.gemspec
+gemspec
 
-  rails = case ENV["RAILS_VERSION"]
-  when "master"
-    {github: "rails/rails"}
-  when nil, ""
-    ">= 3.1.0"
-  else
-    "~> #{ENV["RAILS_VERSION"]}"
-  end
-  gem "rails", rails
-
-  gem "rspec", "~> 3.0"
-  gem "awesome_print"
-  gem "timecop"
-
-  # to test the integration
-  gem "paranoia"
-  gem "paper_trail"
-end
-
-group :development do
-  gem "rdoc", "~> 3.12"
-  gem "bundler", ">= 1.2.0"
-  gem "jeweler", "~> 2.1"
-end
-
-group :test do
-  gem "sqlite3"
-  gem "rspec-extra-formatters"
-  gem "database_cleaner", ">= 1.1.1"
-end
+# Ensure we have the default DB adapter for testing
+gem 'sqlite3'

data/README.md

@@ -1,4 +1,4 @@
-# counter_culture [![Build Status](https://travis-ci.org/magnusvk/counter_culture.svg)](https://travis-ci.org/magnusvk/counter_culture)
+# counter_culture [![Build Status](https://travis-ci.com/magnusvk/counter_culture.svg)](https://travis-ci.com/magnusvk/counter_culture)
 
 Turbo-charged counter caches for your Rails app. Huge improvements over the Rails standard counter caches:
 
@@ -7,14 +7,20 @@ Turbo-charged counter caches for your Rails app. Huge improvements over the Rail
 * Supports dynamic column names, making it possible to split up the counter cache for different types of objects
 * Can keep a running count, or a running total
 
-Tested against Ruby 2.2.5 and 2.3.1 and against the latest patch releases of Rails 3.2, 4.0, 4.1, 4.2, 5.0 and 5.1.
+Tested against Ruby 2.3.8, 2.4.7, 2.5.6 and 2.6.4 and against the latest patch releases of Rails 4.2, 5.0, 5.1, 5.2 and 6.0.
+
+Please note that -- unlike Rails' built-in counter-caches -- counter_culture does not currently change the behavior of the `.size` method on ActiveRecord associations. If you want to avoid a database query and read the cached value, please use the attribute name containing the counter cache directly.
+```
+product.categories.size  # => will lead to a SELECT COUNT(*) query
+product.categories_count # => will use counter cache without query
+```
 
 ## Installation
 
 Add counter_culture to your Gemfile:
 
 ```ruby
-gem 'counter_culture', '~> 1.0'
+gem 'counter_culture', '~> 2.0'
 ```
 
 Then run `bundle install`
@@ -39,6 +45,8 @@ If you are adding counter caches to existing data, you must add code to [manuall
 
 ### Simple counter-cache
 
+#### Has many association
+
 ```ruby
 class Product < ActiveRecord::Base
   belongs_to :category
@@ -52,6 +60,30 @@ end
 
 Now, the ```Category``` model will keep an up-to-date counter-cache in the ```products_count``` column of the ```categories``` table.
 
+#### Many to many association
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :group_memberships
+  has_many :groups, through: :group_memberships
+end
+
+class Group < ActiveRecord::Base
+  has_many :group_memberships
+  has_many :members, through: :group_memberships, class: "User"
+end
+
+class Membership < ActiveRecord::Base
+  belongs_to :group
+  belongs_to :member, class: "User"
+  counter_culture :group, column_name: "members_count"
+  # If you'd like to also touch the group when `members_count` is updated
+  # counter_culture :group, column_name: "members_count", touch: true
+end
+```
+
+Now, the `Group` model will have an up to date count of its members in the `members_count` column
+
 ### Multi-level counter-cache
 
 ```ruby
@@ -116,7 +148,7 @@ end
 ```ruby
 class Product < ActiveRecord::Base
   belongs_to :category
-  counter_culture :category, column_name: :weight, delta_magnitude: proc { model.product_type == 'awesome' ? 2 : 1 }
+  counter_culture :category, column_name: :weight, delta_magnitude: proc {|model| model.product_type == 'awesome' ? 2 : 1 }
 end
 
 class Category < ActiveRecord::Base
@@ -155,6 +187,8 @@ end
 
 Now, the ```Category``` model will keep the counter cache in ```special_count``` up-to-date. Only products where ```special?``` returns true will affect the special_count.
 
+If you would like to use this with `counter_culture_fix_counts`, make sure to also provide [the `column_names` configuration](#handling-dynamic-column-names).
+
 ### Totaling instead of counting
 
 Instead of keeping a running count, you may want to automatically track a running total.
@@ -216,16 +250,6 @@ You may also specify a custom timestamp column that gets updated only when a par
 
 With this option, any time the `category_counter_cache` changes both the `category_count_changed` and `updated_at` columns will get updated.
 
-### Executing counter cache updates after commit
-
-By default, counter_culture will run counter cache updates inside of the same ActiveRecord transaction that triggered it. (Note that this bevavior [changed from version 0.2.3 to 1.0.0](CHANGELOG.md#100-november-15-2016).) If you would like to run counter cache updates outside of that transaction, for example because you are experiencing [deadlocks with older versions of PostgreSQL](http://mina.naguib.ca/blog/2010/11/22/postgresql-foreign-key-deadlocks.html), you can enable that behavior:
-```ruby
-  counter_culture :category, execute_after_commit: true
-```
-
-Please note that using `execute_after_commit` in conjunction with transactional
-fixtures will lead to your tests no longer seeing updated counter values.
-
 ### Manually populating counter cache values
 
 You will sometimes want to populate counter-cache values from primary data. This is required when adding counter-caches to existing data. It is also recommended to run this regularly (at BestVendor, we run it once a week) to catch any incorrect values in the counter caches.
@@ -234,19 +258,29 @@ You will sometimes want to populate counter-cache values from primary data. This
 Product.counter_culture_fix_counts
 # will automatically fix counts for all counter caches defined on Product
 
-Product.counter_culture_fix_counts except: :category
+Product.counter_culture_fix_counts exclude: :category
 # will automatically fix counts for all counter caches defined on Product, except for the :category relation
 
 Product.counter_culture_fix_counts only: :category
 # will automatically fix counts only on the :category relation on Product
 
-# :except and :only also accept arrays of one level relations
+# :exclude and :only also accept arrays of one level relations
 # if you want to fix counts on a more than one level relation you need to use convention below:
 
 Product.counter_culture_fix_counts only: [[:subcategory, :category]]
 # will automatically fix counts only on the two-level [:subcategory, :category] relation on Product
 
+Product.counter_culture_fix_counts column_name: :reviews_count
+# will automatically fix counts only on the :reviews_count column on Product
+# This allows us to skip the columns that have already been processed. This is useful after running big DB changes that affect only one counter cache column.
+
 # :except and :only also accept arrays
+
+Product.counter_culture_fix_counts verbose: true
+# prints some logs to STDOUT
+
+Product.counter_culture_fix_counts only: :category, where: { categories: { id: 1 } }
+# will automatically fix counts only on the :category with id 1 relation on Product
 ```
 
 The ```counter_culture_fix_counts``` counts method uses batch processing of records to keep the memory consumption low. The default batch size is 1000 but is configurable like so
@@ -272,6 +306,37 @@ Product.counter_culture_fix_counts batch_size: 100
 
 ```counter_culture_fix_counts``` is optimized to minimize the number of queries and runs very quickly.
 
+Similarly to `counter_culture`, it is possible to update the records' timestamps, when fixing counts. If you would like to update the default timestamp field, pass `touch: true` option:
+
+```ruby
+Product.counter_culture_fix_counts touch: true
+```
+
+If you have specified a custom timestamps column, pass its name as the value for the `touch` option:
+
+```ruby
+Product.counter_culture_fix_counts touch: 'category_count_changed'
+```
+
+
+#### Parallelizing fix counter cache in multiple workers
+
+The options start and finish are especially useful if you want multiple workers dealing with the same processing queue. You can make worker 1 handle all the records between id 1 and 9999 and worker 2 handle from 10000 and beyond by setting the :start and :finish option on each worker.
+
+```ruby
+Product.counter_culture_fix_counts start: 10_000
+# will fix counts for all counter caches defined on Product from record 10000 and onwards.
+
+Product.counter_culture_fix_counts finish: 10_000
+# let's process until 10000 records.
+
+Product.counter_culture_fix_counts start: 1000, finish: 2000
+# In worker 1, lets process from 1000 to 2000
+
+Product.counter_culture_fix_counts start: 2001, finish: 3000
+# In worker 2, lets process from 2001 to 3000
+```
+
 #### Handling dynamic column names
 
 Manually populating counter caches with dynamic column names requires additional configuration:
@@ -289,16 +354,45 @@ class Product < ActiveRecord::Base
 end
 ```
 
+You can specify a scope instead of a where condition string for `column_names`:
+
+```ruby
+class Product < ActiveRecord::Base
+  belongs_to :category
+  scope :awesomes, ->{ where "products.product_type = ?", 'awesome' }
+  scope :suckys, ->{ where "products.product_type = ?", 'sucky' }
+
+  counter_culture :category,
+      column_name: proc {|model| "#{model.product_type}_count" },
+      column_names: {
+          Product.awesomes => :awesome_count,
+          Product.suckys => :sucky_count
+      }
+end
+```
+
+If you would like to avoid this configuration and simply skip counter caches with
+dynamic column names, while still fixing those counters on the model that are not
+dynamic, you can pass `skip_unsupported`:
+
+```ruby
+Product.counter_culture_fix_counts skip_unsupported: true
+```
+
 #### Handling over-written, dynamic foreign keys
 
 Manually populating counter caches with dynamically over-written foreign keys (```:foreign_key_values``` option) is not supported. You will have to write code to handle this case yourself.
 
-### Soft-deletes / `paranoia` gem
+### Soft-deletes with `paranoia` or `discard`
+
+This gem will keep counters correctly updated in Rails 4.2 or later when using
+[paranoia](https://github.com/rubysherpas/paranoia) or
+[discard](https://github.com/jhawthorn/discard) for soft-delete support.
+However, to ensure that counts are incremented after a restore you have
+to make sure to set up soft deletion (via `acts_as_paranoid` or
+`include Discard::Model`) before the call to `counter_culture` in your model:
 
-This gem will keep counters correctly updated when using the `paranoia` gem for
-soft-delete support. However, to ensure that counts are incremented after a
-restore you have to make sure that the call to `acts_as_paranoid` comes before
-the call to `counter_culture` in your model:
+#### Paranoia
 
 ```ruby
 class SoftDelete < ActiveRecord::Base
@@ -309,6 +403,33 @@ class SoftDelete < ActiveRecord::Base
 end
 ```
 
+#### Discard
+
+```ruby
+class SoftDelete < ActiveRecord::Base
+  include Discard::Model
+
+  belongs_to :company
+  counter_culture :company
+end
+```
+
+### PaperTrail integration
+
+If you are using the [`paper_trail` gem](https://github.com/airblade/paper_trail)
+and would like new versions to be created when the counter cache columns are
+changed by counter_culture, you can set the `with_papertrail` option:
+
+```ruby
+class Review < ActiveRecord::Base
+  counter_culture :product, with_papertrail: true
+end
+
+class Product < ActiveRecord::Base
+  has_paper_trail
+end
+```
+
 #### Polymorphic associations
 
 counter_culture now supports polymorphic associations of one level only.