paper_trail 5.2.3 → 6.0.0

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

@@ -103,7 +103,7 @@ module PaperTrail
             user_for_paper_trail is present, but whodunnit has not been set.
             PaperTrail no longer adds the set_paper_trail_whodunnit callback for
             you. To continue recording whodunnit, please add this before_action
-            callback to your ApplicationController . For more information,
+            callback to your ApplicationController. For more information,
             please see https://git.io/vrTsk
           EOS
         end

data/lib/paper_trail/frameworks/rspec.rb

@@ -27,3 +27,8 @@ RSpec::Matchers.define :have_a_version_with do |attributes|
   # check if the model has a version with the specified attributes
   match { |actual| actual.versions.where_object(attributes).any? }
 end
+
+RSpec::Matchers.define :have_a_version_with_changes do |attributes|
+  # check if the model has a version changes with the specified attributes
+  match { |actual| actual.versions.where_object_changes(attributes).any? }
+end

data/lib/paper_trail/has_paper_trail.rb

@@ -69,306 +69,15 @@ module PaperTrail
       def paper_trail
         ::PaperTrail::ModelConfig.new(self)
       end
-
-      # @api private
-      def paper_trail_deprecate(new_method, old_method = nil)
-        old = old_method.nil? ? new_method : old_method
-        msg = format("Use paper_trail.%s instead of %s", new_method, old)
-        ::ActiveSupport::Deprecation.warn(msg, caller(2))
-      end
-
-      # @deprecated
-      def paper_trail_on_destroy(*args)
-        paper_trail_deprecate "on_destroy", "paper_trail_on_destroy"
-        paper_trail.on_destroy(*args)
-      end
-
-      # @deprecated
-      def paper_trail_on_update
-        paper_trail_deprecate "on_update", "paper_trail_on_update"
-        paper_trail.on_update
-      end
-
-      # @deprecated
-      def paper_trail_on_create
-        paper_trail_deprecate "on_create", "paper_trail_on_create"
-        paper_trail.on_create
-      end
-
-      # @deprecated
-      def paper_trail_off!
-        paper_trail_deprecate "disable", "paper_trail_off!"
-        paper_trail.disable
-      end
-
-      # @deprecated
-      def paper_trail_on!
-        paper_trail_deprecate "enable", "paper_trail_on!"
-        paper_trail.enable
-      end
-
-      # @deprecated
-      def paper_trail_enabled_for_model?
-        paper_trail_deprecate "enabled?", "paper_trail_enabled_for_model?"
-        paper_trail.enabled?
-      end
-
-      # @deprecated
-      def paper_trail_version_class
-        paper_trail_deprecate "version_class", "paper_trail_version_class"
-        paper_trail.version_class
-      end
     end
 
     # Wrap the following methods in a module so we can include them only in the
     # ActiveRecord models that declare `has_paper_trail`.
     module InstanceMethods
+      # @api public
       def paper_trail
         ::PaperTrail::RecordTrail.new(self)
       end
-
-      # @deprecated
-      def live?
-        self.class.paper_trail_deprecate "live?"
-        paper_trail.live?
-      end
-
-      # @deprecated
-      def paper_trail_originator
-        self.class.paper_trail_deprecate "originator", "paper_trail_originator"
-        paper_trail.originator
-      end
-
-      # @deprecated
-      def originator
-        self.class.paper_trail_deprecate "originator"
-        paper_trail.originator
-      end
-
-      # @deprecated
-      def clear_rolled_back_versions
-        self.class.paper_trail_deprecate "clear_rolled_back_versions"
-        paper_trail.clear_rolled_back_versions
-      end
-
-      # @deprecated
-      def source_version
-        self.class.paper_trail_deprecate "source_version"
-        paper_trail.source_version
-      end
-
-      # @deprecated
-      def version_at(*args)
-        self.class.paper_trail_deprecate "version_at"
-        paper_trail.version_at(*args)
-      end
-
-      # @deprecated
-      def versions_between(start_time, end_time, _reify_options = {})
-        self.class.paper_trail_deprecate "versions_between"
-        paper_trail.versions_between(start_time, end_time)
-      end
-
-      # @deprecated
-      def previous_version
-        self.class.paper_trail_deprecate "previous_version"
-        paper_trail.previous_version
-      end
-
-      # @deprecated
-      def next_version
-        self.class.paper_trail_deprecate "next_version"
-        paper_trail.next_version
-      end
-
-      # @deprecated
-      def paper_trail_enabled_for_model?
-        self.class.paper_trail_deprecate "enabled_for_model?", "paper_trail_enabled_for_model?"
-        paper_trail.enabled_for_model?
-      end
-
-      # @deprecated
-      def without_versioning(method = nil, &block)
-        self.class.paper_trail_deprecate "without_versioning"
-        paper_trail.without_versioning(method, &block)
-      end
-
-      # @deprecated
-      def appear_as_new_record(&block)
-        self.class.paper_trail_deprecate "appear_as_new_record"
-        paper_trail.appear_as_new_record(&block)
-      end
-
-      # @deprecated
-      def whodunnit(value, &block)
-        self.class.paper_trail_deprecate "whodunnit"
-        paper_trail.whodunnit(value, &block)
-      end
-
-      # @deprecated
-      def touch_with_version(name = nil)
-        self.class.paper_trail_deprecate "touch_with_version"
-        paper_trail.touch_with_version(name)
-      end
-
-      # `record_create` is deprecated in favor of `paper_trail.record_create`,
-      # but does not yet print a deprecation warning. When the `after_create`
-      # callback is registered (by ModelConfig#on_create) we still refer to this
-      # method by name, e.g.
-      #
-      #     @model_class.after_create :record_create, if: :save_version?
-      #
-      # instead of using the preferred method `paper_trail.record_create`, e.g.
-      #
-      #     @model_class.after_create { |r| r.paper_trail.record_create if r.save_version?}
-      #
-      # We still register the callback by name so that, if someone calls
-      # `has_paper_trail` twice, the callback will *not* be registered twice.
-      # Our own test suite calls `has_paper_trail` many times for the same
-      # class.
-      #
-      # In the future, perhaps we should require that users only set up
-      # PT once per class.
-      #
-      # @deprecated
-      def record_create
-        paper_trail.record_create
-      end
-
-      # See deprecation comment for `record_create`
-      # @deprecated
-      def record_update(force = nil)
-        paper_trail.record_update(force)
-      end
-
-      # @deprecated
-      def pt_record_object_changes?
-        self.class.paper_trail_deprecate "record_object_changes?", "pt_record_object_changes?"
-        paper_trail.record_object_changes?
-      end
-
-      # @deprecated
-      def pt_recordable_object
-        self.class.paper_trail_deprecate "recordable_object", "pt_recordable_object"
-        paper_trail.recordable_object
-      end
-
-      # @deprecated
-      def pt_recordable_object_changes
-        self.class.paper_trail_deprecate "recordable_object_changes", "pt_recordable_object_changes"
-        paper_trail.recordable_object_changes
-      end
-
-      # @deprecated
-      def changes_for_paper_trail
-        self.class.paper_trail_deprecate "changes", "changes_for_paper_trail"
-        paper_trail.changes
-      end
-
-      # See deprecation comment for `record_create`
-      # @deprecated
-      def clear_version_instance!
-        paper_trail.clear_version_instance
-      end
-
-      # See deprecation comment for `record_create`
-      # @deprecated
-      def reset_timestamp_attrs_for_update_if_needed!
-        paper_trail.reset_timestamp_attrs_for_update_if_needed
-      end
-
-      # See deprecation comment for `record_create`
-      # @deprecated
-      def record_destroy
-        paper_trail.record_destroy
-      end
-
-      # @deprecated
-      def save_associations(version)
-        self.class.paper_trail_deprecate "save_associations"
-        paper_trail.save_associations(version)
-      end
-
-      # @deprecated
-      def save_associations_belongs_to(version)
-        self.class.paper_trail_deprecate "save_associations_belongs_to"
-        paper_trail.save_associations_belongs_to(version)
-      end
-
-      # @deprecated
-      def save_associations_has_and_belongs_to_many(version)
-        self.class.paper_trail_deprecate(
-          "save_associations_habtm",
-          "save_associations_has_and_belongs_to_many"
-        )
-        paper_trail.save_associations_habtm(version)
-      end
-
-      # @deprecated
-      # @api private
-      def reset_transaction_id
-        ::ActiveSupport::Deprecation.warn(
-          "reset_transaction_id is deprecated, use PaperTrail.clear_transaction_id"
-        )
-        PaperTrail.clear_transaction_id
-      end
-
-      # @deprecated
-      # @api private
-      def merge_metadata(data)
-        self.class.paper_trail_deprecate "merge_metadata"
-        paper_trail.merge_metadata(data)
-      end
-
-      # @deprecated
-      def attributes_before_change
-        self.class.paper_trail_deprecate "attributes_before_change"
-        paper_trail.attributes_before_change
-      end
-
-      # @deprecated
-      def object_attrs_for_paper_trail
-        self.class.paper_trail_deprecate "object_attrs_for_paper_trail"
-        paper_trail.object_attrs_for_paper_trail
-      end
-
-      # @deprecated
-      def changed_notably?
-        self.class.paper_trail_deprecate "changed_notably?"
-        paper_trail.changed_notably?
-      end
-
-      # @deprecated
-      def ignored_attr_has_changed?
-        self.class.paper_trail_deprecate "ignored_attr_has_changed?"
-        paper_trail.ignored_attr_has_changed?
-      end
-
-      # @deprecated
-      def notably_changed
-        self.class.paper_trail_deprecate "notably_changed"
-        paper_trail.notably_changed
-      end
-
-      # @deprecated
-      def changed_and_not_ignored
-        self.class.paper_trail_deprecate "changed_and_not_ignored"
-        paper_trail.changed_and_not_ignored
-      end
-
-      # The new method is named "enabled?" for consistency.
-      # @deprecated
-      def paper_trail_switched_on?
-        self.class.paper_trail_deprecate "enabled?", "paper_trail_switched_on?"
-        paper_trail.enabled?
-      end
-
-      # @deprecated
-      # @api private
-      def save_version?
-        self.class.paper_trail_deprecate "save_version?"
-        paper_trail.save_version?
-      end
     end
   end
 end

data/lib/paper_trail/model_config.rb

@@ -31,7 +31,9 @@ module PaperTrail
 
     # Adds a callback that records a version after a "create" event.
     def on_create
-      @model_class.after_create :record_create, if: ->(m) { m.paper_trail.save_version? }
+      @model_class.after_create { |r|
+        r.paper_trail.record_create if r.paper_trail.save_version?
+      }
       return if @model_class.paper_trail_options[:on].include?(:create)
       @model_class.paper_trail_options[:on] << :create
     end
@@ -46,8 +48,10 @@ module PaperTrail
         ::ActiveSupport::Deprecation.warn(E_CANNOT_RECORD_AFTER_DESTROY)
       end
 
-      @model_class.send "#{recording_order}_destroy", :record_destroy,
-        if: ->(m) { m.paper_trail.save_version? }
+      @model_class.send(
+        "#{recording_order}_destroy",
+        ->(r) { r.paper_trail.record_destroy if r.paper_trail.save_version? }
+      )
 
       return if @model_class.paper_trail_options[:on].include?(:destroy)
       @model_class.paper_trail_options[:on] << :destroy
@@ -55,9 +59,15 @@ module PaperTrail
 
     # Adds a callback that records a version after an "update" event.
     def on_update
-      @model_class.before_save :reset_timestamp_attrs_for_update_if_needed!, on: :update
-      @model_class.after_update :record_update, if: ->(m) { m.paper_trail.save_version? }
-      @model_class.after_update :clear_version_instance!
+      @model_class.before_save(on: :update) { |r|
+        r.paper_trail.reset_timestamp_attrs_for_update_if_needed
+      }
+      @model_class.after_update { |r|
+        r.paper_trail.record_update(nil) if r.paper_trail.save_version?
+      }
+      @model_class.after_update { |r|
+        r.paper_trail.clear_version_instance
+      }
       return if @model_class.paper_trail_options[:on].include?(:update)
       @model_class.paper_trail_options[:on] << :update
     end
@@ -133,7 +143,7 @@ module PaperTrail
     end
 
     # Adds callbacks to record changes to habtm associations such that on save
-    # the previous version of the association (if changed) can be interpreted.
+    # the previous version of the association (if changed) can be reconstructed.
     def setup_callbacks_for_habtm(join_tables)
       @model_class.send :attr_accessor, :paper_trail_habtm
       @model_class.class_attribute :paper_trail_save_join_tables

data/lib/paper_trail/record_history.rb

@@ -26,7 +26,7 @@ module PaperTrail
         @versions.select(primary_key).order(primary_key.asc)
       else
         @versions.
-          select([timestamp, primary_key]).
+          select([table[:created_at], primary_key]).
           order(@version_class.timestamp_sort_order)
       end
     end
@@ -45,13 +45,5 @@ module PaperTrail
     def table
       @version_class.arel_table
     end
-
-    # @return - Arel::Attribute - Attribute representing the timestamp column
-    #   of the version table, usually named `created_at` (the rails convention)
-    #   but not always.
-    # @api private
-    def timestamp
-      table[PaperTrail.timestamp_field]
-    end
   end
 end

data/lib/paper_trail/record_trail.rb

@@ -1,26 +1,48 @@
 module PaperTrail
   # Represents the "paper trail" for a single record.
   class RecordTrail
+    RAILS_GTE_5_1 = ::ActiveRecord::VERSION::MAJOR >= 5 && ::ActiveRecord::VERSION::MINOR >= 1
+
     def initialize(record)
       @record = record
+      @in_after_callback = false
     end
 
     # Utility method for reifying. Anything executed inside the block will
     # appear like a new record.
+    #
+    # > .. as best as I can tell, the purpose of
+    # > appear_as_new_record was to attempt to prevent the callbacks in
+    # > AutosaveAssociation (which is the module responsible for persisting
+    # > foreign key changes earlier than most people want most of the time
+    # > because backwards compatibility or the maintainer hates himself or
+    # > something) from running. By also stubbing out persisted? we can
+    # > actually prevent those. A more stable option might be to use suppress
+    # > instead, similar to the other branch in reify_has_one.
+    # > -Sean Griffin (https://github.com/airblade/paper_trail/pull/899)
+    #
     def appear_as_new_record
       @record.instance_eval {
         alias :old_new_record? :new_record?
         alias :new_record? :present?
+        alias :old_persisted? :persisted?
+        alias :persisted? :nil?
       }
       yield
-      @record.instance_eval { alias :new_record? :old_new_record? }
+      @record.instance_eval {
+        alias :new_record? :old_new_record?
+        alias :persisted? :old_persisted?
+      }
     end
 
     def attributes_before_change
-      changed = @record.changed_attributes.select { |k, _v|
-        @record.class.column_names.include?(k)
-      }
-      @record.attributes.merge(changed)
+      Hash[@record.attributes.map do |k, v|
+        if @record.class.column_names.include?(k)
+          [k, attribute_in_previous_version(k)]
+        else
+          [k, v]
+        end
+      end]
     end
 
     def changed_and_not_ignored
@@ -34,7 +56,7 @@ module PaperTrail
           }
       end
       skip = @record.paper_trail_options[:skip]
-      @record.changed - ignore - skip
+      changed_in_latest_version - ignore - skip
     end
 
     # Invoked after rollbacks to ensure versions records are not created for
@@ -65,7 +87,7 @@ module PaperTrail
 
     # @api private
     def changes
-      notable_changes = @record.changes.delete_if { |k, _v|
+      notable_changes = changes_in_latest_version.delete_if { |k, _v|
         !notably_changed.include?(k)
       }
       AttributeSerializers::ObjectChangesAttribute.
@@ -87,7 +109,7 @@ module PaperTrail
     # changed.
     def ignored_attr_has_changed?
       ignored = @record.paper_trail_options[:ignore] + @record.paper_trail_options[:skip]
-      ignored.any? && (@record.changed & ignored).any?
+      ignored.any? && (changed_in_latest_version & ignored).any?
     end
 
     # Returns true if this instance is the current, live one;
@@ -107,9 +129,9 @@ module PaperTrail
             # If it is an attribute that is changing in an existing object,
             # be sure to grab the current version.
             if @record.has_attribute?(v) &&
-                @record.send("#{v}_changed?".to_sym) &&
+                attribute_changed_in_latest_version?(v) &&
                 data[:event] != "create"
-              @record.send("#{v}_was".to_sym)
+              attribute_in_previous_version(v)
             else
               @record.send(v)
             end
@@ -164,35 +186,36 @@ module PaperTrail
     end
 
     def record_create
+      @in_after_callback = true
       return unless enabled?
+      versions_assoc = @record.send(@record.class.versions_association_name)
+      version = versions_assoc.create! data_for_create
+      update_transaction_id(version)
+      save_associations(version)
+    ensure
+      @in_after_callback = false
+    end
+
+    # Returns data for record create
+    # @api private
+    def data_for_create
       data = {
         event: @record.paper_trail_event || "create",
         whodunnit: PaperTrail.whodunnit
       }
       if @record.respond_to?(:updated_at)
-        data[PaperTrail.timestamp_field] = @record.updated_at
+        data[:created_at] = @record.updated_at
       end
       if record_object_changes? && changed_notably?
         data[:object_changes] = recordable_object_changes
       end
       add_transaction_id_to(data)
-      versions_assoc = @record.send(@record.class.versions_association_name)
-      version = versions_assoc.create! merge_metadata(data)
-      update_transaction_id(version)
-      save_associations(version)
+      merge_metadata(data)
     end
 
     def record_destroy
       if enabled? && !@record.new_record?
-        data = {
-          item_id: @record.id,
-          item_type: @record.class.base_class.name,
-          event: @record.paper_trail_event || "destroy",
-          object: recordable_object,
-          whodunnit: PaperTrail.whodunnit
-        }
-        add_transaction_id_to(data)
-        version = @record.class.paper_trail.version_class.create(merge_metadata(data))
+        version = @record.class.paper_trail.version_class.create(data_for_destroy)
         if version.errors.any?
           log_version_errors(version, :destroy)
         else
@@ -204,6 +227,20 @@ module PaperTrail
       end
     end
 
+    # Returns data for record destroy
+    # @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,
+        whodunnit: PaperTrail.whodunnit
+      }
+      add_transaction_id_to(data)
+      merge_metadata(data)
+    end
+
     # Returns a boolean indicating whether to store serialized version diffs
     # in the `object_changes` column of the version record.
     # @api private
@@ -213,21 +250,10 @@ module PaperTrail
     end
 
     def record_update(force)
+      @in_after_callback = true
       if enabled? && (force || changed_notably?)
-        data = {
-          event: @record.paper_trail_event || "update",
-          object: recordable_object,
-          whodunnit: PaperTrail.whodunnit
-        }
-        if @record.respond_to?(:updated_at)
-          data[PaperTrail.timestamp_field] = @record.updated_at
-        end
-        if record_object_changes?
-          data[:object_changes] = recordable_object_changes
-        end
-        add_transaction_id_to(data)
         versions_assoc = @record.send(@record.class.versions_association_name)
-        version = versions_assoc.create(merge_metadata(data))
+        version = versions_assoc.create(data_for_update)
         if version.errors.any?
           log_version_errors(version, :update)
         else
@@ -235,6 +261,26 @@ module PaperTrail
           save_associations(version)
         end
       end
+    ensure
+      @in_after_callback = false
+    end
+
+    # Returns data for record update
+    # @api private
+    def data_for_update
+      data = {
+        event: @record.paper_trail_event || "update",
+        object: recordable_object,
+        whodunnit: PaperTrail.whodunnit
+      }
+      if @record.respond_to?(:updated_at)
+        data[:created_at] = @record.updated_at
+      end
+      if record_object_changes?
+        data[:object_changes] = recordable_object_changes
+      end
+      add_transaction_id_to(data)
+      merge_metadata(data)
     end
 
     # Returns an object which can be assigned to the `object` attribute of a
@@ -309,23 +355,19 @@ module PaperTrail
       end
     end
 
+    # When a record is created, updated, or destroyed, we determine what the
+    # HABTM associations looked like before any changes were made, by using
+    # the `paper_trail_habtm` data structure. Then, we create
+    # `VersionAssociation` records for each of the associated records.
     def save_associations_habtm(version)
-      # Use the :added and :removed keys to extrapolate the HABTM associations
-      # to before any changes were made
       @record.class.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|
-        next unless
-          @record.class.paper_trail_save_join_tables.include?(a.name) ||
-              a.klass.paper_trail.enabled?
-        assoc_version_args = {
-          version_id: version.transaction_id,
-          foreign_key_name: a.name
-        }
-        assoc_ids =
-          @record.send(a.name).to_a.map(&:id) +
-          (@record.paper_trail_habtm.try(:[], a.name).try(:[], :removed) || []) -
-          (@record.paper_trail_habtm.try(:[], a.name).try(:[], :added) || [])
-        assoc_ids.each do |id|
-          PaperTrail::VersionAssociation.create(assoc_version_args.merge(foreign_key_id: id))
+        next unless save_habtm_association?(a)
+        habtm_assoc_ids(a).each do |id|
+          PaperTrail::VersionAssociation.create(
+            version_id: version.transaction_id,
+            foreign_key_name: a.name,
+            foreign_key_id: id
+          )
         end
       end
     end
@@ -360,7 +402,7 @@ module PaperTrail
       attributes.each { |column|
         @record.send(:write_attribute, column, current_time)
       }
-      @record.record_update(true) unless will_record_after_update?
+      record_update(true) unless will_record_after_update?
       @record.save!(validate: false)
     end
 
@@ -376,9 +418,7 @@ module PaperTrail
     # Returns the objects (not Versions) as they were between the given times.
     def versions_between(start_time, end_time)
       versions = send(@record.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.created_at) }
     end
 
     # Executes the given method or block without creating a new version.
@@ -416,6 +456,51 @@ module PaperTrail
       data[:transaction_id] = PaperTrail.transaction_id
     end
 
+    # @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 attribute_in_previous_version(attr_name)
+      if @in_after_callback && RAILS_GTE_5_1
+        @record.attribute_before_last_save(attr_name.to_s)
+      else
+        @record.attribute_was(attr_name.to_s)
+      end
+    end
+
+    # @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 changes_in_latest_version
+      if @in_after_callback && RAILS_GTE_5_1
+        @record.saved_changes
+      else
+        @record.changes
+      end
+    end
+
+    # Given a HABTM association, returns an array of ids.
+    # @api private
+    def habtm_assoc_ids(habtm_assoc)
+      current = @record.send(habtm_assoc.name).to_a.map(&:id) # TODO: `pluck` would use less memory
+      removed = @record.paper_trail_habtm.try(:[], habtm_assoc.name).try(:[], :removed) || []
+      added = @record.paper_trail_habtm.try(:[], habtm_assoc.name).try(:[], :added) || []
+      current + removed - added
+    end
+
     def log_version_errors(version, action)
       version.logger.warn(
         "Unable to create version for #{action} of #{@record.class.name}" +
@@ -423,6 +508,13 @@ module PaperTrail
       )
     end
 
+    # Returns true if the given HABTM association should be saved.
+    # @api private
+    def save_habtm_association?(assoc)
+      @record.class.paper_trail_save_join_tables.include?(assoc.name) ||
+        assoc.klass.paper_trail.enabled?
+    end
+
     # Returns true if `save` will cause `record_update`
     # to be called via the `after_update` callback.
     def will_record_after_update?