paper_trail_diff 0.3.0 → 0.3.1

data/lib/paper_trail_diff/activity_event_record_resolver.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Reconstructs an event's post-change record or immutable scalar delta.
+  class ActivityEventRecordResolver
+    RECORD_AFTER_HANDLERS = {
+      'create' => :created_record_after,
+      'update' => :updated_record_after
+    }.freeze
+    private_constant :RECORD_AFTER_HANDLERS
+
+    #: (?record_transition: untyped) -> void
+    def initialize(record_transition: nil)
+      @record_transition = record_transition
+    end
+
+    #: (untyped) -> untyped
+    def record_after(version)
+      return if version.event.to_s == 'destroy'
+
+      changed_record = changed_record_after(version)
+      return changed_record if changed_record
+
+      successor = version.next
+      record = successor&.reify(dup: true)
+      return record if record
+
+      model_class = Endpoint.model_class(version)
+      criteria = { model_class.primary_key => version.item_id } #: Hash[untyped, untyped]
+      model_class.unscoped.find_by(criteria)
+    end
+
+    #: (untyped) -> ActivitySnapshotDelta?
+    def snapshot_delta(version)
+      return unless version.event.to_s == 'update' && version.object
+
+      transition = @record_transition&.call(version)
+      return unless transition
+
+      ActivitySnapshotDelta.new(
+        before_attributes: transition.fetch(0),
+        after_attributes: transition.fetch(1)
+      )
+    end
+
+    #: (untyped) -> untyped
+    def changed_record_after(version)
+      handler = RECORD_AFTER_HANDLERS[version.event.to_s]
+      send(handler, version) if handler
+    end
+
+    #: (untyped) -> untyped
+    def created_record_after(version)
+      model_class = Endpoint.model_class(version)
+      changes = deserialized_changeset(version, model_class)
+      return unless changes.respond_to?(:each) && !changes.empty?
+
+      model_class.new(after_attributes(changes, model_class))
+    end
+
+    #: (untyped) -> untyped
+    def updated_record_after(version)
+      record = version.reify(dup: true)
+      changes = deserialized_changeset(version, record&.class)
+      apply_changes(record, changes)
+    end
+
+    # Mirrors PaperTrail's changeset deserialization without resolving
+    # +version.item+, which would issue one live-record query per event.
+    #: (untyped, untyped) -> untyped
+    def deserialized_changeset(version, model_class)
+      return unless model_class && version.class.column_names.include?('object_changes')
+
+      paper_trail = Object.const_get(:PaperTrail) #: untyped
+      adapter = paper_trail.config.object_changes_adapter
+      return adapter.load_changeset(version) if adapter.respond_to?(:load_changeset)
+
+      standard_changeset(paper_trail, version, model_class)
+    end
+
+    private
+
+    # @rbs @record_transition: untyped
+
+    #: (untyped, untyped) -> Hash[untyped, untyped]
+    def after_attributes(changes, model_class)
+      names = model_class.attribute_names
+      attributes = {} #: Hash[untyped, untyped]
+      changes.each do |name, values|
+        next unless names.include?(name.to_s)
+
+        attributes[name] = values.last
+      end
+      attributes
+    end
+
+    #: (untyped, untyped) -> untyped
+    def apply_changes(record, changes)
+      return unless record && changes.respond_to?(:each) && !changes.empty?
+
+      changes.each do |name, values|
+        next unless record.has_attribute?(name) && values.respond_to?(:last)
+
+        record[name] = values.last
+      end
+      record
+    end
+
+    #: (untyped, untyped, untyped) -> untyped
+    def standard_changeset(paper_trail, version, model_class)
+      raw_changes = version.send(:object_changes_deserialized)
+      active_support = Object.const_get(:ActiveSupport) #: untyped
+      changes = active_support.const_get(:HashWithIndifferentAccess).new(raw_changes)
+      serializers = paper_trail.const_get(:AttributeSerializers)
+      serializers.const_get(:ObjectChangesAttribute).new(model_class).deserialize(changes)
+      changes
+    end
+  end
+end

data/lib/paper_trail_diff/activity_event_route_finder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Finds explicitly selected collection and belongs-to routes for one event type.
+  class ActivityEventRouteFinder
+    #: (AssociationTraversal) -> void
+    def initialize(traversal)
+      @traversal = traversal
+      @collection_model = nil
+      @collection_tree = nil #: AssociationTree?
+      @collection_type = nil #: String?
+      @collection_path = nil #: String?
+      @collection_routes = nil #: Array[Array[untyped]]?
+      @belongs_to_model = nil
+      @belongs_to_tree = nil #: AssociationTree?
+      @belongs_to_type = nil #: String?
+      @belongs_to_path = nil #: String?
+      @belongs_to_routes = nil #: Array[Array[untyped]]?
+    end
+
+    #: (untyped, AssociationTree, String, ?path: String) -> Array[Array[untyped]]
+    def collection_routes(model_class, tree, target_type, path: '')
+      cached = @collection_routes
+      if cached && @collection_model.equal?(model_class) && @collection_tree.equal?(tree) &&
+         @collection_type == target_type && @collection_path == path
+        return cached
+      end
+
+      computed = freeze_routes(routes(model_class, tree, target_type, :has_many, path: path))
+      @collection_model = model_class
+      @collection_tree = tree
+      @collection_type = Support.immutable_copy(target_type)
+      @collection_path = Support.immutable_copy(path)
+      @collection_routes = computed
+    end
+
+    #: (untyped, AssociationTree, String, ?path: String) -> Array[Array[untyped]]
+    def belongs_to_routes(model_class, tree, target_type, path: '')
+      cached = @belongs_to_routes
+      if cached && @belongs_to_model.equal?(model_class) && @belongs_to_tree.equal?(tree) &&
+         @belongs_to_type == target_type && @belongs_to_path == path
+        return cached
+      end
+
+      computed = freeze_routes(routes(model_class, tree, target_type, :belongs_to, path: path))
+      @belongs_to_model = model_class
+      @belongs_to_tree = tree
+      @belongs_to_type = Support.immutable_copy(target_type)
+      @belongs_to_path = Support.immutable_copy(path)
+      @belongs_to_routes = computed
+    end
+
+    private
+
+    # @rbs @traversal: AssociationTraversal
+    # @rbs @collection_model: untyped
+    # @rbs @collection_tree: AssociationTree?
+    # @rbs @collection_type: String?
+    # @rbs @collection_path: String?
+    # @rbs @collection_routes: Array[Array[untyped]]?
+    # @rbs @belongs_to_model: untyped
+    # @rbs @belongs_to_tree: AssociationTree?
+    # @rbs @belongs_to_type: String?
+    # @rbs @belongs_to_path: String?
+    # @rbs @belongs_to_routes: Array[Array[untyped]]?
+
+    #: (Array[Array[untyped]]) -> Array[Array[untyped]]
+    def freeze_routes(routes)
+      routes.each do |route|
+        route.each(&:freeze)
+        route.freeze
+      end.freeze
+    end
+
+    #: (untyped, AssociationTree, String, Symbol, path: String) -> Array[Array[untyped]]
+    def routes(model_class, tree, target_type, macro, path: '')
+      @traversal.reflections_for(model_class, tree, path: path).flat_map do |reflection|
+        routes_for_reflection(reflection, tree, target_type, macro, path)
+      end
+    end
+
+    #: (untyped, AssociationTree, String, Symbol, String) -> Array[Array[untyped]]
+    def routes_for_reflection(reflection, tree, target_type, macro, path)
+      name = reflection.name.to_s
+      subtree = tree.child(name)
+      return [] unless subtree
+
+      child_path = Support.association_path(path, name)
+      entry = [name, reflection, subtree, child_path]
+      direct = [] #: Array[Array[untyped]]
+      direct << [entry] if direct_route?(reflection, target_type, macro)
+      return direct if subtree.empty? || reflection.polymorphic?
+
+      nested = routes(reflection.klass, subtree, target_type, macro, path: child_path)
+      direct.concat(nested.map { |route| [entry, *route] })
+    end
+
+    #: (untyped, String, Symbol) -> bool
+    def direct_route?(reflection, target_type, macro)
+      reflection.macro == macro && supported_direct_reflection?(reflection, macro) &&
+        reflection.klass.base_class.name.to_s == target_type
+    end
+
+    #: (untyped, Symbol) -> bool
+    def supported_direct_reflection?(reflection, macro)
+      return !reflection.options[:through] if macro == :has_many
+
+      !reflection.polymorphic?
+    end
+  end
+end