mongoid 7.4.0 → 8.0.1

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

@@ -67,10 +67,11 @@ module Mongoid
           #
           # @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
@@ -94,6 +95,7 @@ module Mongoid
           # @return [ self ] The empty association.
           def clear
             batch_clear(_target.dup)
+            update_attributes_hash
             self
           end
 
@@ -135,20 +137,21 @@ module Mongoid
           #
           # @return [ Document, nil ] The deleted document or nil if nothing deleted.
           def delete(document)
-            execute_callback :before_remove, document
-            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)
+            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)
+                end
+                update_attributes_hash
               end
+              reindex
+              doc
             end
-            reindex
-            execute_callback :after_remove, document
-            doc
           end
 
           # Delete all the documents in the association without running callbacks.
@@ -209,7 +212,7 @@ module Mongoid
           #
           # @return [ true, false ] True is persisted documents exist, false if not.
           def exists?
-            count > 0
+            _target.any? { |doc| doc.persisted? }
           end
 
           # Finds a document in this association through several different
@@ -256,6 +259,7 @@ module Mongoid
                 integrate(doc)
                 doc._index = index
               end
+              update_attributes_hash
               @_unscoped = _target.dup
               @_target = scope(_target)
             end
@@ -291,6 +295,8 @@ module Mongoid
               end
             else
               delete(_target[-1])
+            end.tap do
+              update_attributes_hash
             end
           end
 
@@ -314,6 +320,8 @@ module Mongoid
               end
             else
               delete(_target[0])
+            end.tap do
+              update_attributes_hash
             end
           end
 
@@ -328,6 +336,7 @@ module Mongoid
           # @return [ Many ] The proxied association.
           def substitute(docs)
             batch_replace(docs)
+            update_attributes_hash
             self
           end
 
@@ -365,6 +374,7 @@ module Mongoid
             end
             _unscoped.push(document)
             integrate(document)
+            update_attributes_hash
             document._index = _unscoped.size - 1
             execute_callback :after_add, document
           end
@@ -398,6 +408,7 @@ module Mongoid
           def delete_one(document)
             _target.delete_one(document)
             _unscoped.delete_one(document)
+            update_attributes_hash
             reindex
           end
 
@@ -486,6 +497,7 @@ module Mongoid
             criteria = where(conditions || {})
             removed = criteria.size
             batch_remove(criteria, method)
+            update_attributes_hash
             removed
           end
 
@@ -511,12 +523,22 @@ module Mongoid
             @_unscoped = docs
           end
 
+          # Returns a list of attributes hashes for each document.
+          #
+          # @return [ Array<Hash> ] The list of attributes hashes
           def as_attributes
-            attributes = []
-            _unscoped.each do |doc|
-              attributes.push(doc.as_document)
+            _unscoped.map { |doc| doc.send(:as_attributes) }
+          end
+
+          # Update the _base's attributes hash with the _target's attributes
+          #
+          # @api private
+          def update_attributes_hash
+            if !_target.empty?
+              _base.attributes.merge!(_association.store_as => _target.map(&:attributes))
+            else
+              _base.attributes.delete(_association.store_as)
             end
-            attributes
           end
 
           class << self

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

@@ -25,11 +25,25 @@ module Mongoid
           #
           # @return [ Document ] A single document.
           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)
+            if object.is_a?(Hash)
+              if _loading? && base.persisted?
+                Factory.execute_from_db(klass, object, nil, selected_fields, execute_callbacks: false)
+              else
+                Factory.build(klass, object)
+              end
             else
-              Factory.build(klass, object)
+              clear_associated(object)
+              object
+            end
+          end
+
+          private
+
+          def clear_associated(doc)
+            if doc && (inv = inverse(doc))
+              if associated = doc.ivar(inv)
+                associated.substitute(nil)
+              end
             end
           end
         end

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

@@ -31,6 +31,7 @@ module Mongoid
               characterize_one(_target)
               bind_one
               characterize_one(_target)
+              update_attributes_hash(_target)
               _base._reset_memoized_descendants!
               _target.save if persistable?
             end
@@ -80,11 +81,15 @@ module Mongoid
                 end
               end
               unbind_one
-              return nil unless replacement
+              unless replacement
+                update_attributes_hash(replacement)
+                return nil
+              end
               replacement = Factory.build(klass, replacement) if replacement.is_a?(::Hash)
               self._target = replacement
-              bind_one
               characterize_one(_target)
+              bind_one
+              update_attributes_hash(_target)
               _target.save if persistable?
             end
             self
@@ -112,6 +117,20 @@ module Mongoid
             _base.persisted? && !_binding? && !_building? && !_assigning?
           end
 
+          # Update the _base's attributes hash with the _target's attributes
+          #
+          # @param replacement [ Document | nil ] The doc to use to update the
+          #   attributes hash.
+          #
+          # @api private
+          def update_attributes_hash(replacement)
+            if replacement
+              _base.attributes.merge!(_association.store_as => replacement.attributes)
+            else
+              _base.attributes.delete(_association.store_as)
+            end
+          end
+
           class << self
 
             # Returns true if the association is an embedded one. In this case

data/lib/mongoid/association/macros.rb

@@ -12,8 +12,29 @@ module Mongoid
         class_attribute :embedded, instance_reader: false
         class_attribute :embedded_relations
         class_attribute :relations
+
+        # A hash that maps aliases to their associations. This hash maps the
+        # associations "in database name" to its "in code" name. This is used when
+        # associations specify the `store_as` option, or on a referenced association.
+        # On a referenced association, this is used to map the foreign key to
+        # the association's name. For example, if we had the following
+        # relationship:
+        #
+        #   User has_many Accounts
+        #
+        # User will have an entry in the aliased associations hash:
+        #
+        #   account_ids => accounts
+        #
+        # Note that on the belongs_to associations, the mapping from
+        # foreign key => name is not in the aliased_associations hash, but a
+        # mapping from name => foreign key is in the aliased_fields hash.
+        #
+        # @return [ Hash<String, String> ] The aliased associations hash.
+        #
         # @api private
         class_attribute :aliased_associations
+
         self.embedded = false
         self.embedded_relations = BSON::Document.new
         self.relations = BSON::Document.new
@@ -196,7 +217,7 @@ module Mongoid
           Association::MACRO_MAPPING[macro_name].new(self, name, options, &block).tap do |assoc|
             assoc.setup!
             self.relations = self.relations.merge(name => assoc)
-            if assoc.respond_to?(:store_as) && assoc.store_as != name
+            if assoc.embedded? && assoc.respond_to?(:store_as) && assoc.store_as != name
               self.aliased_associations[assoc.store_as] = name
             end
           end

data/lib/mongoid/association/many.rb

@@ -61,6 +61,11 @@ module Mongoid
           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

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

@@ -134,8 +134,9 @@ module Mongoid
         # @param [ Proxy ] relation The association proxy.
         # @param [ Document ] doc The document to delete.
         def destroy_document(relation, doc)
+          res = doc.destroy unless doc.embedded? || doc.destroyed?
           relation.delete(doc)
-          doc.destroy unless doc.embedded? || doc.destroyed?
+          res
         end
 
         # Update the document.

data/lib/mongoid/association/proxy.rb

@@ -169,6 +169,18 @@ module Mongoid
         end
       end
 
+      # Execute the before and after callbacks for the given method.
+      #
+      # @param [ Symbol ] name The name of the callbacks to execute.
+      #
+      # @return [ Object ] The result of the given block
+      def execute_callbacks_around(name, doc)
+        execute_callback :"before_#{name.to_s}", doc
+        yield.tap do
+          execute_callback :"after_#{name.to_s}", doc
+        end
+      end
+
       class << self
 
         # Apply ordering to the criteria if it was defined on the association.

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

@@ -56,7 +56,8 @@ module Mongoid
                 __autosaving__ do
                   if assoc_value = ivar(association.name)
                     Array(assoc_value).each do |doc|
-                      doc.with(persistence_context) do |d|
+                      pc = doc.persistence_context? ? doc.persistence_context : persistence_context
+                      doc.with(pc) do |d|
                         d.save
                       end
                     end
@@ -64,7 +65,7 @@ module Mongoid
                 end
               end
             end
-            klass.after_save save_method, unless: :autosaved?
+            klass.after_persist_parent save_method, unless: :autosaved?
           end
         end
       end

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

@@ -28,6 +28,7 @@ module Mongoid
                   if _base.referenced_many?
                     _target.__send__(inverse).push(_base)
                   else
+                    remove_associated(_target)
                     _target.set_relation(inverse, _base)
                   end
                 end

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

@@ -28,7 +28,7 @@ module Mongoid
           private
 
           def execute_query(object, type)
-            query_criteria(object, type).limit(1).first(id_sort: :none)
+            query_criteria(object, type).take
           end
 
           def query_criteria(object, type)

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

@@ -153,7 +153,7 @@ module Mongoid
           create_foreign_key_field!
           setup_index!
           define_touchable!
-          @owner_class.validates_associated(name) if validate?
+          @owner_class.validates_associated(name) if validate? || require_association?
           @owner_class.validates(name, presence: true) if require_association?
         end
 

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

@@ -97,18 +97,18 @@ module Mongoid
 
           association.inverse_class.tap do |klass|
             klass.after_update do
-              if record = __send__(name)
-                foreign_key = association.foreign_key
+              foreign_key = association.foreign_key
 
-                if attribute_changed?(foreign_key)
-                  original, current = attribute_change(foreign_key)
+              if send("#{foreign_key}_previously_changed?")
+                original, current = send("#{foreign_key}_previous_change")
 
-                  unless original.nil?
-                    record.class.with(persistence_context) do |_class|
-                      _class.decrement_counter(cache_column, original)
-                    end
+                unless original.nil?
+                  association.klass.with(persistence_context) do |_class|
+                    _class.decrement_counter(cache_column, original)
                   end
+                end
 
+                if record = __send__(name)
                   unless current.nil?
                     record[cache_column] = (record[cache_column] || 0) + 1
                     record.class.with(record.persistence_context) do |_class|

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

@@ -28,10 +28,34 @@ module Mongoid
             docs = args.flatten
             return concat(docs) if docs.size > 1
             if doc = docs.first
-              append(doc)
-              _base.add_to_set(foreign_key => doc.public_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
@@ -81,12 +105,13 @@ module Mongoid
           #
           # @return [ Document ] The new document.
           def build(attributes = {}, type = nil)
-            doc = Factory.build(type || klass, attributes)
-            _base.public_send(foreign_key).push(doc.public_send(_association.primary_key))
+            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
 
@@ -178,6 +203,7 @@ module Mongoid
               push(replacement.compact.uniq)
             else
               reset_unloaded
+              clear_foreign_key_changes
             end
             self
           end
@@ -195,6 +221,32 @@ module Mongoid
 
           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.
           #
@@ -203,11 +255,12 @@ module Mongoid
           #
           # @param [ Document ] document The document to append to the target.
           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 association.

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

@@ -119,6 +119,8 @@ module Mongoid
             @options[:inverse_foreign_key]
           elsif @options.key?(:inverse_of)
             inverse_of ? "#{inverse_of.to_s.singularize}#{FOREIGN_KEY_SUFFIX}" : nil
+          elsif inv = inverse_association&.foreign_key
+            inv
           else
             "#{inverse_class_name.demodulize.underscore}#{FOREIGN_KEY_SUFFIX}"
           end
@@ -219,7 +221,7 @@ module Mongoid
         def synced_save
           assoc = self
           inverse_class.set_callback(
-              :save,
+              :persist_parent,
               :after,
               if: ->(doc){ doc._syncable?(assoc) }
           ) do |doc|
@@ -228,6 +230,7 @@ module Mongoid
         end
 
         def create_foreign_key_field!
+          inverse_class.aliased_associations[foreign_key] = name.to_s
           @owner_class.field(
               foreign_key,
               type: FOREIGN_KEY_FIELD_TYPE,

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

@@ -240,17 +240,15 @@ module Mongoid
           # @note Automatically adding a sort on _id when no other sort is
           #   defined on the criteria has the potential to cause bad performance issues.
           #   If you experience unexpected poor performance when using #first or #last,
-          #   use the option { id_sort: :none }.
-          #   Be aware that #first/#last won't guarantee order in this case.
+          #   use #take instead.
+          #   Be aware that #take won't guarantee order.
           #
-          # @param [ Hash ] opts The options for the query returning the first document.
-          #
-          # @option opts [ :none ] :id_sort Don't apply a sort on _id.
+          # @param [ Integer ] limit The number of documents to return.
           #
           # @return [ Document ] The first document found.
-          def first(opts = {})
+          def first(limit = nil)
             _loaded.try(:values).try(:first) ||
-                _added[(ul = _unloaded.try(:first, opts)).try(:_id)] ||
+                _added[(ul = _unloaded.try(:first, limit)).try(:_id)] ||
                 ul ||
                 _added.values.try(:first)
           end
@@ -327,18 +325,16 @@ module Mongoid
           # @note Automatically adding a sort on _id when no other sort is
           #   defined on the criteria has the potential to cause bad performance issues.
           #   If you experience unexpected poor performance when using #first or #last,
-          #   use the option { id_sort: :none }.
-          #   Be aware that #first/#last won't guarantee order in this case.
-          #
-          # @param [ Hash ] opts The options for the query returning the first document.
+          #   use #take instead.
+          #   Be aware that #take won't guarantee order.
           #
-          # @option opts [ :none ] :id_sort Don't apply a sort on _id.
+          # @param [ Integer ] limit The number of documents to return.
           #
           # @return [ Document ] The last document found.
-          def last(opts = {})
+          def last(limit = nil)
             _added.values.try(:last) ||
                 _loaded.try(:values).try(:last) ||
-                _added[(ul = _unloaded.try(:last, opts)).try(:_id)] ||
+                _added[(ul = _unloaded.try(:last, limit)).try(:_id)] ||
                 ul
           end
 

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

@@ -71,10 +71,11 @@ module Mongoid
           #
           # @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
@@ -92,13 +93,15 @@ module Mongoid
           #
           # @return [ Document ] The matching document.
           def delete(document)
-            execute_callback :before_remove, document
-            _target.delete(document) do |doc|
-              if doc
-                unbind_one(doc)
-                cascade!(doc) if !_assigning?
+            execute_callbacks_around(:remove, document) do
+              _target.delete(document) do |doc|
+                if doc
+                  unbind_one(doc)
+                  cascade!(doc) if !_assigning?
+                end
+              end.tap do
+                reset_unloaded
               end
-              execute_callback :after_remove, doc
             end
           end
 
@@ -469,8 +472,8 @@ module Mongoid
             selector = conditions || {}
             removed = klass.send(method, selector.merge!(criteria.selector))
             _target.delete_if do |doc|
-              if doc._matches?(selector)
-                unbind_one(doc) and true
+              doc._matches?(selector).tap do |b|
+                unbind_one(doc) if b
               end
             end
             removed

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

@@ -53,7 +53,7 @@ module Mongoid
           end
 
           def execute_query(object, base)
-            query_criteria(object, base).limit(1).first(id_sort: :none)
+            query_criteria(object, base).take
           end
 
           def with_polymorphic_criterion(criteria, base)

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

@@ -49,17 +49,14 @@ module Mongoid
           #
           # @return [ One ] The association.
           def substitute(replacement)
-            # If the same object currently associated is being assigned,
-            # rebind the association and save the target but do not destroy
-            # the target.
-
-            unbind_one
-            if persistable?
-              # TODO can this entire method be skipped if self == replacement?
-              if _association.destructive? && self != replacement
-                send(_association.dependent)
-              else
-                save if persisted?
+            if self != replacement
+              unbind_one
+              if persistable?
+                if _association.destructive?
+                  send(_association.dependent)
+                else
+                  save if persisted?
+                end
               end
             end
             HasOne::Proxy.new(_base, replacement, _association) if replacement

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

@@ -67,8 +67,8 @@ module Mongoid
         #
         # @return [ Object ] The updated values.
         def update_inverse_keys(association)
-          if changes.has_key?(association.foreign_key)
-            old, new = changes[association.foreign_key]
+          if previous_changes.has_key?(association.foreign_key)
+            old, new = previous_changes[association.foreign_key]
             adds, subs = new - (old || []), (old || []) - new
 
             # If we are autosaving we don't want a duplicate to get added - the