paper_trail-bulk_writes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 055ac91334d2baf03ac6070aa705f234296a25eebf790e05e52b7248f2be61b5
+  data.tar.gz: f5739caa8f59629cebd71a0dd16c8c9dafb7fb92e4b45051eddfff9e36e587a6
+SHA512:
+  metadata.gz: 20a07a365217a304a6920df25fdd6cb6d55da74f09d0fe79d33ca86adefb5e2aa140d4b51fc96f77f59cfc0d97eea40abfdcad87943ea0f2faa83ef87967f7c2
+  data.tar.gz: 349d1dd5cc22cfe873d731243540e8bda174d38cfd8893a5ab19edc7a6ddbb7f960dd039bff032b80bf7c163690fddd0bfca2d0196386acef46034b5e0f28a8a

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0
+
+- `PaperTrail::BulkWrites::Model` with `audited_update_all`, `audited_delete_all` and `audited_insert_all`.
+- Honours `only:`, `ignore:`, `skip:`, `meta:` and `versions:` from `has_paper_trail`; sets `item_subtype` for STI.
+- `PaperTrail::BulkWrites.configure { |c| c.batch_size = ... }`.
+- `PaperTrail/BulkWrites/NoBulkWriteOnAuditedModel` RuboCop cop, configured with a `Models:` list; flags `update_all`, `delete_all`, `insert_all`, `insert_all!` and `upsert_all`.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 TODO: Write your name
+
+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.md

@@ -0,0 +1,140 @@
+# Paper Trail Bulk Writes
+
+PaperTrail versions for `update_all`, `delete_all` and `insert_all`.
+
+## The problem
+
+[PaperTrail](https://github.com/paper-trail-gem/paper_trail) records versions from ActiveRecord callbacks. Bulk writes skip callbacks, so they leave no audit trail:
+
+```ruby
+Shift.where(id: ids).update_all(status: :filled)   # no version row
+Shift.where(id: ids).delete_all                    # no version row
+Shift.insert_all(rows)                             # no version row
+```
+
+The usual workaround is `find_each(&:update!)`, which is N queries and N version inserts. PaperTrail's maintainers have [declined to add bulk support](https://github.com/paper-trail-gem/paper_trail/issues/1533).
+
+## What this gem does
+
+```ruby
+Shift.where(id: ids).audited_update_all(attributes: { status: :filled })
+Shift.where(id: ids).audited_delete_all
+Shift.audited_insert_all(rows)
+```
+
+Each call runs the bulk write and inserts one version row per record, in the same transaction, using two statements per batch instead of 2N. The version rows match what the callback path would have written:
+
+- `object_changes` holds `[before, after]` per column, read from the database before the write (or from the loaded records, if you pass an array).
+- `only:`, `ignore:` and `skip:` from `has_paper_trail` are honoured.
+- `meta:` symbols and lambdas are resolved per record.
+- A custom `versions: { class_name: }` is written to instead of `PaperTrail::Version`.
+- `item_subtype` is set for single-table-inheritance models.
+- `whodunnit` defaults to `PaperTrail.request.whodunnit`.
+- `audited_update_all` touches `updated_at` like `update!` does (pass `touch: false` to skip).
+
+## Install
+
+```ruby
+gem 'paper_trail-bulk_writes'
+```
+
+```ruby
+class Shift < ApplicationRecord
+  include PaperTrail::BulkWrites::Model
+
+  has_paper_trail
+end
+```
+
+## Usage
+
+```ruby
+# Relation or array of loaded records; returns the number of rows written.
+Shift.where(company_id: company.id).audited_update_all(attributes: { archived: true })
+Shift.where(id: ids).audited_update_all(attributes: { status: :filled }, touch: false, whodunnit: admin.id)
+
+# Returns the number of rows deleted.
+Shift.where(id: ids).audited_delete_all
+
+# Returns the new ids, in input order. Rows are inserted with insert_all!.
+Shift.audited_insert_all([{ name: 'a', status: 'draft' }, { name: 'b', status: 'draft' }])
+```
+
+Batches default to 1,000 rows:
+
+```ruby
+# config/initializers/paper_trail_bulk_writes.rb
+PaperTrail::BulkWrites.configure do |config|
+  config.batch_size = 500
+end
+```
+
+### Semantics worth knowing
+
+- **Loaded records are written by id**, exactly as `update!` would be, even if they no longer match the scope they were loaded from. An unloaded relation re-applies its predicate per batch, so a row that stopped matching is skipped.
+- **Previous values come from the loaded record** when you pass an array, so if the row changed underneath you the version reports the stale value — the same thing PaperTrail's dirty tracking does.
+- **A touch-only update writes a version** whose `object_changes` is just `updated_at`, like `touch` does. Ignore `updated_at` in `has_paper_trail` (or `PaperTrail.config.has_paper_trail_defaults`) if you don't want that.
+- **Data and versions are one transaction.** If the version insert fails, the data write rolls back, and vice versa.
+
+## RuboCop cop
+
+The gem ships a cop that flags bare bulk writes on models you list as audited:
+
+```yaml
+# .rubocop.yml
+require:
+  - paper_trail/bulk_writes/rubocop
+
+PaperTrail/BulkWrites/NoBulkWriteOnAuditedModel:
+  Models:
+    - Shift
+    - Timesheet
+    - Tasks::Task
+```
+
+```
+Shift.where(id: ids).update_all(status: :filled)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `update_all` on Shift skips callbacks, so PaperTrail records no version. ...
+```
+
+It catches `update_all`, `delete_all`, `insert_all`, `insert_all!` and `upsert_all` when the call chain starts from a listed constant. It does not see relations held in locals or reached through associations (`scope.update_all`, `company.shifts.delete_all`) — the receiver has to be the model.
+
+To keep `Models:` honest, add a spec that fails when a model gains `has_paper_trail` without being listed:
+
+```ruby
+RSpec.describe 'audited models are listed for the bulk-write cop' do
+  it 'lists every model in app/models with has_paper_trail' do
+    config = RuboCop::ConfigLoader.load_file('.rubocop.yml')
+    listed = config['PaperTrail/BulkWrites/NoBulkWriteOnAuditedModel']['Models'].sort
+
+    on_disk = Dir[Rails.root.join('app/models/**/*.rb')].filter_map do |path|
+      next unless File.foreach(path).any? { |line| line.match?(/^\s*has_paper_trail\b/) }
+
+      path.delete_prefix(Rails.root.join('app/models/').to_s).delete_suffix('.rb').camelize
+    end.sort
+
+    expect(listed).to eq(on_disk)
+  end
+end
+```
+
+## Limitations
+
+- **Postgres and SQLite (3.35+) only.** `audited_insert_all` relies on `INSERT ... RETURNING`. MySQL is untested.
+- **`object` is not written**, only `object_changes`. `version.reify` won't work on bulk-written versions; use `where_object_changes` and friends.
+- **`has_paper_trail on:`** is not consulted — every bulk write is versioned.
+- Requires Ruby 3.2+, ActiveRecord 7.1+, PaperTrail 15+.
+
+## Development
+
+```sh
+bundle install
+bundle exec rspec                                   # SQLite in memory
+DB=postgres DATABASE_URL=postgres://localhost/paper_trail_bulk_writes_test bundle exec rspec
+bundle exec appraisal install && bundle exec appraisal rspec   # every Rails × PaperTrail combination
+bundle exec rubocop
+```
+
+## License
+
+MIT. Extracted from production code at [Florence](https://www.florence.co.uk).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/config/default.yml

@@ -0,0 +1,7 @@
+PaperTrail/BulkWrites/NoBulkWriteOnAuditedModel:
+  Description: >-
+    Bulk writes skip callbacks, so PaperTrail records nothing. Use the audited_* helpers
+    on models that have has_paper_trail.
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Models: []

data/lib/paper_trail/bulk_writes/adapter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    class Adapter
+      def initialize(model, whodunnit:)
+        @model = model
+        @whodunnit = whodunnit
+      end
+
+      def tracked(candidates)
+        tracked = candidates.map(&:to_s) - ignored
+        only.any? ? tracked & only : tracked
+      end
+
+      def meta
+        @meta ||= versioned? ? model.paper_trail_options[:meta].to_h : {}
+      end
+
+      def meta_for(record)
+        meta.transform_values do |value|
+          next value.call(record) if value.respond_to?(:call)
+          next record.send(value) if value.is_a?(Symbol)
+
+          value
+        end
+      end
+
+      def build_row(id:, event:, object_changes:, extra:, subtype: nil)
+        row = {
+          item_type: model.base_class.name,
+          item_id: id,
+          event: event,
+          whodunnit: whodunnit,
+          object_changes: serialize(object_changes),
+          created_at: Time.current
+        }
+        row[:item_subtype] = subtype || default_subtype if subtype_column?
+        row.merge(extra)
+      end
+
+      def insert(rows)
+        return unless versioned? && rows.any?
+
+        version_class.insert_all(rows)
+      end
+
+      private
+
+      attr_reader :model, :whodunnit
+
+      def versioned?
+        model.respond_to?(:paper_trail_options)
+      end
+
+      def version_class
+        model.reflect_on_association(model.versions_association_name).klass
+      end
+
+      def subtype_column?
+        versioned? && version_class.column_names.include?('item_subtype')
+      end
+
+      def default_subtype
+        model.name unless model == model.base_class
+      end
+
+      def serialize(object_changes)
+        return object_changes if !versioned? || json_column?
+
+        PaperTrail.serializer.dump(object_changes)
+      end
+
+      def json_column?
+        return @json_column if defined?(@json_column)
+
+        @json_column = %i[json jsonb].include?(version_class.type_for_attribute('object_changes').type)
+      end
+
+      def ignored
+        @ignored ||= versioned? ? option_names(:ignore) + option_names(:skip) : []
+      end
+
+      def only
+        @only ||= versioned? ? option_names(:only) : []
+      end
+
+      def option_names(key)
+        Array(model.paper_trail_options[key]).grep_v(Hash).map(&:to_s)
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    class Configuration
+      DEFAULT_BATCH_SIZE = 1_000
+
+      attr_accessor :batch_size
+
+      def initialize
+        @batch_size = DEFAULT_BATCH_SIZE
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/delete.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    class Delete
+      include Versioned
+      include Scoped
+
+      def initialize(scope:, whodunnit: nil, batch_size: nil)
+        @scope = scope
+        @whodunnit = whodunnit
+        @batch_size = batch_size || default_batch_size
+      end
+
+      def call
+        return 0 if model.nil?
+
+        written = 0
+        rows.each_batch(batch_size) { |batch| written += write(batch) }
+        written
+      end
+
+      private
+
+      attr_reader :scope, :whodunnit, :batch_size
+
+      def write(batch)
+        ids = batch.map(&:first)
+        return 0 if ids.empty?
+
+        model.transaction do
+          model.where(id: ids).delete_all
+          adapter.insert(batch.map { |id, previous, extra| version_row(id, previous, extra) })
+        end
+
+        ids.size
+      end
+
+      def version_row(id, previous, extra)
+        adapter.build_row(
+          id: id,
+          event: 'destroy',
+          object_changes: previous.transform_values { |was| [was, nil] },
+          extra: extra
+        )
+      end
+
+      def tracked
+        @tracked ||= adapter.tracked(model.column_names)
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/insert.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    class Insert
+      include Versioned
+
+      def initialize(model:, rows:, whodunnit: nil, batch_size: nil)
+        @model = model
+        @rows = rows
+        @whodunnit = whodunnit
+        @batch_size = batch_size || default_batch_size
+      end
+
+      def call
+        return [] if rows.empty?
+
+        model.transaction { rows.each_slice(batch_size).flat_map { |batch| write(batch) } }
+      end
+
+      private
+
+      attr_reader :model, :rows, :whodunnit, :batch_size
+
+      def tracked
+        @tracked ||= adapter.tracked(model.column_names) - ['id']
+      end
+
+      def write(batch)
+        inserted = model.insert_all!(batch, returning: ['id', *tracked]).to_a
+        changed = changed_columns(batch)
+        adapter.insert(inserted.map { |attributes| version_row(attributes, changed) })
+        inserted.pluck('id')
+      end
+
+      def changed_columns(batch)
+        supplied = batch.flat_map { |row| row.keys.map(&:to_s) }.uniq
+        (supplied + %w[id created_at updated_at]) & ['id', *tracked]
+      end
+
+      def version_row(attributes, changed)
+        adapter.build_row(
+          id: attributes['id'],
+          event: 'create',
+          object_changes: object_changes_for(attributes.slice(*changed)),
+          extra: adapter.meta.any? ? adapter.meta_for(model.new(attributes)) : {},
+          subtype: attributes[model.inheritance_column]
+        )
+      end
+
+      def object_changes_for(attributes)
+        attributes.compact.to_h { |name, value| [name, [nil, model.type_for_attribute(name).cast(value)]] }
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/model.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    module Model
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def audited_insert_all(rows, whodunnit: PaperTrail.request.whodunnit)
+          Insert.call(model: self, rows: rows, whodunnit: whodunnit)
+        end
+
+        def audited_update_all(attributes:, whodunnit: PaperTrail.request.whodunnit, touch: true)
+          Update.call(scope: all, attributes: attributes, whodunnit: whodunnit, touch: touch)
+        end
+
+        def audited_delete_all(whodunnit: PaperTrail.request.whodunnit)
+          Delete.call(scope: all, whodunnit: whodunnit)
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/row_source.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    class RowSource
+      def initialize(scope, tracked:, adapter:)
+        @scope = scope
+        @tracked = tracked
+        @adapter = adapter
+      end
+
+      def each_batch(batch_size)
+        if scope.is_a?(ActiveRecord::Relation) && !scope.loaded?
+          scope.in_batches(of: batch_size) { |relation| yield(rows_for_relation(relation)) }
+        else
+          scope.to_a.each_slice(batch_size) { |records| yield(loaded_rows(records)) }
+        end
+      end
+
+      private
+
+      attr_reader :scope, :tracked, :adapter
+
+      def rows_for_relation(relation)
+        return loaded_rows(relation.to_a) if adapter.meta.any?
+
+        relation.pluck(:id, *tracked).map do |id, *values|
+          [id, tracked.zip(values).to_h, {}]
+        end
+      end
+
+      def loaded_rows(records)
+        records.map do |record|
+          [record.id, tracked.index_with { |name| record.read_attribute(name) }, adapter.meta_for(record)]
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/rubocop.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative '../../rubocop/cop/paper_trail/bulk_writes/no_bulk_write_on_audited_model'
+
+module PaperTrail
+  module BulkWrites
+    module RuboCop
+      CONFIG_DEFAULT = File.expand_path('../../../config/default.yml', __dir__)
+
+      class Inject
+        def self.defaults!
+          hash = ::RuboCop::ConfigLoader.send(:load_yaml_configuration, CONFIG_DEFAULT)
+          config = ::RuboCop::Config.new(hash, CONFIG_DEFAULT)
+          puts "configuration from #{CONFIG_DEFAULT}" if ::RuboCop::ConfigLoader.debug?
+          config = ::RuboCop::ConfigLoader.merge_with_default(config, CONFIG_DEFAULT)
+          ::RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+        end
+      end
+    end
+  end
+end
+
+PaperTrail::BulkWrites::RuboCop::Inject.defaults!

data/lib/paper_trail/bulk_writes/scoped.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    module Scoped
+      private
+
+      def model
+        return @model if defined?(@model)
+
+        @model = BulkWrites.model_for(scope)
+      end
+
+      def rows
+        RowSource.new(scope, tracked: tracked, adapter: adapter)
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/update.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    class Update
+      include Versioned
+      include Scoped
+
+      def initialize(scope:, attributes:, whodunnit: nil, batch_size: nil, touch: true)
+        @scope = scope
+        @attributes = attributes.stringify_keys
+        @whodunnit = whodunnit
+        @batch_size = batch_size || default_batch_size
+        @touch = touch
+      end
+
+      def call
+        return 0 if model.nil?
+
+        written = 0
+        rows.each_batch(batch_size) { |batch| written += write(batch) }
+        written
+      end
+
+      private
+
+      attr_reader :scope, :attributes, :whodunnit, :batch_size, :touch
+
+      def write(batch)
+        ids = batch.map(&:first)
+        return 0 if ids.empty?
+
+        model.transaction do
+          model.where(id: ids).update_all(write_attributes)
+          adapter.insert(batch.filter_map { |id, previous, extra| version_row(id, previous, extra) })
+        end
+
+        ids.size
+      end
+
+      def write_attributes
+        @write_attributes ||= if touch
+                                attributes.merge('updated_at' => model.current_time_from_proper_timezone)
+                              else
+                                attributes
+                              end
+      end
+
+      def version_row(id, previous, extra)
+        changes = object_changes_for(previous)
+        return if changes.empty?
+
+        adapter.build_row(id: id, event: 'update', object_changes: changes, extra: extra)
+      end
+
+      def tracked
+        @tracked ||= adapter.tracked(write_attributes.keys)
+      end
+
+      def new_values
+        @new_values ||= tracked.index_with { |name| model.type_for_attribute(name).cast(write_attributes[name]) }
+      end
+
+      def object_changes_for(previous)
+        tracked.each_with_object({}) do |name, changes|
+          was = previous[name]
+          now = new_values[name]
+          changes[name] = [was, now] unless was == now
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    VERSION = '0.1.0'
+  end
+end

data/lib/paper_trail/bulk_writes/versioned.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module BulkWrites
+    module Versioned
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def call(...)
+          new(...).call
+        end
+      end
+
+      private
+
+      def adapter
+        @adapter ||= Adapter.new(model, whodunnit: whodunnit)
+      end
+
+      def default_batch_size
+        BulkWrites.configuration.batch_size
+      end
+    end
+  end
+end

data/lib/paper_trail/bulk_writes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'paper_trail'
+
+require_relative 'bulk_writes/version'
+require_relative 'bulk_writes/configuration'
+require_relative 'bulk_writes/adapter'
+require_relative 'bulk_writes/row_source'
+require_relative 'bulk_writes/versioned'
+require_relative 'bulk_writes/scoped'
+require_relative 'bulk_writes/insert'
+require_relative 'bulk_writes/update'
+require_relative 'bulk_writes/delete'
+require_relative 'bulk_writes/model'
+
+module PaperTrail
+  module BulkWrites
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+
+      def model_for(scope)
+        scope.is_a?(ActiveRecord::Relation) ? scope.klass : scope.first&.class
+      end
+    end
+  end
+end

data/lib/rubocop/cop/paper_trail/bulk_writes/no_bulk_write_on_audited_model.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module PaperTrail
+      module BulkWrites
+        # Flags update_all / delete_all / insert_all / upsert_all on a model listed in `Models`.
+        # Those writes skip callbacks, so PaperTrail records nothing. Use the audited_* helpers
+        # from PaperTrail::BulkWrites::Model instead.
+        #
+        # @example
+        #   # bad
+        #   Shift.where(id: ids).update_all(status: :filled)
+        #   Shift.where(id: ids).delete_all
+        #   Shift.insert_all(rows)
+        #
+        #   # good
+        #   Shift.where(id: ids).audited_update_all(attributes: { status: :filled })
+        #   Shift.where(id: ids).audited_delete_all
+        #   Shift.audited_insert_all(rows)
+        class NoBulkWriteOnAuditedModel < Base
+          MSG = '`%<method>s` on %<model>s skips callbacks, so PaperTrail records no version. ' \
+                'Use `%<replacement>s` (include `PaperTrail::BulkWrites::Model` on the model), ' \
+                'or `%<callback_alternative>s` when you want the record callbacks to run too.'
+
+          REPLACEMENTS = {
+            update_all: 'audited_update_all',
+            delete_all: 'audited_delete_all',
+            insert_all: 'audited_insert_all',
+            insert_all!: 'audited_insert_all',
+            upsert_all: 'audited_insert_all'
+          }.freeze
+
+          CALLBACK_ALTERNATIVES = {
+            update_all: 'each(&:update!)',
+            delete_all: 'destroy_all',
+            insert_all: 'create!',
+            insert_all!: 'create!',
+            upsert_all: 'create!'
+          }.freeze
+
+          RESTRICT_ON_SEND = REPLACEMENTS.keys.freeze
+
+          def on_send(node)
+            model = audited_chain_root(node)
+            return unless model
+
+            add_offense(node, message: message_for(node.method_name, model))
+          end
+
+          private
+
+          def message_for(method, model)
+            format(
+              MSG,
+              method: method,
+              model: model,
+              replacement: REPLACEMENTS.fetch(method),
+              callback_alternative: CALLBACK_ALTERNATIVES.fetch(method)
+            )
+          end
+
+          def audited_chain_root(node)
+            receiver = node.receiver
+
+            while receiver
+              return unless receiver.send_type? || receiver.const_type?
+
+              break if receiver.const_type?
+
+              receiver = receiver.receiver
+            end
+
+            return unless receiver
+
+            name = receiver.source.delete_prefix('::')
+            name if audited_models.include?(name)
+          end
+
+          def audited_models
+            @audited_models ||= Array(cop_config['Models']).map(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: paper_trail-bulk_writes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Robinson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: paper_trail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '15'
+description: |
+  Bulk ActiveRecord writes skip callbacks, so PaperTrail records nothing. This gem adds
+  audited_update_all, audited_delete_all and audited_insert_all, which run the bulk write
+  and insert one version row per record in the same transaction, honouring the model's
+  only:, ignore:, skip:, meta: and versions: options. Ships a RuboCop cop that flags
+  bare bulk writes on audited models.
+email:
+- samrobinsonwork@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/default.yml
+- lib/paper_trail/bulk_writes.rb
+- lib/paper_trail/bulk_writes/adapter.rb
+- lib/paper_trail/bulk_writes/configuration.rb
+- lib/paper_trail/bulk_writes/delete.rb
+- lib/paper_trail/bulk_writes/insert.rb
+- lib/paper_trail/bulk_writes/model.rb
+- lib/paper_trail/bulk_writes/row_source.rb
+- lib/paper_trail/bulk_writes/rubocop.rb
+- lib/paper_trail/bulk_writes/scoped.rb
+- lib/paper_trail/bulk_writes/update.rb
+- lib/paper_trail/bulk_writes/version.rb
+- lib/paper_trail/bulk_writes/versioned.rb
+- lib/rubocop/cop/paper_trail/bulk_writes/no_bulk_write_on_audited_model.rb
+homepage: https://github.com/Sam-Robin/paper_trail-bulk_writes
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Sam-Robin/paper_trail-bulk_writes
+  source_code_uri: https://github.com/Sam-Robin/paper_trail-bulk_writes
+  changelog_uri: https://github.com/Sam-Robin/paper_trail-bulk_writes/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: PaperTrail versions for update_all, delete_all and insert_all.
+test_files: []