paper_trail_diff 0.14.0 → 0.15.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paper_trail_diff
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Alex Williams
@@ -9,6 +9,26 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
 - !ruby/object:Gem::Dependency
   name: paper_trail
   requirement: !ruby/object:Gem::Requirement
@@ -59,7 +79,6 @@ files:
 - lib/paper_trail_diff/activity_event_record_resolver.rb
 - lib/paper_trail_diff/activity_event_route_finder.rb
 - lib/paper_trail_diff/activity_event_snapshot_refresher.rb
-- lib/paper_trail_diff/activity_grouping.rb
 - lib/paper_trail_diff/activity_history.rb
 - lib/paper_trail_diff/activity_range.rb
 - lib/paper_trail_diff/activity_relationship.rb
@@ -70,30 +89,38 @@ files:
 - 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_tree_filter.rb
 - lib/paper_trail_diff/activity_version_collector.rb
+- lib/paper_trail_diff/activity_view.rb
 - lib/paper_trail_diff/analysis.rb
 - lib/paper_trail_diff/analysis_batch.rb
+- lib/paper_trail_diff/approximate_paths.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_key.rb
 - lib/paper_trail_diff/association_traversal.rb
 - lib/paper_trail_diff/batch_boundary_resolver.rb
-- lib/paper_trail_diff/batch_safety.rb
+- lib/paper_trail_diff/batch_preload.rb
 - lib/paper_trail_diff/batched_root_analyzer.rb
 - lib/paper_trail_diff/batched_root_versions.rb
 - lib/paper_trail_diff/branch_snapshot_refresher.rb
+- lib/paper_trail_diff/change_row.rb
 - lib/paper_trail_diff/collection_comparator.rb
 - lib/paper_trail_diff/collection_identity_index.rb
 - lib/paper_trail_diff/collection_transition.rb
 - lib/paper_trail_diff/comparison_batch.rb
 - lib/paper_trail_diff/configuration.rb
 - lib/paper_trail_diff/deleted_analysis_batch.rb
+- lib/paper_trail_diff/deleted_root_filter.rb
+- lib/paper_trail_diff/deprecation.rb
 - lib/paper_trail_diff/diagnostics.rb
 - lib/paper_trail_diff/direct_record_state_loader.rb
 - lib/paper_trail_diff/endpoint.rb
 - lib/paper_trail_diff/engine.rb
 - lib/paper_trail_diff/errors.rb
+- lib/paper_trail_diff/fallback_paths.rb
 - lib/paper_trail_diff/habtm_transaction_owners.rb
 - lib/paper_trail_diff/historical_association_reifier.rb
 - lib/paper_trail_diff/historical_filter.rb
@@ -129,12 +156,12 @@ files:
 - lib/paper_trail_diff/step.rb
 - lib/paper_trail_diff/stored_time_precision.rb
 - lib/paper_trail_diff/support.rb
-- lib/paper_trail_diff/time_activity_timeline_builder.rb
 - lib/paper_trail_diff/time_range.rb
 - lib/paper_trail_diff/time_version_range.rb
 - lib/paper_trail_diff/timeline_builder.rb
 - lib/paper_trail_diff/timeline_range.rb
 - lib/paper_trail_diff/timeline_snapshot_provider.rb
+- lib/paper_trail_diff/transaction_cut.rb
 - lib/paper_trail_diff/traversal.rb
 - lib/paper_trail_diff/traversal_emitter.rb
 - lib/paper_trail_diff/traversal_entry.rb
@@ -147,6 +174,7 @@ files:
 - lib/paper_trail_diff/version_range.rb
 - lib/paper_trail_diff/version_scope_filter.rb
 - lib/paper_trail_diff/version_sequence_diagnostics.rb
+- lib/paper_trail_diff/version_table.rb
 - sig/generated/paper_trail_diff.rbs
 - sig/generated/paper_trail_diff/activity_belongs_to_event_applier.rbs
 - sig/generated/paper_trail_diff/activity_boundary.rbs
@@ -160,7 +188,6 @@ files:
 - sig/generated/paper_trail_diff/activity_event_record_resolver.rbs
 - sig/generated/paper_trail_diff/activity_event_route_finder.rbs
 - sig/generated/paper_trail_diff/activity_event_snapshot_refresher.rbs
-- sig/generated/paper_trail_diff/activity_grouping.rbs
 - sig/generated/paper_trail_diff/activity_history.rbs
 - sig/generated/paper_trail_diff/activity_range.rbs
 - sig/generated/paper_trail_diff/activity_relationship.rbs
@@ -171,30 +198,38 @@ files:
 - 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_tree_filter.rbs
 - sig/generated/paper_trail_diff/activity_version_collector.rbs
+- sig/generated/paper_trail_diff/activity_view.rbs
 - sig/generated/paper_trail_diff/analysis.rbs
 - sig/generated/paper_trail_diff/analysis_batch.rbs
+- sig/generated/paper_trail_diff/approximate_paths.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_key.rbs
 - sig/generated/paper_trail_diff/association_traversal.rbs
 - sig/generated/paper_trail_diff/batch_boundary_resolver.rbs
-- sig/generated/paper_trail_diff/batch_safety.rbs
+- sig/generated/paper_trail_diff/batch_preload.rbs
 - sig/generated/paper_trail_diff/batched_root_analyzer.rbs
 - sig/generated/paper_trail_diff/batched_root_versions.rbs
 - sig/generated/paper_trail_diff/branch_snapshot_refresher.rbs
+- sig/generated/paper_trail_diff/change_row.rbs
 - sig/generated/paper_trail_diff/collection_comparator.rbs
 - sig/generated/paper_trail_diff/collection_identity_index.rbs
 - sig/generated/paper_trail_diff/collection_transition.rbs
 - sig/generated/paper_trail_diff/comparison_batch.rbs
 - sig/generated/paper_trail_diff/configuration.rbs
 - sig/generated/paper_trail_diff/deleted_analysis_batch.rbs
+- sig/generated/paper_trail_diff/deleted_root_filter.rbs
+- sig/generated/paper_trail_diff/deprecation.rbs
 - sig/generated/paper_trail_diff/diagnostics.rbs
 - sig/generated/paper_trail_diff/direct_record_state_loader.rbs
 - 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/fallback_paths.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
@@ -230,12 +265,12 @@ files:
 - sig/generated/paper_trail_diff/step.rbs
 - sig/generated/paper_trail_diff/stored_time_precision.rbs
 - sig/generated/paper_trail_diff/support.rbs
-- sig/generated/paper_trail_diff/time_activity_timeline_builder.rbs
 - sig/generated/paper_trail_diff/time_range.rbs
 - sig/generated/paper_trail_diff/time_version_range.rbs
 - sig/generated/paper_trail_diff/timeline_builder.rbs
 - sig/generated/paper_trail_diff/timeline_range.rbs
 - sig/generated/paper_trail_diff/timeline_snapshot_provider.rbs
+- sig/generated/paper_trail_diff/transaction_cut.rbs
 - sig/generated/paper_trail_diff/traversal.rbs
 - sig/generated/paper_trail_diff/traversal_emitter.rbs
 - sig/generated/paper_trail_diff/traversal_entry.rbs
@@ -248,17 +283,18 @@ files:
 - sig/generated/paper_trail_diff/version_range.rbs
 - sig/generated/paper_trail_diff/version_scope_filter.rbs
 - sig/generated/paper_trail_diff/version_sequence_diagnostics.rbs
+- sig/generated/paper_trail_diff/version_table.rbs
 homepage: https://github.com/aheathwilliams/paper_trail_diff
 licenses:
 - MIT
 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.14.0/CHANGELOG.md
-  documentation_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.14.0/README.md
+  changelog_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.15.0/CHANGELOG.md
+  documentation_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.15.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.14.0
+  source_code_uri: https://github.com/aheathwilliams/paper_trail_diff/tree/v0.15.0
 rdoc_options: []
 require_paths:
 - lib

data/lib/paper_trail_diff/activity_grouping.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-# rbs_inline: enabled
-
-module PaperTrailDiff
-  # Shared by the two activity builders. They differ in how they choose
-  # boundaries -- one from an explicit version range, one from a wall-clock
-  # window -- but a transaction has to collapse the same way in both, or the
-  # same history would read differently depending on how it was asked for.
-  module ActivityGrouping
-    #: (Symbol?, ?activity: bool, ?snapshots: bool) -> void
-    def self.validate!(group, activity: true, snapshots: false)
-      unless group.nil? || group == :transaction
-        raise ConfigurationError, 'group: must be :transaction or nil'
-      end
-      raise ConfigurationError, 'snapshots: requires activity: true' if snapshots && !activity
-
-      return if group.nil? || activity
-
-      raise ConfigurationError, 'group: requires activity: true'
-    end
-
-    private
-
-    #: () -> bool
-    def grouping?
-      @group == :transaction
-    end
-
-    # Applied last, to finished steps, so grouping sees the same timeline the
-    # caller would otherwise have received.
-    #: (Array[ActivityStep]) -> Array[ActivityStep]
-    def group_steps(steps)
-      return steps unless grouping?
-
-      ActivityTransactionGrouper.new(steps, retain: @snapshots).call
-    end
-  end
-end

data/lib/paper_trail_diff/batch_safety.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-# rbs_inline: enabled
-
-module PaperTrailDiff
-  # Refuses known per-record association loading before a batch reconstructs it.
-  class BatchSafety
-    #: (AssociationTraversal, allow_expensive: bool) -> void
-    def initialize(traversal, allow_expensive:)
-      unless [true, false].include?(allow_expensive)
-        raise ConfigurationError, 'allow_expensive: must be true or false'
-      end
-
-      @traversal = traversal
-      @allow_expensive = allow_expensive
-    end
-
-    #: (untyped) -> void
-    def call(model)
-      return if @allow_expensive
-
-      @traversal.selected_reflections(model).each do |path, reflection|
-        check(reflection, path)
-      end
-    end
-
-    private
-
-    # @rbs @traversal: AssociationTraversal
-    # @rbs @allow_expensive: bool
-
-    # 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(reflection, path, ranked: true)
-      reason = reason_for(reflection, ranked)
-      if reason
-        raise UnsupportedBatchPathError,
-              "association #{path} requires per-record reconstruction (#{reason}); " \
-              'remove this path or explicitly pass allow_expensive: true'
-      end
-      return unless reflection.through_reflection?
-
-      [reflection.through_reflection, reflection.source_reflection].each do |part|
-        check(part, path, ranked: false)
-      end
-    end
-
-    # 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(reflection, ranked)
-      return ('association scope' if reflection.scope) if reflection.polymorphic?
-      if ranked && ScopeCondition.ranked_through?(reflection)
-        return 'limit, offset or has_one order inside a has_one through'
-      end
-      return if ScopeCondition.build(reflection, ranked: ranked)
-
-      reflection.scope ? 'association scope' : 'default-scoped target'
-    end
-  end
-end

data/lib/paper_trail_diff/time_activity_timeline_builder.rb

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-# rbs_inline: enabled
-
-module PaperTrailDiff
-  # Builds activity views for mutations selected by a wall-clock range.
-  class TimeActivityTimelineBuilder
-    include ActivityGrouping
-
-    #: (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, ?snapshots: bool, ?group: Symbol?) -> void
-    def initialize(record, range:, tree:, snapshotter:, snapshots: false, group: nil) # rubocop:disable Metrics/ParameterLists
-      @snapshots = snapshots
-      @group = group
-      # Merging a group compares its outer states, so the snapshots must survive
-      # the build even when the caller did not ask to keep them.
-      @retain = snapshots || grouping?
-      @record = record
-      @range = range
-      @tree = tree
-      @snapshotter = snapshotter
-    end
-
-    #: () -> Array[ActivityStep]
-    def build
-      history, _plan, closing, = history_and_versions
-      activity_steps(history, closing)
-    end
-
-    #: () -> Analysis
-    def analyze
-      history, plan, closing, closing_snapshot, captured_at = history_and_versions
-      final = plan.closes_on_destroy ? nil : closing_snapshot || history.last_snapshot
-      Analysis.new(
-        diff: Engine.compare(history.first_snapshot, final),
-        timeline: ActivityRootSteps.call(
-          plan, history.root_snapshots,
-          closing_snapshot: closing_snapshot, captured_at: captured_at
-        ),
-        activity_timeline: activity_steps(history, closing),
-        from_snapshot: history.first_snapshot,
-        to_snapshot: final
-      )
-    end
-
-    private
-
-    # @rbs @record: untyped
-    # @rbs @range: TimelineRange
-    # @rbs @tree: AssociationTree
-    # @rbs @snapshotter: untyped
-    # @rbs @snapshots: bool
-
-    #: () -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
-    def history_and_versions
-      plan = @range.select_plan(context_required: !@tree.empty?)
-      reject_live_habtm! if plan.closing_record
-      if plan.reconstruction_versions.empty? && !plan.closing_record
-        return [ActivityHistory.empty, plan, nil, nil, nil]
-      end
-
-      # A window closing on current state runs to the instant it is captured,
-      # not to the last root version, or descendants that moved after that
-      # version would be missing from a report that claims to reach now.
-      history_for(plan, plan.closing_record ? Time.now.utc : nil)
-    end
-
-    #: () -> void
-    def reject_live_habtm!
-      AssociationTraversal.new(@tree).reject_live_habtm_activity!(@record.class)
-    end
-
-    #: (RootVersionPlan, untyped) -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
-    def history_for(plan, captured_at)
-      root_versions = plan.reconstruction_versions
-      events = events_through(root_versions, captured_at)
-      selected = selected_events(events, plan)
-      unless time_events?(selected, events, plan)
-        return [ActivityHistory.empty, plan, nil, nil, nil]
-      end
-
-      history = build_history(root_versions, events, current: plan.closing_record)
-      snapshot = current_snapshot(plan)
-      closing = closing_step(history, selected.last, plan, captured_at, snapshot)
-      [history, plan, closing, snapshot, captured_at]
-    end
-
-    # One live read serves both the closing activity step and the endpoint the
-    # analysis reports, which would otherwise reconstruct the graph twice.
-    #: (RootVersionPlan) -> RecordSnapshot?
-    def current_snapshot(plan)
-      record = plan.closing_record
-      return unless record
-
-      @snapshotter.call(record, record)
-    end
-
-    #: (Array[untyped], untyped) -> Array[ActivityEvent]
-    def events_through(root_versions, captured_at)
-      prepare_history(root_versions, end_at: captured_at)
-      collect_events(root_versions, range_end: captured_at)
-    end
-
-    # Events after the last root version read the root from the live record
-    # when the window closes on it, as an explicit `to: record` range does.
-    #: (Array[untyped], Array[ActivityEvent], ?current: untyped) -> ActivityHistory
-    def build_history(root_versions, events, current: nil)
-      ActivityHistoryBuilder.new(
-        root_versions,
-        events,
-        @snapshotter,
-        current: current,
-        include_step: ->(event) { @range.include?(event.version) },
-        snapshots: @retain
-      ).call
-    end
-
-    #: (ActivityHistory, ActivityStep?) -> Array[ActivityStep]
-    def activity_steps(history, closing)
-      steps = closing ? history.steps + [closing] : history.steps
-      group_steps(steps).freeze
-    end
-
-    # Root versions inside the window that the plan does not report are context
-    # rather than mutations: the version appended to reveal the last selected
-    # change, and anything a filter excluded but the replay still walks. Neither
-    # may be counted as a selected mutation. Descendant events are not filtered,
-    # so window membership is the whole test for them.
-    #: (Array[ActivityEvent], RootVersionPlan) -> Array[ActivityEvent]
-    def selected_events(events, plan)
-      events.select do |event|
-        next false unless @range.include?(event.version)
-
-        !event.root? || plan.mutation?(event.version)
-      end
-    end
-
-    # A window either closes on the absence its final destruction leaves, or on
-    # current state when it reaches past everything recorded. Both are boundaries
-    # no version can supply.
-    #: (ActivityHistory, ActivityEvent?, RootVersionPlan, untyped, RecordSnapshot?) -> ActivityStep?
-    def closing_step(history, event, plan, captured_at, snapshot)
-      return unless event
-      return destroyed_step(history, event) if terminal_destroy?(event)
-      return unless plan.closing_record
-
-      current_step(history, plan.closing_record, captured_at, snapshot)
-    end
-
-    #: (ActivityHistory, ActivityEvent) -> ActivityStep
-    def destroyed_step(history, event)
-      version = event.version
-      ActivityStep.between(
-        from_boundary: ActivityBoundary.from_version(version),
-        to_boundary: ActivityBoundary.destroyed(version),
-        from_snapshot: history.root_snapshots[ActivityRootSteps.version_key(version)],
-        to_snapshot: nil, retain: @retain
-      )
-    end
-
-    # The last boundary reached is where current state is compared from, which
-    # is the final event rather than the final root version once descendants
-    # have moved since it.
-    #: (ActivityHistory, untyped, untyped, RecordSnapshot?) -> ActivityStep?
-    def current_step(history, record, captured_at, snapshot)
-      previous = history.last_boundary
-      return unless previous
-
-      ActivityStep.between(
-        from_boundary: previous,
-        to_boundary: ActivityBoundary.current(record, captured_at: captured_at),
-        from_snapshot: history.last_event_snapshot, to_snapshot: snapshot, retain: @retain
-      )
-    end
-
-    #: (ActivityEvent?) -> bool
-    def terminal_destroy?(event)
-      return false unless event
-
-      event.root? && event.version.event.to_s == 'destroy'
-    end
-
-    #: (Array[untyped], ?end_at: untyped) -> void
-    def prepare_history(root_versions, end_at: nil)
-      return unless @snapshotter.respond_to?(:prepare)
-
-      start_at = @range.begin_time
-      return @snapshotter.prepare(@record, root_versions, start_at: start_at) unless end_at
-
-      @snapshotter.prepare(@record, root_versions, start_at: start_at, end_at: end_at)
-    end
-
-    #: (Array[untyped], ?range_end: untyped) -> Array[ActivityEvent]
-    def collect_events(root_versions, range_end: nil)
-      ActivityVersionCollector.new(
-        @record,
-        root_versions: root_versions,
-        tree: @tree,
-        prepared: (@snapshotter.activity_index if @snapshotter.respond_to?(:activity_index)),
-        range_start: @range.begin_time,
-        range_end: range_end || root_versions.last
-      ).call
-    end
-
-    #: (Array[ActivityEvent], Array[ActivityEvent], RootVersionPlan) -> bool
-    def time_events?(selected, events, plan)
-      return false if selected.empty?
-      return true if later_event?(selected.last, events)
-      return true if terminal_destroy?(selected.last)
-      return true if plan.closing_record
-
-      message = 'time range requires a later activity boundary to reconstruct its ' \
-                'final change: pass close_on: :current to end at current state, ' \
-                'or narrow the window to end before the last recorded boundary'
-      raise IncompleteTimeRangeError, message
-    end
-
-    #: (ActivityEvent, Array[ActivityEvent]) -> bool
-    def later_event?(selected, events)
-      events.any? do |event|
-        Support.compare_versions(selected.version, event.version).negative?
-      end
-    end
-  end
-end

data/sig/generated/paper_trail_diff/activity_grouping.rbs

@@ -1,22 +0,0 @@
-# Generated from lib/paper_trail_diff/activity_grouping.rb with RBS::Inline
-
-module PaperTrailDiff
-  # Shared by the two activity builders. They differ in how they choose
-  # boundaries -- one from an explicit version range, one from a wall-clock
-  # window -- but a transaction has to collapse the same way in both, or the
-  # same history would read differently depending on how it was asked for.
-  module ActivityGrouping
-    # : (Symbol?, ?activity: bool, ?snapshots: bool) -> void
-    def self.validate!: (Symbol?, ?activity: bool, ?snapshots: bool) -> void
-
-    private
-
-    # : () -> bool
-    def grouping?: () -> bool
-
-    # Applied last, to finished steps, so grouping sees the same timeline the
-    # caller would otherwise have received.
-    # : (Array[ActivityStep]) -> Array[ActivityStep]
-    def group_steps: (Array[ActivityStep]) -> Array[ActivityStep]
-  end
-end

data/sig/generated/paper_trail_diff/batch_safety.rbs

@@ -1,30 +0,0 @@
-# Generated from lib/paper_trail_diff/batch_safety.rb with RBS::Inline
-
-module PaperTrailDiff
-  # Refuses known per-record association loading before a batch reconstructs it.
-  class BatchSafety
-    # : (AssociationTraversal, allow_expensive: bool) -> void
-    def initialize: (AssociationTraversal, allow_expensive: bool) -> void
-
-    # : (untyped) -> void
-    def call: (untyped) -> void
-
-    private
-
-    @allow_expensive: bool
-
-    @traversal: AssociationTraversal
-
-    # 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
-end

data/sig/generated/paper_trail_diff/time_activity_timeline_builder.rbs

@@ -1,92 +0,0 @@
-# Generated from lib/paper_trail_diff/time_activity_timeline_builder.rb with RBS::Inline
-
-module PaperTrailDiff
-  # Builds activity views for mutations selected by a wall-clock range.
-  class TimeActivityTimelineBuilder
-    include ActivityGrouping
-
-    # : (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, ?snapshots: bool, ?group: Symbol?) -> void
-    def initialize: (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, ?snapshots: bool, ?group: Symbol?) -> void
-
-    # : () -> Array[ActivityStep]
-    def build: () -> Array[ActivityStep]
-
-    # : () -> Analysis
-    def analyze: () -> Analysis
-
-    private
-
-    @range: TimelineRange
-
-    @record: untyped
-
-    @snapshots: bool
-
-    @snapshotter: untyped
-
-    @tree: AssociationTree
-
-    # : () -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
-    def history_and_versions: () -> [ ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped ]
-
-    # : () -> void
-    def reject_live_habtm!: () -> void
-
-    # : (RootVersionPlan, untyped) -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
-    def history_for: (RootVersionPlan, untyped) -> [ ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped ]
-
-    # One live read serves both the closing activity step and the endpoint the
-    # analysis reports, which would otherwise reconstruct the graph twice.
-    # : (RootVersionPlan) -> RecordSnapshot?
-    def current_snapshot: (RootVersionPlan) -> RecordSnapshot?
-
-    # : (Array[untyped], untyped) -> Array[ActivityEvent]
-    def events_through: (Array[untyped], untyped) -> Array[ActivityEvent]
-
-    # Events after the last root version read the root from the live record
-    # when the window closes on it, as an explicit `to: record` range does.
-    # : (Array[untyped], Array[ActivityEvent], ?current: untyped) -> ActivityHistory
-    def build_history: (Array[untyped], Array[ActivityEvent], ?current: untyped) -> ActivityHistory
-
-    # : (ActivityHistory, ActivityStep?) -> Array[ActivityStep]
-    def activity_steps: (ActivityHistory, ActivityStep?) -> Array[ActivityStep]
-
-    # Root versions inside the window that the plan does not report are context
-    # rather than mutations: the version appended to reveal the last selected
-    # change, and anything a filter excluded but the replay still walks. Neither
-    # may be counted as a selected mutation. Descendant events are not filtered,
-    # so window membership is the whole test for them.
-    # : (Array[ActivityEvent], RootVersionPlan) -> Array[ActivityEvent]
-    def selected_events: (Array[ActivityEvent], RootVersionPlan) -> Array[ActivityEvent]
-
-    # A window either closes on the absence its final destruction leaves, or on
-    # current state when it reaches past everything recorded. Both are boundaries
-    # no version can supply.
-    # : (ActivityHistory, ActivityEvent?, RootVersionPlan, untyped, RecordSnapshot?) -> ActivityStep?
-    def closing_step: (ActivityHistory, ActivityEvent?, RootVersionPlan, untyped, RecordSnapshot?) -> ActivityStep?
-
-    # : (ActivityHistory, ActivityEvent) -> ActivityStep
-    def destroyed_step: (ActivityHistory, ActivityEvent) -> ActivityStep
-
-    # The last boundary reached is where current state is compared from, which
-    # is the final event rather than the final root version once descendants
-    # have moved since it.
-    # : (ActivityHistory, untyped, untyped, RecordSnapshot?) -> ActivityStep?
-    def current_step: (ActivityHistory, untyped, untyped, RecordSnapshot?) -> ActivityStep?
-
-    # : (ActivityEvent?) -> bool
-    def terminal_destroy?: (ActivityEvent?) -> bool
-
-    # : (Array[untyped], ?end_at: untyped) -> void
-    def prepare_history: (Array[untyped], ?end_at: untyped) -> void
-
-    # : (Array[untyped], ?range_end: untyped) -> Array[ActivityEvent]
-    def collect_events: (Array[untyped], ?range_end: untyped) -> Array[ActivityEvent]
-
-    # : (Array[ActivityEvent], Array[ActivityEvent], RootVersionPlan) -> bool
-    def time_events?: (Array[ActivityEvent], Array[ActivityEvent], RootVersionPlan) -> bool
-
-    # : (ActivityEvent, Array[ActivityEvent]) -> bool
-    def later_event?: (ActivityEvent, Array[ActivityEvent]) -> bool
-  end
-end