MONGOID-2586 cannot access parent object in the after_find function (#5174)

* MONGOID-2586 add test

* MONGOID-2586 potential fix

* MONGOID-2586 introduce pending callbacks

* MONGOID-2586 remove block from instantiate

* MONGOID-2586 remove yield and add after initialize test

* MONGOID-2586 fix session tests

* MONGOID-2586 pending test for CI

* MONGOID-2586 fix interceptable tests

* MONGOID-2586 exclude hasmany enumerables

* MONGOID-2586 change condition

* MONGOID-2586 only execute callbacks on embedded associations

* MONGOID-2586 change callbacks option

* MONGOID-2586 move tests and add callback

* MONGOID-2586 change default on defer_callbacks

* MONGOID-2586 add tests for other associations

* MONGOID-2586 add embed_one tests

* MONGOID-2586 update comments and remove TODOs

* MONGOID-2586 delay defaults and refactor tests

* MONGOID-2586 update the comments

* MONGOID-2586 update comments

* MONGOID-2586 clear pending callbacks

* MONGOID-2586 defer callbacks for unpersisted intializers. Add tests for HABTM and create/build methods

* MONGOID-2586 change param to avoid attribute failures

* MONGOID-2586 change instantiate params

* MONGOID-2586 change params for instantiate

* MONGOID-2586 change params to avoid errors

* MONGOID-2586 more param related errors

* MONGOID-2586 remove byebug

* MONGOID-2586 extract the constructor

* MONGOID-2586 remove splat operator

* MONGOID-2586 add private api and comments

* MONGOID-2586 duplicate factory functions

* MONGOID-2586 duplicate instantiate, change to keyword argument

* MONGOID-2586 add back block functionality to instantiate

* MONGOID-2586 flip and rename the flag

* MONGOID-2586 remove byebugs

* MONGOID-2586 update comments

* MONGOID-2586 change comment

Author: neilshweky

lib/mongoid/association/accessors.rb

@@ -42,8 +42,23 @@ def __build__(name, object, association, selected_fields = nil)
       # @return [ Proxy ] The association.
       def create_relation(object, association, selected_fields = nil)
         type = @attributes[association.inverse_type]
-        target = association.build(self, object, type, selected_fields)
-        target ? association.create_relation(self, target) : nil
+        target = if t = association.build(self, object, type, selected_fields)
+          association.create_relation(self, t)
+        else
+          nil
+        end
+
+        # Only need to do this on embedded associations. The pending callbacks
+        # are only added when materializing the documents, which only happens
+        # on embedded associations. There is no call to the database in the
+        # construction of a referenced association.
+        if association.embedded?
+          Array(target).each do |doc|
+            doc.try(:run_pending_callbacks)
+          end
+        end
+
+        target
       end
 
       # Resets the criteria inside the association proxy. Used by many-to-many

lib/mongoid/association/builders.rb

@@ -46,9 +46,10 @@ def self.define_builder!(association)
         association.inverse_class.tap do |klass|
           klass.re_define_method("build_#{association.name}") do |*args|
             attributes, _options = parse_args(*args)
-            document = Factory.build(association.relation_class, attributes)
+            document = Factory.execute_build(association.relation_class, attributes, execute_callbacks: false)
             _building do
               child = send("#{association.name}=", document)
+              child.run_pending_callbacks
               child.run_callbacks(:build)
               child
             end
@@ -69,10 +70,11 @@ def self.define_creator!(association)
         association.inverse_class.tap do |klass|
           klass.re_define_method("create_#{association.name}") do |*args|
             attributes, _options = parse_args(*args)
-            document = Factory.build(association.relation_class, attributes)
+            document = Factory.execute_build(association.relation_class, attributes, execute_callbacks: false)
             doc = _assigning do
               send("#{association.name}=", document)
             end
+            doc.run_pending_callbacks
             doc.save
             save if new_record? && association.stores_foreign_key?
             doc

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

@@ -31,7 +31,7 @@ def build(base, object, type = nil, selected_fields = nil)
             docs = []
             object.each do |attrs|
               if _loading? && base.persisted?
-                docs.push(Factory.from_db(klass, attrs, nil, selected_fields))
+                docs.push(Factory.execute_from_db(klass, attrs, nil, selected_fields, execute_callbacks: false))
               else
                 docs.push(Factory.build(klass, attrs))
               end

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

@@ -67,10 +67,11 @@ def concat(docs)
           #
           # @return [ Document ] The new document.
           def build(attributes = {}, type = nil)
-            doc = Factory.build(type || _association.klass, attributes)
+            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

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

@@ -27,7 +27,7 @@ module Buildable
           def build(base, object, _type = nil, selected_fields = nil)
             return object unless object.is_a?(Hash)
             if _loading? && base.persisted?
-              Factory.from_db(klass, object, nil, selected_fields)
+              Factory.execute_from_db(klass, object, nil, selected_fields, execute_callbacks: false)
             else
               Factory.build(klass, object)
             end

lib/mongoid/association/many.rb

@@ -61,6 +61,11 @@ def create!(attributes = nil, type = nil, &block)
           attributes.map { |attrs| create!(attrs, type, &block) }
         else
           doc = build(attributes, type, &block)
+
+          Array(doc).each do |doc|
+            doc.try(:run_pending_callbacks)
+          end
+
           _base.persisted? ? doc.save! : raise_unsaved(doc)
           doc
         end

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

@@ -83,12 +83,13 @@ def concat(documents)
           #
           # @return [ Document ] The new document.
           def build(attributes = {}, type = nil)
-            doc = Factory.build(type || klass, attributes)
+            doc = Factory.execute_build(type || klass, attributes, execute_callbacks: false)
             _base.public_send(foreign_key).push(doc.public_send(_association.primary_key))
             append(doc)
             doc.apply_post_processed_defaults
             unsynced(doc, inverse_foreign_key)
             yield(doc) if block_given?
+            doc.run_pending_callbacks
             doc
           end
 

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

@@ -71,10 +71,11 @@ def concat(documents)
           #
           # @return [ Document ] The new document.
           def build(attributes = {}, type = nil)
-            doc = Factory.build(type || klass, attributes)
+            doc = Factory.execute_build(type || 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 }
             doc
           end

lib/mongoid/document.rb

@@ -100,21 +100,8 @@ def identity
     # @param [ Hash ] attrs The attributes to set up the document with.
     #
     # @return [ Document ] A new document.
-    def initialize(attrs = nil)
-      @__parent = nil
-      _building do
-        @new_record = true
-        @attributes ||= {}
-        apply_pre_processed_defaults
-        apply_default_scoping
-        process_attributes(attrs) do
-          yield(self) if block_given?
-        end
-        apply_post_processed_defaults
-        # @todo: #2586: Need to have access to parent document in these
-        #   callbacks.
-        run_callbacks(:initialize) unless _initialize_callbacks.empty?
-      end
+    def initialize(attrs = nil, &block)
+      construct_document(attrs, execute_callbacks: true, &block)
     end
 
     # Return the model name of the document.
@@ -228,6 +215,36 @@ def becomes(klass)
 
     private
 
+    # Does the construction of a document.
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+    #   should be run.
+    #
+    # @return [ Document ] A new document.
+    #
+    # @api private
+    def construct_document(attrs = nil, execute_callbacks: true)
+      @__parent = nil
+      _building do
+        @new_record = true
+        @attributes ||= {}
+        apply_pre_processed_defaults
+        apply_default_scoping
+        process_attributes(attrs) do
+          yield(self) if block_given?
+        end
+        apply_post_processed_defaults
+
+        if execute_callbacks
+          run_callbacks(:initialize) unless _initialize_callbacks.empty?
+        else
+          pending_callbacks << :initialize
+        end
+      end
+      self
+    end
+
     # Returns the logger
     #
     # @return [ Logger ] The configured logger or a default Logger instance.
@@ -281,20 +298,58 @@ module ClassMethods
       # @param [ Hash ] attrs The hash of attributes to instantiate with.
       # @param [ Integer ] selected_fields The selected fields from the
       #   criteria.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      def instantiate(attrs = nil, selected_fields = nil, &block)
+        instantiate_document(attrs, selected_fields, execute_callbacks: true, &block)
+      end
+
+      # Instantiate the document.
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      # @param [ Integer ] selected_fields The selected fields from the
+      #   criteria.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
       #
       # @return [ Document ] A new document.
-      def instantiate(attrs = nil, selected_fields = nil)
+      #
+      # @api private
+      def instantiate_document(attrs = nil, selected_fields = nil, execute_callbacks: true)
         attributes = attrs || {}
         doc = allocate
         doc.__selected_fields = selected_fields
         doc.instance_variable_set(:@attributes, attributes)
-        doc.apply_defaults
-        yield(doc) if block_given?
-        doc.run_callbacks(:find) unless doc._find_callbacks.empty?
-        doc.run_callbacks(:initialize) unless doc._initialize_callbacks.empty?
+
+        if execute_callbacks
+          doc.apply_defaults
+          yield(doc) if block_given?
+          doc.run_callbacks(:find) unless doc._find_callbacks.empty?
+          doc.run_callbacks(:initialize) unless doc._initialize_callbacks.empty?
+        else
+          yield(doc) if block_given?
+          doc.pending_callbacks.push(:apply_defaults, :find, :initialize)
+        end
+
         doc
       end
 
+      # Allocates and constructs a document.
+      #
+      # @param [ Hash ] attrs The attributes to set up the document with.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      #
+      # @api private
+      def construct_document(attrs = nil, execute_callbacks: true)
+        doc = allocate
+        doc.send(:construct_document, attrs, execute_callbacks: execute_callbacks)
+      end
+
       # Returns all types to query for when using this class as the base.
       #
       # @example Get the types.

lib/mongoid/factory.rb

@@ -23,16 +23,32 @@ module Factory
     #
     # @param [ Class ] klass The class to instantiate from if _type is not present.
     # @param [ Hash ] attributes The document attributes.
+    # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+    #   should be run.
     #
     # @return [ Document ] The instantiated document.
     def build(klass, attributes = nil)
+      execute_build(klass, attributes, execute_callbacks: true)
+    end
+
+    # Execute the build.
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
+    # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+    #   should be run.
+    #
+    # @return [ Document ] The instantiated document.
+    #
+    # @api private
+    def execute_build(klass, attributes = nil, execute_callbacks: true)
       attributes ||= {}
       dvalue = attributes[klass.discriminator_key] || attributes[klass.discriminator_key.to_sym]
       type = klass.get_discriminator_mapping(dvalue)
       if type
-        type.new(attributes)
+        type.construct_document(attributes, execute_callbacks: execute_callbacks)
       else
-        klass.new(attributes)
+        klass.construct_document(attributes, execute_callbacks: execute_callbacks)
       end
     end
 
@@ -63,12 +79,34 @@ def build(klass, attributes = nil)
     #
     # @return [ Document ] The instantiated document.
     def from_db(klass, attributes = nil, criteria = nil, selected_fields = nil)
+      execute_from_db(klass, attributes, criteria, selected_fields, execute_callbacks: true)
+    end
+
+    # Execute from_db.
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
+    # @param [ Criteria ] criteria Optional criteria object.
+    # @param [ Hash ] selected_fields Fields which were retrieved via
+    #   #only. If selected_fields are specified, fields not listed in it
+    #   will not be accessible in the returned document.
+    # @param [ true | false ] execute_callbacks Whether this method should
+    #   invoke the callbacks. If true, the callbacks will be invoked normally.
+    #   If false, the callbacks will be stored in the +pending_callbacks+ list
+    #   and caller is responsible for invoking +run_pending_callbacks+ at a
+    #   later time. Use this option to defer callback execution until the
+    #   entire object graph containing embedded associations is constructed.
+    #
+    # @return [ Document ] The instantiated document.
+    #
+    # @api private
+    def execute_from_db(klass, attributes = nil, criteria = nil, selected_fields = nil, execute_callbacks: true)
       if criteria
         selected_fields ||= criteria.options[:fields]
       end
       type = (attributes || {})[klass.discriminator_key]
       if type.blank?
-        obj = klass.instantiate(attributes, selected_fields)
+        obj = klass.instantiate_document(attributes, selected_fields, execute_callbacks: execute_callbacks)
         if criteria && criteria.association && criteria.parent_document
           obj.set_relation(criteria.association.inverse, criteria.parent_document)
         end
@@ -92,7 +130,7 @@ def from_db(klass, attributes = nil, criteria = nil, selected_fields = nil)
           raise Errors::UnknownModel.new(camelized, type)
         end
 
-        constantized.instantiate(attributes, selected_fields)
+        constantized.instantiate_document(attributes, selected_fields, execute_callbacks: execute_callbacks)
       end
     end
   end