paper_trail 4.0.2 → 4.1.0

data/doc/bug_report_template.rb

@@ -0,0 +1,65 @@
+# Use this template to report PaperTrail bugs.
+# It is based on the ActiveRecord template.
+# https://github.com/rails/rails/blob/master/guides/bug_report_templates/active_record_gem.rb
+begin
+  require 'bundler/inline'
+rescue LoadError => e
+  $stderr.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
+  raise e
+end
+
+gemfile(true) do
+  ruby '2.2.3'
+  source 'https://rubygems.org'
+  gem 'activerecord', '4.2.0'
+  gem 'minitest', '5.8.3'
+  gem 'paper_trail', '4.0.0', require: false
+  gem 'sqlite3'
+end
+
+require 'active_record'
+require 'minitest/autorun'
+require 'logger'
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+require 'paper_trail'
+
+ActiveRecord::Schema.define do
+  create_table :users, force: true do |t|
+    t.text :first_name, null: false
+    t.timestamps null: false
+  end
+  create_table :versions do |t|
+    t.string :item_type, null: false
+    t.integer :item_id, null: false
+    t.string :event, null: false
+    t.string :whodunnit
+    t.text :object, limit: 1_073_741_823
+    t.text :object_changes, limit: 1_073_741_823
+    t.integer :transaction_id
+    t.datetime :created_at
+  end
+  add_index :versions, [:item_type, :item_id]
+  add_index :versions, [:transaction_id]
+
+  create_table :version_associations do |t|
+    t.integer  :version_id
+    t.string   :foreign_key_name, null: false
+    t.integer  :foreign_key_id
+  end
+  add_index :version_associations, [:version_id]
+  add_index :version_associations, [:foreign_key_name, :foreign_key_id],
+    name: 'index_version_associations_on_foreign_key'
+end
+
+class User < ActiveRecord::Base
+  has_paper_trail
+end
+
+class BugTest < ActiveSupport::TestCase
+  def test_1
+    assert_difference(-> { PaperTrail::Version.count }, +1) {
+      User.create(first_name: "Jane")
+    }
+  end
+end

data/gemfiles/3.0.gemfile

@@ -4,6 +4,12 @@ gem 'activerecord', '~> 3.0'
 gem 'i18n', '~> 0.6.11'
 gem 'request_store', '~> 1.1.0'
 
+# actionpack 3 depends on rack-cache ~> 1.2, but bundler seems to ignore that.
+# Also rack-cache 1.3 dropped support for ruby 1.8.7. The simplest thing for now
+# was to specify rack-cache ~> 1.2 here, though it should be unnecessary given
+# the actionpack 3 dependency.
+gem 'rack-cache', '~> 1.2.0'
+
 group :development, :test do
   gem 'rake', '~> 10.1.1'
   gem 'shoulda', '~> 3.5'
@@ -23,13 +29,10 @@ group :development, :test do
   # To do proper transactional testing with ActiveSupport::TestCase on MySQL
   gem 'database_cleaner', '~> 1.2.0'
 
+  # Allow time travel in testing. timecop is only supported after 1.9.2 but does a better cleanup at 'return'
   if RUBY_VERSION < "1.9.2"
     gem 'delorean'
-
-    # rack-cache 1.3 drops ruby 1.8.7 support
-    gem 'rack-cache', '1.2'
   else
-    # timecop is only supported after 1.9.2 but does a better cleanup at 'return'
     gem 'timecop'
   end
 

data/lib/generators/paper_trail/templates/add_object_changes_to_versions.rb

@@ -5,6 +5,6 @@ class AddObjectChangesToVersions < ActiveRecord::Migration
   TEXT_BYTES = 1_073_741_823
 
   def change
-    add_column :versions, :object_changes, :text, limit: TEXT_BYTES
+    add_column :versions, :object_changes, :text, :limit => TEXT_BYTES
   end
 end

data/lib/generators/paper_trail/templates/create_versions.rb

@@ -13,6 +13,20 @@ class CreateVersions < ActiveRecord::Migration
       t.string   :event,     :null => false
       t.string   :whodunnit
       t.text     :object,    :limit => TEXT_BYTES
+
+      # Known issue in MySQL: fractional second precision
+      # -------------------------------------------------
+      #
+      # MySQL timestamp columns do not support fractional seconds unless
+      # defined with "fractional seconds precision". MySQL users should manually
+      # add fractional seconds precision to this migration, specifically, to
+      # 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
+      # version of ActiveRecord with support for fractional seconds in MySQL.
+      # (https://github.com/rails/rails/pull/14359)
+      #
       t.datetime :created_at
     end
     add_index :versions, [:item_type, :item_id]

data/lib/paper_trail.rb

@@ -1,6 +1,6 @@
 require 'request_store'
 
-# Require core library
+# Require files in lib/paper_trail, but not its subdirectories.
 Dir[File.join(File.dirname(__FILE__), 'paper_trail', '*.rb')].each do |file|
   require File.join('paper_trail', File.basename(file, '.rb'))
 end
@@ -24,11 +24,12 @@ module PaperTrail
     !!PaperTrail.config.enabled
   end
 
-  # ActiveRecord 5 drops support for serialized attributes; for previous
-  # versions of ActiveRecord it is supported, we have a config option
-  # to enable it within PaperTrail.
   def self.serialized_attributes?
-    !!PaperTrail.config.serialized_attributes && ::ActiveRecord::VERSION::MAJOR < 5
+    ActiveSupport::Deprecation.warn(
+      "PaperTrail.serialized_attributes? is deprecated without replacement " +
+        "and always returns false."
+    )
+    false
   end
 
   # Sets whether PaperTrail is enabled or disabled for the current request.
@@ -101,7 +102,8 @@ module PaperTrail
   end
 
   def self.active_record_protected_attributes?
-    @active_record_protected_attributes ||= ::ActiveRecord::VERSION::MAJOR < 4 || !!defined?(ProtectedAttributes)
+    @active_record_protected_attributes ||= ::ActiveRecord::VERSION::MAJOR < 4 ||
+      !!defined?(ProtectedAttributes)
   end
 
   def self.transaction?
@@ -126,9 +128,9 @@ module PaperTrail
 
   # Returns PaperTrail's configuration object.
   def self.config
-    @@config ||= PaperTrail::Config.instance
-    yield @@config if block_given?
-    @@config
+    @config ||= PaperTrail::Config.instance
+    yield @config if block_given?
+    @config
   end
 
   class << self

data/lib/paper_trail/attributes_serialization.rb

@@ -0,0 +1,89 @@
+module PaperTrail
+  module AttributesSerialization
+    class NoOpAttribute
+      def type_cast_for_database(value)
+        value
+      end
+
+      def type_cast_from_database(data)
+        data
+      end
+    end
+    NO_OP_ATTRIBUTE = NoOpAttribute.new
+
+    class SerializedAttribute
+      def initialize(coder)
+        @coder = coder.respond_to?(:dump) ? coder : PaperTrail.serializer
+      end
+
+      def type_cast_for_database(value)
+        @coder.dump(value)
+      end
+
+      def type_cast_from_database(data)
+        @coder.load(data)
+      end
+    end
+
+    SERIALIZE, DESERIALIZE =
+      if ::ActiveRecord::VERSION::MAJOR >= 5
+        [:serialize, :deserialize]
+      else
+        [:type_cast_for_database, :type_cast_from_database]
+      end
+
+    if ::ActiveRecord::VERSION::STRING < '4.2'
+      # Backport Rails 4.2 and later's `type_for_attribute` to build
+      # on a common interface.
+      def type_for_attribute(attr_name)
+        serialized_attribute_types[attr_name.to_s] || NO_OP_ATTRIBUTE
+      end
+
+      def serialized_attribute_types
+        @attribute_types ||= Hash[serialized_attributes.map do |attr_name, coder|
+          [attr_name, SerializedAttribute.new(coder)]
+        end]
+      end
+      private :serialized_attribute_types
+    end
+
+    # Used for `Version#object` attribute.
+    def serialize_attributes_for_paper_trail!(attributes)
+      alter_attributes_for_paper_trail!(SERIALIZE, attributes)
+    end
+
+    def unserialize_attributes_for_paper_trail!(attributes)
+      alter_attributes_for_paper_trail!(DESERIALIZE, attributes)
+    end
+
+    def alter_attributes_for_paper_trail!(serializer, attributes)
+      # Don't serialize before values before inserting into columns of type
+      # `JSON` on `PostgreSQL` databases.
+      return attributes if paper_trail_version_class.object_col_is_json?
+
+      attributes.each do |key, value|
+        attributes[key] = type_for_attribute(key).send(serializer, value)
+      end
+    end
+
+    # Used for Version#object_changes attribute.
+    def serialize_attribute_changes_for_paper_trail!(changes)
+      alter_attribute_changes_for_paper_trail!(SERIALIZE, changes)
+    end
+
+    def unserialize_attribute_changes_for_paper_trail!(changes)
+      alter_attribute_changes_for_paper_trail!(DESERIALIZE, changes)
+    end
+
+    def alter_attribute_changes_for_paper_trail!(serializer, changes)
+      # Don't serialize before values before inserting into columns of type
+      # `JSON` on `PostgreSQL` databases.
+      return changes if paper_trail_version_class.object_changes_col_is_json?
+
+      changes.clone.each do |key, change|
+        type = type_for_attribute(key)
+        changes[key] = Array(change).map { |value| type.send(serializer, value) }
+      end
+    end
+  end
+end

data/lib/paper_trail/cleaner.rb

@@ -16,7 +16,7 @@ module PaperTrail
     def clean_versions!(options = {})
       options = {:keeping => 1, :date => :all}.merge(options)
       gather_versions(options[:item_id], options[:date]).each do |item_id, versions|
-        versions.group_by { |v| v.send(PaperTrail.timestamp_field).to_date }.each do |date, _versions|
+        group_versions_by_date(versions).each do |date, _versions|
           # Remove the number of versions we wish to keep from the collection
           # of versions prior to destruction.
           _versions.pop(options[:keeping])
@@ -41,5 +41,12 @@ module PaperTrail
       versions = PaperTrail::Version.all if versions == PaperTrail::Version
       versions.group_by(&:item_id)
     end
+
+    # Given an array of versions, returns a hash mapping dates to arrays of
+    # versions.
+    # @api private
+    def group_versions_by_date(versions)
+      versions.group_by { |v| v.send(PaperTrail.timestamp_field).to_date }
+    end
   end
 end

data/lib/paper_trail/config.rb

@@ -5,30 +5,26 @@ module PaperTrail
   class Config
     include Singleton
     attr_accessor :timestamp_field, :serializer, :version_limit
-    attr_reader :serialized_attributes
     attr_writer :track_associations
 
     def initialize
       @timestamp_field = :created_at
       @serializer      = PaperTrail::Serializers::YAML
+    end
 
-      # This setting only defaults to false on AR 4.2+, because that's when
-      # it was deprecated. We want it to function with older versions of
-      # ActiveRecord by default.
-      if ::ActiveRecord::VERSION::STRING < '4.2'
-        @serialized_attributes = true
-      end
+    def serialized_attributes
+      ActiveSupport::Deprecation.warn(
+        "PaperTrail.config.serialized_attributes is deprecated without " +
+          "replacement and always returns false."
+      )
+      false
     end
 
-    def serialized_attributes=(value)
-      if ::ActiveRecord::VERSION::MAJOR >= 5
-        ::ActiveSupport::Deprecation.warn(
-          "ActiveRecord 5.0 deprecated `serialized_attributes` "  +
-          "without replacement, so this PaperTrail config setting does " +
-          "nothing with this version, and is always turned off"
-        )
-      end
-      @serialized_attributes = value
+    def serialized_attributes=(_)
+      ActiveSupport::Deprecation.warn(
+        "PaperTrail.config.serialized_attributes= is deprecated without " +
+          "replacement and no longer has any effect."
+      )
     end
 
     def track_associations
@@ -38,9 +34,10 @@ module PaperTrail
     end
     alias_method :track_associations?, :track_associations
 
-    # Indicates whether PaperTrail is on or off.
+    # Indicates whether PaperTrail is on or off. Default: true.
     def enabled
-      PaperTrail.paper_trail_store[:paper_trail_enabled].nil? || PaperTrail.paper_trail_store[:paper_trail_enabled]
+      value = PaperTrail.paper_trail_store.fetch(:paper_trail_enabled, true)
+      value.nil? ? true : value
     end
 
     def enabled= enable

data/lib/paper_trail/frameworks/rails/controller.rb

@@ -3,8 +3,22 @@ module PaperTrail
     module Controller
 
       def self.included(base)
-        base.before_filter :set_paper_trail_enabled_for_controller
-        base.before_filter :set_paper_trail_whodunnit, :set_paper_trail_controller_info
+        before = [
+          :set_paper_trail_enabled_for_controller,
+          :set_paper_trail_whodunnit,
+          :set_paper_trail_controller_info
+        ]
+        after = []
+
+        if base.respond_to? :before_action
+          # Rails 4+
+          before.map {|sym| base.before_action sym }
+          after.map  {|sym| base.after_action  sym }
+        else
+          # Rails 3.
+          before.map {|sym| base.before_filter sym }
+          after.map  {|sym| base.after_filter  sym }
+        end
       end
 
       protected

data/lib/paper_trail/has_paper_trail.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/object' # provides the `try` method
+require 'paper_trail/attributes_serialization'
 
 module PaperTrail
   module Model
@@ -46,9 +47,22 @@ module PaperTrail
       #   column if it exists. Default is true
       #
       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]
+      end
+
+      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
+        send :extend, AttributesSerialization
 
         class_attribute :version_association_name
         self.version_association_name = options[:version] || :version
@@ -60,6 +74,7 @@ module PaperTrail
         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|
@@ -87,26 +102,53 @@ module PaperTrail
             :order      => self.paper_trail_version_class.timestamp_sort_order
         end
 
-        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])
-
-        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!
-        end
-        after_destroy :record_destroy, :if => :save_version? if options_on.include?(:destroy)
-
         # 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
 
+      def setup_callbacks_from_options(options_on = [])
+        options_on.each do |option|
+          send "paper_trail_on_#{option}"
+        end
+      end
+
+      # Record version before or after "destroy" event
+      def paper_trail_on_destroy(recording_order = 'after')
+        unless %w[after before].include?(recording_order.to_s)
+          fail ArgumentError, 'recording order can only be "after" or "before"'
+        end
+
+        send "#{recording_order}_destroy",
+             :record_destroy,
+             :if => :save_version?
+
+        return if paper_trail_options[:on].include?(:destroy)
+        paper_trail_options[:on] << :destroy
+      end
+
+      # 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!
+
+        return if paper_trail_options[:on].include?(:update)
+        paper_trail_options[:on] << :update
+      end
+
+      # Record version after "create" event
+      def paper_trail_on_create
+        after_create :record_create,
+                     :if => :save_version?
+
+        return if paper_trail_options[:on].include?(:create)
+        paper_trail_options[:on] << :create
+      end
+
       # Switches PaperTrail off for this class.
       def paper_trail_off!
         PaperTrail.enabled_for_model(self, false)
@@ -125,74 +167,6 @@ module PaperTrail
       def paper_trail_version_class
         @paper_trail_version_class ||= version_class_name.constantize
       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?
-
-        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
-      end
-
-      # TODO: There is a lot of duplication between this and
-      # `serialize_attributes_for_paper_trail!`.
-      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?
-
-        serialized_attributes.each do |key, coder|
-          if attributes.key?(key)
-            # Fall back to current serializer if `coder` has no `dump` method.
-            # TODO: Shouldn't this be `:load`?
-            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
-            attributes[key] = coder.load(attributes[key])
-          end
-        end
-      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?
-
-        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
-      end
-
-      # TODO: There is a lot of duplication between this and
-      # `serialize_attribute_changes_for_paper_trail!`.
-      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?
-
-        serialized_attributes.each do |key, coder|
-          if changes.key?(key)
-            # Fall back to current serializer if `coder` has no `dump` method.
-            # TODO: Shouldn't this be `:load`?
-            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
-      end
     end
 
     # Wrap the following methods in a module so we can include them only in the
@@ -291,7 +265,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)
@@ -329,9 +303,8 @@ module PaperTrail
           if respond_to?(:updated_at)
             data[PaperTrail.timestamp_field] = updated_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 pt_record_object_changes? && changed_notably?
+            data[:object_changes] = pt_recordable_object_changes
           end
           if self.class.paper_trail_version_class.column_names.include?('transaction_id')
             data[:transaction_id] = PaperTrail.transaction_id
@@ -344,18 +317,16 @@ module PaperTrail
 
       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),
+            :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)
+          if pt_record_object_changes?
+            data[:object_changes] = pt_recordable_object_changes
           end
           if self.class.paper_trail_version_class.column_names.include?('transaction_id')
             data[:transaction_id] = PaperTrail.transaction_id
@@ -366,11 +337,46 @@ module PaperTrail
         end
       end
 
+      # 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
+        object_attrs = object_attrs_for_paper_trail(attributes_before_change)
+        if self.class.paper_trail_version_class.object_col_is_json?
+          object_attrs
+        else
+          PaperTrail.serializer.dump(object_attrs)
+        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 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
         _changes = changes.delete_if { |k,v| !notably_changed.include?(k) }
-        if PaperTrail.serialized_attributes?
-          self.class.serialize_attribute_changes_for_paper_trail!(_changes)
-        end
+        self.class.serialize_attribute_changes_for_paper_trail!(_changes)
         _changes.to_hash
       end
 
@@ -397,12 +403,11 @@ module PaperTrail
 
       def record_destroy
         if paper_trail_switched_on? and not new_record?
-          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
           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),
+            :object    => pt_recordable_object,
             :whodunnit => PaperTrail.whodunnit
           }
           if self.class.paper_trail_version_class.column_names.include?('transaction_id')
@@ -488,9 +493,7 @@ module PaperTrail
       # 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
+        self.class.serialize_attributes_for_paper_trail!(attrs)
         attrs
       end