paper_trail 9.2.0 → 10.0.0

data/lib/paper_trail/events/create.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "paper_trail/events/base"
+
+module PaperTrail
+  module Events
+    # See docs in `Base`.
+    #
+    # @api private
+    class Create < Base
+      # Return attributes of nascent `Version` record.
+      #
+      # @api private
+      def data
+        data = {
+          event: @record.paper_trail_event || "create",
+          whodunnit: PaperTrail.request.whodunnit
+        }
+        if @record.respond_to?(:updated_at)
+          data[:created_at] = @record.updated_at
+        end
+        if record_object_changes? && changed_notably?
+          changes = notable_changes
+          data[:object_changes] = prepare_object_changes(changes)
+        end
+        merge_item_subtype_into(data)
+        merge_metadata_into(data)
+      end
+    end
+  end
+end

data/lib/paper_trail/events/destroy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "paper_trail/events/base"
+
+module PaperTrail
+  module Events
+    # See docs in `Base`.
+    #
+    # @api private
+    class Destroy < Base
+      # Return attributes of nascent `Version` record.
+      #
+      # @api private
+      def data
+        data = {
+          item_id: @record.id,
+          item_type: @record.class.base_class.name,
+          event: @record.paper_trail_event || "destroy",
+          whodunnit: PaperTrail.request.whodunnit
+        }
+        if record_object?
+          data[:object] = recordable_object(false)
+        end
+        if record_object_changes?
+          # Rails' implementation returns nothing on destroy :/
+          changes = @record.attributes.map { |attr, value| [attr, [value, nil]] }.to_h
+          data[:object_changes] = prepare_object_changes(changes)
+        end
+        merge_item_subtype_into(data)
+        merge_metadata_into(data)
+      end
+    end
+  end
+end

data/lib/paper_trail/events/update.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "paper_trail/events/base"
+
+module PaperTrail
+  module Events
+    # See docs in `Base`.
+    #
+    # @api private
+    class Update < Base
+      # - is_touch - [boolean] - Used in the two situations that are touch-like:
+      #   - `after_touch` we call `RecordTrail#record_update`
+      # - force_changes - [Hash] - Only used by `RecordTrail#update_columns`,
+      #   because there dirty-tracking is off, so it has to track its own changes.
+      #
+      # @api private
+      def initialize(record, in_after_callback, is_touch, force_changes)
+        super(record, in_after_callback)
+        @is_touch = is_touch
+        @force_changes = force_changes
+      end
+
+      # Return attributes of nascent `Version` record.
+      #
+      # @api private
+      def data
+        data = {
+          event: @record.paper_trail_event || "update",
+          whodunnit: PaperTrail.request.whodunnit
+        }
+        if @record.respond_to?(:updated_at)
+          data[:created_at] = @record.updated_at
+        end
+        if record_object?
+          data[:object] = recordable_object(@is_touch)
+        end
+        if record_object_changes?
+          changes = @force_changes.nil? ? notable_changes : @force_changes
+          data[:object_changes] = prepare_object_changes(changes)
+        end
+        merge_item_subtype_into(data)
+        merge_metadata_into(data)
+      end
+
+      private
+
+      # `touch` cannot record `object_changes` because rails' `touch` does not
+      # perform dirty-tracking. Specifically, methods from `Dirty`, like
+      # `saved_changes`, return the same values before and after `touch`.
+      #
+      # See https://github.com/rails/rails/issues/33429
+      #
+      # @api private
+      def record_object_changes?
+        !@is_touch && super
+      end
+    end
+  end
+end

data/lib/paper_trail/has_paper_trail.rb

@@ -51,8 +51,6 @@ module PaperTrail
       #   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

data/lib/paper_trail/model_config.rb

@@ -4,27 +4,6 @@ module PaperTrail
   # Configures an ActiveRecord model, mostly at application boot time, but also
   # sometimes mid-request, with methods like enable/disable.
   class ModelConfig
-    DPR_DISABLE = <<-STR.squish.freeze
-      MyModel.paper_trail.disable is deprecated, use
-      PaperTrail.request.disable_model(MyModel). This new API makes it clear
-      that only the current request is affected, not all threads. Also, all
-      other request-variables now go through the same `request` method, so this
-      new API is more consistent.
-    STR
-    DPR_ENABLE = <<-STR.squish.freeze
-      MyModel.paper_trail.enable is deprecated, use
-      PaperTrail.request.enable_model(MyModel). This new API makes it clear
-      that only the current request is affected, not all threads. Also, all
-      other request-variables now go through the same `request` method, so this
-      new API is more consistent.
-    STR
-    DPR_ENABLED = <<-STR.squish.freeze
-      MyModel.paper_trail.enabled? is deprecated, use
-      PaperTrail.request.enabled_for_model?(MyModel). This new API makes it clear
-      that this is a setting specific to the current request, not all threads.
-      Also, all other request-variables now go through the same `request`
-      method, so this new API is more consistent.
-    STR
     E_CANNOT_RECORD_AFTER_DESTROY = <<-STR.strip_heredoc.freeze
       paper_trail.on_destroy(:after) is incompatible with ActiveRecord's
       belongs_to_required_by_default. Use on_destroy(:before)
@@ -44,24 +23,6 @@ module PaperTrail
       @model_class = model_class
     end
 
-    # @deprecated
-    def disable
-      ::ActiveSupport::Deprecation.warn(DPR_DISABLE, caller(1))
-      ::PaperTrail.request.disable_model(@model_class)
-    end
-
-    # @deprecated
-    def enable
-      ::ActiveSupport::Deprecation.warn(DPR_ENABLE, caller(1))
-      ::PaperTrail.request.enable_model(@model_class)
-    end
-
-    # @deprecated
-    def enabled?
-      ::ActiveSupport::Deprecation.warn(DPR_ENABLED, caller(1))
-      ::PaperTrail.request.enabled_for_model?(@model_class)
-    end
-
     # Adds a callback that records a version after a "create" event.
     #
     # @api public
@@ -169,22 +130,31 @@ module PaperTrail
     end
 
     def setup_associations(options)
+      # @api private - version_association_name
       @model_class.class_attribute :version_association_name
       @model_class.version_association_name = options[:version] || :version
 
       # The version this instance was reified from.
+      # @api public
       @model_class.send :attr_accessor, @model_class.version_association_name
 
+      # @api private - `version_class_name` - However, `rails_admin` has been
+      # using it since 2014 (see `rails_admin/extensions/paper_trail/auditing_adapter.rb`,
+      # https://github.com/sferik/rails_admin/commit/959e1bd4e47e0369d264b58bbbe972ff863767cd)
+      # In PR _____ () we ask them to use `paper_trail_options` instead.
       @model_class.class_attribute :version_class_name
       @model_class.version_class_name = options[:class_name] || "PaperTrail::Version"
 
+      # @api private - versions_association_name
       @model_class.class_attribute :versions_association_name
       @model_class.versions_association_name = options[:versions] || :versions
 
+      # @api public - paper_trail_event
       @model_class.send :attr_accessor, :paper_trail_event
 
       assert_concrete_activerecord_class(@model_class.version_class_name)
 
+      # @api public
       @model_class.has_many(
         @model_class.versions_association_name,
         -> { order(model.timestamp_sort_order) },
@@ -200,6 +170,9 @@ module PaperTrail
     end
 
     def setup_options(options)
+      # @api public - paper_trail_options - Let's encourage plugins to use
+      # eg. `paper_trail_options[:class_name]` rather than `version_class_name`
+      # because the former is documented and the latter is not.
       @model_class.class_attribute :paper_trail_options
       @model_class.paper_trail_options = options.dup
 
@@ -211,9 +184,6 @@ module PaperTrail
       end
 
       @model_class.paper_trail_options[:meta] ||= {}
-      if @model_class.paper_trail_options[:save_changes].nil?
-        @model_class.paper_trail_options[:save_changes] = true
-      end
     end
   end
 end

data/lib/paper_trail/queries/versions/where_object.rb

@@ -18,7 +18,10 @@ module PaperTrail
 
         # @api private
         def execute
-          case @version_model_class.columns_hash["object"].type
+          column = @version_model_class.columns_hash["object"]
+          raise "where_object can't be called without an object column" unless column
+
+          case column.type
           when :jsonb
             jsonb
           when :json

data/lib/paper_trail/queries/versions/where_object_changes.rb

@@ -23,7 +23,7 @@ module PaperTrail
 
         # @api private
         def execute
-          if PaperTrail.config.object_changes_adapter
+          if PaperTrail.config.object_changes_adapter&.respond_to?(:where_object_changes)
             return PaperTrail.config.object_changes_adapter.where_object_changes(
               @version_model_class, @attributes
             )

data/lib/paper_trail/record_trail.rb

@@ -1,72 +1,16 @@
 # frozen_string_literal: true
 
+require "paper_trail/events/create"
+require "paper_trail/events/destroy"
+require "paper_trail/events/update"
+
 module PaperTrail
   # Represents the "paper trail" for a single record.
   class RecordTrail
-    DPR_TOUCH_WITH_VERSION = <<-STR.squish.freeze
-      my_model.paper_trail.touch_with_version is deprecated, please use
-      my_model.paper_trail.save_with_version, which is slightly different. It's
-      a save, not a touch, so make sure you understand the difference by reading
-      the ActiveRecord documentation for both.
-    STR
-    DPR_WHODUNNIT = <<-STR.squish.freeze
-      my_model_instance.paper_trail.whodunnit('John') is deprecated,
-      please use PaperTrail.request(whodunnit: 'John')
-    STR
-    DPR_WITHOUT_VERSIONING = <<-STR
-      my_model_instance.paper_trail.without_versioning is deprecated, without
-      an exact replacement. To disable versioning for a particular model,
-
-      ```
-      PaperTrail.request.disable_model(Banana)
-      # changes to Banana model do not create versions,
-      # but eg. changes to Kiwi model do.
-      PaperTrail.request.enable_model(Banana)
-      ```
-
-      Or, you may want to disable all models,
-
-      ```
-      PaperTrail.request.enabled = false
-      # no versions created
-      PaperTrail.request.enabled = true
-
-      # or, with a block,
-      PaperTrail.request(enabled: false) do
-        # no versions created
-      end
-      ```
-    STR
-
     RAILS_GTE_5_1 = ::ActiveRecord.gem_version >= ::Gem::Version.new("5.1.0.beta1")
 
     def initialize(record)
       @record = record
-      @in_after_callback = false
-    end
-
-    def attributes_before_change(is_touch)
-      Hash[@record.attributes.map do |k, v|
-        if @record.class.column_names.include?(k)
-          [k, attribute_in_previous_version(k, is_touch)]
-        else
-          [k, v]
-        end
-      end]
-    end
-
-    def changed_and_not_ignored
-      ignore = @record.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(@record)
-          }
-      end
-      skip = @record.paper_trail_options[:skip]
-      changed_in_latest_version - ignore - skip
     end
 
     # Invoked after rollbacks to ensure versions records are not created for
@@ -83,29 +27,6 @@ module PaperTrail
       @record.send("#{@record.class.version_association_name}=", nil)
     end
 
-    # 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 = @record.send(:timestamp_attributes_for_update_in_model).map(&:to_s)
-        (notably_changed - timestamps).any?
-      else
-        notably_changed.any?
-      end
-    end
-
-    # @api private
-    def changes
-      notable_changes = changes_in_latest_version.delete_if { |k, _v|
-        !notably_changed.include?(k)
-      }
-      AttributeSerializers::ObjectChangesAttribute.
-        new(@record.class).
-        serialize(notable_changes)
-      notable_changes.to_hash
-    end
-
     # Is PT enabled for this particular record?
     # @api private
     def enabled?
@@ -114,77 +35,12 @@ module PaperTrail
         PaperTrail.request.enabled_for_model?(@record.class)
     end
 
-    # Not sure why, but this method was mentioned in the README in the past,
-    # so we need to deprecate it properly.
-    # @deprecated
-    def enabled_for_model?
-      ::ActiveSupport::Deprecation.warn(
-        "MyModel#paper_trail.enabled_for_model? is deprecated, use " \
-        "PaperTrail.request.enabled_for_model?(MyModel) instead.",
-        caller(1)
-      )
-      PaperTrail.request.enabled_for_model?(@record.class)
-    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.
-    def ignored_attr_has_changed?
-      ignored = @record.paper_trail_options[:ignore] + @record.paper_trail_options[:skip]
-      ignored.any? && (changed_in_latest_version & ignored).any?
-    end
-
     # Returns true if this instance is the current, live one;
     # returns false if this instance came from a previous version.
     def live?
       source_version.nil?
     end
 
-    # Updates `data` from the model's `meta` option and from `controller_info`.
-    # Metadata is always recorded; that means all three events (create, update,
-    # destroy) and `update_columns`.
-    # @api private
-    def merge_metadata_into(data)
-      merge_metadata_from_model_into(data)
-      merge_metadata_from_controller_into(data)
-    end
-
-    # Updates `data` from `controller_info`.
-    # @api private
-    def merge_metadata_from_controller_into(data)
-      data.merge(PaperTrail.request.controller_info || {})
-    end
-
-    # Updates `data` from the model's `meta` option.
-    # @api private
-    def merge_metadata_from_model_into(data)
-      @record.paper_trail_options[:meta].each do |k, v|
-        data[k] = model_metadatum(v, data[:event])
-      end
-    end
-
-    # Given a `value` from the model's `meta` option, returns an object to be
-    # persisted. The `value` can be a simple scalar value, but it can also
-    # be a symbol that names a model method, or even a Proc.
-    # @api private
-    def model_metadatum(value, event)
-      if value.respond_to?(:call)
-        value.call(@record)
-      elsif value.is_a?(Symbol) && @record.respond_to?(value, true)
-        # If it is an attribute that is changing in an existing object,
-        # be sure to grab the current version.
-        if event != "create" &&
-            @record.has_attribute?(value) &&
-            attribute_changed_in_latest_version?(value)
-          attribute_in_previous_version(value, false)
-        else
-          @record.send(value)
-        end
-      else
-        value
-      end
-    end
-
     # Returns the object (not a Version) as it became next.
     # NOTE: if self (the item) was not reified from a version, i.e. it is the
     #  "live" item, we return nil.  Perhaps we should return self instead?
@@ -195,30 +51,6 @@ module PaperTrail
       nil
     end
 
-    def notably_changed
-      only = @record.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(@record)
-          }
-      end
-      only.empty? ? changed_and_not_ignored : (changed_and_not_ignored & only)
-    end
-
-    # Returns hash of attributes (with appropriate attributes serialized),
-    # omitting attributes to be skipped.
-    #
-    # @api private
-    def object_attrs_for_paper_trail(is_touch)
-      attrs = attributes_before_change(is_touch).
-        except(*@record.paper_trail_options[:skip])
-      AttributeSerializers::ObjectAttribute.new(@record.class).serialize(attrs)
-      attrs
-    end
-
     # Returns who put `@record` into its current state.
     #
     # @api public
@@ -234,28 +66,22 @@ module PaperTrail
     end
 
     def record_create
-      @in_after_callback = true
       return unless enabled?
+      event = Events::Create.new(@record, true)
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_create` but PT-AT still does.
+      data = event.data.merge(data_for_create)
+
       versions_assoc = @record.send(@record.class.versions_association_name)
-      versions_assoc.create! data_for_create
-    ensure
-      @in_after_callback = false
+      versions_assoc.create!(data)
     end
 
-    # Returns data for record create
+    # PT-AT extends this method to add its transaction id.
+    #
     # @api private
     def data_for_create
-      data = {
-        event: @record.paper_trail_event || "create",
-        whodunnit: PaperTrail.request.whodunnit
-      }
-      if @record.respond_to?(:updated_at)
-        data[:created_at] = @record.updated_at
-      end
-      if record_object_changes? && changed_notably?
-        data[:object_changes] = recordable_object_changes(changes)
-      end
-      merge_metadata_into(data)
+      {}
     end
 
     # `recording_order` is "after" or "before". See ModelConfig#on_destroy.
@@ -264,77 +90,56 @@ module PaperTrail
     # @return - The created version object, so that plugins can use it, e.g.
     # paper_trail-association_tracking
     def record_destroy(recording_order)
-      @in_after_callback = recording_order == "after"
-      if enabled? && !@record.new_record?
-        version = @record.class.paper_trail.version_class.create(data_for_destroy)
-        if version.errors.any?
-          log_version_errors(version, :destroy)
-        else
-          @record.send("#{@record.class.version_association_name}=", version)
-          @record.send(@record.class.versions_association_name).reset
-          version
-        end
+      return unless enabled? && !@record.new_record?
+      in_after_callback = recording_order == "after"
+      event = Events::Destroy.new(@record, in_after_callback)
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_destroy` but PT-AT still does.
+      data = event.data.merge(data_for_destroy)
+
+      version = @record.class.paper_trail.version_class.create(data)
+      if version.errors.any?
+        log_version_errors(version, :destroy)
+      else
+        assign_and_reset_version_association(version)
+        version
       end
-    ensure
-      @in_after_callback = false
     end
 
-    # Returns data for record destroy
+    # PT-AT extends this method to add its transaction id.
+    #
     # @api private
     def data_for_destroy
-      data = {
-        item_id: @record.id,
-        item_type: @record.class.base_class.name,
-        event: @record.paper_trail_event || "destroy",
-        object: recordable_object(false),
-        whodunnit: PaperTrail.request.whodunnit
-      }
-      merge_metadata_into(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
     # @return - The created version object, so that plugins can use it, e.g.
     # paper_trail-association_tracking
     def record_update(force:, in_after_callback:, is_touch:)
-      @in_after_callback = in_after_callback
-      if enabled? && (force || changed_notably?)
-        versions_assoc = @record.send(@record.class.versions_association_name)
-        version = versions_assoc.create(data_for_update(is_touch))
-        if version.errors.any?
-          log_version_errors(version, :update)
-        else
-          version
-        end
+      return unless enabled?
+      event = Events::Update.new(@record, in_after_callback, is_touch, nil)
+      return unless force || event.changed_notably?
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_update` but PT-AT still does.
+      data = event.data.merge(data_for_update)
+
+      versions_assoc = @record.send(@record.class.versions_association_name)
+      version = versions_assoc.create(data)
+      if version.errors.any?
+        log_version_errors(version, :update)
+      else
+        version
       end
-    ensure
-      @in_after_callback = false
     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.
+    # PT-AT extends this method to add its transaction id.
     #
     # @api private
-    def data_for_update(is_touch)
-      data = {
-        event: @record.paper_trail_event || "update",
-        object: recordable_object(is_touch),
-        whodunnit: PaperTrail.request.whodunnit
-      }
-      if @record.respond_to?(:updated_at)
-        data[:created_at] = @record.updated_at
-      end
-      if record_object_changes?
-        data[:object_changes] = recordable_object_changes(changes)
-      end
-      merge_metadata_into(data)
+    def data_for_update
+      {}
     end
 
     # @api private
@@ -342,8 +147,14 @@ module PaperTrail
     # paper_trail-association_tracking
     def record_update_columns(changes)
       return unless enabled?
+      event = Events::Update.new(@record, false, false, changes)
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_update_columns` but PT-AT still does.
+      data = event.data.merge(data_for_update_columns)
+
       versions_assoc = @record.send(@record.class.versions_association_name)
-      version = versions_assoc.create(data_for_update_columns(changes))
+      version = versions_assoc.create(data)
       if version.errors.any?
         log_version_errors(version, :update)
       else
@@ -351,52 +162,11 @@ module PaperTrail
       end
     end
 
-    # Returns data for record_update_columns
-    # @api private
-    def data_for_update_columns(changes)
-      data = {
-        event: @record.paper_trail_event || "update",
-        object: recordable_object(false),
-        whodunnit: PaperTrail.request.whodunnit
-      }
-      if record_object_changes?
-        data[:object_changes] = recordable_object_changes(changes)
-      end
-      merge_metadata_into(data)
-    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`.
+    # PT-AT extends this method to add its transaction id.
     #
     # @api private
-    def recordable_object(is_touch)
-      if @record.class.paper_trail.version_class.object_col_is_json?
-        object_attrs_for_paper_trail(is_touch)
-      else
-        PaperTrail.serializer.dump(object_attrs_for_paper_trail(is_touch))
-      end
-    end
-
-    # 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 recordable_object_changes(changes)
-      if PaperTrail.config.object_changes_adapter
-        changes = PaperTrail.config.object_changes_adapter.diff(changes)
-      end
-
-      if @record.class.paper_trail.version_class.object_changes_col_is_json?
-        changes
-      else
-        PaperTrail.serializer.dump(changes)
-      end
+    def data_for_update_columns
+      {}
     end
 
     # Invoked via callback when a user attempts to persist a reified
@@ -420,38 +190,6 @@ module PaperTrail
       version
     end
 
-    # Mimics the `touch` method from `ActiveRecord::Persistence` (without
-    # actually calling `touch`), but also creates a version.
-    #
-    # A version is created regardless of options such as `:on`, `:if`, or
-    # `:unless`.
-    #
-    # This is an "update" event. That is, we record the same data we would in
-    # the case of a normal AR `update`.
-    #
-    # Some advanced PT users disable all callbacks (eg. `has_paper_trail(on:
-    # [])`) and use only this method, giving them complete control over when
-    # version records are inserted. It's unclear under which specific
-    # circumstances this technique should be adopted.
-    #
-    # @deprecated
-    def touch_with_version(name = nil)
-      ::ActiveSupport::Deprecation.warn(DPR_TOUCH_WITH_VERSION, caller(1))
-      unless @record.persisted?
-        raise ::ActiveRecord::ActiveRecordError, "can not touch on a new record object"
-      end
-      attributes = @record.send :timestamp_attributes_for_update_in_model
-      attributes << name if name
-      current_time = @record.send :current_time_from_proper_timezone
-      attributes.each { |column|
-        @record.send(:write_attribute, column, current_time)
-      }
-      ::PaperTrail.request(enabled: false) do
-        @record.save!(validate: false)
-      end
-      record_update(force: true, in_after_callback: false, is_touch: false)
-    end
-
     # Save, and create a version record regardless of options such as `:on`,
     # `:if`, or `:unless`.
     #
@@ -459,12 +197,6 @@ module PaperTrail
     #
     # This is an "update" event. That is, we record the same data we would in
     # the case of a normal AR `update`.
-    #
-    # In older versions of PaperTrail, a method named `touch_with_version` was
-    # used for this purpose. `save_with_version` is not exactly the same.
-    # First, the arguments are different. It passes all arguments to `save`.
-    # Second, it doesn't set any timestamp attributes prior to the `save` the
-    # way `touch_with_version` did.
     def save_with_version(*args)
       ::PaperTrail.request(enabled: false) do
         @record.save(*args)
@@ -483,9 +215,10 @@ module PaperTrail
     # creates a version to record those changes.
     # @api public
     def update_columns(attributes)
-      # `@record.update_columns` skips dirty tracking, so we can't just use `@record.changes` or
-      # @record.saved_changes` from `ActiveModel::Dirty`. We need to build our own hash with the
-      # changes that will be made directly to the database.
+      # `@record.update_columns` skips dirty-tracking, so we can't just use
+      # `@record.changes` or @record.saved_changes` from `ActiveModel::Dirty`.
+      # We need to build our own hash with the changes that will be made
+      # directly to the database.
       changes = {}
       attributes.each do |k, v|
         changes[k] = [@record[k], v]
@@ -509,92 +242,12 @@ module PaperTrail
       versions.collect { |version| version_at(version.created_at) }
     end
 
-    # Executes the given method or block without creating a new version.
-    # @deprecated
-    def without_versioning(method = nil)
-      ::ActiveSupport::Deprecation.warn(DPR_WITHOUT_VERSIONING, caller(1))
-      paper_trail_was_enabled = PaperTrail.request.enabled_for_model?(@record.class)
-      PaperTrail.request.disable_model(@record.class)
-      if method
-        if respond_to?(method)
-          public_send(method)
-        else
-          @record.send(method)
-        end
-      else
-        yield @record
-      end
-    ensure
-      PaperTrail.request.enable_model(@record.class) if paper_trail_was_enabled
-    end
-
-    # @deprecated
-    def whodunnit(value)
-      raise ArgumentError, "expected to receive a block" unless block_given?
-      ::ActiveSupport::Deprecation.warn(DPR_WHODUNNIT, caller(1))
-      ::PaperTrail.request(whodunnit: value) do
-        yield @record
-      end
-    end
-
     private
 
-    # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-    # https://github.com/paper-trail-gem/paper_trail/pull/899
-    #
     # @api private
-    def attribute_changed_in_latest_version?(attr_name)
-      if @in_after_callback && RAILS_GTE_5_1
-        @record.saved_change_to_attribute?(attr_name.to_s)
-      else
-        @record.attribute_changed?(attr_name.to_s)
-      end
-    end
-
-    # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-    # https://github.com/paper-trail-gem/paper_trail/pull/899
-    #
-    # Event can be any of the three (create, update, destroy).
-    #
-    # @api private
-    def attribute_in_previous_version(attr_name, is_touch)
-      if RAILS_GTE_5_1
-        if @in_after_callback && !is_touch
-          # For most events, we want the original value of the attribute, before
-          # the last save.
-          @record.attribute_before_last_save(attr_name.to_s)
-        else
-          # We are either performing a `record_destroy` or a
-          # `record_update(is_touch: true)`.
-          @record.attribute_in_database(attr_name.to_s)
-        end
-      else
-        @record.attribute_was(attr_name.to_s)
-      end
-    end
-
-    # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-    # https://github.com/paper-trail-gem/paper_trail/pull/899
-    #
-    # @api private
-    def changed_in_latest_version
-      if @in_after_callback && RAILS_GTE_5_1
-        @record.saved_changes.keys
-      else
-        @record.changed
-      end
-    end
-
-    # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-    # https://github.com/paper-trail-gem/paper_trail/pull/899
-    #
-    # @api private
-    def changes_in_latest_version
-      if @in_after_callback && RAILS_GTE_5_1
-        @record.saved_changes
-      else
-        @record.changes
-      end
+    def assign_and_reset_version_association(version)
+      @record.send("#{@record.class.version_association_name}=", version)
+      @record.send(@record.class.versions_association_name).reset
     end
 
     def log_version_errors(version, action)