mongoid 7.0.2 → 8.1.1

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

@@ -1,12 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Association
     module Referenced
       module Eager
 
         # Base class for eager load preload functions.
-        #
-        # @since 4.0.0
         class Base
 
           # Instantiate the eager load class.
@@ -15,11 +14,9 @@ module Mongoid
           #   BelongsTo.new(association, parent_docs)
           #
           # @param [ Array<Association> ] associations Associations to eager load
-          # @param [ Array<Document> ] docs Documents to preload the relations
+          # @param [ Array<Document> ] docs Documents to preload the associations
           #
           # @return [ Base ] The eager load preloader
-          #
-          # @since 4.0.0
           def initialize(associations, docs)
             @associations = associations
             @docs = docs
@@ -28,12 +25,10 @@ module Mongoid
 
           # Run the preloader.
           #
-          # @example Preload the relations into the documents.
+          # @example Preload the associations into the documents.
           #   loader.run
           #
           # @return [ Array ] The list of documents given.
-          #
-          # @since 4.0.0
           def run
             @loaded = []
             while shift_association
@@ -45,26 +40,39 @@ module Mongoid
 
           protected
 
-          # Preload the current relation.
+          # Preload the current association.
           #
           # This method should be implemented in the subclass
           #
-          # @example Preload the current relation into the documents.
+          # @example Preload the current association into the documents.
           #   loader.preload
-          #
-          # @since 4.0.0
           def preload
             raise NotImplementedError
           end
 
-          # Run the preloader.
-          #
-          # @example Iterate over the documents loaded for the current relation
-          #   loader.each_loaded_document { |doc| }
-          #
-          # @since 4.0.0
-          def each_loaded_document
-            criteria = @association.klass.any_in(key => keys_from_docs)
+          # Retrieves the documents referenced by the association, and
+          # yields each one sequentially to the provided block. If the
+          # association is not polymorphic, all documents are retrieved in
+          # a single query. If the association is polymorphic, one query is
+          # issued per association target class.
+          def each_loaded_document(&block)
+            each_loaded_document_of_class(@association.klass, keys_from_docs, &block)
+          end
+
+          # Retrieves the documents of the specified class, that have the
+          # foreign key included in the specified list of keys.
+          #
+          # When the documents are retrieved, the set of inclusions applied
+          # is the set of inclusions applied to the host document minus the
+          # association that is being eagerly loaded.
+          private def each_loaded_document_of_class(cls, keys)
+            # Note: keys should not include nil elements.
+            # Upstream code is responsible for eliminating nils from keys.
+            return cls.none if keys.empty?
+
+            criteria = cls.criteria
+            criteria = criteria.apply_scope(@association.scope)
+            criteria = criteria.any_in(key => keys)
             criteria.inclusions = criteria.inclusions - [@association]
             criteria.each do |doc|
               yield doc
@@ -77,9 +85,7 @@ module Mongoid
           #   loader.set_on_parent("foo", docs)
           #
           # @param [ ObjectId ] id parent`s id
-          # @param [ Document, Array ] element to push into the parent
-          #
-          # @since 4.0.0
+          # @param [ Document | Array ] element to push into the parent
           def set_on_parent(id, element)
             grouped_docs[id].each do |d|
               set_relation(d, element)
@@ -88,26 +94,30 @@ module Mongoid
 
           # Return a hash with the current documents grouped by key.
           #
+          # Documents that do not have a value for the association being loaded
+          # are not returned.
+          #
           # @example Return a hash with the current documents grouped by key.
           #   loader.grouped_docs
           #
           # @return [ Hash ] hash with grouped documents.
-          #
-          # @since 4.0.0
           def grouped_docs
             @grouped_docs[@association.name] ||= @docs.group_by do |doc|
               doc.send(group_by_key) if doc.respond_to?(group_by_key)
+            end.reject do |k, v|
+              k.nil?
             end
           end
 
-          # Group the documents and return the keys
+          # Group the documents and return the keys.
+          #
+          # This method omits nil keys (i.e. keys from documents that do not
+          # have a value for the association being loaded).
           #
           # @example
           #   loader.keys_from_docs
           #
           # @return [ Array ] keys, ids
-          #
-          # @since 4.0.0
           def keys_from_docs
             grouped_docs.keys
           end
@@ -120,21 +130,17 @@ module Mongoid
           #   loader.group_by_key
           #
           # @return [ Symbol ] Key to group by the current documents.
-          #
-          # @since 4.0.0
           def group_by_key
             raise NotImplementedError
           end
 
           # Set the pre-loaded document into its parent.
           #
-          # @example Set docs into parent using the current relation name.
+          # @example Set docs into parent using the current association name.
           #   loader.set_relation(doc, docs)
           #
-          # @param [ Document ] doc The object to set the relation on
-          # @param [ Document, Array ] element to set into the parent
-          #
-          # @since 4.0.0
+          # @param [ Document ] doc The object to set the association on
+          # @param [ Document | Array ] element to set into the parent
           def set_relation(doc, element)
             doc.set_relation(@association.name, element) unless doc.blank?
           end
@@ -147,8 +153,6 @@ module Mongoid
           #   loader.shift_association
           #
           # @return [ Association ] The association object.
-          #
-          # @since 4.0.0
           def shift_association
             @association = @associations.shift
           end

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

@@ -1,22 +1,21 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Association
     module Referenced
       class HasAndBelongsToMany
 
-        # Binding class for all has_and_belongs_to_many relations.
+        # Binding class for all has_and_belongs_to_many associations.
         class Binding
           include Bindable
 
-          # Binds a single document with the inverse relation. Used
+          # Binds a single document with the inverse association. Used
           # specifically when appending to the proxy.
           #
           # @example Bind one document.
           #   person.preferences.bind_one(preference)
           #
           # @param [ Document ] doc The single document to bind.
-          #
-          # @since 2.0.0.rc.1
           def bind_one(doc)
             binding do
               inverse_keys = doc.you_must(_association.inverse_foreign_key)
@@ -36,8 +35,6 @@ module Mongoid
           #
           # @example Unbind the document.
           #   person.preferences.unbind_one(document)
-          #
-          # @since 2.0.0.rc.1
           def unbind_one(doc)
             binding do
               _base.send(_association.foreign_key).delete_one(record_id(doc))
@@ -53,11 +50,15 @@ module Mongoid
 
           # Find the inverse id referenced by inverse_keys
           def inverse_record_id(doc)
-            inverse_association = determine_inverse_association(doc)
-            if inverse_association
-              _base.__send__(inverse_association.primary_key)
+            if pk = _association.options[:inverse_primary_key]
+              _base.send(pk)
             else
-              _base._id
+              inverse_association = determine_inverse_association(doc)
+              if inverse_association
+                _base.__send__(inverse_association.primary_key)
+              else
+                _base._id
+              end
             end
           end
 

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

@@ -1,12 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Association
     module Referenced
       class HasAndBelongsToMany
 
         # The Builder behavior for has_and_belongs_to_many associations.
-        #
-        # @since 7.0
         module Buildable
 
           # This builder either takes a hash and queries for the
@@ -16,11 +15,12 @@ module Mongoid
           #   relation.build(association, attrs)
           #
           # @param [ Object ] base The base object.
-          # @param [ Object ] object The object to use to build the relation.
+          # @param [ Object ] object The object to use to build the association.
           # @param [ String ] type Not used in this context.
+          # @param [ nil ] selected_fields Must be nil.
           #
           # @return [ Array<Document> ] The documents.
-          def build(base, object, type = nil)
+          def build(base, object, type = nil, selected_fields = nil)
             if query?(object)
               query_criteria(object)
             else

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

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Association
     module Referenced

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

@@ -1,14 +1,15 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Association
     module Referenced
       class HasAndBelongsToMany
 
-        # This class defines the behaviour for all relations that are a
+        # This class defines the behavior for all associations that are a
         # many-to-many between documents in different collections.
         class Proxy < Referenced::HasMany::Proxy
 
-          # Appends a document or array of documents to the relation. Will set
+          # Appends a document or array of documents to the association. Will set
           # the parent and update the index in the process.
           #
           # @example Append a document.
@@ -20,19 +21,41 @@ 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.
-          #
-          # @since 2.0.0.beta.1
           def <<(*args)
             docs = args.flatten
             return concat(docs) if docs.size > 1
             if doc = docs.first
-              append(doc)
-              _base.add_to_set(foreign_key => doc.send(_association.primary_key))
-              if child_persistable?(doc)
-                doc.save
+              append(doc) do
+                # We ignore the changes to the value for the foreign key in the
+                # changed_attributes hash in this block of code for two reasons:
+                #
+                # 1) The add_to_set method deletes the value for the foreign
+                #    key in the changed_attributes hash, but if we enter this
+                #    method with a value for the foreign key in the
+                #    changed_attributes hash, then we want it to exist outside
+                #    this method as well. It's used later on in the Syncable
+                #    module to set the inverse foreign keys.
+                # 2) The reset_unloaded method accesses the value for the foreign
+                #    key on _base, which causes it to get added to the
+                #    changed_attributes hash. This happens because when reading
+                #    a "resizable" attribute, it is automatically added to the
+                #    changed_attributes hash. This is true only for the foreign
+                #    key value for HABTM associations as the other associations
+                #    use strings for their foreign key values. For consistency
+                #    with the other associations, we ignore this addition to
+                #    the changed_attributes hash.
+                #    See MONGOID-4843 for a longer discussion about this.
+                reset_foreign_key_changes do
+                  _base.add_to_set(foreign_key => doc.public_send(_association.primary_key))
+
+                  if child_persistable?(doc)
+                    doc.save
+                  end
+                  reset_unloaded
+                end
               end
             end
             unsynced(_base, foreign_key) and self
@@ -40,7 +63,7 @@ module Mongoid
 
           alias :push :<<
 
-          # Appends an array of documents to the relation. Performs a batch
+          # Appends an array of documents to the association. Performs a batch
           # insert of the documents instead of persisting one at a time.
           #
           # @example Concat with other documents.
@@ -49,20 +72,18 @@ module Mongoid
           # @param [ Array<Document> ] documents The docs to add.
           #
           # @return [ Array<Document> ] The documents.
-          #
-          # @since 2.4.0
           def concat(documents)
             ids, docs, inserts = {}, [], []
             documents.each do |doc|
               next unless doc
               append(doc)
               if persistable? || _creating?
-                ids[doc._id] = true
+                ids[doc.public_send(_association.primary_key)] = true
                 save_or_delay(doc, docs, inserts)
               else
-                existing = _base.send(foreign_key)
-                unless existing.include?(doc._id)
-                  existing.push(doc._id) and unsynced(_base, foreign_key)
+                existing = _base.public_send(foreign_key)
+                unless existing.include?(doc.public_send(_association.primary_key))
+                  existing.push(doc.public_send(_association.primary_key)) and unsynced(_base, foreign_key)
                 end
               end
             end
@@ -74,32 +95,31 @@ module Mongoid
           end
 
           # Build a new document from the attributes and append it to this
-          # relation without saving.
+          # association without saving.
           #
-          # @example Build a new document on the relation.
+          # @example Build a new document on the association.
           #   person.posts.build(:title => "A new post")
           #
           # @param [ Hash ] attributes The attributes of the new document.
           # @param [ Class ] type The optional subclass to build.
           #
           # @return [ Document ] The new document.
-          #
-          # @since 2.0.0.beta.1
           def build(attributes = {}, type = nil)
-            doc = Factory.build(type || klass, attributes)
-            _base.send(foreign_key).push(doc._id)
+            doc = Factory.execute_build(type || klass, attributes, execute_callbacks: false)
             append(doc)
             doc.apply_post_processed_defaults
+            _base.public_send(foreign_key).push(doc.public_send(_association.primary_key))
             unsynced(doc, inverse_foreign_key)
             yield(doc) if block_given?
+            doc.run_pending_callbacks
             doc
           end
 
           alias :new :build
 
-          # Delete the document from the relation. This will set the foreign key
-          # on the document to nil. If the dependent options on the relation are
-          # :delete or :destroy the appropriate removal will occur.
+          # Delete the document from the association. This will set the foreign key
+          # on the document to nil. If the dependent options on the association are
+          # :delete_all or :destroy the appropriate removal will occur.
           #
           # @example Delete the document.
           #   person.posts.delete(post)
@@ -107,42 +127,49 @@ module Mongoid
           # @param [ Document ] document The document to remove.
           #
           # @return [ Document ] The matching document.
-          #
-          # @since 2.1.0
           def delete(document)
             doc = super
             if doc && persistable?
-              _base.pull(foreign_key => doc.send(_association.primary_key))
+              _base.pull(foreign_key => doc.public_send(_association.primary_key))
               _target._unloaded = criteria
               unsynced(_base, foreign_key)
             end
             doc
           end
 
+          # Mongoid::Extensions::Array defines Array#delete_one, so we need
+          # to make sure that method behaves reasonably on proxies, too.
+          alias delete_one delete
+
           # Removes all associations between the base document and the target
           # documents by deleting the foreign keys and the references, orphaning
           # the target documents in the process.
           #
-          # @example Nullify the relation.
+          # @example Nullify the association.
           #   person.preferences.nullify
           #
           # @param [ Array<Document> ] replacement The replacement documents.
-          #
-          # @since 2.0.0.rc.1
           def nullify(replacement = [])
             _target.each do |doc|
               execute_callback :before_remove, doc
             end
             unless _association.forced_nil_inverse?
+              if field = _association.options[:inverse_primary_key]
+                ipk = _base.public_send(field)
+              else
+                ipk = _base._id
+              end
               if replacement
-                objects_to_clear = _base.send(foreign_key) - replacement.collect(&:id)
-                criteria(objects_to_clear).pull(inverse_foreign_key => _base._id)
+                objects_to_clear = _base.public_send(foreign_key) - replacement.collect do |object|
+                  object.public_send(_association.primary_key)
+                end
+                criteria(objects_to_clear).pull(inverse_foreign_key => ipk)
               else
-                criteria.pull(inverse_foreign_key => _base._id)
+                criteria.pull(inverse_foreign_key => ipk)
               end
             end
             if persistable?
-              _base.set(foreign_key => _base.send(foreign_key).clear)
+              _base.set(foreign_key => _base.public_send(foreign_key).clear)
             end
             after_remove_error = nil
             many_to_many = _target.clear do |doc|
@@ -165,23 +192,22 @@ module Mongoid
           alias :purge :nullify
 
           # Substitutes the supplied target documents for the existing documents
-          # in the relation. If the new target is nil, perform the necessary
+          # in the association. If the new target is nil, perform the necessary
           # deletion.
           #
-          # @example Replace the relation.
+          # @example Replace the association.
           # person.preferences.substitute([ new_post ])
           #
           # @param [ Array<Document> ] replacement The replacement target.
           #
-          # @return [ Many ] The relation.
-          #
-          # @since 2.0.0.rc.1
+          # @return [ Many ] The association.
           def substitute(replacement)
             purge(replacement)
             unless replacement.blank?
               push(replacement.compact.uniq)
             else
               reset_unloaded
+              clear_foreign_key_changes
             end
             self
           end
@@ -193,39 +219,60 @@ module Mongoid
           #   person.preferences.unscoped
           #
           # @return [ Criteria ] The unscoped criteria.
-          #
-          # @since 2.4.0
           def unscoped
-            klass.unscoped.any_in(_id: _base.send(foreign_key))
+            klass.unscoped.any_in(_id: _base.public_send(foreign_key))
           end
 
           private
 
+          # Clears the foreign key from the changed_attributes hash.
+          #
+          # This is, in general, used to clear the foreign key from the
+          # changed_attributes hash for consistency with the other referenced
+          # associations.
+          #
+          # @api private
+          def clear_foreign_key_changes
+            _base.changed_attributes.delete(foreign_key)
+          end
+
+          # Reset the value in the changed_attributes hash for the foreign key
+          # to its value before executing the given block.
+          #
+          # @api private
+          def reset_foreign_key_changes
+            if _base.changed_attributes.key?(foreign_key)
+              fk = _base.changed_attributes[foreign_key].dup
+              yield if block_given?
+              _base.changed_attributes[foreign_key] = fk
+            else
+              yield if block_given?
+              clear_foreign_key_changes
+            end
+          end
+
           # Appends the document to the target array, updating the index on the
           # document at the same time.
           #
-          # @example Append the document to the relation.
+          # @example Append the document to the association.
           #   relation.append(document)
           #
           # @param [ Document ] document The document to append to the target.
-          #
-          # @since 2.0.0.rc.1
           def append(document)
-            execute_callback :before_add, document
-            _target.push(document)
-            characterize_one(document)
-            bind_one(document)
-            execute_callback :after_add, document
+            execute_callbacks_around(:add, document) do
+              _target.push(document)
+              characterize_one(document)
+              bind_one(document)
+              yield if block_given?
+            end
           end
 
-          # Instantiate the binding associated with this relation.
+          # Instantiate the binding associated with this association.
           #
           # @example Get the binding.
           #   relation.binding([ address ])
           #
           # @return [ Binding ] The binding.
-          #
-          # @since 2.0.0.rc.1
           def binding
             HasAndBelongsToMany::Binding.new(_base, _target, _association)
           end
@@ -239,9 +286,7 @@ module Mongoid
           #
           # @param [ Document ] doc The document.
           #
-          # @return [ true, false ] If the document can be persisted.
-          #
-          # @since 3.0.20
+          # @return [ true | false ] If the document can be persisted.
           def child_persistable?(doc)
             (persistable? || _creating?) &&
                 !(doc.persisted? && _association.forced_nil_inverse?)
@@ -250,7 +295,7 @@ module Mongoid
           # Returns the criteria object for the target class with its documents set
           # to target.
           #
-          # @example Get a criteria for the relation.
+          # @example Get a criteria for the association.
           #   relation.criteria
           #
           # @return [ Criteria ] A new criteria.
@@ -269,8 +314,6 @@ module Mongoid
           # @param [ Symbol ] key The key to flag on the document.
           #
           # @return [ true ] true.
-          #
-          # @since 3.0.0
           def unsynced(doc, key)
             doc._synced[key] = false
             true
@@ -284,21 +327,17 @@ module Mongoid
             #
             # @param [ Association ] association The association object.
             # @param [ Array<Document> ] docs The array of documents.
-            #
-            # @since 7.0
             def eager_loader(association, docs)
               Eager.new(association, docs)
             end
 
-            # Returns true if the relation is an embedded one. In this case
+            # Returns true if the association is an embedded one. In this case
             # always false.
             #
-            # @example Is this relation embedded?
+            # @example Is this association embedded?
             #   Referenced::ManyToMany.embedded?
             #
             # @return [ false ] Always false.
-            #
-            # @since 2.0.0.rc.1
             def embedded?
               false
             end