mongoid 8.1.9 → 9.0.0

data/lib/mongoid/association/embedded/embeds_many/proxy.rb

@@ -6,10 +6,76 @@ module Mongoid
   module Association
     module Embedded
       class EmbedsMany
-
+        # Transparent proxy for embeds_many associations.
+        # An instance of this class is returned when calling the
+        # association getter method on the parent document. This
+        # class inherits from Mongoid::Association::Proxy and forwards
+        # most of its methods to the target of the association, i.e.
+        # the array of child documents.
         class Proxy < Association::Many
           include Batchable
 
+          # Class-level methods for the Proxy class.
+          module ClassMethods
+            # Returns the eager loader for this association.
+            #
+            # @param [ Array<Mongoid::Association> ] associations The
+            #   associations to be eager loaded
+            # @param [ Array<Mongoid::Document> ] docs The parent documents
+            #   that possess the given associations, which ought to be
+            #   populated by the eager-loaded documents.
+            #
+            # @return [ Mongoid::Association::Embedded::Eager ]
+            def eager_loader(associations, docs)
+              Eager.new(associations, docs)
+            end
+
+            # Returns true if the association is an embedded one. In this case
+            # always true.
+            #
+            # @example Is the association embedded?
+            #   Association::Embedded::EmbedsMany.embedded?
+            #
+            # @return [ true ] true.
+            def embedded?
+              true
+            end
+
+            # Returns the suffix of the foreign key field, either "_id" or "_ids".
+            #
+            # @example Get the suffix for the foreign key.
+            #   Association::Embedded::EmbedsMany.foreign_key_suffix
+            #
+            # @return [ nil ] nil.
+            def foreign_key_suffix
+              nil
+            end
+          end
+
+          extend ClassMethods
+
+          # Instantiate a new embeds_many association.
+          #
+          # @example Create the new association.
+          #   Many.new(person, addresses, association)
+          #
+          # @param [ Document ] base The document this association hangs off of.
+          # @param [ Array<Document> ] target The child documents of the association.
+          # @param [ Mongoid::Association::Relatable ] association The association metadata.
+          #
+          # @return [ Many ] The proxy.
+          def initialize(base, target, association)
+            super do
+              _target.each_with_index do |doc, index|
+                integrate(doc)
+                doc._index = index
+              end
+              update_attributes_hash
+              @_unscoped = _target.dup
+              @_target = scope(_target)
+            end
+          end
+
           # Appends a document or array of documents to the association. Will set
           # the parent and update the index in the process.
           #
@@ -22,15 +88,18 @@ module Mongoid
           # @param [ Document... ] *args Any number of documents.
           def <<(*args)
             docs = args.flatten
+            return unless docs.any?
             return concat(docs) if docs.size > 1
-            if doc = docs.first
+
+            docs.first.tap do |doc|
               append(doc)
               doc.save if persistable? && !_assigning?
             end
+
             self
           end
 
-          alias :push :<<
+          alias push <<
 
           # Get this association as as its representation in the database.
           #
@@ -67,17 +136,17 @@ module Mongoid
           #
           # @return [ Document ] The new document.
           def build(attributes = {}, type = nil)
-            doc = Factory.execute_build(type || _association.klass, attributes, execute_callbacks: false)
-            append(doc)
-            doc.apply_post_processed_defaults
-            yield(doc) if block_given?
-            doc.run_pending_callbacks
-            doc.run_callbacks(:build) { doc }
-            _base._reset_memoized_descendants!
-            doc
+            Factory.execute_build(type || _association.klass, attributes, execute_callbacks: false).tap do |doc|
+              append(doc)
+              doc.apply_post_processed_defaults
+              yield doc if block_given?
+              doc.run_pending_callbacks
+              doc.run_callbacks(:build) { doc }
+              _base._reset_memoized_descendants!
+            end
           end
 
-          alias :new :build
+          alias new build
 
           # Clear the association. Will delete the documents from the db
           # if they are already persisted.
@@ -124,7 +193,7 @@ module Mongoid
           def count(*args, &block)
             return _target.count(*args, &block) if args.any? || block
 
-            _target.select { |doc| doc.persisted? }.size
+            _target.count(&:persisted?)
           end
 
           # Delete the supplied document from the target. This method is proxied
@@ -138,19 +207,19 @@ module Mongoid
           # @return [ Document | nil ] The deleted document or nil if nothing deleted.
           def delete(document)
             execute_callbacks_around(:remove, document) do
-              doc = _target.delete_one(document)
-              if doc && !_binding?
-                _unscoped.delete_one(doc)
-                if _assigning?
-                  _base.add_atomic_pull(doc)
-                else
-                  doc.delete(suppress: true)
-                  unbind_one(doc)
+              _target.delete_one(document).tap do |doc|
+                if doc && !_binding?
+                  _unscoped.delete_one(doc)
+                  if _assigning?
+                    _base.add_atomic_pull(doc)
+                  else
+                    doc.delete(suppress: true)
+                    unbind_one(doc)
+                  end
+                  update_attributes_hash
                 end
-                update_attributes_hash
+                reindex
               end
-              reindex
-              doc
             end
           end
 
@@ -193,18 +262,14 @@ module Mongoid
           #     doc.state == "GA"
           #   end
           #
-          # @return [ Many | Enumerator ] The association or an enumerator if no
-          #   block was provided.
+          # @return [ EmbedsMany::Proxy | Enumerator ] The proxy or an
+          #   enumerator if no block was provided.
           def delete_if
-            if block_given?
-              dup_target = _target.dup
-              dup_target.each do |doc|
-                delete(doc) if yield(doc)
-              end
-              self
-            else
-              super
-            end
+            return super unless block_given?
+
+            _target.dup.each { |doc| delete(doc) if yield doc }
+
+            self
           end
 
           # Destroy all the documents in the association whilst running callbacks.
@@ -268,33 +333,12 @@ module Mongoid
           #   person.addresses.find { |addr| addr.state == 'CA' }
           #
           # @param [ Object... ] *args Various arguments.
-          # @param [ Proc ] block Optional block to pass.
+          # @param &block Optional block to pass.
+          # @yield [ Object ] Yields each enumerable element to the block.
           #
           # @return [ Document | Array<Document> | nil ] A document or matching documents.
-          def find(*args, &block)
-            criteria.find(*args, &block)
-          end
-
-          # Instantiate a new embeds_many association.
-          #
-          # @example Create the new association.
-          #   Many.new(person, addresses, association)
-          #
-          # @param [ Document ] base The document this association hangs off of.
-          # @param [ Array<Document> ] target The child documents of the association.
-          # @param [ Association ] association The association metadata
-          #
-          # @return [ Many ] The proxy.
-          def initialize(base, target, association)
-            init(base, target, association) do
-              _target.each_with_index do |doc, index|
-                integrate(doc)
-                doc._index = index
-              end
-              update_attributes_hash
-              @_unscoped = _target.dup
-              @_target = scope(_target)
-            end
+          def find(...)
+            criteria.find(...)
           end
 
           # Get all the documents in the association that are loaded into memory.
@@ -303,9 +347,7 @@ module Mongoid
           #   relation.in_memory
           #
           # @return [ Array<Document> ] The documents in memory.
-          def in_memory
-            _target
-          end
+          alias in_memory _target
 
           # Pop documents off the association. This can be a single document or
           # multiples, and will automatically persist the changes.
@@ -319,17 +361,12 @@ module Mongoid
           # @param [ Integer ] count The number of documents to pop, or 1 if not
           #   provided.
           #
-          # @return [ Document | Array<Document> ] The popped document(s).
+          # @return [ Document | Array<Document> | nil ] The popped document(s).
           def pop(count = nil)
-            if count
-              if docs = _target[_target.size - count, _target.size]
-                docs.each { |doc| delete(doc) }
-              end
-            else
-              delete(_target[-1])
-            end.tap do
-              update_attributes_hash
-            end
+            return [] if count&.zero?
+
+            docs = _target.last(count || 1).each { |doc| delete(doc) }
+            (count.nil? || docs.empty?) ? docs.first : docs
           end
 
           # Shift documents off the association. This can be a single document or
@@ -344,17 +381,12 @@ module Mongoid
           # @param [ Integer ] count The number of documents to shift, or 1 if not
           #   provided.
           #
-          # @return [ Document | Array<Document> ] The shifted document(s).
+          # @return [ Document | Array<Document> | nil ] The shifted document(s).
           def shift(count = nil)
-            if count
-              if _target.size > 0 && docs = _target[0, count]
-                docs.each { |doc| delete(doc) }
-              end
-            else
-              delete(_target[0])
-            end.tap do
-              update_attributes_hash
-            end
+            return [] if count&.zero?
+
+            docs = _target.first(count || 1).each { |doc| delete(doc) }
+            (count.nil? || docs.empty?) ? docs.first : docs
           end
 
           # Substitutes the supplied target documents for the existing documents
@@ -388,8 +420,10 @@ module Mongoid
 
           private
 
+          attr_accessor :_unscoped
+
           def object_already_related?(document)
-            _target.any? { |existing| existing._id && existing === document }
+            _target.any? { |existing| existing._id && existing == document }
           end
 
           # Appends the document to the target array, updating the index on the
@@ -401,9 +435,7 @@ module Mongoid
           # @param [ Document ] document The document to append to the target.
           def append(document)
             execute_callback :before_add, document
-            unless object_already_related?(document)
-              _target.push(*scope([document]))
-            end
+            _target.push(*scope([ document ])) unless object_already_related?(document)
             _unscoped.push(document)
             integrate(document)
             update_attributes_hash
@@ -448,15 +480,21 @@ module Mongoid
           #
           # @param [ Symbol | String ] name The name of the method.
           # @param [ Object... ] *args The method args.
-          # @param [ Proc ] block Optional block to pass.
+          # @param &block Optional block to pass.
           #
           # @return [ Criteria | Object ] A Criteria or return value from the target.
+          #
+          # TODO: make sure we are consistingly using respond_to_missing
+          #   anywhere we define method_missing.
+          # rubocop:disable Style/MissingRespondToMissing
           ruby2_keywords def method_missing(name, *args, &block)
             return super if _target.respond_to?(name)
+
             klass.send(:with_scope, criteria) do
               criteria.public_send(name, *args, &block)
             end
           end
+          # rubocop:enable Style/MissingRespondToMissing
 
           # Are we able to persist this association?
           #
@@ -490,9 +528,7 @@ module Mongoid
           #
           # @return [ Array<Document> ] The scoped docs.
           def scope(docs)
-            unless _association.order || _association.klass.default_scoping?
-              return docs
-            end
+            return docs unless _association.order || _association.klass.default_scoping?
 
             crit = _association.klass.order_by(_association.order)
             crit.embedded = true
@@ -512,32 +548,10 @@ module Mongoid
           # @return [ Integer ] The number of documents removed.
           def remove_all(conditions = {}, method = :delete)
             criteria = where(conditions || {})
-            removed = criteria.size
-            batch_remove(criteria, method)
-            update_attributes_hash
-            removed
-          end
-
-          # Get the internal unscoped documents.
-          #
-          # @example Get the unscoped documents.
-          #   relation._unscoped
-          #
-          # @return [ Array<Document> ] The unscoped documents.
-          def _unscoped
-            @_unscoped ||= []
-          end
-
-          # Set the internal unscoped documents.
-          #
-          # @example Set the unscoped documents.
-          #   relation._unscoped = docs
-          #
-          # @param [ Array<Document> ] docs The documents.
-          #
-          # @return [ Array<Document ] The unscoped docs.
-          def _unscoped=(docs)
-            @_unscoped = docs
+            criteria.size.tap do
+              batch_remove(criteria, method)
+              update_attributes_hash
+            end
           end
 
           # Returns a list of attributes hashes for each document.
@@ -551,34 +565,10 @@ module Mongoid
           #
           # @api private
           def update_attributes_hash
-            if !_target.empty?
-              _base.attributes.merge!(_association.store_as => _target.map(&:attributes))
-            else
+            if _target.empty?
               _base.attributes.delete(_association.store_as)
-            end
-          end
-
-          class << self
-
-            # Returns true if the association is an embedded one. In this case
-            # always true.
-            #
-            # @example Is the association embedded?
-            #   Association::Embedded::EmbedsMany.embedded?
-            #
-            # @return [ true ] true.
-            def embedded?
-              true
-            end
-
-            # Returns the suffix of the foreign key field, either "_id" or "_ids".
-            #
-            # @example Get the suffix for the foreign key.
-            #   Association::Embedded::EmbedsMany.foreign_key_suffix
-            #
-            # @return [ nil ] nil.
-            def foreign_key_suffix
-              nil
+            else
+              _base.attributes.merge!(_association.store_as => _target.map(&:attributes))
             end
           end
         end

data/lib/mongoid/association/embedded/embeds_many.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'mongoid/association/embedded/embeds_many/binding'
 require 'mongoid/association/embedded/embeds_many/buildable'

data/lib/mongoid/association/embedded/embeds_one/binding.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 module Mongoid
   module Association
@@ -21,7 +22,7 @@ module Mongoid
           def bind_one
             _target.parentize(_base)
             binding do
-              _target.do_or_do_not(_association.inverse_setter(_target), _base)
+              try_method(_target, _association.inverse_setter(_target), _base)
             end
           end
 
@@ -33,7 +34,7 @@ module Mongoid
           #   person.name = nil
           def unbind_one
             binding do
-              _target.do_or_do_not(_association.inverse_setter(_target), nil)
+              try_method(_target, _association.inverse_setter(_target), nil)
             end
           end
         end

data/lib/mongoid/association/embedded/embeds_one/buildable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 module Mongoid
   module Association

data/lib/mongoid/association/embedded/embeds_one/proxy.rb

@@ -4,18 +4,22 @@ module Mongoid
   module Association
     module Embedded
       class EmbedsOne
-
+        # Transparent proxy for embeds_one associations.
+        # An instance of this class is returned when calling the
+        # association getter method on the parent document. This
+        # class inherits from Mongoid::Association::Proxy and forwards
+        # most of its methods to the target of the association, i.e.
+        # the child document.
         class Proxy < Association::One
-
           # The valid options when defining this association.
           #
           # @return [ Array<Symbol> ] The allowed options when defining this association.
-          VALID_OPTIONS = [
-              :autobuild,
-              :as,
-              :cascade_callbacks,
-              :cyclic,
-              :store_as
+          VALID_OPTIONS = %i[
+            autobuild
+            as
+            cascade_callbacks
+            cyclic
+            store_as
           ].freeze
 
           # Instantiate a new embeds_one association.
@@ -25,9 +29,9 @@ module Mongoid
           #
           # @param [ Document ] base The document this association hangs off of.
           # @param [ Document ] target The child document in the association.
-          # @param [ Association ] association The association metadata.
+          # @param [ Mongoid::Association::Relatable ] association The association metadata.
           def initialize(base, target, association)
-            init(base, target, association) do
+            super do
               characterize_one(_target)
               bind_one
               characterize_one(_target)
@@ -47,51 +51,20 @@ module Mongoid
           #
           # @return [ Document | nil ] The association or nil.
           def substitute(replacement)
-            if replacement != self
-              if _assigning?
-                _base.add_atomic_unset(_target) unless replacement
-              else
-                # The associated object will be replaced by the below update if non-nil, so only
-                # run the callbacks and state-changing code by passing persist: false in that case.
-                _target.destroy(persist: !replacement) if persistable?
-
-                unless Mongoid.broken_updates
-                  # A little explanation on why this is needed... Say we have three assignments:
-                  #
-                  # canvas.palette = palette
-                  # canvas.palette = nil
-                  # canvas.palette = palette
-                  # Where canvas embeds_one palette.
-                  #
-                  # Previously, what was happening was, on the first assignment,
-                  # palette was considered a "new record" (new_record?=true) and
-                  # thus palette was being inserted into the database. However,
-                  # on the third assignment, we're trying to reassign the palette,
-                  # palette is no longer considered a new record, because it had
-                  # been inserted previously. This is not exactly accurate,
-                  # because the second assignment ultimately removed the palette
-                  # from the database, so it needs to be reinserted. Since the
-                  # palette's new_record is false, Mongoid ends up "updating" the
-                  # document, which doesn't reinsert it into the database.
-                  #
-                  # The change I introduce here, respecifies palette as a "new
-                  # record" when it gets removed from the database, so if it is
-                  # reassigned, it will be reinserted into the database.
-                  _target.new_record = true
-                end
-              end
-              unbind_one
-              unless replacement
-                update_attributes_hash(replacement)
-                return nil
-              end
-              replacement = Factory.build(klass, replacement) if replacement.is_a?(::Hash)
-              self._target = replacement
-              characterize_one(_target)
-              bind_one
-              update_attributes_hash(_target)
-              _target.save if persistable?
+            return self if replacement == self
+
+            if _assigning?
+              _base.add_atomic_unset(_target) unless replacement
+            else
+              update_target_when_not_assigning(replacement)
             end
+
+            unbind_one
+
+            return nil if replace_with_nil_document(replacement)
+
+            replace_with(replacement)
+
             self
           end
 
@@ -131,7 +104,92 @@ module Mongoid
             end
           end
 
+          # When not ``_assigning?``, the target may need to be destroyed, and
+          # may need to be marked as a new record. This method takes care of
+          # that, with extensive documentation for why it is necessary.
+          #
+          # @param [ Mongoid::Document ] replacement the replacement document
+          def update_target_when_not_assigning(replacement)
+            # The associated object will be replaced by the below update if non-nil, so only
+            # run the callbacks and state-changing code by passing persist: false in that case.
+            _target.destroy(persist: !replacement) if persistable?
+
+            # A little explanation on why this is needed... Say we have three assignments:
+            #
+            # canvas.palette = palette
+            # canvas.palette = nil
+            # canvas.palette = palette
+            # Where canvas embeds_one palette.
+            #
+            # Previously, what was happening was, on the first assignment,
+            # palette was considered a "new record" (new_record?=true) and
+            # thus palette was being inserted into the database. However,
+            # on the third assignment, we're trying to reassign the palette,
+            # palette is no longer considered a new record, because it had
+            # been inserted previously. This is not exactly accurate,
+            # because the second assignment ultimately removed the palette
+            # from the database, so it needs to be reinserted. Since the
+            # palette's new_record is false, Mongoid ends up "updating" the
+            # document, which doesn't reinsert it into the database.
+            #
+            # The change I introduce here, respecifies palette as a "new
+            # record" when it gets removed from the database, so if it is
+            # reassigned, it will be reinserted into the database.
+            _target.new_record = true
+          end
+
+          # Checks the argument. If it is non-nil, this method does nothing.
+          # Otherwise, it performs the logic for replacing the current
+          # document with nil.
+          #
+          # @param [ Mongoid::Document | Hash | nil ] replacement the document
+          #   to check.
+          #
+          # @return [ true | false ] whether a nil document was substituted
+          #   or not.
+          def replace_with_nil_document(replacement)
+            return false if replacement
+
+            update_attributes_hash(replacement)
+
+            # when `touch: true` is the default (see MONGOID-5016), creating
+            # an embedded document will touch the parent, and will cause the
+            # _descendants list to be initialized and memoized. If the object
+            # is then deleted, we need to make sure and un-memoize that list,
+            # otherwise when the update happens, the memoized _descendants list
+            # gets used and the "deleted" subdocument gets added again.
+            _reset_memoized_descendants!
+
+            true
+          end
+
+          # Replaces the current document with the given replacement
+          # document, which may be a Hash of attributes.
+          #
+          # @param [ Mongoid::Document | Hash ] replacement the document to
+          #   substitute in place of the current document.
+          def replace_with(replacement)
+            replacement = Factory.build(klass, replacement) if replacement.is_a?(::Hash)
+            self._target = replacement
+            characterize_one(_target)
+            bind_one
+            update_attributes_hash(_target)
+            _target.save if persistable?
+          end
+
           class << self
+            # Returns the eager loader for this association.
+            #
+            # @param [ Array<Mongoid::Association> ] associations The
+            #   associations to be eager loaded
+            # @param [ Array<Mongoid::Document> ] docs The parent documents
+            #   that possess the given associations, which ought to be
+            #   populated by the eager-loaded documents.
+            #
+            # @return [ Mongoid::Association::Embedded::Eager ]
+            def eager_loader(associations, docs)
+              Eager.new(associations, docs)
+            end
 
             # Returns true if the association is an embedded one. In this case
             # always true.

data/lib/mongoid/association/embedded/embeds_one.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'mongoid/association/embedded/embeds_one/binding'
 require 'mongoid/association/embedded/embeds_one/buildable'

data/lib/mongoid/association/embedded.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'mongoid/association/embedded/cyclic'
+require 'mongoid/association/embedded/eager'
 require 'mongoid/association/embedded/embedded_in'
 require 'mongoid/association/embedded/embeds_many'
 require 'mongoid/association/embedded/embeds_one'