mongoid 6.4.8 → 7.5.4

data/lib/mongoid/association/depending.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+
+    # This module defines the behavior for setting up cascading deletes and
+    # nullifies for associations, and how to delegate to the appropriate strategy.
+    module Depending
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :dependents
+
+        # @api private
+        class_attribute :dependents_owner
+
+        self.dependents = []
+        self.dependents_owner = self
+      end
+
+      class_methods do
+        # @api private
+        def _all_dependents
+          superclass_dependents = superclass.respond_to?(:_all_dependents) ? superclass._all_dependents : []
+          dependents + superclass_dependents.reject do |new_dep|
+            dependents.any? do |old_dep| old_dep.name == new_dep.name
+            end
+          end
+        end
+      end
+
+      # The valid dependent strategies.
+      STRATEGIES = [
+          :delete_all,
+          :destroy,
+          :nullify,
+          :restrict_with_exception,
+          :restrict_with_error
+      ]
+
+      # Attempt to add the cascading information for the document to know how
+      # to handle associated documents on a removal.
+      #
+      # @example Set up cascading information
+      #   Mongoid::Association::Depending.define_dependency!(association)
+      #
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Class ] The class of the document.
+      def self.define_dependency!(association)
+        validate!(association)
+        association.inverse_class.tap do |klass|
+          if klass.dependents_owner != klass
+            klass.dependents = []
+            klass.dependents_owner = klass
+          end
+
+          if association.dependent && !klass.dependents.include?(association)
+            klass.dependents.push(association)
+          end
+        end
+      end
+
+      def self.validate!(association)
+        unless STRATEGIES.include?(association.dependent)
+          raise Errors::InvalidDependentStrategy.new(association,
+                                                     association.dependent,
+                                                     STRATEGIES)
+        end
+      end
+
+      # Perform all cascading deletes, destroys, or nullifies. Will delegate to
+      # the appropriate strategy to perform the operation.
+      #
+      # @example Execute cascades.
+      #   document.apply_destroy_dependencies!
+      def apply_destroy_dependencies!
+        self.class._all_dependents.each do |association|
+          if dependent = association.try(:dependent)
+            send("_dependent_#{dependent}!", association)
+          end
+        end
+      end
+
+      private
+
+      def _dependent_delete_all!(association)
+        if relation = send(association.name)
+          if relation.respond_to?(:dependents) && relation.dependents.blank?
+            relation.clear
+          else
+            ::Array.wrap(send(association.name)).each { |rel| rel.delete }
+          end
+        end
+      end
+
+      def _dependent_destroy!(association)
+        if relation = send(association.name)
+          if relation.is_a?(Enumerable)
+            relation.entries
+            relation.each { |doc| doc.destroy }
+          else
+            relation.destroy
+          end
+        end
+      end
+
+      def _dependent_nullify!(association)
+        if relation = send(association.name)
+          relation.nullify
+        end
+      end
+
+      def _dependent_restrict_with_exception!(association)
+        if (relation = send(association.name)) && !relation.blank?
+          raise Errors::DeleteRestriction.new(relation, association.name)
+        end
+      end
+
+      def _dependent_restrict_with_error!(association)
+        if (relation = send(association.name)) && !relation.blank?
+          errors.add(association.name, :destroy_restrict_with_error_dependencies_exist)
+          throw(:abort, false)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/eager_loadable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "mongoid/association/referenced/eager"
+
+module Mongoid
+  module Association
+
+    # This module defines the eager loading behavior for criteria.
+    module EagerLoadable
+
+      def eager_loadable?
+        !criteria.inclusions.empty?
+      end
+
+      def eager_load(docs)
+        docs.tap do |d|
+          if eager_loadable?
+            preload(criteria.inclusions, d)
+          end
+        end
+      end
+
+      def preload(relations, docs)
+        relations.group_by(&:inverse_class_name)
+            .values
+            .each do |associations|
+          associations.group_by(&:relation)
+              .each do |relation, association|
+            relation.eager_loader(association, docs).run
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # Contains behavior for executing operations in batch on embedded
+      # documents.
+      module Batchable
+        include Positional
+
+        # Insert new documents as a batch push ($push with $each). This ensures that
+        # all callbacks are run at the appropriate time and only 1 request is
+        # made to the database.
+        #
+        # @example Execute the batch push.
+        #   batchable.batch_insert([ doc_one, doc_two ])
+        #
+        # @param [ Array<Document> ] docs The docs to add.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        def batch_insert(docs)
+          execute_batch_push(docs)
+        end
+
+        # Clear all of the docs out of the association in a single swipe.
+        #
+        # @example Clear all docs.
+        #   batchable.batch_clear(docs)
+        #
+        # @param [ Array<Document> ] docs The docs to clear.
+        #
+        # @return [ Array ] The empty array.
+        def batch_clear(docs)
+          pre_process_batch_remove(docs, :delete)
+          unless docs.empty?
+            collection.find(selector).update_one(
+              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
+            post_process_batch_remove(docs, :delete)
+          end
+          _unscoped.clear
+        end
+
+        # Batch remove the provided documents as a $pullAll.
+        #
+        # @example Batch remove the documents.
+        #   batchable.batch_remove([ doc_one, doc_two ])
+        #
+        # @param [ Array<Document> ] docs The docs to remove.
+        # @param [ Symbol ] method Delete or destroy.
+        def batch_remove(docs, method = :delete)
+          removals = pre_process_batch_remove(docs, method)
+          if !docs.empty?
+            collection.find(selector).update_one(
+                positionally(selector, "$pullAll" => { path => removals }),
+                session: _session
+            )
+            post_process_batch_remove(docs, method)
+          end
+          reindex
+        end
+
+        # Batch replace the provided documents as a $set.
+        #
+        # @example Batch replace the documents.
+        #   batchable.batch_replace([ doc_one, doc_two ])
+        #
+        # @param [ Array<Document> ] docs The docs to replace with.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        def batch_replace(docs)
+          if docs.blank?
+            if _assigning? && !empty?
+              _base.delayed_atomic_sets.delete(path)
+              clear_atomic_path_cache
+              _base.add_atomic_unset(first)
+              target_duplicate = _target.dup
+              pre_process_batch_remove(target_duplicate, :delete)
+              post_process_batch_remove(target_duplicate, :delete)
+            else
+              batch_remove(_target.dup)
+            end
+          elsif _target != docs
+            _base.delayed_atomic_sets.clear unless _assigning?
+            docs = normalize_docs(docs).compact
+            _target.clear and _unscoped.clear
+            _base.delayed_atomic_unsets.delete(path)
+            clear_atomic_path_cache
+            inserts = execute_batch_set(docs)
+            add_atomic_sets(inserts)
+          end
+        end
+
+        private
+
+        # Add the atomic sets to the base document.
+        #
+        # @api private
+        #
+        # @example Add the atomic sets.
+        #   batchable.add_atomic_sets([{ field: value }])
+        #
+        # @param [ Array<Hash> ] sets The atomic sets.
+        def add_atomic_sets(sets)
+          if _assigning?
+            _base.delayed_atomic_sets[path].try(:clear)
+            _base.collect_children.each do |child|
+              child.delayed_atomic_sets.clear
+            end
+            _base.delayed_atomic_sets[path] = sets
+          end
+        end
+
+        # Perform a batch persist of the provided documents with a $set.
+        #
+        # @api private
+        #
+        # @example Perform a batch $set.
+        #   batchable.execute_batch_set(docs)
+        #
+        # @param [ Array<Document> ] docs The docs to persist.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        def execute_batch_set(docs)
+          self.inserts_valid = true
+          inserts = pre_process_batch_insert(docs)
+          if insertable?
+            collection.find(selector).update_one(
+                positionally(selector, '$set' => { path => inserts }),
+                session: _session
+            )
+            post_process_batch_insert(docs)
+          end
+          inserts
+        end
+
+        # Perform a batch persist of the provided documents with $push and $each.
+        #
+        # @api private
+        #
+        # @example Perform a batch push.
+        #   batchable.execute_batch_push(docs)
+        #
+        # @param [ Array<Document> ] docs The docs to persist.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        def execute_batch_push(docs)
+          self.inserts_valid = true
+          pushes = pre_process_batch_insert(docs)
+          if insertable?
+            collection.find(selector).update_one(
+                positionally(selector, '$push' => { path => { '$each' => pushes } }),
+                session: _session
+            )
+            post_process_batch_insert(docs)
+          end
+          pushes
+        end
+
+        # Are we in a state to be able to batch insert?
+        #
+        # @api private
+        #
+        # @example Can inserts be performed?
+        #   batchable.insertable?
+        #
+        # @return [ true, false ] If inserts can be performed.
+        def insertable?
+          persistable? && !_assigning? && inserts_valid
+        end
+
+        # Are the inserts currently valid?
+        #
+        # @api private
+        #
+        # @example Are the inserts currently valid.
+        #   batchable.inserts_valid
+        #
+        # @return [ true, false ] If inserts are currently valid.
+        def inserts_valid
+          @inserts_valid
+        end
+
+        # Set the inserts valid flag.
+        #
+        # @api private
+        #
+        # @example Set the flag.
+        #   batchable.inserts_valid = true
+        #
+        # @param [ true, false ] value The flag.
+        #
+        # @return [ true, false ] The flag.
+        def inserts_valid=(value)
+          @inserts_valid = value
+        end
+
+        # Normalize the documents, in case they were provided as an array of
+        # hashes.
+        #
+        # @api private
+        #
+        # @example Normalize the docs.
+        #   batchable.normalize_docs(docs)
+        #
+        # @param [ Array<Hash, Document> ] docs The docs to normalize.
+        #
+        # @return [ Array<Document> ] The docs.
+        def normalize_docs(docs)
+          if docs.first.is_a?(::Hash)
+            docs.map do |doc|
+              attributes = { _association: _association, _parent: _base }
+              attributes.merge!(doc)
+              Factory.build(klass, attributes)
+            end
+          else
+            docs
+          end
+        end
+
+        # Get the atomic path.
+        #
+        # @api private
+        #
+        # @example Get the atomic path.
+        #   batchable.path
+        #
+        # @return [ String ] The atomic path.
+        def path
+          @path ||= if _unscoped.empty?
+            Mongoid::Atomic::Paths::Embedded::Many.position_without_document(_base, _association)
+          else
+            _unscoped.first.atomic_path
+          end
+        end
+
+        # Clear the cache for path and atomic_paths. This method is used when
+        # the path method is used, and the association has not been set on the
+        # document yet, which can cause path and atomic_paths to be calculated
+        # incorrectly later.
+        #
+        # @api private
+        def clear_atomic_path_cache
+          self.path = nil
+          _base.instance_variable_set("@atomic_paths", nil)
+        end
+
+        # Set the atomic path.
+        #
+        # @api private
+        #
+        # @example Set the atomic path.
+        #   batchable.path = "addresses"
+        #
+        # @param [ String ] value The path.
+        #
+        # @return [ String ] The path.
+        def path=(value)
+          @path = value
+        end
+
+        # Get the selector for executing atomic operations on the collection.
+        #
+        # @api private
+        #
+        # @example Get the selector.
+        #   batchable.selector
+        #
+        # @return [ Hash ] The atomic selector.
+        def selector
+          @selector ||= _base.atomic_selector
+        end
+
+        # Pre processes the batch insert for the provided documents.
+        #
+        # @api private
+        #
+        # @example Pre process the documents.
+        #   batchable.pre_process_batch_insert(docs)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        #
+        # @return [ Array<Hash> ] The documents as an array of hashes.
+        def pre_process_batch_insert(docs)
+          docs.map do |doc|
+            next unless doc
+            append(doc)
+            if persistable? && !_assigning?
+              self.path = doc.atomic_path unless path
+              if doc.valid?(:create)
+                doc.run_before_callbacks(:save, :create)
+              else
+                self.inserts_valid = false
+              end
+            end
+            doc.send(:as_attributes)
+          end
+        end
+
+        # Pre process the batch removal.
+        #
+        # @api private
+        #
+        # @example Pre process the documents.
+        #   batchable.pre_process_batch_remove(docs, :delete)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        # @param [ Symbol ] method Delete or destroy.
+        #
+        # @return [ Array<Hash> ] The documents as hashes.
+        def pre_process_batch_remove(docs, method)
+          docs.map do |doc|
+            self.path = doc.atomic_path unless path
+            execute_callback :before_remove, doc
+            unless _assigning?
+              doc.apply_destroy_dependencies!
+              doc.run_before_callbacks(:destroy) if method == :destroy
+            end
+            _target.delete_one(doc)
+            _unscoped.delete_one(doc)
+            unbind_one(doc)
+            execute_callback :after_remove, doc
+            doc.send(:as_attributes)
+          end
+        end
+
+        # Post process the documents after batch insert.
+        #
+        # @api private
+        #
+        # @example Post process the documents.
+        #   batchable.post_process_batch_insert(docs)
+        #
+        # @param [ Array<Documents> ] docs The inserted docs.
+        #
+        # @return [ Enumerable ] The document enum.
+        def post_process_batch_insert(docs)
+          docs.each do |doc|
+            doc.new_record = false
+            doc.run_after_callbacks(:create, :save)
+            doc.post_persist
+          end
+        end
+
+        # Post process the batch removal.
+        #
+        # @api private
+        #
+        # @example Post process the documents.
+        #   batchable.post_process_batch_remove(docs, :delete)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        # @param [ Symbol ] method Delete or destroy.
+        #
+        # @return [ Array<Document> ] The documents.
+        def post_process_batch_remove(docs, method)
+          docs.each do |doc|
+            doc.run_after_callbacks(:destroy) if method == :destroy
+            doc.freeze
+            doc.destroyed = true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # This module provides convenience macros for using cyclic embedded
+      # associations.
+      module Cyclic
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :cyclic
+        end
+
+        module ClassMethods
+
+          # Create a cyclic embedded association that creates a tree hierarchy for
+          # the document and many embedded child documents.
+          #
+          # @example Set up a recursive embeds many.
+          #
+          #   class Role
+          #     include Mongoid::Document
+          #     recursively_embeds_many
+          #   end
+          #
+          # @example The previous example is a shortcut for this.
+          #
+          #   class Role
+          #     include Mongoid::Document
+          #     embeds_many :child_roles, :class_name => "Role", :cyclic => true
+          #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+          #   end
+          #
+          # This provides the default nomenclature for accessing a parent document
+          # or its children.
+          def recursively_embeds_many(options = {})
+            embeds_many(
+                cyclic_child_name,
+                options.merge(class_name: self.name, cyclic: true)
+            )
+            embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
+          end
+
+          # Create a cyclic embedded association that creates a single self
+          # referencing relationship for a parent and a single child.
+          #
+          # @example Set up a recursive embeds one.
+          #
+          #   class Role
+          #     include Mongoid::Document
+          #     recursively_embeds_one
+          #   end
+          #
+          # @example The previous example is a shortcut for this.
+          #
+          #   class Role
+          #     include Mongoid::Document
+          #     embeds_one :child_role, :class_name => "Role", :cyclic => true
+          #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+          #   end
+          #
+          # This provides the default nomenclature for accessing a parent document
+          # or its children.
+          def recursively_embeds_one(options = {})
+            embeds_one(
+                cyclic_child_name(false),
+                options.merge(class_name: self.name, cyclic: true)
+            )
+            embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
+          end
+
+          private
+
+          # Determines the parent name given the class.
+          #
+          # @example Determine the parent name.
+          #   Role.cyclic_parent_name
+          #
+          # @return [ String ] "parent_" plus the class name underscored.
+          def cyclic_parent_name
+            ("parent_#{self.name.demodulize.underscore.singularize}").to_sym
+          end
+
+          # Determines the child name given the class.
+          #
+          # @example Determine the child name.
+          #   Role.cyclic_child_name
+          #
+          # @param [ true, false ] many Is the a many association?
+          #
+          # @return [ String ] "child_" plus the class name underscored in
+          #   singular or plural form.
+          def cyclic_child_name(many = true)
+            ("child_#{self.name.demodulize.underscore.send(many ? :pluralize : :singularize)}").to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Embedded
+      class EmbeddedIn
+
+        # The Binding object for embedded_in associations.
+        class Binding
+          include Bindable
+
+          # Binds the base object to the inverse of the association. This is so we
+          # are referenced to the actual objects themselves on both sides.
+          #
+          # This case sets the association metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind the documents.
+          #   name.person.bind(:continue => true)
+          #   name.person = Person.new
+          def bind_one
+            _base._association = _association.inverse_association(_target) unless _base._association
+            _base.parentize(_target)
+            binding do
+              if _base.embedded_many?
+                _target.do_or_do_not(_association.inverse(_target)).push(_base)
+              else
+                _target.do_or_do_not(_association.inverse_setter(_target), _base)
+              end
+            end
+          end
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   name.person.unbind(:continue => true)
+          #   name.person = nil
+          def unbind_one
+            binding do
+              if _base.embedded_many?
+                _target.do_or_do_not(_association.inverse(_target)).delete(_base)
+              else
+                _target.do_or_do_not(_association.inverse_setter(_target), nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end