paper_trail_diff 0.13.1 → 0.14.0

data/sig/generated/paper_trail_diff/scope_condition.rbs

@@ -0,0 +1,185 @@
+# Generated from lib/paper_trail_diff/scope_condition.rb with RBS::Inline
+
+module PaperTrailDiff
+  # An association scope, or its target's default scope, read as conditions
+  # on stored attributes, so membership at a boundary can be decided from each
+  # record's state there rather than by a query. A limit, offset or has_one
+  # order then ranks the records that meet the conditions (ScopeRanking). It
+  # reads the relation the scope builds once and never runs application code
+  # per record. A scope it cannot read exactly builds no condition, and the
+  # caller keeps its slower path.
+  class ScopeCondition
+    # Relation parts that leave membership to the where clause and the
+    # ranking alone.
+    RELATION_VALUES: untyped
+
+    # Types whose stored values compare in Ruby as the database compares them,
+    # named rather than referenced so that loading needs no Active Model.
+    VALUE_TYPES: untyped
+
+    TEXT_TYPE: ::String
+
+    ENUM_TYPE: ::String
+
+    BIND_PARAM: ::String
+
+    ATTRIBUTE: ::String
+
+    # Adapters that compare strings exactly by default. MySQL and SQL Server
+    # ignore case and trailing spaces by default, which Ruby cannot follow.
+    EXACT_TEXT_ADAPTERS: untyped
+
+    # Raised while reading a node that has no exact plain-Ruby reading.
+    class Unreadable < StandardError
+    end
+
+    # Whether the reflection filters its target beyond its keys at all.
+    # : (untyped) -> bool
+    def self.scoped?: (untyped) -> bool
+
+    # A through also filters by the scopes of each reflection it passes.
+    # : (untyped) -> bool
+    def self.scoped_path?: (untyped) -> bool
+
+    # Returns nil when the scope cannot be read as plain conditions and an
+    # exact ranking. A part of a has_many through is read unranked: the
+    # through's query keeps only its conditions.
+    # : (untyped, ?untyped, ?ranked: bool) -> ScopeCondition?
+    def self.build: (untyped, ?untyped, ?ranked: bool) -> ScopeCondition?
+
+    # nil when the relation picks its members by conditions alone.
+    # : (untyped, untyped, untyped) -> ScopeRanking?
+    def self.ranking: (untyped, untyped, untyped) -> ScopeRanking?
+
+    # A has_one through orders its rows by its own order and then its parts',
+    # and takes the first, so one that passes a ranked part is not read. A
+    # has_many through keeps only its parts' conditions.
+    # : (untyped) -> bool
+    def self.ranked_through?: (untyped) -> bool
+
+    # Whether any part of a through, at any depth, has a limit, an offset or
+    # a has_one order.
+    # : (untyped) -> bool
+    def self.ranked_parts?: (untyped) -> bool
+
+    # A polymorphic part's class, and so its scope, is known only per record.
+    # : (untyped) -> bool
+    def self.ranked_part?: (untyped) -> bool
+
+    # A scope that takes the owner differs per record, so it is never read.
+    # : (untyped, untyped) -> untyped
+    def self.scoped_relation: (untyped, untyped) -> untyped
+
+    # Some parts, such as the having clause `or` sets, may be present but
+    # empty.
+    # : (untyped) -> bool
+    def self.plain_relation?: (untyped) -> bool
+
+    # : (untyped, Array[untyped], ?ScopeRanking?) -> void
+    def initialize: (untyped, Array[untyped], ?ScopeRanking?) -> void
+
+    # : (Hash[String, untyped]) -> bool
+    def matches?: (Hash[String, untyped]) -> bool
+
+    # The members among records that are each the owner's by key: those that
+    # meet the conditions, then ranked.
+    # : (Array[untyped]) -> Array[untyped]
+    def members: (Array[untyped]) -> Array[untyped]
+
+    # Records that meet the conditions, as ranked; unchanged without a
+    # ranking.
+    # : (Array[untyped]) -> Array[untyped]
+    def rank: (Array[untyped]) -> Array[untyped]
+
+    # SQL compares NULL with nothing, so only an IS NULL test, an equality
+    # with nil, matches it.
+    COMPARISONS: untyped
+
+    private
+
+    @model_class: untyped
+
+    @predicate: Array[untyped]
+
+    @ranking: ScopeRanking?
+
+    # : (Array[untyped], Hash[String, untyped]) -> bool
+    def evaluate: (Array[untyped], Hash[String, untyped]) -> bool
+
+    # The form the database holds, as the scope's own values were cast.
+    # : (String, Hash[String, untyped]) -> untyped
+    def stored: (String, Hash[String, untyped]) -> untyped
+
+    # Builds each reflection's condition once per target class.
+    class Cache
+      # : () -> void
+      def initialize: () -> void
+
+      # nil when the scope cannot be read from stored attributes.
+      # : (untyped, ?untyped, ?ranked: bool) -> ScopeCondition?
+      def call: (untyped, ?untyped, ?ranked: bool) -> ScopeCondition?
+
+      # The records the reflection's scope admits, as it ranks them. Its
+      # condition must exist.
+      # : (untyped, Array[untyped], ?untyped, ranked: bool) -> Array[untyped]
+      def select: (untyped, Array[untyped], ?untyped, ranked: bool) -> Array[untyped]
+
+      @conditions: Hash[Array[untyped], ScopeCondition?]
+    end
+
+    # Compiles a where clause into nested arrays of plain comparisons.
+    class Reader
+      # : (untyped) -> void
+      def initialize: (untyped) -> void
+
+      # : (untyped) -> Array[untyped]
+      def call: (untyped) -> Array[untyped]
+
+      private
+
+      @model_class: untyped
+
+      # An Or is binary before Rails 7.2 and n-ary from it.
+      # : (untyped) -> Array[untyped]
+      def either: (untyped) -> Array[untyped]
+
+      # : (untyped) -> Array[untyped]
+      def comparison: (untyped) -> Array[untyped]
+
+      # : (Symbol, untyped) -> Array[untyped]
+      def binary: (Symbol, untyped) -> Array[untyped]
+
+      # : (untyped) -> Array[untyped]
+      def homogeneous_in: (untyped) -> Array[untyped]
+
+      # Active Record writes an empty NOT IN as a condition that is always
+      # true, and a NOT IN list holding NULL matches no row.
+      # : (Symbol, untyped, Array[untyped]) -> Array[untyped]
+      def list: (Symbol, untyped, Array[untyped]) -> Array[untyped]
+
+      # Ruby comparison stands in for SQL only on the record's own column of
+      # a type both compare alike.
+      # : (untyped) -> String
+      def column: (untyped) -> String
+
+      # : (String) -> bool
+      def comparable?: (String) -> bool
+
+      # An enum compares the values it stores, which its subtype describes. A
+      # wrapper such as a serialized or encrypted type is none of these.
+      # : (untyped) -> untyped
+      def value_type: (untyped) -> untyped
+
+      # A list that is not plain values, such as a subquery, is unreadable.
+      # : (untyped) -> Array[untyped]
+      def values: (untyped) -> Array[untyped]
+
+      # A value out of the column's range makes Active Record write a
+      # constant condition instead, so it is left unread. Active Record
+      # writes IS NULL for a value that is nil before casting, but `= NULL`,
+      # which matches nothing, for one that only casts to nil.
+      # : (untyped) -> untyped
+      def value: (untyped) -> untyped
+    end
+  end
+end

data/sig/generated/paper_trail_diff/scope_ranking.rbs

@@ -0,0 +1,117 @@
+# Generated from lib/paper_trail_diff/scope_ranking.rb with RBS::Inline
+
+module PaperTrailDiff
+  # The order, offset and limit by which a scope picks its members from the
+  # records that meet its conditions, as the database would rank them. It is
+  # read only when the order is total and every key compares in Ruby as SQL
+  # compares it; otherwise build returns nil and the caller keeps its slower
+  # path.
+  class ScopeRanking
+    DIRECTIONS: untyped
+
+    ATTRIBUTE: ::String
+
+    ENUM_TYPE: ::String
+
+    # Integers, booleans and dates sort alike everywhere. Strings follow a
+    # collation, so they are not read.
+    ORDER_TYPES: untyped
+
+    # Times sort alike only at the precision both the column and history
+    # keep. A time of day is not read: in memory it keeps the date it was
+    # given, which the database drops.
+    DATETIME_TYPE: ::String
+
+    # Where each adapter sorts NULL in an ascending order by default; a
+    # descending order reverses it. Another adapter's ranking is not read.
+    NULLS_LAST: untyped
+
+    # Places in a sort key, of which only the order counts: a value between a
+    # NULL sorted first and one sorted last, and false before true. Every
+    # value is a number, so that a descending key can negate it.
+    NULL_PLACE: untyped
+
+    VALUE_PLACE: ::Integer
+
+    BOOLEAN_VALUE: untyped
+
+    # Whether the relation picks members by rank rather than by condition
+    # alone. A has_one takes the first record its order names.
+    # : (untyped, untyped) -> bool
+    def self.ranks?: (untyped, untyped) -> bool
+
+    # A has_many, through or not, or a direct has_one is ranked per owner as
+    # its own query ranks it. A has_many through ranks the rows its join
+    # yields, a record reached twice counting twice, by its own order first.
+    # Returns nil when the ranking cannot be read exactly.
+    # : (untyped, untyped, untyped) -> ScopeRanking?
+    def self.build: (untyped, untyped, untyped) -> ScopeRanking?
+
+    # : (untyped) -> bool
+    def self.own?: (untyped) -> bool
+
+    # Active Record casts a limit to an integer but keeps an offset as given,
+    # which may be a String or SQL.
+    # : (untyped) -> bool
+    def self.plain_offset?: (untyped) -> bool
+
+    # The order's keys up to the primary key, which makes it total. Keys
+    # after it never decide anything.
+    # : (Array[untyped], untyped) -> Array[[String, bool]]?
+    def self.keys: (Array[untyped], untyped) -> Array[[ String, bool ]]?
+
+    # The record's own column, sorted plainly in one direction.
+    # : (untyped, untyped) -> String?
+    def self.column: (untyped, untyped) -> String?
+
+    # : (untyped, String) -> bool
+    def self.orderable?: (untyped, String) -> bool
+
+    # Active Record truncates a time to its column's precision before writing
+    # it, so history holds the stored value when it keeps that many digits.
+    # Times the type stores in UTC sort as the instants they name; local
+    # times repeat an hour when clocks go back.
+    # : (untyped, untyped) -> bool
+    def self.exact_time?: (untyped, untyped) -> bool
+
+    # : (untyped, Array[[String, bool]], bool, Integer?, Integer?) -> void
+    def initialize: (untyped, Array[[ String, bool ]], bool, Integer?, Integer?) -> void
+
+    # The members among records that met the scope's conditions, in order.
+    # : (Array[untyped]) -> Array[untyped]
+    def call: (Array[untyped]) -> Array[untyped]
+
+    private
+
+    @keys: Array[[ String, bool ]]
+
+    @limit: Integer?
+
+    @model_class: untyped
+
+    @nulls_last: bool
+
+    @offset: Integer?
+
+    # Keys compare in turn, and the primary key always decides. A descending
+    # key negates its places, which also moves NULL to the other end, as each
+    # adapter does by default.
+    # : (Hash[String, untyped]) -> Array[Array[Numeric]]
+    def sort_key: (Hash[String, untyped]) -> Array[Array[Numeric]]
+
+    # NULL holds the adapter's place alone, so it never compares as a value.
+    # A version saved before its column existed holds NULL there too.
+    # : (untyped) -> Array[Numeric]
+    def place: (untyped) -> Array[Numeric]
+
+    # A time as its seconds, exactly, and a date as its day number.
+    # : (untyped) -> Numeric
+    def number: (untyped) -> Numeric
+
+    # The value the database sorts by, as the key's type casts it. An enum
+    # sorts by the integer it stores; other types are compared cast, since an
+    # adapter may serialize a time or date as a wrapper, as SQL Server does.
+    # : (String, Hash[String, untyped]) -> untyped
+    def stored: (String, Hash[String, untyped]) -> untyped
+  end
+end

data/sig/generated/paper_trail_diff/scoped_analysis_builder.rbs

@@ -3,8 +3,8 @@
 module PaperTrailDiff
   # Selects both populations and checks their shared ceiling before analysis.
   class ScopedAnalysisBuilder
-    # : (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped) -> void
-    def initialize: (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped) -> void
+    # : (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped, ?activity_tree: AssociationTree?) -> void
+    def initialize: (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped, ?activity_tree: AssociationTree?) -> void
 
     # : () -> ScopedAnalysis
     def call: () -> ScopedAnalysis

data/sig/generated/paper_trail_diff/scoped_root_selection.rbs

@@ -38,8 +38,11 @@ module PaperTrailDiff
       def initialize: (records: Array[untyped], unreachable: Array[Array[String]]) -> void
     end
 
-    # : (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer) -> void
-    def initialize: (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer) -> void
+    # `activity_tree` names the association paths whose changes also select a
+    # root, as an activity analysis reports them. Without one, only a root's
+    # own versions select it.
+    # : (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer, ?activity_tree: AssociationTree?) -> void
+    def initialize: (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer, ?activity_tree: AssociationTree?) -> void
 
     # : () -> Result
     def call: () -> Result
@@ -50,6 +53,8 @@ module PaperTrailDiff
 
     @limit: Integer
 
+    @related: AssociationActivitySelection?
+
     @scope: untyped
 
     @time_range: TimeRange?
@@ -59,14 +64,28 @@ module PaperTrailDiff
     # in the window -- not to the relation or `limit:` -- so a report on one
     # record could read every id in a busy table. A subquery keeps the work
     # bounded by what the relation and the deletions actually contain.
-    # : () -> Result
-    def database_selection: () -> Result
+    # : (Array[AssociationActivitySelection::Query]) -> Result
+    def database_selection: (Array[AssociationActivitySelection::Query]) -> Result
+
+    # Comparing in SQL needs every subquery's column to share the key's type.
+    # : (Array[AssociationActivitySelection::source]) -> Array[AssociationActivitySelection::Query]?
+    def subqueries: (Array[AssociationActivitySelection::source]) -> Array[AssociationActivitySelection::Query]?
+
+    # : (Array[String]) -> Result
+    def plucked_selection: (Array[String]) -> Result
 
     # Comparing the two columns in SQL needs them to share a type: PostgreSQL
-    # rejects an integer key against a string item_id outright.
+    # rejects an integer key against a string item_id outright. A composite
+    # key names no single attribute, so it has no type and never matches.
     # : () -> bool
     def comparable_keys?: () -> bool
 
+    # : () -> Symbol?
+    def key_type: () -> Symbol?
+
+    # : (Array[AssociationActivitySelection::Query]) -> Array[String]
+    def related_missing_ids: (Array[AssociationActivitySelection::Query]) -> Array[String]
+
     # Changed in the window but without a row, found with an anti-join instead
     # of comparing two plucked lists.
     # : () -> Array[String]
@@ -81,6 +100,10 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def normalize_scope: (untyped) -> untyped
 
+    # : () -> void
+    def reject_unversioned!: () -> void
+
+    # No Integer subclass has instances, so this is `is_a?` by another name.
     # : (Integer) -> Integer
     def validate_limit: (Integer) -> Integer
 
@@ -98,8 +121,13 @@ module PaperTrailDiff
     # Deduplicate records rather than adding SQL DISTINCT: an otherwise valid
     # relation may order by joined columns or select a PostgreSQL json column.
     # Read bounded pages until the relation ends or too many unique roots appear.
-    # : (untyped) -> Array[untyped]
-    def selected_records: (untyped) -> Array[untyped]
+    # Each candidate source is an id list or a subquery; a record matching any
+    # of them is selected.
+    # : (Array[untyped]) -> Array[untyped]
+    def selected_records: (Array[untyped]) -> Array[untyped]
+
+    # : (Array[untyped]) -> untyped
+    def candidate_relation: (Array[untyped]) -> untyped
 
     # : (untyped, Integer) -> Array[untyped]
     def record_page: (untyped, Integer) -> Array[untyped]
@@ -121,6 +149,12 @@ module PaperTrailDiff
     # : () -> String
     def item_type: () -> String
 
+    # A relation delegates class methods to its model, so every mutation here,
+    # which drops `.model`, answers the same.
+    # mutant:disable
+    # : () -> untyped
+    def model: () -> untyped
+
     # : () -> untyped
     def base_class: () -> untyped
 

data/sig/generated/paper_trail_diff/snapshot_normalizer.rbs

@@ -98,6 +98,12 @@ module PaperTrailDiff
     # : (untyped, untyped, AssociationTree, String, untyped) -> AssociationSnapshot
     def association_snapshot: (untyped, untyped, AssociationTree, String, untyped) -> AssociationSnapshot
 
+    # A reified history can hold a member PaperTrail could not rebuild. A
+    # through loads a record once per join that reaches it; it is one member,
+    # as Active Record compares records by class and id.
+    # : (untyped, untyped) -> Array[untyped]
+    def members: (untyped, untyped) -> Array[untyped]
+
     # : (Array[untyped], AssociationTree, String, untyped) -> Array[RecordSnapshot]
     def normalize_children: (Array[untyped], AssociationTree, String, untyped) -> Array[RecordSnapshot]
 

data/sig/generated/paper_trail_diff/support.rbs

@@ -15,6 +15,9 @@ module PaperTrailDiff
     # : (untyped) -> Array[untyped]
     def self?.chronological_version_key: (untyped) -> Array[untyped]
 
+    # : (untyped, untyped) -> Array[untyped]
+    def self?.version_key: (untyped, untyped) -> Array[untyped]
+
     # Ordering falls back to the id whenever timestamps tie, which recovers the
     # real order only while ids increase with insertion. An autoincrement id
     # does; a UUID does not, so a tie between UUID-keyed versions is genuinely
@@ -59,8 +62,8 @@ module PaperTrailDiff
     # : (untyped, untyped) -> Integer
     def self?.compare_versions: (untyped, untyped) -> Integer
 
-    # : (String, String) -> String
-    def self?.association_path: (String, String) -> String
+    # : (String, String | Symbol) -> String
+    def self?.association_path: (String, String | Symbol) -> String
 
     # : (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
     def self?.merge_record_groups: (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]

data/sig/generated/paper_trail_diff/time_range.rbs

@@ -41,6 +41,10 @@ module PaperTrailDiff
     # : (untyped, boundary: Symbol) -> Time
     def coerce_time: (untyped, boundary: Symbol) -> Time
 
+    # Active Support 8.0 and older warn, once per process, that `to_time` will
+    # change on a zoned time, so read zoned values without it. Every branch
+    # gives the same instant, so no spec (and no mutation) can tell them apart.
+    # mutant:disable
     # : (untyped) -> Time
     def time_value: (untyped) -> Time
 

data/sig/generated/paper_trail_diff/time_version_range.rbs

@@ -3,11 +3,11 @@
 module PaperTrailDiff
   # Selects in-range root versions plus one later reconstruction boundary.
   class TimeVersionRange
-    # : (untyped, time_range: TimeRange, ?version_scope: untyped, ?live_endpoint: untyped) -> void
-    def initialize: (untyped, time_range: TimeRange, ?version_scope: untyped, ?live_endpoint: untyped) -> void
+    # : (untyped, time_range: TimeRange, version_scope: untyped, live_endpoint: untyped) -> void
+    def initialize: (untyped, time_range: TimeRange, version_scope: untyped, live_endpoint: untyped) -> void
 
-    # : (?context_required: bool) -> RootVersionPlan
-    def select_plan: (?context_required: bool) -> RootVersionPlan
+    # : (context_required: bool) -> RootVersionPlan
+    def select_plan: (context_required: bool) -> RootVersionPlan
 
     private
 

data/sig/generated/paper_trail_diff/version_association_candidate_scope.rbs

@@ -36,6 +36,13 @@ module PaperTrailDiff
     # : (Hash[Symbol, String], String, untyped) -> String
     def activity_condition: (Hash[Symbol, String], String, untyped) -> String
 
+    # A time quoted on its own takes the adapter's default precision, which on
+    # SQL Server is `datetime` and rounds to 1/300 second. Serializing through
+    # the column's type quotes it as a bound value would be, at the precision
+    # `created_at` is stored with.
+    # : (untyped, untyped) -> String
+    def quote_time: (untyped, untyped) -> String
+
     # : (untyped, String, String) -> String
     def column: (untyped, String, String) -> String
 

data/sig/generated/paper_trail_diff/version_range.rbs

@@ -3,8 +3,8 @@
 module PaperTrailDiff
   # Selects an inclusive, chronological range from a record's root versions.
   class VersionRange
-    # : (untyped, from: untyped, to: untyped, ?version_scope: untyped) -> void
-    def initialize: (untyped, from: untyped, to: untyped, ?version_scope: untyped) -> void
+    # : (untyped, from: untyped, to: untyped, version_scope: untyped) -> void
+    def initialize: (untyped, from: untyped, to: untyped, version_scope: untyped) -> void
 
     # Keep both reconstruction boundaries and the step pairs a filter implies.
     # : () -> RootVersionPlan
@@ -35,6 +35,8 @@ module PaperTrailDiff
     # : (untyped, untyped, boundary: Symbol) -> void
     def validate_boundary!: (untyped, untyped, boundary: Symbol) -> void
 
+    # The relation holds only this record's versions, so finding the id there
+    # also settles which record the version belongs to.
     # : (untyped, untyped) -> bool
     def valid_boundary?: (untyped, untyped) -> bool
   end

data/sig/generated/paper_trail_diff/version_scope_filter.rbs

@@ -12,6 +12,10 @@ module PaperTrailDiff
     # : (untyped, Array[untyped]) -> Array[untyped]
     def call: (untyped, Array[untyped]) -> Array[untyped]
 
+    # The ids of the versions the scope keeps, or nil when there is no scope.
+    # : (untyped) -> Set[untyped]?
+    def chosen_ids: (untyped) -> Set[untyped]?
+
     private
 
     @scope: untyped

data/sig/generated/paper_trail_diff.rbs

@@ -41,7 +41,9 @@ module PaperTrailDiff
   def self.analyze_many: (Array[untyped], ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?allow_expensive: bool) -> Hash[identity, Analysis]
 
   # Analyzes every root the relation reaches whose history moved inside the
-  # window. Joined duplicates are read in bounded pages and analyzed once.
+  # window. With `activity: true`, a change to a record on one of the
+  # requested association paths also counts, because the activity timeline
+  # reports it. Joined duplicates are read in bounded pages and analyzed once.
   #
   # `limit:` is required and exceeding it raises. Selection moves into the gem
   # here. The relation's own limit/offset select the live page; this separate
@@ -67,7 +69,8 @@ module PaperTrailDiff
   # : (untyped, limit: Integer?, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?historical_filter: untyped, ?max_filter_versions: Integer, ?include_deleted: bool, ?allow_expensive: bool) -> ScopedAnalysis
   def self.analyze_scope: (untyped, limit: Integer?, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?historical_filter: untyped, ?max_filter_versions: Integer, ?include_deleted: bool, ?allow_expensive: bool) -> ScopedAnalysis
 
-  # Recent root and selected-child activity through the current saved state.
+  # Recent root and selected-child activity through the current saved state,
+  # for every root that changed or whose requested associations did.
   # Historical windows remain explicit on analyze_scope; this entry point is
   # deliberately named for a report through now rather than an as-of query.
   # : (untyped, since: untyped, limit: Integer, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?snapshots: bool, ?group: Symbol?, ?include_deleted: bool, ?historical_filter: untyped, ?max_filter_versions: Integer, ?allow_expensive: bool) -> ScopedAnalysis
@@ -105,6 +108,22 @@ module PaperTrailDiff
   # JSON uses for a present null.
   # : (untyped, ?untyped) -> nested_changes
   def self.nested_changes: (untyped, ?untyped) -> nested_changes
+
+  # Reads what PaperTrail recorded with one version: its `object_changes`,
+  # typed by the version's model, as `{ "title" => <from "Draft" to "Published"> }`.
+  #
+  #   versions = PaperTrail::Version.where(id: steps.map { _1.source_boundary.version_id })
+  #   versions.to_h { [_1.id, PaperTrailDiff.recorded_changes(_1)] }
+  #
+  # A step's diff compares the states before and after an event, so it also
+  # includes anything saved without a version in between; this does not.
+  # Returns nil when nothing was recorded (no `object_changes` column, or no
+  # value for this version), which differs from a recorded empty hash. Unlike
+  # PaperTrail's `version.changeset`, it never loads the record, so it costs no
+  # query per version and still types a deleted record's changes. `ignore:`
+  # takes attribute names, as an array, and defaults to `updated_at`.
+  # : (untyped, ?ignore: Array[String | Symbol]) -> Hash[String, ValueChange]?
+  def self.recorded_changes: (untyped, ?ignore: Array[String | Symbol]) -> Hash[String, ValueChange]?
 end
 
 module PaperTrailDiff

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paper_trail_diff
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Alex Williams
@@ -67,11 +67,14 @@ files:
 - lib/paper_trail_diff/activity_root_steps.rb
 - lib/paper_trail_diff/activity_snapshot_delta.rb
 - lib/paper_trail_diff/activity_snapshot_sequence.rb
+- lib/paper_trail_diff/activity_target_candidate_loader.rb
 - lib/paper_trail_diff/activity_timeline_builder.rb
 - lib/paper_trail_diff/activity_transaction_grouper.rb
 - lib/paper_trail_diff/activity_version_collector.rb
 - lib/paper_trail_diff/analysis.rb
 - lib/paper_trail_diff/analysis_batch.rb
+- lib/paper_trail_diff/association_activity_edge.rb
+- lib/paper_trail_diff/association_activity_selection.rb
 - lib/paper_trail_diff/association_diff_traversal.rb
 - lib/paper_trail_diff/association_discovery.rb
 - lib/paper_trail_diff/association_traversal.rb
@@ -91,6 +94,7 @@ files:
 - lib/paper_trail_diff/endpoint.rb
 - lib/paper_trail_diff/engine.rb
 - lib/paper_trail_diff/errors.rb
+- lib/paper_trail_diff/habtm_transaction_owners.rb
 - lib/paper_trail_diff/historical_association_reifier.rb
 - lib/paper_trail_diff/historical_filter.rb
 - lib/paper_trail_diff/historical_snapshot_store.rb
@@ -110,8 +114,12 @@ files:
 - lib/paper_trail_diff/prepared_record_index.rb
 - lib/paper_trail_diff/prepared_snapshot_builder.rb
 - lib/paper_trail_diff/prepared_state_association_reader.rb
+- lib/paper_trail_diff/recorded_changes.rb
+- lib/paper_trail_diff/recorded_class.rb
 - lib/paper_trail_diff/root_version_plan.rb
 - lib/paper_trail_diff/root_version_selection.rb
+- lib/paper_trail_diff/scope_condition.rb
+- lib/paper_trail_diff/scope_ranking.rb
 - lib/paper_trail_diff/scoped_analysis.rb
 - lib/paper_trail_diff/scoped_analysis_builder.rb
 - lib/paper_trail_diff/scoped_root_selection.rb
@@ -160,11 +168,14 @@ files:
 - sig/generated/paper_trail_diff/activity_root_steps.rbs
 - sig/generated/paper_trail_diff/activity_snapshot_delta.rbs
 - sig/generated/paper_trail_diff/activity_snapshot_sequence.rbs
+- sig/generated/paper_trail_diff/activity_target_candidate_loader.rbs
 - sig/generated/paper_trail_diff/activity_timeline_builder.rbs
 - sig/generated/paper_trail_diff/activity_transaction_grouper.rbs
 - sig/generated/paper_trail_diff/activity_version_collector.rbs
 - sig/generated/paper_trail_diff/analysis.rbs
 - sig/generated/paper_trail_diff/analysis_batch.rbs
+- sig/generated/paper_trail_diff/association_activity_edge.rbs
+- sig/generated/paper_trail_diff/association_activity_selection.rbs
 - sig/generated/paper_trail_diff/association_diff_traversal.rbs
 - sig/generated/paper_trail_diff/association_discovery.rbs
 - sig/generated/paper_trail_diff/association_traversal.rbs
@@ -184,6 +195,7 @@ files:
 - sig/generated/paper_trail_diff/endpoint.rbs
 - sig/generated/paper_trail_diff/engine.rbs
 - sig/generated/paper_trail_diff/errors.rbs
+- sig/generated/paper_trail_diff/habtm_transaction_owners.rbs
 - sig/generated/paper_trail_diff/historical_association_reifier.rbs
 - sig/generated/paper_trail_diff/historical_filter.rbs
 - sig/generated/paper_trail_diff/historical_snapshot_store.rbs
@@ -203,8 +215,12 @@ files:
 - sig/generated/paper_trail_diff/prepared_record_index.rbs
 - sig/generated/paper_trail_diff/prepared_snapshot_builder.rbs
 - sig/generated/paper_trail_diff/prepared_state_association_reader.rbs
+- sig/generated/paper_trail_diff/recorded_changes.rbs
+- sig/generated/paper_trail_diff/recorded_class.rbs
 - sig/generated/paper_trail_diff/root_version_plan.rbs
 - sig/generated/paper_trail_diff/root_version_selection.rbs
+- sig/generated/paper_trail_diff/scope_condition.rbs
+- sig/generated/paper_trail_diff/scope_ranking.rbs
 - sig/generated/paper_trail_diff/scoped_analysis.rbs
 - sig/generated/paper_trail_diff/scoped_analysis_builder.rbs
 - sig/generated/paper_trail_diff/scoped_root_selection.rbs
@@ -238,11 +254,11 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   bug_tracker_uri: https://github.com/aheathwilliams/paper_trail_diff/issues
-  changelog_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.13.1/CHANGELOG.md
-  documentation_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.13.1/README.md
+  changelog_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.14.0/CHANGELOG.md
+  documentation_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.14.0/README.md
   homepage_uri: https://github.com/aheathwilliams/paper_trail_diff
   rubygems_mfa_required: 'true'
-  source_code_uri: https://github.com/aheathwilliams/paper_trail_diff/tree/v0.13.1
+  source_code_uri: https://github.com/aheathwilliams/paper_trail_diff/tree/v0.14.0
 rdoc_options: []
 require_paths:
 - lib