paper_trail 4.0.2 → 4.1.0

data/lib/paper_trail/record_history.rb

@@ -0,0 +1,59 @@
+module PaperTrail
+
+  # Represents the history of a single record.
+  # @api private
+  class RecordHistory
+
+    # @param versions - ActiveRecord::Relation - All versions of the record.
+    # @param version_class - Class - Usually PaperTrail::Version,
+    #   but it could also be a custom version class.
+    # @api private
+    def initialize(versions, version_class)
+      @versions = versions
+      @version_class = version_class
+    end
+
+    # Returns ordinal position of `version` in `sequence`.
+    # @api private
+    def index(version)
+      sequence.index(version)
+    end
+
+    private
+
+    # Returns `@versions` in chronological order.
+    # @api private
+    def sequence
+      if @version_class.primary_key_is_int?
+        @versions.select(primary_key).order(primary_key.asc)
+      else
+        @versions.
+          select([timestamp, primary_key]).
+          order(@version_class.timestamp_sort_order)
+      end
+    end
+
+    # @return - Arel::Attribute - Attribute representing the primary key
+    #   of the version table. The column's data type is usually a serial
+    #   integer (the rails convention) but not always.
+    # @api private
+    def primary_key
+      table[@version_class.primary_key]
+    end
+
+    # @return - Arel::Table - The version table, usually named `versions`, but
+    #   not always.
+    # @api private
+    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/reifier.rb

@@ -0,0 +1,270 @@
+module PaperTrail
+
+  # Given a version record and some options, builds a new model object.
+  # @api private
+  module Reifier
+    class << self
+
+      # See `VersionConcern#reify` for documentation.
+      # @api private
+      def reify(version, options)
+        options = options.dup
+
+        options.reverse_merge!(
+          :version_at => version.created_at,
+          :mark_for_destruction => false,
+          :has_one    => false,
+          :has_many   => false,
+          :unversioned_attributes => :nil
+        )
+
+        attrs = version.class.object_col_is_json? ?
+          version.object :
+          PaperTrail.serializer.load(version.object)
+
+        # Normally a polymorphic belongs_to relationship allows us to get the
+        # object we belong to by calling, in this case, `item`.  However this
+        # returns nil if `item` has been destroyed, and we need to be able to
+        # retrieve destroyed objects.
+        #
+        # In this situation we constantize the `item_type` to get hold of the
+        # class...except when the stored object's attributes include a `type`
+        # key.  If this is the case, the object we belong to is using single
+        # table inheritance and the `item_type` will be the base class, not the
+        # actual subclass. If `type` is present but empty, the class is the base
+        # class.
+
+        if options[:dup] != true && version.item
+          model = version.item
+          # Look for attributes that exist in the model and not in this
+          # version. These attributes should be set to nil.
+          if options[:unversioned_attributes] == :nil
+            (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
+          end
+        else
+          inheritance_column_name = version.item_type.constantize.inheritance_column
+          class_name = attrs[inheritance_column_name].blank? ?
+            version.item_type :
+            attrs[inheritance_column_name]
+          klass = class_name.constantize
+          # The `dup` option always returns a new object, otherwise we should
+          # attempt to look for the item outside of default scope(s).
+          if options[:dup] || (_item = klass.unscoped.find_by_id(version.item_id)).nil?
+            model = klass.new
+          elsif options[:unversioned_attributes] == :nil
+            model = _item
+            # Look for attributes that exist in the model and not in this
+            # version. These attributes should be set to nil.
+            (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
+          end
+        end
+
+        model.class.unserialize_attributes_for_paper_trail! attrs
+
+        # Set all the attributes in this version on the model.
+        attrs.each do |k, v|
+          if model.has_attribute?(k)
+            model[k.to_sym] = v
+          elsif model.respond_to?("#{k}=")
+            model.send("#{k}=", v)
+          else
+            version.logger.warn(
+              "Attribute #{k} does not exist on #{version.item_type} (Version id: #{version.id})."
+            )
+          end
+        end
+
+        model.send "#{model.class.version_association_name}=", version
+
+        unless options[:has_one] == false
+          reify_has_ones version.transaction_id, model, options
+        end
+
+        unless options[:has_many] == false
+          reify_has_manys version.transaction_id, model, options
+        end
+
+        model
+      end
+
+      private
+
+      # Replaces each record in `array` with its reified version, if present
+      # in `versions`.
+      #
+      # @api private
+      # @param array - The collection to be modified.
+      # @param options
+      # @param versions - A `Hash` mapping IDs to `Version`s
+      # @return nil - Always returns `nil`
+      #
+      # Once modified by this method, `array` will be assigned to the
+      # AR association currently being reified.
+      #
+      def prepare_array_for_has_many(array, options, versions)
+        # Iterate each child to replace it with the previous value if there is
+        # a version after the timestamp.
+        array.map! do |record|
+          if (version = versions.delete(record.id)).nil?
+            record
+          elsif version.event == 'create'
+            options[:mark_for_destruction] ? record.tap { |r| r.mark_for_destruction } : nil
+          else
+            version.reify(options.merge(:has_many => false, :has_one => false))
+          end
+        end
+
+        # Reify the rest of the versions and add them to the collection, these
+        # versions are for those that have been removed from the live
+        # associations.
+        array.concat(
+          versions.values.map { |v|
+            v.reify(options.merge(:has_many => false, :has_one => false))
+          }
+        )
+
+        array.compact!
+
+        nil
+      end
+
+      # Restore the `model`'s has_one associations as they were when this
+      # version was superseded by the next (because that's what the user was
+      # looking at when they made the change).
+      def reify_has_ones(transaction_id, model, options = {})
+        version_table_name = model.class.paper_trail_version_class.table_name
+        model.class.reflect_on_all_associations(:has_one).each do |assoc|
+          if assoc.klass.paper_trail_enabled_for_model?
+            version = model.class.paper_trail_version_class.joins(:version_associations).
+              where("version_associations.foreign_key_name = ?", assoc.foreign_key).
+              where("version_associations.foreign_key_id = ?", model.id).
+              where("#{version_table_name}.item_type = ?", assoc.class_name).
+              where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+              order("#{version_table_name}.id ASC").
+              first
+            if version
+              if version.event == 'create'
+                if options[:mark_for_destruction]
+                  model.send(assoc.name).mark_for_destruction if model.send(assoc.name, true)
+                else
+                  model.appear_as_new_record do
+                    model.send "#{assoc.name}=", nil
+                  end
+                end
+              else
+                child = version.reify(options.merge(:has_many => false, :has_one => false))
+                model.appear_as_new_record do
+                  model.send "#{assoc.name}=", child
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Restore the `model`'s has_many associations as they were at version_at
+      # timestamp We lookup the first child versions after version_at timestamp or
+      # in same transaction.
+      def reify_has_manys(transaction_id, model, options = {})
+        assoc_has_many_through, assoc_has_many_directly =
+          model.class.reflect_on_all_associations(:has_many).
+            partition { |assoc| assoc.options[:through] }
+        reify_has_many_directly(transaction_id, assoc_has_many_directly, model, options)
+        reify_has_many_through(transaction_id, assoc_has_many_through, model, options)
+      end
+
+      # Restore the `model`'s has_many associations not associated through
+      # another association.
+      def reify_has_many_directly(transaction_id, associations, model, options = {})
+        version_table_name = model.class.paper_trail_version_class.table_name
+        associations.each do |assoc|
+          next unless assoc.klass.paper_trail_enabled_for_model?
+          version_id_subquery = PaperTrail::VersionAssociation.
+            joins(model.class.version_association_name).
+            select("MIN(version_id)").
+            where("foreign_key_name = ?", assoc.foreign_key).
+            where("foreign_key_id = ?", model.id).
+            where("#{version_table_name}.item_type = ?", assoc.class_name).
+            where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+            group("item_id").
+            to_sql
+          versions = versions_by_id(model.class, version_id_subquery)
+          collection = Array.new model.send(assoc.name, true) # pass true to avoid cache
+          prepare_array_for_has_many(collection, options, versions)
+          model.send(assoc.name).proxy_association.target = collection
+        end
+      end
+
+      # Restore the `model`'s has_many associations through another association.
+      # This must be called after the direct has_manys have been reified
+      # (reify_has_many_directly).
+      def reify_has_many_through(transaction_id, associations, model, options = {})
+        associations.each do |assoc|
+          next unless assoc.klass.paper_trail_enabled_for_model?
+
+          # Load the collection of through-models. For example, if `model` is a
+          # Chapter, having many Paragraphs through Sections, then
+          # `through_collection` will contain Sections.
+          through_collection = model.send(assoc.options[:through])
+
+          # Examine the `source_reflection`, i.e. the "source" of `assoc` the
+          # `ThroughReflection`. The source can be a `BelongsToReflection`
+          # or a `HasManyReflection`.
+          #
+          # If the association is a has_many association again, then call
+          # reify_has_manys for each record in `through_collection`.
+          if !assoc.source_reflection.belongs_to? && through_collection.present?
+            through_collection.each do |through_model|
+              reify_has_manys(transaction_id, through_model, options)
+            end
+
+            # At this point, the "through" part of the association chain has
+            # been reified, but not the final, "target" part. To continue our
+            # example, `model.sections` (including `model.sections.paragraphs`)
+            # has been loaded. However, the final "target" part of the
+            # association, that is, `model.paragraphs`, has not been loaded. So,
+            # we do that now.
+            collection = through_collection.map { |through_model|
+              through_model.send(assoc.name.to_sym).to_a
+            }.flatten
+          else
+            collection_keys = through_collection.map { |through_model|
+              through_model.send(assoc.association_foreign_key)
+            }
+
+            version_id_subquery = assoc.klass.paper_trail_version_class.
+              select("MIN(id)").
+              where("item_type = ?", assoc.class_name).
+              where("item_id IN (?)", collection_keys).
+              where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+              group("item_id").
+              to_sql
+            versions = versions_by_id(assoc.klass, version_id_subquery)
+            collection = Array.new assoc.klass.where(assoc.klass.primary_key => collection_keys)
+            prepare_array_for_has_many(collection, options, versions)
+          end
+
+          # To continue our example above, assign to `model.paragraphs` the
+          # `collection` (an array of `Paragraph`s).
+          model.send(assoc.name).proxy_association.target = collection
+        end
+      end
+
+      # Given a SQL fragment that identifies the IDs of version records,
+      # returns a `Hash` mapping those IDs to `Version`s.
+      #
+      # @api private
+      # @param klass - An ActiveRecord class.
+      # @param version_id_subquery - String. A SQL subquery that selects
+      #   the IDs of version records.
+      # @return A `Hash` mapping IDs to `Version`s
+      #
+      def versions_by_id(klass, version_id_subquery)
+        klass.
+          paper_trail_version_class.
+          where("id IN (#{version_id_subquery})").
+          inject({}) { |acc, v| acc.merge!(v.item_id => v) }
+      end
+    end
+  end
+end

data/lib/paper_trail/version_association_concern.rb

@@ -7,7 +7,9 @@ module PaperTrail
     included do
       belongs_to :version
 
-      attr_accessible :version_id, :foreign_key_name, :foreign_key_id if PaperTrail.active_record_protected_attributes?
+      if PaperTrail.active_record_protected_attributes?
+        attr_accessible :version_id, :foreign_key_name, :foreign_key_id
+      end
     end
   end
 end

data/lib/paper_trail/version_concern.rb

@@ -18,7 +18,16 @@ module PaperTrail
       validates_presence_of :event
 
       if PaperTrail.active_record_protected_attributes?
-        attr_accessible :item_type, :item_id, :event, :whodunnit, :object, :object_changes, :transaction_id, :created_at
+        attr_accessible(
+          :item_type,
+          :item_id,
+          :event,
+          :whodunnit,
+          :object,
+          :object_changes,
+          :transaction_id,
+          :created_at
+        )
       end
 
       after_create :enforce_version_limit!
@@ -47,8 +56,13 @@ module PaperTrail
         where 'event <> ?', 'create'
       end
 
-      # Expects `obj` to be an instance of `PaperTrail::Version` by default,
-      # but can accept a timestamp if `timestamp_arg` receives `true`
+      # Returns versions after `obj`.
+      #
+      # @param obj - a `Version` or a timestamp
+      # @param timestamp_arg - boolean - When true, `obj` is a timestamp.
+      #   Default: false.
+      # @return `ActiveRecord::Relation`
+      # @api public
       def subsequent(obj, timestamp_arg = false)
         if timestamp_arg != true && self.primary_key_is_int?
           return where(arel_table[primary_key].gt(obj.id)).order(arel_table[primary_key].asc)
@@ -58,6 +72,13 @@ module PaperTrail
         where(arel_table[PaperTrail.timestamp_field].gt(obj)).order(self.timestamp_sort_order)
       end
 
+      # Returns versions before `obj`.
+      #
+      # @param obj - a `Version` or a timestamp
+      # @param timestamp_arg - boolean - When true, `obj` is a timestamp.
+      #   Default: false.
+      # @return `ActiveRecord::Relation`
+      # @api public
       def preceding(obj, timestamp_arg = false)
         if timestamp_arg != true && self.primary_key_is_int?
           return where(arel_table[primary_key].lt(obj.id)).order(arel_table[primary_key].desc)
@@ -67,7 +88,6 @@ module PaperTrail
         where(arel_table[PaperTrail.timestamp_field].lt(obj)).order(self.timestamp_sort_order('desc'))
       end
 
-
       def between(start_time, end_time)
         where(
           arel_table[PaperTrail.timestamp_field].gt(start_time).
@@ -182,79 +202,8 @@ module PaperTrail
     #
     def reify(options = {})
       return nil if object.nil?
-
       without_identity_map do
-        options.reverse_merge!(
-          :version_at => created_at,
-          :mark_for_destruction => false,
-          :has_one    => false,
-          :has_many   => false,
-          :unversioned_attributes => :nil
-        )
-
-        attrs = self.class.object_col_is_json? ? object : PaperTrail.serializer.load(object)
-
-        # Normally a polymorphic belongs_to relationship allows us to get the
-        # object we belong to by calling, in this case, `item`.  However this
-        # returns nil if `item` has been destroyed, and we need to be able to
-        # retrieve destroyed objects.
-        #
-        # In this situation we constantize the `item_type` to get hold of the
-        # class...except when the stored object's attributes include a `type`
-        # key.  If this is the case, the object we belong to is using single
-        # table inheritance and the `item_type` will be the base class, not the
-        # actual subclass. If `type` is present but empty, the class is the base
-        # class.
-
-        if options[:dup] != true && item
-          model = item
-          # Look for attributes that exist in the model and not in this
-          # version. These attributes should be set to nil.
-          if options[:unversioned_attributes] == :nil
-            (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
-          end
-        else
-          inheritance_column_name = item_type.constantize.inheritance_column
-          class_name = attrs[inheritance_column_name].blank? ? item_type : attrs[inheritance_column_name]
-          klass = class_name.constantize
-          # The `dup` option always returns a new object, otherwise we should
-          # attempt to look for the item outside of default scope(s).
-          if options[:dup] || (_item = klass.unscoped.find_by_id(item_id)).nil?
-            model = klass.new
-          elsif options[:unversioned_attributes] == :nil
-            model = _item
-            # Look for attributes that exist in the model and not in this
-            # version. These attributes should be set to nil.
-            (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
-          end
-        end
-
-        if PaperTrail.serialized_attributes?
-          model.class.unserialize_attributes_for_paper_trail! attrs
-        end
-
-        # Set all the attributes in this version on the model.
-        attrs.each do |k, v|
-          if model.has_attribute?(k)
-            model[k.to_sym] = v
-          elsif model.respond_to?("#{k}=")
-            model.send("#{k}=", v)
-          else
-            logger.warn "Attribute #{k} does not exist on #{item_type} (Version id: #{id})."
-          end
-        end
-
-        model.send "#{model.class.version_association_name}=", self
-
-        unless options[:has_one] == false
-          reify_has_ones model, options
-        end
-
-        unless options[:has_many] == false
-          reify_has_manys model, options
-        end
-
-        model
+        ::PaperTrail::Reifier.reify(self, options)
       end
     end
 
@@ -263,15 +212,7 @@ module PaperTrail
     # not have an `object_changes` text column.
     def changeset
       return nil unless self.class.column_names.include? 'object_changes'
-
-      _changes = self.class.object_changes_col_is_json? ? object_changes : PaperTrail.serializer.load(object_changes)
-      @changeset ||= HashWithIndifferentAccess.new(_changes).tap do |changes|
-        if PaperTrail.serialized_attributes?
-          item_type.constantize.unserialize_attribute_changes_for_paper_trail!(changes)
-        end
-      end
-    rescue
-      {}
+      @changeset ||= load_changeset
     end
 
     # Returns who put the item into the state stored in this version.
@@ -292,8 +233,10 @@ module PaperTrail
     alias_method :version_author, :terminator
 
     def sibling_versions(reload = false)
-      @sibling_versions = nil if reload == true
-      @sibling_versions ||= self.class.with_item_keys(item_type, item_id)
+      if reload || @sibling_versions.nil?
+        @sibling_versions = self.class.with_item_keys(item_type, item_id)
+      end
+      @sibling_versions
     end
 
     def next
@@ -304,21 +247,37 @@ module PaperTrail
       @previous ||= sibling_versions.preceding(self).first
     end
 
+    # Returns an integer representing the chronological position of the
+    # version among its siblings (see `sibling_versions`). The "create" event,
+    # for example, has an index of 0.
+    # @api public
     def index
-      table = self.class.arel_table unless @index
-      @index ||=
-        if self.class.primary_key_is_int?
-          sibling_versions.select(table[self.class.primary_key]).order(table[self.class.primary_key].asc).index(self)
-        else
-          sibling_versions.select([table[PaperTrail.timestamp_field], table[self.class.primary_key]]).
-            order(self.class.timestamp_sort_order).index(self)
-        end
+      @index ||= RecordHistory.new(sibling_versions, self.class).index(self)
     end
 
     private
 
+    # @api private
+    def load_changeset
+      changes = HashWithIndifferentAccess.new(object_changes_deserialized)
+      item_type.constantize.unserialize_attribute_changes_for_paper_trail!(changes)
+      changes
+    rescue # TODO: Rescue something specific
+      {}
+    end
+
+    # @api private
+    def object_changes_deserialized
+      if self.class.object_changes_col_is_json?
+        object_changes
+      else
+        PaperTrail.serializer.load(object_changes)
+      end
+    end
+
     # In Rails 3.1+, calling reify on a previous version confuses the
     # IdentityMap, if enabled. This prevents insertion into the map.
+    # @api private
     def without_identity_map(&block)
       if defined?(::ActiveRecord::IdentityMap) && ::ActiveRecord::IdentityMap.respond_to?(:without)
         ::ActiveRecord::IdentityMap.without(&block)
@@ -327,141 +286,16 @@ module PaperTrail
       end
     end
 
-    # Restore the `model`'s has_one associations as they were when this
-    # version was superseded by the next (because that's what the user was
-    # looking at when they made the change).
-    def reify_has_ones(model, options = {})
-      version_table_name = model.class.paper_trail_version_class.table_name
-      model.class.reflect_on_all_associations(:has_one).each do |assoc|
-        if assoc.klass.paper_trail_enabled_for_model?
-          version = model.class.paper_trail_version_class.joins(:version_associations).
-            where("version_associations.foreign_key_name = ?", assoc.foreign_key).
-            where("version_associations.foreign_key_id = ?", model.id).
-            where("#{version_table_name}.item_type = ?", assoc.class_name).
-            where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
-            order("#{version_table_name}.id ASC").first
-          if version
-            if version.event == 'create'
-              if options[:mark_for_destruction]
-                model.send(assoc.name).mark_for_destruction if model.send(assoc.name, true)
-              else
-                model.appear_as_new_record do
-                  model.send "#{assoc.name}=", nil
-                end
-              end
-            else
-              child = version.reify(options.merge(:has_many => false, :has_one => false))
-              model.appear_as_new_record do
-                model.send "#{assoc.name}=", child
-              end
-            end
-          end
-        end
-      end
-    end
-
-    # Restore the `model`'s has_many associations as they were at version_at
-    # timestamp We lookup the first child versions after version_at timestamp or
-    # in same transaction.
-    def reify_has_manys(model, options = {})
-      assoc_has_many_through, assoc_has_many_directly =
-        model.class.reflect_on_all_associations(:has_many).
-        partition { |assoc| assoc.options[:through] }
-      reify_has_many_directly(assoc_has_many_directly, model, options)
-      reify_has_many_through(assoc_has_many_through, model, options)
-    end
-
-    # Restore the `model`'s has_many associations not associated through
-    # another association.
-    def reify_has_many_directly(associations, model, options = {})
-      version_table_name = model.class.paper_trail_version_class.table_name
-      associations.each do |assoc|
-        next unless assoc.klass.paper_trail_enabled_for_model?
-        version_id_subquery = PaperTrail::VersionAssociation.joins(model.class.version_association_name).
-          select("MIN(version_id)").
-          where("foreign_key_name = ?", assoc.foreign_key).
-          where("foreign_key_id = ?", model.id).
-          where("#{version_table_name}.item_type = ?", assoc.class_name).
-          where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
-          group("item_id").to_sql
-        versions = model.class.paper_trail_version_class.where("id IN (#{version_id_subquery})").inject({}) do |acc, v|
-          acc.merge!(v.item_id => v)
-        end
-
-        # Pass true to force the model to load.
-        collection = Array.new model.send(assoc.name, true)
-
-        # Iterate each child to replace it with the previous value if there is
-        # a version after the timestamp.
-        collection.map! do |c|
-          if (version = versions.delete(c.id)).nil?
-            c
-          elsif version.event == 'create'
-            options[:mark_for_destruction] ? c.tap { |r| r.mark_for_destruction } : nil
-          else
-            version.reify(options.merge(:has_many => false, :has_one => false))
-          end
-        end
-
-        # Reify the rest of the versions and add them to the collection, these
-        # versions are for those that have been removed from the live
-        # associations.
-        collection += versions.values.map { |version| version.reify(options.merge(:has_many => false, :has_one => false)) }
-
-        model.send(assoc.name).proxy_association.target = collection.compact
-      end
-    end
-
-    # Restore the `model`'s has_many associations through another association.
-    # This must be called after the direct has_manys have been reified
-    # (reify_has_many_directly).
-    def reify_has_many_through(associations, model, options = {})
-      associations.each do |assoc|
-        next unless assoc.klass.paper_trail_enabled_for_model?
-        through_collection = model.send(assoc.options[:through])
-        collection_keys = through_collection.map { |through_model| through_model.send(assoc.foreign_key) }
-
-        version_id_subquery = assoc.klass.paper_trail_version_class.
-          select("MIN(id)").
-          where("item_type = ?", assoc.class_name).
-          where("item_id IN (?)", collection_keys).
-          where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
-          group("item_id").to_sql
-        versions = assoc.klass.paper_trail_version_class.where("id IN (#{version_id_subquery})").inject({}) do |acc, v|
-          acc.merge!(v.item_id => v)
-        end
-
-        collection = Array.new assoc.klass.where(assoc.klass.primary_key => collection_keys)
-
-        # Iterate each child to replace it with the previous value if there is
-        # a version after the timestamp.
-        collection.map! do |c|
-          if (version = versions.delete(c.id)).nil?
-            c
-          elsif version.event == 'create'
-            options[:mark_for_destruction] ? c.tap { |r| r.mark_for_destruction } : nil
-          else
-            version.reify(options.merge(:has_many => false, :has_one => false))
-          end
-        end
-
-        # Reify the rest of the versions and add them to the collection, these
-        # versions are for those that have been removed from the live
-        # associations.
-        collection += versions.values.map { |version| version.reify(options.merge(:has_many => false, :has_one => false)) }
-
-        model.send(assoc.name).proxy_association.target = collection.compact
-      end
-    end
-
     # Checks that a value has been set for the `version_limit` config
     # option, and if so enforces it.
+    # @api private
     def enforce_version_limit!
-      return unless PaperTrail.config.version_limit.is_a? Numeric
+      limit = PaperTrail.config.version_limit
+      return unless limit.is_a? Numeric
       previous_versions = sibling_versions.not_creates
-      return unless previous_versions.size > PaperTrail.config.version_limit
-      excess_previous_versions = previous_versions - previous_versions.last(PaperTrail.config.version_limit)
-      excess_previous_versions.map(&:destroy)
+      return unless previous_versions.size > limit
+      excess_versions = previous_versions - previous_versions.last(limit)
+      excess_versions.map(&:destroy)
     end
   end
 end