paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/prepared_edge_loader.rb

@@ -4,25 +4,21 @@
 module PaperTrailDiff
   # Loads every historical identity that can participate in one association edge.
   class PreparedEdgeLoader
-    EDGE_LOADERS = {
-      belongs_to: :belongs_to_edge,
-      has_one: :child_edge,
-      has_many: :child_edge,
-      has_and_belongs_to_many: :habtm_edge
-    }.freeze
-    private_constant :EDGE_LOADERS
-
     #: (PreparedRecordIndex, Array[untyped], ?start_at: untyped) -> void
     def initialize(records, root_versions, start_at: root_versions.first&.created_at)
       @records = records
-      @transaction_ids = root_versions.filter_map(&:transaction_id).uniq.freeze
+      @transaction_ids = root_versions.filter_map(&:transaction_id)
       @start_at = start_at
     end
 
+    # HABTM alone also returns each root transaction's members.
     #: (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]?]
     def call(owner_class, owner_ids, reflection)
-      loader = EDGE_LOADERS.fetch(reflection.macro)
-      send(loader, owner_class, owner_ids, reflection)
+      case reflection.macro
+      when :belongs_to then [belongs_to_groups(owner_class, owner_ids, reflection), nil]
+      when :has_and_belongs_to_many then habtm_groups(owner_class, reflection)
+      else [child_groups(owner_class, owner_ids, reflection), nil]
+      end
     end
 
     private
@@ -31,21 +27,6 @@ module PaperTrailDiff
     # @rbs @transaction_ids: Array[untyped]
     # @rbs @start_at: untyped
 
-    #: (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], nil]
-    def belongs_to_edge(owner_class, owner_ids, reflection)
-      [belongs_to_groups(owner_class, owner_ids, reflection), nil]
-    end
-
-    #: (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], nil]
-    def child_edge(owner_class, owner_ids, reflection)
-      [child_groups(owner_class, owner_ids, reflection), nil]
-    end
-
-    #: (untyped, Array[untyped], untyped) -> [Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]]
-    def habtm_edge(owner_class, _owner_ids, reflection)
-      habtm_groups(owner_class, reflection)
-    end
-
     #: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def belongs_to_groups(owner_class, owner_ids, reflection)
       key = scalar_foreign_key(reflection)
@@ -56,9 +37,12 @@ module PaperTrailDiff
       end
 
       grouped = {} #: Hash[String, Hash[Symbol, untyped]]
+      # Grouping only decides what to preload, so a type that names no class is
+      # left to raise where that state is read.
       @records.records_for(owner_class, owner_ids).each do |owner|
         id = owner.public_send(key)
-        model_class = AssociationTraversal.belongs_to_target(reflection, owner)
+        type = owner.public_send(reflection.foreign_type).to_s
+        model_class = AssociationTraversal.named_class(type)
         add_identity(grouped, model_class, id) if model_class && id
       end
       grouped
@@ -75,28 +59,31 @@ module PaperTrailDiff
       group_for(reflection.klass, owners.values.flatten, owners: owners)
     end
 
+    # A transaction more than one owner recorded members in is left out, so
+    # its read falls back to HistoricalAssociationReifier, which raises.
     #: (untyped, untyped) -> [Hash[String, Hash[Symbol, untyped]], Hash[String, Array[untyped]]]
     def habtm_groups(owner_class, reflection)
       rows = habtm_rows(owner_class, reflection)
+      shared = HabtmTransactionOwners.new(owner_class, reflection).shared(rows.map(&:version_id))
       memberships = @transaction_ids.to_h do |transaction_id|
         [transaction_id.to_s, membership_ids(rows, transaction_id)]
       end
-      [group_for(reflection.klass, rows.filter_map(&:foreign_key_id)), memberships]
+      [group_for(reflection.klass, rows.map(&:foreign_key_id)), memberships.except(*shared)]
     end
 
     #: (untyped, untyped) -> Array[untyped]
     def habtm_rows(owner_class, reflection)
       owner_class.paper_trail.version_association_class.where(
         version_id: @transaction_ids,
-        foreign_key_name: reflection.name.to_s
-      ).to_a
+        foreign_key_name: reflection.name
+      )
     end
 
     #: (Array[untyped], untyped) -> Array[untyped]
     def membership_ids(rows, transaction_id)
       rows.filter_map do |row|
         row.foreign_key_id if row.version_id.to_s == transaction_id.to_s
-      end.uniq
+      end
     end
 
     #: (untyped, Array[untyped], untyped, String) -> Hash[String, Array[untyped]]
@@ -109,7 +96,7 @@ module PaperTrailDiff
       version_class = owner_class.paper_trail.version_class
       association_class = owner_class.paper_trail.version_association_class
       relation = historical_child_relation(owner_class, owner_ids, reflection, foreign_key)
-      pairs = child_candidate_scope(version_class).call(relation).distinct.pluck(
+      pairs = child_candidate_scope(version_class).call(relation).pluck(
         association_class.arel_table[:foreign_key_id],
         version_class.arel_table[:item_id]
       )
@@ -141,10 +128,10 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped], untyped, String) -> Hash[String, Array[untyped]]
     def live_child_ids(owner_class, owner_ids, reflection, foreign_key)
+      # Every row of the table, as history reads them: an STI subclass's
+      # siblings are left out where children are resolved.
       relation = reflection.klass.base_class.unscoped.where(foreign_key => owner_ids)
-      if reflection.options[:as]
-        relation = relation.where(reflection.type => parent_types(owner_class))
-      end
+      relation = relation.where(reflection.type => parent_types(owner_class)) if reflection.type
       group_ids_by_owner(relation.pluck(foreign_key, reflection.klass.primary_key))
     end
 
@@ -161,18 +148,15 @@ module PaperTrailDiff
 
       group = { model: model_class, ids: unique } #: Hash[Symbol, untyped]
       group[:owners] = owners if owners
-      { model_class.name.to_s => group }
+      { model_class.name => group }
     end
 
-    # Keyed rather than scanned so that a wide edge stays linear in its width.
+    # A set rather than a scan, so that a wide edge stays linear in its width.
     #: (Array[Array[untyped]]) -> Hash[String, Array[untyped]]
     def group_ids_by_owner(pairs)
-      grouped = {} #: Hash[String, Hash[untyped, true]]
-      pairs.each do |owner_id, child_id|
-        ids = grouped[owner_id.to_s] ||= {} #: Hash[untyped, true]
-        ids[child_id] = true
-      end
-      grouped.transform_values(&:keys)
+      grouped = {} #: Hash[String, Set[untyped]]
+      pairs.each { |owner_id, child_id| (grouped[owner_id.to_s] ||= Set.new) << child_id }
+      grouped.transform_values(&:to_a)
     end
 
     #: (Hash[String, Array[untyped]], Hash[String, Array[untyped]]) -> Hash[String, Array[untyped]]
@@ -183,12 +167,12 @@ module PaperTrailDiff
     #: (untyped) -> String?
     def scalar_foreign_key(reflection)
       key = reflection.foreign_key
-      key.to_s unless key.is_a?(Array)
+      key unless key.is_a?(Array)
     end
 
     #: (untyped) -> Array[String?]
     def parent_types(owner_class)
-      [nil, '', owner_class.name.to_s, owner_class.base_class.name.to_s].uniq
+      [nil, '', owner_class.name, owner_class.base_class.name]
     end
   end
 end

data/lib/paper_trail_diff/prepared_history.rb

@@ -17,14 +17,16 @@ module PaperTrailDiff
     #: (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
     def initialize(records, activity_index: nil)
       @records = records
-      @state_reader = PreparedStateAssociationReader.new(records, method(:edge))
+      @conditions = ScopeCondition::Cache.new
+      @state_reader = PreparedStateAssociationReader.new(records, method(:edge), @conditions)
       @activity_index = activity_index
       @edges = {} #: Hash[Array[String], Hash[String, Hash[Symbol, untyped]]]
       @unsupported = {} #: Hash[Array[String], bool]
       @habtm = {} #: Hash[Array[String], Hash[String, Array[untyped]]]
     end
 
-    #: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
+    # Returns every group the edge now holds.
+    #: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
     def merge_edge(owner_class, reflection, groups)
       key = edge_key(owner_class, reflection)
       empty = {} #: Hash[String, Hash[Symbol, untyped]]
@@ -62,14 +64,16 @@ module PaperTrailDiff
       @state_reader.call(owner, reflection, boundary)
     end
 
-    #: (untyped, untyped, untyped, habtm_boundary: untyped) -> [bool, Array[untyped]]
-    def resolve(record, reflection, boundary, habtm_boundary:)
-      return [false, []] unless supported?(record.class, reflection)
+    # Unranked, as a part of a has_many through is read, it returns every row
+    # the part's conditions admit, a record reached twice appearing twice.
+    #: (untyped, untyped, untyped, habtm_boundary: untyped, ?ranked: bool) -> [bool, Array[untyped]]
+    def resolve(record, reflection, boundary, habtm_boundary:, ranked: true)
+      return [false, []] unless supported?(record.class, reflection, ranked)
 
       records = if reflection.options[:through]
-                  through_records(record, reflection, boundary, habtm_boundary)
+                  through_records(record, reflection, boundary, habtm_boundary, ranked)
                 else
-                  direct_records(record, reflection, boundary, habtm_boundary)
+                  direct_records(record, reflection, boundary, habtm_boundary, ranked)
                 end
       records ? [true, records] : [false, []]
     end
@@ -81,31 +85,34 @@ module PaperTrailDiff
     # @rbs @edges: Hash[Array[String], Hash[String, Hash[Symbol, untyped]]]
     # @rbs @unsupported: Hash[Array[String], bool]
     # @rbs @habtm: Hash[Array[String], Hash[String, Array[untyped]]]
+    # @rbs @conditions: ScopeCondition::Cache
 
-    #: (untyped, untyped) -> bool
-    def supported?(owner_class, reflection)
+    # A polymorphic target's class is known only once a record names it, so
+    # belongs_to_records reads its scope for each record instead.
+    #: (untyped, untyped, bool) -> bool
+    def supported?(owner_class, reflection, ranked)
       !@unsupported[edge_key(owner_class, reflection)] &&
-        reflection.scope.nil? && !reflection.klass.default_scopes?
+        (reflection.polymorphic? || !@conditions.call(reflection, ranked: ranked).nil?)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def direct_records(record, reflection, boundary, habtm_boundary)
+    #: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def direct_records(record, reflection, boundary, habtm_boundary, ranked)
       resolver = DIRECT_RESOLVERS.fetch(reflection.macro)
-      send(resolver, record, reflection, boundary, habtm_boundary)
+      send(resolver, record, reflection, boundary, habtm_boundary, ranked)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def resolve_belongs_to(record, reflection, boundary, _habtm_boundary)
-      belongs_to_records(record, reflection, boundary)
+    #: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def resolve_belongs_to(record, reflection, boundary, _habtm_boundary, ranked)
+      belongs_to_records(record, reflection, boundary, ranked)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]
-    def resolve_children(record, reflection, boundary, _habtm_boundary)
-      child_records(record, reflection, boundary)
+    #: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]
+    def resolve_children(record, reflection, boundary, _habtm_boundary, ranked)
+      child_records(record, reflection, boundary, ranked)
     end
 
-    #: (untyped, untyped, untyped) -> Array[untyped]?
-    def belongs_to_records(record, reflection, boundary)
+    #: (untyped, untyped, untyped, bool) -> Array[untyped]?
+    def belongs_to_records(record, reflection, boundary, ranked)
       foreign_key = scalar_foreign_key(reflection)
       return unless foreign_key
 
@@ -113,20 +120,23 @@ module PaperTrailDiff
       return [] if id.nil?
 
       model_class = AssociationTraversal.belongs_to_target(reflection, record)
-      return unless model_class && @records.loaded?(model_class, id)
+      return unless model_class && @conditions.call(reflection, model_class, ranked: ranked) &&
+                    @records.loaded?(model_class, id)
 
-      Array(@records.record_before(model_class, id, boundary)).compact
+      target = Array(@records.record_before(model_class, id, boundary)).compact
+      @conditions.select(reflection, target, model_class, ranked: ranked)
     end
 
-    #: (untyped, untyped, untyped) -> Array[untyped]
-    def child_records(record, reflection, boundary)
-      edge(record.class, reflection).values.flat_map do |group|
+    #: (untyped, untyped, untyped, bool) -> Array[untyped]
+    def child_records(record, reflection, boundary, ranked)
+      children = edge(record.class, reflection).values.flat_map do |group|
         model_class = group.fetch(:model)
         child_ids_for(group, record).filter_map do |id|
           child = @records.record_before(model_class, id, boundary)
           child if child && member_of?(child, reflection, record)
         end
       end
+      @conditions.select(reflection, children, ranked: ranked)
     end
 
     #: (Hash[Symbol, untyped], untyped) -> Array[untyped]
@@ -136,8 +146,8 @@ module PaperTrailDiff
       owners ? owners.fetch(owner.id.to_s, empty) : group.fetch(:ids)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def habtm_records(record, reflection, boundary, habtm_boundary)
+    #: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def habtm_records(record, reflection, boundary, habtm_boundary, ranked)
       transaction_id = transaction_id_for(habtm_boundary)
       return unless transaction_id
 
@@ -145,37 +155,35 @@ module PaperTrailDiff
       ids = @habtm.fetch(edge_key(record.class, reflection), empty)[transaction_id.to_s]
       return unless ids
 
-      ids.filter_map do |id|
-        @records.record_before(reflection.klass, id, boundary)
-      end
+      members = ids.filter_map { |id| @records.record_before(reflection.klass, id, boundary) }
+      @conditions.select(reflection, members, ranked: ranked)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def through_records(record, reflection, boundary, habtm_boundary)
-      handled, intermediates = resolve(
-        record,
-        reflection.through_reflection,
-        boundary,
-        habtm_boundary: habtm_boundary
-      )
-      return unless handled
-
-      resolved = resolve_sources(intermediates, reflection, boundary, habtm_boundary)
-      return unless resolved.all?(&:first)
+    # A has_many through reads its parts unranked, as its query does. Its own
+    # scope applies to each row, and a ranked read then keeps a record reached
+    # twice as one member.
+    #: (untyped, untyped, untyped, untyped, bool) -> Array[untyped]?
+    def through_records(record, reflection, boundary, habtm_boundary, ranked)
+      read = lambda do |owner, part|
+        resolve(owner, part, boundary, habtm_boundary: habtm_boundary,
+                                       ranked: ranked && !reflection.collection?)
+      end
+      rows = through_rows(record, reflection, read)
+      return unless rows
 
-      unique_records(resolved.flat_map(&:last))
+      rows = @conditions.select(reflection, rows, ranked: ranked)
+      ranked ? unique_records(rows) : rows
     end
 
-    #: (Array[untyped], untyped, untyped, untyped) -> Array[[bool, Array[untyped]]]
-    def resolve_sources(intermediates, reflection, boundary, habtm_boundary)
-      intermediates.map do |intermediate|
-        resolve(
-          intermediate,
-          reflection.source_reflection,
-          boundary,
-          habtm_boundary: habtm_boundary
-        )
-      end
+    # The source records of each join record, once for each join.
+    #: (untyped, untyped, ^(untyped, untyped) -> [bool, Array[untyped]]) -> Array[untyped]?
+    def through_rows(record, reflection, read)
+      handled, joins = read.call(record, reflection.through_reflection)
+      return unless handled
+
+      joins = joins.select { |join| AssociationTraversal.source_type_join?(reflection, join) }
+      resolved = joins.map { |join| read.call(join, reflection.source_reflection) }
+      resolved.flat_map(&:last) if resolved.all?(&:first)
     end
 
     #: (untyped, untyped, untyped) -> bool
@@ -183,6 +191,7 @@ module PaperTrailDiff
       foreign_key = scalar_foreign_key(reflection)
       return false unless foreign_key
       return false unless child.public_send(foreign_key).to_s == owner.id.to_s
+      return false unless AssociationTraversal.sti_member?(reflection.klass, child.attributes)
       return true unless reflection.options[:as]
 
       owner_types(reflection, owner).include?(child.public_send(reflection.type).to_s)

data/lib/paper_trail_diff/prepared_history_loader.rb

@@ -4,16 +4,17 @@
 module PaperTrailDiff
   # Expands the explicit association tree into a request-scoped PreparedHistory.
   class PreparedHistoryLoader
-    #: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?root_ids: Array[untyped], ?start_at: untyped, ?end_at: untyped, ?live_records: Array[untyped]) -> void
+    # Without `end_at`, the activity range closes on the last root version.
+    #: (untyped, root_ids: Array[untyped], root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, start_at: untyped, end_at: untyped, live_records: Array[untyped]) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
       record,
+      root_ids:,
       root_versions:,
       tree:,
       traversal:,
-      root_ids: [record.id],
-      start_at: root_versions.first.created_at,
-      end_at: nil,
-      live_records: []
+      start_at:,
+      end_at:,
+      live_records:
     )
       @record = record
       @root_ids = root_ids
@@ -21,12 +22,12 @@ module PaperTrailDiff
       @tree = tree
       @traversal = traversal
       @records = PreparedRecordIndex.new(start_at, end_at: end_at, live_records: live_records)
-      activity = PreparedActivityIndex.new(
+      @activity = PreparedActivityIndex.new(
         @records, root_versions, start_at: start_at, end_at: end_at || root_versions.last.created_at
       )
-      @history = PreparedHistory.new(@records, activity_index: activity)
+      @history = PreparedHistory.new(@records, activity_index: @activity)
       @edges = PreparedEdgeLoader.new(@records, root_versions, start_at: start_at)
-      @prepared = {} #: Hash[Array[String], Array[String]]
+      @prepared = {} #: Hash[untyped, Array[String]]
     end
 
     #: () -> PreparedHistory
@@ -44,20 +45,18 @@ module PaperTrailDiff
     # @rbs @tree: AssociationTree
     # @rbs @traversal: AssociationTraversal
     # @rbs @records: PreparedRecordIndex
+    # @rbs @activity: PreparedActivityIndex
     # @rbs @history: PreparedHistory
     # @rbs @edges: PreparedEdgeLoader
-    # @rbs @prepared: Hash[Array[String], Array[String]]
+    # @rbs @prepared: Hash[untyped, Array[String]]
 
     #: (untyped, Array[untyped], AssociationTree, path: String) -> void
     def load_node(model_class, ids, tree, path:)
-      @history.activity_index&.register(model_class, ids)
+      @activity.register(model_class, ids)
       @traversal.reflections_for(model_class, tree, path: path).each do |reflection|
-        subtree = tree.child(reflection.name)
-        next unless subtree
-
+        subtree = tree.child(reflection.name) #: AssociationTree
         groups = prepare_reflection(model_class, ids, reflection)
-        load_groups(groups)
-        child_path = Support.association_path(path, reflection.name.to_s)
+        child_path = Support.association_path(path, reflection.name)
         groups.each_value do |group|
           load_node(group.fetch(:model), group.fetch(:ids), subtree, path: child_path)
         end
@@ -66,70 +65,66 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def prepare_reflection(owner_class, owner_ids, reflection)
-      return prepare_through(owner_class, owner_ids, reflection) if reflection.options[:through]
+      return prepare_through(owner_class, owner_ids, reflection) if reflection.through_reflection?
 
       prepare_edge(owner_class, owner_ids, reflection)
     end
 
+    # Either part can itself be a through, which has no key of its own to
+    # read, so each part is prepared as what it is. Like an edge, it returns
+    # every group it holds, not only those of these owners.
     #: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def prepare_through(owner_class, owner_ids, reflection)
-      through_groups = prepare_edge(owner_class, owner_ids, reflection.through_reflection)
+      through_groups = prepare_reflection(owner_class, owner_ids, reflection.through_reflection)
       targets = {} #: Hash[String, Hash[Symbol, untyped]]
       through_groups.each_value do |group|
-        load_groups({ group.fetch(:model).name.to_s => group })
-        source = prepare_edge(group.fetch(:model), group.fetch(:ids), reflection.source_reflection)
+        source = prepare_reflection(group.fetch(:model), group.fetch(:ids),
+                                    reflection.source_reflection)
         targets = merge_groups(targets, source)
       end
       @history.merge_edge(owner_class, reflection, targets)
-      @history.mark_unsupported(owner_class, reflection) if deferred_macro?(reflection)
-      targets
     end
 
     #: (untyped, Array[untyped], untyped) -> Hash[String, Hash[Symbol, untyped]]
     def prepare_edge(owner_class, owner_ids, reflection)
-      missing = unprepared_ids(owner_class, owner_ids, reflection)
+      missing = unprepared_ids(owner_ids, reflection)
       return @history.edge(owner_class, reflection) if missing.empty?
 
-      load_records(owner_class, missing) if reflection.macro == :belongs_to
       groups, memberships = @edges.call(owner_class, missing, reflection)
       @history.merge_edge(owner_class, reflection, groups)
       @history.register_habtm(owner_class, reflection, memberships) if memberships
-      mark_prepared(owner_class, missing, reflection)
+      mark_prepared(missing, reflection)
       mark_unsupported(owner_class, reflection, groups)
       load_groups(groups)
       @history.edge(owner_class, reflection)
     end
 
-    #: (untyped, Array[untyped], untyped) -> Array[untyped]
-    def unprepared_ids(owner_class, ids, reflection)
-      prepared = @prepared.fetch(edge_key(owner_class, reflection), [])
+    # A reflection belongs to the class that declares it, so it alone names
+    # the edge; a subclass that inherits it reads the same records.
+    #: (Array[untyped], untyped) -> Array[untyped]
+    def unprepared_ids(ids, reflection)
+      prepared = @prepared.fetch(reflection, [])
       ids.reject { |id| prepared.include?(id.to_s) }
     end
 
-    #: (untyped, Array[untyped], untyped) -> void
-    def mark_prepared(owner_class, ids, reflection)
-      key = edge_key(owner_class, reflection)
-      @prepared[key] = (@prepared.fetch(key, []) | ids.map(&:to_s))
+    #: (Array[untyped], untyped) -> void
+    def mark_prepared(ids, reflection)
+      @prepared[reflection] = (@prepared.fetch(reflection, []) | ids.map(&:to_s))
     end
 
     #: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
     def mark_unsupported(owner_class, reflection, groups)
-      unsupported = deferred_macro?(reflection) || reflection.foreign_key.is_a?(Array) ||
+      unsupported = reflection.foreign_key.is_a?(Array) ||
                     groups.values.any? { |group| !versioned?(group.fetch(:model)) }
       @history.mark_unsupported(owner_class, reflection) if unsupported
     end
 
-    #: (untyped) -> bool
-    def deferred_macro?(reflection)
-      reflection.options[:through] && !reflection.source_reflection.belongs_to?
-    end
-
     #: (Hash[String, Hash[Symbol, untyped]]) -> void
     def load_groups(groups)
       groups.each_value do |group|
         model = group.fetch(:model)
         ids = group.fetch(:ids)
-        @history.activity_index&.register(model, ids)
+        @activity.register(model, ids)
         load_records(model, ids)
       end
     end
@@ -144,11 +139,6 @@ module PaperTrailDiff
       Support.versioned?(model_class)
     end
 
-    #: (untyped, untyped) -> Array[String]
-    def edge_key(owner_class, reflection)
-      [owner_class.base_class.name.to_s, reflection.name.to_s]
-    end
-
     #: (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
     def merge_groups(left, right)
       Support.merge_record_groups(left, right)

data/lib/paper_trail_diff/prepared_record_index.rb

@@ -163,6 +163,22 @@ module PaperTrailDiff
       live ? [*recorded, live] : recorded
     end
 
+    # The classes the record had at any point, or either side of one version.
+    #: (?untyped) -> Array[untyped]
+    def model_classes(version = nil)
+      return states.map(&:model_class) unless version
+
+      states_around(version).map(&:model_class)
+    end
+
+    # The states either side of one version; a create has none before it and a
+    # destroy none after.
+    #: (untyped) -> Array[PreparedRecordState]
+    def states_around(version)
+      index = @version_positions.fetch(version.id.to_s)
+      [state_for(version), state_after(index)].compact
+    end
+
     #: (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def transition(version)
       index = @version_positions[version.id.to_s]
@@ -337,6 +353,16 @@ module PaperTrailDiff
       @series.fetch(identity(model_class, id)).versions
     end
 
+    #: (untyped, untyped, ?untyped) -> Array[untyped]
+    def model_classes(model_class, id, version = nil)
+      @series.fetch(identity(model_class, id)).model_classes(version)
+    end
+
+    #: (untyped, untyped, untyped) -> Array[PreparedRecordState]
+    def states_around(model_class, id, version)
+      @series.fetch(identity(model_class, id)).states_around(version)
+    end
+
     #: (untyped, untyped) -> bool
     def loaded?(model_class, id)
       @series.key?(identity(model_class, id))

data/lib/paper_trail_diff/prepared_snapshot_builder.rb

@@ -49,7 +49,7 @@ module PaperTrailDiff
       subtree = tree.child(reflection.name)
       return [false, nil] unless subtree
 
-      child_path = Support.association_path(path, reflection.name.to_s)
+      child_path = Support.association_path(path, reflection.name)
       records = [] #: Array[RecordSnapshot]
       states.each do |state|
         supported, snapshot = build(state, boundary, subtree, normalizer, history,