paper_trail 9.1.1 → 9.2.0

data/lib/paper_trail/reifiers/has_many_through.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  module Reifiers
-    # Reify a single HMT association of `model`.
-    # @api private
-    module HasManyThrough
-      class << self
-        # @api private
-        def reify(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 = 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
-
-        private
-
-        # 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 collection(through_collection, assoc, options, transaction_id)
-          if !assoc.source_reflection.belongs_to? && through_collection.present?
-            collection_through_has_many(through_collection, assoc, options, transaction_id)
-          else
-            collection_through_belongs_to(through_collection, assoc, options, transaction_id)
-          end
-        end
-
-        # @api private
-        def collection_through_has_many(through_collection, assoc, options, transaction_id)
-          through_collection.each do |through_model|
-            ::PaperTrail::Reifier.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 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)
-          Reifiers::HasMany.prepare_array(collection, options, versions)
-          collection
-        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.klass.base_class.name).
-            where("item_id IN (?)", ids).
-            where(
-              "created_at >= ? OR transaction_id = ?",
-              version_at,
-              tx_id
-            ).
-            group("item_id").
-            to_sql
-          Reifiers::HasMany.versions_by_id(assoc.klass, version_id_subquery)
-        end
-      end
-    end
-  end
-end

data/lib/paper_trail/reifiers/has_one.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  module Reifiers
-    # Reify a single `has_one` association of `model`.
-    # @api private
-    module HasOne
-      # A more helpful error message, instead of the AssociationTypeMismatch
-      # you would get if, eg. we were to try to assign a Bicycle to the :car
-      # association (before, if there were multiple records we would just take
-      # the first and hope for the best).
-      # @api private
-      class FoundMoreThanOne < RuntimeError
-        MESSAGE_FMT = <<~STR
-          Unable to reify has_one association. Expected to find one %s,
-          but found %d.
-
-          This is a known issue, and a good example of why association tracking
-          is an experimental feature that should not be used in production.
-
-          That said, this is a rare error. In spec/models/person_spec.rb we
-          reproduce it by having two STI models with the same foreign_key (Car
-          and Bicycle are both Vehicles and the FK for both is owner_id)
-
-          If you'd like to help fix this error, please read
-          https://github.com/paper-trail-gem/paper_trail/issues/594
-          and see spec/models/person_spec.rb
-        STR
-
-        def initialize(base_class_name, num_records_found)
-          @base_class_name = base_class_name.to_s
-          @num_records_found = num_records_found.to_i
-        end
-
-        def message
-          format(MESSAGE_FMT, @base_class_name, @num_records_found)
-        end
-      end
-
-      class << self
-        # @api private
-        def reify(assoc, model, options, transaction_id)
-          version = load_version(assoc, model, transaction_id, options[:version_at])
-          return unless version
-          if version.event == "create"
-            create_event(assoc, model, options)
-          else
-            noncreate_event(assoc, model, options, version)
-          end
-        end
-
-        private
-
-        # @api private
-        def create_event(assoc, model, options)
-          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
-        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(assoc, model, transaction_id, version_at)
-          base_class_name = assoc.klass.base_class.name
-          versions = load_versions(assoc, model, transaction_id, version_at, base_class_name)
-          case versions.length
-          when 0
-            nil
-          when 1
-            versions.first
-          else
-            case PaperTrail.config.association_reify_error_behaviour.to_s
-            when "warn"
-              version = versions.first
-              version.logger&.warn(
-                FoundMoreThanOne.new(base_class_name, versions.length).message
-              )
-              version
-            when "ignore"
-              versions.first
-            else # "error"
-              raise FoundMoreThanOne.new(base_class_name, versions.length)
-            end
-          end
-        end
-
-        # @api private
-        def load_versions(assoc, model, transaction_id, version_at, base_class_name)
-          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 = ?", base_class_name).
-            where("created_at >= ? OR transaction_id = ?", version_at, transaction_id).
-            order("#{version_table_name}.id ASC").
-            load
-        end
-
-        # @api private
-        def noncreate_event(assoc, model, options, version)
-          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
-
-        # 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
-end

data/lib/paper_trail/version_association_concern.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  # Functionality for `PaperTrail::VersionAssociation`. Exists in a module
-  # for the same reasons outlined in version_concern.rb.
-  module VersionAssociationConcern
-    extend ::ActiveSupport::Concern
-
-    included do
-      belongs_to :version
-    end
-  end
-end