paper_trail 9.2.0 → 10.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2e53b5f5457783341505d9c0341c5fdc93c52191644db689260311c6c63de72
-  data.tar.gz: bd94edaeb1bd3ca9d329b925241c1fe8774e7f058e64f82e06411e04397833ae
+  metadata.gz: b53e84ebfeca4497e5ec413afd5db52751dcec8865d6b3282468fcdad0d8d5d8
+  data.tar.gz: a78df196db71dfa88c60709f22ea194f54902c66ff4a1fe90c4e5dabf89d6c74
 SHA512:
-  metadata.gz: 63d9377e20237a70d024e857f64dcd089126efc5bbce13f4dffc65a1c9f4d8210426269bfb60af9bdcdaa7d23211c2359d3a8676ceaa3346b0d0e414cd813ffd
-  data.tar.gz: 952ea2469901473c0fe66b5b5e6aaaf65070957c0211147c60372c5a172029415aea87c93c6daac2c00243a087aa4135ca304b0ac69ad0f32a1a4fb940543e50
+  metadata.gz: 2716b1c5ec7a22b549f2a932d1d9f34a53437cb8c4f862ce3dc7e881d71903fd568187efdd144226822444e8c19ecb0df8e92152899f87fd91d71e6571707f44
+  data.tar.gz: 0354eebcdc0994e107e02440b665d74bbe7e644b02629cf681542624691a01b691206accc7f47b081db2e0d58672ee394e1ebbffe75b9bb5410608a18acae631

data/lib/generators/paper_trail/install/USAGE

@@ -0,0 +1,3 @@
+Description:
+  Generates (but does not run) a migration to add a versions table. Also generates an initializer
+  file for configuring PaperTrail. See section 5.c. Generators in README.md for more information.

data/lib/generators/paper_trail/install/install_generator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../migration_generator"
+
+module PaperTrail
+  # Installs PaperTrail in a rails app.
+  class InstallGenerator < MigrationGenerator
+    # Class names of MySQL adapters.
+    # - `MysqlAdapter` - Used by gems: `mysql`, `activerecord-jdbcmysql-adapter`.
+    # - `Mysql2Adapter` - Used by `mysql2` gem.
+    MYSQL_ADAPTERS = [
+      "ActiveRecord::ConnectionAdapters::MysqlAdapter",
+      "ActiveRecord::ConnectionAdapters::Mysql2Adapter"
+    ].freeze
+
+    source_root File.expand_path("templates", __dir__)
+    class_option(
+      :with_changes,
+      type: :boolean,
+      default: false,
+      desc: "Store changeset (diff) with each version"
+    )
+
+    desc "Generates (but does not run) a migration to add a versions table." \
+         "  Also generates an initializer file for configuring PaperTrail." \
+         "  See section 5.c. Generators in README.md for more information."
+
+    def create_migration_file
+      add_paper_trail_migration("create_versions",
+        item_type_options: item_type_options,
+        versions_table_options: versions_table_options)
+      add_paper_trail_migration("add_object_changes_to_versions") if options.with_changes?
+    end
+
+    private
+
+    # MySQL 5.6 utf8mb4 limit is 191 chars for keys used in indexes.
+    # See https://github.com/paper-trail-gem/paper_trail/issues/651
+    def item_type_options
+      opt = { null: false }
+      opt[:limit] = 191 if mysql?
+      ", #{opt}"
+    end
+
+    def mysql?
+      MYSQL_ADAPTERS.include?(ActiveRecord::Base.connection.class.name)
+    end
+
+    # Even modern versions of MySQL still use `latin1` as the default character
+    # encoding. Many users are not aware of this, and run into trouble when they
+    # try to use PaperTrail in apps that otherwise tend to use UTF-8. Postgres, by
+    # comparison, uses UTF-8 except in the unusual case where the OS is configured
+    # with a custom locale.
+    #
+    # - https://dev.mysql.com/doc/refman/5.7/en/charset-applications.html
+    # - http://www.postgresql.org/docs/9.4/static/multibyte.html
+    #
+    # Furthermore, MySQL's original implementation of UTF-8 was flawed, and had
+    # to be fixed later by introducing a new charset, `utf8mb4`.
+    #
+    # - https://mathiasbynens.be/notes/mysql-utf8mb4
+    # - https://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html
+    #
+    def versions_table_options
+      if mysql?
+        ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/generators/paper_trail/{templates → install/templates}/create_versions.rb.erb

@@ -25,7 +25,7 @@ class CreateVersions < ActiveRecord::Migration<%= migration_version %>
       # the `created_at` column.
       # (https://dev.mysql.com/doc/refman/5.6/en/fractional-seconds.html)
       #
-      # MySQL users should also upgrade to rails 4.2, which is the first
+      # MySQL users should also upgrade to at least rails 4.2, which is the first
       # version of ActiveRecord with support for fractional seconds in MySQL.
       # (https://github.com/rails/rails/pull/14359)
       #

data/lib/generators/paper_trail/migration_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module PaperTrail
+  # Basic structure to support a generator that builds a migration
+  class MigrationGenerator < ::Rails::Generators::Base
+    include ::Rails::Generators::Migration
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    protected
+
+    def add_paper_trail_migration(template, extra_options = {})
+      migration_dir = File.expand_path("db/migrate")
+      if self.class.migration_exists?(migration_dir, template)
+        ::Kernel.warn "Migration already exists: #{template}"
+      else
+        migration_template(
+          "#{template}.rb.erb",
+          "db/migrate/#{template}.rb",
+          { migration_version: migration_version }.merge(extra_options)
+        )
+      end
+    end
+
+    def migration_version
+      major = ActiveRecord::VERSION::MAJOR
+      if major >= 5
+        "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/paper_trail/update_item_subtype/USAGE

@@ -0,0 +1,4 @@
+Description:
+  Generates (but does not run) a migration to update item_type for STI entries
+  in an existing versions table. See section 5.c. Generators in README.md for
+  more information.

data/lib/generators/paper_trail/update_item_subtype/templates/update_versions_for_item_subtype.rb.erb

@@ -0,0 +1,85 @@
+# This migration updates existing `versions` that have `item_type` that refers to
+# the base_class, and changes them to refer to the subclass instead.
+class UpdateVersionsForItemSubtype < ActiveRecord::Migration<%= migration_version %>
+  include ActionView::Helpers::TextHelper
+  def up
+<%=
+  # Returns class, column, range
+  def self.parse_custom_entry(text)
+    parts = text.split("):")
+    range = parts.last.split("..").map(&:to_i)
+    range = Range.new(range.first, range.last)
+    parts.first.split("(") + [range]
+  end
+  # Running:
+  #   rails g paper_trail:update_item_subtype Animal(species):1..4 Plant(genus):42..1337
+  # results in:
+  #   # Versions of item_type "Animal" with IDs between 1 and 4 will be updated based on `species`
+  #   # Versions of item_type "Plant" with IDs between 42 and 1337 will be updated based on `genus`
+  #   hints = {"Animal"=>{1..4=>"species"}, "Plant"=>{42..1337=>"genus"}}
+  hint_descriptions = ""
+  hints = args.inject(Hash.new{|h, k| h[k] = {}}) do |s, v|
+    klass, column, range = parse_custom_entry(v)
+    hint_descriptions << "    # Versions of item_type \"#{klass}\" with IDs between #{
+      range.first} and #{range.last} will be updated based on \`#{column}\`\n"
+    s[klass][range] = column
+    s
+  end
+
+  unless hints.empty?
+    "#{hint_descriptions}    hints = #{hints.inspect}\n"
+  end
+%>
+    # Find all ActiveRecord models mentioned in existing versions
+    changes = Hash.new { |h, k| h[k] = [] }
+    model_names = PaperTrail::Version.select(:item_type).distinct
+    model_names.map(&:item_type).each do |model_name|
+      hint = hints[model_name] if defined?(hints)
+      begin
+        klass = model_name.constantize
+        # Actually implements an inheritance_column?  (Usually "type")
+        has_inheritance_column = klass.columns.map(&:name).include?(klass.inheritance_column)
+        # Find domain of types stored in PaperTrail versions
+        PaperTrail::Version.where(item_type: model_name, item_subtype: nil).select(:id, :object, :object_changes).each do |obj|
+          if (object_detail = PaperTrail.serializer.load(obj.object || obj.object_changes))
+            is_found = false
+            subtype_name = nil
+            hint&.each do |k, v|
+              if k === obj.id && (subtype_name = object_detail[v])
+                break
+              end
+            end
+            if subtype_name.nil? && has_inheritance_column
+              subtype_name = object_detail[klass.inheritance_column]
+            end
+            if subtype_name
+              subtype_name = subtype_name.last if subtype_name.is_a?(Array)
+              if subtype_name != model_name
+                changes[subtype_name] << obj.id
+              end
+            end
+          end
+        end
+      rescue NameError => ex
+        say "Skipping reference to #{model_name}", subitem: true
+      end
+    end
+    changes.each do |k, v|
+      # Update in blocks of up to 100 at a time
+      block_of_ids = []
+      id_count = 0
+      num_updated = 0
+      v.sort.each do |id|
+        block_of_ids << id
+        if (id_count += 1) % 100 == 0
+          num_updated += PaperTrail::Version.where(id: block_of_ids).update_all(item_subtype: k)
+          block_of_ids = []
+        end
+      end
+      num_updated += PaperTrail::Version.where(id: block_of_ids).update_all(item_subtype: k)
+      if num_updated > 0
+        say "Associated #{pluralize(num_updated, 'record')} to #{k}", subitem: true
+      end
+    end
+  end
+end

data/lib/generators/paper_trail/update_item_subtype/update_item_subtype_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../migration_generator"
+
+module PaperTrail
+  # Updates STI entries for PaperTrail
+  class UpdateItemSubtypeGenerator < MigrationGenerator
+    source_root File.expand_path("templates", __dir__)
+
+    desc "Generates (but does not run) a migration to update item_subtype for STI entries in an "\
+      "existing versions table."
+
+    def create_migration_file
+      add_paper_trail_migration("update_versions_for_item_subtype", sti_type_options: options)
+    end
+  end
+end

data/lib/paper_trail.rb

@@ -57,46 +57,6 @@ module PaperTrail
       !!PaperTrail.config.enabled
     end
 
-    # @deprecated
-    def enabled_for_controller=(value)
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.enabled_for_controller= is deprecated, " \
-        "use PaperTrail.request.enabled=",
-        caller(1)
-      )
-      request.enabled = value
-    end
-
-    # @deprecated
-    def enabled_for_controller?
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.enabled_for_controller? is deprecated, " \
-        "use PaperTrail.request.enabled?",
-        caller(1)
-      )
-      request.enabled?
-    end
-
-    # @deprecated
-    def enabled_for_model(model, value)
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.enabled_for_model is deprecated, " \
-        "use PaperTrail.request.enabled_for_model",
-        caller(1)
-      )
-      request.enabled_for_model(model, value)
-    end
-
-    # @deprecated
-    def enabled_for_model?(model)
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.enabled_for_model? is deprecated, " \
-        "use PaperTrail.request.enabled_for_model?",
-        caller(1)
-      )
-      request.enabled_for_model?(model)
-    end
-
     # Returns PaperTrail's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::PaperTrail::VERSION::STRING`.
     #
@@ -137,53 +97,6 @@ module PaperTrail
       raise(E_TIMESTAMP_FIELD_CONFIG)
     end
 
-    # @deprecated
-    def whodunnit=(value)
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.whodunnit= is deprecated, use PaperTrail.request.whodunnit=",
-        caller(1)
-      )
-      request.whodunnit = value
-    end
-
-    # @deprecated
-    def whodunnit(value = nil, &block)
-      if value.nil?
-        ::ActiveSupport::Deprecation.warn(
-          "PaperTrail.whodunnit is deprecated, use PaperTrail.request.whodunnit",
-          caller(1)
-        )
-        request.whodunnit
-      elsif block_given?
-        ::ActiveSupport::Deprecation.warn(
-          "Passing a block to PaperTrail.whodunnit is deprecated, " \
-          'use PaperTrail.request(whodunnit: "John") do .. end',
-          caller(1)
-        )
-        request(whodunnit: value, &block)
-      else
-        raise ArgumentError, "Invalid arguments"
-      end
-    end
-
-    # @deprecated
-    def controller_info=(value)
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.controller_info= is deprecated, use PaperTrail.request.controller_info=",
-        caller(1)
-      )
-      request.controller_info = value
-    end
-
-    # @deprecated
-    def controller_info
-      ::ActiveSupport::Deprecation.warn(
-        "PaperTrail.controller_info is deprecated, use PaperTrail.request.controller_info",
-        caller(1)
-      )
-      request.controller_info
-    end
-
     # Set the PaperTrail serializer. This setting affects all threads.
     # @api public
     def serializer=(value)
@@ -228,7 +141,3 @@ if defined?(::Rails)
 else
   require "paper_trail/frameworks/active_record"
 end
-
-# https://github.com/paper-trail-gem/paper_trail/issues/1070
-# https://github.com/westonganger/paper_trail-association_tracking/issues/2
-require "paper_trail-association_tracking"

data/lib/paper_trail/config.rb

@@ -8,8 +8,18 @@ module PaperTrail
   # configuration can be found in `paper_trail.rb`, others in `controller.rb`.
   class Config
     include Singleton
-    attr_accessor :serializer, :version_limit, :association_reify_error_behaviour,
-      :object_changes_adapter
+
+    E_PT_AT_REMOVED = <<-EOS.squish
+      Association Tracking for PaperTrail has been extracted to a seperate gem.
+      Please add `paper_trail-association_tracking` to your Gemfile.
+    EOS
+
+    attr_accessor(
+      :association_reify_error_behaviour,
+      :object_changes_adapter,
+      :serializer,
+      :version_limit
+    )
 
     def initialize
       # Variables which affect all threads, whose access is synchronized.
@@ -28,5 +38,21 @@ module PaperTrail
     def enabled=(enable)
       @mutex.synchronize { @enabled = enable }
     end
+
+    # In PT 10, the paper_trail-association_tracking gem was changed from a
+    # runtime dependency to a development dependency. We raise an error about
+    # this for the people who don't read changelogs.
+    #
+    # We raise a generic RuntimeError instead of a specific PT error class
+    # because there is no known use case where someone would want to rescue
+    # this. If we think of such a use case in the future we can revisit this
+    # decision.
+    def track_associations=(_)
+      raise E_PT_AT_REMOVED
+    end
+
+    def track_associations?
+      raise E_PT_AT_REMOVED
+    end
   end
 end

data/lib/paper_trail/events/base.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module Events
+    # We refer to times in the lifecycle of a record as "events". There are
+    # three events:
+    #
+    # - create
+    #   - `after_create` we call `RecordTrail#record_create`
+    # - update
+    #   - `after_update` we call `RecordTrail#record_update`
+    #   - `after_touch` we call `RecordTrail#record_update`
+    #   - `RecordTrail#save_with_version` calls `RecordTrail#record_update`
+    #   - `RecordTrail#update_columns` is also referred to as an update, though
+    #     it uses `RecordTrail#record_update_columns` rather than
+    #     `RecordTrail#record_update`
+    # - destroy
+    #   - `before_destroy` or `after_destroy` we call `RecordTrail#record_destroy`
+    #
+    # The value inserted into the `event` column of the versions table can also
+    # be overridden by the user, with `paper_trail_event`.
+    #
+    # @api private
+    class Base
+      RAILS_GTE_5_1 = ::ActiveRecord.gem_version >= ::Gem::Version.new("5.1.0.beta1")
+
+      # @api private
+      def initialize(record, in_after_callback)
+        @record = record
+        @in_after_callback = in_after_callback
+      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.
+      #
+      # @api private
+      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
+
+      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
+
+      # @api private
+      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
+
+      # 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
+
+      # @api private
+      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
+
+      # 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
+
+      # @api private
+      def prepare_object_changes(changes)
+        changes = serialize_object_changes(changes)
+        changes = recordable_object_changes(changes)
+        changes
+      end
+
+      # @api private
+      def serialize_object_changes(changes)
+        AttributeSerializers::ObjectChangesAttribute.
+          new(@record.class).
+          serialize(changes)
+        changes.to_hash
+      end
+
+      # @api private
+      def notable_changes
+        changes_in_latest_version.delete_if { |k, _v|
+          !notably_changed.include?(k)
+        }
+      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
+      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.
+      #
+      # @api private
+      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
+
+      # PT 10 has a new optional column, `item_subtype`
+      #
+      # @api private
+      def merge_item_subtype_into(data)
+        if @record.class.paper_trail.version_class.columns_hash.key?("item_subtype")
+          data.merge!(item_subtype: @record.class.name)
+        end
+      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
+
+      # @api private
+      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 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&.respond_to?(:diff)
+          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
+      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.class.paper_trail.version_class.column_names.include?("object_changes")
+      end
+
+      # Returns a boolean indicating whether to store the original object during save.
+      #
+      # @api private
+      def record_object?
+        @record.class.paper_trail.version_class.column_names.include?("object")
+      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 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
+    end
+  end
+end