mongoid 6.4.4 → 7.1.7

data/lib/mongoid/association/builders.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+
+    # This module is responsible for defining the build and create methods used
+    # in one to one associations.
+    #
+    # @example Methods that get created.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #   end
+    #
+    #   # The following methods get created:
+    #   person.build_name({ :first_name => "Durran" })
+    #   person.create_name({ :first_name => "Durran" })
+    #
+    # @since 2.0.0.rc.1
+    module Builders
+      extend ActiveSupport::Concern
+
+      private
+
+      # Parse out the attributes and the options from the args passed to a
+      # build_ or create_ methods.
+      #
+      # @example Parse the args.
+      #   doc.parse_args(:name => "Joe")
+      #
+      # @param [ Array ] args The arguments.
+      #
+      # @return [ Array<Hash> ] The attributes and options.
+      #
+      # @since 2.3.4
+      def parse_args(*args)
+        [ args.first || {}, args.size > 1 ? args[1] : {} ]
+      end
+
+      # Defines a builder method. This is defined as #build_name.
+      #
+      # @example
+      #   Person.define_builder!(association)
+      #
+      # @param [ Association ] association The association metadata for the association.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      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)
+            _building do
+              child = send("#{association.name}=", document)
+              child.run_callbacks(:build)
+              child
+            end
+          end
+        end
+      end
+
+      # Defines a creator method. This is defined as #create_name.
+      # After the object is built it will immediately save.
+      #
+      # @example
+      #   Person.define_creator!(association)
+      #
+      # @param [ Association ] association The association metadata for the association.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      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)
+            doc = _assigning do
+              send("#{association.name}=", document)
+            end
+            doc.save
+            save if new_record? && association.stores_foreign_key?
+            doc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/constrainable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+
+    # Used for converting foreign key values to the correct type based on the
+    # types of ids that the document stores.
+    #
+    module Constrainable
+
+      # Convert the supplied object to the appropriate type to set as the
+      # foreign key for an association.
+      #
+      # @example Convert the object.
+      #   constraint.convert("12345")
+      #
+      # @param [ Object ] object The object to convert.
+      #
+      # @return [ Object ] The object cast to the correct type.
+      #
+      # @since 2.0.0.rc.7
+      def convert_to_foreign_key(object)
+        return convert_polymorphic(object) if polymorphic?
+        field = relation_class.fields["_id"]
+        if relation_class.using_object_ids?
+          BSON::ObjectId.mongoize(object)
+        elsif object.is_a?(::Array)
+          object.map!{ |obj| field.mongoize(obj) }
+        else
+          field.mongoize(object)
+        end
+      end
+
+      private
+
+      def convert_polymorphic(object)
+        if object.is_a?(Mongoid::Document)
+          object.id
+        else
+          BSON::ObjectId.mongoize(object)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/depending.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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.
+      #
+      # @since 7.0
+      STRATEGIES = [
+          :delete_all,
+          :destroy,
+          :nullify,
+          :restrict_with_exception,
+          :restrict_with_error
+      ]
+
+      # The error message when a strategy cannot delete objects because there are associated objects.
+      #
+      # @since 7.0
+      RESTRICT_ERROR_MSG = 'Cannot delete record because associated objects exist.'.freeze
+
+      # 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.
+      #
+      # @since 2.0.0.rc.1
+      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_delete_dependencies!
+      #
+      # @since 2.0.0.rc.1
+      def apply_delete_dependencies!
+        self.class._all_dependents.each do |association|
+          if association.try(:dependent)
+            send("_dependent_#{association.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, RESTRICT_ERROR_MSG)
+          throw(:abort, false)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations/eager.rb → association/eager_loadable.rb}

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
 # encoding: utf-8
-require "mongoid/relations/eager/base"
-require "mongoid/relations/eager/belongs_to"
-require "mongoid/relations/eager/has_one"
-require "mongoid/relations/eager/has_many"
-require "mongoid/relations/eager/has_and_belongs_to_many"
+
+require "mongoid/association/referenced/eager"
 
 module Mongoid
-  module Relations
-    module Eager
+  module Association
+
+    # This module defines the eager loading behavior for criteria.
+    #
+    # @since 7.0
+    module EagerLoadable
 
       def eager_loadable?
         !criteria.inclusions.empty?
@@ -23,11 +25,11 @@ module Mongoid
 
       def preload(relations, docs)
         relations.group_by(&:inverse_class_name)
-                 .values
-                 .each do |associations|
+            .values
+            .each do |associations|
           associations.group_by(&:relation)
-                      .each do |relation, association|
-            relation.eager_load_klass.new(association, docs).run
+              .each do |relation, association|
+            relation.eager_loader(association, docs).run
           end
         end
       end

data/lib/mongoid/{relations → association}/embedded/batchable.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
-  module Relations
+  module Association
     module Embedded
 
-      # Contains behaviour for executing operations in batch on embedded
+      # Contains behavior for executing operations in batch on embedded
       # documents.
       module Batchable
         include Positional
@@ -24,7 +26,7 @@ module Mongoid
           execute_batch_push(docs)
         end
 
-        # Clear all of the docs out of the relation in a single swipe.
+        # Clear all of the docs out of the association in a single swipe.
         #
         # @example Clear all docs.
         #   batchable.batch_clear(docs)
@@ -38,8 +40,8 @@ module Mongoid
           pre_process_batch_remove(docs, :delete)
           unless docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$unset" => { path => true }),
-              session: _session
+                positionally(selector, "$unset" => { path => true }),
+                session: _session
             )
             post_process_batch_remove(docs, :delete)
           end
@@ -59,8 +61,8 @@ module Mongoid
           removals = pre_process_batch_remove(docs, method)
           if !docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$pullAll" => { path => removals }),
-              session: _session
+                positionally(selector, "$pullAll" => { path => removals }),
+                session: _session
             )
             post_process_batch_remove(docs, method)
           end
@@ -80,17 +82,17 @@ module Mongoid
         def batch_replace(docs)
           if docs.blank?
             if _assigning? && !empty?
-              base.add_atomic_unset(first)
-              target_duplicate = target.dup
+              _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)
+              batch_remove(_target.dup)
             end
-          elsif target != docs
-            base.delayed_atomic_sets.clear unless _assigning?
+          elsif _target != docs
+            _base.delayed_atomic_sets.clear unless _assigning?
             docs = normalize_docs(docs).compact
-            target.clear and _unscoped.clear
+            _target.clear and _unscoped.clear
             inserts = execute_batch_set(docs)
             add_atomic_sets(inserts)
           end
@@ -110,11 +112,11 @@ module Mongoid
         # @since 3.0.0
         def add_atomic_sets(sets)
           if _assigning?
-            base.delayed_atomic_sets[path].try(:clear)
-            base.collect_children.each do |child|
+            _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
+            _base.delayed_atomic_sets[path] = sets
           end
         end
 
@@ -122,7 +124,7 @@ module Mongoid
         #
         # @api private
         #
-        #@example Perform a batch $set.
+        # @example Perform a batch $set.
         #   batchable.execute_batch_set(docs)
         #
         # @param [ Array<Document> ] docs The docs to persist.
@@ -228,7 +230,7 @@ module Mongoid
         def normalize_docs(docs)
           if docs.first.is_a?(::Hash)
             docs.map do |doc|
-              attributes = { __metadata: __metadata, _parent: base }
+              attributes = { _association: _association, _parent: _base }
               attributes.merge!(doc)
               Factory.build(klass, attributes)
             end
@@ -278,7 +280,7 @@ module Mongoid
         #
         # @since 3.0.0
         def selector
-          @selector ||= base.atomic_selector
+          @selector ||= _base.atomic_selector
         end
 
         # Pre processes the batch insert for the provided documents.
@@ -327,10 +329,10 @@ module Mongoid
             self.path = doc.atomic_path unless path
             execute_callback :before_remove, doc
             unless _assigning?
-              doc.cascade!
+              doc.apply_delete_dependencies!
               doc.run_before_callbacks(:destroy) if method == :destroy
             end
-            target.delete_one(doc)
+            _target.delete_one(doc)
             _unscoped.delete_one(doc)
             unbind_one(doc)
             execute_callback :after_remove, doc

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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 shorcut 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.
+          #
+          # @since 2.0.0.rc.1
+          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 shorcut 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.
+          #
+          # @since 2.0.0.rc.1
+          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.
+          #
+          # @since 2.0.0.rc.1
+          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.
+          #
+          # @since 2.0.0.rc.1
+          def cyclic_child_name(many = true)
+            ("child_#{self.name.demodulize.underscore.send(many ? :pluralize : :singularize)}").to_sym
+          end
+        end
+      end
+    end
+  end
+end