paper_trail-association_tracking 0.0.1

data/lib/paper_trail-association_tracking.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'paper_trail'
+require "paper_trail_association_tracking/config"
+require "paper_trail_association_tracking/model_config"
+require "paper_trail_association_tracking/reifier"
+require "paper_trail_association_tracking/record_trail"
+require "paper_trail_association_tracking/request"
+require "paper_trail_association_tracking/paper_trail"
+require "paper_trail_association_tracking/version_concern"
+
+module PaperTrailAssociationTracking
+  def self.version
+    VERSION::STRING
+  end
+
+  def self.gem_version
+    ::Gem::Version.new(VERSION::STRING)
+  end
+end
+
+module PaperTrail
+  class << self
+    prepend ::PaperTrailAssociationTracking::PaperTrail::ClassMethods
+  end
+
+  class Config
+    prepend ::PaperTrailAssociationTracking::Config
+  end
+
+  class ModelConfig
+    prepend ::PaperTrailAssociationTracking::ModelConfig
+  end
+
+  class RecordTrail
+    prepend ::PaperTrailAssociationTracking::RecordTrail
+  end
+
+  module Reifier
+    class << self
+      prepend ::PaperTrailAssociationTracking::Reifier::ClassMethods
+    end
+  end
+
+  module Request
+    class << self
+      prepend ::PaperTrailAssociationTracking::Request::ClassMethods
+    end
+  end
+
+  module VersionConcern
+    include ::PaperTrailAssociationTracking::VersionConcern
+  end
+end
+
+
+# Require frameworks
+if defined?(::Rails)
+  # Rails module is sometimes defined by gems like rails-html-sanitizer
+  # so we check for presence of Rails.application.
+  if defined?(::Rails.application)
+    require "paper_trail_association_tracking/frameworks/rails"
+  else
+    ::Kernel.warn('PaperTrail has been loaded too early, before rails is loaded. This can happen when another gem defines the ::Rails namespace, then PT is loaded, all before rails is loaded. You may want to reorder your Gemfile, or defer the loading of PT by using `require: false` and a manual require elsewhere.')
+  end
+else
+  require "paper_trail_association_tracking/frameworks/active_record"
+end

data/lib/paper_trail_association_tracking/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module PaperTrailAssociationTracking
+  module Config
+    def association_reify_error_behaviour=(val)
+      val = val.to_s
+      if ['error', 'warn', 'ignore'].include?(val.to_s)
+        @association_reify_error_behaviour = val.to_s
+      else
+        raise ArgumentError.new('Incorrect value passed to `association_reify_error_behaviour`')
+      end
+    end
+
+    def association_reify_error_behaviour
+      @association_reify_error_behaviour ||= "error"
+    end
+    
+    def track_associations=(val)
+      @track_associations = !!val
+    end 
+
+    def track_associations?
+      !!@track_associations
+    end
+  end
+end

data/lib/paper_trail_association_tracking/frameworks/active_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# This file only needs to be loaded if the gem is being used outside of Rails,
+# since otherwise the model(s) will get loaded in via the `Rails::Engine`.
+require "paper_trail_association_tracking/frameworks/active_record/models/paper_trail/version_association"

data/lib/paper_trail_association_tracking/frameworks/active_record/models/paper_trail/version_association.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "paper_trail_association_tracking/version_association_concern"
+
+module ::PaperTrail
+  # This is the default ActiveRecord model provided by PaperTrail. Most simple
+  # applications will only use this and its partner, `Version`, but it is
+  # possible to sub-class, extend, or even do without this model entirely.
+  # See the readme for details.
+  class VersionAssociation < ::ActiveRecord::Base
+    include PaperTrailAssociationTracking::VersionAssociationConcern
+  end
+end

data/lib/paper_trail_association_tracking/frameworks/rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "paper_trail_association_tracking/frameworks/rails/engine"

data/lib/paper_trail_association_tracking/frameworks/rails/engine.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module PaperTrailAssociationTracking
+  module Rails
+    # See http://guides.rubyonrails.org/engines.html
+    class Engine < ::Rails::Engine
+      paths["app/models"] << "lib/paper_trail_association_tracking/frameworks/active_record/models"
+    end
+  end
+end

data/lib/paper_trail_association_tracking/frameworks/rspec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/matchers"
+
+RSpec::Matchers.define :have_a_version_with do |attributes|
+  # check if the model has a version with the specified attributes
+  match do |actual|
+    versions_association = actual.class.versions_association_name
+    actual.send(versions_association).where_object(attributes).any?
+  end
+end
+
+RSpec::Matchers.define :have_a_version_with_changes do |attributes|
+  # check if the model has a version changes with the specified attributes
+  match do |actual|
+    versions_association = actual.class.versions_association_name
+    actual.send(versions_association).where_object_changes(attributes).any?
+  end
+end

data/lib/paper_trail_association_tracking/model_config.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module PaperTrailAssociationTracking
+  # Configures an ActiveRecord model, mostly at application boot time, but also
+  # sometimes mid-request, with methods like enable/disable.
+  module ModelConfig
+    # Set up `@model_class` for PaperTrail. Installs callbacks, associations,
+    # "class attributes", instance methods, and more.
+    # @api private
+    def setup(options = {})
+      super
+
+      setup_transaction_callbacks
+      setup_callbacks_for_habtm(options[:join_tables])
+    end
+
+    private
+
+    # Raises an error if the provided class is an `abstract_class`.
+    # @api private
+    def assert_concrete_activerecord_class(class_name)
+      if class_name.constantize.abstract_class?
+        raise format(::PaperTrail::ModelConfig::E_HPT_ABSTRACT_CLASS, @model_class, class_name)
+      end
+    end
+
+    def habtm_assocs_not_skipped
+      @model_class.reflect_on_all_associations(:has_and_belongs_to_many).
+        reject { |a| @model_class.paper_trail_options[:skip].include?(a.name.to_s) }
+    end
+
+    # Adds callbacks to record changes to habtm associations such that on save
+    # the previous version of the association (if changed) can be reconstructed.
+    def setup_callbacks_for_habtm(join_tables)
+      @model_class.send :attr_accessor, :paper_trail_habtm
+      @model_class.class_attribute :paper_trail_save_join_tables
+      @model_class.paper_trail_save_join_tables = Array.wrap(join_tables)
+      habtm_assocs_not_skipped.each(&method(:setup_habtm_change_callbacks))
+    end
+
+    def setup_habtm_change_callbacks(assoc)
+      assoc_name = assoc.name
+      %w[add remove].each do |verb|
+        @model_class.send(:"before_#{verb}_for_#{assoc_name}").send(
+          :<<,
+          lambda do |*args|
+            update_habtm_state(assoc_name, :"before_#{verb}", args[-2], args.last)
+          end
+        )
+      end
+    end
+
+    # Reset the transaction id when the transaction is closed.
+    def setup_transaction_callbacks
+      @model_class.after_commit { ::PaperTrail.request.clear_transaction_id }
+      @model_class.after_rollback { ::PaperTrail.request.clear_transaction_id }
+    end
+
+    def update_habtm_state(name, callback, model, assoc)
+      model.paper_trail_habtm ||= {}
+      model.paper_trail_habtm[name] ||= { removed: [], added: [] }
+      state = model.paper_trail_habtm[name]
+      assoc_id = assoc.id
+      case callback
+      when :before_add
+        state[:added] |= [assoc_id]
+        state[:removed] -= [assoc_id]
+      when :before_remove
+        state[:removed] |= [assoc_id]
+        state[:added] -= [assoc_id]
+      else
+        raise "Invalid callback: #{callback}"
+      end
+    end
+  end
+end

data/lib/paper_trail_association_tracking/paper_trail.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PaperTrailAssociationTracking
+  module PaperTrail
+    module ClassMethods
+      def transaction?
+        ::ActiveRecord::Base.connection.open_transactions.positive?
+      end
+
+      # @deprecated
+      def clear_transaction_id
+        ::ActiveSupport::Deprecation.warn(
+          "PaperTrail.clear_transaction_id is deprecated, use PaperTrail.request.clear_transaction_id",
+          caller(1)
+        )
+        request.clear_transaction_id
+      end
+
+      # @deprecated
+      def transaction_id
+        ::ActiveSupport::Deprecation.warn(
+          "PaperTrail.transaction_id is deprecated without replacement.",
+          caller(1)
+        )
+        request.transaction_id
+      end
+
+      # @deprecated
+      def transaction_id=(id)
+        ::ActiveSupport::Deprecation.warn(
+          "PaperTrail.transaction_id= is deprecated without replacement.",
+          caller(1)
+        )
+        request.transaction_id = id
+      end
+    end
+  end
+end

data/lib/paper_trail_association_tracking/record_trail.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module PaperTrailAssociationTracking
+  module RecordTrail
+    # Utility method for reifying. Anything executed inside the block will
+    # appear like a new record.
+    #
+    # > .. as best as I can tell, the purpose of
+    # > appear_as_new_record was to attempt to prevent the callbacks in
+    # > AutosaveAssociation (which is the module responsible for persisting
+    # > foreign key changes earlier than most people want most of the time
+    # > because backwards compatibility or the maintainer hates himself or
+    # > something) from running. By also stubbing out persisted? we can
+    # > actually prevent those. A more stable option might be to use suppress
+    # > instead, similar to the other branch in reify_has_one.
+    # > -Sean Griffin (https://github.com/paper-trail-gem/paper_trail/pull/899)
+    #
+    # @api private
+    def appear_as_new_record
+      @record.instance_eval {
+        alias :old_new_record? :new_record?
+        alias :new_record? :present?
+        alias :old_persisted? :persisted?
+        alias :persisted? :nil?
+      }
+      yield
+      @record.instance_eval {
+        alias :new_record? :old_new_record?
+        alias :persisted? :old_persisted?
+      }
+    end
+
+    # @api private
+    def record_create
+      version = super
+      if version
+        update_transaction_id(version)
+        save_associations(version)
+      end
+    end
+
+    # @api private
+    def data_for_create
+      data = super
+      add_transaction_id_to(data)
+      data
+    end
+
+    # @api private
+    def record_destroy(*args)
+      version = super
+      if version && version.respond_to?(:errors) && version.errors.empty?
+        update_transaction_id(version)
+        save_associations(version)
+      end
+      version
+    end
+
+    # @api private
+    def data_for_destroy
+      data = super
+      add_transaction_id_to(data)
+      data
+    end
+
+    # Returns a boolean indicating whether to store serialized version diffs
+    # in the `object_changes` column of the version record.
+    # @api private
+    def record_object_changes?
+      @record.paper_trail_options[:save_changes] &&
+        @record.class.paper_trail.version_class.column_names.include?("object_changes")
+    end
+
+    # @api private
+    def record_update(**opts)
+      version = super
+      if version && version.respond_to?(:errors) && version.errors.empty?
+        update_transaction_id(version)
+        save_associations(version)
+      end
+      version
+    end
+
+    # Used during `record_update`, returns a hash of data suitable for an AR
+    # `create`. That is, all the attributes of the nascent `Version` record.
+    #
+    # @api private
+    def data_for_update(*args)
+      data = super
+      add_transaction_id_to(data)
+      data
+    end
+
+    # @api private
+    def record_update_columns(*args)
+      version = super
+      if version && version.respond_to?(:errors) && version.errors.empty?
+        update_transaction_id(version)
+        save_associations(version)
+      end
+      version
+    end
+
+    # Returns data for record_update_columns
+    # @api private
+    def data_for_update_columns(*args)
+      data = super
+      add_transaction_id_to(data)
+      data
+    end
+
+    # Saves associations if the join table for `VersionAssociation` exists.
+    def save_associations(version)
+      return unless ::PaperTrail.config.track_associations?
+      save_bt_associations(version)
+      save_habtm_associations(version)
+    end
+
+    # Save all `belongs_to` associations.
+    # @api private
+    def save_bt_associations(version)
+      @record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        save_bt_association(assoc, version)
+      end
+    end
+
+    # When a record is created, updated, or destroyed, we determine what the
+    # HABTM associations looked like before any changes were made, by using
+    # the `paper_trail_habtm` data structure. Then, we create
+    # `VersionAssociation` records for each of the associated records.
+    # @api private
+    def save_habtm_associations(version)
+      @record.class.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|
+        next unless save_habtm_association?(a)
+        habtm_assoc_ids(a).each do |id|
+          ::PaperTrail::VersionAssociation.create(
+            version_id: version.transaction_id,
+            foreign_key_name: a.name,
+            foreign_key_id: id
+          )
+        end
+      end
+    end
+
+    private
+
+    def add_transaction_id_to(data)
+      return unless @record.class.paper_trail.version_class.column_names.include?("transaction_id")
+      data[:transaction_id] = ::PaperTrail.request.transaction_id
+    end
+
+    # Given a HABTM association, returns an array of ids.
+    #
+    # @api private
+    def habtm_assoc_ids(habtm_assoc)
+      current = @record.send(habtm_assoc.name).to_a.map(&:id) # TODO: `pluck` would use less memory
+      removed = @record.paper_trail_habtm.try(:[], habtm_assoc.name).try(:[], :removed) || []
+      added = @record.paper_trail_habtm.try(:[], habtm_assoc.name).try(:[], :added) || []
+      current + removed - added
+    end
+
+    # Save a single `belongs_to` association.
+    # @api private
+    def save_bt_association(assoc, version)
+      assoc_version_args = {
+        version_id: version.id,
+        foreign_key_name: assoc.foreign_key
+      }
+
+      if assoc.options[:polymorphic]
+        associated_record = @record.send(assoc.name) if @record.send(assoc.foreign_type)
+        if associated_record && ::PaperTrail.request.enabled_for_model?(associated_record.class)
+          assoc_version_args[:foreign_key_id] = associated_record.id
+        end
+      elsif ::PaperTrail.request.enabled_for_model?(assoc.klass)
+        assoc_version_args[:foreign_key_id] = @record.send(assoc.foreign_key)
+      end
+
+      if assoc_version_args.key?(:foreign_key_id)
+        ::PaperTrail::VersionAssociation.create(assoc_version_args)
+      end
+    end
+
+    # Returns true if the given HABTM association should be saved.
+    # @api private
+    def save_habtm_association?(assoc)
+      @record.class.paper_trail_save_join_tables.include?(assoc.name) ||
+        ::PaperTrail.request.enabled_for_model?(assoc.klass)
+    end
+
+    def update_transaction_id(version)
+      return unless @record.class.paper_trail.version_class.column_names.include?("transaction_id")
+      if ::PaperTrail.transaction? && ::PaperTrail.request.transaction_id.nil?
+        ::PaperTrail.request.transaction_id = version.id
+        version.transaction_id = version.id
+        version.save
+      end
+    end
+  end
+end