mongo_trails 10.3.1 → 14.0.1

data/lib/mongo_trails/events/base.rb

@@ -2,322 +2,19 @@
 
 module PaperTrail
   module Events
-    # We refer to times in the lifecycle of a record as "events". There are
-    # three events:
-    #
-    # - create
-    #   - `after_create` we call `RecordTrail#record_create`
-    # - update
-    #   - `after_update` we call `RecordTrail#record_update`
-    #   - `after_touch` we call `RecordTrail#record_update`
-    #   - `RecordTrail#save_with_version` calls `RecordTrail#record_update`
-    #   - `RecordTrail#update_columns` is also referred to as an update, though
-    #     it uses `RecordTrail#record_update_columns` rather than
-    #     `RecordTrail#record_update`
-    # - destroy
-    #   - `before_destroy` or `after_destroy` we call `RecordTrail#record_destroy`
-    #
-    # The value inserted into the `event` column of the versions table can also
-    # be overridden by the user, with `paper_trail_event`.
-    #
-    # @api private
     class Base
-      RAILS_GTE_5_1 = ::ActiveRecord.gem_version >= ::Gem::Version.new("5.1.0.beta1")
-
-      # @api private
-      def initialize(record, in_after_callback)
-        @record = record
-        @in_after_callback = in_after_callback
-      end
-
-      # Determines whether it is appropriate to generate a new version
-      # instance. A timestamp-only update (e.g. only `updated_at` changed) is
-      # considered notable unless an ignored attribute was also changed.
-      #
-      # @api private
-      def changed_notably?
-        if ignored_attr_has_changed?
-          timestamps = @record.send(:timestamp_attributes_for_update_in_model).map(&:to_s)
-          (notably_changed - timestamps).any?
-        else
-          notably_changed.any?
-        end
-      end
-
-      private
-
-      # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-      # https://github.com/paper-trail-gem/mongo_trails/pull/899
-      #
-      # @api private
-      def attribute_changed_in_latest_version?(attr_name)
-        if @in_after_callback && RAILS_GTE_5_1
-          @record.saved_change_to_attribute?(attr_name.to_s)
-        else
-          @record.attribute_changed?(attr_name.to_s)
-        end
-      end
-
-      # @api private
-      def nonskipped_attributes_before_change(is_touch)
-        cache_changed_attributes do
-          record_attributes = @record.attributes.except(*@record.paper_trail_options[:skip])
-
-          record_attributes.each_key do |k|
-            if @record.class.column_names.include?(k)
-              record_attributes[k] = attribute_in_previous_version(k, is_touch)
-            end
-          end
-        end
-      end
-
-      # Rails 5.1 changed the API of `ActiveRecord::Dirty`.
-      # @api private
-      def cache_changed_attributes
-        if RAILS_GTE_5_1
-          # Everything works fine as it is
-          yield
-        else
-          # Any particular call to `changed_attributes` produces the huge memory allocation.
-          # Lets use the generic AR workaround for that.
-          @record.send(:cache_changed_attributes) { yield }
-        end
-      end
-
-      # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-      # https://github.com/paper-trail-gem/mongo_trails/pull/899
-      #
-      # Event can be any of the three (create, update, destroy).
-      #
-      # @api private
-      def attribute_in_previous_version(attr_name, is_touch)
-        if RAILS_GTE_5_1
-          if @in_after_callback && !is_touch
-            # For most events, we want the original value of the attribute, before
-            # the last save.
-            @record.attribute_before_last_save(attr_name.to_s)
-          else
-            # We are either performing a `record_destroy` or a
-            # `record_update(is_touch: true)`.
-            @record.attribute_in_database(attr_name.to_s)
-          end
-        else
-          @record.attribute_was(attr_name.to_s)
-        end
-      end
-
-      # @api private
-      def calculated_ignored_array
-        ignore = @record.paper_trail_options[:ignore].dup
-        # Remove Hash arguments and then evaluate whether the attributes (the
-        # keys of the hash) should also get pushed into the collection.
-        ignore.delete_if do |obj|
-          obj.is_a?(Hash) &&
-            obj.each { |attr, condition|
-              ignore << attr if condition.respond_to?(:call) && condition.call(@record)
-            }
-        end
-      end
-
-      # @api private
-      def changed_and_not_ignored
-        skip = @record.paper_trail_options[:skip]
-        (changed_in_latest_version - calculated_ignored_array) - skip
-      end
-
-      # @api private
-      def changed_in_latest_version
-        # Memoized to reduce memory usage
-        @changed_in_latest_version ||= changes_in_latest_version.keys
-      end
-
-      # Rails 5.1 changed the API of `ActiveRecord::Dirty`. See
-      # https://github.com/paper-trail-gem/mongo_trails/pull/899
-      #
-      # @api private
-      def changes_in_latest_version
-        # Memoized to reduce memory usage
-        @changes_in_latest_version ||= begin
-          if @in_after_callback && RAILS_GTE_5_1
+      def load_changes_in_latest_version
+        changes =
+          if @in_after_callback
             @record.saved_changes
           else
             @record.changes
           end
-        end
-      end
 
-      # An attributed is "ignored" if it is listed in the `:ignore` option
-      # and/or the `:skip` option.  Returns true if an ignored attribute has
-      # changed.
-      #
-      # @api private
-      def ignored_attr_has_changed?
-        ignored = calculated_ignored_array + @record.paper_trail_options[:skip]
-        ignored.any? && (changed_in_latest_version & ignored).any?
-      end
-
-      # PT 10 has a new optional column, `item_subtype`
-      #
-      # @api private
-      def merge_item_subtype_into(data)
-        if @record.class.paper_trail.version_class.fields.key?("item_subtype")
-          data.merge!(item_subtype: @record.class.name)
+        changes.delete_if do |_k, v|
+          v.is_a?(Array) && v.size > 1 && v.last.is_a?(Hash) && v.uniq.size == 1
         end
       end
-
-      # Updates `data` from the model's `meta` option and from `controller_info`.
-      # Metadata is always recorded; that means all three events (create, update,
-      # destroy) and `update_columns`.
-      #
-      # @api private
-      def merge_metadata_into(data)
-        merge_metadata_from_model_into(data)
-        merge_metadata_from_controller_into(data)
-      end
-
-      # Updates `data` from `controller_info`.
-      #
-      # @api private
-      def merge_metadata_from_controller_into(data)
-        data.merge(PaperTrail.request.controller_info || {})
-      end
-
-      # Updates `data` from the model's `meta` option.
-      #
-      # @api private
-      def merge_metadata_from_model_into(data)
-        @record.paper_trail_options[:meta].each do |k, v|
-          data[k] = model_metadatum(v, data[:event])
-        end
-      end
-
-      # Given a `value` from the model's `meta` option, returns an object to be
-      # persisted. The `value` can be a simple scalar value, but it can also
-      # be a symbol that names a model method, or even a Proc.
-      #
-      # @api private
-      def model_metadatum(value, event)
-        if value.respond_to?(:call)
-          value.call(@record)
-        elsif value.is_a?(Symbol) && @record.respond_to?(value, true)
-          # If it is an attribute that is changing in an existing object,
-          # be sure to grab the current version.
-          if event != "create" &&
-              @record.has_attribute?(value) &&
-              attribute_changed_in_latest_version?(value)
-            attribute_in_previous_version(value, false)
-          else
-            @record.send(value)
-          end
-        else
-          value
-        end
-      end
-
-      # @api private
-      def notable_changes
-        changes_in_latest_version.delete_if { |k, _v|
-          !notably_changed.include?(k)
-        }
-      end
-
-      # @api private
-      def notably_changed
-        # Memoized to reduce memory usage
-        @notably_changed ||= begin
-          only = @record.paper_trail_options[:only].dup
-          # Remove Hash arguments and then evaluate whether the attributes (the
-          # keys of the hash) should also get pushed into the collection.
-          only.delete_if do |obj|
-            obj.is_a?(Hash) &&
-              obj.each { |attr, condition|
-                only << attr if condition.respond_to?(:call) && condition.call(@record)
-              }
-          end
-          only.empty? ? changed_and_not_ignored : (changed_and_not_ignored & only)
-        end
-      end
-
-      # Returns hash of attributes (with appropriate attributes serialized),
-      # omitting attributes to be skipped.
-      #
-      # @api private
-      def object_attrs_for_paper_trail(is_touch)
-        attrs = nonskipped_attributes_before_change(is_touch)
-        AttributeSerializers::ObjectAttribute.new(@record.class).serialize(attrs)
-        attrs
-      end
-
-      # @api private
-      def prepare_object_changes(changes)
-        changes = serialize_object_changes(changes)
-        recordable_object_changes(changes)
-      end
-
-      # Returns an object which can be assigned to the `object_changes`
-      # attribute of a nascent version record. If the `object_changes` column is
-      # a postgres `json` column, then a hash can be used in the assignment,
-      # otherwise the column is a `text` column, and we must perform the
-      # serialization here, using `PaperTrail.serializer`.
-      #
-      # @api private
-      # @param changes HashWithIndifferentAccess
-      def recordable_object_changes(changes)
-        if PaperTrail.config.object_changes_adapter&.respond_to?(:diff)
-          # We'd like to avoid the `to_hash` here, because it increases memory
-          # usage, but that would be a breaking change because
-          # `object_changes_adapter` expects a plain `Hash`, not a
-          # `HashWithIndifferentAccess`.
-          changes = PaperTrail.config.object_changes_adapter.diff(changes.to_hash)
-        end
-
-        if @record.class.paper_trail.version_class.object_changes_col_is_json?
-          changes
-        else
-          PaperTrail.serializer.dump(changes)
-        end
-      end
-
-      # Returns a boolean indicating whether to store serialized version diffs
-      # in the `object_changes` column of the version record.
-      #
-      # @api private
-      def record_object_changes?
-        @record.class.paper_trail.version_class.fields.keys.include?("object_changes")
-      end
-
-      # Returns a boolean indicating whether to store the original object during save.
-      #
-      # @api private
-      def record_object?
-        @record.class.paper_trail.version_class.fields.keys.include?("object")
-      end
-
-      # Returns an object which can be assigned to the `object` attribute of a
-      # nascent version record. If the `object` column is a postgres `json`
-      # column, then a hash can be used in the assignment, otherwise the column
-      # is a `text` column, and we must perform the serialization here, using
-      # `PaperTrail.serializer`.
-      #
-      # @api private
-      def recordable_object(is_touch)
-        if @record.class.paper_trail.version_class.object_col_is_json?
-          object_attrs_for_paper_trail(is_touch)
-        else
-          PaperTrail.serializer.dump(object_attrs_for_paper_trail(is_touch))
-        end
-      end
-
-      # @api private
-      def serialize_object_changes(changes)
-        AttributeSerializers::ObjectChangesAttribute.
-          new(@record.class).
-          serialize(changes)
-
-        # We'd like to convert this `HashWithIndifferentAccess` to a plain
-        # `Hash`, but we don't, to save memory.
-        changes
-      end
     end
   end
 end

data/lib/mongo_trails/model_config.rb

@@ -1,178 +1,8 @@
 # frozen_string_literal: true
 
 module PaperTrail
-  # Configures an ActiveRecord model, mostly at application boot time, but also
-  # sometimes mid-request, with methods like enable/disable.
   class ModelConfig
-    E_CANNOT_RECORD_AFTER_DESTROY = <<-STR.strip_heredoc.freeze
-      paper_trail.on_destroy(:after) is incompatible with ActiveRecord's
-      belongs_to_required_by_default. Use on_destroy(:before)
-      or disable belongs_to_required_by_default.
-    STR
-    E_HPT_ABSTRACT_CLASS = <<~STR.squish.freeze
-      An application model (%s) has been configured to use PaperTrail (via
-      `has_paper_trail`), but the version model it has been told to use (%s) is
-      an `abstract_class`. This could happen when an advanced feature called
-      Custom Version Classes (http://bit.ly/2G4ch0G) is misconfigured. When all
-      version classes are custom, PaperTrail::Version is configured to be an
-      `abstract_class`. This is fine, but all application models must be
-      configured to use concrete (not abstract) version models.
-    STR
-    E_MODEL_LIMIT_REQUIRES_ITEM_SUBTYPE = <<~STR.squish.freeze
-      To use PaperTrail's per-model limit in your %s model, you must have an
-      item_subtype column in your versions table. See documentation sections
-      2.e.1 Per-model limit, and 4.b.1 The optional item_subtype column.
-    STR
-    DPR_PASSING_ASSOC_NAME_DIRECTLY_TO_VERSIONS_OPTION = <<~STR.squish
-      Passing versions association name as `has_paper_trail versions: %{versions_name}`
-      is deprecated. Use `has_paper_trail versions: {name: %{versions_name}}` instead.
-      The hash you pass to `versions:` is now passed directly to `has_many`.
-    STR
-    DPR_CLASS_NAME_OPTION = <<~STR.squish
-      Passing Version class name as `has_paper_trail class_name: %{class_name}`
-      is deprecated. Use `has_paper_trail versions: {class_name: %{class_name}}`
-      instead. The hash you pass to `versions:` is now passed directly to `has_many`.
-    STR
-
-    def initialize(model_class)
-      @model_class = model_class
-    end
-
-    # Adds a callback that records a version after a "create" event.
-    #
-    # @api public
-    def on_create
-      @model_class.after_create { |r|
-        r.paper_trail.record_create if r.paper_trail.save_version?
-      }
-      return if @model_class.paper_trail_options[:on].include?(:create)
-      @model_class.paper_trail_options[:on] << :create
-    end
-
-    # Adds a callback that records a version before or after a "destroy" event.
-    #
-    # @api public
-    def on_destroy(recording_order = "before")
-      unless %w[after before].include?(recording_order.to_s)
-        raise ArgumentError, 'recording order can only be "after" or "before"'
-      end
-
-      if recording_order.to_s == "after" && cannot_record_after_destroy?
-        raise E_CANNOT_RECORD_AFTER_DESTROY
-      end
-
-      @model_class.send(
-        "#{recording_order}_destroy",
-        lambda do |r|
-          return unless r.paper_trail.save_version?
-          r.paper_trail.record_destroy(recording_order)
-        end
-      )
-
-      return if @model_class.paper_trail_options[:on].include?(:destroy)
-      @model_class.paper_trail_options[:on] << :destroy
-    end
-
-    # Adds a callback that records a version after an "update" event.
-    #
-    # @api public
-    def on_update
-      @model_class.before_save { |r|
-        r.paper_trail.reset_timestamp_attrs_for_update_if_needed
-      }
-      @model_class.after_update { |r|
-        if r.paper_trail.save_version?
-          r.paper_trail.record_update(
-            force: false,
-            in_after_callback: true,
-            is_touch: false
-          )
-        end
-      }
-      @model_class.after_update { |r|
-        r.paper_trail.clear_version_instance
-      }
-      return if @model_class.paper_trail_options[:on].include?(:update)
-      @model_class.paper_trail_options[:on] << :update
-    end
-
-    # Adds a callback that records a version after a "touch" event.
-    # @api public
-    def on_touch
-      @model_class.after_touch { |r|
-        r.paper_trail.record_update(
-          force: true,
-          in_after_callback: true,
-          is_touch: true
-        )
-      }
-    end
-
-    # Set up `@model_class` for PaperTrail. Installs callbacks, associations,
-    # "class attributes", instance methods, and more.
-    # @api private
-    def setup(options = {})
-      options[:on] ||= %i[create update destroy touch]
-      options[:on] = Array(options[:on]) # Support single symbol
-      @model_class.send :include, ::PaperTrail::Model::InstanceMethods
-      setup_options(options)
-      setup_associations(options)
-      check_presence_of_item_subtype_column(options)
-      @model_class.after_rollback { paper_trail.clear_rolled_back_versions }
-      setup_callbacks_from_options options[:on]
-    end
-
-    def version_class
-      @_version_class ||= @model_class.version_class_name.constantize
-    end
-
-    private
-
-    # Raises an error if the provided class is an `abstract_class`.
-    # @api private
-    def assert_concrete_activerecord_class(class_name)
-      if class_name.constantize.abstract_class?
-        raise format(E_HPT_ABSTRACT_CLASS, @model_class, class_name)
-      end
-    end
-
-    def cannot_record_after_destroy?
-      ::ActiveRecord::Base.belongs_to_required_by_default
-    end
-
-    # Some options require the presence of the `item_subtype` column. Currently
-    # only `limit`, but in the future there may be others.
-    #
-    # @api private
-    def check_presence_of_item_subtype_column(options)
-      return unless options.key?(:limit)
-      return if version_class.item_subtype_column_present?
-      raise format(E_MODEL_LIMIT_REQUIRES_ITEM_SUBTYPE, @model_class.name)
-    end
-
-    def check_version_class_name(options)
-      # @api private - `version_class_name`
-      @model_class.class_attribute :version_class_name
-      if options[:class_name]
-        ::ActiveSupport::Deprecation.warn(
-          format(
-            DPR_CLASS_NAME_OPTION,
-            class_name: options[:class_name].inspect
-          ),
-          caller(1)
-        )
-        options[:versions][:class_name] = options[:class_name]
-      end
-      @model_class.version_class_name = options[:versions][:class_name] || "PaperTrail::Version"
-    end
-
-    def check_versions_association_name(options)
-      # @api private - versions_association_name
-      @model_class.class_attribute :versions_association_name
-      @model_class.versions_association_name = options[:versions][:name] || :versions
-    end
-
-    def define_has_many_mongo_versions(options)
+    def define_has_many_versions(options)
       options = ensure_versions_option_is_hash(options)
       check_version_class_name(options)
       check_versions_association_name(options)
@@ -184,66 +14,5 @@ module PaperTrail
         end
       RUBY
     end
-
-    def ensure_versions_option_is_hash(options)
-      unless options[:versions].is_a?(Hash)
-        if options[:versions]
-          ::ActiveSupport::Deprecation.warn(
-            format(
-              DPR_PASSING_ASSOC_NAME_DIRECTLY_TO_VERSIONS_OPTION,
-              versions_name: options[:versions].inspect
-            ),
-            caller(1)
-          )
-        end
-        options[:versions] = {
-          name: options[:versions]
-        }
-      end
-      options
-    end
-
-    def get_versions_scope(options)
-      options[:versions][:scope] || -> { order(model.timestamp_sort_order) }
-    end
-
-    def setup_associations(options)
-      # @api private - version_association_name
-      @model_class.class_attribute :version_association_name
-      @model_class.version_association_name = options[:version] || :version
-
-      # The version this instance was reified from.
-      # @api public
-      @model_class.send :attr_accessor, @model_class.version_association_name
-
-      # @api public - paper_trail_event
-      @model_class.send :attr_accessor, :paper_trail_event
-
-      define_has_many_mongo_versions(options)
-    end
-
-    def setup_callbacks_from_options(options_on = [])
-      options_on.each do |event|
-        public_send("on_#{event}")
-      end
-    end
-
-    def setup_options(options)
-      # @api public - paper_trail_options - Let's encourage plugins to use eg.
-      # `paper_trail_options[:versions][:class_name]` rather than
-      # `version_class_name` because the former is documented and the latter is
-      # not.
-      @model_class.class_attribute :paper_trail_options
-      @model_class.paper_trail_options = options.dup
-
-      %i[ignore skip only].each do |k|
-        @model_class.paper_trail_options[k] = [@model_class.paper_trail_options[k]].
-          flatten.
-          compact.
-          map { |attr| attr.is_a?(Hash) ? attr.stringify_keys : attr.to_s }
-      end
-
-      @model_class.paper_trail_options[:meta] ||= {}
-    end
   end
 end

data/lib/mongo_trails/mongo_support/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mongoid'
 
 Mongoid.configure do |config|
@@ -6,4 +8,8 @@ Mongoid.configure do |config|
   config.log_level = :error
 end
 
-Mongoid::QueryCache.enabled = false
+if defined?(Mongo::QueryCache)
+  Mongo::QueryCache.enabled = false
+elsif defined?(Mongoid::QueryCache)
+  Mongoid::QueryCache.enabled = false
+end

data/lib/mongo_trails/mongo_support/criteria.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    def reset; end
+  end
+end