paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/activity_belongs_to_event_applier.rb

@@ -25,7 +25,7 @@ module PaperTrailDiff
       routes = @route_finder.belongs_to_routes(
         endpoint_model_class(root_endpoint), tree, version.item_type.to_s
       )
-      return [false, nil] if routes.empty?
+      return [false, nil] if routes.empty? || scoped_route?(routes)
 
       snapshot = previous
       routes.each do |route|
@@ -43,6 +43,15 @@ module PaperTrailDiff
     # @rbs @record_resolver: ActivityEventRecordResolver
     # @rbs @record_normalizer: ActivityEventRecordNormalizer
 
+    # An edit can move a target into or out of a scope, which a replacement
+    # in place cannot show, so a scoped route's branch is read again instead.
+    #: (Array[Array[untyped]]) -> bool
+    def scoped_route?(routes)
+      routes.any? do |route|
+        route.any? { |entry| ScopeCondition.scoped_path?(entry.fetch(1)) }
+      end
+    end
+
     #: (Array[untyped], untyped, SnapshotNormalizer, untyped, untyped) -> RecordSnapshot?
     def normalized_route_record(route, version, normalizer, root_endpoint, context_endpoint)
       record = @record_resolver.record_after(version, direct: route.last.fetch(2).empty?)
@@ -91,8 +100,7 @@ module PaperTrailDiff
     #: (Array[RecordSnapshot], untyped, RecordSnapshot?) -> [Array[RecordSnapshot], bool]
     def replace_existing_target(records, version, replacement)
       index = records.index do |record|
-        record.id.to_s == version.item_id.to_s &&
-          record.type.to_s == replacement_type(version, replacement)
+        record.id.to_s == version.item_id.to_s && same_table?(record, version)
       end
       return [records, false] unless index
 
@@ -101,16 +109,18 @@ module PaperTrailDiff
       [updated.freeze, true]
     end
 
-    #: (untyped, RecordSnapshot?) -> String
-    def replacement_type(version, replacement)
-      return replacement.type.to_s if replacement
-
-      Endpoint.model_class(version).name.to_s
+    # The target is matched by id within its table rather than by type name.
+    # Without `item_subtype`, a version names only the STI base class, and a
+    # row whose type changes is replaced by a record of another class.
+    #: (RecordSnapshot, untyped) -> bool
+    def same_table?(record, version)
+      model = AssociationTraversal.named_class(record.type.to_s)
+      !model.nil? && model.base_class == Endpoint.model_class(version).base_class
     end
 
     #: (untyped) -> untyped
     def endpoint_model_class(endpoint)
-      Endpoint.version?(endpoint) ? Endpoint.model_class(endpoint) : endpoint.class
+      Endpoint.version?(endpoint) ? RecordedClass.for(endpoint) : endpoint.class
     end
   end
 end

data/lib/paper_trail_diff/activity_collection_event_applier.rb

@@ -14,7 +14,8 @@ module PaperTrailDiff
 
     #: (Array[Array[untyped]], untyped, ActivitySnapshotDelta?) -> bool
     def safe?(routes, version, delta)
-      !unsafe_through_membership_event?(routes, version) &&
+      !scoped_route?(routes) &&
+        !unsafe_through_membership_event?(routes, version) &&
         !unsafe_nested_membership_delta?(routes, delta)
     end
 
@@ -62,6 +63,15 @@ module PaperTrailDiff
       @route_updater.call(snapshot, change).fetch(0)
     end
 
+    # Any edit can move a record into or out of a scope, so a scoped route's
+    # branch is read again from history instead.
+    #: (Array[Array[untyped]]) -> bool
+    def scoped_route?(routes)
+      routes.any? do |route|
+        route.any? { |entry| ScopeCondition.scoped_path?(entry.fetch(1)) }
+      end
+    end
+
     #: (Array[Array[untyped]], untyped) -> bool
     def unsafe_through_membership_event?(routes, version)
       return false if version.event.to_s == 'update'

data/lib/paper_trail_diff/activity_collection_record_updater.rb

@@ -33,12 +33,13 @@ module PaperTrailDiff
     #: (AssociationSnapshot, untyped, RecordSnapshot?) -> [Array[RecordSnapshot], RecordSnapshot?, RecordSnapshot?, bool]
     def call(association, version, replacement)
       records = association.records
-      position = association.position(replacement_type(version, replacement), version.item_id)
+      position = association.position(replacement_type(version, replacement), version.item_id) ||
+                 retyped_position(association, version)
       return [records, nil, nil, true] unless replacement || position
 
       before = records.fetch(position) if position
       updated = replacement_records(records, position, replacement)
-      [updated, before, replacement, !before.nil? && !replacement.nil?]
+      [updated, before, replacement, !!before && before.identity == replacement&.identity]
     end
 
     #: (untyped, RecordSnapshot?) -> String
@@ -52,6 +53,19 @@ module PaperTrailDiff
 
     # @rbs @relationship: ActivityRelationship
 
+    # A row whose STI type changed is the same row under a new identity, so it
+    # is found by id among the records of its table.
+    #: (AssociationSnapshot, untyped) -> Integer?
+    def retyped_position(association, version)
+      position = association.position_for_id(version.item_id)
+      return unless position
+
+      type = association.records.fetch(position).type
+      position if Object.const_get(type).base_class == Endpoint.model_class(version).base_class
+    rescue NameError
+      nil
+    end
+
     #: (Array[RecordSnapshot], Integer?, RecordSnapshot?) -> Array[RecordSnapshot]
     def replacement_records(records, position, replacement)
       updated = records.dup

data/lib/paper_trail_diff/activity_event_record_resolver.rb

@@ -129,7 +129,26 @@ module PaperTrailDiff
       return unless before
 
       attributes = before.attributes.merge(after_attributes(changes, model))
-      @direct_loader.complete(PreparedRecordState.from_attributes(model, attributes))
+      model_after = class_after(model, attributes)
+      return unless model_after
+
+      @direct_loader.complete(PreparedRecordState.from_attributes(model_after, attributes))
+    end
+
+    # Without `item_subtype` a version names only the STI base class, and a
+    # change can move the row to another class, so the type the row holds
+    # after the change decides. A type that names no class has no direct
+    # state; the caller falls back to reifying the record.
+    #: (untyped, Hash[untyped, untyped]) -> untyped
+    def class_after(model, attributes)
+      column = model.inheritance_column.to_s
+      return model unless model.columns_hash.key?(column)
+
+      type = attributes[column].to_s
+      type.empty? ? model.base_class : model.base_class.sti_class_for(type)
+    rescue StandardError => e
+      active_record = Object.const_get(:ActiveRecord) #: untyped
+      raise unless e.is_a?(active_record.const_get(:SubclassNotFound))
     end
 
     #: (untyped) -> untyped

data/lib/paper_trail_diff/activity_event_route_finder.rb

@@ -70,7 +70,8 @@ module PaperTrailDiff
       entry = [name, reflection, subtree, child_path]
       direct = [] #: Array[Array[untyped]]
       direct << [entry] if direct_route?(reflection, target_type, macro)
-      return direct if subtree.empty? || reflection.polymorphic?
+      # Validation rejects a path that continues past a polymorphic target.
+      return direct if subtree.empty?
 
       nested = routes(reflection.klass, subtree, target_type, macro, path: child_path)
       direct.concat(nested.map { |route| [entry, *route] })

data/lib/paper_trail_diff/activity_event_snapshot_refresher.rb

@@ -111,7 +111,7 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def endpoint_model_class(endpoint)
-      Endpoint.version?(endpoint) ? Endpoint.model_class(endpoint) : endpoint.class
+      Endpoint.version?(endpoint) ? RecordedClass.for(endpoint) : endpoint.class
     end
   end
 end

data/lib/paper_trail_diff/activity_range.rb

@@ -9,7 +9,6 @@ module PaperTrailDiff
 
     #: (untyped, untyped) -> void
     def initialize(start_boundary, end_boundary)
-      @start_boundary = start_boundary
       @end_boundary = end_boundary
       @start_key = if Endpoint.version?(start_boundary)
                      Support.chronological_version_key(start_boundary)
@@ -39,9 +38,22 @@ module PaperTrailDiff
       !Endpoint.version?(@end_boundary)
     end
 
+    # Whether the state a version recorded after its change held inside the
+    # range. A range ending at a version ends at the state before it, so the
+    # change that version records is past the end, unlike #include?.
+    #: (untyped, untyped) -> bool
+    def recorded_before_end?(created_at, id)
+      end_key = @end_key
+      return created_at <= @end_boundary unless end_key
+
+      comparison = Support.version_key(created_at, id) <=> end_key
+      raise ConfigurationError, 'versions have incomparable timestamps' unless comparison
+
+      comparison.negative?
+    end
+
     private
 
-    # @rbs @start_boundary: untyped
     # @rbs @end_boundary: untyped
     # @rbs @start_key: Array[untyped]?
     # @rbs @start_time: untyped

data/lib/paper_trail_diff/activity_relationship.rb

@@ -11,6 +11,7 @@ module PaperTrailDiff
       # @type var expected_ids: Array[untyped]
       expected = expected_ids.map { |id| id.to_s } # rubocop:disable Style/SymbolProc
       return false unless actual == expected
+      return false unless sti_member?(record, reflection, state)
       return true unless reflection.options[:as]
 
       type = event_attribute(record, reflection.type, state: state).to_s
@@ -27,6 +28,17 @@ module PaperTrailDiff
 
     private
 
+    #: (untyped, untyped, Symbol) -> bool
+    def sti_member?(record, reflection, state)
+      model_class = reflection.klass
+      return true if model_class.descends_from_active_record?
+
+      column = model_class.inheritance_column
+      type = event_attribute(record, column, state: state)
+      attributes = { column => type } #: Hash[untyped, untyped]
+      AssociationTraversal.sti_member?(model_class, attributes)
+    end
+
     #: (untyped, untyped, state: Symbol) -> Array[String]
     def relationship_owner_values(record, reflection, state:)
       Array(reflection.foreign_key).map do |key|

data/lib/paper_trail_diff/activity_root_snapshot_refresher.rb

@@ -33,7 +33,7 @@ module PaperTrailDiff
       return [false, nil] unless previous && event.root?
 
       version = event.version
-      model_class = Endpoint.model_class(version)
+      model_class = RecordedClass.for(version)
       return [false, nil] unless same_record?(previous, version)
 
       changes = @changeset.call(version, model_class)
@@ -108,9 +108,12 @@ module PaperTrailDiff
       end.uniq.sort.freeze
     end
 
+    # A polymorphic target's class is known only per record, so it cannot be
+    # checked here; a target that is not versioned raises when it is read.
     #: (untyped) -> bool
     def direct_versioned_reflection?(reflection)
-      return false if reflection.polymorphic? || reflection.options[:through]
+      return true if reflection.polymorphic?
+      return false if reflection.options[:through]
       return false if reflection.macro == :has_and_belongs_to_many
 
       paper_trail = Object.const_get(:PaperTrail) #: untyped

data/lib/paper_trail_diff/activity_target_candidate_loader.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Loads the `belongs_to` targets owners pointed at during one activity range:
+  # at its start and after each change inside it.
+  #
+  # PT-AT records a version's foreign keys as they stood after its change, so
+  # the target at the start comes from the latest version before it, and the
+  # version a range ends at names a target only after the range. Reading only
+  # the owners' versions inside the range misses a target whose owner did not
+  # change there -- an author renamed under an article nobody edited.
+  class ActivityTargetCandidateLoader
+    # A plain class rather than Data.define, which arrived in Ruby 3.2 while this
+    # gem supports 3.1.
+    class Row
+      attr_reader :owner_id #: untyped
+      attr_reader :foreign_key_id #: untyped
+      attr_reader :foreign_type #: String?
+      attr_reader :created_at #: untyped
+      attr_reader :event #: String?
+      attr_reader :version_id #: untyped
+
+      #: (untyped, untyped, String?, ?untyped, ?String?, ?untyped) -> void
+      def initialize(owner_id, foreign_key_id, foreign_type, created_at = nil, event = nil, # rubocop:disable Metrics/ParameterLists
+                     version_id = nil)
+        @owner_id = owner_id
+        @foreign_key_id = foreign_key_id
+        @foreign_type = foreign_type
+        @created_at = created_at
+        @event = event
+        @version_id = version_id
+        freeze
+      end
+    end
+
+    #: (untyped, Array[untyped], untyped, ActivityRange) -> void
+    def initialize(owner_class, owner_ids, reflection, range)
+      @owner_class = owner_class
+      @owner_ids = owner_ids
+      @reflection = reflection
+      @range = range
+    end
+
+    #: () -> Array[Row]
+    def call
+      rows = historical_rows.select do |row|
+        @range.recorded_before_end?(row.created_at, row.version_id)
+      end
+      @range.current_end? ? rows + current_rows : rows
+    end
+
+    # One shared query keeps the owner and timestamp needed to partition a
+    # batch's candidates back into each root's exact activity range.
+    #: () -> Array[Row]
+    def historical_rows
+      return [] if composite_foreign_key?
+
+      version_class = @owner_class.paper_trail.version_class
+      relation = candidate_scope(version_class).call(historical_relation(version_class))
+      historical_columns(relation, version_class).map do |row|
+        owner_id, id, type, created_at, event, version_id = row
+        Row.new(Support.record_id(@owner_class, owner_id), id, type, created_at, event, version_id)
+      end
+    end
+
+    # The live row holds the state at a range that ends at the current record.
+    #: () -> Array[Row]
+    def current_rows
+      return [] if composite_foreign_key? || @owner_class.composite_primary_key?
+
+      live_rows.filter_map do |owner_id, id, type|
+        Row.new(owner_id, id, type) unless id.nil?
+      end
+    end
+
+    private
+
+    # @rbs @owner_class: untyped
+    # @rbs @owner_ids: Array[untyped]
+    # @rbs @reflection: untyped
+    # @rbs @range: ActivityRange
+
+    #: (untyped) -> untyped
+    def historical_relation(version_class)
+      association_class.joins(:version)
+                       .where(foreign_key_name: @reflection.foreign_key)
+                       .where(version_class.table_name => {
+                                item_type: @owner_class.base_class.name, item_id: @owner_ids
+                              })
+    end
+
+    #: (untyped, untyped) -> Array[Array[untyped]]
+    def historical_columns(relation, version_class)
+      versions = version_class.arel_table
+      associations = association_class.arel_table
+      relation.pluck(versions[:item_id], associations[:foreign_key_id],
+                     associations[:foreign_type], versions[:created_at], versions[:event],
+                     versions[:id])
+    end
+
+    # A polymorphic key names its target in a type column; any other names it
+    # in the reflection, so no type is read. Like the history, the live read
+    # takes owners of every class under the base class: a batch can ask for
+    # the owners of an association through one subclass.
+    #: () -> Array[Array[untyped]]
+    def live_rows
+      relation = @owner_class.base_class.unscoped.where(@owner_class.primary_key => @owner_ids)
+      key = @reflection.foreign_key
+      return relation.pluck(@owner_class.primary_key, key) unless @reflection.polymorphic?
+
+      relation.pluck(@owner_class.primary_key, key, @reflection.foreign_type)
+    end
+
+    #: (untyped) -> VersionAssociationCandidateScope
+    def candidate_scope(version_class)
+      VersionAssociationCandidateScope.new(version_class, @range.start_time,
+                                           end_at: @range.end_time)
+    end
+
+    #: () -> untyped
+    def association_class
+      @owner_class.paper_trail.version_association_class
+    end
+
+    #: () -> bool
+    def composite_foreign_key?
+      @reflection.foreign_key.is_a?(Array)
+    end
+  end
+end

data/lib/paper_trail_diff/activity_timeline_builder.rb

@@ -6,8 +6,8 @@ module PaperTrailDiff
   class ActivityTimelineBuilder
     include ActivityGrouping
 
-    #: (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, ?snapshots: bool, ?group: Symbol?) -> void
-    def initialize(record, range:, tree:, snapshotter:, snapshots: false, group: nil) # rubocop:disable Metrics/ParameterLists
+    #: (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, snapshots: bool, group: Symbol?) -> void
+    def initialize(record, range:, tree:, snapshotter:, snapshots:, group:) # rubocop:disable Metrics/ParameterLists
       ActivityGrouping.validate!(group)
       @snapshots = snapshots
       @group = group
@@ -15,7 +15,6 @@ module PaperTrailDiff
       # the build even when the caller did not ask to keep them.
       @retain = snapshots || grouping?
       @record = record
-      @from = range.from
       @to = range.to
       @range = range
       @tree = tree
@@ -40,6 +39,8 @@ module PaperTrailDiff
       return analyze_current if Endpoint.record?(@to)
 
       plan = @range.select_plan
+      return Analysis.empty if plan.empty?
+
       root_versions = plan.reconstruction_versions
       prepare_history(root_versions)
       events = collect_events(root_versions)
@@ -49,7 +50,6 @@ module PaperTrailDiff
     private
 
     # @rbs @record: untyped
-    # @rbs @from: untyped
     # @rbs @to: untyped
     # @rbs @range: TimelineRange
     # @rbs @tree: AssociationTree
@@ -65,10 +65,14 @@ module PaperTrailDiff
     # Every boundary in the span, filtered out or not. A filter narrows where the
     # span starts and ends, but the sequence inside it stays complete: dropping
     # boundaries would fold the changes they carried into a neighbouring step and
-    # credit them to whoever made that one.
+    # credit them to whoever made that one. A filter that keeps no version
+    # leaves no span, as it does for a checkpoint timeline.
     #: () -> Array[ActivityStep]
     def build_between_versions
-      root_versions = @range.select_plan.reconstruction_versions
+      plan = @range.select_plan
+      return no_steps if plan.empty?
+
+      root_versions = plan.reconstruction_versions
       prepare_history(root_versions)
       events = collect_events(root_versions)
       history = event_history(root_versions, events)
@@ -102,7 +106,7 @@ module PaperTrailDiff
     def current_history
       validate_current_range!
       plan = @range.select_plan
-      return [plan, [], ActivityHistory.empty, nil, nil] if plan.empty?
+      return empty_history(plan) if plan.empty?
 
       snapshot, captured_at = capture_current if plan.closing_record
       versions = plan.reconstruction_versions
@@ -113,6 +117,14 @@ module PaperTrailDiff
       [plan, events, history, snapshot, boundary]
     end
 
+    # Without a closing boundary nothing reads the events or the closing pair,
+    # so their mutations cannot change an answer.
+    # mutant:disable
+    #: (RootVersionPlan) -> [RootVersionPlan, Array[ActivityEvent], ActivityHistory, RecordSnapshot?, ActivityBoundary?]
+    def empty_history(plan)
+      [plan, [], ActivityHistory.empty, nil, nil]
+    end
+
     #: () -> [RecordSnapshot?, untyped]
     def capture_current
       [@snapshotter.call(@to, @to), Time.now.utc]
@@ -120,12 +132,11 @@ module PaperTrailDiff
 
     #: () -> void
     def validate_current_range!
-      unless Endpoint.version?(@from)
+      unless Endpoint.version?(@range.from)
         raise InvalidTimelineRangeError, '`from` must be a root PaperTrail version'
       end
 
-      Endpoint.validate_pair!(@from, @to)
-      Endpoint.validate_pair!(@record, @to)
+      Endpoint.validate_pair!(@range.from, @to)
       AssociationTraversal.new(@tree).reject_live_habtm_activity!(@record.class)
     end
 
@@ -139,7 +150,6 @@ module PaperTrailDiff
         @record,
         root_versions: root_versions,
         tree: @tree,
-        traversal: AssociationTraversal.new(@tree),
         prepared: (@snapshotter.activity_index if @snapshotter.respond_to?(:activity_index)),
         range_start: range_start,
         range_end: range_end
@@ -156,14 +166,15 @@ module PaperTrailDiff
 
     # Appends the transition into an explicit closing boundary, which is either
     # a requested current record or the absence a final root destroy leaves.
+    # Either follows the root versions, which are themselves events.
     #: (ActivityHistory, Array[ActivityEvent], ActivityBoundary?, RecordSnapshot?) -> Array[ActivityStep]
     def activity_steps(history, events, final_boundary, final_snapshot)
       steps = history.steps.dup
-      previous_event = events.last
-      previous_boundary = ActivityBoundary.from_version(previous_event.version) if previous_event
-      if final_boundary && previous_boundary
+      if final_boundary
+        last_event = events.last #: ActivityEvent
         steps << ActivityStep.between(
-          from_boundary: previous_boundary, to_boundary: final_boundary,
+          from_boundary: ActivityBoundary.from_version(last_event.version),
+          to_boundary: final_boundary,
           from_snapshot: history.last_snapshot, to_snapshot: final_snapshot,
           retain: @retain
         )
@@ -176,7 +187,7 @@ module PaperTrailDiff
     #: (Array[untyped]) -> ActivityBoundary?
     def destroyed_boundary(root_versions)
       version = root_versions.last
-      return unless version && version.event.to_s == 'destroy'
+      return unless version.event == 'destroy'
 
       ActivityBoundary.destroyed(version)
     end
@@ -210,14 +221,9 @@ module PaperTrailDiff
 
     #: () -> TimeActivityTimelineBuilder
     def time_builder
-      TimeActivityTimelineBuilder.new(
-        @record,
-        range: @range,
-        tree: @tree,
-        snapshotter: @snapshotter,
-        snapshots: @snapshots,
-        group: @group
-      )
+      TimeActivityTimelineBuilder.new(@record, range: @range, tree: @tree,
+                                               snapshotter: @snapshotter, snapshots: @snapshots,
+                                               group: @group)
     end
   end
 end

data/lib/paper_trail_diff/activity_version_collector.rb

@@ -4,12 +4,11 @@
 module PaperTrailDiff
   # Collects root and selected-descendant versions relevant to one root history range.
   class ActivityVersionCollector
-    #: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?range_start: untyped, ?range_end: untyped, ?prepared: PreparedActivityIndex?) -> void
+    #: (untyped, root_versions: Array[untyped], tree: AssociationTree, ?range_start: untyped, ?range_end: untyped, ?prepared: PreparedActivityIndex?) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
       record,
       root_versions:,
       tree:,
-      traversal:,
       range_start: root_versions.first,
       range_end: root_versions.last,
       prepared: nil
@@ -18,7 +17,7 @@ module PaperTrailDiff
       @record = record
       @root_versions = root_versions
       @tree = tree
-      @traversal = traversal
+      @traversal = AssociationTraversal.new(tree)
       @range = ActivityRange.new(range_start, range_end)
       @registry = ActivityEventRegistry.new
     end
@@ -62,7 +61,7 @@ module PaperTrailDiff
         @registry.add(group.fetch(:versions), branch: branch)
         next if subtree.empty?
 
-        child_path = Support.association_path(path, reflection.name.to_s)
+        child_path = Support.association_path(path, reflection.name)
         collect_tree(group.fetch(:model), group.fetch(:ids), subtree,
                      path: child_path, branch: branch)
       end
@@ -74,7 +73,7 @@ module PaperTrailDiff
 
       case reflection.macro
       when :belongs_to
-        belongs_to_groups(parent.fetch(:model), parent.fetch(:versions), reflection)
+        belongs_to_groups(parent.fetch(:model), parent.fetch(:ids), reflection)
       when :has_one, :has_many
         direct_child_groups(parent.fetch(:model), parent.fetch(:ids), reflection)
       when :has_and_belongs_to_many
@@ -90,24 +89,35 @@ module PaperTrailDiff
       intermediate = edge_groups(parent, through, branch)
       result = {} #: Hash[String, untyped]
       intermediate.each_value do |group|
-        @registry.add(group.fetch(:versions), branch: branch)
+        # A through is always read with prepared history, which knows the
+        # join row's state either side of each version.
+        @registry.add(@prepared&.join_versions(group, reflection) || group.fetch(:versions),
+                      branch: branch)
         source = reflection.source_reflection
         children = edge_groups(group, source, branch)
         merge_groups!(result, children)
       end
-      result
+      # Under `source_type:`, only targets of that type are members.
+      reflection.options[:source_type]&.then { |type| result.slice(type.to_s) } || result
     end
 
+    # Every target the owners pointed at in the range, not only those their own
+    # changes there recorded: an author renamed under an article nobody edited
+    # is still that article's activity.
     #: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
-    def belongs_to_groups(parent_class, parent_versions, reflection)
-      if (prepared = @prepared)
-        rows = prepared.association_rows(parent_class, parent_versions, reflection)
-        return identity_groups(rows, reflection)
-      end
-      rows = parent_class.paper_trail.version_association_class.where(
-        version_id: parent_versions.map(&:id),
-        foreign_key_name: reflection.foreign_key.to_s
-      ).to_a
+    def belongs_to_groups(parent_class, parent_ids, reflection)
+      prepared = @prepared
+      return unprepared_belongs_to_groups(parent_class, parent_ids, reflection) unless prepared
+
+      # Prepared history holds every target its snapshots can contain. One it
+      # did not load -- a key changed without a version -- has no state to compare.
+      rows = prepared.target_rows(parent_class, parent_ids, reflection, @range)
+      identity_groups(rows, reflection) { |model_class, id| prepared.loaded?(model_class, id) }
+    end
+
+    #: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
+    def unprepared_belongs_to_groups(parent_class, parent_ids, reflection)
+      rows = ActivityTargetCandidateLoader.new(parent_class, parent_ids, reflection, @range).call
       identity_groups(rows, reflection)
     end
 
@@ -127,8 +137,7 @@ module PaperTrailDiff
     #: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
     def habtm_groups(parent_class, parent_versions, reflection)
       if (prepared = @prepared)
-        rows = prepared.association_rows(parent_class, parent_versions, reflection,
-                                         transactions: true)
+        rows = prepared.habtm_rows(parent_class, parent_versions, reflection)
         return identity_groups(rows, reflection)
       end
       transaction_ids = parent_versions.filter_map do |version|
@@ -141,7 +150,7 @@ module PaperTrailDiff
       identity_groups(rows, reflection)
     end
 
-    #: (Array[untyped], untyped) -> Hash[String, untyped]
+    #: (Array[untyped], untyped) ?{ (untyped, untyped) -> bool } -> Hash[String, untyped]
     def identity_groups(rows, reflection)
       identities = rows.group_by { |row| target_class(reflection, row) }
       groups = {} #: Hash[String, untyped]
@@ -149,6 +158,7 @@ module PaperTrailDiff
         next unless model_class
 
         ids = class_rows.filter_map(&:foreign_key_id).uniq
+        ids = ids.select { |id| yield(model_class, id) } if block_given?
         groups[model_class.name] = group(model_class, ids)
       end
       groups
@@ -156,6 +166,7 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped]) -> Hash[Symbol, untyped]
     def group(model_class, ids)
+      ids = @prepared&.member_ids(model_class, ids) || ids
       { model: model_class, ids: ids, versions: versions_for(model_class, ids) }
     end
 
@@ -178,7 +189,7 @@ module PaperTrailDiff
       return [] if ids.empty?
 
       if (prepared = @prepared)
-        return prepared.versions(model_class, ids).select { |version| @range.include?(version) }
+        return prepared.member_versions(model_class, ids, @range)
       end
 
       version_class = model_class.paper_trail.version_class