paper_trail_diff 0.13.1 → 0.14.0

data/sig/generated/paper_trail_diff/association_activity_selection.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/paper_trail_diff/association_activity_selection.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Finds the roots whose requested associations changed in a window, so that
+  # selecting by activity includes a record whose own row did not change.
+  #
+  # A root qualifies when a record on one of its requested paths has a version
+  # in the window while it belonged to that root: when the window opened, or
+  # after a change inside it. Those are the memberships PT-AT recorded, and the
+  # ones an activity analysis reads. For `has_many :through`, the join rows are
+  # on the path too, since creating or destroying one changes membership.
+  #
+  # Each edge is one query, walked from the leaves toward the root, never one
+  # per root. Ids stay in a subquery while the columns compared share a type;
+  # otherwise they are read and the edge runs over them in slices.
+  class AssociationActivitySelection
+    SLICE: ::Integer
+
+    # The ids a one-column subquery selects, with that column's type: a
+    # database compares columns of one type only, and PostgreSQL rejects an
+    # integer key against a string item_id outright.
+    class Query
+      attr_reader relation: untyped
+
+      attr_reader column: untyped
+
+      attr_reader type: Symbol?
+
+      # : (untyped, untyped, Symbol?) -> void
+      def initialize: (untyped, untyped, Symbol?) -> void
+
+      # A key PT-AT recorded as empty names no record, so it is left out.
+      # : () -> Array[untyped]
+      def values: () -> Array[untyped]
+
+      # The ids with no match in `keys`, a subquery of the keys that exist.
+      # : (untyped) -> Array[untyped]
+      def missing: (untyped) -> Array[untyped]
+    end
+
+    type source = Query | Array[untyped]
+
+    # Every id the sources name, read from the database where needed.
+    # : (Array[source]) -> Array[untyped]
+    def self.values: (Array[source]) -> Array[untyped]
+
+    # : (untyped, tree: AssociationTree, time_range: TimeRange?) -> void
+    def initialize: (untyped, tree: AssociationTree, time_range: TimeRange?) -> void
+
+    # The roots' ids, each source a subquery or an array of values.
+    # : () -> Array[source]
+    def call: () -> Array[source]
+
+    private
+
+    @model: untyped
+
+    @time_range: TimeRange?
+
+    @traversal: AssociationTraversal
+
+    # Ids of `model` records with a change somewhere below them in `tree`: the
+    # targets that changed, or that reach a change further down.
+    # : (untyped, AssociationTree, String) -> Array[source]
+    def reach: (untyped, AssociationTree, String) -> Array[source]
+
+    # : (untyped, Array[source]) -> Array[source]
+    def owners: (untyped, Array[source]) -> Array[source]
+
+    # A join row that changes moves membership as surely as a target that does.
+    # : (untyped, Array[source]) -> Array[source]
+    def through_owners: (untyped, Array[source]) -> Array[source]
+
+    # Under `source_type:`, only join rows of that type are members, so only
+    # targets of that type and changes to those rows count.
+    # : (untyped, Array[source], untyped) -> Array[source]
+    def typed_joins: (untyped, Array[source], untyped) -> Array[source]
+
+    # A polymorphic key's targets are known only from the types its rows name,
+    # and a path stops at one, so only the targets' own changes count.
+    # : (untyped) -> Array[source]
+    def polymorphic_owners: (untyped) -> Array[source]
+
+    # : (untyped) -> Array[AssociationActivityEdge]
+    def edges: (untyped) -> Array[AssociationActivityEdge]
+
+    # Records with a version in the window, or only those of them `item_ids`
+    # selects: under `source_type:`, the join rows that had that type.
+    # : (untyped, ?untyped) -> Array[source]
+    def changed: (untyped, ?untyped) -> Array[source]
+
+    # One edge for each source. A subquery whose column type matches the
+    # filtered column stays a subquery; anything else is read, and the edge
+    # runs over its values in slices.
+    # : (AssociationActivityEdge, Array[source]) -> Array[source]
+    def follow: (AssociationActivityEdge, Array[source]) -> Array[source]
+
+    # : (AssociationActivityEdge, Array[untyped]) -> Array[untyped]
+    def read: (AssociationActivityEdge, Array[untyped]) -> Array[untyped]
+
+    # Sources are only ever a Query or a plain Array, so the one mutation
+    # left, `instance_of?` for `is_a?`, cannot change an answer.
+    # mutant:disable
+    # : (source, Symbol?) -> Query?
+    def subquery: (source, Symbol?) -> Query?
+
+    # A type naming no class has no versions to read; `changed` skips one that
+    # names an unversioned class.
+    # : (String) -> untyped
+    def target_class: (String) -> untyped
+  end
+end

data/sig/generated/paper_trail_diff/association_discovery.rbs

@@ -45,11 +45,9 @@ module PaperTrailDiff
     # : (untyped, String, untyped, bool) -> AssociationDescriptor
     def descriptor_for: (untyped, String, untyped, bool) -> AssociationDescriptor
 
-    # : (untyped) -> Array[untyped]
-    def supported_reflections: (untyped) -> Array[untyped]
-
-    # : (untyped, untyped) -> bool
-    def paper_trail_versions?: (untyped, untyped) -> bool
+    # Only what a request accepts, so every listed path can be requested.
+    # : (untyped, root: bool) -> Array[untyped]
+    def supported_reflections: (untyped, root: bool) -> Array[untyped]
 
     # : (untyped) -> untyped
     def reflection_target: (untyped) -> untyped

data/sig/generated/paper_trail_diff/association_traversal.rbs

@@ -4,10 +4,80 @@ module PaperTrailDiff
   # Resolves and validates ActiveRecord reflections for a bounded association tree.
   class AssociationTraversal
     # The class a `belongs_to` points at for this record, reading a polymorphic
-    # type column when there is one. Nil when that type names no class.
+    # type column when there is one. Nil when the record points at nothing.
     # : (untyped, untyped) -> untyped
     def self.belongs_to_target: (untyped, untyped) -> untyped
 
+    # A through with `source_type:` reaches only the join records whose type
+    # column names that class, as Active Record's `where(type => source_type)`.
+    # A through's `foreign_type` is its polymorphic source's.
+    # : (untyped, untyped) -> bool
+    def self.source_type_join?: (untyped, untyped) -> bool
+
+    # The same check for a join row read as stored attributes, given the
+    # value of its type column.
+    # : (untyped, untyped) -> bool
+    def self.source_type_member?: (untyped, untyped) -> bool
+
+    # The class a stored type names, or nil when it names none.
+    # This class defines no constants of its own, so the one mutation left,
+    # `const_get` on it rather than on Object, finds the same class.
+    # mutant:disable
+    # : (String) -> untyped
+    def self.named_class: (String) -> untyped
+
+    # A type left by a renamed or removed model names no class. Active Record
+    # and PT-AT raise a bare NameError for it, which does not say where it is.
+    # : (untyped, untyped, String) -> untyped
+    def self.polymorphic_target: (untyped, untyped, String) -> untyped
+
+    # Why a request cannot name this association of the model, or nil when it
+    # can; `root` says whether the model is the record the request compares.
+    # Discovery lists only the associations this accepts, so every path it
+    # lists can be requested. A has_many :through Active Record cannot follow
+    # raises Active Record's own error.
+    # : (untyped, untyped, root: bool) -> String?
+    def self.unsupported_reason: (untyped, untyped, root: bool) -> String?
+
+    # PT-AT records a HABTM's membership only when its owner saves a version,
+    # in rows keyed by transaction and association name, not by owner. A root
+    # checkpoint so holds the root's membership and no one else's: another
+    # record's HABTM would read the root's rows, or none.
+    # : (untyped) -> String
+    def self.habtm_below_root: (untyped) -> String
+
+    # PT-AT records a HABTM's membership by loading the association, scope and
+    # target default scope applied, so a target outside the scope when the
+    # owner saved is never recorded. One that enters it before the next save
+    # is a member then that history cannot hold.
+    # : (untyped, bool) -> String?
+    def self.habtm_reason: (untyped, bool) -> String?
+
+    # : (untyped, untyped) -> bool
+    def self.paper_trail_versions?: (untyped, untyped) -> bool
+
+    # Active Record joins a HABTM through a hidden model of its own, which has
+    # no versions and no reader that PT-AT or prepared history can follow, so a
+    # through that crosses one would fail partway through reconstruction.
+    #
+    # The through and source reflections of a through are the hidden ones, a
+    # has_many in place of each HABTM, so only the public reflection of the
+    # same name shows the HABTM. Active Record's own check, which it runs on
+    # first use anyway, explains a through it cannot follow before the chain
+    # below it is read.
+    # : (untyped) -> untyped
+    def self.habtm_in_chain: (untyped) -> untyped
+
+    attr_reader tree: AssociationTree
+
+    # Whether a row belongs to an association whose class is `model_class`.
+    # Children are found by key across the whole table, so an association to an
+    # STI subclass has to leave out its siblings, as Active Record's type
+    # condition does for the live association: the row's type must name the
+    # class or one of its descendants. A base class takes every row.
+    # : (untyped, Hash[String, untyped]) -> bool
+    def self.sti_member?: (untyped, Hash[String, untyped]) -> bool
+
     # : (AssociationTree) -> void
     def initialize: (AssociationTree) -> void
 
@@ -29,9 +99,15 @@ module PaperTrailDiff
     # : (untyped) -> void
     def reject_live_habtm_activity!: (untyped) -> void
 
+    # A model and a tree resolve to the same reflections wherever they are
+    # read: a tree is only ever walked from one place, the root tree at the
+    # root and a subtree below it. Beyond that, the path only names a failure,
+    # and a failure is not cached.
     # : (untyped, AssociationTree, path: String) -> Array[untyped]
     def reflections_for: (untyped, AssociationTree, path: String) -> Array[untyped]
 
+    # Active Record names keys as strings. A polymorphic child also points back
+    # with its type column; `type` is nil for any other.
     # : (untyped) -> Array[String]
     def incoming_relationship_columns: (untyped) -> Array[String]
 
@@ -47,19 +123,18 @@ module PaperTrailDiff
     # : (untyped, AssociationTree, path: String) -> void
     def validate_tree!: (untyped, AssociationTree, path: String) -> void
 
+    # A polymorphic target's class differs from record to record, so the
+    # associations a path names below it may not exist on every target.
+    # : (untyped, AssociationTree, String) -> void
+    def reject_polymorphic_descent!: (untyped, AssociationTree, String) -> void
+
     # : (untyped, AssociationTree, String) -> Array[untyped]
     def requested_reflections: (untyped, AssociationTree, String) -> Array[untyped]
 
-    # : (untyped, String, String) -> untyped
-    def resolve_reflection: (untyped, String, String) -> untyped
-
-    # : (untyped, untyped) -> bool
-    def paper_trail_versions?: (untyped, untyped) -> bool
+    # : (untyped, String, String, root: bool) -> untyped
+    def resolve_reflection: (untyped, String, String, root: bool) -> untyped
 
     # : (untyped) -> bool
     def habtm_reflection?: (untyped) -> bool
-
-    # : (String, String) -> String
-    def join_path: (String, String) -> String
   end
 end

data/sig/generated/paper_trail_diff/batch_safety.rbs

@@ -6,8 +6,8 @@ module PaperTrailDiff
     # : (AssociationTraversal, allow_expensive: bool) -> void
     def initialize: (AssociationTraversal, allow_expensive: bool) -> void
 
-    # : (untyped, ?historical: bool) -> void
-    def call: (untyped, ?historical: bool) -> void
+    # : (untyped) -> void
+    def call: (untyped) -> void
 
     private
 
@@ -15,9 +15,15 @@ module PaperTrailDiff
 
     @traversal: AssociationTraversal
 
-    # : (untyped, String, bool) -> void
-    def check: (untyped, String, bool) -> void
+    # A has_many through reads its parts' conditions only, at any depth. A
+    # has_one through over a ranked part is refused whole, so its parts, too,
+    # are checked for conditions alone.
+    # : (untyped, String, ?ranked: bool) -> void
+    def check: (untyped, String, ?ranked: bool) -> void
 
+    # A scope prepared history can read as conditions on stored attributes
+    # is batched like any other path. A polymorphic target's class, and so
+    # its scope, is known only per record.
     # : (untyped, bool) -> String?
     def reason_for: (untyped, bool) -> String?
   end

data/sig/generated/paper_trail_diff/batched_root_versions.rbs

@@ -5,8 +5,8 @@ module PaperTrailDiff
   # queries. Only the range forms that mean the same thing for every root are
   # supported: a shared wall-clock window, or each root's own whole history.
   class BatchedRootVersions
-    # : (Array[untyped], time_range: TimeRange?, ?version_scope: untyped, ?live_endpoints: Hash[Array[String], untyped]?, ?context_required: bool) -> void
-    def initialize: (Array[untyped], time_range: TimeRange?, ?version_scope: untyped, ?live_endpoints: Hash[Array[String], untyped]?, ?context_required: bool) -> void
+    # : (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool) -> void
+    def initialize: (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool) -> void
 
     # Returns a plan per record identity.
     # : () -> Hash[Array[String], RootVersionPlan]
@@ -54,11 +54,5 @@ module PaperTrailDiff
 
     # : (untyped, Array[untyped]) -> untyped
     def base_scope: (untyped, Array[untyped]) -> untyped
-
-    # : (untyped) -> Array[untyped]
-    def ordered: (untyped) -> Array[untyped]
-
-    # : (untyped, untyped) -> Array[String]
-    def identity: (untyped, untyped) -> Array[String]
   end
 end

data/sig/generated/paper_trail_diff/comparison_batch.rbs

@@ -3,8 +3,11 @@
 module PaperTrailDiff
   # Validates and executes independent comparisons with shared live endpoint loading.
   class ComparisonBatch
-    # : (Array[comparison_input], live_loader: untyped, preparer: untyped, history_preparer: untyped, historical_snapshotter: untyped, live_normalizer: untyped) -> void
-    def initialize: (Array[comparison_input], live_loader: untyped, preparer: untyped, history_preparer: untyped, historical_snapshotter: untyped, live_normalizer: untyped) -> void
+    # `history_preparer` prepares roots that have a live endpoint to collect a
+    # graph from; `version_history_preparer` prepares roots compared only
+    # between versions.
+    # : (Array[comparison_input], live_loader: untyped, preparer: untyped, history_preparer: untyped, version_history_preparer: untyped, historical_snapshotter: untyped, live_normalizer: untyped) -> void
+    def initialize: (Array[comparison_input], live_loader: untyped, preparer: untyped, history_preparer: untyped, version_history_preparer: untyped, historical_snapshotter: untyped, live_normalizer: untyped) -> void
 
     # : () -> comparison_results
     def call: () -> comparison_results
@@ -23,6 +26,8 @@ module PaperTrailDiff
 
     @preparer: untyped
 
+    @version_history_preparer: untyped
+
     # : (Array[[untyped, untyped]]) -> Hash[identity, RecordSnapshot]
     def prepared_live_snapshots: (Array[[ untyped, untyped ]]) -> Hash[identity, RecordSnapshot]
 
@@ -53,8 +58,21 @@ module PaperTrailDiff
     # : (Array[[untyped, untyped]], Hash[identity, untyped]) -> void
     def prepare_historical_batches!: (Array[[ untyped, untyped ]], Hash[identity, untyped]) -> void
 
-    # : (Array[[untyped, untyped]], Hash[identity, untyped]) -> Array[untyped]
-    def historical_versions: (Array[[ untyped, untyped ]], Hash[identity, untyped]) -> Array[untyped]
+    # A root compared only between versions has no live endpoint, and its row
+    # may be gone. Without prepared history, PT-AT finds a has_many's children
+    # by the keys each version recorded after its change, so it misses a child
+    # that later moved to another owner. Such roots are prepared from identity
+    # alone, like deleted ones. Their history still reads the live rows it
+    # needs: a record's current row is its state after its last version.
+    # : (Array[untyped]) -> void
+    def prepare_version_roots!: (Array[untyped]) -> void
+
+    # The record supplies identity and model metadata only.
+    # : (untyped, untyped) -> untyped
+    def historical_root: (untyped, untyped) -> untyped
+
+    # : (Array[[untyped, untyped]]) -> Array[untyped]
+    def historical_versions: (Array[[ untyped, untyped ]]) -> Array[untyped]
 
     # : () -> Array[[untyped, untyped]]
     def comparison_pairs: () -> Array[[ untyped, untyped ]]

data/sig/generated/paper_trail_diff/deleted_analysis_batch.rbs

@@ -3,8 +3,10 @@
 module PaperTrailDiff
   # Analyzes missing roots together without pretending that they have live rows.
   class DeletedAnalysisBatch
-    # : (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, ?version_scope: untyped) -> void
-    def initialize: (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, ?version_scope: untyped) -> void
+    # `context_required` reads a root that did not change in the window from
+    # the version after it, so its associations' activity can be reported.
+    # : (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, version_scope: untyped, context_required: bool) -> void
+    def initialize: (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, version_scope: untyped, context_required: bool) -> void
 
     # : () -> Hash[Array[String], Analysis?]
     def call: () -> Hash[Array[String], Analysis?]
@@ -16,6 +18,8 @@ module PaperTrailDiff
 
     @analyzer: untyped
 
+    @context_required: bool
+
     @history_preparer: untyped
 
     @identities: Array[Array[String]]
@@ -26,11 +30,19 @@ module PaperTrailDiff
 
     @version_scope: untyped
 
+    # A root destroyed before the window had no state inside it to read, so
+    # only the others take the version after the window as context.
+    # : (Array[untyped], Array[untyped]) -> Hash[Array[String], RootVersionPlan]
+    def plans: (Array[untyped], Array[untyped]) -> Hash[Array[String], RootVersionPlan]
+
+    # : (Array[untyped], bool) -> Hash[Array[String], RootVersionPlan]
+    def plans_for: (Array[untyped], bool) -> Hash[Array[String], RootVersionPlan]
+
     # These records supply identity and model metadata only. Every reported
     # value comes from the batched historical plan; no per-root reify or live
     # lookup is needed to get into the comparison engine.
-    # : () -> Array[untyped]
-    def historical_roots: () -> Array[untyped]
+    # : (Array[untyped]) -> Array[untyped]
+    def historical_roots: (Array[untyped]) -> Array[untyped]
 
     # : () -> Array[untyped]
     def destroy_versions: () -> Array[untyped]

data/sig/generated/paper_trail_diff/diagnostics.rbs

@@ -64,8 +64,13 @@ module PaperTrailDiff
     # : (Array[Array[untyped]]) -> void
     def inspect_targets: (Array[Array[untyped]]) -> void
 
-    # : (Array[Array[untyped]]) -> void
-    def inspect_habtm: (Array[Array[untyped]]) -> void
+    # : (untyped, Array[Array[untyped]]) -> void
+    def inspect_habtm: (untyped, Array[Array[untyped]]) -> void
+
+    # 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: (untyped, Array[Array[untyped]]) -> void
 
     # : () -> void
     def inspect_version_sequence: () -> void

data/sig/generated/paper_trail_diff/direct_record_state_loader.rbs

@@ -27,6 +27,12 @@ module PaperTrailDiff
     # : (untyped) -> bool
     def plain_model?: (untyped) -> bool
 
+    # 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?: (untyped) -> bool
+
     # : (untyped) -> bool
     def plain_attributes?: (untyped) -> bool
 

data/sig/generated/paper_trail_diff/errors.rbs

@@ -75,7 +75,8 @@ module PaperTrailDiff
   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
 

data/sig/generated/paper_trail_diff/habtm_transaction_owners.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/paper_trail_diff/habtm_transaction_owners.rb with RBS::Inline
+
+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: (untyped, untyped) -> void
+
+    # The given transactions (one id or several) in which more than one
+    # possible owner saved a version, as strings.
+    # : (untyped) -> Array[String]
+    def shared: (untyped) -> Array[String]
+
+    # 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?: (untyped) -> bool
+
+    # : (untyped) -> void
+    def ensure_single_owner!: (untyped) -> void
+
+    private
+
+    @associations: untyped
+
+    @name: String
+
+    @owner_types: Hash[String, bool]
+
+    @versions: untyped
+
+    # 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?: (String) -> bool
+  end
+end

data/sig/generated/paper_trail_diff/historical_association_reifier.rbs

@@ -22,6 +22,14 @@ module PaperTrailDiff
     # : (untyped, untyped) -> void
     def reify_association: (untyped, untyped) -> void
 
+    # : (untyped, untyped) -> void
+    def reify_belongs_to: (untyped, untyped) -> void
+
+    # 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!: (untyped, untyped) -> void
+
     # : (untyped, untyped) -> void
     def reify_has_many: (untyped, untyped) -> void
 
@@ -30,6 +38,11 @@ module PaperTrailDiff
     # : (untyped, untyped) -> void
     def reify_through: (untyped, untyped) -> void
 
+    # 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?: (untyped) -> bool
+
     # : (untyped, untyped, untyped) -> Array[untyped]
     def through_members: (untyped, untyped, untyped) -> Array[untyped]
 

data/sig/generated/paper_trail_diff/historical_snapshot_store.rbs

@@ -12,8 +12,9 @@ module PaperTrailDiff
     # : (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
     def prepare_batch: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
 
-    # 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: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
 

data/sig/generated/paper_trail_diff/live_endpoint_batch_loader.rbs

@@ -25,6 +25,11 @@ module PaperTrailDiff
     # : (untyped, AssociationTree) -> Array[[untyped, AssociationTree]]
     def selected_reflections: (untyped, AssociationTree) -> Array[[ untyped, AssociationTree ]]
 
+    # 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: (Array[untyped], Array[[ untyped, AssociationTree ]]) -> void
+
     # : (Array[untyped], Array[[untyped, AssociationTree]], individually: bool) -> void
     def preload_subtrees: (Array[untyped], Array[[ untyped, AssociationTree ]], individually: bool) -> void
 
@@ -34,9 +39,21 @@ module PaperTrailDiff
     # : () -> untyped
     def active_record_preloader: () -> untyped
 
+    # 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?: (untyped, untyped) -> bool
 
+    # : (untyped) -> bool
+    def cut_part?: (untyped) -> bool
+
+    # Every part a through passes, at any depth.
+    # : (untyped) -> Array[untyped]
+    def through_parts: (untyped) -> Array[untyped]
+
     # : (Array[untyped], untyped) -> Array[untyped]
     def load_individually: (Array[untyped], untyped) -> Array[untyped]
 

data/sig/generated/paper_trail_diff/paper_trail_adapter.rbs

@@ -41,6 +41,11 @@ module PaperTrailDiff
 
     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: (untyped, bool) -> void
+
     # : (Array[comparison_input], preparer: untyped) -> ComparisonBatch
     def comparison_batch: (Array[comparison_input], preparer: untyped) -> ComparisonBatch