paper_trail_diff 0.12.0 → 0.13.1

data/lib/paper_trail_diff/prepared_activity_index.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Shares association event discovery across every root in a prepared graph.
+  class PreparedActivityIndex
+    #: (PreparedRecordIndex, Array[untyped], start_at: untyped, end_at: untyped) -> void
+    def initialize(records, root_versions, start_at:, end_at:)
+      @records = records
+      @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]]]
+    end
+
+    #: (untyped, Array[untyped]) -> void
+    def register(model, ids)
+      name = model.base_class.name.to_s
+      @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)
+      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)
+      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, []) }
+    end
+
+    private
+
+    # @rbs @records: PreparedRecordIndex
+    # @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]]]
+
+    #: (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)
+        end
+      end
+    end
+
+    #: (untyped) -> Array[untyped]
+    def node_ids(model)
+      name = model.base_class.name.to_s
+      @nodes.fetch(name) do
+        raise ConfigurationError,
+              "prepared activity graph is missing #{name}; " \
+              'register the model before collecting activity'
+      end
+    end
+
+    #: (untyped, untyped) -> untyped
+    def child_rows(model, reflection)
+      loader = ActivityChildCandidateLoader.new(
+        model, node_ids(model), reflection, @range
+      )
+      [loader.historical_rows.group_by { |row| row.first.to_s },
+       loader.current_pairs.group_by { |row| row.first.to_s }
+             .transform_values { |rows| rows.map(&:last) }]
+    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
+      return timestamp <= range.end_time if timestamp >= range.start_time
+      return false if event == 'destroy'
+
+      later = @records.versions_for_id(model, id)
+                      .bsearch { |version| version.created_at > timestamp }
+      !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
+      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
+    end
+  end
+end

data/lib/paper_trail_diff/prepared_edge_loader.rb

@@ -50,11 +50,15 @@ module PaperTrailDiff
     def belongs_to_groups(owner_class, owner_ids, reflection)
       key = scalar_foreign_key(reflection)
       return {} unless key
+      unless reflection.polymorphic?
+        return group_for(reflection.klass,
+                         @records.attribute_values_for(owner_class, owner_ids, key))
+      end
 
       grouped = {} #: Hash[String, Hash[Symbol, untyped]]
       @records.records_for(owner_class, owner_ids).each do |owner|
         id = owner.public_send(key)
-        model_class = target_class(reflection, owner)
+        model_class = AssociationTraversal.belongs_to_target(reflection, owner)
         add_identity(grouped, model_class, id) if model_class && id
       end
       grouped
@@ -109,7 +113,12 @@ module PaperTrailDiff
         association_class.arel_table[:foreign_key_id],
         version_class.arel_table[:item_id]
       )
-      group_ids_by_owner(pairs)
+      group_ids_by_owner(typed_child_ids(reflection.klass, pairs))
+    end
+
+    #: (untyped, Array[Array[untyped]]) -> Array[Array[untyped]]
+    def typed_child_ids(model_class, pairs)
+      pairs.map { |owner_id, child_id| [owner_id, Support.record_id(model_class, child_id)] }
     end
 
     #: (untyped, Array[untyped], untyped, String) -> untyped
@@ -139,15 +148,6 @@ module PaperTrailDiff
       group_ids_by_owner(relation.pluck(foreign_key, reflection.klass.primary_key))
     end
 
-    #: (untyped, untyped) -> untyped
-    def target_class(reflection, owner)
-      return reflection.klass unless reflection.polymorphic?
-
-      Object.const_get(owner.public_send(reflection.foreign_type).to_s)
-    rescue NameError
-      nil
-    end
-
     #: (Hash[String, Hash[Symbol, untyped]], untyped, untyped) -> void
     def add_identity(groups, model_class, id)
       group = groups[model_class.name.to_s] ||= { model: model_class, ids: [] }

data/lib/paper_trail_diff/prepared_history.rb

@@ -4,17 +4,21 @@
 module PaperTrailDiff
   # Batched record states and relationship candidates for one activity range.
   class PreparedHistory
+    attr_reader :activity_index #: PreparedActivityIndex?
+
     DIRECT_RESOLVERS = {
       belongs_to: :resolve_belongs_to,
       has_one: :resolve_children,
       has_many: :resolve_children,
-      has_and_belongs_to_many: :resolve_habtm
+      has_and_belongs_to_many: :habtm_records
     }.freeze
     private_constant :DIRECT_RESOLVERS
 
-    #: (PreparedRecordIndex) -> void
-    def initialize(records)
+    #: (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
+    def initialize(records, activity_index: nil)
       @records = records
+      @state_reader = PreparedStateAssociationReader.new(records, method(:edge))
+      @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]]]
@@ -24,7 +28,7 @@ module PaperTrailDiff
     def merge_edge(owner_class, reflection, groups)
       key = edge_key(owner_class, reflection)
       empty = {} #: Hash[String, Hash[Symbol, untyped]]
-      @edges[key] = merge_groups(@edges.fetch(key, empty), groups)
+      @edges[key] = Support.merge_record_groups(@edges.fetch(key, empty), groups)
     end
 
     #: (untyped, untyped) -> Hash[String, Hash[Symbol, untyped]]
@@ -48,6 +52,16 @@ module PaperTrailDiff
       @records.transition(model_class, id, version)
     end
 
+    #: (untyped, untyped, untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(model_class, id, version, direct: false)
+      @records.record_after(model_class, id, version, direct: direct)
+    end
+
+    #: (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def snapshot_states(owner, reflection, boundary)
+      @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)
@@ -63,6 +77,7 @@ module PaperTrailDiff
     private
 
     # @rbs @records: PreparedRecordIndex
+    # @rbs @state_reader: PreparedStateAssociationReader
     # @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]]]
@@ -70,12 +85,7 @@ module PaperTrailDiff
     #: (untyped, untyped) -> bool
     def supported?(owner_class, reflection)
       !@unsupported[edge_key(owner_class, reflection)] &&
-        reflection.scope.nil? && !default_scoped?(reflection.klass)
-    end
-
-    #: (untyped) -> bool
-    def default_scoped?(model_class)
-      model_class.default_scopes?
+        reflection.scope.nil? && !reflection.klass.default_scopes?
     end
 
     #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
@@ -94,11 +104,6 @@ module PaperTrailDiff
       child_records(record, reflection, boundary)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def resolve_habtm(record, reflection, boundary, habtm_boundary)
-      habtm_records(record, reflection, boundary, habtm_boundary)
-    end
-
     #: (untyped, untyped, untyped) -> Array[untyped]?
     def belongs_to_records(record, reflection, boundary)
       foreign_key = scalar_foreign_key(reflection)
@@ -107,7 +112,7 @@ module PaperTrailDiff
       id = record.public_send(foreign_key)
       return [] if id.nil?
 
-      model_class = belongs_to_class(record, reflection)
+      model_class = AssociationTraversal.belongs_to_target(reflection, record)
       return unless model_class && @records.loaded?(model_class, id)
 
       Array(@records.record_before(model_class, id, boundary)).compact
@@ -189,15 +194,6 @@ module PaperTrailDiff
       key.to_s unless key.is_a?(Array)
     end
 
-    #: (untyped, untyped) -> untyped
-    def belongs_to_class(record, reflection)
-      return reflection.klass unless reflection.polymorphic?
-
-      Object.const_get(record.public_send(reflection.foreign_type).to_s)
-    rescue NameError
-      nil
-    end
-
     #: (untyped, untyped) -> Array[String]
     def owner_types(reflection, owner)
       types = [owner.class.name, owner.class.base_class.name, reflection.active_record.name]
@@ -218,10 +214,5 @@ module PaperTrailDiff
     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(existing, incoming)
-      Support.merge_record_groups(existing, incoming)
-    end
   end
 end

data/lib/paper_trail_diff/prepared_history_loader.rb

@@ -17,16 +17,21 @@ module PaperTrailDiff
     )
       @record = record
       @root_ids = root_ids
+      @root_versions = root_versions
       @tree = tree
       @traversal = traversal
       @records = PreparedRecordIndex.new(start_at, end_at: end_at, live_records: live_records)
-      @history = PreparedHistory.new(@records)
+      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)
       @edges = PreparedEdgeLoader.new(@records, root_versions, start_at: start_at)
       @prepared = {} #: Hash[Array[String], Array[String]]
     end
 
     #: () -> PreparedHistory
     def call
+      @records.seed(@record.class, @root_ids, @root_versions)
       load_node(@record.class, @root_ids, @tree, path: '')
       @history
     end
@@ -35,6 +40,7 @@ module PaperTrailDiff
 
     # @rbs @record: untyped
     # @rbs @root_ids: Array[untyped]
+    # @rbs @root_versions: Array[untyped]
     # @rbs @tree: AssociationTree
     # @rbs @traversal: AssociationTraversal
     # @rbs @records: PreparedRecordIndex
@@ -44,6 +50,7 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped], AssociationTree, path: String) -> void
     def load_node(model_class, ids, tree, path:)
+      @history.activity_index&.register(model_class, ids)
       @traversal.reflections_for(model_class, tree, path: path).each do |reflection|
         subtree = tree.child(reflection.name)
         next unless subtree
@@ -119,7 +126,12 @@ module PaperTrailDiff
 
     #: (Hash[String, Hash[Symbol, untyped]]) -> void
     def load_groups(groups)
-      groups.each_value { |group| load_records(group.fetch(:model), group.fetch(:ids)) }
+      groups.each_value do |group|
+        model = group.fetch(:model)
+        ids = group.fetch(:ids)
+        @history.activity_index&.register(model, ids)
+        load_records(model, ids)
+      end
     end
 
     #: (untyped, Array[untyped]) -> void

data/lib/paper_trail_diff/prepared_record_index.rb

@@ -10,7 +10,7 @@ module PaperTrailDiff
     #: (untyped) -> void
     def initialize(record)
       @model_class = record.class
-      @attributes = Support.immutable_copy(record.attributes)
+      @attributes = stored_attributes(record.class, record.attributes)
       freeze
     end
 
@@ -36,9 +36,18 @@ module PaperTrailDiff
     #: (untyped, Hash[untyped, untyped]) -> void
     def initialize_attributes(model_class, attributes)
       @model_class = model_class
-      @attributes = Support.immutable_copy(attributes)
+      @attributes = stored_attributes(model_class, attributes)
       freeze
     end
+
+    # A live fallback and a version decoded from history must agree on what
+    # the stored history could represent, or the gap between them reads as a
+    # change.
+    #: (untyped, Hash[untyped, untyped]) -> Hash[untyped, untyped]
+    def stored_attributes(model_class, attributes)
+      digits = StoredTimePrecision.digits(model_class)
+      Support.immutable_copy(StoredTimePrecision.apply(attributes, digits))
+    end
   end
 
   # Extracts a version's scalar state without constructing a disposable AR object.
@@ -121,17 +130,37 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def record_before(boundary)
+      state_before(boundary)&.instantiate
+    end
+
+    #: (untyped) -> PreparedRecordState?
+    def state_before(boundary)
       index = boundary_index(boundary)
-      return state_for(versions.fetch(index))&.instantiate if index
+      return state_for(versions.fetch(index)) if index
+
+      @live
+    end
+
+    # A handled nil is known absence, not permission to query the current row.
+    #: (untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(version, direct: false)
+      index = @version_positions[version.id.to_s]
+      return [false, nil] unless index
 
-      @live&.instantiate
+      state = state_after(index)
+      [true, direct ? state : state&.instantiate]
     end
 
     #: () -> Array[untyped]
     def records
-      version_records = versions.filter_map { |version| state_for(version)&.instantiate }
+      states.map(&:instantiate)
+    end
+
+    #: () -> Array[PreparedRecordState]
+    def states
+      recorded = versions.filter_map { |version| state_for(version) }
       live = @live
-      live ? [*version_records, live.instantiate] : version_records
+      live ? [*recorded, live] : recorded
     end
 
     #: (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
@@ -164,11 +193,15 @@ module PaperTrailDiff
     # boundary's transaction. The first is monotonic over the chronological
     # list and the second is indexed, so neither rescans a long history once
     # per boundary.
+    #
+    # "At or after" is decided by the version order rather than the timestamp
+    # alone. A version written in the same instant as the boundary but before
+    # it already took effect there; reading its pre-change state would put the
+    # boundary on the wrong side of a change it follows.
     #: (untyped) -> Integer?
     def boundary_index(boundary)
-      created_at = boundary.created_at
       chronological = versions.bsearch_index do |candidate|
-        candidate.created_at >= created_at
+        VersionBoundary.at_or_after?(candidate, boundary)
       end
       transactional = transaction_index(boundary)
       return chronological unless transactional
@@ -200,6 +233,7 @@ module PaperTrailDiff
     #: (untyped) -> PreparedRecordState?
     def state_for(version)
       return @states[version.id] if @states.key?(version.id)
+      return @states[version.id] = nil unless version.object
 
       prepared = @state_loader.call(version)
       return @states[version.id] = prepared if prepared
@@ -226,6 +260,8 @@ module PaperTrailDiff
       end
       @state_loader = PreparedVersionStateLoader.new
       @series = {} #: Hash[Array[String], PreparedRecordSeries]
+      @direct_loader = DirectRecordStateLoader.new
+      @direct_states = {} #: Hash[PreparedRecordState, PreparedRecordState?]
     end
 
     #: (untyped, Array[untyped]) -> void
@@ -240,21 +276,67 @@ module PaperTrailDiff
       missing.each { |id| add_series(model_class, id, versions, live) }
     end
 
+    #: (untyped, Array[untyped], Array[untyped]) -> void
+    def seed(model_class, ids, versions)
+      grouped = versions.group_by { |version| version.item_id.to_s }
+      live = available_live_records(model_class, ids).to_h { |record| [record.id.to_s, record] }
+      ids.each { |id| add_series(model_class, id, grouped, live) }
+    end
+
     #: (untyped, untyped, untyped) -> untyped
     def record_before(model_class, id, boundary)
       @series.fetch(identity(model_class, id)).record_before(boundary)
     end
 
+    #: (untyped, untyped, untyped) -> [bool, PreparedRecordState?]
+    def snapshot_state_before(model_class, id, boundary)
+      series = @series[identity(model_class, id)]
+      return [false, nil] unless series
+
+      state = series.state_before(boundary)
+      return [true, nil] unless state
+
+      @direct_states[state] = @direct_loader.complete(state) unless @direct_states.key?(state)
+      prepared = @direct_states[state]
+      [!prepared.nil?, prepared]
+    end
+
     #: (untyped, untyped, untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def transition(model_class, id, version)
       @series[identity(model_class, id)]&.transition(version)
     end
 
+    #: (untyped, untyped, untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(model_class, id, version, direct: false)
+      handled, state = @series[identity(model_class, id)]&.record_after(version, direct: direct)
+      return [false, nil] unless handled
+      return [true, state] unless direct && state
+
+      prepared = @direct_loader.complete(state)
+      [!prepared.nil?, prepared]
+    end
+
     #: (untyped, Array[untyped]) -> Array[untyped]
     def records_for(model_class, ids)
       ids.flat_map { |id| @series.fetch(identity(model_class, id)).records }
     end
 
+    #: (untyped, Array[untyped], String) -> Array[untyped]
+    def attribute_values_for(model_class, ids, name)
+      plain_reader = generated_reader?(model_class, name)
+      ids.flat_map do |id|
+        @series.fetch(identity(model_class, id)).states.map do |state|
+          direct = @direct_loader.complete(state) if plain_reader
+          direct ? direct.attributes[name] : state.instantiate.public_send(name)
+        end
+      end
+    end
+
+    #: (untyped, untyped) -> Array[untyped]
+    def versions_for_id(model_class, id)
+      @series.fetch(identity(model_class, id)).versions
+    end
+
     #: (untyped, untyped) -> bool
     def loaded?(model_class, id)
       @series.key?(identity(model_class, id))
@@ -262,11 +344,19 @@ module PaperTrailDiff
 
     private
 
+    #: (untyped, String) -> bool
+    def generated_reader?(model, name)
+      model.define_attribute_methods
+      model.instance_method(name).owner.name.to_s.end_with?('GeneratedAttributeMethods')
+    end
+
     # @rbs @start_time: untyped
     # @rbs @end_time: untyped
     # @rbs @seeded_live_records: Hash[Array[String], untyped]
     # @rbs @state_loader: PreparedVersionStateLoader
     # @rbs @series: Hash[Array[String], PreparedRecordSeries]
+    # @rbs @direct_loader: DirectRecordStateLoader
+    # @rbs @direct_states: Hash[PreparedRecordState, PreparedRecordState?]
 
     # Callers bound the range with either a version or a bare timestamp.
     #: (untyped) -> untyped
@@ -314,27 +404,10 @@ module PaperTrailDiff
     #: (untyped) -> untyped
     def window_condition(version_class)
       table = version_class.arel_table
-      table[:created_at].lteq(@end_time).or(first_after_range(table))
-    end
-
-    #: (untyped) -> untyped
-    def first_after_range(table)
-      arel = Object.const_get(:Arel) #: untyped
-      later = table.alias('paper_trail_diff_later_versions')
-      arel.const_get(:SelectManager).new
-          .from(later)
-          .project(arel.sql('1'))
-          .where(preceding_trailing_version(table, later))
-          .exists
-          .not
-    end
-
-    #: (untyped, untyped) -> untyped
-    def preceding_trailing_version(table, later)
-      later[:item_type].eq(table[:item_type])
-                       .and(later[:item_id].eq(table[:item_id]))
-                       .and(later[:created_at].gt(@end_time))
-                       .and(later[:created_at].lt(table[:created_at]))
+      first_after = VersionQuery.no_earlier_version(table) do |earlier|
+        earlier[:created_at].gt(@end_time)
+      end
+      table[:created_at].lteq(@end_time).or(first_after)
     end
 
     #: (untyped, Array[untyped]) -> Array[untyped]

data/lib/paper_trail_diff/prepared_snapshot_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Normalizes supported recorded graphs without historical ActiveRecord instances.
+  class PreparedSnapshotBuilder
+    #: (AssociationTraversal) -> void
+    def initialize(traversal)
+      @traversal = traversal
+      @loader = DirectRecordStateLoader.new
+    end
+
+    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, history: PreparedHistory?) -> [bool, RecordSnapshot?]
+    def call(version, boundary, tree:, normalizer:, history:)
+      return [true, nil] unless version.object
+
+      state = @loader.call(version)
+      return [false, nil] unless state
+
+      build(state, boundary, tree, normalizer, history, path: '')
+    end
+
+    private
+
+    # @rbs @traversal: AssociationTraversal
+    # @rbs @loader: DirectRecordStateLoader
+
+    #: (PreparedRecordState, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory?, path: String, ?incoming: untyped) -> [bool, RecordSnapshot?]
+    def build(state, boundary, tree, normalizer, history, path:, incoming: nil) # rubocop:disable Metrics/ParameterLists
+      associations = {} #: snapshot_associations
+      @traversal.reflections_for(state.model_class, tree, path: path).each do |reflection|
+        return [false, nil] unless history
+
+        handled, snapshot = association(state, reflection, boundary, tree, normalizer, history,
+                                        path)
+        return [false, nil] unless handled && snapshot
+
+        associations[reflection.name.to_s] = snapshot
+      end
+      [true, normalizer.from_state(state, tree: tree, path: path,
+                                          incoming: incoming, associations: associations)]
+    end
+
+    #: (PreparedRecordState, untyped, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory, String) -> [bool, AssociationSnapshot?]
+    def association(owner, reflection, boundary, tree, normalizer, history, path) # rubocop:disable Metrics/ParameterLists
+      handled, states = history.snapshot_states(owner, reflection, boundary)
+      return [false, nil] unless handled
+
+      subtree = tree.child(reflection.name)
+      return [false, nil] unless subtree
+
+      child_path = Support.association_path(path, reflection.name.to_s)
+      records = [] #: Array[RecordSnapshot]
+      states.each do |state|
+        supported, snapshot = build(state, boundary, subtree, normalizer, history,
+                                    path: child_path, incoming: reflection)
+        return [false, nil] unless supported && snapshot
+
+        records << snapshot
+      end
+      [true, AssociationSnapshot.new(kind: reflection.macro, records: records)]
+    end
+  end
+end