mongoid 8.0.13 → 8.1.0

data/lib/mongoid/association/nested/nested_buildable.rb

@@ -53,26 +53,12 @@ module Mongoid
         # @example Convert the id.
         #   builder.convert_id(Person, "4d371b444835d98b8b000010")
         #
-        # Ids arriving from a form are always scalars. A Hash or an Array
-        # here means the parameters were crafted, and letting one through
-        # would turn the id into a query operator, so they are rejected.
-        #
         # @param [ Class ] klass The class we're trying to convert for.
         # @param [ String ] id The id, usually coming from the form.
         #
         # @return [ BSON::ObjectId | String | Object ] The converted id.
-        #
-        # @raise [ Errors::DocumentNotFound ] if the id is not a scalar, or
-        #   cannot be converted to the type the class uses for its ids.
-        #   The BSON::Error rescue is defensive: a value that reaches
-        #   BSON::ObjectId.mongoize and raises there must not surface as an
-        #   unhandled BSON error in the caller.
         def convert_id(klass, id)
-          raise Errors::DocumentNotFound.new(klass, id) if id.is_a?(::Hash) || id.is_a?(::Array)
-
           klass.using_object_ids? ? BSON::ObjectId.mongoize(id) : id
-        rescue BSON::Error
-          raise Errors::DocumentNotFound.new(klass, id)
         end
       end
     end

data/lib/mongoid/association/nested/one.rb

@@ -32,6 +32,8 @@ module Mongoid
             parent.send(association.setter, Factory.build(@class_name, attributes))
           elsif delete?
             parent.send(association.setter, nil)
+          else
+            check_for_id_violation!
           end
         end
 
@@ -54,6 +56,17 @@ module Mongoid
 
         private
 
+        # Extracts and converts the id to the expected type.
+        #
+        # @return [ BSON::ObjectId | String | Object | nil ] The converted id,
+        #   or nil if no id is present in the attributes hash.
+        def extracted_id
+          @extracted_id ||= begin
+            id = association.klass.extract_id_field(attributes)
+            convert_id(existing.class, id)
+          end
+        end
+
         # Is the id in the attributes acceptable for allowing an update to
         # the existing association?
         #
@@ -64,8 +77,7 @@ module Mongoid
         #
         # @return [ true | false ] If the id part of the logic will allow an update.
         def acceptable_id?
-          id = association.klass.extract_id_field(attributes)
-          id = convert_id(existing.class, id)
+          id = extracted_id
           existing._id == id || id.nil? || (existing._id != id && update_only?)
         end
 
@@ -110,6 +122,32 @@ module Mongoid
         def update?
           existing && !destroyable? && acceptable_id?
         end
+
+        # Checks to see if the _id attribute (which is supposed to be
+        # immutable) is being asked to change. If so, raise an exception.
+        #
+        # If Mongoid::Config.immutable_ids is false, this will do nothing,
+        # and the update operation will fail silently.
+        #
+        # @raise [ Errors::ImmutableAttribute ] if _id has changed, and
+        #   the document has been persisted.
+        def check_for_id_violation!
+          # look for the basic criteria of an update (see #update?)
+          return unless existing&.persisted? && !destroyable?
+
+          # if the id is either absent, or if it equals the existing record's
+          # id, there is no immutability violation.
+          id = extracted_id
+          return if existing._id == id || id.nil?
+
+          # otherwise, an attempt has been made to set the _id of an existing,
+          # persisted document.
+          if Mongoid::Config.immutable_ids
+            raise Errors::ImmutableAttribute.new(:_id, id)
+          else
+            Mongoid::Warnings.warn_mutable_ids
+          end
+        end
       end
     end
   end

data/lib/mongoid/association/proxy.rb

@@ -118,7 +118,7 @@ module Mongoid
       # to the target of the proxy. This can be overridden in special cases.
       #
       # @param [ String | Symbol ] name The name of the method.
-      # @param [ Array ] args The arguments passed to the method.
+      # @param [ Object... ] *args The arguments passed to the method.
       ruby2_keywords def method_missing(name, *args, &block)
         _target.send(name, *args, &block)
       end

data/lib/mongoid/association/referenced/counter_cache.rb

@@ -13,7 +13,7 @@ module Mongoid
         # @example Reset the given counter cache
         #   post.reset_counters(:comments)
         #
-        # @param [ Symbol | Array ] counters One or more counter caches to reset
+        # @param [ Symbol... ] *counters One or more counter caches to reset.
         def reset_counters(*counters)
           self.class.with(persistence_context) do |_class|
             _class.reset_counters(self, *counters)
@@ -30,7 +30,7 @@ module Mongoid
           #   Post.reset_counters('50e0edd97c71c17ea9000001', :comments)
           #
           # @param [ String ] id The id of the object that will be reset.
-          # @param [ Symbol | Array ] counters One or more counter caches to reset
+          # @param [ Symbol... ] *counters One or more counter caches to reset.
           def reset_counters(id, *counters)
             document = id.is_a?(Document) ? id : find(id)
             counters.each do |name|

data/lib/mongoid/association/referenced/has_and_belongs_to_many/proxy.rb

@@ -21,7 +21,7 @@ module Mongoid
           # @example Concat with other documents.
           #   person.posts.concat([ post_one, post_two ])
           #
-          # @param [ Document | Array<Document> ] args Any number of documents.
+          # @param [ Document... ] *args Any number of documents.
           #
           # @return [ Array<Document> ] The loaded docs.
           def <<(*args)

data/lib/mongoid/association/referenced/has_many/enumerable.rb

@@ -215,13 +215,13 @@ module Mongoid
           # completely depending on whether it is iterated to completion.
           #
           # This method can take a parameter and a block. The behavior with
-          # either the paramater or the block is delegated to the standard
+          # either the parameter or the block is delegated to the standard
           # library Enumerable module.
           #
           # Note that when Enumerable's any? method is invoked with both
           # a block and a pattern, it only uses the pattern.
           #
-          # @param [ Object ] condition The condition that documents
+          # @param [ Object... ] *args The condition that documents
           #   must satisfy. See Enumerable documentation for details.
           #
           # @return [ true | false ] If the association has any documents.
@@ -422,28 +422,11 @@ module Mongoid
           #
           # @return [ Integer ] The size of the enumerable.
           def size
-            # If _unloaded is present, then it will match the set of documents
-            # that belong to this association, which have already been persisted
-            # to the database. This set of documents must be considered when
-            # computing the size of the association, along with anything that has
-            # since been added.
-            if _unloaded
-              if _added.any?
-                # Note that _added may include records that _unloaded already
-                # matches. This is the case if the association is assigned an array
-                # of items and some of them were already elements of the association.
-                #
-                # we need to thus make sure _unloaded.count excludes any elements
-                # that already exist in _added.
-
-                count = _unloaded.not(:_id.in => _added.values.map(&:id)).count
-                count + _added.values.count
-              else
-                _unloaded.count
-              end
-
+            count = (_unloaded ? _unloaded.count : _loaded.count)
+            if count.zero?
+              count + _added.count
             else
-              _loaded.count + _added.count
+              count + _added.values.count { |d| d.new_record? }
             end
           end
 

data/lib/mongoid/association/referenced/has_many/proxy.rb

@@ -25,7 +25,7 @@ module Mongoid
           # @example Concat with other documents.
           #   person.posts.concat([ post_one, post_two ])
           #
-          # @param [ Document | Array<Document> ] args Any number of documents.
+          # @param [ Document... ] *args Any number of documents.
           #
           # @return [ Array<Document> ] The loaded docs.
           def <<(*args)
@@ -203,7 +203,7 @@ module Mongoid
           # @note This will keep matching documents in memory for iteration
           #   later.
           #
-          # @param [ Object | Array<Object> ] *args The ids.
+          # @param [ [ Object | Array<Object> ]... ] *args The ids.
           # @param [ Proc ] block Optional block to pass.
           #
           # @return [ Document | Array<Document> | nil ] A document or matching documents.
@@ -418,7 +418,7 @@ module Mongoid
           # If the method exists on the array, use the default proxy behavior.
           #
           # @param [ Symbol | String ] name The name of the method.
-          # @param [ Array ] args The method args
+          # @param [ Object... ] *args The method args
           # @param [ Proc ] block Optional block to pass.
           #
           # @return [ Criteria | Object ] A Criteria or return value from the target.
@@ -477,111 +477,12 @@ module Mongoid
           # @return [ Integer ] The number of documents deleted.
           def remove_all(conditions = nil, method = :delete_all)
             selector = conditions || {}
-            selector.merge!(criteria.selector)
-
-            # Scanning before the delete means scanning only what is already in
-            # memory, so it is only done where there is a pattern whose cost has
-            # to be bounded. Everywhere else the delete comes first and the scan
-            # sees the survivors, which is what this association has always
-            # done.
-            #
-            # The limit is read once and carried into whichever branch is taken.
-            # Letting the branch below ask again would read it a second time,
-            # across a server round trip, and a limit that had become positive
-            # in the meantime would put a deadline on the delete_if -- a query,
-            # and an unbind of every match -- which is the arrangement this
-            # branch exists to avoid.
-            limit = Matcher::RegexpBudget.limit_for(selector)
-            return remove_all_bounded(selector, method, limit) if limit
-
-            removed = klass.send(method, selector)
-
-            # No scope around this. The scan runs after the delete, so the
-            # association this loads comes back holding only what the delete did
-            # not match, and there is no pattern here to bound in any case.
-            # Opening a scope would save _matches? from deciding once per
-            # document -- 0.48us against 1.74us for the match itself -- but a
-            # scope with nothing to bound suppresses that decision for
-            # everything nested inside it, and loading the association runs
-            # find callbacks. A pattern in a selector one of those evaluates
-            # would go unguarded, which costs more than the saving is worth on a
-            # path that has just made two round trips.
+            removed = klass.send(method, selector.merge!(criteria.selector))
             _target.delete_if do |doc|
               doc._matches?(selector).tap do |b|
                 unbind_one(doc) if b
               end
             end
-
-            removed
-          end
-
-          # Deletes all related documents matching a selector that carries a
-          # regular expression, with the whole scan under one regexp budget.
-          #
-          # The scan runs before anything is deleted, so a budget that runs out
-          # leaves both the database and the association untouched rather than
-          # reporting a failure for a delete that has already happened. It also
-          # means the budget is closed by the time the association is mutated,
-          # so where the budget is enforced with Timeout there is no window for
-          # the exception to land in the middle of an unbind.
-          #
-          # @param [ Hash ] selector The selector to delete with.
-          # @param [ Symbol ] method The deletion method to call.
-          # @param [ Float ] limit The seconds the scan may spend, as read by
-          #   the caller when it chose this path.
-          #
-          # @return [ Integer ] The number of documents deleted.
-          def remove_all_bounded(selector, method, limit)
-            # Only what the association already holds. Iterating it instead
-            # would load the whole association before the delete, and for a
-            # broad pattern that is every document the association has: /.*/ is
-            # both the cheapest pattern an attacker can supply and the one that
-            # matches everything, so bounding the cost of the matching would
-            # have been paid for with an unbounded amount of memory. Nothing is
-            # missed by not loading, because the server evaluates the same
-            # selector for the delete itself.
-            #
-            # It also means the scan runs no query, so no deadline of ours can
-            # land on one. Where the budget is enforced with Timeout, covering
-            # a query would report a slow network as a regexp timeout and could
-            # deliver the asynchronous exception inside the driver's socket
-            # read.
-            documents = _target.in_memory
-
-            matching = Matcher::RegexpBudget.open_with(limit) do
-              documents.select { |doc| doc._matches?(selector) }
-            end
-
-            removed = klass.send(method, selector)
-
-            # The ids are already known to be in memory, so the loaded and added
-            # documents can be dropped directly. Enumerable#delete would look
-            # each one up by id and stop at the first hash that has it, which
-            # removes the wrong instance when both hashes hold one for the same
-            # id. Enumerable#delete_if drops it from both, as this does, but
-            # only after load_all!, which is the load this scan exists to avoid.
-            #
-            # Which documents get unbound has always depended on which ones
-            # happened to be in memory, and scanning only what is in memory
-            # keeps that. It matters for has_and_belongs_to_many, whose
-            # unbind_one pulls the id out of the foreign key array on _base and
-            # marks it dirty; the scan used to run after the delete, against an
-            # association that a cold proxy had just reloaded as holding only
-            # the survivors, so nothing matched and nothing was unbound.
-            #
-            # TODO: unbinding should not depend on what was in memory. Every
-            # matched document leaves the association, so every one of them
-            # should be unbound, which would also stop _base's foreign key
-            # array from keeping ids that no longer resolve. That is a
-            # behaviour change for has_and_belongs_to_many and belongs in a
-            # ticket of its own, with a release note; it should not ride along
-            # on this one.
-            matching.each do |doc|
-              unbind_one(doc)
-              _target._loaded.delete(doc._id)
-              _target._added.delete(doc._id)
-            end
-
             removed
           end
 

data/lib/mongoid/association/reflections.rb

@@ -25,7 +25,7 @@ module Mongoid
       # @example Find multiple association metadata by macro.
       #   person.reflect_on_all_associations(:embeds_many)
       #
-      # @param [ Array<Symbol> ] macros The association macros.
+      # @param [ Symbol... ] *macros The association macros.
       #
       # @return [ Array<Association> ] The matching association metadata.
       def reflect_on_all_association(*macros)
@@ -51,7 +51,7 @@ module Mongoid
         # @example Find multiple association metadata by macro.
         #   Person.reflect_on_all_associations(:embeds_many)
         #
-        # @param [ Array<Symbol> ] macros The association macros.
+        # @param [ Symbol... ] *macros The association macros.
         #
         # @return [ Array<Association> ] The matching association metadata.
         def reflect_on_all_associations(*macros)

data/lib/mongoid/atomic.rb

@@ -178,15 +178,13 @@ module Mongoid
     #
     # @return [ Object ] The associated path.
     def atomic_paths
-      return @atomic_paths if @atomic_paths
-
-      paths = if _association
-                _association.path(self)
-              else
-                Atomic::Paths::Root.new(self)
-              end
-
-      paths.tap { @atomic_paths = paths unless new_record? }
+      @atomic_paths ||= begin
+        if _association
+          _association.path(self)
+        else
+          Atomic::Paths::Root.new(self)
+        end
+      end
     end
 
     # Get all the attributes that need to be pulled.
@@ -313,13 +311,6 @@ module Mongoid
 
     private
 
-    # Clears all pending atomic updates.
-    def reset_atomic_updates!
-      Atomic::UPDATES.each do |update|
-        send(update).clear
-      end
-    end
-
     # Generates the atomic updates in the correct order.
     #
     # @example Generate the updates.

data/lib/mongoid/attributes/dynamic.rb

@@ -115,7 +115,7 @@ module Mongoid
       #   document.method_missing(:test)
       #
       # @param [ String | Symbol ] name The name of the method.
-      # @param [ Array ] args The arguments to the method.
+      # @param [ Object... ] *args The arguments to the method.
       #
       # @return [ Object ] The result of the method call.
       def method_missing(name, *args)

data/lib/mongoid/attributes/nested.rb

@@ -33,8 +33,8 @@ module Mongoid
         #     accepts_nested_attributes_for :addresses, :game, :posts
         #   end
         #
-        # @param [ Array<Symbol> | Hash ] args A list of association names, followed
-        #   by a hash of options.
+        # @param [ Symbol..., Hash ] *args A list of association names, followed
+        #   by an optional hash of options.
         #
         # @option *args [ true | false ] :allow_destroy Can deletion occur?
         # @option *args [ Proc | Symbol ] :reject_if Block or symbol pointing

data/lib/mongoid/attributes/processing.rb

@@ -43,46 +43,22 @@ module Mongoid
       # @return [ true | false ] True if pending, false if not.
       def pending_attribute?(key, value)
         name = key.to_s
+
         aliased = if aliased_associations.key?(name)
           aliased_associations[name]
         else
           name
         end
+
         if relations.has_key?(aliased)
-          set_pending_relation(name, aliased, value)
+          pending_relations[name] = value
           return true
         end
         if nested_attributes.has_key?(aliased)
-          set_pending_nested(name, aliased, value)
-          return true
-        end
-        false
-      end
-
-      # Set value of the pending relation.
-      #
-      # @param [ Symbol ] name The name of the relation.
-      # @param [ Symbol ] aliased The aliased name of the relation.
-      # @param [ Object ] value The value of the relation.
-      def set_pending_relation(name, aliased, value)
-        if stored_as_associations.include?(name)
-          pending_relations[aliased] = value
-        else
-          pending_relations[name] = value
-        end
-      end
-
-      # Set value of the pending nested attribute.
-      #
-      # @param [ Symbol ] name The name of the nested attribute.
-      # @param [ Symbol ] aliased The aliased name of the nested attribute.
-      # @param [ Object ] value The value of the nested attribute.
-      def set_pending_nested(name, aliased, value)
-        if stored_as_associations.include?(name)
-          pending_nested[aliased] = value
-        else
           pending_nested[name] = value
+          return true
         end
+        return false
       end
 
       # Get all the pending associations that need to be set.

data/lib/mongoid/attributes/projector.rb

@@ -6,7 +6,7 @@ module Mongoid
     # This module defines projection helpers.
     #
     # Projection rules are rather non-trivial. See
-    # https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection
+    # https://www.mongodb.com/docs/manual/reference/method/db.collection.find/#find-projection
     # for server documentation.
     # 4.4 server (and presumably all older ones) requires that a projection
     # for content fields is either exclusionary or inclusionary, i.e. one

data/lib/mongoid/attributes/readonly.rb

@@ -61,7 +61,7 @@ module Mongoid
         #     attr_readonly :name, :genre
         #   end
         #
-        # @param [ Array<Symbol> ] names The names of the fields.
+        # @param [ Symbol... ] *names The names of the fields.
         def attr_readonly(*names)
           names.each do |name|
             readonly_attributes << database_field_name(name)

data/lib/mongoid/attributes.rb

@@ -177,8 +177,14 @@ module Mongoid
             attribute_will_change!(field_name)
           end
           if localized
-            attributes[field_name] ||= {}
-            attributes[field_name].merge!(typed_value)
+            present = fields[field_name].try(:localize_present?)
+            loc_key, loc_val = typed_value.first
+            if present && loc_val.blank?
+              attributes[field_name]&.delete(loc_key)
+            else
+              attributes[field_name] ||= {}
+              attributes[field_name].merge!(typed_value)
+            end
           else
             attributes[field_name] = typed_value
           end

data/lib/mongoid/changeable.rb

@@ -68,9 +68,13 @@ module Mongoid
     # @example Move the changes to previous.
     #   person.move_changes
     def move_changes
+      @changes_before_last_save = @previous_changes
       @previous_changes = changes
+      @attributes_before_last_save = @previous_attributes
       @previous_attributes = attributes.dup
-      reset_atomic_updates!
+      Atomic::UPDATES.each do |update|
+        send(update).clear
+      end
       changed_attributes.clear
     end
 
@@ -131,6 +135,72 @@ module Mongoid
       mods
     end
 
+    # Returns the original value of an attribute before the last save.
+    #
+    # This method is useful in after callbacks to get the original value of
+    #   an attribute before the save that triggered the callbacks to run.
+    #
+    # @param [ Symbol | String ] attr The name of the attribute.
+    #
+    # @return [ Object ] Value of the attribute before the last save.
+    def attribute_before_last_save(attr)
+      attr = database_field_name(attr)
+      attributes_before_last_save[attr]
+    end
+
+    # Returns the change to an attribute during the last save.
+    #
+    # @param [ Symbol | String ] attr The name of the attribute.
+    #
+    # @return [ Array<Object> | nil ] If the attribute was changed, returns
+    #   an array containing the original value and the saved value, otherwise nil.
+    def saved_change_to_attribute(attr)
+      attr = database_field_name(attr)
+      previous_changes[attr]
+    end
+
+    # Returns whether this attribute changed during the last save.
+    #
+    # This method is useful in after callbacks, to see the change
+    #   in an attribute during the save that triggered the callbacks to run.
+    #
+    # @param [ String ] attr The name of the attribute.
+    # @param **kwargs The optional keyword arguments.
+    #
+    # @option **kwargs [ Object ] :from The object the attribute was changed from.
+    # @option **kwargs [ Object ] :to The object the attribute was changed to.
+    #
+    # @return [ true | false ] Whether the attribute has changed during the last save.
+    def saved_change_to_attribute?(attr, **kwargs)
+      changes = saved_change_to_attribute(attr)
+      return false unless changes.is_a?(Array)
+      if kwargs.key?(:from) && kwargs.key?(:to)
+        changes.first == kwargs[:from] && changes.last == kwargs[:to]
+      elsif kwargs.key?(:from)
+        changes.first == kwargs[:from]
+      elsif kwargs.key?(:to)
+        changes.last == kwargs[:to]
+      else
+        true
+      end
+    end
+
+    # Returns whether this attribute change the next time we save.
+    #
+    # This method is useful in validations and before callbacks to determine
+    #   if the next call to save will change a particular attribute.
+    #
+    # @param [ String ] attr The name of the attribute.
+    # @param **kwargs The optional keyword arguments.
+    #
+    # @option **kwargs [ Object ] :from The object the attribute was changed from.
+    # @option **kwargs [ Object ] :to The object the attribute was changed to.
+    #
+    # @return [ true | false ] Whether the attribute change the next time we save.
+    def will_save_change_to_attribute?(attr, **kwargs)
+      attribute_changed?(attr, **kwargs)
+    end
+
     private
 
     # Get attributes of the document before the document was saved.
@@ -140,6 +210,14 @@ module Mongoid
       @previous_attributes ||= {}
     end
 
+    def changes_before_last_save
+      @changes_before_last_save ||= {}
+    end
+
+    def attributes_before_last_save
+      @attributes_before_last_save ||= {}
+    end
+
     # Get the old and new value for the provided attribute.
     #
     # @example Get the attribute change.
@@ -159,12 +237,24 @@ module Mongoid
     #   model.attribute_changed?("name")
     #
     # @param [ String ] attr The name of the attribute.
+    # @param **kwargs The optional keyword arguments.
+    #
+    # @option **kwargs [ Object ] :from The object the attribute was changed from.
+    # @option **kwargs [ Object ] :to The object the attribute was changed to.
     #
     # @return [ true | false ] Whether the attribute has changed.
-    def attribute_changed?(attr)
+    def attribute_changed?(attr, **kwargs)
       attr = database_field_name(attr)
       return false unless changed_attributes.key?(attr)
-      changed_attributes[attr] != attributes[attr]
+      return false if changed_attributes[attr] == attributes[attr]
+      if kwargs.key?(:from)
+        return false if changed_attributes[attr] != kwargs[:from]
+      end
+      if kwargs.key?(:to)
+        return false if attributes[attr] != kwargs[:to]
+      end
+
+      true
     end
 
     # Get whether or not the field has a different value from the default.
@@ -300,8 +390,11 @@ module Mongoid
       # @param [ String ] meth The name of the accessor.
       def create_dirty_change_check(name, meth)
         generated_methods.module_eval do
-          re_define_method("#{meth}_changed?") do
-            attribute_changed?(name)
+          re_define_method("#{meth}_changed?") do |**kwargs|
+            attribute_changed?(name, **kwargs)
+          end
+          re_define_method("will_save_change_to_#{meth}?") do |**kwargs|
+            will_save_change_to_attribute?(name, **kwargs)
           end
         end
       end
@@ -336,6 +429,15 @@ module Mongoid
           re_define_method("#{meth}_previously_was") do
             attribute_previously_was(name)
           end
+          re_define_method("#{meth}_before_last_save") do
+            attribute_before_last_save(name)
+          end
+          re_define_method("saved_change_to_#{meth}") do
+            saved_change_to_attribute(name)
+          end
+          re_define_method("saved_change_to_#{meth}?") do |**kwargs|
+            saved_change_to_attribute?(name, **kwargs)
+          end
         end
       end
 

data/lib/mongoid/clients/factory.rb

@@ -95,10 +95,6 @@ module Mongoid
             [MONGOID_WRAPPING_LIBRARY] + options[:wrapping_libraries]
           else
             [MONGOID_WRAPPING_LIBRARY]
-          end.tap do |wrap|
-            if defined?(::Rails) && ::Rails.respond_to?(:version)
-              wrap << { name: 'Rails', version: ::Rails.version }
-            end
           end
           options[:wrapping_libraries] = wrap_lib
         end