mongoid 6.4.2 → 7.0.3

data/lib/mongoid/{relations/constraint.rb → association/constrainable.rb}

@@ -1,26 +1,11 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # Used for converting foreign key values to the correct type based on the
     # types of ids that the document stores.
     #
-    # @note Durran: The name of this class is this way to match the metadata
-    #   getter, and foreign_key was already taken there.
-    class Constraint
-      attr_reader :metadata
-
-      # Create the new constraint with the metadata.
-      #
-      # @example Instantiate the constraint.
-      #   Constraint.new(metdata)
-      #
-      # @param [ Metadata ] metadata The metadata of the relation.
-      #
-      # @since 2.0.0.rc.7
-      def initialize(metadata)
-        @metadata = metadata
-      end
+    module Constrainable
 
       # Convert the supplied object to the appropriate type to set as the
       # foreign key for a relation.
@@ -33,10 +18,10 @@ module Mongoid
       # @return [ Object ] The object cast to the correct type.
       #
       # @since 2.0.0.rc.7
-      def convert(object)
-        return convert_polymorphic(object) if metadata.polymorphic?
-        klass, field = metadata.klass, metadata.klass.fields["_id"]
-        if klass.using_object_ids?
+      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) }
@@ -48,7 +33,11 @@ module Mongoid
       private
       
       def convert_polymorphic(object)
-        object.respond_to?(:id) ? object.id : object
+        if object.is_a?(Mongoid::Document)
+          object.id
+        else
+          BSON::ObjectId.mongoize(object)
+        end
       end
     end
   end

data/lib/mongoid/association/depending.rb

@@ -0,0 +1,137 @@
+module Mongoid
+  module Association
+
+    # This module defines the behaviour for setting up cascading deletes and
+    # nullifies for relations, 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,13 @@
 # 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 +23,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,6 +1,6 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
     module Embedded
 
       # Contains behaviour for executing operations in batch on embedded
@@ -38,8 +38,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 +59,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 +80,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 +110,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 +122,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 +228,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 +278,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 +327,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,109 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Embedded
+
+      # This module provides convenience macros for using cyclic embedded
+      # relations.
+      module Cyclic
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :cyclic
+        end
+
+        module ClassMethods
+
+          # Create a cyclic embedded relation 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 relation 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 relation?
+          #
+          # @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

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

@@ -0,0 +1,56 @@
+module Mongoid
+  module Association
+    module Embedded
+      class EmbeddedIn
+
+        # The Binding object for embedded_in associations.
+        #
+        # @since 7.0
+        class Binding
+          include Bindable
+
+          # Binds the base object to the inverse of the relation. 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
+          #
+          # @since 2.0.0.rc.1
+          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
+          #
+          # @since 2.0.0.rc.1
+          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

data/lib/mongoid/{relations/builders/embedded/in.rb → association/embedded/embedded_in/buildable.rb}

@@ -1,9 +1,13 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Builders
-      module Embedded
-        class In < Builder
+  module Association
+    module Embedded
+      class EmbeddedIn
+
+        # The Builder behavior for embedded_in associations.
+        #
+        # @since 7.0
+        module Buildable
+          include Threaded::Lifecycle
 
           # This builder doesn't actually build anything, just returns the
           # parent since it should already be instantiated.
@@ -11,10 +15,12 @@ module Mongoid
           # @example Build the document.
           #   Builder.new(meta, attrs).build
           #
+          # @param [ Object ] base The object.
+          # @param [ Object ] object The parent hash or document.
           # @param [ String ] type Not used in this context.
           #
           # @return [ Document ] A single document.
-          def build(type = nil)
+          def build(base, object, type = nil)
             return object unless object.is_a?(Hash)
             if _loading?
               Factory.from_db(klass, object)

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

@@ -0,0 +1,121 @@
+module Mongoid
+  module Association
+    module Embedded
+      class EmbeddedIn
+
+        class Proxy < Association::One
+
+          # Instantiate a new embedded_in relation.
+          #
+          # @example Create the new relation.
+          #   Association::Embedded::EmbeddedIn.new(person, address, association)
+          #
+          # @param [ Document ] base The document the relation hangs off of.
+          # @param [ Document ] target The target (parent) of the relation.
+          # @param [ Association ] association The association metadata.
+          #
+          # @return [ In ] The proxy.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              characterize_one(_target)
+              bind_one
+            end
+          end
+
+          # Substitutes the supplied target documents for the existing document
+          # in the relation.
+          #
+          # @example Substitute the new document.
+          #   person.name.substitute(new_name)
+          #
+          # @param [ Document ] replacement A document to replace the target.
+          #
+          # @return [ Document, nil ] The relation or nil.
+          #
+          # @since 2.0.0.rc.1
+          def substitute(replacement)
+            unbind_one
+            unless replacement
+              _base.delete if persistable?
+              return nil
+            end
+            _base.new_record = true
+            self._target = replacement
+            bind_one
+            self
+          end
+
+          private
+
+          # Instantiate the binding associated with this relation.
+          #
+          # @example Get the binding.
+          #   binding([ address ])
+          #
+          # @return [ Binding ] A binding object.
+          #
+          # @since 2.0.0.rc.1
+          def binding
+            Binding.new(_base, _target, _association)
+          end
+
+          # Characterize the document.
+          #
+          # @example Set the base association.
+          #   object.characterize_one(document)
+          #
+          # @param [ Document ] document The document to set the association metadata on.
+          #
+          # @since 2.1.0
+          def characterize_one(document)
+            unless _base._association
+              _base._association = _association.inverse_association(document)
+            end
+          end
+
+          # Are we able to persist this relation?
+          #
+          # @example Can we persist the relation?
+          #   relation.persistable?
+          #
+          # @return [ true, false ] If the relation is persistable.
+          #
+          # @since 2.1.0
+          def persistable?
+            _target.persisted? && !_binding? && !_building?
+          end
+
+          class << self
+
+            # Returns true if the relation is an embedded one. In this case
+            # always true.
+            #
+            # @example Is this relation embedded?
+            #   Association::Embedded::EmbeddedIn.embedded?
+            #
+            # @return [ true ] true.
+            #
+            # @since 2.0.0.rc.1
+            def embedded?
+              true
+            end
+
+            # Get the path calculator for the supplied document.
+            #
+            # @example Get the path calculator.
+            #   Proxy.path(document)
+            #
+            # @param [ Document ] document The document to calculate on.
+            #
+            # @return [ Root ] The root atomic path calculator.
+            #
+            # @since 2.1.0
+            def path(document)
+              Mongoid::Atomic::Paths::Root.new(document)
+            end
+          end
+        end
+      end
+    end
+  end
+end