paper_trail 6.0.2 → 7.0.0

data/Rakefile

@@ -27,4 +27,4 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 desc "Default: run all available test suites"
-task default: [:rubocop, :prepare, :test, :spec]
+task default: %i(rubocop prepare test spec)

data/doc/bug_report_template.rb

@@ -34,7 +34,7 @@ ActiveRecord::Schema.define do
     t.integer :transaction_id
     t.datetime :created_at
   end
-  add_index :versions, [:item_type, :item_id]
+  add_index :versions, %i(item_type item_id)
   add_index :versions, [:transaction_id]
 
   create_table :version_associations do |t|
@@ -43,7 +43,7 @@ ActiveRecord::Schema.define do
     t.integer  :foreign_key_id
   end
   add_index :version_associations, [:version_id]
-  add_index :version_associations, [:foreign_key_name, :foreign_key_id],
+  add_index :version_associations, %i(foreign_key_name foreign_key_id),
     name: "index_version_associations_on_foreign_key"
 end
 ActiveRecord::Base.logger = Logger.new(STDOUT)
@@ -67,3 +67,5 @@ class BugTest < ActiveSupport::TestCase
     }
   end
 end
+
+# STEP SIX: Run this script using `ruby my_bug_report.rb`

data/gemfiles/ar_4.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.0"
+
+gemspec :path => "../"

data/gemfiles/ar_4.2.gemfile

@@ -3,6 +3,5 @@
 source "https://rubygems.org"
 
 gem "activerecord", "~> 4.2"
-gem "sinatra", "~> 1.4.6"
 
 gemspec :path => "../"

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

@@ -9,7 +9,7 @@ class CreateVersionAssociations < ActiveRecord::Migration
     end
     add_index :version_associations, [:version_id]
     add_index :version_associations,
-      [:foreign_key_name, :foreign_key_id],
+      %i(foreign_key_name foreign_key_id),
       name: "index_version_associations_on_foreign_key"
   end
 

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

@@ -38,7 +38,7 @@ class CreateVersions < ActiveRecord::Migration
       #
       t.datetime :created_at
     end
-    add_index :versions, [:item_type, :item_id]
+    add_index :versions, %i(item_type item_id)
   end
 
   private

data/lib/paper_trail.rb

@@ -34,14 +34,6 @@ module PaperTrail
       !!PaperTrail.config.enabled
     end
 
-    def serialized_attributes?
-      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.
     # @api public
     def enabled_for_controller=(value)
@@ -70,6 +62,13 @@ module PaperTrail
       !!paper_trail_store.fetch(:"enabled_for_#{model}", true)
     end
 
+    # Returns a `::Gem::Version`, convenient for comparisons. This is
+    # recommended over `::PaperTrail::VERSION::STRING`.
+    # @api public
+    def gem_version
+      ::Gem::Version.new(VERSION::STRING)
+    end
+
     # Set the field which records when a version was created.
     # @api public
     def timestamp_field=(_field_name)
@@ -163,7 +162,6 @@ ActiveSupport.on_load(:active_record) do
 end
 
 # Require frameworks
-require "paper_trail/frameworks/sinatra"
 if defined?(::Rails) && ActiveRecord::VERSION::STRING >= "3.2"
   require "paper_trail/frameworks/rails"
 else

data/lib/paper_trail/config.rb

@@ -18,21 +18,6 @@ module PaperTrail
       @serializer = PaperTrail::Serializers::YAML
     end
 
-    def serialized_attributes
-      ActiveSupport::Deprecation.warn(
-        "PaperTrail.config.serialized_attributes is deprecated without " +
-          "replacement and always returns false."
-      )
-      false
-    end
-
-    def serialized_attributes=(_)
-      ActiveSupport::Deprecation.warn(
-        "PaperTrail.config.serialized_attributes= is deprecated without " +
-          "replacement and no longer has any effect."
-      )
-    end
-
     # Previously, we checked `PaperTrail::VersionAssociation.table_exists?`
     # here, but that proved to be problematic in situations when the database
     # connection had not been established, or when the database does not exist

data/lib/paper_trail/frameworks/rspec.rb

@@ -25,10 +25,16 @@ end
 
 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? }
+  match do |actual|
+    versions_association = actual.class.versions_association_name
+    actual.send(versions_association).where_object(attributes).any?
+  end
 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? }
+  match do |actual|
+    versions_association = actual.class.versions_association_name
+    actual.send(versions_association).where_object_changes(attributes).any?
+  end
 end

data/lib/paper_trail/model_config.rb

@@ -76,10 +76,14 @@ module PaperTrail
     # "class attributes", instance methods, and more.
     # @api private
     def setup(options = {})
-      options[:on] ||= [:create, :update, :destroy]
+      options[:on] ||= %i(create update destroy)
       options[:on] = Array(options[:on]) # Support single symbol
       @model_class.send :include, ::PaperTrail::Model::InstanceMethods
       if ::ActiveRecord::VERSION::STRING < "4.2"
+        ::ActiveSupport::Deprecation.warn(
+          "Your version of ActiveRecord (< 4.2) has reached EOL. PaperTrail " \
+          "will soon drop support. Please upgrade ActiveRecord ASAP."
+        )
         @model_class.send :extend, AttributeSerializers::LegacyActiveRecordShim
       end
       setup_options(options)
@@ -163,7 +167,7 @@ module PaperTrail
       @model_class.class_attribute :paper_trail_options
       @model_class.paper_trail_options = options.dup
 
-      [:ignore, :skip, :only].each do |k|
+      %i(ignore skip only).each do |k|
         @model_class.paper_trail_options[k] = [@model_class.paper_trail_options[k]].
           flatten.
           compact.

data/lib/paper_trail/record_trail.rb

@@ -474,7 +474,9 @@ module PaperTrail
       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)
+        # TODO: after dropping support for rails 4.0, remove send, because
+        # attribute_was is no longer private.
+        @record.send(:attribute_was, attr_name.to_s)
       end
     end
 

data/lib/paper_trail/reifier.rb

@@ -1,4 +1,9 @@
 require "paper_trail/attribute_serializers/object_attribute"
+require "paper_trail/reifiers/belongs_to"
+require "paper_trail/reifiers/has_and_belongs_to_many"
+require "paper_trail/reifiers/has_many"
+require "paper_trail/reifiers/has_many_through"
+require "paper_trail/reifiers/has_one"
 
 module PaperTrail
   # Given a version record and some options, builds a new model object.
@@ -17,6 +22,18 @@ module PaperTrail
         model
       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.
+      # @api private
+      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_associations(transaction_id, assoc_has_many_directly, model, options)
+        reify_has_many_through_associations(transaction_id, assoc_has_many_through, model, options)
+      end
+
       private
 
       # Given a hash of `options` for `.reify`, return a new hash with default
@@ -79,54 +96,6 @@ module PaperTrail
         model
       end
 
-      # 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`.
-      #
-      # @api private
-      def hmt_collection(through_collection, assoc, options, transaction_id)
-        if !assoc.source_reflection.belongs_to? && through_collection.present?
-          hmt_collection_through_has_many(
-            through_collection, assoc, options, transaction_id
-          )
-        else
-          hmt_collection_through_belongs_to(
-            through_collection, assoc, options, transaction_id
-          )
-        end
-      end
-
-      # @api private
-      def hmt_collection_through_has_many(through_collection, assoc, options, transaction_id)
-        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.
-        through_collection.flat_map { |through_model|
-          through_model.public_send(assoc.name.to_sym).to_a
-        }
-      end
-
-      # @api private
-      def hmt_collection_through_belongs_to(through_collection, assoc, options, tx_id)
-        ids = through_collection.map { |through_model|
-          through_model.send(assoc.source_reflection.foreign_key)
-        }
-        versions = load_versions_for_hmt_association(assoc, ids, tx_id, options[:version_at])
-        collection = Array.new assoc.klass.where(assoc.klass.primary_key => ids)
-        prepare_array_for_has_many(collection, options, versions)
-        collection
-      end
-
       # Look for attributes that exist in `model` and not in this version.
       # These attributes should be set to nil. Modifies `attrs`.
       # @api private
@@ -134,171 +103,35 @@ module PaperTrail
         (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
       end
 
-      # Given a `belongs_to` association and a `version`, return a record that
-      # can be assigned in order to reify that association.
+      # Reify onto `model` an attribute named `k` with value `v` from `version`.
+      #
+      # `ObjectAttribute#deserialize` will return the mapped enum value and in
+      # Rails < 5, the []= uses the integer type caster from the column
+      # definition (in general) and thus will turn a (usually) string to 0
+      # instead of the correct value.
+      #
       # @api private
-      def load_record_for_bt_association(assoc, id, options, version)
-        if version.nil?
-          assoc.klass.where(assoc.klass.primary_key => id).first
-        else
-          version.reify(
-            options.merge(
-              has_many: false,
-              has_one: false,
-              belongs_to: false,
-              has_and_belongs_to_many: false
-            )
+      def reify_attribute(k, v, model, version)
+        enums = model.class.respond_to?(:defined_enums) ? model.class.defined_enums : {}
+        is_enum_without_type_caster = ::ActiveRecord::VERSION::MAJOR < 5 && enums.key?(k)
+        if model.has_attribute?(k) && !is_enum_without_type_caster
+          model[k.to_sym] = v
+        elsif model.respond_to?("#{k}=")
+          model.send("#{k}=", v)
+        elsif version.logger
+          version.logger.warn(
+            "Attribute #{k} does not exist on #{version.item_type} (Version id: #{version.id})."
           )
         end
       end
 
-      # Given a `belongs_to` association and an `id`, return a version record
-      # from the point in time identified by `transaction_id` or `version_at`.
-      # @api private
-      def load_version_for_bt_association(assoc, id, transaction_id, version_at)
-        assoc.klass.paper_trail.version_class.
-          where("item_type = ?", assoc.class_name).
-          where("item_id = ?", id).
-          where("created_at >= ? OR transaction_id = ?", version_at, transaction_id).
-          order("id").limit(1).first
-      end
-
-      # Given a HABTM association `assoc` and an `id`, return a version record
-      # from the point in time identified by `transaction_id` or `version_at`.
-      # @api private
-      def load_version_for_habtm(assoc, id, transaction_id, version_at)
-        assoc.klass.paper_trail.version_class.
-          where("item_type = ?", assoc.klass.name).
-          where("item_id = ?", id).
-          where("created_at >= ? OR transaction_id = ?", version_at, transaction_id).
-          order("id").
-          limit(1).
-          first
-      end
-
-      # Given a has-one association `assoc` on `model`, return the version
-      # record from the point in time identified by `transaction_id` or `version_at`.
-      # @api private
-      def load_version_for_has_one(assoc, model, transaction_id, version_at)
-        version_table_name = model.class.paper_trail.version_class.table_name
-        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 = ?", version_at, transaction_id).
-          order("#{version_table_name}.id ASC").
-          first
-      end
-
-      # Given a `has_many` association on `model`, return the version records
-      # from the point in time identified by `tx_id` or `version_at`.
+      # Reify onto `model` all the attributes of `version`.
       # @api private
-      def load_versions_for_hm_association(assoc, model, version_table, tx_id, version_at)
-        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}.item_type = ?", assoc.class_name).
-          where("created_at >= ? OR transaction_id = ?", version_at, tx_id).
-          group("item_id").
-          to_sql
-        versions_by_id(model.class, version_id_subquery)
-      end
-
-      # Given a `has_many(through:)` association and an array of `ids`, return
-      # the version records from the point in time identified by `tx_id` or
-      # `version_at`.
-      # @api private
-      def load_versions_for_hmt_association(assoc, ids, tx_id, version_at)
-        version_id_subquery = assoc.klass.paper_trail.version_class.
-          select("MIN(id)").
-          where("item_type = ?", assoc.class_name).
-          where("item_id IN (?)", ids).
-          where(
-            "created_at >= ? OR transaction_id = ?",
-            version_at,
-            tx_id
-          ).
-          group("item_id").
-          to_sql
-        versions_by_id(assoc.klass, version_id_subquery)
-      end
-
-      # Set all the attributes in this version on the model.
       def reify_attributes(model, version, attrs)
-        enums = model.class.respond_to?(:defined_enums) ? model.class.defined_enums : {}
         AttributeSerializers::ObjectAttribute.new(model.class).deserialize(attrs)
         attrs.each do |k, v|
-          # `ObjectAttribute#deserialize` will return the mapped enum value
-          # and in Rails < 5, the []= uses the integer type caster from the column
-          # definition (in general) and thus will turn a (usually) string to 0 instead
-          # of the correct value
-          is_enum_without_type_caster = ::ActiveRecord::VERSION::MAJOR < 5 && enums.key?(k)
-
-          if model.has_attribute?(k) && !is_enum_without_type_caster
-            model[k.to_sym] = v
-          elsif model.respond_to?("#{k}=")
-            model.send("#{k}=", v)
-          elsif version.logger
-            version.logger.warn(
-              "Attribute #{k} does not exist on #{version.item_type} (Version id: #{version.id})."
-            )
-          end
-        end
-      end
-
-      # 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(&:mark_for_destruction) : nil
-          else
-            version.reify(
-              options.merge(
-                has_many: false,
-                has_one: false,
-                belongs_to: false,
-                has_and_belongs_to_many: false
-              )
-            )
-          end
+          reify_attribute(k, v, model, version)
         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,
-                belongs_to: false,
-                has_and_belongs_to_many: false
-              )
-            )
-          }
-        )
-
-        array.compact!
-
-        nil
       end
 
       # @api private
@@ -317,36 +150,6 @@ module PaperTrail
         end
       end
 
-      # Reify a single `has_one` association of `model`.
-      # @api private
-      def reify_has_one_association(assoc, model, options, transaction_id)
-        version = load_version_for_has_one(assoc, model, transaction_id, options[:version_at])
-        return unless 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.paper_trail.appear_as_new_record do
-              model.send "#{assoc.name}=", nil
-            end
-          end
-        else
-          child = version.reify(
-            options.merge(
-              has_many: false,
-              has_one: false,
-              belongs_to: false,
-              has_and_belongs_to_many: false
-            )
-          )
-          model.paper_trail.appear_as_new_record do
-            without_persisting(child) do
-              model.send "#{assoc.name}=", child
-            end
-          end
-        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).
@@ -354,130 +157,44 @@ module PaperTrail
       def reify_has_one_associations(transaction_id, model, options = {})
         associations = model.class.reflect_on_all_associations(:has_one)
         each_enabled_association(associations) do |assoc|
-          reify_has_one_association(assoc, model, options, transaction_id)
+          Reifiers::HasOne.reify(assoc, model, options, transaction_id)
         end
       end
 
-      # Reify a single `belongs_to` association of `model`.
-      # @api private
-      def reify_belongs_to_association(assoc, model, options, transaction_id)
-        id = model.send(assoc.association_foreign_key)
-        version = load_version_for_bt_association(assoc, id, transaction_id, options[:version_at])
-        record = load_record_for_bt_association(assoc, id, options, version)
-        model.send("#{assoc.name}=".to_sym, record)
-      end
-
       # Reify all `belongs_to` associations of `model`.
       # @api private
       def reify_belongs_to_associations(transaction_id, model, options = {})
         associations = model.class.reflect_on_all_associations(:belongs_to)
         each_enabled_association(associations) do |assoc|
-          reify_belongs_to_association(assoc, model, options, transaction_id)
+          Reifiers::BelongsTo.reify(assoc, model, options, transaction_id)
         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_associations(transaction_id, assoc_has_many_directly, model, options)
-        reify_has_many_through_associations(transaction_id, assoc_has_many_through, model, options)
-      end
-
-      # Reify a single, direct (not `through`) `has_many` association of `model`.
-      # @api private
-      def reify_has_many_association(assoc, model, options, transaction_id, version_table_name)
-        versions = load_versions_for_hm_association(
-          assoc,
-          model,
-          version_table_name,
-          transaction_id,
-          options[:version_at]
-        )
-        collection = Array.new model.send(assoc.name).reload # to avoid cache
-        prepare_array_for_has_many(collection, options, versions)
-        model.send(assoc.name).proxy_association.target = collection
-      end
-
       # Reify all direct (not `through`) `has_many` associations of `model`.
       # @api private
       def reify_has_many_associations(transaction_id, associations, model, options = {})
         version_table_name = model.class.paper_trail.version_class.table_name
         each_enabled_association(associations) do |assoc|
-          reify_has_many_association(assoc, model, options, transaction_id, version_table_name)
+          Reifiers::HasMany.reify(assoc, model, options, transaction_id, version_table_name)
         end
       end
 
-      # Reify a single HMT association of `model`.
-      # @api private
-      def reify_has_many_through_association(assoc, model, options, transaction_id)
-        # 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])
-
-        # Now, given the collection of "through" models (e.g. sections), load
-        # the collection of "target" models (e.g. paragraphs)
-        collection = hmt_collection(through_collection, assoc, options, transaction_id)
-
-        # Finally, assign the `collection` of "target" models, e.g. to
-        # `model.paragraphs`.
-        model.send(assoc.name).proxy_association.target = collection
-      end
-
       # Reify all HMT associations of `model`. This must be called after the
       # direct (non-`through`) has_manys have been reified.
       # @api private
       def reify_has_many_through_associations(transaction_id, associations, model, options = {})
         each_enabled_association(associations) do |assoc|
-          reify_has_many_through_association(assoc, model, options, transaction_id)
+          Reifiers::HasManyThrough.reify(assoc, model, options, transaction_id)
         end
       end
 
-      # Reify a single HABTM association of `model`.
-      # @api private
-      def reify_habtm_association(assoc, model, options, papertrail_enabled, transaction_id)
-        version_ids = PaperTrail::VersionAssociation.
-          where("foreign_key_name = ?", assoc.name).
-          where("version_id = ?", transaction_id).
-          pluck(:foreign_key_id)
-
-        model.send(assoc.name).proxy_association.target =
-          version_ids.map do |id|
-            if papertrail_enabled
-              version = load_version_for_habtm(
-                assoc,
-                id,
-                transaction_id,
-                options[:version_at]
-              )
-              if version
-                next version.reify(
-                  options.merge(
-                    has_many: false,
-                    has_one: false,
-                    belongs_to: false,
-                    has_and_belongs_to_many: false
-                  )
-                )
-              end
-            end
-            assoc.klass.where(assoc.klass.primary_key => id).first
-          end
-      end
-
       # Reify all HABTM associations of `model`.
       # @api private
       def reify_habtm_associations(transaction_id, model, options = {})
         model.class.reflect_on_all_associations(:has_and_belongs_to_many).each do |assoc|
-          papertrail_enabled = assoc.klass.paper_trail.enabled?
-          next unless
-            model.class.paper_trail_save_join_tables.include?(assoc.name) ||
-                papertrail_enabled
-          reify_habtm_association(assoc, model, options, papertrail_enabled, transaction_id)
+          pt_enabled = assoc.klass.paper_trail.enabled?
+          next unless model.class.paper_trail_save_join_tables.include?(assoc.name) || pt_enabled
+          Reifiers::HasAndBelongsToMany.reify(pt_enabled, assoc, model, options, transaction_id)
         end
       end
 
@@ -497,34 +214,6 @@ module PaperTrail
         class_name = inher_col_value.blank? ? version.item_type : inher_col_value
         class_name.constantize
       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({}) { |a, e| a.merge!(e.item_id => e) }
-      end
-
-      # Temporarily suppress #save so we can reassociate with the reified
-      # master of a has_one relationship. Since ActiveRecord 5 the related
-      # object is saved when it is assigned to the association. ActiveRecord
-      # 5 also happens to be the first version that provides #suppress.
-      def without_persisting(record)
-        if record.class.respond_to? :suppress
-          record.class.suppress { yield }
-        else
-          yield
-        end
-      end
     end
   end
 end