mongoid 6.4.4 → 7.1.7

data/lib/mongoid/persistable/creatable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for persistence operations that create new documents.
+    # Defines behavior for persistence operations that create new documents.
     #
     # @since 4.0.0
     module Creatable

data/lib/mongoid/persistable/deletable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for persistence operations that delete documents.
+    # Defines behavior for persistence operations that delete documents.
     #
     # @since 4.0.0
     module Deletable
@@ -21,10 +23,12 @@ module Mongoid
       def delete(options = {})
         raise Errors::ReadonlyDocument.new(self.class) if readonly?
         prepare_delete do
-          if embedded?
-            delete_as_embedded(options)
-          else
-            delete_as_root
+          unless options[:persist] == false
+            if embedded?
+              delete_as_embedded(options)
+            else
+              delete_as_root
+            end
           end
         end
       end
@@ -113,11 +117,10 @@ module Mongoid
       #
       # @since 4.0.0
       def prepare_delete
-        cascade!
+        return false unless catch(:abort) { apply_delete_dependencies! }
         yield(self)
         freeze
         self.destroyed = true
-        true
       end
 
       module ClassMethods

data/lib/mongoid/persistable/destroyable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for persistence operations that destroy documents.
+    # Defines behavior for persistence operations that destroy documents.
     #
     # @since 4.0.0
     module Destroyable

data/lib/mongoid/persistable/incrementable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $inc operations.
+    # Defines behavior for $inc operations.
     #
     # @since 4.0.0
     module Incrementable
@@ -25,10 +27,12 @@ module Mongoid
           process_atomic_operations(increments) do |field, value|
             increment = value.__to_inc__
             current = attributes[field]
-            attributes[field] = (current || 0) + increment
+            new_value = (current || 0) + increment
+            process_attribute field, new_value if executing_atomically?
+            attributes[field] = new_value
             ops[atomic_attribute_name(field)] = increment
           end
-          { "$inc" => ops }
+          { "$inc" => ops } unless ops.empty?
         end
       end
     end

data/lib/mongoid/persistable/logical.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for logical bitwise operations.
+    # Defines behavior for logical bitwise operations.
     #
     # @since 4.0.0
     module Logical
@@ -27,10 +29,11 @@ module Mongoid
               value = value & val if op.to_s == "and"
               value = value | val if op.to_s == "or"
             end
+            process_attribute field, value if executing_atomically?
             attributes[field] = value
             ops[atomic_attribute_name(field)] = values
           end
-          { "$bit" => ops }
+          { "$bit" => ops } unless ops.empty?
         end
       end
     end

data/lib/mongoid/persistable/poppable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $pop operations.
+    # Defines behavior for $pop operations.
     #
     # @since 4.0.0
     module Poppable

data/lib/mongoid/persistable/pullable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $pull and $pullAll operations.
+    # Defines behavior for $pull and $pullAll operations.
     #
     # @since 4.0.0
     module Pullable

data/lib/mongoid/persistable/pushable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $push and $addToSet operations.
+    # Defines behavior for $push and $addToSet operations.
     #
     # @since 4.0.0
     module Pushable
@@ -22,7 +24,13 @@ module Mongoid
       def add_to_set(adds)
         prepare_atomic_operation do |ops|
           process_atomic_operations(adds) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || attributes[field]
+            if existing.nil?
+              attributes[field] = []
+              # Read the value out of attributes:
+              # https://jira.mongodb.org/browse/MONGOID-4874
+              existing = attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each do |val|
               existing.push(val) unless existing.include?(val)
@@ -49,7 +57,10 @@ module Mongoid
       def push(pushes)
         prepare_atomic_operation do |ops|
           process_atomic_operations(pushes) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || begin
+              attributes[field] ||= []
+              attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each{ |val| existing.push(val) }
             ops[atomic_attribute_name(field)] = { "$each" => values }

data/lib/mongoid/persistable/renamable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $rename operations.
+    # Defines behavior for $rename operations.
     #
     # @since 4.0.0
     module Renamable
@@ -13,7 +15,7 @@ module Mongoid
       # @example Rename the fields.
       #   document.rename(title: "salutation", name: "nombre")
       #
-      # @note This does not work for fields in embeds many relations.
+      # @note This does not work for fields in embeds many associations.
       #
       # @param [ Hash ] renames The rename pairs of old name/new name.
       #
@@ -24,7 +26,12 @@ module Mongoid
         prepare_atomic_operation do |ops|
           process_atomic_operations(renames) do |old_field, new_field|
             new_name = new_field.to_s
-            attributes[new_name] = attributes.delete(old_field)
+            if executing_atomically?
+              process_attribute new_name, attributes[old_field]
+              process_attribute old_field, nil
+            else
+              attributes[new_name] = attributes.delete(old_field)
+            end
             ops[atomic_attribute_name(old_field)] = atomic_attribute_name(new_name)
           end
           { "$rename" => ops }

data/lib/mongoid/persistable/savable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for persistence operations that save documents.
+    # Defines behavior for persistence operations that save documents.
     #
     # @since 4.0.0
     module Savable

data/lib/mongoid/persistable/settable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $set operations.
+    # Defines behavior for $set operations.
     #
     # @since 4.0.0
     module Settable
@@ -14,6 +16,34 @@ module Mongoid
       # @example Set the values.
       #   document.set(title: "sir", dob: Date.new(1970, 1, 1))
       #
+      # The key can be a dotted sequence of keys, in which case the
+      # top level field is treated as a nested hash and any missing keys
+      # are created automatically:
+      #
+      # @example Set the values using nested hash semantics.
+      #   document.set('author.title' => 'Sir')
+      #   # => document.author == {'title' => 'Sir'}
+      #
+      # Performing a nested set like this merges values of intermediate keys:
+      #
+      # @example Nested hash value merging.
+      #   document.set('author.title' => 'Sir')
+      #   document.set('author.name' => 'Linus Torvalds')
+      #   # => document.author == {'title' => 'Sir', 'name' => 'Linus Torvalds'}
+      #
+      # If the top level field was not a hash, its original value is discarded
+      # and the field is replaced with a hash.
+      #
+      # @example Nested hash overwriting a non-hash value.
+      #   document.set('author' => 'John Doe')
+      #   document.set('author.title' => 'Sir')
+      #   # => document.author == {'title' => 'Sir'}
+      #
+      # Note that unlike MongoDB's $set, Mongoid's set writes out the entire
+      # field even when setting a subset of the field via the nested hash
+      # semantics. This means performing a $set with nested hash semantics
+      # can overwrite other hash keys within the top level field in the database.
+      #
       # @param [ Hash ] setters The field/value pairs to set.
       #
       # @return [ Document ] The document.
@@ -23,16 +53,38 @@ module Mongoid
         prepare_atomic_operation do |ops|
           process_atomic_operations(setters) do |field, value|
 
-            field_and_value_hash = hasherizer(field.split('.'), value)
-            field = field_and_value_hash.keys.first.to_s
-            value = field_and_value_hash[field]
+            field_seq = field.to_s.split('.')
+            field = field_seq.shift
+            if field_seq.length > 0
+              # nested hash path
+              old_value = attributes[field]
+
+              # if the old value is not a hash, clobber it
+              unless Hash === old_value
+                old_value = {}
+              end
+
+              # descend into the hash, creating intermediate keys as needed
+              cur_value = old_value
+              while field_seq.length > 1
+                cur_key = field_seq.shift
+                # clobber on each level if type is not a hash
+                unless Hash === cur_value[cur_key]
+                  cur_value[cur_key] = {}
+                end
+                cur_value = cur_value[cur_key]
+              end
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field) && Hash === value && !value.empty?
-              merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = (attributes[field] || {}).merge(value, &merger)
+              # now we are on the leaf level, perform the set
+              # and overwrite whatever was on this level before
+              cur_value[field_seq.shift] = value
+
+              # and set value to the value of the top level field
+              # because this is what we pass to $set
+              value = old_value
             end
 
-            process_attribute(field.to_s, value)
+            process_attribute(field, value)
 
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
@@ -42,10 +94,5 @@ module Mongoid
         end
       end
     end
-
-    def hasherizer(keys, value)
-      return value if keys.empty?
-      {}.tap { |hash| hash[keys.shift] = hasherizer(keys, value) }
-    end
   end
 end

data/lib/mongoid/persistable/unsettable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for $unset operations.
+    # Defines behavior for $unset operations.
     #
     # @since 4.0.0
     module Unsettable
@@ -24,7 +26,11 @@ module Mongoid
         prepare_atomic_operation do |ops|
           fields.flatten.each do |field|
             normalized = database_field_name(field)
-            attributes.delete(normalized)
+            if executing_atomically?
+              process_attribute normalized, nil
+            else
+              attributes.delete(normalized)
+            end
             ops[atomic_attribute_name(normalized)] = true
           end
           { "$unset" => ops }
@@ -33,4 +39,3 @@ module Mongoid
     end
   end
 end
-

data/lib/mongoid/persistable/updatable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for persistence operations that update existing
+    # Defines behavior for persistence operations that update existing
     # documents.
     #
     # @since 4.0.0

data/lib/mongoid/persistable/upsertable.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Persistable
 
-    # Defines behaviour for persistence operations that upsert documents.
+    # Defines behavior for persistence operations that upsert documents.
     #
     # @since 4.0.0
     module Upsertable

data/lib/mongoid/persistable.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 require "mongoid/persistable/creatable"
 require "mongoid/persistable/deletable"
 require "mongoid/persistable/destroyable"
@@ -16,7 +18,7 @@ require "mongoid/persistable/unsettable"
 
 module Mongoid
 
-  # Contains general behaviour for persistence operations.
+  # Contains general behavior for persistence operations.
   #
   # @since 2.0.0
   module Persistable
@@ -43,24 +45,80 @@ module Mongoid
     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
     #
+    # @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
+    #
+    # @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.
     #
     # @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
+    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
 
@@ -103,7 +161,7 @@ module Mongoid
     #
     # @since 4.0.0
     def executing_atomically?
-      !@atomic_updates_to_execute.nil?
+      !@atomic_updates_to_execute_stack.nil?
     end
 
     # Post process the persistence operation.
@@ -144,7 +202,7 @@ module Mongoid
       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.
     #
@@ -162,13 +220,72 @@ module Mongoid
     # @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.
     #
@@ -183,8 +300,8 @@ module Mongoid
     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)
@@ -202,7 +319,7 @@ module Mongoid
     #
     # @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