mongo_trails 10.3.1 → 14.0.0

data/gemfiles/rails_8_1.gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# This file was generated by Appraisal
+
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 8.1'
+gem 'after_commit_everywhere'
+gem 'appraisal', '~> 2.3'
+gem 'minitest', '~> 5.0'
+gem 'rake', '~> 13.0'
+gem 'rubocop', require: false
+gem 'sqlite3', '~> 2.9'
+
+gemspec path: '../'

data/gemfiles/rails_8_1.gemfile.lock

@@ -0,0 +1,143 @@
+PATH
+  remote: ..
+  specs:
+    mongo_trails (14.0.0)
+      mongoid (>= 7, < 10)
+      ostruct
+      paper_trail (~> 16)
+      sidekiq (>= 6.5, < 9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (8.1.3.1)
+      activesupport (= 8.1.3.1)
+    activerecord (8.1.3.1)
+      activemodel (= 8.1.3.1)
+      activesupport (= 8.1.3.1)
+      timeout (>= 0.4.0)
+    activesupport (8.1.3.1)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    after_commit_everywhere (1.6.0)
+      activerecord (>= 4.2)
+      activesupport
+    appraisal (2.5.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (4.1.2)
+    bson (5.2.0)
+    concurrent-ruby (1.3.8)
+    connection_pool (3.0.2)
+    drb (2.2.3)
+    i18n (1.15.2)
+      concurrent-ruby (~> 1.0)
+    json (2.21.2)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    minitest (5.27.0)
+    mongo (2.25.0)
+      base64
+      bson (>= 4.14.1, < 6.0.0)
+    mongoid (9.1.0)
+      activemodel (>= 5.1, < 8.2, != 7.0.0)
+      concurrent-ruby (>= 1.0.5, < 2.0)
+      mongo (>= 2.18.0, < 3.0.0)
+      ostruct
+    ostruct (0.6.3)
+    paper_trail (16.0.0)
+      activerecord (>= 6.1)
+      request_store (~> 1.4)
+    parallel (1.28.0)
+    parser (3.3.11.1)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    racc (1.8.1)
+    rack (3.2.7)
+    rainbow (3.1.1)
+    rake (13.3.1)
+    redis-client (0.30.1)
+      connection_pool
+    regexp_parser (2.12.0)
+    request_store (1.7.0)
+      rack (>= 1.4)
+    rubocop (1.86.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
+    sidekiq (8.1.7)
+      connection_pool (>= 3.0.0)
+      json (>= 2.16.0)
+      logger (>= 1.7.0)
+      rack (>= 3.2.0)
+      redis-client (>= 0.29.0)
+    sqlite3 (2.9.2-aarch64-linux-gnu)
+    sqlite3 (2.9.2-aarch64-linux-musl)
+    sqlite3 (2.9.2-arm-linux-gnu)
+    sqlite3 (2.9.2-arm-linux-musl)
+    sqlite3 (2.9.2-arm64-darwin)
+    sqlite3 (2.9.2-x86-linux-gnu)
+    sqlite3 (2.9.2-x86-linux-musl)
+    sqlite3 (2.9.2-x86_64-darwin)
+    sqlite3 (2.9.2-x86_64-linux-gnu)
+    sqlite3 (2.9.2-x86_64-linux-musl)
+    thor (1.5.0)
+    timeout (0.6.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  activerecord (~> 8.1)
+  after_commit_everywhere
+  appraisal (~> 2.3)
+  minitest (~> 5.0)
+  mongo_trails!
+  rake (~> 13.0)
+  rubocop
+  sqlite3 (~> 2.9)
+
+BUNDLED WITH
+  4.0.19

data/lib/mongo_trails/callback_propagation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MongoTrails
+  class CallbackPropagation
+    PRESERVED_ATTRIBUTES = %w[_id item_type item_id event object object_changes integer_id].freeze
+
+    attr_reader :version
+
+    def initialize(source, version, bang:)
+      @source = source
+      @version = version
+      @bang = bang
+    end
+
+    def merge!(new_version, bang:)
+      merge_changes!(new_version.object_changes)
+      copy_latest_metadata!(new_version)
+      @bang ||= bang
+      self
+    end
+
+    def snapshot
+      {
+        object_changes: version.object_changes.to_h.deep_dup,
+        metadata: latest_metadata.deep_dup,
+        bang: @bang
+      }
+    end
+
+    def restore!(snapshot)
+      version.object_changes = snapshot.fetch(:object_changes)
+      snapshot.fetch(:metadata).each { |attribute, value| version[attribute] = value }
+      @bang = snapshot.fetch(:bang)
+    end
+
+    def persist
+      version.send(:persist_version, version, bang: @bang)
+    ensure
+      clear
+    end
+
+    def clear
+      propagations = @source.instance_variable_get(:@mongo_trails_callback_propagations)
+      propagations&.delete(version.event) if propagations&.fetch(version.event, nil).equal?(self)
+    end
+
+    private
+
+    def merge_changes!(new_changes)
+      changes = version.object_changes.to_h.deep_dup
+
+      new_changes.to_h.each do |attribute, values|
+        key = attribute.to_s
+        changes[key] = merged_values(changes[key], values)
+        changes.delete(key) if unchanged?(changes[key])
+      end
+
+      version.object_changes = changes
+    end
+
+    def merged_values(previous_values, new_values)
+      previous_values ? [previous_values.first, new_values.last] : new_values
+    end
+
+    def unchanged?(values)
+      values.first == values.last
+    end
+
+    def copy_latest_metadata!(new_version)
+      latest_metadata(new_version).each { |attribute, value| version[attribute] = value }
+    end
+
+    def latest_metadata(source = version)
+      source.attributes.except(*PRESERVED_ATTRIBUTES)
+    end
+  end
+end

data/lib/mongo_trails/config.rb

@@ -1,41 +1,24 @@
 # frozen_string_literal: true
 
-require "singleton"
-require "mongo_trails/serializers/yaml"
-
 module PaperTrail
-  # Global configuration affecting all threads. Some thread-specific
-  # configuration can be found in `paper_trail.rb`, others in `controller.rb`.
   class Config
-    include Singleton
-
     attr_accessor(
-      :association_reify_error_behaviour,
-      :object_changes_adapter,
-      :serializer,
-      :version_limit,
-      :has_paper_trail_defaults,
       :mongo_config,
-      :mongo_prefix
+      :mongo_prefix,
+      :enable_sidekiq,
+      :sidekiq_worker,
+      :sidekiq_options,
+      :mongo_trails_config
     )
 
     def initialize
-      # Variables which affect all threads, whose access is synchronized.
       @mutex = Mutex.new
       @enabled = true
 
-      # Variables which affect all threads, whose access is *not* synchronized.
       @serializer = PaperTrail::Serializers::YAML
       @has_paper_trail_defaults = {}
-    end
-
-    # Indicates whether PaperTrail is on or off. Default: true.
-    def enabled
-      @mutex.synchronize { !!@enabled }
-    end
-
-    def enabled=(enable)
-      @mutex.synchronize { @enabled = enable }
+      @enable_sidekiq = false
+      @sidekiq_options = { queue: :default, retry: true, backtrace: false }
     end
   end
 end

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