paper_trail 6.0.1 → 6.0.2

data/lib/paper_trail/reifier.rb

@@ -10,36 +10,7 @@ module PaperTrail
       def reify(version, options)
         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
-        # 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
-          if options[:unversioned_attributes] == :nil
-            init_unversioned_attrs(attrs, model)
-          end
-        else
-          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).
-          find_cond = { klass.primary_key => version.item_id }
-          if options[:dup] || (item_found = klass.unscoped.where(find_cond).first).nil?
-            model = klass.new
-          elsif options[:unversioned_attributes] == :nil
-            model = item_found
-            init_unversioned_attrs(attrs, model)
-          end
-        end
-
+        model = init_model(attrs, options, version)
         reify_attributes(model, version, attrs)
         model.send "#{model.class.version_association_name}=", version
         reify_associations(model, options, version)
@@ -71,6 +42,43 @@ module PaperTrail
         end
       end
 
+      # Initialize a model object suitable for reifying `version` into. Does
+      # not perform reification, merely instantiates the appropriate model
+      # class and, if specified by `options[:unversioned_attributes]`, sets
+      # unversioned attributes to `nil`.
+      #
+      # 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 (STI) 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.
+      def init_model(attrs, options, version)
+        if options[:dup] != true && version.item
+          model = version.item
+          if options[:unversioned_attributes] == :nil
+            init_unversioned_attrs(attrs, model)
+          end
+        else
+          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).
+          find_cond = { klass.primary_key => version.item_id }
+          if options[:dup] || (item_found = klass.unscoped.where(find_cond).first).nil?
+            model = klass.new
+          elsif options[:unversioned_attributes] == :nil
+            model = item_found
+            init_unversioned_attrs(attrs, model)
+          end
+        end
+        model
+      end
+
       # Examine the `source_reflection`, i.e. the "source" of `assoc` the
       # `ThroughReflection`. The source can be a `BelongsToReflection`
       # or a `HasManyReflection`.
@@ -109,23 +117,12 @@ module PaperTrail
       end
 
       # @api private
-      def hmt_collection_through_belongs_to(through_collection, assoc, options, transaction_id)
-        collection_keys = through_collection.map { |through_model|
+      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)
         }
-        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)
+        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
@@ -137,6 +134,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.
+      # @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
+            )
+          )
+        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
@@ -164,6 +190,41 @@ module PaperTrail
           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`.
+      # @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 : {}
@@ -179,7 +240,7 @@ module PaperTrail
             model[k.to_sym] = v
           elsif model.respond_to?("#{k}=")
             model.send("#{k}=", v)
-          else
+          elsif version.logger
             version.logger.warn(
               "Attribute #{k} does not exist on #{version.item_type} (Version id: #{version.id})."
             )
@@ -240,76 +301,78 @@ module PaperTrail
         nil
       end
 
+      # @api private
       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_one]
+          reify_has_one_associations(version.transaction_id, model, options)
+        end
+        if options[:belongs_to]
+          reify_belongs_to_associations(version.transaction_id, model, options)
+        end
+        if options[:has_many]
+          reify_has_manys(version.transaction_id, model, options)
+        end
         if options[:has_and_belongs_to_many]
-          reify_has_and_belongs_to_many version.transaction_id, model, options
+          reify_habtm_associations version.transaction_id, model, options
+        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).
-      def reify_has_ones(transaction_id, model, options = {})
+      # @api private
+      def reify_has_one_associations(transaction_id, model, options = {})
         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.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
+          reify_has_one_association(assoc, model, options, transaction_id)
         end
       end
 
-      def reify_belongs_tos(transaction_id, model, options = {})
+      # 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|
-          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)
+          reify_belongs_to_association(assoc, model, options, transaction_id)
         end
       end
 
@@ -320,85 +383,101 @@ module PaperTrail
         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)
+        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
 
-      # Restore the `model`'s has_many associations not associated through
-      # another association.
-      def reify_has_many_directly(transaction_id, associations, model, options = {})
+      # 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|
-          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).reload # to avoid cache
-          prepare_array_for_has_many(collection, options, versions)
-          model.send(assoc.name).proxy_association.target = collection
+          reify_has_many_association(assoc, model, options, transaction_id, version_table_name)
         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 = {})
+      # 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|
-          # 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
+          reify_has_many_through_association(assoc, model, options, transaction_id)
         end
       end
 
-      def reify_has_and_belongs_to_many(transaction_id, model, options = {})
+      # 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
-
-          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
+          reify_habtm_association(assoc, model, options, papertrail_enabled, transaction_id)
         end
       end