paper_trail 6.0.2 → 7.0.0

data/lib/paper_trail/reifiers/belongs_to.rb

@@ -0,0 +1,48 @@
+module PaperTrail
+  module Reifiers
+    # Reify a single `belongs_to` association of `model`.
+    # @api private
+    module BelongsTo
+      class << self
+        # @api private
+        def reify(assoc, model, options, transaction_id)
+          id = model.send(assoc.foreign_key)
+          version = load_version(assoc, id, transaction_id, options[:version_at])
+          record = load_record(assoc, id, options, version)
+          model.send("#{assoc.name}=".to_sym, record)
+        end
+
+        private
+
+        # 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(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(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
+      end
+    end
+  end
+end

data/lib/paper_trail/reifiers/has_and_belongs_to_many.rb

@@ -0,0 +1,50 @@
+module PaperTrail
+  module Reifiers
+    # Reify a single HABTM association of `model`.
+    # @api private
+    module HasAndBelongsToMany
+      class << self
+        # @api private
+        def reify(pt_enabled, assoc, model, options, 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 pt_enabled
+                version = load_version(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
+
+        private
+
+        # 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(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
+      end
+    end
+  end
+end

data/lib/paper_trail/reifiers/has_many.rb

@@ -0,0 +1,110 @@
+module PaperTrail
+  module Reifiers
+    # Reify a single, direct (not `through`) `has_many` association of `model`.
+    # @api private
+    module HasMany
+      class << self
+        # @api private
+        def reify(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(collection, options, versions)
+          model.send(assoc.name).proxy_association.target = collection
+        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(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
+          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
+
+        # 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
+
+        private
+
+        # 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
+      end
+    end
+  end
+end

data/lib/paper_trail/reifiers/has_many_through.rb

@@ -0,0 +1,90 @@
+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.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

@@ -0,0 +1,76 @@
+module PaperTrail
+  module Reifiers
+    # Reify a single `has_one` association of `model`.
+    # @api private
+    module HasOne
+      class << self
+        # @api private
+        def reify(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"
+            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_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
+
+        # @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/serializers/yaml.rb

@@ -24,33 +24,10 @@ module PaperTrail
       # value in the serialized `object_changes`.
       def where_object_changes_condition(arel_field, field, value)
         # Need to check first (before) and secondary (after) fields
-        m1 = nil
-        m2 = nil
-        case yaml_engine_id
-        when :psych
-          m1 = "%\n#{field}:\n- #{value}\n%"
-          m2 = "%\n#{field}:\n-%\n- #{value}\n%"
-        when :syck
-          # Syck adds extra spaces into array dumps
-          m1 = "%\n#{field}: \n%- #{value}\n%"
-          m2 = "%\n#{field}: \n-%\n- #{value}\n%"
-        else
-          raise "Unknown yaml engine"
-        end
+        m1 = "%\n#{field}:\n- #{value}\n%"
+        m2 = "%\n#{field}:\n-%\n- #{value}\n%"
         arel_field.matches(m1).or(arel_field.matches(m2))
       end
-
-      # Returns a symbol identifying the YAML engine. Syck was removed from
-      # the ruby stdlib in ruby 2.0, but is still available as a gem.
-      # @api private
-      def yaml_engine_id
-        if (defined?(::YAML::ENGINE) && ::YAML::ENGINE.yamler == "psych") ||
-            (defined?(::Psych) && ::YAML == ::Psych)
-          :psych
-        else
-          :syck
-        end
-      end
     end
   end
 end

data/lib/paper_trail/version_concern.rb

@@ -162,13 +162,13 @@ module PaperTrail
       # Returns whether the `object` column is using the `json` type supported
       # by PostgreSQL.
       def object_col_is_json?
-        [:json, :jsonb].include?(columns_hash["object"].type)
+        %i(json jsonb).include?(columns_hash["object"].type)
       end
 
       # Returns whether the `object_changes` column is using the `json` type
       # supported by PostgreSQL.
       def object_changes_col_is_json?
-        [:json, :jsonb].include?(columns_hash["object_changes"].try(:type))
+        %i(json jsonb).include?(columns_hash["object_changes"].try(:type))
       end
     end
 
@@ -306,13 +306,13 @@ module PaperTrail
       end
     end
 
-    # Checks that a value has been set for the `version_limit` config
-    # option, and if so enforces it.
+    # Enforces the `version_limit`, if set. Default: no limit.
     # @api private
     def enforce_version_limit!
       limit = PaperTrail.config.version_limit
       return unless limit.is_a? Numeric
-      previous_versions = sibling_versions.not_creates
+      previous_versions = sibling_versions.not_creates.
+        order(self.class.timestamp_sort_order("asc"))
       return unless previous_versions.size > limit
       excess_versions = previous_versions - previous_versions.last(limit)
       excess_versions.map(&:destroy)