paper_trail_diff 0.11.0 → 0.13.0

data/lib/paper_trail_diff/branch_snapshot_refresher.rb

@@ -4,7 +4,7 @@
 module PaperTrailDiff
   # Reconstructs selected root branches and merges them into a prior immutable snapshot.
   class BranchSnapshotRefresher
-    #: (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped, record_transition: untyped) -> void
+    #: (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped, record_transition: untyped, ?prepared_record_after: untyped) -> void
     def initialize( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
       tree:,
       ignore_policy:,
@@ -14,7 +14,8 @@ module PaperTrailDiff
       full_snapshotter:,
       partial_snapshotter:,
       association_reader:,
-      record_transition:
+      record_transition:,
+      prepared_record_after: nil
     )
       @tree = tree
       @ignore_policy = ignore_policy
@@ -24,16 +25,14 @@ module PaperTrailDiff
       @partial_snapshotter = partial_snapshotter
       @components = {} #: Hash[Array[String], [AssociationTree, SnapshotNormalizer]]
       @event_refresher = ActivityEventSnapshotRefresher.new(
-        traversal: traversal,
-        pool: pool,
+        traversal: traversal, pool: pool,
         components: method(:components),
         association_reader: association_reader,
-        record_transition: record_transition
+        record_transition: record_transition,
+        prepared_record_after: prepared_record_after
       )
       @root_refresher = ActivityRootSnapshotRefresher.new(
-        tree: tree,
-        traversal: traversal,
-        normalizer: normalizer,
+        tree: tree, traversal: traversal, normalizer: normalizer,
         record_after: @event_refresher.method(:record_after),
         changeset: @event_refresher.method(:deserialized_changeset),
         partial_snapshotter: method(:partial_snapshot)

data/lib/paper_trail_diff/deleted_analysis_batch.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+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( # rubocop:disable Metrics/ParameterLists
+      model, identities:, time_range:, analyzer:, history_preparer:, version_scope: nil
+    )
+      @model = model
+      @identities = identities
+      @time_range = time_range
+      @analyzer = analyzer
+      @history_preparer = history_preparer
+      @version_scope = version_scope
+    end
+
+    #: () -> Hash[Array[String], Analysis?]
+    def call
+      empty = {} #: Hash[Array[String], Analysis?]
+      return empty.freeze if @identities.empty?
+
+      records = historical_roots
+      selected = BatchedRootVersions.new(
+        records, time_range: @time_range, version_scope: @version_scope
+      ).call
+      prepare(records, selected)
+      analyses = records.to_h do |record|
+        key = Endpoint.identity(record)
+        plan = selected.fetch(key)
+        [key, plan.empty? ? Analysis.empty : @analyzer.call(record, plan)]
+      end
+      with_unavailable(analyses)
+    end
+
+    private
+
+    #: (Hash[Array[String], Analysis]) -> Hash[Array[String], Analysis?]
+    def with_unavailable(analyses)
+      @identities.to_h { |key| [Support.immutable_copy(key), analyses[key]] }.freeze
+    end
+
+    # @rbs @model: untyped
+    # @rbs @identities: Array[Array[String]]
+    # @rbs @time_range: TimeRange?
+    # @rbs @analyzer: untyped
+    # @rbs @history_preparer: untyped
+    # @rbs @version_scope: untyped
+
+    # 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
+      loader = PreparedVersionStateLoader.new
+      destroy_versions.map do |version|
+        model = loader.call(version)&.model_class || Endpoint.model_class(version)
+        record = model.new
+        record[model.primary_key] = version.item_id
+        record
+      end
+    end
+
+    #: () -> Array[untyped]
+    def destroy_versions
+      versions = @model.paper_trail.version_class.where(
+        item_type: @model.base_class.name, item_id: @identities.map(&:last), event: 'destroy'
+      ).reorder(created_at: :asc, id: :asc)
+      versions.group_by { |version| version.item_id.to_s }.values.map do |history|
+        Support.chronological_sort(history).last
+      end
+    end
+
+    #: (Array[untyped]) -> Hash[Symbol, untyped]
+    def preparation_range(versions)
+      { start_at: @time_range&.begin_time,
+        end_at: [@time_range&.end_time, versions.map(&:created_at).max].compact.max }
+    end
+
+    #: (Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
+    def prepare(records, selected)
+      records.group_by(&:class).each_value do |group|
+        versions = group.flat_map do |record|
+          selected.fetch(Endpoint.identity(record)).reconstruction_versions
+        end
+        next if versions.empty?
+
+        @history_preparer.call(group, versions, **preparation_range(versions))
+      end
+    end
+  end
+end

data/lib/paper_trail_diff/direct_record_state_loader.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Completes plain recorded state without invoking model initialization or writers.
+  # Decline model behavior whose values require an actual ActiveRecord instance.
+  class DirectRecordStateLoader
+    #: () -> void
+    def initialize
+      @loader = PreparedVersionStateLoader.new
+      @supported = {} #: Hash[untyped, bool]
+      @defaults = {} #: Hash[untyped, Hash[untyped, untyped]]
+    end
+
+    #: (untyped) -> PreparedRecordState?
+    def call(version)
+      state = @loader.call(version)
+      complete(state) if state
+    end
+
+    #: (PreparedRecordState) -> PreparedRecordState?
+    def complete(state)
+      model = state.model_class
+      return unless supported?(model)
+
+      defaults = @defaults[model] ||= model.column_defaults
+      attributes = defaults.merge(state.attributes).to_h do |name, value|
+        [name, model.type_for_attribute(name).cast(value)]
+      end
+      PreparedRecordState.from_attributes(model, attributes)
+    end
+
+    private
+
+    # @rbs @loader: PreparedVersionStateLoader
+    # @rbs @supported: Hash[untyped, bool]
+    # @rbs @defaults: Hash[untyped, Hash[untyped, untyped]]
+
+    #: (untyped) -> bool
+    def supported?(model)
+      return @supported[model] if @supported.key?(model)
+
+      @supported[model] = plain_model?(model) && plain_attributes?(model)
+    end
+
+    #: (untyped) -> bool
+    def plain_model?(model)
+      !model.primary_key.is_a?(Array) && !model.default_scopes? &&
+        model._initialize_callbacks.empty? &&
+        %i[initialize attributes []= write_attribute id].all? do |name|
+          framework_class?(model.instance_method(name).owner)
+        end
+    end
+
+    #: (untyped) -> bool
+    def plain_attributes?(model)
+      return false if encrypted?(model)
+      return false unless model.attribute_types.keys.sort == model.column_names.sort
+      return false if application_defaults?(model)
+
+      model.attribute_types.values.all? { |type| framework_class?(type.class) }
+    end
+
+    #: (untyped) -> bool
+    def application_defaults?(model)
+      model._default_attributes.each_value.any? do |attribute|
+        attribute.class.name.to_s.end_with?('UserProvidedDefault')
+      end
+    end
+
+    #: (untyped) -> bool
+    def encrypted?(model)
+      !!(model.respond_to?(:encrypted_attributes) && model.encrypted_attributes&.any?)
+    end
+
+    #: (untyped) -> bool
+    def framework_class?(value)
+      value.name.to_s.start_with?('ActiveRecord::', 'ActiveModel::')
+    end
+  end
+end

data/lib/paper_trail_diff/endpoint.rb

@@ -82,6 +82,16 @@ module PaperTrailDiff
       raise InvalidEndpointError, "cannot resolve endpoint model: #{model_type}", cause: e
     end
 
+    # The record's own PaperTrail versions, under whatever name the model gave
+    # the association.
+    #: (untyped) -> untyped
+    def versions(record)
+      record.public_send(record.class.versions_association_name)
+    rescue NoMethodError => e
+      message = 'record does not expose a PaperTrail version history'
+      raise InvalidTimelineRangeError, message, cause: e
+    end
+
     #: (untyped) -> untyped
     def reload_record(record)
       validate_record!(record)

data/lib/paper_trail_diff/engine.rb

@@ -71,6 +71,8 @@ module PaperTrailDiff
         raise ArgumentError, 'association kind changed between snapshots'
       end
 
+      # Kinds are symbols, so `!=`, `equal?`, and `eql?` all agree here.
+      # mutant:disable
       #: (AssociationSnapshot?, AssociationSnapshot?) -> bool
       def kinds_differ?(from_association, to_association)
         return false unless from_association && to_association
@@ -131,9 +133,9 @@ module PaperTrailDiff
         ).call
       end
 
-      #: (RecordSnapshot?, RecordSnapshot?) -> bool
+      #: (RecordSnapshot?, RecordSnapshot?) -> boolish
       def same_identity?(from_record, to_record)
-        from_record && to_record ? from_record.identity == to_record.identity : false
+        from_record && to_record && from_record.identity == to_record.identity
       end
     end
   end

data/lib/paper_trail_diff/errors.rb

@@ -8,6 +8,9 @@ module PaperTrailDiff
   # Raised when a public option has an invalid type, key, value, or path.
   class ConfigurationError < Error; end
 
+  # Raised when nested data keys cannot be represented by unique string paths.
+  class AmbiguousNestedKeyError < Error; end
+
   # Raised when compare endpoints do not belong to the same PaperTrail item.
   class VersionMismatchError < Error; end
 
@@ -36,6 +39,12 @@ module PaperTrailDiff
   # Truncating instead would hand back a report that is short without saying so.
   class BatchLimitExceededError < Error; end
 
+  # Historical candidate loading exceeded its explicitly bounded work budget.
+  class FilterLimitExceededError < Error; end
+
+  # A batch selected a known expensive association without explicitly opting in.
+  class UnsupportedBatchPathError < ConfigurationError; end
+
   # Raised when a requested ActiveRecord association does not exist.
   class UnknownAssociationError < Error; end
 

data/lib/paper_trail_diff/historical_association_reifier.rb

@@ -51,7 +51,7 @@ module PaperTrailDiff
     def reify_has_many(record, reflection)
       if reflection.options[:through]
         reify_association(record, reflection.through_reflection)
-        reifier(:HasManyThrough).reify(reflection, record, options, @transaction_id)
+        reify_through(record, reflection)
         return
       end
 
@@ -65,6 +65,31 @@ module PaperTrailDiff
       )
     end
 
+    # PT-AT's collection-source helper reifies every has_many on each join
+    # record. Walk only the requested source instead, including nested throughs.
+    #: (untyped, untyped) -> void
+    def reify_through(record, reflection)
+      source = reflection.source_reflection
+      if source.belongs_to?
+        reifier(:HasManyThrough).reify(reflection, record, options, @transaction_id)
+        return
+      end
+
+      members = through_members(record, reflection, source)
+      association = record.association(reflection.name)
+      association.target = members.uniq { |member| [member.class.base_class.name, member.id] }
+      association.loaded!
+    end
+
+    #: (untyped, untyped, untyped) -> Array[untyped]
+    def through_members(record, reflection, source)
+      joins = Array(record.public_send(reflection.through_reflection.name)) #: Array[untyped]
+      joins.flat_map do |join|
+        reify_association(join, source)
+        Array(join.public_send(source.name))
+      end
+    end
+
     #: (untyped, untyped) -> void
     def reify_habtm(record, reflection)
       unless @habtm_transaction_id

data/lib/paper_trail_diff/historical_filter.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Selects roots by the values they held at any point in the window, with an
+  # explicit ceiling on version loading.
+  #
+  # A version records the state *before* its own change, so the versions in
+  # the window supply the state at its start and after every change but the
+  # last. The state after the last change lives in the first version after
+  # the window, or in the live row when nothing follows; a destroy leaves none.
+  class HistoricalFilter
+    DEFAULT_VERSION_LIMIT = 10_000
+    CANDIDATE_BATCH = 250
+
+    #: (untyped, predicate: untyped, time_range: TimeRange?, limit: Integer, max_versions: Integer) -> void
+    def initialize(model, predicate:, time_range:, limit:, max_versions:)
+      @model = model
+      @predicate = validate_predicate(predicate)
+      @time_range = time_range
+      @limit = limit
+      @max_versions = validate_budget(max_versions)
+      @loaded = 0
+      @state_loader = PreparedVersionStateLoader.new
+    end
+
+    #: (Array[String]) -> Array[String]
+    def call(candidates)
+      matched = [] #: Array[String]
+      candidates.each_slice(CANDIDATE_BATCH) do |slice|
+        versions = candidate_versions(slice)
+        closing = closing_states(slice, versions)
+        slice.each do |id|
+          next unless held?(versions.fetch(id, []), closing[id])
+
+          matched << id
+          reject_root_limit! if matched.length > @limit
+        end
+      end
+      matched
+    end
+
+    private
+
+    # @rbs @model: untyped
+    # @rbs @predicate: untyped
+    # @rbs @time_range: TimeRange?
+    # @rbs @limit: Integer
+    # @rbs @max_versions: Integer
+    # @rbs @loaded: Integer
+    # @rbs @state_loader: PreparedVersionStateLoader
+
+    #: (untyped) -> untyped
+    def validate_predicate(predicate)
+      return predicate if predicate.respond_to?(:call)
+      unless predicate.is_a?(Hash)
+        raise ConfigurationError, 'historical_filter: must respond to call or be an attribute hash'
+      end
+
+      attributes = predicate.transform_keys(&:to_s)
+      unknown = attributes.keys - @model.attribute_names
+      if unknown.any?
+        raise ConfigurationError,
+              "unknown historical attributes: #{unknown.join(', ')}"
+      end
+
+      Support.immutable_copy(attributes)
+    end
+
+    #: (untyped) -> Integer
+    def validate_budget(value)
+      return value if value.is_a?(Integer) && value.positive?
+
+      raise ConfigurationError, 'max_filter_versions: must be a positive Integer'
+    end
+
+    #: (Array[String]) -> Hash[String, Array[untyped]]
+    def candidate_versions(ids)
+      relation = @model.paper_trail.version_class.where(item_type: @model.base_class.name,
+                                                        item_id: ids)
+      range = @time_range
+      relation = range.scope(relation) if range
+      versions = relation.reorder(created_at: :asc, id: :asc)
+                         .limit(@max_versions - @loaded + 1).to_a
+      account_versions!(versions.length)
+      versions.group_by { |version| version.item_id.to_s }
+    end
+
+    #: (Array[untyped], untyped) -> bool
+    def held?(versions, closing)
+      return true if versions.any? { |version| matches?(version) }
+      return false unless closing
+
+      Endpoint.version?(closing) ? matches?(closing) : record_matches?(closing)
+    end
+
+    # What each candidate held after its last change in the window.
+    #: (Array[String], Hash[String, Array[untyped]]) -> Hash[String, untyped]
+    def closing_states(ids, versions)
+      open = ids.reject { |id| versions.fetch(id, []).last&.event.to_s == 'destroy' }
+      return {} if open.empty?
+
+      trailing = trailing_versions(open)
+      trailing.merge(live_records(open - trailing.keys))
+    end
+
+    #: (Array[String]) -> Hash[String, untyped]
+    def trailing_versions(ids)
+      range = @time_range
+      return {} unless range
+
+      relation = @model.paper_trail.version_class.where(item_type: @model.base_class.name,
+                                                        item_id: ids)
+      trailing = range.first_trailing_versions(relation)
+      account_versions!(trailing.length)
+      trailing
+    end
+
+    #: (Array[String]) -> Hash[String, untyped]
+    def live_records(ids)
+      return {} if ids.empty?
+
+      @model.base_class.unscoped.where(@model.primary_key => ids).to_a
+            .to_h { |record| [record.id.to_s, record] }
+    end
+
+    #: (untyped) -> bool
+    def record_matches?(record)
+      return !!@predicate.call(record) unless @predicate.is_a?(Hash)
+
+      @predicate.all? { |name, expected| record.attributes.fetch(name) == expected }
+    end
+
+    #: (Integer) -> void
+    def account_versions!(count)
+      @loaded += count
+      return unless @loaded > @max_versions
+
+      raise FilterLimitExceededError,
+            "historical_filter: exceeds max_filter_versions: #{@max_versions}; " \
+            'narrow the window or explicitly increase the version budget'
+    end
+
+    #: (untyped) -> bool
+    def matches?(version)
+      if @predicate.is_a?(Hash)
+        return false unless version.object
+
+        return attributes_match?(version)
+      end
+
+      state = version.reify(dup: true)
+      !!(state && @predicate.call(state))
+    end
+
+    #: (untyped) -> bool
+    def attributes_match?(version)
+      state = @state_loader.call(version)
+      unless state
+        raise ConfigurationError,
+              'historical_filter: cannot read recorded attributes directly; use a bounded callable'
+      end
+
+      @predicate.all? do |name, expected|
+        unless state.attributes.key?(name)
+          raise ConfigurationError,
+                "historical_filter: #{name} was not recorded in version #{version.id}"
+        end
+
+        state.model_class.type_for_attribute(name).cast(state.attributes.fetch(name)) == expected
+      end
+    end
+
+    #: () -> void
+    def reject_root_limit!
+      raise BatchLimitExceededError,
+            "historical_filter: matched more than #{@limit} roots; narrow the window " \
+            'or the filter, or raise limit: to the population you intend to analyze'
+    end
+  end
+end

data/lib/paper_trail_diff/historical_snapshot_store.rb

@@ -10,6 +10,7 @@ module PaperTrailDiff
       @traversal = traversal
       @normalizer = normalizer
       @preparer = preparer
+      @prepared_snapshotter = PreparedSnapshotBuilder.new(traversal)
       @live_graph_collector = LiveGraphCollector.new(tree: tree, traversal: traversal)
       @snapshots = {} #: Hash[Array[untyped], RecordSnapshot?]
       @prepared_history = nil #: PreparedHistory?
@@ -24,8 +25,13 @@ module PaperTrailDiff
       end_at: root_versions.last.created_at
     )
       return if @tree.empty?
+
       # A batched preparation already covers these roots.
-      return if root_versions.any? { |v| @prepared_histories.key?(context_key(v)) }
+      batched = root_versions.find { |version| @prepared_histories.key?(context_key(version)) }
+      if batched
+        @prepared_history = @prepared_histories.fetch(context_key(batched))
+        return
+      end
 
       @prepared_history = PreparedHistoryLoader.new(
         record,
@@ -37,15 +43,24 @@ module PaperTrailDiff
       ).call
     end
 
-    #: (Array[untyped], Array[untyped]) -> void
-    def prepare_batch(records, root_versions)
+    #: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare_batch(records, root_versions, start_at: nil, end_at: nil)
       return if @tree.empty? || records.empty? || root_versions.empty?
 
       Instrumentation.instrument('prepare_history', batch_payload(records, root_versions)) do
-        register_batch(records, root_versions)
+        register_batch(records, root_versions, start_at: start_at, end_at: end_at)
       end
     end
 
+    # 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.
+    #: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare_deleted_batch(records, root_versions, start_at: nil, end_at: nil)
+      return if @tree.empty? || records.empty? || root_versions.empty?
+
+      register_batch(records, root_versions, live_records: [], start_at: start_at, end_at: end_at)
+    end
+
     #: (untyped, untyped) -> RecordSnapshot?
     def call(root_endpoint, context_endpoint)
       key = snapshot_key(root_endpoint, context_endpoint)
@@ -100,6 +115,11 @@ module PaperTrailDiff
       )
     end
 
+    #: () -> PreparedActivityIndex?
+    def activity_index
+      @prepared_history&.activity_index
+    end
+
     #: (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def record_transition(version)
       history = @prepared_history
@@ -108,12 +128,19 @@ module PaperTrailDiff
       history.record_transition(Endpoint.model_class(version), version.item_id, version)
     end
 
+    #: (untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(version, direct: false)
+      @prepared_history&.record_after(Endpoint.model_class(version), version.item_id, version,
+                                      direct: direct) || [false, nil]
+    end
+
     private
 
     # @rbs @tree: AssociationTree
     # @rbs @traversal: AssociationTraversal
     # @rbs @normalizer: SnapshotNormalizer
     # @rbs @preparer: untyped
+    # @rbs @prepared_snapshotter: PreparedSnapshotBuilder
     # @rbs @live_graph_collector: LiveGraphCollector
     # @rbs @snapshots: Hash[Array[untyped], RecordSnapshot?]
     # @rbs @prepared_history: PreparedHistory?
@@ -126,25 +153,22 @@ module PaperTrailDiff
 
     #: (Array[untyped], Array[untyped]) -> Hash[Symbol, untyped]
     def batch_payload(records, root_versions)
-      {
-        root_count: records.length,
-        version_count: root_versions.length,
-        model_type: records.first.class.base_class.name.to_s,
-        batched: true
-      }
+      { root_count: records.length, version_count: root_versions.length,
+        model_type: records.first.class.base_class.name.to_s, batched: true }
     end
 
-    #: (Array[untyped], Array[untyped]) -> void
-    def register_batch(records, root_versions)
+    #: (Array[untyped], Array[untyped], ?live_records: Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def register_batch(records, root_versions, live_records: @live_graph_collector.call(records),
+                       start_at: nil, end_at: nil)
       history = PreparedHistoryLoader.new(
         records.first,
         root_ids: records.map(&:id),
         root_versions: root_versions,
-        start_at: root_versions.map(&:created_at).min,
-        end_at: root_versions.map(&:created_at).max,
+        start_at: start_at || root_versions.map(&:created_at).min,
+        end_at: end_at || root_versions.map(&:created_at).max,
         tree: @tree,
         traversal: @traversal,
-        live_records: @live_graph_collector.call(records)
+        live_records: live_records
       ).call
       root_versions.each { |version| @prepared_histories[context_key(version)] = history }
     end
@@ -154,27 +178,24 @@ module PaperTrailDiff
       model_class = Endpoint.model_class(root_version)
       @preparer.call(model_class, historical: true)
       @traversal.ensure_habtm_history!(model_class, root_version)
-      record = root_version.reify(dup: true)
-      normalize(
-        record,
-        context_version,
-        tree: tree,
-        normalizer: normalizer,
-        habtm_version: root_version
+      handled, snapshot = @prepared_snapshotter.call(
+        root_version, context_version, tree: tree, normalizer: normalizer,
+                                       history: @prepared_histories[context_key(context_version)] ||
+                                         @prepared_history
       )
+      return snapshot if handled
+
+      record = root_version.reify(dup: true)
+      normalize(record, context_version, tree: tree, normalizer: normalizer,
+                                         habtm_version: root_version)
     end
 
     #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
     def snapshot_from_live_root(root_record, context_version, tree:, normalizer:)
       record = Endpoint.reload_record(root_record)
       @preparer.call(record.class, historical: true)
-      normalize(
-        record,
-        context_version,
-        tree: tree,
-        normalizer: normalizer,
-        habtm_version: context_version
-      )
+      normalize(record, context_version, tree: tree, normalizer: normalizer,
+                                         habtm_version: context_version)
     end
 
     #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, habtm_version: untyped) -> RecordSnapshot?
@@ -188,12 +209,7 @@ module PaperTrailDiff
 
     #: (untyped, untyped) -> Array[untyped]
     def snapshot_key(root_endpoint, context_endpoint)
-      [
-        root_endpoint.class.name,
-        root_endpoint.id,
-        context_endpoint.class.name,
-        context_endpoint.id
-      ]
+      context_key(root_endpoint) + context_key(context_endpoint)
     end
   end
 end

data/lib/paper_trail_diff/instrumentation.rb

@@ -9,13 +9,13 @@ module PaperTrailDiff
     module_function
 
     #: (String | Symbol, Hash[Symbol, untyped]) { () -> untyped } -> untyped
-    def instrument(event, payload, &)
+    def instrument(event, payload, &block)
       active_support = Object.const_get(:ActiveSupport) #: untyped
       notifications = active_support.const_get(:Notifications) #: untyped
       notifications.instrument(
         "#{event}.paper_trail_diff",
         payload,
-        &
+        &block
       )
     end