paper_trail_diff 0.6.0 → 0.7.1

data/sig/generated/paper_trail_diff/live_endpoint_provider.rbs

@@ -10,13 +10,22 @@ module PaperTrailDiff
     # : (tree: AssociationTree, traversal: AssociationTraversal, reload: bool) -> void
     def initialize: (tree: AssociationTree, traversal: AssociationTraversal, reload: bool) -> void
 
+    # Loads each endpoint at most once for the life of this provider, which is
+    # one public call. A batch that resolves every root up front and then asks
+    # again for one of them costs nothing the second time, and every root in the
+    # result reflects the same instant rather than whenever its turn came.
     # : (Array[untyped]) -> Hash[identity, untyped]
     def call: (Array[untyped]) -> Hash[identity, untyped]
 
     private
 
+    @loaded: Hash[identity, untyped]
+
     @loader: untyped
 
+    # : (Array[untyped]) -> Hash[identity, untyped]
+    def known: (Array[untyped]) -> Hash[identity, untyped]
+
     # : (Array[untyped]) -> Hash[Symbol, untyped]
     def payload: (Array[untyped]) -> Hash[Symbol, untyped]
   end

data/sig/generated/paper_trail_diff/paper_trail_adapter.rbs

@@ -6,6 +6,9 @@ module PaperTrailDiff
   # the only place allowed to know about both PaperTrail and the pure engine.
   # Reconstruction logic lives in the collaborators it wires together.
   class PaperTrailAdapter
+    # The only thing a wall-clock window can close on besides a later version.
+    CLOSE_ON_CURRENT: ::Symbol
+
     # : (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool) -> void
     def initialize: (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool) -> void
 
@@ -16,18 +19,18 @@ module PaperTrailDiff
     # : (Array[comparison_input]) -> comparison_results
     def compare_many: (Array[comparison_input]) -> comparison_results
 
-    # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped) -> Array[Step]
-    def timeline: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped) -> Array[Step]
+    # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?close_on: Symbol?) -> Array[Step]
+    def timeline: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?close_on: Symbol?) -> Array[Step]
 
-    # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped) -> Array[ActivityStep]
-    def activity_timeline: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped) -> Array[ActivityStep]
+    # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?close_on: Symbol?) -> Array[ActivityStep]
+    def activity_timeline: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?close_on: Symbol?) -> Array[ActivityStep]
 
-    # : (untyped, from: untyped, to: untyped, within: untyped, ?activity: bool, ?version_scope: untyped) -> Analysis
-    def analyze: (untyped, from: untyped, to: untyped, within: untyped, ?activity: bool, ?version_scope: untyped) -> Analysis
+    # : (untyped, from: untyped, to: untyped, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Analysis
+    def analyze: (untyped, from: untyped, to: untyped, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Analysis
 
     # Analyzes many roots over one shared range, preparing their history once.
-    # : (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped) -> Hash[identity, Analysis]
-    def analyze_many: (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped) -> Hash[identity, Analysis]
+    # : (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
+    def analyze_many: (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
 
     private
 
@@ -53,6 +56,19 @@ module PaperTrailDiff
 
     @traversal_preparer: TraversalPreparer
 
+    # : (untyped, from: untyped, to: untyped, within: untyped, version_scope: untyped, live_endpoint: untyped) -> Analysis
+    def analyze_activity: (untyped, from: untyped, to: untyped, within: untyped, version_scope: untyped, live_endpoint: untyped) -> Analysis
+
+    # `close_on:` names what ends a wall-clock window, so it is meaningless for a
+    # range whose endpoints the caller already gave explicitly.
+    # : (Symbol?, untyped) -> bool
+    def close_on_current?: (Symbol?, untyped) -> bool
+
+    # A destroyed root has no current state to close on, and its own destroy
+    # version already terminates the history.
+    # : (untyped, Symbol?, untyped) -> untyped
+    def live_endpoint_for: (untyped, Symbol?, untyped) -> untyped
+
     # : () -> void
     def build_snapshotters: () -> void
 
@@ -65,8 +81,8 @@ module PaperTrailDiff
     # : () -> ActivitySnapshotProvider
     def build_activity_snapshotter: () -> ActivitySnapshotProvider
 
-    # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped) -> ActivityTimelineBuilder
-    def activity_builder: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped) -> ActivityTimelineBuilder
+    # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?live_endpoint: untyped) -> ActivityTimelineBuilder
+    def activity_builder: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?live_endpoint: untyped) -> ActivityTimelineBuilder
 
     # : (untyped) -> void
     def reject_live_habtm_activity!: (untyped) -> void

data/sig/generated/paper_trail_diff/root_version_plan.rbs

@@ -23,6 +23,11 @@ module PaperTrailDiff
 
     attr_reader context_version: untyped
 
+    # The live record a window closes on when no later version can reveal its
+    # final mutation. It is a boundary, never a version, so it stays out of
+    # `versions` and out of anything that reconstructs from version history.
+    attr_reader closing_record: untyped
+
     # The root versions this plan reports as mutations, which excludes any
     # version present only to reveal what the last of them produced.
     attr_reader mutations: Array[untyped]
@@ -34,12 +39,17 @@ module PaperTrailDiff
     # : () -> RootVersionPlan
     def self.empty: () -> RootVersionPlan
 
-    # : (versions: Array[untyped], steps: Array[[untyped, untyped]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?) -> void
-    def initialize: (versions: Array[untyped], steps: Array[[ untyped, untyped ]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?) -> void
+    # : (versions: Array[untyped], steps: Array[[untyped, untyped]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped) -> void
+    def initialize: (versions: Array[untyped], steps: Array[[ untyped, untyped ]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped) -> void
 
     # : () -> bool
     def empty?: () -> bool
 
+    # What the range's final state is read from, which is the live record when
+    # the window closes on current state and the last version otherwise.
+    # : () -> untyped
+    def final_endpoint: () -> untyped
+
     # : (untyped) -> bool
     def mutation?: (untyped) -> bool
 

data/sig/generated/paper_trail_diff/root_version_selection.rbs

@@ -10,10 +10,13 @@ module PaperTrailDiff
   # Both the single-record and the batched selectors resolve this here, because
   # the rule is subtle enough that two copies of it would drift apart.
   class RootVersionSelection
+    # An error is a specification, so it names the way out as well as the wall.
+    # A window ending at the present can never gain a later version, which makes
+    # "write a checkpoint afterwards" impossible advice on its own.
     INCOMPLETE: ::String
 
-    # : (in_range: Array[untyped], selected: Array[untyped], after_range: untyped, windowed: bool, ?context_required: bool, ?filtered: bool) -> void
-    def initialize: (in_range: Array[untyped], selected: Array[untyped], after_range: untyped, windowed: bool, ?context_required: bool, ?filtered: bool) -> void
+    # : (in_range: Array[untyped], selected: Array[untyped], after_range: untyped, windowed: bool, ?context_required: bool, ?filtered: bool, ?live_endpoint: untyped) -> void
+    def initialize: (in_range: Array[untyped], selected: Array[untyped], after_range: untyped, windowed: bool, ?context_required: bool, ?filtered: bool, ?live_endpoint: untyped) -> void
 
     # : () -> RootVersionPlan
     def call: () -> RootVersionPlan
@@ -28,10 +31,18 @@ module PaperTrailDiff
 
     @in_range: Array[untyped]
 
+    @live_endpoint: untyped
+
     @selected: Array[untyped]
 
     @windowed: bool
 
+    # A window reaching past the last recorded version has only the live record
+    # left to show what its final mutation produced. That record is a closing
+    # boundary rather than a selected mutation, so it never joins `versions`.
+    # : (untyped) -> RootVersionPlan
+    def contiguous_plan: (untyped) -> RootVersionPlan
+
     # An activity view still needs a root to reconstruct from even when no root
     # version falls inside the window, because descendants may have moved.
     # : () -> RootVersionPlan
@@ -44,6 +55,9 @@ module PaperTrailDiff
     # : (untyped) -> RootVersionPlan
     def filtered_plan: (untyped) -> RootVersionPlan
 
+    # : (Array[[untyped, untyped]], untyped) -> RootVersionPlan
+    def filtered_plan_for: (Array[[ untyped, untyped ]], untyped) -> RootVersionPlan
+
     # Nothing can follow a destroy, so it never pairs into a step. It is still a
     # selected mutation, and the activity view closes on the absence it leaves,
     # so it has to stay a boundary or a filtered report loses the deletion

data/sig/generated/paper_trail_diff/step.rbs

@@ -13,8 +13,11 @@ module PaperTrailDiff
 
     attr_reader diff: Diff
 
-    # : (from_version: untyped, to_version: untyped, diff: Diff) -> void
-    def initialize: (from_version: untyped, to_version: untyped, diff: Diff) -> void
+    # `to_version` is nil for the one step that closes on current state, which a
+    # window reaching past the last recorded version has to do. Read
+    # `to_boundary` instead when a caller may have opted into that.
+    # : (from_version: untyped, to_version: untyped, diff: Diff, ?captured_at: untyped) -> void
+    def initialize: (from_version: untyped, to_version: untyped, diff: Diff, ?captured_at: untyped) -> void
 
     # : () -> bool
     def empty?: () -> bool

data/sig/generated/paper_trail_diff/time_activity_timeline_builder.rbs

@@ -22,8 +22,19 @@ module PaperTrailDiff
 
     @tree: AssociationTree
 
-    # : () -> [ActivityHistory, RootVersionPlan, ActivityStep?]
-    def history_and_versions: () -> [ ActivityHistory, RootVersionPlan, ActivityStep? ]
+    # : () -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
+    def history_and_versions: () -> [ ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped ]
+
+    # : (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]
 
     # : (Array[untyped], Array[ActivityEvent]) -> ActivityHistory
     def build_history: (Array[untyped], Array[ActivityEvent]) -> ActivityHistory
@@ -39,22 +50,32 @@ module PaperTrailDiff
     # : (Array[ActivityEvent], RootVersionPlan) -> Array[ActivityEvent]
     def selected_events: (Array[ActivityEvent], RootVersionPlan) -> Array[ActivityEvent]
 
-    # The window's last selected mutation is the root's own destruction, so the
-    # timeline closes on the absence it leaves rather than on a later boundary.
-    # : (ActivityHistory, ActivityEvent?) -> ActivityStep?
-    def closing_step: (ActivityHistory, ActivityEvent?) -> ActivityStep?
+    # 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]) -> void
-    def prepare_history: (Array[untyped]) -> void
+    # : (Array[untyped], ?end_at: untyped) -> void
+    def prepare_history: (Array[untyped], ?end_at: untyped) -> void
 
-    # : (Array[untyped]) -> Array[ActivityEvent]
-    def collect_events: (Array[untyped]) -> Array[ActivityEvent]
+    # : (Array[untyped], ?range_end: untyped) -> Array[ActivityEvent]
+    def collect_events: (Array[untyped], ?range_end: untyped) -> Array[ActivityEvent]
 
-    # : (Array[ActivityEvent], Array[ActivityEvent]) -> bool
-    def time_events?: (Array[ActivityEvent], Array[ActivityEvent]) -> bool
+    # : (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

data/sig/generated/paper_trail_diff/time_version_range.rbs

@@ -3,8 +3,8 @@
 module PaperTrailDiff
   # Selects in-range root versions plus one later reconstruction boundary.
   class TimeVersionRange
-    # : (untyped, time_range: TimeRange, ?version_scope: untyped) -> void
-    def initialize: (untyped, time_range: TimeRange, ?version_scope: 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) -> Array[untyped]
     def select: (?context_required: bool) -> Array[untyped]
@@ -14,6 +14,8 @@ module PaperTrailDiff
 
     private
 
+    @live_endpoint: untyped
+
     @record: untyped
 
     @time_range: TimeRange

data/sig/generated/paper_trail_diff/timeline_builder.rbs

@@ -3,8 +3,8 @@
 module PaperTrailDiff
   # Selects and compares a chronological slice of a record's version history.
   class TimelineBuilder
-    # : (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?) -> void
-    def initialize: (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?) -> void
+    # : (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
+    def initialize: (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
 
     # : () -> Array[Step]
     def build: () -> Array[Step]
@@ -23,6 +23,9 @@ module PaperTrailDiff
     # : (RootVersionPlan) -> [Array[Step], RecordSnapshot?, RecordSnapshot?]
     def compare_history: (RootVersionPlan) -> [ Array[Step], RecordSnapshot?, RecordSnapshot? ]
 
+    # : (RootVersionPlan) -> Array[Step]
+    def build_steps: (RootVersionPlan) -> Array[Step]
+
     # : () -> [Array[Step], nil, nil]
     def empty_history: () -> [ Array[Step], nil, nil ]
 

data/sig/generated/paper_trail_diff/timeline_range.rbs

@@ -11,8 +11,8 @@ module PaperTrailDiff
 
     attr_reader time_range: TimeRange?
 
-    # : (untyped, from: untyped, to: untyped, within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?) -> void
-    def initialize: (untyped, from: untyped, to: untyped, within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?) -> void
+    # : (untyped, from: untyped, to: untyped, within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
+    def initialize: (untyped, from: untyped, to: untyped, within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
 
     # A record with no versions has no first or last boundary to resolve, which
     # is an empty history rather than a bad request.
@@ -42,6 +42,8 @@ module PaperTrailDiff
 
     @from: untyped
 
+    @live_endpoint: untyped
+
     @plan: RootVersionPlan?
 
     @record: untyped

data/sig/generated/paper_trail_diff/timeline_snapshot_provider.rbs

@@ -3,15 +3,24 @@
 module PaperTrailDiff
   # Gives TimelineBuilder one-argument access to a range-prepared snapshot store.
   class TimelineSnapshotProvider
-    # : (HistoricalSnapshotStore) -> void
-    def initialize: (HistoricalSnapshotStore) -> void
+    # : (HistoricalSnapshotStore, ?live_snapshotter: untyped) -> void
+    def initialize: (HistoricalSnapshotStore, ?live_snapshotter: untyped) -> void
 
     # : (untyped, Array[untyped]) -> void
     def prepare: (untyped, Array[untyped]) -> void
 
+    # A window closing on current state ends at the live record rather than at a
+    # version, which is the one endpoint no version history can reconstruct.
     # : (untyped) -> RecordSnapshot?
     def call: (untyped) -> RecordSnapshot?
 
+    private
+
+    # : (untyped) -> RecordSnapshot?
+    def live_snapshot: (untyped) -> RecordSnapshot?
+
+    @live_snapshotter: untyped
+
     @store: HistoricalSnapshotStore
   end
 end

data/sig/generated/paper_trail_diff.rbs

@@ -17,24 +17,24 @@ module PaperTrailDiff
   def self.compare_many: (Array[comparison_input], ?associations: Array[String | Symbol], ?ignore: ignore_option, ?reload_live_endpoints: bool) -> comparison_results
 
   # Compares every adjacent reconstructed state in an inclusive version range.
-  # : (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?version_scope: untyped) -> Array[Step]
-  def self.timeline: (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?version_scope: untyped) -> Array[Step]
+  # : (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?version_scope: untyped, ?close_on: Symbol?) -> Array[Step]
+  def self.timeline: (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?version_scope: untyped, ?close_on: Symbol?) -> Array[Step]
 
   # Compares adjacent root and selected-descendant activity boundaries.
   # `reload_live_endpoints:` applies only when `to:` is a current record; the
   # other range forms never read live state.
-  # : (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?reload_live_endpoints: bool, ?version_scope: untyped) -> Array[ActivityStep]
-  def self.activity_timeline: (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?reload_live_endpoints: bool, ?version_scope: untyped) -> Array[ActivityStep]
+  # : (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?reload_live_endpoints: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Array[ActivityStep]
+  def self.activity_timeline: (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?reload_live_endpoints: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Array[ActivityStep]
 
   # Builds an endpoint diff and root-checkpoint timeline while normalizing each version once.
-  # : (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped) -> Analysis
-  def self.analyze: (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped) -> Analysis
+  # : (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Analysis
+  def self.analyze: (untyped, ?from: untyped, ?to: untyped, ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Analysis
 
   # Analyzes many roots over one shared time window, preparing their selected
   # history once for the batch instead of once per record. Roots with no
   # versions in the window return an empty `Analysis`.
-  # : (Array[untyped], ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped) -> Hash[identity, Analysis]
-  def self.analyze_many: (Array[untyped], ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped) -> Hash[identity, Analysis]
+  # : (Array[untyped], ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
+  def self.analyze_many: (Array[untyped], ?within: untyped, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
 
   # Returns the association macros this release can normalize.
   # : () -> Array[Symbol]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paper_trail_diff
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Alex Williams
@@ -200,11 +200,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.6.0/CHANGELOG.md
-  documentation_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.6.0/README.md
+  changelog_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.7.1/CHANGELOG.md
+  documentation_uri: https://github.com/aheathwilliams/paper_trail_diff/blob/v0.7.1/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.6.0
+  source_code_uri: https://github.com/aheathwilliams/paper_trail_diff/tree/v0.7.1
 rdoc_options: []
 require_paths:
 - lib