paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/diagnostics.rb

@@ -91,7 +91,7 @@ module PaperTrailDiff
       selected = traversal.selected_reflections(model_class)
       inspect_targets(selected)
       inspect_checkpoint_timestamp(model_class)
-      inspect_habtm(selected)
+      inspect_habtm(model_class, selected)
       DiagnosticReport.new(issues: @issues)
     end
 
@@ -126,14 +126,32 @@ module PaperTrailDiff
       end
     end
 
-    #: (Array[Array[untyped]]) -> void
-    def inspect_habtm(selected)
-      paths = selected.filter_map do |path, reflection|
-        path if reflection.macro == :has_and_belongs_to_many
-      end
-      return if paths.empty?
+    #: (untyped, Array[Array[untyped]]) -> void
+    def inspect_habtm(model_class, selected)
+      habtm = selected.select { |_, reflection| reflection.macro == :has_and_belongs_to_many }
+      return if habtm.empty?
+
+      inspect_transaction_metadata(habtm.map(&:first))
+      inspect_shared_transactions(model_class, habtm)
+    end
 
-      inspect_transaction_metadata(paths)
+    # PT-AT does not record which owner a HABTM member belongs to, so a
+    # transaction that more than one owner recorded members in cannot be read.
+    #: (untyped, Array[Array[untyped]]) -> void
+    def inspect_shared_transactions(model_class, habtm)
+      versions = [@from_version, @to_version].select do |version|
+        version.respond_to?(:transaction_id) && version.transaction_id
+      end
+      habtm.each do |path, reflection|
+        owners = HabtmTransactionOwners.new(model_class, reflection)
+        versions.each do |version|
+          next unless owners.ambiguous?(version.transaction_id)
+
+          add_error(:habtm_transaction_shared,
+                    'HABTM endpoint shares its transaction with another owner of the association',
+                    path, version.id)
+        end
+      end
     end
 
     #: () -> void

data/lib/paper_trail_diff/direct_record_state_loader.rb

@@ -45,13 +45,22 @@ module PaperTrailDiff
 
     #: (untyped) -> bool
     def plain_model?(model)
-      !model.primary_key.is_a?(Array) && !model.default_scopes? &&
+      !model.primary_key.is_a?(Array) && !scope_assigns_attributes?(model) &&
         model._initialize_callbacks.empty? &&
         %i[initialize attributes []= write_attribute id].all? do |name|
           framework_class?(model.instance_method(name).owner)
         end
     end
 
+    # A default scope's equality conditions are assigned to every new record,
+    # through the model's writers, before a reified version's attributes are.
+    # A subclass's own type is assigned with or without one.
+    #: (untyped) -> bool
+    def scope_assigns_attributes?(model)
+      model.default_scopes? &&
+        model.default_scoped.scope_for_create != model.unscoped.scope_for_create
+    end
+
     #: (untyped) -> bool
     def plain_attributes?(model)
       return false if encrypted?(model)

data/lib/paper_trail_diff/errors.rb

@@ -58,7 +58,8 @@ module PaperTrailDiff
   # Raised when association comparison is requested without an available PT-AT setup.
   class AssociationTrackingUnavailableError < Error; end
 
-  # Raised when recorded PT-AT metadata cannot reliably reconstruct a selected association.
+  # Raised when recorded PT-AT metadata cannot reliably reconstruct a selected association,
+  # or a polymorphic type names no class.
   class IncompleteAssociationHistoryError < Error; end
 
   # Raised when current-ended activity cannot be reconstructed for a selected association.

data/lib/paper_trail_diff/habtm_transaction_owners.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # PT-AT records HABTM members under a transaction id and the association's
+  # name, with nothing naming the record they belong to. When more than one
+  # record that can own that name saved a version in the transaction, their
+  # members are mixed together and none of them can be read back.
+  class HabtmTransactionOwners
+    #: (untyped, untyped) -> void
+    def initialize(owner_class, reflection)
+      @versions = owner_class.paper_trail.version_class
+      @associations = owner_class.paper_trail.version_association_class
+      @name = reflection.name.to_s
+      @owner_types = {} #: Hash[String, bool]
+    end
+
+    # The given transactions (one id or several) in which more than one
+    # possible owner saved a version, as strings.
+    #: (untyped) -> Array[String]
+    def shared(transaction_ids)
+      items = @versions.where(transaction_id: transaction_ids).distinct
+                       .pluck(:transaction_id, :item_type, :item_id)
+      owners = items.select { |_, type, _| owner_type?(type) }
+      owners.group_by { |transaction_id, _, _| transaction_id.to_s }
+            .filter_map { |transaction_id, rows| transaction_id if rows.size > 1 }
+    end
+
+    # Members recorded in a shared transaction cannot be told apart. With no
+    # members recorded, every owner had none, so that reads correctly.
+    #: (untyped) -> bool
+    def ambiguous?(transaction_id)
+      shared(transaction_id).any? &&
+        @associations.exists?(version_id: transaction_id, foreign_key_name: @name)
+    end
+
+    #: (untyped) -> void
+    def ensure_single_owner!(transaction_id)
+      return unless ambiguous?(transaction_id)
+
+      message = "HABTM history is ambiguous for #{@name} at transaction #{transaction_id}: " \
+                "more than one record with a #{@name} association saved a version in it, " \
+                'and PT-AT does not record which members belong to which record'
+      raise IncompleteAssociationHistoryError, message
+    end
+
+    private
+
+    # @rbs @versions: untyped
+    # @rbs @associations: untyped
+    # @rbs @name: String
+    # @rbs @owner_types: Hash[String, bool]
+
+    # Versions name the base class, so a HABTM declared on a subclass counts.
+    # A type that names no model may have recorded members when it existed.
+    #: (String) -> bool
+    def owner_type?(type)
+      @owner_types.fetch(type) do
+        model_class = AssociationTraversal.named_class(type)
+        @owner_types[type] =
+          !model_class.respond_to?(:reflect_on_association) ||
+          [model_class, *model_class.descendants].any? do |candidate|
+            candidate.reflect_on_association(@name)&.macro == :has_and_belongs_to_many
+          end
+      end
+    end
+  end
+end

data/lib/paper_trail_diff/historical_association_reifier.rb

@@ -37,7 +37,7 @@ module PaperTrailDiff
       reified[reflection.name] = true
       case reflection.macro
       when :belongs_to
-        reifier(:BelongsTo).reify(reflection, record, options, @transaction_id)
+        reify_belongs_to(record, reflection)
       when :has_one
         reifier(:HasOne).reify(reflection, record, options, @transaction_id)
       when :has_many
@@ -47,6 +47,26 @@ module PaperTrailDiff
       end
     end
 
+    #: (untyped, untyped) -> void
+    def reify_belongs_to(record, reflection)
+      ensure_versioned_target!(record, reflection) if reflection.polymorphic?
+      reifier(:BelongsTo).reify(reflection, record, options, @transaction_id)
+    end
+
+    # A polymorphic target's class is known only from the record's type
+    # column, so TraversalPreparer cannot check it is versioned up front.
+    #: (untyped, untyped) -> void
+    def ensure_versioned_target!(record, reflection)
+      model_class = AssociationTraversal.belongs_to_target(reflection, record)
+      return if model_class.nil? || Support.versioned?(model_class)
+
+      raise UnversionedAssociationError,
+            "association #{record.class.name}##{reflection.name} cannot be compared " \
+            "historically: it points at #{model_class.name}, which is not versioned. Add " \
+            "`has_paper_trail` to #{model_class.name}, or mirror the fields you need onto a " \
+            'model that has it.'
+    end
+
     #: (untyped, untyped) -> void
     def reify_has_many(record, reflection)
       if reflection.options[:through]
@@ -70,7 +90,7 @@ module PaperTrailDiff
     #: (untyped, untyped) -> void
     def reify_through(record, reflection)
       source = reflection.source_reflection
-      if source.belongs_to?
+      if pt_at_source?(reflection)
         reifier(:HasManyThrough).reify(reflection, record, options, @transaction_id)
         return
       end
@@ -81,9 +101,17 @@ module PaperTrailDiff
       association.loaded!
     end
 
+    # PT-AT's belongs_to source ignores `source_type:` and reads targets by id
+    # alone, so a typed through walks its join records instead.
+    #: (untyped) -> bool
+    def pt_at_source?(reflection)
+      reflection.source_reflection.belongs_to? && !reflection.options[:source_type]
+    end
+
     #: (untyped, untyped, untyped) -> Array[untyped]
     def through_members(record, reflection, source)
       joins = Array(record.public_send(reflection.through_reflection.name)) #: Array[untyped]
+      joins = joins.select { |join| AssociationTraversal.source_type_join?(reflection, join) }
       joins.flat_map do |join|
         reify_association(join, source)
         Array(join.public_send(source.name))
@@ -96,6 +124,8 @@ module PaperTrailDiff
         message = 'HABTM reconstruction requires a transaction-backed endpoint version'
         raise IncompleteAssociationHistoryError, message
       end
+      HabtmTransactionOwners.new(record.class, reflection)
+                            .ensure_single_owner!(@habtm_transaction_id)
 
       paper_trail = Object.const_get(:PaperTrail) #: untyped
       target_versioned = paper_trail.request.enabled_for_model?(reflection.klass)

data/lib/paper_trail_diff/historical_snapshot_store.rb

@@ -34,12 +34,8 @@ module PaperTrailDiff
       end
 
       @prepared_history = PreparedHistoryLoader.new(
-        record,
-        root_versions: root_versions,
-        start_at: start_at,
-        end_at: end_at,
-        tree: @tree,
-        traversal: @traversal
+        record, root_ids: [record.id], root_versions: root_versions, start_at: start_at,
+                end_at: end_at, tree: @tree, traversal: @traversal, live_records: []
       ).call
     end
 
@@ -52,8 +48,9 @@ module PaperTrailDiff
       end
     end
 
-    # Missing roots have no live graph to collect. Reading their associations
-    # here would issue a query per root and seed nonexistent rows as live state.
+    # Missing roots, and roots compared only between versions, have no live
+    # graph to collect. Reading their associations here would issue a query
+    # per root and seed nonexistent rows as live state.
     #: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
     def prepare_deleted_batch(records, root_versions, start_at: nil, end_at: nil)
       return if @tree.empty? || records.empty? || root_versions.empty?
@@ -175,7 +172,7 @@ module PaperTrailDiff
 
     #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
     def snapshot_from_version(root_version, context_version, tree:, normalizer:)
-      model_class = Endpoint.model_class(root_version)
+      model_class = RecordedClass.for(root_version)
       @preparer.call(model_class, historical: true)
       @traversal.ensure_habtm_history!(model_class, root_version)
       handled, snapshot = @prepared_snapshotter.call(

data/lib/paper_trail_diff/live_endpoint_batch_loader.rb

@@ -44,7 +44,9 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped], AssociationTree) -> void
     def preload_model_tree(model_class, records, tree)
-      batch, individual = selected_reflections(model_class, tree).partition do |reflection, _|
+      reflections = selected_reflections(model_class, tree)
+      resolve_polymorphic_targets(records, reflections)
+      batch, individual = reflections.partition do |reflection, _|
         batch_safe?(records.fetch(0), reflection)
       end
       preload_batch(records, batch.map { |reflection, _| reflection.name })
@@ -62,6 +64,15 @@ module PaperTrailDiff
       end
     end
 
+    # Active Record raises a bare NameError for a type that names no class, so
+    # each type is resolved first to raise one that names the record.
+    #: (Array[untyped], Array[[untyped, AssociationTree]]) -> void
+    def resolve_polymorphic_targets(records, reflections)
+      reflections.map(&:first).select(&:polymorphic?).each do |reflection|
+        records.each { |record| AssociationTraversal.belongs_to_target(reflection, record) }
+      end
+    end
+
     #: (Array[untyped], Array[[untyped, AssociationTree]], individually: bool) -> void
     def preload_subtrees(records, reflections, individually:)
       reflections.each do |reflection, subtree|
@@ -90,16 +101,38 @@ module PaperTrailDiff
       active_record.const_get(:Associations).const_get(:Preloader)
     end
 
+    # The preloader applies a limit or offset to all owners' records at once,
+    # not to each owner's, so such an association is loaded per record. A
+    # has_one is no exception. Through a part with a limit, an offset or a
+    # has_one cut, the preloader keeps what the part alone would load, while
+    # the through's own query keeps the part's conditions only.
     #: (untyped, untyped) -> bool
     def batch_safe?(record, reflection)
       scope = reflection.scope
       return false if scope && !scope.arity.zero?
-      return true unless reflection.collection?
+      return true unless reflection.collection? || reflection.has_one?
+      return false if cut_part?(reflection)
 
       relation = record.association(reflection.name).scope
       relation.limit_value.nil? && relation.offset_value.nil?
     end
 
+    #: (untyped) -> bool
+    def cut_part?(reflection)
+      reflection.collection? &&
+        (ScopeCondition.ranked_parts?(reflection) || through_parts(reflection).any?(&:has_one?))
+    end
+
+    # Every part a through passes, at any depth.
+    #: (untyped) -> Array[untyped]
+    def through_parts(reflection)
+      return [] unless reflection.through_reflection?
+
+      [reflection.through_reflection, reflection.source_reflection].flat_map do |part|
+        [part, *through_parts(part)]
+      end
+    end
+
     #: (Array[untyped], untyped) -> Array[untyped]
     def load_individually(records, reflection)
       unique_records(records.flat_map do |record|

data/lib/paper_trail_diff/live_graph_collector.rb

@@ -36,7 +36,7 @@ module PaperTrailDiff
         subtree = tree.child(reflection.name)
         next unless subtree
 
-        child_path = Support.association_path(path, reflection.name.to_s)
+        child_path = Support.association_path(path, reflection.name)
         collect(children_for(records, reflection), subtree, path: child_path, into: into)
       end
     end

data/lib/paper_trail_diff/paper_trail_adapter.rb

@@ -38,8 +38,9 @@ module PaperTrailDiff
         if @association_tree.empty?
           Engine.compare(snapshot_for_endpoint(from_endpoint), snapshot_for_endpoint(to_endpoint))
         else
-          # Prepared history orders versions that share a timestamp; reading
-          # associations straight from PT-AT would resolve them by time alone.
+          # Prepared history orders versions that share a timestamp and finds
+          # children that later moved away; reading associations straight from
+          # PT-AT would resolve them by time alone and miss those children.
           comparison_batch([{ from: from_endpoint, to: to_endpoint }],
                            preparer: @traversal_preparer.method(:call)).call.values.fetch(0)
         end
@@ -133,7 +134,7 @@ module PaperTrailDiff
     #: (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?historical_filter: untyped, ?max_filter_versions: Integer, ?include_deleted: bool) -> ScopedAnalysis
     def analyze_scope(scope, limit:, within:, activity: false, version_scope: nil, close_on: nil, snapshots: false, group: nil, historical_filter: nil, max_filter_versions: HistoricalFilter::DEFAULT_VERSION_LIMIT, include_deleted: false) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
       ActivityGrouping.validate!(group, activity: activity, snapshots: snapshots)
-      @batch_safety.call(scope.all.model) if scope.respond_to?(:all) && scope.respond_to?(:where)
+      check_scope(scope, activity)
       # @type var options: report_options
       options = { within: within, activity: activity, version_scope: version_scope,
                   close_on: close_on, snapshots: snapshots, group: group }
@@ -143,18 +144,32 @@ module PaperTrailDiff
                analyzer: ->(records) { analyze_many(records, **options, within: within) },
                deleted_analyzer: lambda { |identities|
                  analyze_deleted(scope.all.model, identities, options)
-               }
+               },
+               # Checkpoints compare a root's own versions, so only activity can
+               # report a window in which just its associations changed.
+               activity_tree: (@association_tree if activity)
       ).call
     end
 
     private
 
+    # Selecting by activity reads association history, so it must be available
+    # before the first selection query rather than once analysis starts.
+    #: (untyped, bool) -> void
+    def check_scope(scope, activity)
+      return unless scope.respond_to?(:all) && scope.respond_to?(:where)
+
+      @batch_safety.call(scope.all.model)
+      @traversal_preparer.call(scope.all.model, historical: true) if activity
+    end
+
     #: (Array[comparison_input], preparer: untyped) -> ComparisonBatch
     def comparison_batch(comparisons, preparer:)
       ComparisonBatch.new(
         comparisons,
         live_loader: @live_endpoints, preparer: preparer,
         history_preparer: @historical_store.method(:prepare_batch),
+        version_history_preparer: @historical_store.method(:prepare_deleted_batch),
         historical_snapshotter: method(:historical_snapshot),
         live_normalizer: method(:normalize_live_snapshot)
       )
@@ -168,7 +183,7 @@ module PaperTrailDiff
 
     #: (untyped, historical: bool) -> void
     def prepare_batch_model(model, historical:)
-      @batch_safety.call(model, historical: historical)
+      @batch_safety.call(model)
       @traversal_preparer.call(model, historical: historical)
     end
 
@@ -185,7 +200,8 @@ module PaperTrailDiff
         model, identities: identities, time_range: within.nil? ? nil : TimeRange.new(within),
                version_scope: options.fetch(:version_scope),
                history_preparer: @historical_store.method(:prepare_deleted_batch),
-               analyzer: analyzer
+               analyzer: analyzer,
+               context_required: options.fetch(:activity) && !@association_tree.empty?
       ).call
     end
 

data/lib/paper_trail_diff/preloaded_endpoint_batch_loader.rb

@@ -30,7 +30,7 @@ module PaperTrailDiff
 
     #: (untyped, AssociationTree, String, untyped) -> void
     def validate_association(record, tree, path, reflection)
-      association_path = Support.association_path(path, reflection.name.to_s)
+      association_path = Support.association_path(path, reflection.name)
       association = record.association(reflection.name)
       unless association.loaded?
         message = "current endpoint association is not preloaded: #{association_path}"

data/lib/paper_trail_diff/prepared_activity_index.rb

@@ -10,39 +10,93 @@ module PaperTrailDiff
       @range = ActivityRange.new(start_at, end_at)
       @roots = root_versions.group_by { |version| [version.item_type, version.item_id.to_s] }
       @nodes = {} #: Hash[String, Array[untyped]]
-      @children = {} #: Hash[Array[String], untyped]
-      @rows = {} #: Hash[Array[String], Hash[String, Array[untyped]]]
+      # Rows are cached by reflection, which a subclass shares with its base.
+      @children = {} #: Hash[untyped, untyped]
+      @targets = {} #: Hash[untyped, untyped]
+      @rows = {} #: Hash[untyped, Hash[String, Array[untyped]]]
     end
 
     #: (untyped, Array[untyped]) -> void
     def register(model, ids)
-      name = model.base_class.name.to_s
+      name = model.base_class.name
       @nodes[name] = (@nodes.fetch(name, []) | ids)
     end
 
     #: (untyped, Array[untyped]) -> Array[untyped]
     def versions(model, ids)
       ids.flat_map do |id|
-        key = [model.base_class.name.to_s, id.to_s]
-        @roots[key] || @records.versions_for_id(model, id)
+        @roots[[model.base_class.name, id.to_s]] || @records.versions_for_id(model, id)
+      end
+    end
+
+    # Children are found by key across the whole table, so an association to
+    # an STI subclass finds the rows of its siblings too. Only a row that was
+    # of the class at some point belongs to it, and of that row only the
+    # versions it had the class before or after.
+    #: (untyped, Array[untyped]) -> Array[untyped]
+    def member_ids(model, ids)
+      return ids if model.descends_from_active_record?
+
+      ids.select { |id| member_class?(model, @records.model_classes(model, id)) }
+    end
+
+    #: (untyped, Array[untyped], ActivityRange) -> Array[untyped]
+    def member_versions(model, ids, range)
+      all = versions(model, ids).select { |version| range.include?(version) }
+      return all if model.descends_from_active_record?
+
+      all.select do |version|
+        member_class?(model, @records.model_classes(model, version.item_id, version))
+      end
+    end
+
+    # The versions of a through's join rows that are on its path. Under
+    # `source_type:`, a row is on it only while its type column names that
+    # class, so only the versions it had that type before or after count. A
+    # version saved before the type column existed has no type to read.
+    #: (Hash[Symbol, untyped], untyped) -> Array[untyped]
+    def join_versions(group, reflection)
+      versions = group.fetch(:versions)
+      source_type = reflection.options[:source_type]
+      return versions unless source_type
+
+      column = reflection.foreign_type
+      versions.select do |version|
+        @records.states_around(group.fetch(:model), version.item_id, version).any? do |state|
+          state.attributes[column] == source_type.to_s
+        end
       end
     end
 
     #: (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
     def child_ids(model, ids, reflection, range)
-      key = [model.base_class.name.to_s, reflection.name.to_s]
-      historical, live = @children[key] ||= child_rows(model, reflection)
+      historical, live = @children[reflection] ||= child_rows(model, reflection)
       empty = [] #: Array[untyped]
       selected = historical_ids(reflection.klass, ids, historical, range)
       selected |= ids.flat_map { |id| live.fetch(id.to_s, empty) } if range.current_end?
       selected.uniq
     end
 
-    #: (untyped, Array[untyped], untyped, ?transactions: bool) -> Array[untyped]
-    def association_rows(model, selected_versions, reflection, transactions: false)
-      key = [model.base_class.name.to_s, reflection.name.to_s]
-      rows = @rows[key] ||= load_association_rows(model, reflection, transactions)
-      version_ids(selected_versions, transactions).flat_map { |id| rows.fetch(id.to_s, []) }
+    # The `belongs_to` targets each owner pointed at in the range: at its start
+    # and after each change inside it, plus the live row at a current end.
+    #: (untyped, Array[untyped], untyped, ActivityRange) -> Array[ActivityTargetCandidateLoader::Row]
+    def target_rows(model, ids, reflection, range)
+      historical, live = @targets[reflection] ||= target_candidates(model, reflection)
+      rows = eligible_rows(model, rows_for(historical, ids), range)
+      range.current_end? ? rows + rows_for(live, ids) : rows
+    end
+
+    #: (untyped, untyped) -> bool
+    def loaded?(model, id)
+      @records.loaded?(model, id)
+    end
+
+    # PT-AT records HABTM membership once per transaction, under the
+    # association's name, so the rows are keyed by transaction id.
+    #: (untyped, Array[untyped], untyped) -> Array[untyped]
+    def habtm_rows(model, selected_versions, reflection)
+      rows = @rows[reflection] ||= load_habtm_rows(model, reflection)
+      transaction_ids(selected_versions).flat_map { |id| rows.fetch(id.to_s, []) }
     end
 
     private
@@ -51,22 +105,29 @@ module PaperTrailDiff
     # @rbs @range: ActivityRange
     # @rbs @roots: Hash[Array[String], Array[untyped]]
     # @rbs @nodes: Hash[String, Array[untyped]]
-    # @rbs @children: Hash[Array[String], untyped]
-    # @rbs @rows: Hash[Array[String], Hash[String, Array[untyped]]]
+    # @rbs @children: Hash[untyped, untyped]
+    # @rbs @targets: Hash[untyped, untyped]
+    # @rbs @rows: Hash[untyped, Hash[String, Array[untyped]]]
+
+    #: (untyped, Array[untyped]) -> bool
+    def member_class?(model, classes)
+      classes.any? { |model_class| model_class <= model }
+    end
 
     #: (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
     def historical_ids(model, ids, historical, range)
       empty = [] #: Array[untyped]
       ids.flat_map do |id|
         historical.fetch(id.to_s, empty).filter_map do |row|
-          row[1] if eligible_child?(model, row, range)
+          _owner, child_id, timestamp, event = row
+          child_id if eligible_version?(model, child_id, timestamp, event, range)
         end
       end
     end
 
     #: (untyped) -> Array[untyped]
     def node_ids(model)
-      name = model.base_class.name.to_s
+      name = model.base_class.name
       @nodes.fetch(name) do
         raise ConfigurationError,
               "prepared activity graph is missing #{name}; " \
@@ -84,12 +145,31 @@ module PaperTrailDiff
              .transform_values { |rows| rows.map(&:last) }]
     end
 
+    #: (Hash[String, Array[ActivityTargetCandidateLoader::Row]], Array[untyped]) -> Array[ActivityTargetCandidateLoader::Row]
+    def rows_for(grouped, ids)
+      ids.flat_map { |id| grouped[id.to_s] || [] }
+    end
+
+    #: (untyped, Array[ActivityTargetCandidateLoader::Row], ActivityRange) -> Array[ActivityTargetCandidateLoader::Row]
+    def eligible_rows(model, rows, range)
+      rows.select do |row|
+        eligible_version?(model, row.owner_id, row.created_at, row.event, range) &&
+          range.recorded_before_end?(row.created_at, row.version_id)
+      end
+    end
+
+    #: (untyped, untyped) -> untyped
+    def target_candidates(model, reflection)
+      loader = ActivityTargetCandidateLoader.new(model, node_ids(model), reflection, @range)
+      [loader.historical_rows.group_by { |row| row.owner_id.to_s },
+       loader.current_rows.group_by { |row| row.owner_id.to_s }]
+    end
+
     # Mirrors VersionAssociationCandidateScope's before-window rule. The loaded
     # series includes changes to other owners too, so an old membership cannot
     # survive a later pre-window reassignment just because that owner is absent.
-    #: (untyped, Array[untyped], ActivityRange) -> bool
-    def eligible_child?(model, row, range)
-      _owner, id, timestamp, event = row
+    #: (untyped, untyped, untyped, String?, ActivityRange) -> bool
+    def eligible_version?(model, id, timestamp, event, range)
       return timestamp <= range.end_time if timestamp >= range.start_time
       return false if event == 'destroy'
 
@@ -98,24 +178,18 @@ module PaperTrailDiff
       !later || later.created_at >= range.start_time
     end
 
-    #: (untyped, untyped, bool) -> Hash[String, Array[untyped]]
-    def load_association_rows(model, reflection, transactions)
-      all_versions = versions(model, node_ids(model))
-      foreign_key = transactions ? reflection.name.to_s : reflection.foreign_key.to_s
+    #: (untyped, untyped) -> Hash[String, Array[untyped]]
+    def load_habtm_rows(model, reflection)
       model.paper_trail.version_association_class.where(
-        version_id: version_ids(all_versions, transactions), foreign_key_name: foreign_key
-      ).to_a.group_by { |row| row.version_id.to_s }
-    end
-
-    #: (Array[untyped], bool) -> Array[untyped]
-    def version_ids(versions, transactions)
-      if transactions
-        versions.filter_map do |version|
-          version.transaction_id if version.respond_to?(:transaction_id)
-        end.uniq
-      else
-        versions.map(&:id)
-      end
+        version_id: transaction_ids(versions(model, node_ids(model))),
+        foreign_key_name: reflection.name
+      ).group_by { |row| row.version_id.to_s }
+    end
+
+    # A version without a transaction id names no rows, so it can stay in.
+    #: (Array[untyped]) -> Array[untyped]
+    def transaction_ids(versions)
+      versions.map { |version| version.transaction_id if version.respond_to?(:transaction_id) }.uniq
     end
   end
 end