paper_trail-related_changes 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9765e2d2318f809d303c5d36168083ce3abcd9abd0470862c39e1778ff546a5a
+  data.tar.gz: 70b70b6b660f2cc1eb54545ee994325b4e22c5379f03389a94aa80ba44dc0ea3
+SHA512:
+  metadata.gz: bcdf9b171bfe8a25009f6f4f0bcfb7646aae39370410fbf13bdd3bd4a8646f3d6203ae999d3990158fd79a719cb63562a183a62a138337981033b6b493b95b62
+  data.tar.gz: 2e9e3e5839c709b8ef7dca6ebc3df17b1238339abcd65906d96600410191a6ecc4a2a727b6c6eafa627f4534d6f235c8f1c82fc2c56c01467eb9aabbc813f06f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Dustin Zeisler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# PaperTrail::RelatedChanges
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'paper_trail-related_changes'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install paper_trail-related_changes
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PaperTrail::RelatedChanges'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/assets/config/paper_trail_changelog_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/paper_trail/related_changes .css

data/app/assets/stylesheets/paper_trail/changelog/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/paper_trail/related_changes/application_controller.rb

@@ -0,0 +1,9 @@
+module PaperTrail
+  module RelatedChanges
+    class ApplicationController < ActionController::Base
+      protect_from_forgery with: :exception
+
+
+    end
+  end
+end

data/app/controllers/paper_trail/related_changes/base_controller.rb

@@ -0,0 +1,25 @@
+module PaperTrail
+  module RelatedChanges
+    class BaseController < PaperTrail::RelatedChanges::ApplicationController
+      def show
+        render json: { data: versions.to_a, meta: {} }
+      end
+
+      private
+
+      def versions
+        RelatedChanges::GroupedByRequestId.new(
+          limit: limit,
+          **params.permit!.to_h.symbolize_keys.slice(
+            :type,
+            :id,
+          )
+        )
+      end
+
+      def limit
+        params[:limit] || params.dig('page', 'size')
+      end
+    end
+  end
+end

data/app/helpers/paper_trail/changelog/application_helper.rb

@@ -0,0 +1,6 @@
+module PaperTrail
+  module RelatedChanges
+    module ApplicationHelper
+    end
+  end
+end

data/app/jobs/paper_trail/changelog/application_job.rb

@@ -0,0 +1,6 @@
+module PaperTrail
+  module RelatedChanges
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/mailers/paper_trail/changelog/application_mailer.rb

@@ -0,0 +1,8 @@
+module PaperTrail
+  module RelatedChanges
+    class ApplicationMailer < ActionMailer::Base
+      default from: 'from@example.com'
+      layout 'mailer'
+    end
+  end
+end

data/app/models/paper_trail/related_changes/application_record.rb

@@ -0,0 +1,7 @@
+module PaperTrail
+  module RelatedChanges
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/views/layouts/paper_trail/related_changes/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Paper trail related_changes</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "paper_trail/related_changes/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,3 @@
+PaperTrail::RelatedChanges::Engine.routes.draw do
+  root 'base#show'
+end

data/lib/paper_trail/related_changes.rb

@@ -0,0 +1,35 @@
+require 'paper_trail/frameworks/active_record/models/paper_trail/version'
+require 'paper_trail/related_changes/relationally_independent'
+require 'paper_trail/related_changes/version_model'
+require "paper_trail/related_changes/engine"
+require "paper_trail/related_changes/serializer"
+require "paper_trail/related_changes/grouped_by_request_id"
+require "paper_trail/related_changes/hierarchy"
+require "paper_trail/related_changes/build_changes"
+require "paper_trail/related_changes/version"
+
+module PaperTrail
+  module RelatedChanges
+    def self.serializers
+      @serializers ||= [
+        Serializer::Skippable,
+        Serializer::BelongsTo,
+        Serializer::Polymorphic
+      ]
+    end
+
+    def self.insert_after_serializer(serializer, after_serializer)
+      serializer_index = serializers.index(serializer)
+      @serializers = serializers.insert(serializer_index + 1, after_serializer)
+    end
+
+    def self.insert_before_serializer(serializer, after_serializer)
+      serializer_index = serializers.index(serializer)
+      @serializers = serializers.insert(serializer_index, after_serializer)
+    end
+
+    def self.user_class
+      User if defined? User
+    end
+  end
+end

data/lib/paper_trail/related_changes/attribute.rb

@@ -0,0 +1,11 @@
+module PaperTrail::RelatedChanges
+  Attribute = Struct.new(:name, :diff, :version, :request_type, keyword_init: true) do
+    def to_s
+      name.to_s
+    end
+
+    def to_sym
+      name.to_sym
+    end
+  end
+end

data/lib/paper_trail/related_changes/build_changes.rb

@@ -0,0 +1,83 @@
+module PaperTrail
+  module RelatedChanges
+    class BuildChanges
+      attr_reader :results,
+                  :model_type_children,
+                  :item_type,
+                  :item_id
+
+      def initialize(results, model_type_children, item_type, item_id)
+        @results             = results
+        @model_type_children = model_type_children
+        @item_type           = item_type
+        @item_id             = item_id
+      end
+
+      def call
+        changes = results.map do |root_version, versions, request_id|
+          versions_serialized         = versions_serialized(versions)
+          root_change                 = change_with_root(request_id, root_version, versions_serialized)
+          root_change.change.children = children_versions(versions_serialized).map(&:change)
+          root_change.change
+        end.compact
+
+        remove_duplicate_changes(changes)
+      end
+
+      private
+
+      # Given a case where a change is represented by a previous change do not show it.
+      def remove_duplicate_changes(changes)
+        changes.reject.with_index do |change, index|
+          stop_iteration = false
+          changes[(index + 1)..-1].each do |previous_change|
+            change.diffs = change.diffs.reject do |current_change|
+              next false if stop_iteration
+              previous_matched_change = previous_change
+                                          .diffs
+                                          .detect { |previous_change| previous_change.attribute == current_change.attribute }
+              stop_iteration          = true if previous_matched_change # As soon as their is match stop
+              previous_matched_change.eql?(current_change)
+            end
+          end
+
+          change.empty?
+        end
+      end
+
+      def change_with_root(request_id, root_version, versions_serialized)
+        s                   = Serializer.new(root_version, item_type: root_version.item_type, root_type: item_type)
+        s.change.diffs      = [*s.change.diffs, *attribute_version_changes(versions_serialized)]
+        s.change.version_id = request_id || root_version.request_id
+        s
+      end
+
+      def children_versions(versions_serialized)
+        versions_serialized.reject { |vr| vr.change.merge_into_root }
+      end
+
+      def attribute_version_changes(versions_serialized)
+        versions_serialized.select { |vr| vr.change.merge_into_root }.map(&:change).flat_map(&:diffs)
+      end
+
+      def versions_serialized(versions)
+        versions.flat_map do |parent_type, versions_with_child_type|
+          versions_with_child_type.flat_map do |_type, versions_of_child|
+            versions_of_child.map do |version|
+              Serializer.new(
+                version,
+                item_type:             parent_type,
+                model_to_include_name: model_to_include_name,
+                root_type:             item_type
+              )
+            end
+          end
+        end
+      end
+
+      def model_to_include_name
+        model_type_children.each_with_object({}) { |(n, r), h| h[r.klass.name] = n }
+      end
+    end
+  end
+end

data/lib/paper_trail/related_changes/change.rb

@@ -0,0 +1,40 @@
+module PaperTrail::RelatedChanges
+  Change = Struct.new(:version_id,
+                      :user,
+                      :event,
+                      :resource,
+                      :description,
+                      :resource_id,
+                      :diffs,
+                      :timestamp,
+                      :requested_root,
+                      :children,
+                      :merge_into_root,
+                      keyword_init: true) do
+    def initialize(diffs: [], merge_into_root: false, **args)
+      super
+    end
+
+    def to_h(*)
+      self.diffs = diffs
+                     .group_by(&:source)
+                     .map { |k, g| [k, g.sort_by(&:source_rank)] } # ie. segments can be in display order
+                     .sort_by { |_, g| g[0].rank } # Direct attributes shown first
+                     .flat_map(&:last)
+                     .uniq
+      results    = super().except(:merge_into_root).map { |k, v| [k, v.is_a?(Array) ? v.map(&:to_h) : v] }.to_h
+      results.delete(:children) if results[:children].nil?
+      results
+    end
+
+    alias_method :as_json, :to_h
+
+    def empty?
+      diffs.count.zero? && children.count.zero?
+    end
+
+    def add_diff(args)
+      self.diffs << PaperTrail::RelatedChanges::Serializer::Diff.new(args)
+    end
+  end
+end

data/lib/paper_trail/related_changes/engine.rb

@@ -0,0 +1,15 @@
+module PaperTrail
+  module RelatedChanges
+    class Engine < ::Rails::Engine
+      isolate_namespace PaperTrail::RelatedChanges
+
+      ActiveSupport.on_load(:active_record) do
+        extend PaperTrail::RelatedChanges::RelationallyIndependent
+      end
+
+      config.after_initialize do
+        PaperTrail::Version.include(PaperTrail::VersionModel)
+      end
+    end
+  end
+end

data/lib/paper_trail/related_changes/grouped_by_request_id.rb

@@ -0,0 +1,154 @@
+module PaperTrail
+  module RelatedChanges
+    # Goal of class is to group versions rows into groups that represent a user event.
+    # When a user saves a resource that may have many associated resources and we want to see that as one event.
+    # Use ActiveRecord#reflections build a tree of downward relationships and query the versions.object and version.object_changes
+    # Group by the request_id to collect all actions into an event.
+    class GroupedByRequestId
+      attr_reader :item_id,
+                  :item_type,
+                  :limit
+
+      def initialize(item_type: nil,
+                     type: nil,
+                     item_id: nil,
+                     id: nil,
+                     limit: nil)
+        @item_type         = (item_type || type).underscore.classify
+        @item_id           = item_id || id
+        @limit             = Integer([limit, 1_000].reject(&:blank?).first)
+        @append_root       = true
+      end
+
+      def to_a
+        BuildChanges.new(
+          raw_records,
+          hierarchy.model_type_children,
+          model_name,
+          item_id
+        ).call.take(limit) # appending the last root version can cause limit+1 sized results.
+      end
+
+      def raw_records
+        results.map do |result|
+          root_version, versions = build_versions(result)
+          [root_version, group_versions(versions), result["request_id"]]
+        end.concat(append_root_version)
+      end
+
+      private
+
+      # When a limit is used you may not have a root record. A root record will collapse many versions into it's self.
+      # Without a root record you will see different types of records that won't be seen when no limit is set.
+      def append_root_version
+        return [] unless @append_root
+        [[last_root, []]]
+      end
+
+      def results
+        conn = ActiveRecord::Base.connection
+        conn.execute(<<~SQL)
+          SELECT json_agg(hierarchy_versions ORDER BY (rank, item_type, item_id, id)) AS versions,
+                 MIN(hierarchy_versions.created_at) as created_at,
+                 request_id
+             FROM (#{hierarchy.find_by_id(item_id)}) AS hierarchy_versions
+             GROUP BY request_id
+             ORDER BY created_at DESC
+             LIMIT #{conn.quote(limit)}
+        SQL
+      end
+
+      def last_root
+        @last_root ||= PaperTrail::Version.where(
+          item_type: item_type,
+          item_id:   item_id
+        ).order(
+          created_at: :desc
+        ).limit(1).first
+      end
+
+      def build_versions(result)
+        requested_root_version = nil
+        versions               = JSON.parse(result["versions"]).map do |version|
+          record                 = convert_to_record(version)
+          requested_root_version = record if record.item_id == item_id.to_s && record.item_type == model_name
+          record
+        end
+        @append_root           = false if requested_root_version == last_root
+        root_version           = requested_root_version || find_root(versions, result["request_id"])
+        versions.delete(root_version)
+        [root_version, versions]
+      end
+
+      def find_root(versions, request_id)
+        return versions.first if versions.count == 1 && versions.first.model_class.relationally_independent?
+        shared_relation = hierarchy.shared_relation(versions)
+        root_version    = versions.detect { |version| version.item_type == shared_relation.dig(:relation).class_name }
+
+        return build_sudo_root(shared_relation, request_id, versions) unless root_version
+        root_version
+      end
+
+      def merge_event(versions)
+        if versions.map(&:event).uniq.count == 1
+          versions.map(&:event).uniq.first
+        else
+          'update'
+        end
+      end
+
+      def convert_to_record(version)
+        PaperTrail::Version.new(
+          **version.except('created_at', 'rank').symbolize_keys,
+          created_at: ActiveSupport::TimeZone["UTC"].parse(version['created_at'])
+        )
+      end
+
+      def group_versions(versions)
+        versions.each_with_object({}) do |version, hash|
+          sources = hierarchy.search_hierarchy(version.item_type)
+
+          next unless (relation_to_root = sources.min_by { |s| s[:name].length }) # Prefer the shortest name ie. note vs notes
+          hash[relation_to_root[:parent][:type]]                          ||= {}
+          hash[relation_to_root[:parent][:type]][relation_to_root[:name]] ||= []
+          hash[relation_to_root[:parent][:type]][relation_to_root[:name]] << version
+        end
+      end
+
+      def build_sudo_root(shared_relation, request_id, versions)
+        # Assigning the parent_id will allow the description.name to be populated.
+        extracted_reference_keys = versions.map { |version| hierarchy.search_hierarchy(version.item_type)&.first&.fetch(:relation) }.map { |v| [v.foreign_key, v.type].compact }
+        parent_id                = versions.flat_map { |version| extracted_reference_keys.map { |keys| version.extract(*keys) } }.flatten.select { |t| t.class == Integer }.first
+
+        PaperTrail::Version.new(
+          item_type:  shared_relation.dig(:relation).class_name,
+          item_id:    parent_id,
+          request_id: request_id,
+          event:      merge_event(versions),
+          created_at: versions.first.created_at,
+          whodunnit:  versions.first.whodunnit
+        )
+      end
+
+      # This might happen if a developer did a mass edit in the console of unrelated items.
+      # If there are competing versions that match the request type only include the one with the matching id
+      def remove_stowaways(requested_root_version, versions)
+        versions.reject do |version|
+          version.item_type == requested_root_version.item_type && version.item_id != requested_root_version.item_id
+        end
+      end
+
+      def model_class
+        model_name.constantize
+      end
+
+      def model_name
+        item_type.underscore.classify
+      end
+
+      def hierarchy
+        @hierarchy ||= PaperTrail::RelatedChanges::Hierarchy.new(model_class)
+      end
+    end
+  end
+end

data/lib/paper_trail/related_changes/hierarchy.rb

@@ -0,0 +1,117 @@
+module PaperTrail
+  module RelatedChanges
+    class Hierarchy
+      require "paper_trail/related_changes/hierarchy/query"
+
+      class << self
+        # Builds downward relational hierarchy with 4 generations
+        def build(*args)
+          self.new(*args).send(:build_source)
+        end
+
+        # Does filtering of relations
+        def model_type_children(model)
+          self.new(model).model_type_children
+        end
+      end
+
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def find_by_id(id)
+        Query.call(model, id)
+      end
+
+      # Find the node that matches the item_type
+      # The result has a parent reference instead of a child reference.
+      def search_hierarchy(item_type, source: send(:source), parent: nil)
+        parent_without_children = (parent || source).except(:children)
+        return [source.except(:children).merge(parent: parent_without_children)] if source[:type] == item_type
+        return if source[:children].empty?
+        source[:children].flat_map { |child| search_hierarchy(item_type, source: child, parent: source) }.compact
+      end
+
+      # Finds a common root between versions
+      def shared_relation(versions)
+        result = versions.map do |version|
+          [
+            version.item_type, # It can be it's self
+            *search_hierarchy(version.item_type).map { |s| s.fetch(:parent, {}).fetch(:type, s[:type]) }
+          ].uniq
+        end.inject(:&)&.last
+
+        search_hierarchy(result)&.first
+      end
+
+      def model_type_children
+        @model_type_children ||= model.reflections.each_with_object({}) do |(name, rel), result|
+          next if source_reflection(rel).belongs_to? # Only Looking for downward relations. (Children not parents)
+          next if name == PaperTrail::Version.table_name
+          result[name.to_sym] = source_reflection(rel)
+        end
+      end
+
+      def source
+        @source ||= build_source
+      end
+
+      private
+
+      def build_source
+        top_relation = SelfRelation.new(foreign_key: :id, class_name: model.name, name: model.name)
+        root         = Node.new(type: model.name, name: model.name, relation: top_relation, children: [])
+        model_type_children.each do |n1, r1|
+          next if r1.klass == model
+
+          r1_branch = Node.new(type: r1.klass.name, name: n1, relation: r1, children: [])
+          root.children << r1_branch
+
+          self.class.model_type_children(r1.klass).each do |n2, r2|
+            next if r2.klass == model
+
+            r2_branch = Node.new(type: r2.klass.name, name: n2, relation: r2, children: [])
+            r1_branch.children << r2_branch
+
+            self.class.model_type_children(r2.klass).each do |n3, r3|
+              next if r3.klass == model
+
+              r3_branch = Node.new(type: r3.klass.name, name: n3, relation: r3, children: [])
+              r2_branch.children << r3_branch
+            end
+          end
+        end
+        root
+      end
+
+      def source_reflection(v)
+        v.through_reflection? ? source_reflection(v.through_reflection) : v
+      end
+
+      def include_parent?(name)
+        include_parent_as_child.include?(name.to_sym)
+      end
+
+      def whitelisted_child?(name)
+        return true unless only_include_children
+
+        only_include_children.include?(name.to_sym)
+      end
+
+      SelfRelation = Struct.new(:foreign_key, :class_name, :name, keyword_init: true)
+      Node         = Struct.new(:type, :name, :relation, :children, keyword_init: true) do
+        def to_simple
+          base = to_h.except(:relation, :children)
+          return { **base, children: children.map(&:to_simple) } unless children.empty?
+          base
+        end
+
+        def except(*args)
+          to_h.except(*args)
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/related_changes/hierarchy/query.rb

@@ -0,0 +1,78 @@
+module PaperTrail::RelatedChanges::Hierarchy::Query
+  class << self
+    # Builds a UNION joined set of queries that finds related versions to the 4th generation.
+    def call(model, id)
+      parent_query_r0 = parent(model.name, id)
+      hierarchy       = PaperTrail::RelatedChanges::Hierarchy.model_type_children(model).each_with_object([]) do |(_n, r1), col|
+        parent_query_r1 = call_query(parent_query_r0, r1)
+        col << parent_query_r1
+        PaperTrail::RelatedChanges::Hierarchy.model_type_children(r1.klass).each do |_n, r2|
+          parent_query_r2 = call_query(parent_query_r1, r2)
+          col << parent_query_r2
+          PaperTrail::RelatedChanges::Hierarchy.model_type_children(r2.klass).each do |_n, r3|
+            parent_query_r3 = call_query(parent_query_r2, r3)
+            col << parent_query_r3
+          end
+        end
+      end
+      final           = [
+        parent_query_r0,
+        *hierarchy.uniq
+      ].join("\nUNION\n")
+
+      <<~SQL
+        SELECT #{columns('hierarchy')},
+          CASE event
+          WHEN 'create' THEN 1
+          WHEN 'update' THEN 2
+          WHEN 'destroy' THEN 3
+          ELSE 4 END as rank
+        FROM (#{final}) hierarchy
+      SQL
+    end
+
+    private
+
+    def call_query(parent_query, r)
+      if r.type
+        nth_polymorphic_children(parent_query, r.type, r.foreign_key)
+      else
+        nth_children(parent_query, r.foreign_key)
+      end
+    end
+
+    def parent(item_type, item_id)
+      <<~SQL
+        SELECT '#{item_type}=>#{item_id}' as tree, #{columns('versions')}
+        FROM versions
+        WHERE versions.item_type = '#{item_type}'
+          AND versions.item_id = '#{item_id}'
+      SQL
+    end
+
+    def nth_children(parent_query, parent_foreign_key)
+      <<~SQL
+        SELECT parents.tree || '.' || children.item_type || '=>' || children.item_id as tree, #{columns('children')}
+        FROM (#{parent_query}) parents
+        JOIN versions children ON parents.item_id = #{query_changes(parent_foreign_key)}
+      SQL
+    end
+
+    def nth_polymorphic_children(parent_query, parent_type_foreign_key, parent_id_foreign_key)
+      <<~SQL
+        SELECT parents.tree || '.' ||  children.item_type || '=>' || children.item_id as tree, #{columns('children')}
+        FROM (#{parent_query}) parents
+          JOIN versions children ON  parents.item_id = #{query_changes(parent_id_foreign_key)}
+        AND parents.item_type = #{query_changes(parent_type_foreign_key)}
+      SQL
+    end
+
+    def query_changes(key)
+      "COALESCE((children.object_changes -> '#{key}' ->> 1)::TEXT, (children.object ->> '#{key}')::TEXT)"
+    end
+
+    def columns(prefix)
+      %w(id item_type item_id event whodunnit object object_changes request_id created_at).map { |c| "#{prefix}.#{c}" }.join(", ")
+    end
+  end
+end

data/lib/paper_trail/related_changes/relationally_independent.rb

@@ -0,0 +1,14 @@
+module PaperTrail::RelatedChanges::RelationallyIndependent
+  def relationally_independent=(value)
+    @relationally_independent = value
+  end
+
+  def relationally_independent?
+    if instance_variable_defined? :@relationally_independent
+      @relationally_independent
+    else
+      true
+    end
+  end
+end
+

data/lib/paper_trail/related_changes/serializer.rb

@@ -0,0 +1,117 @@
+require "paper_trail/related_changes/serializer/polymorphic"
+require "paper_trail/related_changes/serializer/belongs_to"
+require "paper_trail/related_changes/serializer/skippable"
+require "paper_trail/related_changes/attribute"
+require "paper_trail/related_changes/serializer/diff"
+require "paper_trail/related_changes/change"
+
+module PaperTrail
+  module RelatedChanges
+    class Serializer
+      def initialize(record, item_type:, model_to_include_name: {}, root_type: nil)
+        @record                = record
+        @item_type             = item_type
+        @model_to_include_name = model_to_include_name
+        @root_type             = root_type
+      end
+
+      delegate :to_h, to: :change
+
+      def change
+        @change ||= change_template
+        build_changes
+        @change
+      end
+
+      private
+
+      def change_template
+        Change.new(
+          version_id:     record.id,
+          user:           user,
+          event:          record.event,
+          resource:       record.item_type,
+          description:    {
+            name:  resource_title,
+            value: record.name
+          },
+          resource_id:    record.item_id,
+          timestamp:      record.created_at,
+          requested_root: !included?
+        )
+      end
+
+      attr_reader :record,
+                  :item_type,
+                  :model_to_include_name,
+                  :root_type
+
+      def included?
+        return record.item_type != root_type unless root_type.nil?
+        record.item_type != item_type.classify
+      end
+
+      def resource_title
+        model_to_include_name.fetch(
+          record.item_type,
+          record.item_type.underscore.split('/').last
+        ).to_s.singularize.titleize
+      end
+
+      def user
+        PaperTrail::RelatedChanges.user_class.find_by(id: record.whodunnit)&.name || "system"
+      end
+
+      def build_changes
+        @build_changes ||= record.changeset.each do |attr, diff|
+          BuildDiffs.new(attr, diff, record, item_type, @change).call
+        end
+      end
+
+      class BuildDiffs
+        def initialize(attr, diff, record, request_type, change)
+          @attr         = attr.to_sym
+          @diff         = diff
+          @record       = record
+          @request_type = request_type
+          @change       = change
+        end
+
+        def call
+          return call_serializer if custom_serializer
+
+          change.diffs << default_diff
+        end
+
+        private
+
+        attr_reader :diff,
+                    :attr,
+                    :record,
+                    :request_type,
+                    :change
+
+        def default_diff
+          Diff.new(attribute: attr, old: diff[0], new: diff[1], rank: 0, meta: record, source: :default)
+        end
+
+        def attribute
+          @attribute ||= Attribute.new(
+            name:         attr,
+            diff:         diff,
+            version:      record,
+            request_type: request_type
+          )
+        end
+
+        def custom_serializer
+          RelatedChanges.serializers.detect { |serializer| serializer.match(attribute) }
+        end
+
+        def call_serializer
+          custom_serializer.serialize(attribute, change)
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/related_changes/serializer/belongs_to.rb

@@ -0,0 +1,73 @@
+class PaperTrail::RelatedChanges::Serializer
+  class BelongsTo
+
+    def self.match(attribute)
+      attribute.version
+        .model_class
+        .reflections
+        .values
+        .select(&:belongs_to?)
+        .reject(&:polymorphic?)
+        .any? { |r| r.join_foreign_key.to_sym == attribute.to_sym }
+    end
+
+    def self.serialize(attribute, change)
+      new(attribute, change).serialize
+    end
+
+    attr_reader :attribute,
+                :item_type,
+                :change
+
+    def initialize(attribute, change)
+      @attribute = attribute
+      @item_type = attribute.version.item_type
+      @change    = change
+    end
+
+    def serialize
+      return if association.name.to_s.underscore.singularize == attribute.request_type.to_s.underscore.singularize
+      change.merge_into_root = true unless model_class.relationally_independent?
+      change.add_diff(
+        attribute: attribute_name,
+        old:       find_record(attribute.diff[0]),
+        new:       find_record(attribute.diff[1]),
+        rank:      3,
+        source:    self.class.name
+      )
+    end
+
+    def attribute_name
+      association.name
+    end
+
+    def association
+      @association ||= item_type
+                         .constantize
+                         .reflections
+                         .detect { |_, a| a.foreign_key.to_sym == attribute.to_sym }&.fetch(1)
+    end
+
+    def find_record(id)
+      return unless id
+      find_associated_version(id).try(:name) || find_current_record(id).try(:name) || "Record no longer exists"
+    end
+
+    def model_class
+      @model_class ||= association.klass
+    end
+
+    def find_current_record(id)
+      model_class.find_by(id: id)
+    end
+
+    def find_associated_version(id)
+      PaperTrail::Version.where(
+        PaperTrail::Version.arel_table[:created_at].lt(attribute.version.created_at)
+      ).where(
+        item_id:   id,
+        item_type: model_class.name
+      ).order(created_at: :desc).first
+    end
+  end
+end

data/lib/paper_trail/related_changes/serializer/diff.rb

@@ -0,0 +1,23 @@
+class PaperTrail::RelatedChanges::Serializer
+  Diff = Struct.new(:attribute, :old, :new, :rank, :source_rank, :source, :meta, keyword_init: true) do
+    def initialize(rank: 1, source_rank: 1, **args)
+      super
+    end
+
+    def to_h
+      if ENV['RELATED_CHANGES_DEBUG']
+        super
+      else
+        super.except(:rank, :source, :source_rank, :meta)
+      end
+    end
+
+    def eql?(other)
+      attribute == other.attribute && new == other.new && old == other.old
+    end
+
+    def hash
+      [attribute, new, old].hash
+    end
+  end
+end

data/lib/paper_trail/related_changes/serializer/polymorphic.rb

@@ -0,0 +1,19 @@
+class PaperTrail::RelatedChanges::Serializer
+  module Polymorphic
+    def self.match(attribute)
+      attribute.version.item_type.constantize.reflections.detect { |_, r| r.polymorphic? && r.belongs_to? }
+    end
+
+    def self.serialize(attribute, change)
+      return if [/_id/, /_type/].any? { |r| attribute.to_s =~ r } # Catch all non-associative attributes
+      change.merge_into_root = true unless attribute.version.model_class.relationally_independent?
+      change.add_diff(
+        attribute: attribute.version.item_type.titleize,
+        old:       attribute.diff[0],
+        new:       attribute.diff[1],
+        rank:      2,
+        source:    self.name
+      )
+    end
+  end
+end

data/lib/paper_trail/related_changes/serializer/skippable.rb

@@ -0,0 +1,17 @@
+class PaperTrail::RelatedChanges::Serializer
+  class Skippable
+    def self.match(attribute)
+      !!SKIP_COLUMNS.detect do |sk|
+        sk == attribute.to_sym
+      end
+    end
+
+    SKIP_COLUMNS = [
+      :id,
+      :created_at,
+      :updated_at,
+    ].freeze
+
+    def self.serialize(*); end
+  end
+end

data/lib/paper_trail/related_changes/version.rb

@@ -0,0 +1,5 @@
+module PaperTrail
+  module RelatedChanges
+    VERSION = '1.0.0'
+  end
+end

data/lib/paper_trail/related_changes/version_model.rb

@@ -0,0 +1,35 @@
+module PaperTrail::VersionModel
+  DISPLAY_NAME_METHODS = [
+    :title,
+    :name,
+    :code
+  ].freeze
+
+  def name
+    call_by_name(self.next&.reify || live_record)
+  rescue StandardError
+    call_by_name(live_record)
+  end
+
+  def model_class
+    item_type.constantize
+  end
+
+  def extract(*keys)
+    result = keys.map do |key|
+      (object_changes || {})[key.to_s]&.last || (object || {})[key.to_s]
+    end
+    return result if keys.count > 1
+    result.first
+  end
+
+  private
+
+  def live_record
+    model_class.find_by(id: item_id)
+  end
+
+  def call_by_name(record)
+    DISPLAY_NAME_METHODS.map { |meth| record.try(meth) }.compact.first
+  end
+end

data/lib/tasks/paper_trail/changelog_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :paper_trail_related_changes do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: paper_trail-related_changes
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Dustin Zeisler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.1
+- !ruby/object:Gem::Dependency
+  name: paper_trail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Find all child ActiveRecord relationships from a given resource and groups
+  thems by request_id.
+email:
+- dustin@zeisler.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/paper_trail_changelog_manifest.js
+- app/assets/stylesheets/paper_trail/changelog/application.css
+- app/controllers/paper_trail/related_changes/application_controller.rb
+- app/controllers/paper_trail/related_changes/base_controller.rb
+- app/helpers/paper_trail/changelog/application_helper.rb
+- app/jobs/paper_trail/changelog/application_job.rb
+- app/mailers/paper_trail/changelog/application_mailer.rb
+- app/models/paper_trail/related_changes/application_record.rb
+- app/views/layouts/paper_trail/related_changes/application.html.erb
+- config/routes.rb
+- lib/paper_trail/related_changes.rb
+- lib/paper_trail/related_changes/attribute.rb
+- lib/paper_trail/related_changes/build_changes.rb
+- lib/paper_trail/related_changes/change.rb
+- lib/paper_trail/related_changes/engine.rb
+- lib/paper_trail/related_changes/grouped_by_request_id.rb
+- lib/paper_trail/related_changes/hierarchy.rb
+- lib/paper_trail/related_changes/hierarchy/query.rb
+- lib/paper_trail/related_changes/relationally_independent.rb
+- lib/paper_trail/related_changes/serializer.rb
+- lib/paper_trail/related_changes/serializer/belongs_to.rb
+- lib/paper_trail/related_changes/serializer/diff.rb
+- lib/paper_trail/related_changes/serializer/polymorphic.rb
+- lib/paper_trail/related_changes/serializer/skippable.rb
+- lib/paper_trail/related_changes/version.rb
+- lib/paper_trail/related_changes/version_model.rb
+- lib/tasks/paper_trail/changelog_tasks.rake
+homepage: https://github.com/zeisler/paper_trail-related_changes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Groups and formats related changes that are recorded with PaperTrail
+test_files: []