mongoid 7.5.3 → 8.1.2

data/lib/mongoid/interceptable.rb

@@ -27,7 +27,7 @@ module Mongoid
       :before_save,
       :before_update,
       :before_upsert,
-      :before_validation
+      :before_validation,
     ].freeze
 
     included do
@@ -37,6 +37,12 @@ module Mongoid
       define_model_callbacks :build, :find, :initialize, :touch, only: :after
       define_model_callbacks :create, :destroy, :save, :update, :upsert
 
+      # This callback is used internally by Mongoid to save association
+      # targets for referenced associations after the parent model is persisted.
+      #
+      # @api private
+      define_model_callbacks :persist_parent
+
       attr_accessor :before_callback_halted
     end
 
@@ -47,7 +53,7 @@ module Mongoid
     #
     # @param [ Symbol ] kind The type of callback.
     #
-    # @return [ true, false ] If the callback can be executed.
+    # @return [ true | false ] If the callback can be executed.
     def callback_executable?(kind)
       respond_to?("_#{kind}_callbacks")
     end
@@ -60,7 +66,7 @@ module Mongoid
     #
     # @param [ Symbol ] kind The callback kind.
     #
-    # @return [ true, false ] If the document is in a callback state.
+    # @return [ true | false ] If the document is in a callback state.
     def in_callback_state?(kind)
       [ :create, :destroy ].include?(kind) || new_record? || flagged_for_destroy? || changed?
     end
@@ -73,7 +79,7 @@ module Mongoid
     # @example Run only the after save callbacks.
     #   model.run_after_callbacks(:save)
     #
-    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    # @param [ Symbol... ] *kinds The events that are occurring.
     #
     # @return [ Object ] The result of the chain executing.
     def run_after_callbacks(*kinds)
@@ -90,7 +96,7 @@ module Mongoid
     # @example Run only the before save callbacks.
     #   model.run_before_callbacks(:save, :create)
     #
-    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    # @param [ Symbol... ] *kinds The events that are occurring.
     #
     # @return [ Object ] The result of the chain executing.
     def run_before_callbacks(*kinds)
@@ -109,22 +115,77 @@ module Mongoid
     #   end
     #
     # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array ] args Any options.
-    #
-    # @return [ Document ] The document
-    ruby2_keywords def run_callbacks(kind, *args, &block)
-      cascadable_children(kind).each do |child|
-        if child.run_callbacks(child_callback_type(kind, child), *args) == false
-          return false
+    # @param [ true | false ] with_children Flag specifies whether callbacks of embedded document should be run.
+    def run_callbacks(kind, with_children: true, &block)
+      if with_children
+        cascadable_children(kind).each do |child|
+          if child.run_callbacks(child_callback_type(kind, child), with_children: with_children) == false
+            return false
+          end
         end
       end
       if callback_executable?(kind)
-        super(kind, *args, &block)
+        super(kind, &block)
       else
         true
       end
     end
 
+    # Run the callbacks for embedded documents.
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array<Document> ] children Children to execute callbacks on. If
+    #   nil, callbacks will be executed on all cascadable children of
+    #   the document.
+    #
+    # @api private
+    def _mongoid_run_child_callbacks(kind, children: nil, &block)
+      child, *tail = (children || cascadable_children(kind))
+      with_children = !Mongoid::Config.prevent_multiple_calls_of_embedded_callbacks
+      if child.nil?
+        block&.call
+      elsif tail.empty?
+        child.run_callbacks(child_callback_type(kind, child), with_children: with_children, &block)
+      else
+        child.run_callbacks(child_callback_type(kind, child), with_children: with_children) do
+          _mongoid_run_child_callbacks(kind, children: tail, &block)
+        end
+      end
+    end
+
+    # This is used to store callbacks to be executed later. A good use case for
+    # this is delaying the after_find and after_initialize callbacks until the
+    # associations are set on the document. This can also be used to delay
+    # applying the defaults on a document.
+    #
+    # @return [ Array<Symbol> ] an array of symbols that represent the pending callbacks.
+    #
+    # @api private
+    def pending_callbacks
+      @pending_callbacks ||= [].to_set
+    end
+
+    # @api private
+    def pending_callbacks=(value)
+      @pending_callbacks = value
+    end
+
+    # Run the pending callbacks. If the callback is :apply_defaults, we will apply
+    # the defaults for this document. Otherwise, the callback is passed to the
+    # run_callbacks function.
+    #
+    # @api private
+    def run_pending_callbacks
+      pending_callbacks.each do |cb|
+        if [:apply_defaults, :apply_post_processed_defaults].include?(cb)
+          send(cb)
+        else
+          self.run_callbacks(cb, with_children: false)
+        end
+      end
+      pending_callbacks.clear
+    end
+
     private
 
     # We need to hook into this for autosave, since we don't want it firing if
@@ -135,7 +196,7 @@ module Mongoid
     # @example Was a before callback halted?
     #   document.before_callback_halted?
     #
-    # @return [ true, false ] If a before callback was halted.
+    # @return [ true | false ] If a before callback was halted.
     def before_callback_halted?
       !!@before_callback_halted
     end
@@ -175,7 +236,7 @@ module Mongoid
     # @param [ Symbol ] kind The type of callback.
     # @param [ Document ] child The child document.
     #
-    # @return [ true, false ] If the child should fire the callback.
+    # @return [ true | false ] If the child should fire the callback.
     def cascadable_child?(kind, child, association)
       return false if kind == :initialize || kind == :find || kind == :touch
       return false if kind == :validate && association.validate?

data/lib/mongoid/matchable.rb

@@ -15,7 +15,7 @@ module Mongoid
     #
     # @param [ Hash ] selector The MongoDB selector.
     #
-    # @return [ true, false ] True if matches, false if not.
+    # @return [ true | false ] True if matches, false if not.
     def _matches?(selector)
       Matcher::Expression.matches?(self, selector)
     end

data/lib/mongoid/matcher/eq_impl.rb

@@ -46,7 +46,7 @@ module Mongoid
         end
       end
 
-      # Per https://docs.mongodb.com/ruby-driver/current/tutorials/bson-v4/#time-instances,
+      # Per https://www.mongodb.com/docs/ruby-driver/current/tutorials/bson-v4/#time-instances,
       # > Times in BSON (and MongoDB) can only have millisecond precision. When Ruby Time instances
       # are serialized to BSON or Extended JSON, the times are floored to the nearest millisecond.
       #

data/lib/mongoid/matcher/type.rb

@@ -1,7 +1,7 @@
 module Mongoid
   module Matcher
 
-    # @see https://docs.mongodb.com/manual/reference/operator/query/type/
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/type/
     #
     # @api private
     module Type

data/lib/mongoid/matcher.rb

@@ -2,7 +2,6 @@ module Mongoid
 
   # @api private
   module Matcher
-
     # Extracts field values in the document at the specified key.
     #
     # The document can be a Hash or a model instance.
@@ -24,23 +23,28 @@ module Mongoid
     #   an array of values of the `bar` field in each of the hashes in the
     #   `foo` array.
     #
-    # The return value is a two-element array. The first element is the value
-    # retrieved, or an array of values. The second element is a boolean flag
-    # indicating whether an array was expanded at any point during the key
-    # traversal (because the respective document field was an array).
+    # This method can return an individual field value in some document
+    # or an array of values from multiple documents. The array can be returned
+    # because a field value in the specified path is an array of primitive
+    # values (e.g. integers) or because a field value in the specified path
+    # is an array of documents (e.g. a one-to-many embedded association),
+    # in which case the leaf value may be a scalar for each individual document.
+    # If the leaf value is an array and a one-to-many association was traversed,
+    # the return value will be an array of arrays. Note that an individual
+    # field value can also be an array and this case is indistinguishable
+    # from and behaves identically to association traversal for the purposes
+    # of, for example, subsequent array element retrieval.
     #
     # @param [ Document | Hash ] document The document to extract from.
     # @param [ String ] key The key path to extract.
     #
-    # @return [ Array<true | false, Object | Array, true | false> ]
-    #   Whether the value existed in the document, the extracted value
-    #   and the array expansion flag.
+    # @return [ Object | Array ] Field value or values.
     module_function def extract_attribute(document, key)
       if document.respond_to?(:as_attributes, true)
         # If a document has hash fields, as_attributes would keep those fields
         # as Hash instances which do not offer indifferent access.
         # Convert to BSON::Document to get indifferent access on hash fields.
-        document = BSON::Document.new(document.send(:as_attributes))
+        document = document.send(:as_attributes)
       end
 
       current = [document]
@@ -50,8 +54,9 @@ module Mongoid
         current.each do |doc|
           case doc
           when Hash
-            if doc.key?(field)
-              new << doc[field]
+            actual_key = find_exact_key(doc, field)
+            if !actual_key.nil?
+              new << doc[actual_key]
             end
           when Array
             if (index = field.to_i).to_s == field
@@ -61,8 +66,9 @@ module Mongoid
             end
             doc.each do |subdoc|
               if Hash === subdoc
-                if subdoc.key?(field)
-                  new << subdoc[field]
+                actual_key = find_exact_key(subdoc, field)
+                if !actual_key.nil?
+                  new << subdoc[actual_key]
                 end
               end
             end
@@ -74,6 +80,20 @@ module Mongoid
 
       current
     end
+
+    # Indifferent string or symbol key lookup, returning the exact key.
+    #
+    # @param [ Hash ] hash The input hash.
+    # @param [ String | Symbol ] key The key to perform indifferent lookups with.
+    #
+    # @return [ String | Symbol | nil ] The exact key (with the correct type) that exists in the hash, or nil if the key does not exist.
+    module_function def find_exact_key(hash, key)
+      key_s = key.to_s
+      return key_s if hash.key?(key_s)
+
+      key_sym = key.to_sym
+      hash.key?(key_sym) ? key_sym : nil
+    end
   end
 end
 

data/lib/mongoid/persistable/creatable.rb

@@ -100,15 +100,25 @@ module Mongoid
       #
       # @return [ Document ] The document.
       def prepare_insert(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
         return self if performing_validations?(options) &&
           invalid?(options[:context] || :create)
-        result = run_callbacks(:save) do
-          run_callbacks(:create) do
-            yield(self)
-            post_process_insert
+        run_callbacks(:save, with_children: false) do
+          run_callbacks(:create, with_children: false) do
+            run_callbacks(:persist_parent, with_children: false) do
+              _mongoid_run_child_callbacks(:save) do
+                _mongoid_run_child_callbacks(:create) do
+                  result = yield(self)
+                  if !result.is_a?(Document) || result.errors.empty?
+                    post_process_insert
+                    post_process_persist(result, options)
+                  end
+                end
+              end
+            end
           end
         end
-        post_process_persist(result, options) and self
+        self
       end
 
       module ClassMethods
@@ -123,10 +133,10 @@ module Mongoid
         # @example Create multiple new documents.
         #   Person.create({ title: "Mr" }, { title: "Mrs" })
         #
-        # @param [ Hash, Array ] attributes The attributes to create with, or an
+        # @param [ Hash | Array ] attributes The attributes to create with, or an
         #   Array of multiple attributes for multiple documents.
         #
-        # @return [ Document, Array<Document> ] The newly created document(s).
+        # @return [ Document | Array<Document> ] The newly created document(s).
         def create(attributes = nil, &block)
           _creating do
             if attributes.is_a?(::Array)
@@ -150,10 +160,10 @@ module Mongoid
         # @example Create multiple new documents.
         #   Person.create!({ title: "Mr" }, { title: "Mrs" })
         #
-        # @param [ Hash, Array ] attributes The attributes to create with, or an
+        # @param [ Hash | Array ] attributes The attributes to create with, or an
         #   Array of multiple attributes for multiple documents.
         #
-        # @return [ Document, Array<Document> ] The newly created document(s).
+        # @return [ Document | Array<Document> ] The newly created document(s).
         def create!(attributes = nil, &block)
           _creating do
             if attributes.is_a?(::Array)

data/lib/mongoid/persistable/deletable.rb

@@ -16,7 +16,6 @@ module Mongoid
       #
       # @return [ TrueClass ] True.
       def delete(options = {})
-        raise Errors::ReadonlyDocument.new(self.class) if readonly?
         prepare_delete do
           unless options[:persist] == false
             if embedded?
@@ -86,7 +85,7 @@ module Mongoid
       #
       # @param [ Hash ] options The delete options.
       #
-      # @return [ true, false ] If the parent should be notified.
+      # @return [ true | false ] If the parent should be notified.
       def notifying_parent?(options = {})
         !options.delete(:suppress)
       end
@@ -102,6 +101,7 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def prepare_delete
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
         yield(self)
         freeze
         self.destroyed = true

data/lib/mongoid/persistable/destroyable.rb

@@ -14,7 +14,7 @@ module Mongoid
       #
       # @param [ Hash ] options Options to pass to destroy.
       #
-      # @return [ true, false ] True if successful, false if not.
+      # @return [ true | false ] True if successful, false if not.
       def destroy(options = nil)
         raise Errors::ReadonlyDocument.new(self.class) if readonly?
         self.flagged_for_destroy = true

data/lib/mongoid/persistable/savable.rb

@@ -14,7 +14,13 @@ module Mongoid
       #
       # @param [ Hash ] options Options to pass to the save.
       #
-      # @return [ true, false ] True is success, false if not.
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time. When this option is
+      #   false, none of the embedded documents will be touched. This option is
+      #   ignored when saving a new document, and the created_at and updated_at
+      #   will be set to the current time.
+      #
+      # @return [ true | false ] True if success, false if not.
       def save(options = {})
         if new_record?
           !insert(options).new_record?
@@ -31,10 +37,16 @@ module Mongoid
       #
       # @param [ Hash ] options Options to pass to the save.
       #
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time. When this option is
+      #   false, none of the embedded documents will be touched.This option is
+      #   ignored when saving a new document, and the created_at and updated_at
+      #   will be set to the current time.
+      #
       # @raise [ Errors::Validations ] If validation failed.
       # @raise [ Errors::Callback ] If a callback returns false.
       #
-      # @return [ true, false ] True if validation passed.
+      # @return [ true | false ] True if validation passed.
       def save!(options = {})
         unless save(options)
           fail_due_to_validation! unless errors.empty?

data/lib/mongoid/persistable/unsettable.rb

@@ -13,8 +13,8 @@ module Mongoid
       # @example Unset the values.
       #   document.unset(:first_name, :last_name, :middle)
       #
-      # @param [ Array<String, Symbol> ] fields The names of the fields to
-      #   unset.
+      # @param [ [ String | Symbol | Array<String | Symbol>]... ] *fields
+      #   The names of the field(s) to unset.
       #
       # @return [ Document ] The document.
       def unset(*fields)

data/lib/mongoid/persistable/updatable.rb

@@ -13,13 +13,13 @@ module Mongoid
       # @example Update the attribute.
       #   person.update_attribute(:title, "Sir")
       #
-      # @param [ Symbol, String ] name The name of the attribute.
+      # @param [ Symbol | String ] name The name of the attribute.
       # @param [ Object ] value The new value of the attribute.a
       #
       # @raise [ Errors::ReadonlyAttribute ] If the field cannot be changed due
       #   to being flagged as read-only.
       #
-      # @return [ true, false ] True if save was successful, false if not.
+      # @return [ true | false ] True if save was successful, false if not.
       def update_attribute(name, value)
         as_writable_attribute!(name, value) do |access|
           normalized = name.to_s
@@ -35,7 +35,7 @@ module Mongoid
       #
       # @param [ Hash ] attributes The attributes to update.
       #
-      # @return [ true, false ] True if validation passed, false if not.
+      # @return [ true | false ] True if validation passed, false if not.
       def update(attributes = {})
         assign_attributes(attributes)
         save
@@ -53,7 +53,7 @@ module Mongoid
       # @raise [ Errors::Validations ] If validation failed.
       # @raise [ Errors::Callbacks ] If a callback returns false.
       #
-      # @return [ true, false ] True if validation passed.
+      # @return [ true | false ] True if validation passed.
       def update!(attributes = {})
         result = update_attributes(attributes)
         unless result
@@ -91,18 +91,32 @@ module Mongoid
       #
       # @param [ Hash ] options The options.
       #
-      # @return [ true, false ] The result of the update.
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time.
+      #
+      # @return [ true | false ] The result of the update.
       def prepare_update(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
+        enforce_immutability_of_id_field!
         return false if performing_validations?(options) &&
           invalid?(options[:context] || :update)
         process_flagged_destroys
-        result = run_callbacks(:save) do
-          run_callbacks(:update) do
-            yield(self)
-            true
+        update_children = cascadable_children(:update)
+        process_touch_option(options, update_children)
+        run_callbacks(:save, with_children: false) do
+          run_callbacks(:update, with_children: false) do
+            run_callbacks(:persist_parent, with_children: false) do
+              _mongoid_run_child_callbacks(:save) do
+                _mongoid_run_child_callbacks(:update, children: update_children) do
+                  result = yield(self)
+                  self.previously_new_record = false
+                  post_process_persist(result, options)
+                  true
+                end
+              end
+            end
           end
         end
-        post_process_persist(result, options) and result
       end
 
       # Update the document in the database.
@@ -112,9 +126,9 @@ module Mongoid
       #
       # @param [ Hash ] options Options to pass to update.
       #
-      # @option options [ true, false ] :validate Whether or not to validate.
+      # @option options [ true | false ] :validate Whether or not to validate.
       #
-      # @return [ true, false ] True if succeeded, false if not.
+      # @return [ true | false ] True if succeeded, false if not.
       def update_document(options = {})
         prepare_update(options) do
           updates, conflicts = init_atomic_updates
@@ -153,6 +167,49 @@ module Mongoid
           end
         end
       end
+
+      # If there is a touch option and it is false, this method will call the
+      # timeless method so that the updated_at attribute is not updated. It
+      # will call the timeless method on all of the cascadable children as
+      # well. Note that timeless is cleared in the before_update callback.
+      #
+      # @param [ Hash ] options The options.
+      # @param [ Array<Document> ] children The children that the :update
+      #   callbacks will be executed on.
+      #
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time.
+      def process_touch_option(options, children)
+        unless options.fetch(:touch, true)
+          timeless
+          children.each(&:timeless)
+        end
+      end
+
+      # Checks to see if the _id field has been modified. If it has, and if
+      # the document has already been persisted, this is an error. Otherwise,
+      # returns without side-effects.
+      #
+      # Note that if `Mongoid::Config.immutable_ids` is false, this will do
+      # nothing.
+      #
+      # @raise [ Errors::ImmutableAttribute ] if _id has changed, and document
+      #   has been persisted.
+      def enforce_immutability_of_id_field!
+        # special case here: we *do* allow the _id to be mutated if it was
+        # previously nil. This addresses an odd case exposed in
+        # has_one/proxy_spec.rb where `person.create_address` would
+        # (somehow?) create the address with a nil _id first, before then
+        # saving it *again* with the correct _id.
+
+        if _id_changed? && !_id_was.nil? && persisted?
+          if Mongoid::Config.immutable_ids
+            raise Errors::ImmutableAttribute.new(:_id, _id)
+          else
+            Mongoid::Warnings.warn_mutable_ids
+          end
+        end
+      end
     end
   end
 end

data/lib/mongoid/persistable/upsertable.rb

@@ -10,16 +10,32 @@ module Mongoid
       # database, then Mongo will insert a new one, otherwise the fields will get
       # overwritten with new values on the existing document.
       #
+      # If the replace option is true, unspecified attributes will be dropped,
+      # and if it is false, unspecified attributes will be maintained. The
+      # replace option defaults to true in Mongoid 8.1 and earlier. The default
+      # will be flipped to false in Mongoid 9.
+      #
       # @example Upsert the document.
       #   document.upsert
       #
+      # @example Upsert the document without replace.
+      #   document.upsert(replace: false)
+      #
       # @param [ Hash ] options The validation options.
       #
+      # @option options [ true | false ] :validate Whether or not to validate.
+      # @option options [ true | false ] :replace Whether or not to replace the document on upsert.
+      #
       # @return [ true ] True.
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).replace_one(
+          if options.fetch(:replace, true)
+            collection.find(atomic_selector).replace_one(
               as_attributes, upsert: true, session: _session)
+          else
+            collection.find(atomic_selector).update_one(
+              { "$set" => as_attributes }, upsert: true, session: _session)
+          end
         end
       end
 
@@ -36,8 +52,11 @@ module Mongoid
       #
       # @param [ Hash ] options The options hash.
       #
-      # @return [ true, false ] If the operation succeeded.
+      # @option options [ true | false ] :validate Whether or not to validate.
+      #
+      # @return [ true | false ] If the operation succeeded.
       def prepare_upsert(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
         return false if performing_validations?(options) && invalid?(:upsert)
         result = run_callbacks(:upsert) do
           yield(self)

data/lib/mongoid/persistable.rb

@@ -79,11 +79,11 @@ module Mongoid
     #     document.set name: "Tool"
     #   end
     #
-    # @param [ true, false ] join_context Join the context (i.e. merge
+    # @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.
+    # @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
@@ -146,7 +146,7 @@ module Mongoid
     # @example Are we executing atomically?
     #   document.executing_atomically?
     #
-    # @return [ true, false ] If we are current executing atomically.
+    # @return [ true | false ] If we are current executing atomically.
     def executing_atomically?
       !@atomic_updates_to_execute_stack.nil?
     end
@@ -161,6 +161,8 @@ module Mongoid
     # @param [ Object ] result The result of the operation.
     # @param [ Hash ] options The options.
     #
+    # @option options [ true | false ] :validate Whether or not to validate.
+    #
     # @return [ true ] true.
     def post_process_persist(result, options = {})
       post_persist unless result == false
@@ -180,6 +182,7 @@ module Mongoid
     #
     # @return [ Object ] The result of the operation.
     def prepare_atomic_operation
+      raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
       operations = yield({})
       persist_or_delay_atomic_operation(operations)
       self