mongoid 8.1.9 → 9.0.0

data/lib/mongoid/association/eager.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+module Mongoid
+  module Association
+
+    # Base class for eager load preload functions.
+    class Eager
+      # Instantiate the eager load class.
+      #
+      # @example Create the new belongs to eager load preloader.
+      #   BelongsTo.new(association, parent_docs)
+      #
+      # @param [ Array<Mongoid::Association::Relatable> ] associations
+      #   Associations to eager load
+      # @param [ Array<Document> ] docs Documents to preload the associations
+      #
+      # @return [ Base ] The eager load preloader
+      def initialize(associations, docs)
+        @associations = associations
+        @docs = docs
+        @grouped_docs = {}
+      end
+
+      # Run the preloader.
+      #
+      # @example Preload the associations into the documents.
+      #   loader.run
+      #
+      # @return [ Array ] The list of documents given.
+      def run
+        @loaded = []
+        while shift_association
+          preload
+          @loaded << @docs.collect { |d| d.send(@association.name) if d.respond_to?(@association.name) }
+        end
+        @loaded.flatten
+      end
+
+      protected
+
+      # Preload the current association.
+      #
+      # This method should be implemented in the subclass
+      #
+      # @example Preload the current association into the documents.
+      #   loader.preload
+      def preload
+        raise NotImplementedError
+      end
+
+      # 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
+        end
+      end
+
+      # Set the pre-loaded document into its parent.
+      #
+      # @example Set docs into parent with pk = "foo"
+      #   loader.set_on_parent("foo", docs)
+      #
+      # @param [ ObjectId ] id parent`s id
+      # @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)
+        end
+      end
+
+      # 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.
+      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.
+      #
+      # 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
+      def keys_from_docs
+        grouped_docs.keys
+      end
+
+      # Return the key to group the current documents.
+      #
+      # This method should be implemented in the subclass
+      #
+      # @example Return the key for group
+      #   loader.group_by_key
+      #
+      # @return [ Symbol ] Key to group by the current documents.
+      def group_by_key
+        raise NotImplementedError
+      end
+
+      # Set the pre-loaded document into its parent.
+      #
+      # @example Set docs into parent using the current association name.
+      #   loader.set_relation(doc, docs)
+      #
+      # @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
+
+      private
+
+      # Shift the current association metadata
+      #
+      # @example Shift the current association.
+      #   loader.shift_association
+      #
+      # @return [ Mongoid::Association::Relatable ] The association object.
+      def shift_association
+        @association = @associations.shift
+      end
+    end
+  end
+end

data/lib/mongoid/association/eager_loadable.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
-require "mongoid/association/referenced/eager"
+require "mongoid/association/eager"
 
 module Mongoid
   module Association
@@ -8,10 +9,19 @@ module Mongoid
     # This module defines the eager loading behavior for criteria.
     module EagerLoadable
 
+      # Indicates whether the criteria has association
+      # inclusions which should be eager loaded.
+      #
+      # @return [ true | false ] Whether to eager load.
       def eager_loadable?
         !criteria.inclusions.empty?
       end
 
+      # Load the associations for the given documents.
+      #
+      # @param [ Array<Mongoid::Document> ] docs The documents.
+      #
+      # @return [ Array<Mongoid::Document> ] The given documents.
       def eager_load(docs)
         docs.tap do |d|
           if eager_loadable?
@@ -22,18 +32,16 @@ module Mongoid
 
       # Load the associations for the given documents. This will be done
       # recursively to load the associations of the given documents'
-      # subdocuments.
+      # associated documents.
       #
-      # @param [ Array<Association> ] associations The associations to load.
-      # @param [ Array<Document> ] document The documents.
+      # @param [ Array<Mongoid::Association::Relatable> ] associations
+      #   The associations to load.
+      # @param [ Array<Mongoid::Document> ] docs The documents.
       def preload(associations, docs)
         assoc_map = associations.group_by(&:inverse_class_name)
         docs_map = {}
         queue = [ klass.to_s ]
 
-        # account for single-collection inheritance
-        queue.push(klass.root_class.to_s) if klass != klass.root_class
-
         while klass = queue.shift
           if as = assoc_map.delete(klass)
             as.each do |assoc|

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 module Mongoid
   module Association
@@ -38,13 +39,11 @@ module Mongoid
               positionally(selector, "$unset" => { path => true }),
               session: _session
             )
-            unless Mongoid.broken_updates
-              # This solves the case in which a user sets, clears and resets an
-              # embedded document. Previously, since the embedded document was
-              # already marked not a "new_record", it wouldn't be persisted to
-              # the second time. This change fixes that and allows it to be persisted.
-              docs.each { |doc| doc.new_record = true }
-            end
+            # This solves the case in which a user sets, clears and resets an
+            # embedded document. Previously, since the embedded document was
+            # already marked not a "new_record", it wouldn't be persisted to
+            # the second time. This change fixes that and allows it to be persisted.
+            docs.each { |doc| doc.new_record = true }
             post_process_batch_remove(docs, :delete)
           end
           _unscoped.clear

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

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

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # Eager class for embedded associations (embedded_in, embeds_many,
+      # embeds_one).
+      class Eager < Association::Eager
+
+        private
+
+        # Embedded associations have no preload phase, since the embedded
+        # documents are loaded with the parent document. This method is
+        # implemented as a no-op to represent that.
+        def preload
+        end
+      end
+
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 module Mongoid
   module Association
@@ -24,10 +25,10 @@ module Mongoid
               _base._association = _association.inverse_association(_target) unless _base._association
               _base.parentize(_target)
               if _base.embedded_many?
-                _target.do_or_do_not(_association.inverse(_target)).push(_base)
+                _target.send(_association.inverse(_target)).push(_base)
               else
                 remove_associated(_target)
-                _target.do_or_do_not(_association.inverse_setter(_target), _base)
+                try_method(_target, _association.inverse_setter(_target), _base)
               end
             end
           end
@@ -41,9 +42,9 @@ module Mongoid
           def unbind_one
             binding do
               if _base.embedded_many?
-                _target.do_or_do_not(_association.inverse(_target)).delete(_base)
+                _target.send(_association.inverse(_target)).delete(_base)
               else
-                _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/embedded_in/buildable.rb

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

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

@@ -4,9 +4,13 @@ module Mongoid
   module Association
     module Embedded
       class EmbeddedIn
-
+        # Transparent proxy for embedded_in associations.
+        # An instance of this class is returned when calling the
+        # association getter method on the child document. This
+        # class inherits from Mongoid::Association::Proxy and forwards
+        # most of its methods to the target of the association, i.e.
+        # the parent document.
         class Proxy < Association::One
-
           # Instantiate a new embedded_in association.
           #
           # @example Create the new association.
@@ -14,11 +18,11 @@ module Mongoid
           #
           # @param [ Document ] base The document the association hangs off of.
           # @param [ Document ] target The target (parent) of the association.
-          # @param [ Association ] association The association metadata.
+          # @param [ Mongoid::Association::Relatable ] association The association metadata.
           #
           # @return [ In ] The proxy.
           def initialize(base, target, association)
-            init(base, target, association) do
+            super do
               characterize_one(_target)
               bind_one
             end
@@ -65,9 +69,7 @@ module Mongoid
           #
           # @param [ Document ] document The document to set the association metadata on.
           def characterize_one(document)
-            unless _base._association
-              _base._association = _association.inverse_association(document)
-            end
+            _base._association ||= _association.inverse_association(document)
           end
 
           # Are we able to persist this association?
@@ -81,6 +83,18 @@ module Mongoid
           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/embedded_in.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'mongoid/association/embedded/embedded_in/binding'
 require 'mongoid/association/embedded/embedded_in/buildable'
@@ -34,6 +35,7 @@ module Mongoid
         #
         # @return [ self ]
         def setup!
+          setup_defaults!
           setup_instance_methods!
           @owner_class.embedded = true
           self
@@ -92,6 +94,11 @@ module Mongoid
 
         private
 
+        # Set up default values for any options used by this association.
+        def setup_defaults!
+          @options[:touch] = true unless @options.key?(:touch)
+        end
+
         def setup_instance_methods!
           define_getter!
           define_setter!

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 module Mongoid
   module Association
@@ -20,7 +21,7 @@ module Mongoid
             doc.parentize(_base)
             binding do
               remove_associated(doc)
-              doc.do_or_do_not(_association.inverse_setter(_target), _base)
+              try_method(doc, _association.inverse_setter(_target), _base)
             end
           end
 
@@ -32,7 +33,7 @@ module Mongoid
           # @param [ Document ] doc The single document to unbind.
           def unbind_one(doc)
             binding do
-              doc.do_or_do_not(_association.inverse_setter(_target), nil)
+              try_method(doc, _association.inverse_setter(_target), nil)
             end
           end
         end

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

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