paper_trail_diff 0.3.0 → 0.4.0

data/lib/paper_trail_diff/prepared_record_index.rb

@@ -21,9 +21,14 @@ module PaperTrailDiff
       state
     end
 
+    # Mirrors PaperTrail's reifier, which writes attributes directly. Mass
+    # assignment would route reconstructed state through application-defined
+    # attribute writers and reify a different record than the version stored.
     #: () -> untyped
     def instantiate
-      @model_class.new(@attributes)
+      record = @model_class.new
+      @attributes.each { |name, value| record[name] = value }
+      record
     end
 
     private
@@ -108,6 +113,7 @@ module PaperTrailDiff
       @version_positions = @versions.each_with_index.to_h do |version, index|
         [version.id.to_s, index]
       end.freeze
+      @transaction_positions = build_transaction_positions
       @live = live
       @state_loader = state_loader
       @states = {} #: Hash[untyped, PreparedRecordState?]
@@ -115,8 +121,8 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def record_before(boundary)
-      version = versions.find { |candidate| eligible?(candidate, boundary) }
-      return state_for(version)&.instantiate if version
+      index = boundary_index(boundary)
+      return state_for(versions.fetch(index))&.instantiate if index
 
       @live&.instantiate
     end
@@ -146,6 +152,7 @@ module PaperTrailDiff
     # @rbs @state_loader: PreparedVersionStateLoader
     # @rbs @states: Hash[untyped, PreparedRecordState?]
     # @rbs @version_positions: Hash[String, Integer]
+    # @rbs @transaction_positions: Hash[untyped, Integer]
 
     #: (Integer) -> PreparedRecordState?
     def state_after(index)
@@ -153,16 +160,41 @@ module PaperTrailDiff
       successor ? state_for(successor) : @live
     end
 
-    #: (untyped, untyped) -> bool
-    def eligible?(version, boundary)
-      version.created_at >= boundary.created_at || same_transaction?(version, boundary)
+    # A version is eligible when it is at or after the boundary, or shares the
+    # boundary's transaction. The first is monotonic over the chronological
+    # list and the second is indexed, so neither rescans a long history once
+    # per boundary.
+    #: (untyped) -> Integer?
+    def boundary_index(boundary)
+      created_at = boundary.created_at
+      chronological = versions.bsearch_index do |candidate|
+        candidate.created_at >= created_at
+      end
+      transactional = transaction_index(boundary)
+      return chronological unless transactional
+      return transactional unless chronological
+
+      [chronological, transactional].min
     end
 
-    #: (untyped, untyped) -> bool
-    def same_transaction?(version, boundary)
+    #: (untyped) -> Integer?
+    def transaction_index(boundary)
       transaction_id = boundary.transaction_id if boundary.respond_to?(:transaction_id)
-      transaction_id && version.respond_to?(:transaction_id) &&
-        version.transaction_id == transaction_id
+      return unless transaction_id
+
+      @transaction_positions[transaction_id]
+    end
+
+    #: () -> Hash[untyped, Integer]
+    def build_transaction_positions
+      positions = {} #: Hash[untyped, Integer]
+      @versions.each_with_index do |version, index|
+        next unless version.respond_to?(:transaction_id)
+
+        transaction_id = version.transaction_id
+        positions[transaction_id] ||= index if transaction_id
+      end
+      positions.freeze
     end
 
     #: (untyped) -> PreparedRecordState?
@@ -185,9 +217,10 @@ module PaperTrailDiff
 
   # Request-scoped scalar history loaded once per model identity.
   class PreparedRecordIndex
-    #: (untyped, ?live_records: Array[untyped]) -> void
-    def initialize(start_at, live_records: [])
-      @start_time = start_at
+    #: (untyped, ?end_at: untyped, ?live_records: Array[untyped]) -> void
+    def initialize(start_at, end_at: nil, live_records: [])
+      @start_time = boundary_time(start_at)
+      @end_time = boundary_time(end_at)
       @seeded_live_records = live_records.to_h do |record|
         [identity(record.class, record.id), record]
       end
@@ -230,10 +263,17 @@ module PaperTrailDiff
     private
 
     # @rbs @start_time: untyped
+    # @rbs @end_time: untyped
     # @rbs @seeded_live_records: Hash[Array[String], untyped]
     # @rbs @state_loader: PreparedVersionStateLoader
     # @rbs @series: Hash[Array[String], PreparedRecordSeries]
 
+    # Callers bound the range with either a version or a bare timestamp.
+    #: (untyped) -> untyped
+    def boundary_time(value)
+      value.respond_to?(:created_at) ? value.created_at : value
+    end
+
     #: (untyped, untyped) -> Array[String]
     def identity(model_class, id)
       [model_class.base_class.name.to_s, id.to_s]
@@ -254,12 +294,47 @@ module PaperTrailDiff
       )
     end
 
+    # A PaperTrail version is a pre-change snapshot, so the state at the last
+    # selected boundary can only live in the next version after it. One
+    # trailing version per identity is retained, rather than every version
+    # recorded between the requested range and the present.
     #: (untyped, Array[untyped]) -> Array[untyped]
     def versions_for(model_class, ids)
-      model_class.paper_trail.version_class.where(
+      version_class = model_class.paper_trail.version_class
+      scope = version_class.where(
         item_type: model_class.base_class.name,
         item_id: ids
-      ).where('created_at >= ?', @start_time).order(:id).to_a
+      ).where(created_at: @start_time..)
+      scope = scope.where(window_condition(version_class)) if @end_time
+      scope.order(:id).to_a
+    end
+
+    # In range, or the earliest version after it, resolved in the same query
+    # rather than with a window function or one query per identity.
+    #: (untyped) -> untyped
+    def window_condition(version_class)
+      table = version_class.arel_table
+      table[:created_at].lteq(@end_time).or(first_after_range(table))
+    end
+
+    #: (untyped) -> untyped
+    def first_after_range(table)
+      arel = Object.const_get(:Arel) #: untyped
+      later = table.alias('paper_trail_diff_later_versions')
+      arel.const_get(:SelectManager).new
+          .from(later)
+          .project(arel.sql('1'))
+          .where(preceding_trailing_version(table, later))
+          .exists
+          .not
+    end
+
+    #: (untyped, untyped) -> untyped
+    def preceding_trailing_version(table, later)
+      later[:item_type].eq(table[:item_type])
+                       .and(later[:item_id].eq(table[:item_id]))
+                       .and(later[:created_at].gt(@end_time))
+                       .and(later[:created_at].lt(table[:created_at]))
     end
 
     #: (untyped, Array[untyped]) -> Array[untyped]

data/lib/paper_trail_diff/snapshot.rb

@@ -57,6 +57,30 @@ module PaperTrailDiff
     end
     private_constant :IdentityIndexCache
 
+    # Identifies one snapshot for internal carry-forward. A transition cannot
+    # hold its origin without retaining every earlier snapshot at that path,
+    # and `object_id` is only guaranteed unique among live objects, so Ruby may
+    # hand a collected snapshot's id to a later one.
+    class SerialSequence
+      #: () -> void
+      def initialize
+        @mutex = Mutex.new
+        @counter = 0
+      end
+
+      #: () -> Integer
+      def next_serial
+        @mutex.synchronize { @counter += 1 }
+      end
+
+      # @rbs @mutex: Thread::Mutex
+      # @rbs @counter: Integer
+    end
+    private_constant :SerialSequence
+
+    SERIALS = SerialSequence.new
+    private_constant :SERIALS
+
     class << self
       #: (Symbol) -> bool
       def collection_kind?(kind)
@@ -66,6 +90,7 @@ module PaperTrailDiff
 
     attr_reader :kind #: Symbol
     attr_reader :records #: Array[RecordSnapshot]
+    attr_reader :serial #: Integer
 
     #: (kind: Symbol, records: Array[RecordSnapshot], ?identity_index_cache: untyped, ?transition: CollectionTransition?) -> void
     def initialize(kind:, records:, identity_index_cache: nil, transition: nil)
@@ -80,6 +105,7 @@ module PaperTrailDiff
       @records = records.frozen? ? records : records.dup.freeze
       @identity_index_cache = identity_index_cache || IdentityIndexCache.new
       @transition = transition
+      @serial = SERIALS.next_serial
       freeze
     end
 

data/lib/paper_trail_diff/snapshot_normalizer.rb

@@ -53,6 +53,7 @@ module PaperTrailDiff
       @traversal = traversal
       @pool = pool
       @structural_columns = {} #: Hash[String, Array[String]]
+      @excluded_attributes = {} #: Hash[Array[untyped], Array[String]]
     end
 
     #: (untyped, reifier: untyped) -> RecordSnapshot?
@@ -86,6 +87,7 @@ module PaperTrailDiff
     # @rbs @traversal: AssociationTraversal
     # @rbs @pool: SnapshotPool
     # @rbs @structural_columns: Hash[String, Array[String]]
+    # @rbs @excluded_attributes: Hash[Array[untyped], Array[String]]
 
     #: (untyped, AssociationTree, String, untyped, Array[untyped]) -> RecordSnapshot?
     def normalize_record(record, tree, path, reifier, reflections)
@@ -107,15 +109,25 @@ module PaperTrailDiff
       attributes
     end
 
+    # Every input is fixed for one model class at one selected path, and the
+    # path's structural columns are recorded before its records normalize, so
+    # this is resolved once instead of per record per boundary.
     #: (untyped, Array[untyped], String) -> Array[String]
     def excluded_attributes(record, reflections, path)
-      primary_key = record.class.primary_key #: untyped
+      model_class = record.class
+      @excluded_attributes[[model_class, path]] ||=
+        build_excluded_attributes(model_class, reflections, path)
+    end
+
+    #: (untyped, Array[untyped], String) -> Array[String]
+    def build_excluded_attributes(model_class, reflections, path)
+      primary_key = model_class.primary_key #: untyped
       primary_keys = primary_key.is_a?(Array) ? primary_key : [primary_key]
       # @type var primary_keys: Array[untyped]
       primary_keys = primary_keys.map { |key| key.to_s } # rubocop:disable Style/SymbolProc
       ignored = @ignore_policy.attributes_for(path)
       structural = @structural_columns.fetch(path, [])
-      (primary_keys + ignored + relationship_columns(reflections) + structural).uniq
+      (primary_keys + ignored + relationship_columns(reflections) + structural).uniq.freeze
     end
 
     #: (Array[untyped]) -> Array[String]

data/lib/paper_trail_diff/time_activity_timeline_builder.rb

@@ -14,17 +14,17 @@ module PaperTrailDiff
 
     #: () -> Array[ActivityStep]
     def build
-      history, = history_and_versions
-      history.steps
+      history, _root_versions, closing = history_and_versions
+      activity_steps(history, closing)
     end
 
     #: () -> Analysis
     def analyze
-      history, root_versions = history_and_versions
+      history, root_versions, closing = history_and_versions
       Analysis.new(
         diff: Engine.compare(history.first_snapshot, history.last_snapshot),
-        timeline: root_steps(root_versions, history.root_snapshots),
-        activity_timeline: history.steps
+        timeline: ActivityRootSteps.call(root_versions, history.root_snapshots),
+        activity_timeline: activity_steps(history, closing)
       )
     end
 
@@ -35,22 +35,61 @@ module PaperTrailDiff
     # @rbs @tree: AssociationTree
     # @rbs @snapshotter: untyped
 
-    #: () -> [ActivityHistory, Array[untyped]]
+    #: () -> [ActivityHistory, Array[untyped], ActivityStep?]
     def history_and_versions
       root_versions = @range.select(context_required: !@tree.empty?)
-      return [ActivityHistory.empty, root_versions] if root_versions.empty?
+      return [ActivityHistory.empty, root_versions, nil] if root_versions.empty?
 
       prepare_history(root_versions)
       events = collect_events(root_versions)
-      return [ActivityHistory.empty, root_versions] unless time_events?(events)
+      selected = selected_events(events)
+      return [ActivityHistory.empty, root_versions, nil] unless time_events?(selected, events)
 
-      history = ActivityHistoryBuilder.new(
+      history = build_history(root_versions, events)
+      [history, root_versions, closing_step(history, selected.last)]
+    end
+
+    #: (Array[untyped], Array[ActivityEvent]) -> ActivityHistory
+    def build_history(root_versions, events)
+      ActivityHistoryBuilder.new(
         root_versions,
         events,
         @snapshotter,
         include_step: ->(event) { @range.include?(event.version) }
       ).call
-      [history, root_versions]
+    end
+
+    #: (ActivityHistory, ActivityStep?) -> Array[ActivityStep]
+    def activity_steps(history, closing)
+      return history.steps unless closing
+
+      (history.steps + [closing]).freeze
+    end
+
+    #: (Array[ActivityEvent]) -> Array[ActivityEvent]
+    def selected_events(events)
+      events.select { |event| @range.include?(event.version) }
+    end
+
+    # 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(history, event)
+      return unless event && terminal_destroy?(event)
+
+      version = event.version
+      ActivityStep.new(
+        from_boundary: ActivityBoundary.from_version(version),
+        to_boundary: ActivityBoundary.destroyed(version),
+        diff: Engine.compare(history.root_snapshots[ActivityRootSteps.version_key(version)], nil)
+      )
+    end
+
+    #: (ActivityEvent?) -> bool
+    def terminal_destroy?(event)
+      return false unless event
+
+      event.root? && event.version.event.to_s == 'destroy'
     end
 
     #: (Array[untyped]) -> void
@@ -72,11 +111,11 @@ module PaperTrailDiff
       ).call
     end
 
-    #: (Array[ActivityEvent]) -> bool
-    def time_events?(events)
-      selected = events.select { |event| @range.include?(event.version) }
+    #: (Array[ActivityEvent], Array[ActivityEvent]) -> bool
+    def time_events?(selected, events)
       return false if selected.empty?
       return true if later_event?(selected.last, events)
+      return true if terminal_destroy?(selected.last)
 
       message = 'time range requires a later activity boundary to reconstruct its final change'
       raise IncompleteTimeRangeError, message
@@ -88,24 +127,5 @@ module PaperTrailDiff
         Support.compare_versions(selected.version, event.version).negative?
       end
     end
-
-    #: (Array[untyped], Hash[Array[untyped], RecordSnapshot?]) -> Array[Step]
-    def root_steps(root_versions, root_snapshots)
-      snapshots = root_versions.map do |version|
-        root_snapshots.fetch(version_key(version))
-      end
-      root_versions.each_cons(2).with_index.map do |versions, index|
-        Step.new(
-          from_version: versions.fetch(0),
-          to_version: versions.fetch(1),
-          diff: Engine.compare(snapshots.fetch(index), snapshots.fetch(index + 1))
-        )
-      end.freeze
-    end
-
-    #: (untyped) -> Array[untyped]
-    def version_key(version)
-      [version.class.name, version.id]
-    end
   end
 end

data/lib/paper_trail_diff/time_version_range.rb

@@ -19,6 +19,8 @@ module PaperTrailDiff
 
       trailing = trailing_version(relation)
       unless trailing
+        return selected.freeze if terminal_destroy?(selected)
+
         message = 'time range requires a later root version to reconstruct its final change'
         raise IncompleteTimeRangeError, message
       end
@@ -40,6 +42,15 @@ module PaperTrailDiff
       raise InvalidTimelineRangeError, message, cause: e
     end
 
+    # A window closing on the record's own destruction needs no later version:
+    # the destroy reveals the preceding mutation and nothing can follow it, so
+    # demanding a checkpoint that can never be written would reject the range
+    # permanently.
+    #: (Array[untyped]) -> bool
+    def terminal_destroy?(versions)
+      versions.last&.event.to_s == 'destroy'
+    end
+
     #: (untyped) -> untyped
     def trailing_version(relation)
       @time_range.trailing_scope(relation).reorder(created_at: :asc, id: :asc).first

data/lib/paper_trail_diff/timeline_range.rb

@@ -4,6 +4,8 @@
 module PaperTrailDiff
   # Chooses explicit-version or wall-clock selection for one timeline request.
   class TimelineRange
+    BOUNDARY_SYMBOLS = %i[first last].freeze
+
     attr_reader :from #: untyped
     attr_reader :to #: untyped
     attr_reader :time_range #: TimeRange?
@@ -11,13 +13,22 @@ module PaperTrailDiff
     #: (untyped, from: untyped, to: untyped, within: untyped) -> void
     def initialize(record, from:, to:, within:)
       @record = record
-      @from = from
-      @to = to
+      @requested_from = from
+      @requested_to = to
       @time_range = build_time_range(within)
       validate_mode!
+      @from = resolve(from)
+      @to = resolve(to)
       freeze
     end
 
+    # A record with no versions has no first or last boundary to resolve, which
+    # is an empty history rather than a bad request.
+    #: () -> bool
+    def unresolved?
+      (symbolic?(@requested_from) && @from.nil?) || (symbolic?(@requested_to) && @to.nil?)
+    end
+
     #: (?context_required: bool) -> Array[untyped]
     def select(context_required: false)
       range = time_range
@@ -26,6 +37,7 @@ module PaperTrailDiff
           context_required: context_required
         )
       end
+      return empty_versions if unresolved?
 
       VersionRange.new(@record, from: @from, to: @to).select
     end
@@ -49,9 +61,50 @@ module PaperTrailDiff
     private
 
     # @rbs @record: untyped
+    # @rbs @requested_from: untyped
+    # @rbs @requested_to: untyped
     # @rbs @from: untyped
     # @rbs @to: untyped
 
+    #: () -> Array[untyped]
+    def empty_versions
+      versions = [] #: Array[untyped]
+      versions.freeze
+    end
+
+    #: (untyped) -> bool
+    def symbolic?(boundary)
+      boundary.is_a?(Symbol)
+    end
+
+    # Resolving `:first` and `:last` here keeps callers from depending on the
+    # order PaperTrail happens to give its versions association, which a caller
+    # is also free to reorder.
+    #: (untyped) -> untyped
+    def resolve(boundary)
+      return boundary unless symbolic?(boundary)
+
+      unless BOUNDARY_SYMBOLS.include?(boundary)
+        raise InvalidTimelineRangeError,
+              "unsupported boundary: #{boundary.inspect}; use :first, :last, a version, or a record"
+      end
+
+      boundary == :first ? ordered_versions.first : ordered_versions.last
+    end
+
+    #: () -> untyped
+    def ordered_versions
+      versions_relation.reorder(created_at: :asc, id: :asc)
+    end
+
+    #: () -> untyped
+    def versions_relation
+      @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) -> TimeRange?
     def build_time_range(within)
       TimeRange.new(within) unless within.nil?
@@ -60,11 +113,11 @@ module PaperTrailDiff
     #: () -> void
     def validate_mode!
       if time?
-        return if @from.nil? && @to.nil?
+        return if @requested_from.nil? && @requested_to.nil?
 
         raise InvalidTimelineRangeError, '`within` cannot be combined with `from` or `to`'
       end
-      return unless @from.nil? || @to.nil?
+      return unless @requested_from.nil? || @requested_to.nil?
 
       raise InvalidTimelineRangeError, 'provide both `from` and `to`, or provide `within`'
     end

data/lib/paper_trail_diff/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module PaperTrailDiff
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/paper_trail_diff/version_association_candidate_scope.rb

@@ -24,45 +24,72 @@ module PaperTrailDiff
     # @rbs @start_at: untyped
     # @rbs @end_at: untyped
 
+    # Only quoting helpers are needed, so the connection is borrowed for the
+    # duration of building the condition rather than checked out permanently,
+    # which Active Record 7.2 and newer can deprecate. Active Record 7.1 has no
+    # `with_connection` and reaches the same connection through the accessor.
+    #: () { (untyped) -> String } -> String
+    def with_connection(&block)
+      return @version_class.with_connection(&block) if @version_class.respond_to?(:with_connection)
+
+      block.call(@version_class.connection)
+    end
+
     #: () -> String
-    def candidate_condition # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      connection = @version_class.connection
+    def candidate_condition
+      with_connection { |connection| condition_sql(connection) }
+    end
+
+    #: (untyped) -> String
+    def condition_sql(connection) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       outer = connection.quote_table_name(@version_class.table_name)
       later = connection.quote_table_name('paper_trail_diff_later_versions')
       start_at = connection.quote(@start_at)
-      destroyed = connection.quote('destroy')
-      activity = activity_condition(outer, start_at)
+      columns = quoted_columns(connection, outer, later)
       compact_sql(<<~SQL)
         (
-          #{activity}
+          #{activity_condition(columns, start_at, connection)}
           OR (
-            #{column(outer, 'created_at')} < #{start_at}
-            AND #{column(outer, 'event')} != #{destroyed}
+            #{columns.fetch(:outer_created_at)} < #{start_at}
+            AND #{columns.fetch(:outer_event)} != #{connection.quote('destroy')}
             AND NOT EXISTS (
               SELECT 1
                 FROM #{outer} #{later}
-               WHERE #{column(later, 'item_type')} = #{column(outer, 'item_type')}
-                 AND #{column(later, 'item_id')} = #{column(outer, 'item_id')}
-                 AND #{column(later, 'created_at')} < #{start_at}
-                 AND #{column(later, 'created_at')} > #{column(outer, 'created_at')}
+               WHERE #{columns.fetch(:later_item_type)} = #{columns.fetch(:outer_item_type)}
+                 AND #{columns.fetch(:later_item_id)} = #{columns.fetch(:outer_item_id)}
+                 AND #{columns.fetch(:later_created_at)} < #{start_at}
+                 AND #{columns.fetch(:later_created_at)} > #{columns.fetch(:outer_created_at)}
             )
           )
         )
       SQL
     end
 
-    #: (String, String) -> String
-    def activity_condition(table, start_at)
-      condition = "#{column(table, 'created_at')} >= #{start_at}"
+    #: (untyped, String, String) -> Hash[Symbol, String]
+    def quoted_columns(connection, outer, later)
+      {
+        outer_created_at: column(connection, outer, 'created_at'),
+        outer_event: column(connection, outer, 'event'),
+        outer_item_type: column(connection, outer, 'item_type'),
+        outer_item_id: column(connection, outer, 'item_id'),
+        later_created_at: column(connection, later, 'created_at'),
+        later_item_type: column(connection, later, 'item_type'),
+        later_item_id: column(connection, later, 'item_id')
+      }
+    end
+
+    #: (Hash[Symbol, String], String, untyped) -> String
+    def activity_condition(columns, start_at, connection)
+      created_at = columns.fetch(:outer_created_at)
+      condition = "#{created_at} >= #{start_at}"
       return condition unless @end_at
 
-      end_at = @version_class.connection.quote(@end_at)
-      "(#{condition} AND #{column(table, 'created_at')} <= #{end_at})"
+      "(#{condition} AND #{created_at} <= #{connection.quote(@end_at)})"
     end
 
-    #: (String, String) -> String
-    def column(table, name)
-      "#{table}.#{@version_class.connection.quote_column_name(name)}"
+    #: (untyped, String, String) -> String
+    def column(connection, table, name)
+      "#{table}.#{connection.quote_column_name(name)}"
     end
 
     #: (String) -> String

data/lib/paper_trail_diff.rb

@@ -40,12 +40,22 @@ require_relative 'paper_trail_diff/comparison_batch'
 require_relative 'paper_trail_diff/snapshot_normalizer'
 require_relative 'paper_trail_diff/historical_snapshot_store'
 require_relative 'paper_trail_diff/timeline_snapshot_provider'
+require_relative 'paper_trail_diff/activity_event_record_resolver'
+require_relative 'paper_trail_diff/activity_event_route_finder'
+require_relative 'paper_trail_diff/activity_relationship'
+require_relative 'paper_trail_diff/activity_collection_route_change'
+require_relative 'paper_trail_diff/activity_collection_record_updater'
+require_relative 'paper_trail_diff/activity_collection_route_updater'
+require_relative 'paper_trail_diff/activity_event_record_normalizer'
+require_relative 'paper_trail_diff/activity_collection_event_applier'
+require_relative 'paper_trail_diff/activity_belongs_to_event_applier'
 require_relative 'paper_trail_diff/activity_event_snapshot_refresher'
 require_relative 'paper_trail_diff/activity_root_snapshot_refresher'
 require_relative 'paper_trail_diff/branch_snapshot_refresher'
 require_relative 'paper_trail_diff/activity_boundary'
 require_relative 'paper_trail_diff/step'
 require_relative 'paper_trail_diff/analysis'
+require_relative 'paper_trail_diff/activity_root_steps'
 require_relative 'paper_trail_diff/version_range'
 require_relative 'paper_trail_diff/time_range'
 require_relative 'paper_trail_diff/time_version_range'