paper_trail 4.2.0 → 5.0.0

data/lib/paper_trail/record_history.rb

@@ -1,9 +1,7 @@
 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.
@@ -16,7 +14,7 @@ module PaperTrail
     # Returns ordinal position of `version` in `sequence`.
     # @api private
     def index(version)
-      sequence.index(version)
+      sequence.to_a.index(version)
     end
 
     private

data/lib/paper_trail/reifier.rb

@@ -1,26 +1,13 @@
 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)
+        options = apply_defaults_to(options, version)
+        attrs = version.object_deserialized
 
         # Normally a polymorphic belongs_to relationship allows us to get the
         # object we belong to by calling, in this case, `item`.  However this
@@ -33,37 +20,160 @@ module PaperTrail
         # 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 }
+            init_unversioned_attrs(attrs, model)
           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
+          klass = version_reification_class(version, attrs)
           # 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?
+          if options[:dup] || (item_found = 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 }
+            model = item_found
+            init_unversioned_attrs(attrs, model)
           end
         end
 
+        reify_attributes(model, version, attrs)
+        model.send "#{model.class.version_association_name}=", version
+        reify_associations(model, options, version)
+        model
+      end
+
+      private
+
+      # Given a hash of `options` for `.reify`, return a new hash with default
+      # values applied.
+      # @api private
+      def apply_defaults_to(options, version)
+        {
+          version_at: version.created_at,
+          mark_for_destruction: false,
+          has_one: false,
+          has_many: false,
+          belongs_to: false,
+          has_and_belongs_to_many: false,
+          unversioned_attributes: :nil
+        }.merge(options)
+      end
+
+      # @api private
+      def each_enabled_association(associations)
+        associations.each do |assoc|
+          next unless assoc.klass.paper_trail_enabled_for_model?
+          yield assoc
+        end
+      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, transaction_id)
+        collection_keys = through_collection.map { |through_model|
+          through_model.send(assoc.source_reflection.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)
+        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
+      def init_unversioned_attrs(attrs, model)
+        (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
+      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
+
+      # 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 : {}
         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)
+          # `unserialize_attributes_for_paper_trail!` 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)
@@ -73,22 +183,8 @@ module PaperTrail
             )
           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`.
       #
@@ -107,10 +203,17 @@ module PaperTrail
         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
+          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))
+            version.reify(
+              options.merge(
+                has_many: false,
+                has_one: false,
+                belongs_to: false,
+                has_and_belongs_to_many: false
+              )
+            )
           end
         end
 
@@ -119,7 +222,14 @@ module PaperTrail
         # associations.
         array.concat(
           versions.values.map { |v|
-            v.reify(options.merge(:has_many => false, :has_one => false))
+            v.reify(
+              options.merge(
+                has_many: false,
+                has_one: false,
+                belongs_to: false,
+                has_and_belongs_to_many: false
+              )
+            )
           }
         )
 
@@ -128,40 +238,79 @@ module PaperTrail
         nil
       end
 
+      def reify_associations(model, options, version)
+        reify_has_ones version.transaction_id, model, options if options[:has_one]
+
+        reify_belongs_tos version.transaction_id, model, options if options[:belongs_to]
+
+        reify_has_manys version.transaction_id, model, options if options[:has_many]
+
+        if options[:has_and_belongs_to_many]
+          reify_has_and_belongs_to_many version.transaction_id, model, options
+        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(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
+        associations = model.class.reflect_on_all_associations(:has_one)
+        each_enabled_association(associations) do |assoc|
+          version = load_version_for_has_one(assoc, model, transaction_id, options[:version_at])
+          next 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.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.appear_as_new_record do
+              without_persisting(child) do
+                model.send "#{assoc.name}=", child
               end
             end
           end
         end
       end
 
+      def reify_belongs_tos(transaction_id, model, options = {})
+        associations = model.class.reflect_on_all_associations(:belongs_to)
+        each_enabled_association(associations) do |assoc|
+          collection_key = model.send(assoc.association_foreign_key)
+          version = assoc.klass.paper_trail_version_class.
+            where("item_type = ?", assoc.class_name).
+            where("item_id = ?", collection_key).
+            where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+            order("id").limit(1).first
+
+          collection = if version.nil?
+                         assoc.klass.where(assoc.klass.primary_key => collection_key).first
+                       else
+                         version.reify(
+                           options.merge(
+                             has_many: false,
+                             has_one: false,
+                             belongs_to: false,
+                             has_and_belongs_to_many: false
+                           )
+                         )
+                       end
+
+          model.send("#{assoc.name}=".to_sym, collection)
+        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.
@@ -177,8 +326,7 @@ module PaperTrail
       # 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?
+        each_enabled_association(associations) do |assoc|
           version_id_subquery = PaperTrail::VersionAssociation.
             joins(model.class.version_association_name).
             select("MIN(version_id)").
@@ -189,7 +337,7 @@ module PaperTrail
             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
+          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
@@ -199,57 +347,76 @@ module PaperTrail
       # 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?
-
+        each_enabled_association(associations) do |assoc|
           # 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
+          # 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)
 
-            # 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).
+          # Finally, assign the `collection` of "target" models, e.g. to
+          # `model.paragraphs`.
           model.send(assoc.name).proxy_association.target = collection
         end
       end
 
+      def reify_has_and_belongs_to_many(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_for_model?
+          next unless
+            model.class.paper_trail_save_join_tables.include?(assoc.name) ||
+                papertrail_enabled
+
+          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
+      end
+
+      # Given a `version`, return the class to reify. This method supports
+      # Single Table Inheritance (STI) with custom inheritance columns.
+      #
+      # For example, imagine a `version` whose `item_type` is "Animal". The
+      # `animals` table is an STI table (it has cats and dogs) and it has a
+      # custom inheritance column, `species`. If `attrs["species"]` is "Dog",
+      # this method returns the constant `Dog`. If `attrs["species"]` is blank,
+      # this method returns the constant `Animal`. You can see this particular
+      # example in action in `spec/models/animal_spec.rb`.
+      #
+      def version_reification_class(version, attrs)
+        inheritance_column_name = version.item_type.constantize.inheritance_column
+        inher_col_value = attrs[inheritance_column_name]
+        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.
       #
@@ -263,7 +430,19 @@ module PaperTrail
         klass.
           paper_trail_version_class.
           where("id IN (#{version_id_subquery})").
-          inject({}) { |acc, v| acc.merge!(v.item_id => v) }
+          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