mongoid 6.4.8 → 7.5.4

data/lib/mongoid/persistable.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require "mongoid/persistable/creatable"
 require "mongoid/persistable/deletable"
 require "mongoid/persistable/destroyable"
@@ -16,9 +17,7 @@ require "mongoid/persistable/unsettable"
 
 module Mongoid
 
-  # Contains general behaviour for persistence operations.
-  #
-  # @since 2.0.0
+  # Contains general behavior for persistence operations.
   module Persistable
     extend ActiveSupport::Concern
     include Creatable
@@ -38,29 +37,81 @@ module Mongoid
     include Unsettable
 
     # The atomic operations that deal with arrays or sets in the db.
-    #
-    # @since 4.0.0
     LIST_OPERATIONS = [ "$addToSet", "$push", "$pull", "$pullAll" ].freeze
 
     # Execute operations atomically (in a single database call) for everything
-    # that would happen inside the block.
+    # that would happen inside the block. This method supports nesting further
+    # calls to atomically, which will behave according to the options described
+    # below.
+    #
+    # An option join_context can be given which, when true, will merge the
+    # operations declared by the given block with the atomically block wrapping
+    # the current invocation for the same document, if one exists. If this
+    # block or any other block sharing the same context raises before
+    # persisting, then all the operations of that context will not be
+    # persisted, and will also be reset in memory.
+    #
+    # When join_context is false, the given block of operations will be
+    # persisted independently of other contexts. Failures in other contexts will
+    # not affect this one, so long as this block was able to run and persist
+    # changes.
+    #
+    # The default value of join_context is set by the global configuration
+    # option join_contexts, whose own default is false.
     #
     # @example Execute the operations atomically.
     #   document.atomically do
     #     document.set(name: "Tool").inc(likes: 10)
     #   end
     #
-    # @return [ true, false ] If the operation succeeded.
+    # @example Execute some inner operations atomically, but independently from the outer operations.
+    #
+    #   document.atomically do
+    #     document.inc likes: 10
+    #     document.atomically join_context: false do
+    #       # The following is persisted to the database independently.
+    #       document.unset :origin
+    #     end
+    #     document.atomically join_context: true do
+    #       # The following is persisted along with the other outer operations.
+    #       document.inc member_count: 3
+    #     end
+    #     document.set name: "Tool"
+    #   end
     #
-    # @since 4.0.0
-    def atomically
-      begin
-        @atomic_updates_to_execute = @atomic_updates_to_execute || {}
-        yield(self) if block_given?
-        persist_atomic_operations(@atomic_updates_to_execute)
-        true
-      ensure
-        @atomic_updates_to_execute = nil
+    # @param [ true, false ] join_context Join the context (i.e. merge
+    #   declared atomic operations) of the atomically block wrapping this one
+    #   for the same document, if one exists.
+    #
+    # @return [ true, false ] If the operation succeeded.
+    def atomically(join_context: nil)
+      join_context = Mongoid.join_contexts if join_context.nil?
+      call_depth = @atomic_depth ||= 0
+      has_own_context = call_depth.zero? || !join_context
+      @atomic_updates_to_execute_stack ||= []
+      _mongoid_push_atomic_context if has_own_context
+
+      if block_given?
+        @atomic_depth += 1
+        yield(self)
+        @atomic_depth -= 1
+      end
+
+      if has_own_context
+        persist_atomic_operations @atomic_context
+        _mongoid_remove_atomic_context_changes
+      end
+
+      true
+    rescue Exception => e
+      _mongoid_reset_atomic_context_changes! if has_own_context
+      raise e
+    ensure
+      _mongoid_pop_atomic_context if has_own_context
+
+      if call_depth.zero?
+        @atomic_depth = nil
+        @atomic_updates_to_execute_stack = nil
       end
     end
 
@@ -70,8 +121,6 @@ module Mongoid
     #   Person.fail_due_to_validation!(person)
     #
     # @raise [ Errors::Validations ] The validation error.
-    #
-    # @since 4.0.0
     def fail_due_to_validation!
       raise Errors::Validations.new(self)
     end
@@ -84,8 +133,6 @@ module Mongoid
     # @param [ Symbol ] method The method being called.
     #
     # @raise [ Errors::Callback ] The callback error.
-    #
-    # @since 4.0.0
     def fail_due_to_callback!(method)
       raise Errors::Callback.new(self.class, method)
     end
@@ -100,10 +147,8 @@ module Mongoid
     #   document.executing_atomically?
     #
     # @return [ true, false ] If we are current executing atomically.
-    #
-    # @since 4.0.0
     def executing_atomically?
-      !@atomic_updates_to_execute.nil?
+      !@atomic_updates_to_execute_stack.nil?
     end
 
     # Post process the persistence operation.
@@ -117,8 +162,6 @@ module Mongoid
     # @param [ Hash ] options The options.
     #
     # @return [ true ] true.
-    #
-    # @since 4.0.0
     def post_process_persist(result, options = {})
       post_persist unless result == false
       errors.clear unless performing_validations?(options)
@@ -136,15 +179,13 @@ module Mongoid
     #   end
     #
     # @return [ Object ] The result of the operation.
-    #
-    # @since 4.0.0
     def prepare_atomic_operation
       operations = yield({})
       persist_or_delay_atomic_operation(operations)
       self
     end
 
-    # Process the atomic operations - this handles the common behaviour of
+    # Process the atomic operations - this handles the common behavior of
     # iterating through each op, getting the aliased field name, and removing
     # appropriate dirty changes.
     #
@@ -158,17 +199,74 @@ module Mongoid
     # @param [ Hash ] operations The atomic operations.
     #
     # @return [ Hash ] The operations.
-    #
-    # @since 4.0.0
     def process_atomic_operations(operations)
       operations.each do |field, value|
-        as_writable_attribute!(field, value) do |access|
-          yield(access, value)
-          remove_change(access)
-        end
+        access = database_field_name(field)
+        yield(access, value)
+        remove_change(access) unless executing_atomically?
       end
     end
 
+    # Remove the dirty changes for all fields changed in the current atomic
+    # context.
+    #
+    # @api private
+    #
+    # @example Remove the current atomic context's dirty changes.
+    #   document._mongoid_remove_atomic_context_changes
+    def _mongoid_remove_atomic_context_changes
+      return unless executing_atomically?
+      _mongoid_atomic_context_changed_fields.each { |f| remove_change f }
+    end
+
+    # Reset the attributes for all fields changed in the current atomic
+    # context.
+    #
+    # @api private
+    #
+    # @example Reset the current atomic context's changed attributes.
+    #   document._mongoid_reset_atomic_context_changes!
+    def _mongoid_reset_atomic_context_changes!
+      return unless executing_atomically?
+      _mongoid_atomic_context_changed_fields.each { |f| reset_attribute! f }
+    end
+
+    # Push a new atomic context onto the stack.
+    #
+    # @api private
+    #
+    # @example Push a new atomic context onto the stack.
+    #   document._mongoid_push_atomic_context
+    def _mongoid_push_atomic_context
+      return unless executing_atomically?
+      @atomic_context = {}
+      @atomic_updates_to_execute_stack << @atomic_context
+    end
+
+    # Pop an atomic context off the stack.
+    #
+    # @api private
+    #
+    # @example Pop an atomic context off the stack.
+    #   document._mongoid_pop_atomic_context
+    def _mongoid_pop_atomic_context
+      return unless executing_atomically?
+      @atomic_updates_to_execute_stack.pop
+      @atomic_context = @atomic_updates_to_execute_stack.last
+    end
+
+    # Return the current atomic context's changed fields.
+    #
+    # @api private
+    #
+    # @example Return the current atomic context's changed fields.
+    #   document._mongoid_atomic_context_changed_fields
+    #
+    # @return [ Array ] The changed fields.
+    def _mongoid_atomic_context_changed_fields
+      @atomic_context.values.flat_map(&:keys)
+    end
+
     # If we are in an atomically block, add the operations to the delayed group,
     # otherwise persist immediately.
     #
@@ -178,13 +276,11 @@ module Mongoid
     #   document.persist_or_delay_atomic_operation(ops)
     #
     # @param [ Hash ] operation The operation.
-    #
-    # @since 4.0.0
     def persist_or_delay_atomic_operation(operation)
       if executing_atomically?
         operation.each do |(name, hash)|
-          @atomic_updates_to_execute[name] ||= {}
-          @atomic_updates_to_execute[name].merge!(hash)
+          @atomic_context[name] ||= {}
+          @atomic_context[name].merge!(hash)
         end
       else
         persist_atomic_operations(operation)
@@ -199,10 +295,8 @@ module Mongoid
     #   persist_atomic_operations(ops)
     #
     # @param [ Hash ] operations The atomic operations.
-    #
-    # @since 4.0.0
     def persist_atomic_operations(operations)
-      if persisted? && operations
+      if persisted? && operations && !operations.empty?
         selector = atomic_selector
         _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
       end

data/lib/mongoid/persistence_context.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 module Mongoid
 
   # Object encapsulating logic for setting/getting a collection and database name
   # and a client with particular options to use when persisting models.
-  #
-  # @since 6.0.0
   class PersistenceContext
     extend Forwardable
 
@@ -16,8 +16,6 @@ module Mongoid
     # The options defining this persistence context.
     #
     # @return [ Hash ] The persistence context options.
-    #
-    # @since 6.0.0
     attr_reader :options
 
     # Extra options in addition to driver client options that determine the
@@ -25,8 +23,6 @@ module Mongoid
     #
     # @return [ Array<Symbol> ] The list of extra options besides client options
     #   that determine the persistence context.
-    #
-    # @since 6.0.0
     EXTRA_OPTIONS = [ :client,
                       :collection
                     ].freeze
@@ -35,8 +31,6 @@ module Mongoid
     #
     # @return [ Array<Symbol> ] The full list of options defining the persistence
     #   context.
-    #
-    # @since 6.0.0
     VALID_OPTIONS = ( Mongo::Client::VALID_OPTIONS + EXTRA_OPTIONS ).freeze
 
     # Initialize the persistence context object.
@@ -47,8 +41,6 @@ module Mongoid
     # @param [ Object ] object The class or model instance for which a persistence context
     #   should be created.
     # @param [ Hash ] opts The persistence context options.
-    #
-    # @since 6.0.0
     def initialize(object, opts = {})
       @object = object
       set_options!(opts)
@@ -64,8 +56,6 @@ module Mongoid
     #
     # @return [ Mongo::Collection ] The collection for this persistence
     #   context.
-    #
-    # @since 6.0.0
     def collection(parent = nil)
       parent ? parent.collection.with(client_options) : client[collection_name.to_sym]
     end
@@ -77,8 +67,6 @@ module Mongoid
     #
     # @return [ String ] The collection name for this persistence
     #  context.
-    #
-    # @since 6.0.0
     def collection_name
       @collection_name ||= (__evaluate__(options[:collection] ||
                              storage_options[:collection]))
@@ -91,8 +79,6 @@ module Mongoid
     #
     # @return [ String ] The database name for this persistence
     #  context.
-    #
-    # @since 6.0.0
     def database_name
       __evaluate__(database_name_option) || client.database.name
     end
@@ -104,16 +90,23 @@ module Mongoid
     #
     # @return [ Mongo::Client ] The client for this persistence
     #  context.
-    #
-    # @since 6.0.0
     def client
-      client_options = send(:client_options)
-      if client_options[:read].is_a?(Symbol)
-        client_options = client_options.merge(read: {mode: client_options[:read]})
+      @client ||= begin
+        client = Clients.with_name(client_name)
+        if database_name_option
+          client = client.use(database_name)
+        end
+        unless client_options.empty?
+          client = client.with(client_options)
+        end
+        client
       end
-      @client ||= (client = Clients.with_name(client_name)
-                    client = client.use(database_name) if database_name_option
-                    client.with(client_options))
+    end
+
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
     end
 
     # Determine if this persistence context is equal to another.
@@ -124,21 +117,28 @@ module Mongoid
     # @param [ Object ] other The object to be compared with this one.
     #
     # @return [ true, false ] Whether the two persistence contexts are equal.
-    #
-    # @since 6.0.0
     def ==(other)
       return false unless other.is_a?(PersistenceContext)
       options == other.options
     end
 
-    private
-
-    def client_name
-      @client_name ||= options[:client] ||
-                         Threaded.client_override ||
-                         storage_options && __evaluate__(storage_options[:client])
+    # Whether the client of the context can be reused later, and therefore should
+    # not be closed.
+    #
+    # If the persistence context is requested with :client option only, it means
+    # that the context should use a client configured in mongoid.yml.
+    # Such clients should not be closed when the context is cleared since they
+    # will be reused later.
+    #
+    # @return [ true | false ] True if client can be reused, otherwise false.
+    #
+    # @api private
+    def reusable_client?
+      @options.keys == [:client]
     end
 
+    private
+
     def set_options!(opts)
       @options ||= opts.each.reduce({}) do |_options, (key, value)|
                      unless VALID_OPTIONS.include?(key.to_sym)
@@ -154,9 +154,15 @@ module Mongoid
     end
 
     def client_options
-      @client_options ||= options.select do |k, v|
-                            Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
-                          end
+      @client_options ||= begin
+        opts = options.select do |k, v|
+                              Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
+                            end
+        if opts[:read].is_a?(Symbol)
+          opts[:read] = {mode: opts[:read]}
+        end
+        opts
+      end
     end
 
     def database_name_option
@@ -169,6 +175,9 @@ module Mongoid
 
       # Set the persistence context for a particular class or model instance.
       #
+      # If there already is a persistence context set, options in the existing
+      # context are combined with options given to the set call.
+      #
       # @example Set the persistence context for a class or model instance.
       #  PersistenceContext.set(model)
       #
@@ -177,12 +186,19 @@ module Mongoid
       #   options or a persistence context object.
       #
       # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
-      #
-      # @since 6.0.0
       def set(object, options_or_context)
-        context = PersistenceContext.new(object, options_or_context.is_a?(PersistenceContext) ?
-                                                   options_or_context.options : options_or_context)
-        Thread.current["[mongoid][#{object.object_id}]:context"] = context
+        existing_context = get_context(object)
+        existing_options = if existing_context
+          existing_context.options
+        else
+          {}
+        end
+        if options_or_context.is_a?(PersistenceContext)
+          options_or_context = options_or_context.options
+        end
+        new_options = existing_options.merge(options_or_context)
+        context = PersistenceContext.new(object, new_options)
+        store_context(object, context)
       end
 
       # Get the persistence context for a particular class or model instance.
@@ -193,10 +209,8 @@ module Mongoid
       # @param [ Object ] object The class or model instance.
       #
       # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
-      #
-      # @since 6.0.0
       def get(object)
-        Thread.current["[mongoid][#{object.object_id}]:context"]
+        get_context(object)
       end
 
       # Clear the persistence context for a particular class or model instance.
@@ -206,14 +220,53 @@ module Mongoid
       #
       # @param [ Class, Object ] object The class or model instance.
       # @param [ Mongo::Cluster ] cluster The original cluster before this context was used.
-      #
-      # @since 6.0.0
-      def clear(object, cluster = nil)
+      # @param [ Mongoid::PersistenceContext ] original_context The original persistence
+      #   context that was set before this context was used.
+      def clear(object, cluster = nil, original_context = nil)
         if context = get(object)
-          context.client.close unless (context.cluster.equal?(cluster) || cluster.nil?)
+          unless cluster.nil? || context.cluster.equal?(cluster)
+            context.client.close unless context.reusable_client?
+          end
         end
       ensure
-        Thread.current["[mongoid][#{object.object_id}]:context"] = nil
+        store_context(object, original_context)
+      end
+
+      private
+
+      # Key to store persistence contexts in the thread local storage.
+      #
+      # @api private
+      PERSISTENCE_CONTEXT_KEY = :"[mongoid]:persistence_context"
+
+      # Get the persistence context for a given object from the thread local
+      #   storage.
+      #
+      # @param [ Object ] object Object to get the persistance context for.
+      #
+      # @return [ Mongoid::PersistenceContext | nil ] The persistence context
+      #   for the object if previously stored, otherwise nil.
+      #
+      # @api private
+      def get_context(object)
+        Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
+        Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id]
+      end
+
+      # Store persistence context for a given object in the thread local
+      #   storage.
+      #
+      # @param [ Object ] object Object to store the persistance context for.
+      # @param [ Mongoid::PersistenceContext ] context Context to store
+      #
+      # @api private
+      def store_context(object, context)
+        if context.nil?
+          Thread.current[PERSISTENCE_CONTEXT_KEY]&.delete(object.object_id)
+        else
+          Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
+          Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id] = context
+        end
       end
     end
   end

data/lib/mongoid/positional.rb

@@ -1,10 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
 
   # This module is responsible for taking update selectors and switching out
   # the indexes for the $ positional operator where appropriate.
-  #
-  # @since 4.0.0
   module Positional
 
     # Takes the provided selector and atomic operations and replaces the
@@ -31,8 +30,6 @@ module Mongoid
     # @param [ Hash ] processed The processed update operations.
     #
     # @return [ Hash ] The new operations.
-    #
-    # @since 3.1.0
     def positionally(selector, operations, processed = {})
       if selector.size == 1 || selector.values.any? { |val| val.nil? }
         return operations
@@ -64,7 +61,7 @@ module Mongoid
       matches = position.scan(/\.\d+\./)
       if matches.size == 1
         keys.each do |kk|
-          if position =~ /^#{kk}\.\d+\.(.*)/
+          if position =~ /\A#{kk}\.\d+\.(.*)\z/
             return "#{kk}.$.#{$1}"
           end
         end