paper_trail_diff 0.1.0

data/lib/paper_trail_diff/activity_root_snapshot_refresher.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Advances scalar-only root events while retaining already reconstructed associations.
+  class ActivityRootSnapshotRefresher
+    #: (tree: AssociationTree, traversal: AssociationTraversal, normalizer: SnapshotNormalizer, record_after: untyped, changeset: untyped, partial_snapshotter: untyped) -> void
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      tree:,
+      traversal:,
+      normalizer:,
+      record_after:,
+      changeset:,
+      partial_snapshotter:
+    )
+      @tree = tree
+      @traversal = traversal
+      @normalizer = normalizer
+      @record_after = record_after
+      @changeset = changeset
+      @partial_snapshotter = partial_snapshotter
+      @unsupported_branches = {} #: Hash[String, Array[String]]
+      @relationship_reflections = {} #: Hash[String, Array[untyped]]
+    end
+
+    #: (untyped, untyped, RecordSnapshot?, ActivityEvent) -> [bool, RecordSnapshot?]
+    def call( # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      root_endpoint,
+      context_endpoint,
+      previous,
+      event
+    )
+      return [false, nil] unless previous && event.root?
+
+      version = event.version
+      model_class = Endpoint.model_class(version)
+      return [false, nil] unless same_record?(previous, version)
+
+      changes = @changeset.call(version, model_class)
+      return [false, nil] unless changes.respond_to?(:each)
+
+      branches = branches_to_refresh(model_class, changes)
+      partial = nil #: RecordSnapshot?
+      unless branches.empty?
+        partial = @partial_snapshotter.call(root_endpoint, context_endpoint, branches)
+      end
+      return [false, nil] if !branches.empty? && !partial
+
+      attributes = advanced_attributes(previous, version, changes)
+      return [false, nil] unless attributes
+
+      incoming_associations = {} #: snapshot_associations
+      incoming_associations = partial.associations if partial
+      associations = previous.associations.merge(incoming_associations)
+      return [true, previous] if attributes == previous.attributes &&
+                                 associations == previous.associations
+
+      [
+        true,
+        RecordSnapshot.new(
+          type: previous.type,
+          id: previous.id,
+          attributes: attributes,
+          associations: associations
+        )
+      ]
+    end
+
+    private
+
+    # @rbs @tree: AssociationTree
+    # @rbs @traversal: AssociationTraversal
+    # @rbs @normalizer: SnapshotNormalizer
+    # @rbs @record_after: untyped
+    # @rbs @changeset: untyped
+    # @rbs @partial_snapshotter: untyped
+    # @rbs @unsupported_branches: Hash[String, Array[String]]
+    # @rbs @relationship_reflections: Hash[String, Array[untyped]]
+
+    #: (RecordSnapshot, untyped, untyped) -> snapshot_attributes?
+    def advanced_attributes(previous, version, changes)
+      return previous.attributes if changes.empty?
+
+      record = @record_after.call(version)
+      return unless record
+
+      @normalizer.attributes_for(record, tree: @tree, path: '')
+    end
+
+    #: (untyped, untyped) -> Array[String]
+    def branches_to_refresh(model_class, changes)
+      (unsupported_branches(model_class) + changed_relationship_branches(model_class, changes))
+        .uniq
+        .sort
+        .freeze
+    end
+
+    #: (untyped) -> Array[String]
+    def unsupported_branches(model_class)
+      key = model_class.name.to_s
+      return @unsupported_branches[key] if @unsupported_branches.key?(key)
+
+      @unsupported_branches[key] = @traversal.selected_reflections(
+        model_class
+      ).filter_map do |path, reflection|
+        path.split('.').first unless direct_versioned_reflection?(reflection)
+      end.uniq.sort.freeze
+    end
+
+    #: (untyped) -> bool
+    def direct_versioned_reflection?(reflection)
+      return false if reflection.polymorphic? || reflection.options[:through]
+      return false if reflection.macro == :has_and_belongs_to_many
+
+      paper_trail = Object.const_get(:PaperTrail) #: untyped
+      paper_trail.request.enabled_for_model?(reflection.klass)
+    rescue NameError
+      false
+    end
+
+    #: (RecordSnapshot, untyped) -> bool
+    def same_record?(snapshot, version)
+      identity = Endpoint.identity(version)
+      snapshot.type.to_s == identity.fetch(0) && snapshot.id.to_s == identity.fetch(1)
+    end
+
+    #: (untyped, untyped) -> Array[String]
+    def changed_relationship_branches(model_class, changes)
+      changed = changes.each_key.map(&:to_s)
+      root_relationship_reflections(model_class).filter_map do |reflection|
+        reflection.name.to_s if changed.intersect?(relationship_columns(reflection))
+      end
+    end
+
+    #: (untyped) -> Array[untyped]
+    def root_relationship_reflections(model_class)
+      key = model_class.name.to_s
+      @relationship_reflections[key] ||= @traversal.reflections_for(
+        model_class,
+        @tree,
+        path: ''
+      ).select { |reflection| reflection.macro == :belongs_to }.freeze
+    end
+
+    #: (untyped) -> Array[String]
+    def relationship_columns(reflection)
+      foreign_keys = Array(reflection.foreign_key)
+      # @type var foreign_keys: Array[untyped]
+      columns = foreign_keys.map do |name| # rubocop:disable Style/SymbolProc
+        name.to_s
+      end
+      columns << reflection.foreign_type.to_s if reflection.polymorphic?
+      columns
+    end
+  end
+end

data/lib/paper_trail_diff/activity_snapshot_sequence.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Optional full/partial snapshot operations consumed by the activity sequence.
+  class ActivitySnapshotProvider
+    #: (snapshotter: untyped, refresher: untyped, preparer: untyped) -> void
+    def initialize(snapshotter:, refresher:, preparer:)
+      @snapshotter = snapshotter
+      @refresher = refresher
+      @preparer = preparer
+    end
+
+    #: (untyped, Array[untyped]) -> void
+    def prepare(record, root_versions)
+      @preparer.call(record, root_versions)
+    end
+
+    #: (untyped, untyped) -> RecordSnapshot?
+    def call(root_endpoint, context_endpoint)
+      @snapshotter.call(root_endpoint, context_endpoint)
+    end
+
+    #: (untyped, untyped, RecordSnapshot?, Array[String], event: ActivityEvent, isolated: bool) -> RecordSnapshot?
+    def refresh( # rubocop:disable Metrics/ParameterLists
+      root_endpoint,
+      context_endpoint,
+      previous_snapshot,
+      branches,
+      event:,
+      isolated:
+    )
+      @refresher.call(
+        root_endpoint,
+        context_endpoint,
+        previous_snapshot,
+        branches,
+        event: event,
+        isolated: isolated
+      )
+    end
+
+    #: (untyped, untyped, RecordSnapshot?, event: ActivityEvent) -> RecordSnapshot?
+    def advance_root(root_endpoint, context_endpoint, previous_snapshot, event:)
+      @refresher.advance_root(
+        root_endpoint,
+        context_endpoint,
+        previous_snapshot,
+        event: event
+      )
+    end
+
+    # @rbs @snapshotter: untyped
+    # @rbs @refresher: untyped
+    # @rbs @preparer: untyped
+  end
+
+  # Builds chronological snapshots, refreshing only branches affected by prior events.
+  class ActivitySnapshotSequence
+    #: (Array[untyped], Array[ActivityEvent], untyped, ?current: untyped) -> void
+    def initialize(root_versions, events, snapshotter, current: nil)
+      @root_versions = root_versions
+      @events = events
+      @snapshotter = snapshotter
+      @current = current
+      @transaction_groups = ActivityTransactionGroups.new(events)
+      @root_endpoints = build_root_endpoints
+    end
+
+    #: () -> Array[RecordSnapshot?]
+    def call
+      snapshots = [] #: Array[RecordSnapshot?]
+      each { |_event, snapshot| snapshots << snapshot }
+      snapshots
+    end
+
+    #: () { (ActivityEvent, RecordSnapshot?) -> void } -> void
+    def each
+      first = @events.first
+      return unless first
+
+      previous_snapshot = full_snapshot(first)
+      yield first, previous_snapshot
+      @events.each_cons(2) do |pair|
+        previous_event = pair.fetch(0)
+        event = pair.fetch(1)
+        previous_snapshot = transition_snapshot(previous_event, event, previous_snapshot)
+        yield event, previous_snapshot
+      end
+    end
+
+    private
+
+    # @rbs @root_versions: Array[untyped]
+    # @rbs @events: Array[ActivityEvent]
+    # @rbs @snapshotter: untyped
+    # @rbs @current: untyped
+    # @rbs @transaction_groups: ActivityTransactionGroups
+    # @rbs @root_endpoints: Hash[untyped, untyped]
+
+    #: (ActivityEvent, ActivityEvent, RecordSnapshot?) -> RecordSnapshot?
+    def transition_snapshot(previous_event, event, previous_snapshot)
+      return advance_root(previous_event, event, previous_snapshot) if
+        incremental_root?(previous_event)
+
+      branches = @transaction_groups.branches_for(previous_event)
+      return full_snapshot(event) unless branches && @snapshotter.respond_to?(:refresh)
+
+      @snapshotter.refresh(
+        root_endpoint(event.version),
+        event.version,
+        previous_snapshot,
+        branches,
+        event: previous_event,
+        isolated: @transaction_groups.isolated?(previous_event)
+      )
+    end
+
+    #: (ActivityEvent) -> bool
+    def incremental_root?(event)
+      event.root? && @transaction_groups.isolated?(event) &&
+        @snapshotter.respond_to?(:advance_root)
+    end
+
+    #: (ActivityEvent, ActivityEvent, RecordSnapshot?) -> RecordSnapshot?
+    def advance_root(previous_event, event, previous_snapshot)
+      @snapshotter.advance_root(
+        root_endpoint(event.version),
+        event.version,
+        previous_snapshot,
+        event: previous_event
+      )
+    end
+
+    #: (ActivityEvent) -> RecordSnapshot?
+    def full_snapshot(event)
+      @snapshotter.call(root_endpoint(event.version), event.version)
+    end
+
+    #: (untyped) -> untyped
+    def root_endpoint(activity_version)
+      @root_endpoints.fetch(activity_version)
+    end
+
+    #: () -> Hash[untyped, untyped]
+    def build_root_endpoints
+      root_index = 0
+      endpoints = {} #: Hash[untyped, untyped]
+      endpoints.compare_by_identity
+      @events.each do |event|
+        while @root_versions[root_index] &&
+              Support.compare_versions(@root_versions[root_index], event.version).negative?
+          root_index += 1
+        end
+        endpoint = @root_versions[root_index] || @current || @root_versions.last
+        endpoints[event.version] = endpoint
+      end
+      endpoints
+    end
+  end
+end

data/lib/paper_trail_diff/activity_timeline_builder.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Compares adjacent root and selected-descendant activity boundaries.
+  class ActivityTimelineBuilder
+    #: (untyped, from: untyped, to: untyped, tree: AssociationTree, snapshotter: untyped) -> void
+    def initialize(record, from:, to:, tree:, snapshotter:)
+      @record = record
+      @from = from
+      @to = to
+      @tree = tree
+      @snapshotter = snapshotter
+    end
+
+    #: () -> Array[ActivityStep]
+    def build
+      return build_to_current if Endpoint.record?(@to)
+
+      Endpoint.validate!(@to)
+      build_between_versions
+    end
+
+    # Builds all three version-bounded views from one activity snapshot pass.
+    #: () -> Analysis
+    def analyze
+      unless Endpoint.version?(@to)
+        raise InvalidTimelineRangeError, '`to` must be a root PaperTrail version'
+      end
+
+      root_versions = VersionRange.new(@record, from: @from, to: @to).select
+      prepare_history(root_versions)
+      events = collect_events(root_versions)
+      activity_steps, root_snapshots, = event_history(root_versions, events)
+      build_analysis(root_versions, root_snapshots, activity_steps)
+    end
+
+    private
+
+    # @rbs @record: untyped
+    # @rbs @from: untyped
+    # @rbs @to: untyped
+    # @rbs @tree: AssociationTree
+    # @rbs @snapshotter: untyped
+
+    #: () -> Array[ActivityStep]
+    def build_between_versions
+      root_versions = VersionRange.new(@record, from: @from, to: @to).select
+      prepare_history(root_versions)
+      events = collect_events(root_versions)
+      build_event_steps(root_versions, events)
+    end
+
+    #: () -> Array[ActivityStep]
+    def build_to_current
+      validate_current_range!
+      current_snapshot, captured_at = capture_current
+      root_versions = VersionRange.new(@record, from: @from, to: @from).select_through_latest
+      prepare_history(root_versions)
+      events = collect_events(root_versions, range_end: captured_at)
+      build_event_steps(
+        root_versions,
+        events,
+        current: @to,
+        final_boundary: ActivityBoundary.current(@to, captured_at: captured_at),
+        final_snapshot: current_snapshot
+      )
+    end
+
+    #: () -> [RecordSnapshot?, untyped]
+    def capture_current
+      [@snapshotter.call(@to, @to), Time.now.utc]
+    end
+
+    #: () -> void
+    def validate_current_range!
+      unless Endpoint.version?(@from)
+        raise InvalidTimelineRangeError, '`from` must be a root PaperTrail version'
+      end
+
+      Endpoint.validate_pair!(@from, @to)
+      Endpoint.validate_pair!(@record, @to)
+    end
+
+    #: (Array[untyped], ?range_end: untyped) -> Array[ActivityEvent]
+    def collect_events(root_versions, range_end: root_versions.last)
+      ActivityVersionCollector.new(
+        @record,
+        root_versions: root_versions,
+        tree: @tree,
+        traversal: AssociationTraversal.new(@tree),
+        range_end: range_end
+      ).call
+    end
+
+    #: (Array[untyped]) -> void
+    def prepare_history(root_versions)
+      @snapshotter.prepare(@record, root_versions) if @snapshotter.respond_to?(:prepare)
+    end
+
+    #: (Array[untyped], Array[ActivityEvent], ?current: untyped, ?final_boundary: ActivityBoundary?, ?final_snapshot: RecordSnapshot?) -> Array[ActivityStep]
+    def build_event_steps(
+      root_versions,
+      events,
+      current: nil,
+      final_boundary: nil,
+      final_snapshot: nil
+    )
+      steps, _root_snapshots, previous_snapshot = event_history(
+        root_versions,
+        events,
+        current: current
+      )
+      previous_event = events.last
+      previous_boundary = ActivityBoundary.from_version(previous_event.version) if previous_event
+      if final_boundary && previous_boundary
+        steps << ActivityStep.new(
+          from_boundary: previous_boundary,
+          to_boundary: final_boundary,
+          diff: Engine.compare(previous_snapshot, final_snapshot)
+        )
+      end
+      steps.freeze
+    end
+
+    #: (Array[untyped], Array[ActivityEvent], ?current: untyped) -> [Array[ActivityStep], Hash[Array[untyped], RecordSnapshot?], RecordSnapshot?]
+    def event_history(root_versions, events, current: nil) # rubocop:disable Metrics/MethodLength
+      sequence = ActivitySnapshotSequence.new(root_versions, events, @snapshotter, current: current)
+      steps = [] #: Array[ActivityStep]
+      root_snapshots = {} #: Hash[Array[untyped], RecordSnapshot?]
+      previous_boundary = nil #: ActivityBoundary?
+      previous_snapshot = nil #: RecordSnapshot?
+      sequence.each do |event, snapshot|
+        boundary = ActivityBoundary.from_version(event.version)
+        root_snapshots[version_key(event.version)] = snapshot if event.root?
+        if previous_boundary
+          steps << ActivityStep.new(
+            from_boundary: previous_boundary,
+            to_boundary: boundary,
+            diff: Engine.compare(previous_snapshot, snapshot)
+          )
+        end
+        previous_boundary = boundary
+        previous_snapshot = snapshot
+      end
+      [steps, root_snapshots, previous_snapshot]
+    end
+
+    #: (Array[untyped], Hash[Array[untyped], RecordSnapshot?], Array[ActivityStep]) -> Analysis
+    def build_analysis(root_versions, root_snapshots, activity_steps)
+      snapshots = root_versions.map do |version|
+        root_snapshots.fetch(version_key(version))
+      end
+      Analysis.new(
+        diff: Engine.compare(snapshots.first, snapshots.last),
+        timeline: build_root_steps(root_versions, snapshots),
+        activity_timeline: activity_steps.freeze
+      )
+    end
+
+    #: (Array[untyped], Array[RecordSnapshot?]) -> Array[Step]
+    def build_root_steps(root_versions, snapshots)
+      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/activity_version_collector.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Collects root and selected-descendant versions relevant to one root history range.
+  class ActivityVersionCollector
+    #: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?range_end: untyped) -> void
+    def initialize(record, root_versions:, tree:, traversal:, range_end: root_versions.last)
+      @record = record
+      @root_versions = root_versions
+      @tree = tree
+      @traversal = traversal
+      @range = ActivityRange.new(root_versions.first, range_end)
+      @registry = ActivityEventRegistry.new
+    end
+
+    #: () -> Array[ActivityEvent]
+    def call
+      @registry.add(@root_versions)
+      collect_tree(@record.class, [@record.id], @tree, path: '', branch: nil) unless @tree.empty?
+      @registry.to_a.sort_by do |event|
+        Support.chronological_version_key(event.version)
+      end.freeze
+    end
+
+    private
+
+    # @rbs @record: untyped
+    # @rbs @root_versions: Array[untyped]
+    # @rbs @tree: AssociationTree
+    # @rbs @traversal: AssociationTraversal
+    # @rbs @range: ActivityRange
+    # @rbs @registry: ActivityEventRegistry
+
+    #: (untyped, Array[untyped], AssociationTree, path: String, branch: String?) -> void
+    def collect_tree(parent_class, parent_ids, tree, path:, branch:)
+      parent = group(parent_class, parent_ids)
+      @registry.add(parent.fetch(:versions), branch: branch) unless path.empty?
+      @traversal.reflections_for(parent_class, tree, path: path).each do |reflection|
+        subtree = tree.child(reflection.name)
+        next unless subtree
+
+        selected_branch = branch || reflection.name.to_s
+        collect_reflection(parent, reflection, subtree, path, selected_branch)
+      end
+    end
+
+    #: (Hash[Symbol, untyped], untyped, AssociationTree, String, String) -> void
+    def collect_reflection(parent, reflection, subtree, path, branch)
+      groups = edge_groups(parent, reflection, branch)
+      groups.each_value do |group|
+        @registry.add(group.fetch(:versions), branch: branch)
+        next if subtree.empty?
+
+        child_path = join_path(path, reflection.name.to_s)
+        collect_tree(group.fetch(:model), group.fetch(:ids), subtree,
+                     path: child_path, branch: branch)
+      end
+    end
+
+    #: (Hash[Symbol, untyped], untyped, String) -> Hash[String, untyped]
+    def edge_groups(parent, reflection, branch)
+      return through_groups(parent, reflection, branch) if reflection.options[:through]
+
+      case reflection.macro
+      when :belongs_to
+        belongs_to_groups(parent.fetch(:model), parent.fetch(:versions), reflection)
+      when :has_one, :has_many
+        direct_child_groups(parent.fetch(:model), parent.fetch(:ids), reflection)
+      when :has_and_belongs_to_many
+        habtm_groups(parent.fetch(:model), parent.fetch(:versions), reflection)
+      else
+        {}
+      end
+    end
+
+    #: (Hash[Symbol, untyped], untyped, String) -> Hash[String, untyped]
+    def through_groups(parent, reflection, branch)
+      through = reflection.through_reflection
+      intermediate = edge_groups(parent, through, branch)
+      result = {} #: Hash[String, untyped]
+      intermediate.each_value do |group|
+        @registry.add(group.fetch(:versions), branch: branch)
+        source = reflection.source_reflection
+        children = edge_groups(group, source, branch)
+        merge_groups!(result, children)
+      end
+      result
+    end
+
+    #: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
+    def belongs_to_groups(parent_class, parent_versions, reflection)
+      rows = parent_class.paper_trail.version_association_class.where(
+        version_id: parent_versions.map(&:id),
+        foreign_key_name: reflection.foreign_key.to_s
+      ).to_a
+      identity_groups(rows, reflection)
+    end
+
+    #: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
+    def direct_child_groups(parent_class, parent_ids, reflection) # rubocop:disable Metrics/AbcSize
+      version_class = parent_class.paper_trail.version_class
+      relation = parent_class.paper_trail.version_association_class.joins(:version).where(
+        foreign_key_name: reflection.foreign_key.to_s,
+        foreign_key_id: parent_ids
+      ).where(foreign_type: related_parent_types(parent_class))
+      item_ids = relation.where(
+        version_class.table_name => { item_type: reflection.klass.base_class.name }
+      ).distinct.pluck(version_class.arel_table[:item_id])
+      return {} if item_ids.empty?
+
+      { reflection.klass.name => group(reflection.klass, item_ids) }
+    end
+
+    #: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
+    def habtm_groups(parent_class, parent_versions, reflection)
+      transaction_ids = parent_versions.filter_map do |version|
+        version.transaction_id if version.respond_to?(:transaction_id)
+      end
+      rows = parent_class.paper_trail.version_association_class.where(
+        version_id: transaction_ids,
+        foreign_key_name: reflection.name.to_s
+      ).to_a
+      identity_groups(rows, reflection)
+    end
+
+    #: (Array[untyped], untyped) -> Hash[String, untyped]
+    def identity_groups(rows, reflection)
+      identities = rows.group_by { |row| target_class(reflection, row) }
+      groups = {} #: Hash[String, untyped]
+      identities.each do |model_class, class_rows|
+        next unless model_class
+
+        ids = class_rows.map(&:foreign_key_id).compact.uniq
+        groups[model_class.name] = group(model_class, ids)
+      end
+      groups
+    end
+
+    #: (untyped, Array[untyped]) -> Hash[Symbol, untyped]
+    def group(model_class, ids)
+      { model: model_class, ids: ids, versions: versions_for(model_class, ids) }
+    end
+
+    #: (Hash[String, untyped], Hash[String, untyped]) -> void
+    def merge_groups!(destination, source)
+      source.each do |name, incoming|
+        existing = destination[name]
+        unless existing
+          destination[name] = incoming
+          next
+        end
+
+        ids = (existing.fetch(:ids) | incoming.fetch(:ids))
+        destination[name] = group(existing.fetch(:model), ids)
+      end
+    end
+
+    #: (untyped, Array[untyped]) -> Array[untyped]
+    def versions_for(model_class, ids)
+      return [] if ids.empty?
+
+      version_class = model_class.paper_trail.version_class
+      @range.scope(
+        version_class.where(
+          item_type: model_class.base_class.name,
+          item_id: ids
+        )
+      ).to_a.select { |version| in_range?(version) }
+    end
+
+    #: (untyped, untyped) -> untyped
+    def target_class(reflection, row)
+      return reflection.klass unless reflection.polymorphic?
+
+      Object.const_get(row.foreign_type.to_s) unless row.foreign_type.to_s.empty?
+    rescue NameError
+      nil
+    end
+
+    #: (untyped) -> Array[String?]
+    def related_parent_types(parent_class)
+      [nil, '', parent_class.name.to_s, parent_class.base_class.name.to_s].uniq
+    end
+
+    #: (untyped) -> bool
+    def in_range?(version)
+      @range.include?(version)
+    end
+
+    #: (String, String) -> String
+    def join_path(parent, name)
+      parent.empty? ? name : "#{parent}.#{name}"
+    end
+  end
+end