paper_trail 4.0.0 → 5.1.0

data/lib/paper_trail/has_paper_trail.rb

@@ -1,169 +1,236 @@
-require 'active_support/core_ext/object' # provides the `try` method
+require "active_support/core_ext/object" # provides the `try` method
+require "paper_trail/attribute_serializers/legacy_active_record_shim"
+require "paper_trail/attribute_serializers/object_attribute"
+require "paper_trail/attribute_serializers/object_changes_attribute"
 
 module PaperTrail
+  # Extensions to `ActiveRecord::Base`.  See `frameworks/active_record.rb`.
   module Model
-
     def self.included(base)
       base.send :extend, ClassMethods
+      base.send :attr_accessor, :paper_trail_habtm
     end
 
+    # :nodoc:
     module ClassMethods
-      # Declare this in your model to track every create, update, and destroy.  Each version of
-      # the model is available in the `versions` association.
+      # Declare this in your model to track every create, update, and destroy.
+      # Each version of the model is available in the `versions` association.
       #
       # Options:
-      # :on            the events to track (optional; defaults to all of them).  Set to an array of
-      #                `:create`, `:update`, `:destroy` as desired.
-      # :class_name    the name of a custom Version class.  This class should inherit from `PaperTrail::Version`.
-      # :ignore        an array of attributes for which a new `Version` will not be created if only they change.
-      #                it can also aceept a Hash as an argument where the key is the attribute to ignore (a `String` or `Symbol`),
-      #                which will only be ignored if the value is a `Proc` which returns truthily.
-      # :if, :unless   Procs that allow to specify conditions when to save versions for an object
-      # :only          inverse of `ignore` - a new `Version` will be created only for these attributes if supplied
-      #                it can also aceept a Hash as an argument where the key is the attribute to track (a `String` or `Symbol`),
-      #                which will only be counted if the value is a `Proc` which returns truthily.
-      # :skip          fields to ignore completely.  As with `ignore`, updates to these fields will not create
-      #                a new `Version`.  In addition, these fields will not be included in the serialized versions
-      #                of the object whenever a new `Version` is created.
-      # :meta          a hash of extra data to store.  You must add a column to the `versions` table for each key.
-      #                Values are objects or procs (which are called with `self`, i.e. the model with the paper
-      #                trail).  See `PaperTrail::Controller.info_for_paper_trail` for how to store data from
-      #                the controller.
-      # :versions      the name to use for the versions association.  Default is `:versions`.
-      # :version       the name to use for the method which returns the version the instance was reified from.
-      #                Default is `:version`.
-      # :save_changes  whether or not to save changes to the object_changes column if it exists. Default is true
       #
+      # - :on - The events to track (optional; defaults to all of them). Set
+      #   to an array of `:create`, `:update`, `:destroy` as desired.
+      # - :class_name - The name of a custom Version class.  This class should
+      #   inherit from `PaperTrail::Version`.
+      # - :ignore - An array of attributes for which a new `Version` will not be
+      #   created if only they change. It can also aceept a Hash as an
+      #   argument where the key is the attribute to ignore (a `String` or
+      #   `Symbol`), which will only be ignored if the value is a `Proc` which
+      #   returns truthily.
+      # - :if, :unless - Procs that allow to specify conditions when to save
+      #   versions for an object.
+      # - :only - Inverse of `ignore`. A new `Version` will be created only
+      #   for these attributes if supplied it can also aceept a Hash as an
+      #   argument where the key is the attribute to track (a `String` or
+      #   `Symbol`), which will only be counted if the value is a `Proc` which
+      #   returns truthily.
+      # - :skip - Fields to ignore completely.  As with `ignore`, updates to
+      #   these fields will not create a new `Version`.  In addition, these
+      #   fields will not be included in the serialized versions of the object
+      #   whenever a new `Version` is created.
+      # - :meta - A hash of extra data to store. You must add a column to the
+      #   `versions` table for each key. Values are objects or procs (which
+      #   are called with `self`, i.e. the model with the paper trail).  See
+      #   `PaperTrail::Controller.info_for_paper_trail` for how to store data
+      #   from the controller.
+      # - :versions - The name to use for the versions association.  Default
+      #   is `:versions`.
+      # - :version - The name to use for the method which returns the version
+      #   the instance was reified from. Default is `:version`.
+      # - :save_changes - Whether or not to save changes to the object_changes
+      #   column if it exists. Default is true
+      # - :join_tables - If the model has a has_and_belongs_to_many relation
+      #   with an unpapertrailed model, passing the name of the association to
+      #   the join_tables option will paper trail the join table but not save
+      #   the other model, allowing reification of the association but with the
+      #   other models latest state (if the other model is paper trailed, this
+      #   option does nothing)
+      #
+      # @api public
       def has_paper_trail(options = {})
+        options[:on] ||= [:create, :update, :destroy]
+
+        # Wrap the :on option in an array if necessary. This allows a single
+        # symbol to be passed in.
+        options[:on] = Array(options[:on])
+
+        setup_model_for_paper_trail(options)
+
+        setup_callbacks_from_options options[:on]
+
+        setup_callbacks_for_habtm options[:join_tables]
+      end
+
+      def update_for_callback(name, callback, model, assoc)
+        model.paper_trail_habtm ||= {}
+        model.paper_trail_habtm.reverse_merge!(name => { removed: [], added: [] })
+        case callback
+        when :before_add
+          model.paper_trail_habtm[name][:added] |= [assoc.id]
+          model.paper_trail_habtm[name][:removed] -= [assoc.id]
+        when :before_remove
+          model.paper_trail_habtm[name][:removed] |= [assoc.id]
+          model.paper_trail_habtm[name][:added] -= [assoc.id]
+        end
+      end
+
+      attr_reader :paper_trail_save_join_tables
+
+      def setup_callbacks_for_habtm(join_tables)
+        @paper_trail_save_join_tables = Array.wrap(join_tables)
+        # Adds callbacks to record changes to habtm associations such that on
+        # save the previous version of the association (if changed) can be
+        # interpreted
+        reflect_on_all_associations(:has_and_belongs_to_many).
+          reject { |a| paper_trail_options[:skip].include?(a.name.to_s) }.
+          each do |a|
+            added_callback = lambda do |*args|
+              update_for_callback(a.name, :before_add, args[-2], args.last)
+            end
+            removed_callback = lambda do |*args|
+              update_for_callback(a.name, :before_remove, args[-2], args.last)
+            end
+            send(:"before_add_for_#{a.name}").send(:<<, added_callback)
+            send(:"before_remove_for_#{a.name}").send(:<<, removed_callback)
+          end
+      end
+
+      # Installs callbacks, associations, "class attributes", and more.
+      # For details of how "class attributes" work, see the activesupport docs.
+      # @api private
+      def setup_model_for_paper_trail(options = {})
         # Lazily include the instance methods so we don't clutter up
         # any more ActiveRecord models than we have to.
         send :include, InstanceMethods
 
+        if ::ActiveRecord::VERSION::STRING < "4.2"
+          send :extend, AttributeSerializers::LegacyActiveRecordShim
+        end
+
         class_attribute :version_association_name
         self.version_association_name = options[:version] || :version
 
         # The version this instance was reified from.
-        attr_accessor self.version_association_name
+        attr_accessor version_association_name
 
         class_attribute :version_class_name
-        self.version_class_name = options[:class_name] || 'PaperTrail::Version'
+        self.version_class_name = options[:class_name] || "PaperTrail::Version"
 
-        class_attribute :paper_trail_options
-        self.paper_trail_options = options.dup
-
-        [:ignore, :skip, :only].each do |k|
-          paper_trail_options[k] =
-            [paper_trail_options[k]].flatten.compact.map { |attr| attr.is_a?(Hash) ? attr.stringify_keys : attr.to_s }
-        end
-
-        paper_trail_options[:meta] ||= {}
-        paper_trail_options[:save_changes] = true if paper_trail_options[:save_changes].nil?
+        setup_paper_trail_options(options)
 
         class_attribute :versions_association_name
         self.versions_association_name = options[:versions] || :versions
 
         attr_accessor :paper_trail_event
 
-        if ::ActiveRecord::VERSION::MAJOR >= 4 # `has_many` syntax for specifying order uses a lambda in Rails 4
-          has_many self.versions_association_name,
-            lambda { order(model.timestamp_sort_order) },
-            :class_name => self.version_class_name, :as => :item
+        # `has_many` syntax for specifying order uses a lambda in Rails 4
+        if ::ActiveRecord::VERSION::MAJOR >= 4
+          has_many versions_association_name,
+            -> { order(model.timestamp_sort_order) },
+            class_name: version_class_name, as: :item
         else
-          has_many self.versions_association_name,
-            :class_name => self.version_class_name,
-            :as         => :item,
-            :order      => self.paper_trail_version_class.timestamp_sort_order
-        end
-
-        options[:on] ||= [:create, :update, :destroy]
-        options_on = Array(options[:on]) # so that a single symbol can be passed in without wrapping it in an `Array`
-        after_create  :record_create, :if => :save_version? if options_on.include?(:create)
-        if options_on.include?(:update)
-          before_save   :reset_timestamp_attrs_for_update_if_needed!, :on => :update
-          after_update  :record_update, :if => :save_version?
-          after_update  :clear_version_instance!
+          has_many versions_association_name,
+            class_name: version_class_name,
+            as: :item,
+            order: paper_trail_version_class.timestamp_sort_order
         end
-        after_destroy :record_destroy, :if => :save_version? if options_on.include?(:destroy)
 
-        # Reset the transaction id when the transaction is closed
+        # Reset the transaction id when the transaction is closed.
         after_commit :reset_transaction_id
         after_rollback :reset_transaction_id
         after_rollback :clear_rolled_back_versions
       end
 
-      # Switches PaperTrail off for this class.
-      def paper_trail_off!
-        PaperTrail.enabled_for_model(self, false)
+      # Given `options`, populates `paper_trail_options`.
+      # @api private
+      def setup_paper_trail_options(options)
+        class_attribute :paper_trail_options
+        self.paper_trail_options = options.dup
+        [:ignore, :skip, :only].each do |k|
+          paper_trail_options[k] = [paper_trail_options[k]].flatten.compact.map { |attr|
+            attr.is_a?(Hash) ? attr.stringify_keys : attr.to_s
+          }
+        end
+        paper_trail_options[:meta] ||= {}
+        if paper_trail_options[:save_changes].nil?
+          paper_trail_options[:save_changes] = true
+        end
       end
 
-      # Switches PaperTrail on for this class.
-      def paper_trail_on!
-        PaperTrail.enabled_for_model(self, true)
+      def setup_callbacks_from_options(options_on = [])
+        options_on.each do |option|
+          send "paper_trail_on_#{option}"
+        end
       end
 
-      def paper_trail_enabled_for_model?
-        return false unless self.include?(PaperTrail::Model::InstanceMethods)
-        PaperTrail.enabled_for_model?(self)
-      end
+      # Record version before or after "destroy" event
+      def paper_trail_on_destroy(recording_order = "before")
+        unless %w(after before).include?(recording_order.to_s)
+          raise ArgumentError, 'recording order can only be "after" or "before"'
+        end
 
-      def paper_trail_version_class
-        @paper_trail_version_class ||= version_class_name.constantize
+        if recording_order == "after" &&
+            Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new("5")
+          if ::ActiveRecord::Base.belongs_to_required_by_default
+            ::ActiveSupport::Deprecation.warn(
+              "paper_trail_on_destroy(:after) is incompatible with ActiveRecord " +
+                "belongs_to_required_by_default and has no effect. Please use :before " +
+                "or disable belongs_to_required_by_default."
+            )
+          end
+        end
+
+        send "#{recording_order}_destroy", :record_destroy, if: :save_version?
+
+        return if paper_trail_options[:on].include?(:destroy)
+        paper_trail_options[:on] << :destroy
       end
 
-      # Used for Version#object attribute
-      def serialize_attributes_for_paper_trail!(attributes)
-        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
-        return attributes if self.paper_trail_version_class.object_col_is_json?
+      # Record version after "update" event
+      def paper_trail_on_update
+        before_save :reset_timestamp_attrs_for_update_if_needed!, on: :update
+        after_update :record_update, if: :save_version?
+        after_update :clear_version_instance!
 
-        serialized_attributes.each do |key, coder|
-          if attributes.key?(key)
-            # Fall back to current serializer if `coder` has no `dump` method
-            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
-            attributes[key] = coder.dump(attributes[key])
-          end
-        end
+        return if paper_trail_options[:on].include?(:update)
+        paper_trail_options[:on] << :update
       end
 
-      def unserialize_attributes_for_paper_trail!(attributes)
-        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
-        return attributes if self.paper_trail_version_class.object_col_is_json?
+      # Record version after "create" event
+      def paper_trail_on_create
+        after_create :record_create, if: :save_version?
 
-        serialized_attributes.each do |key, coder|
-          if attributes.key?(key)
-            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
-            attributes[key] = coder.load(attributes[key])
-          end
-        end
+        return if paper_trail_options[:on].include?(:create)
+        paper_trail_options[:on] << :create
       end
 
-      # Used for Version#object_changes attribute
-      def serialize_attribute_changes_for_paper_trail!(changes)
-        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
-        return changes if self.paper_trail_version_class.object_changes_col_is_json?
+      # Switches PaperTrail off for this class.
+      def paper_trail_off!
+        PaperTrail.enabled_for_model(self, false)
+      end
 
-        serialized_attributes.each do |key, coder|
-          if changes.key?(key)
-            # Fall back to current serializer if `coder` has no `dump` method
-            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
-            old_value, new_value = changes[key]
-            changes[key] = [coder.dump(old_value),
-                            coder.dump(new_value)]
-          end
-        end
+      # Switches PaperTrail on for this class.
+      def paper_trail_on!
+        PaperTrail.enabled_for_model(self, true)
       end
 
-      def unserialize_attribute_changes_for_paper_trail!(changes)
-        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
-        return changes if self.paper_trail_version_class.object_changes_col_is_json?
+      def paper_trail_enabled_for_model?
+        return false unless include?(PaperTrail::Model::InstanceMethods)
+        PaperTrail.enabled_for_model?(self)
+      end
 
-        serialized_attributes.each do |key, coder|
-          if changes.key?(key)
-            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
-            old_value, new_value = changes[key]
-            changes[key] = [coder.load(old_value),
-                            coder.load(new_value)]
-          end
-        end
+      def paper_trail_version_class
+        @paper_trail_version_class ||= version_class_name.constantize
       end
     end
 
@@ -183,34 +250,43 @@ module PaperTrail
 
       def originator
         ::ActiveSupport::Deprecation.warn "Use paper_trail_originator instead of originator."
-        self.paper_trail_originator
+        paper_trail_originator
       end
 
       # Invoked after rollbacks to ensure versions records are not created
-      # for changes that never actually took place
+      # for changes that never actually took place.
+      # Optimization: Use lazy `reset` instead of eager `reload` because, in
+      # many use cases, the association will not be used.
       def clear_rolled_back_versions
-        send(self.class.versions_association_name).reload
+        send(self.class.versions_association_name).reset
       end
 
       # Returns the object (not a Version) as it was at the given timestamp.
-      def version_at(timestamp, reify_options={})
+      def version_at(timestamp, reify_options = {})
         # Because a version stores how its object looked *before* the change,
         # we need to look for the first version created *after* the timestamp.
         v = send(self.class.versions_association_name).subsequent(timestamp, true).first
         return v.reify(reify_options) if v
-        self unless self.destroyed?
+        self unless destroyed?
       end
 
       # Returns the objects (not Versions) as they were between the given times.
-      def versions_between(start_time, end_time, reify_options={})
+      # TODO: Either add support for the third argument, `_reify_options`, or
+      # add a deprecation warning if someone tries to use it.
+      def versions_between(start_time, end_time, _reify_options = {})
         versions = send(self.class.versions_association_name).between(start_time, end_time)
-        versions.collect { |version| version_at(version.send PaperTrail.timestamp_field) }
+        versions.collect { |version| version_at(version.send(PaperTrail.timestamp_field)) }
       end
 
       # Returns the object (not a Version) as it was most recently.
       def previous_version
-        preceding_version = source_version ? source_version.previous : send(self.class.versions_association_name).last
-        preceding_version.reify if preceding_version
+        previous =
+          if source_version
+            source_version.previous
+          else
+            send(self.class.versions_association_name).last
+          end
+        previous.try(:reify)
       end
 
       # Returns the object (not a Version) as it became next.
@@ -218,7 +294,7 @@ module PaperTrail
       #  "live" item, we return nil.  Perhaps we should return self instead?
       def next_version
         subsequent_version = source_version.next
-        subsequent_version ? subsequent_version.reify : self.class.find(self.id)
+        subsequent_version ? subsequent_version.reify : self.class.find(id)
       rescue
         nil
       end
@@ -229,14 +305,15 @@ module PaperTrail
 
       # Executes the given method or block without creating a new version.
       def without_versioning(method = nil)
-        paper_trail_was_enabled = self.paper_trail_enabled_for_model?
+        paper_trail_was_enabled = paper_trail_enabled_for_model?
         self.class.paper_trail_off!
         method ? method.to_proc.call(self) : yield(self)
       ensure
         self.class.paper_trail_on! if paper_trail_was_enabled
       end
 
-      # Utility method for reifying. Anything executed inside the block will appear like a new record
+      # Utility method for reifying. Anything executed inside the block will
+      # appear like a new record.
       def appear_as_new_record
         instance_eval {
           alias :old_new_record? :new_record?
@@ -246,9 +323,10 @@ module PaperTrail
         instance_eval { alias :new_record? :old_new_record? }
       end
 
-      # Temporarily overwrites the value of whodunnit and then executes the provided block.
+      # Temporarily overwrites the value of whodunnit and then executes the
+      # provided block.
       def whodunnit(value)
-        raise ArgumentError, 'expected to receive a block' unless block_given?
+        raise ArgumentError, "expected to receive a block" unless block_given?
         current_whodunnit = PaperTrail.whodunnit
         PaperTrail.whodunnit = value
         yield self
@@ -261,7 +339,7 @@ module PaperTrail
       # `:on`, `:if`, or `:unless`.
       #
       # TODO: look into leveraging the `after_touch` callback from
-      # `ActiveRecord` to allow the regular `touch` method go generate a version
+      # `ActiveRecord` to allow the regular `touch` method to generate a version
       # as normal. May make sense to switch the `record_update` method to
       # leverage an `after_update` callback anyways (likely for v4.0.0)
       def touch_with_version(name = nil)
@@ -274,7 +352,7 @@ module PaperTrail
         attributes.each { |column| write_attribute(column, current_time) }
 
         record_update(true) unless will_record_after_update?
-        save!(:validate => false)
+        save!(validate: false)
       end
 
       private
@@ -293,66 +371,103 @@ module PaperTrail
       def record_create
         if paper_trail_switched_on?
           data = {
-            :event     => paper_trail_event || 'create',
-            :whodunnit => PaperTrail.whodunnit
+            event: paper_trail_event || "create",
+            whodunnit: PaperTrail.whodunnit
           }
-          if respond_to?(:created_at)
-            data[PaperTrail.timestamp_field] = created_at
-          end
-          if paper_trail_options[:save_changes] && changed_notably? && self.class.paper_trail_version_class.column_names.include?('object_changes')
-            data[:object_changes] = self.class.paper_trail_version_class.object_changes_col_is_json? ? changes_for_paper_trail :
-              PaperTrail.serializer.dump(changes_for_paper_trail)
+          if respond_to?(:updated_at)
+            data[PaperTrail.timestamp_field] = updated_at
           end
-          if self.class.paper_trail_version_class.column_names.include?('transaction_id')
-            data[:transaction_id] = PaperTrail.transaction_id
+          if pt_record_object_changes? && changed_notably?
+            data[:object_changes] = pt_recordable_object_changes
           end
+          add_transaction_id_to(data)
           version = send(self.class.versions_association_name).create! merge_metadata(data)
-          set_transaction_id(version)
+          update_transaction_id(version)
           save_associations(version)
         end
       end
 
       def record_update(force = nil)
         if paper_trail_switched_on? && (force || changed_notably?)
-          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
           data = {
-            :event     => paper_trail_event || 'update',
-            :object    => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
-            :whodunnit => PaperTrail.whodunnit
+            event: paper_trail_event || "update",
+            object: pt_recordable_object,
+            whodunnit: PaperTrail.whodunnit
           }
           if respond_to?(:updated_at)
             data[PaperTrail.timestamp_field] = updated_at
           end
-          if paper_trail_options[:save_changes] && self.class.paper_trail_version_class.column_names.include?('object_changes')
-            data[:object_changes] = self.class.paper_trail_version_class.object_changes_col_is_json? ? changes_for_paper_trail :
-              PaperTrail.serializer.dump(changes_for_paper_trail)
-          end
-          if self.class.paper_trail_version_class.column_names.include?('transaction_id')
-            data[:transaction_id] = PaperTrail.transaction_id
+          if pt_record_object_changes?
+            data[:object_changes] = pt_recordable_object_changes
           end
+          add_transaction_id_to(data)
           version = send(self.class.versions_association_name).create merge_metadata(data)
-          set_transaction_id(version)
-          save_associations(version)
+          if version.errors.any?
+            log_version_errors(version, :update)
+          else
+            update_transaction_id(version)
+            save_associations(version)
+          end
         end
       end
 
-      def changes_for_paper_trail
-        _changes = changes.delete_if { |k,v| !notably_changed.include?(k) }
-        if PaperTrail.serialized_attributes?
-          self.class.serialize_attribute_changes_for_paper_trail!(_changes)
+      # Returns a boolean indicating whether to store serialized version diffs
+      # in the `object_changes` column of the version record.
+      # @api private
+      def pt_record_object_changes?
+        paper_trail_options[:save_changes] &&
+          self.class.paper_trail_version_class.column_names.include?("object_changes")
+      end
+
+      # Returns an object which can be assigned to the `object` attribute of a
+      # nascent version record. If the `object` column is a postgres `json`
+      # column, then a hash can be used in the assignment, otherwise the column
+      # is a `text` column, and we must perform the serialization here, using
+      # `PaperTrail.serializer`.
+      # @api private
+      def pt_recordable_object
+        if self.class.paper_trail_version_class.object_col_is_json?
+          object_attrs_for_paper_trail
+        else
+          PaperTrail.serializer.dump(object_attrs_for_paper_trail)
         end
-        _changes.to_hash
       end
 
-      # Invoked via`after_update` callback for when a previous version is reified and then saved
+      # Returns an object which can be assigned to the `object_changes`
+      # attribute of a nascent version record. If the `object_changes` column is
+      # a postgres `json` column, then a hash can be used in the assignment,
+      # otherwise the column is a `text` column, and we must perform the
+      # serialization here, using `PaperTrail.serializer`.
+      # @api private
+      def pt_recordable_object_changes
+        if self.class.paper_trail_version_class.object_changes_col_is_json?
+          changes_for_paper_trail
+        else
+          PaperTrail.serializer.dump(changes_for_paper_trail)
+        end
+      end
+
+      def changes_for_paper_trail
+        notable_changes = changes.delete_if { |k, _v| !notably_changed.include?(k) }
+        AttributeSerializers::ObjectChangesAttribute.
+          new(self.class).
+          serialize(notable_changes)
+        notable_changes.to_hash
+      end
+
+      # Invoked via`after_update` callback for when a previous version is
+      # reified and then saved.
       def clear_version_instance!
         send("#{self.class.version_association_name}=", nil)
       end
 
+      # Invoked via callback when a user attempts to persist a reified
+      # `Version`.
       def reset_timestamp_attrs_for_update_if_needed!
-        return if self.live? # invoked via callback when a user attempts to persist a reified `Version`
+        return if live?
         timestamp_attributes_for_update_in_model.each do |column|
-          # ActiveRecord 4.2 deprecated `reset_column!` in favor of `restore_column!`
+          # ActiveRecord 4.2 deprecated `reset_column!` in favor of
+          # `restore_column!`.
           if respond_to?("restore_#{column}!")
             send("restore_#{column}!")
           else
@@ -362,54 +477,74 @@ module PaperTrail
       end
 
       def record_destroy
-        if paper_trail_switched_on? and not new_record?
-          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
+        if paper_trail_switched_on? && !new_record?
           data = {
-            :item_id   => self.id,
-            :item_type => self.class.base_class.name,
-            :event     => paper_trail_event || 'destroy',
-            :object    => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
-            :whodunnit => PaperTrail.whodunnit
+            item_id: id,
+            item_type: self.class.base_class.name,
+            event: paper_trail_event || "destroy",
+            object: pt_recordable_object,
+            whodunnit: PaperTrail.whodunnit
           }
-          if self.class.paper_trail_version_class.column_names.include?('transaction_id')
-            data[:transaction_id] = PaperTrail.transaction_id
-          end
+          add_transaction_id_to(data)
           version = self.class.paper_trail_version_class.create(merge_metadata(data))
-          send("#{self.class.version_association_name}=", version)
-          send(self.class.versions_association_name).send :load_target
-          set_transaction_id(version)
-          save_associations(version)
+          if version.errors.any?
+            log_version_errors(version, :destroy)
+          else
+            send("#{self.class.version_association_name}=", version)
+            send(self.class.versions_association_name).reset
+            update_transaction_id(version)
+            save_associations(version)
+          end
         end
       end
 
-      # saves associations if the join table for `VersionAssociation` exists
+      # Saves associations if the join table for `VersionAssociation` exists.
       def save_associations(version)
         return unless PaperTrail.config.track_associations?
+        save_associations_belongs_to(version)
+        save_associations_has_and_belongs_to_many(version)
+      end
+
+      def save_associations_belongs_to(version)
         self.class.reflect_on_all_associations(:belongs_to).each do |assoc|
           assoc_version_args = {
-              :version_id => version.id,
-              :foreign_key_name => assoc.foreign_key
+            version_id: version.id,
+            foreign_key_name: assoc.foreign_key
           }
 
           if assoc.options[:polymorphic]
             associated_record = send(assoc.name) if send(assoc.foreign_type)
             if associated_record && associated_record.class.paper_trail_enabled_for_model?
-              assoc_version_args.merge!(:foreign_key_id => associated_record.id)
+              assoc_version_args[:foreign_key_id] = associated_record.id
             end
           elsif assoc.klass.paper_trail_enabled_for_model?
-            assoc_version_args.merge!(:foreign_key_id => send(assoc.foreign_key))
+            assoc_version_args[:foreign_key_id] = send(assoc.foreign_key)
           end
 
-          PaperTrail::VersionAssociation.create(assoc_version_args) if assoc_version_args.has_key?(:foreign_key_id)
+          if assoc_version_args.key?(:foreign_key_id)
+            PaperTrail::VersionAssociation.create(assoc_version_args)
+          end
         end
       end
 
-      def set_transaction_id(version)
-        return unless self.class.paper_trail_version_class.column_names.include?('transaction_id')
-        if PaperTrail.transaction? && PaperTrail.transaction_id.nil?
-           PaperTrail.transaction_id = version.id
-           version.transaction_id = version.id
-           version.save
+      def save_associations_has_and_belongs_to_many(version)
+        # Use the :added and :removed keys to extrapolate the HABTM associations
+        # to before any changes were made
+        self.class.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|
+          next unless
+            self.class.paper_trail_save_join_tables.include?(a.name) ||
+                a.klass.paper_trail_enabled_for_model?
+          assoc_version_args = {
+            version_id: version.transaction_id,
+            foreign_key_name: a.name
+          }
+          assoc_ids =
+            send(a.name).to_a.map(&:id) +
+            (@paper_trail_habtm.try(:[], a.name).try(:[], :removed) || []) -
+            (@paper_trail_habtm.try(:[], a.name).try(:[], :added) || [])
+          assoc_ids.each do |id|
+            PaperTrail::VersionAssociation.create(assoc_version_args.merge(foreign_key_id: id))
+          end
         end
       end
 
@@ -419,14 +554,14 @@ module PaperTrail
 
       def merge_metadata(data)
         # First we merge the model-level metadata in `meta`.
-        paper_trail_options[:meta].each do |k,v|
+        paper_trail_options[:meta].each do |k, v|
           data[k] =
             if v.respond_to?(:call)
               v.call(self)
-            elsif v.is_a?(Symbol) && respond_to?(v)
-              # if it is an attribute that is changing in an existing object,
-              # be sure to grab the current version
-              if has_attribute?(v) && send("#{v}_changed?".to_sym) && data[:event] != 'create'
+            elsif v.is_a?(Symbol) && respond_to?(v, true)
+              # If it is an attribute that is changing in an existing object,
+              # be sure to grab the current version.
+              if has_attribute?(v) && send("#{v}_changed?".to_sym) && data[:event] != "create"
                 send("#{v}_was".to_sym)
               else
                 send(v)
@@ -435,34 +570,27 @@ module PaperTrail
               v
             end
         end
+
         # Second we merge any extra data from the controller (if available).
         data.merge(PaperTrail.controller_info || {})
       end
 
       def attributes_before_change
-        attributes.tap do |prev|
-          enums = self.respond_to?(:defined_enums) ? self.defined_enums : {}
-          changed_attributes.select { |k,v| self.class.column_names.include?(k) }.each do |attr, before|
-            before = enums[attr][before] if enums[attr]
-            prev[attr] = before
-          end
-        end
+        changed = changed_attributes.select { |k, _v| self.class.column_names.include?(k) }
+        attributes.merge(changed)
       end
 
-      # returns hash of attributes (with appropriate attributes serialized),
-      # ommitting attributes to be skipped
-      def object_attrs_for_paper_trail(attributes_hash)
-        attrs = attributes_hash.except(*self.paper_trail_options[:skip])
-        if PaperTrail.serialized_attributes?
-          self.class.serialize_attributes_for_paper_trail!(attrs)
-        end
+      # Returns hash of attributes (with appropriate attributes serialized),
+      # ommitting attributes to be skipped.
+      def object_attrs_for_paper_trail
+        attrs = attributes_before_change.except(*paper_trail_options[:skip])
+        AttributeSerializers::ObjectAttribute.new(self.class).serialize(attrs)
         attrs
       end
 
-      # This method determines whether it is appropriate to generate a new
-      # version instance. A timestamp-only update (e.g. only `updated_at`
-      # changed) is considered notable unless an ignored attribute was also
-      # changed.
+      # Determines whether it is appropriate to generate a new version
+      # instance. A timestamp-only update (e.g. only `updated_at` changed) is
+      # considered notable unless an ignored attribute was also changed.
       def changed_notably?
         if ignored_attr_has_changed?
           timestamps = timestamp_attributes_for_update_in_model.map(&:to_s)
@@ -473,41 +601,73 @@ module PaperTrail
       end
 
       # An attributed is "ignored" if it is listed in the `:ignore` option
-      # and/or the `:skip` option.  Returns true if an ignored attribute
-      # has changed.
+      # and/or the `:skip` option.  Returns true if an ignored attribute has
+      # changed.
       def ignored_attr_has_changed?
-        ignored = self.paper_trail_options[:ignore] + self.paper_trail_options[:skip]
+        ignored = paper_trail_options[:ignore] + paper_trail_options[:skip]
         ignored.any? && (changed & ignored).any?
       end
 
       def notably_changed
-        only = self.paper_trail_options[:only].dup
-        # remove Hash arguments and then evaluate whether the attributes (the keys of the hash) should also get pushed into the collection
+        only = paper_trail_options[:only].dup
+        # Remove Hash arguments and then evaluate whether the attributes (the
+        # keys of the hash) should also get pushed into the collection.
         only.delete_if do |obj|
-          obj.is_a?(Hash) && obj.each { |attr, condition| only << attr if condition.respond_to?(:call) && condition.call(self) }
+          obj.is_a?(Hash) &&
+            obj.each { |attr, condition|
+              only << attr if condition.respond_to?(:call) && condition.call(self)
+            }
         end
         only.empty? ? changed_and_not_ignored : (changed_and_not_ignored & only)
       end
 
       def changed_and_not_ignored
-        ignore = self.paper_trail_options[:ignore].dup
-         # remove Hash arguments and then evaluate whether the attributes (the keys of the hash) should also get pushed into the collection
+        ignore = paper_trail_options[:ignore].dup
+        # Remove Hash arguments and then evaluate whether the attributes (the
+        # keys of the hash) should also get pushed into the collection.
         ignore.delete_if do |obj|
-          obj.is_a?(Hash) && obj.each { |attr, condition| ignore << attr if condition.respond_to?(:call) && condition.call(self) }
+          obj.is_a?(Hash) &&
+            obj.each { |attr, condition|
+              ignore << attr if condition.respond_to?(:call) && condition.call(self)
+            }
         end
-        skip = self.paper_trail_options[:skip]
+        skip = paper_trail_options[:skip]
         changed - ignore - skip
       end
 
       def paper_trail_switched_on?
-        PaperTrail.enabled? && PaperTrail.enabled_for_controller? && self.paper_trail_enabled_for_model?
+        PaperTrail.enabled? &&
+          PaperTrail.enabled_for_controller? &&
+          paper_trail_enabled_for_model?
       end
 
       def save_version?
-        if_condition     = self.paper_trail_options[:if]
-        unless_condition = self.paper_trail_options[:unless]
+        if_condition = paper_trail_options[:if]
+        unless_condition = paper_trail_options[:unless]
         (if_condition.blank? || if_condition.call(self)) && !unless_condition.try(:call, self)
       end
+
+      def add_transaction_id_to(data)
+        return unless self.class.paper_trail_version_class.column_names.include?("transaction_id")
+        data[:transaction_id] = PaperTrail.transaction_id
+      end
+
+      # @api private
+      def update_transaction_id(version)
+        return unless self.class.paper_trail_version_class.column_names.include?("transaction_id")
+        if PaperTrail.transaction? && PaperTrail.transaction_id.nil?
+          PaperTrail.transaction_id = version.id
+          version.transaction_id = version.id
+          version.save
+        end
+      end
+
+      def log_version_errors(version, action)
+        version.logger.warn(
+          "Unable to create version for #{action} of #{self.class.name}##{id}: " +
+          version.errors.full_messages.join(", ")
+        )
+      end
     end
   end
 end