mongoid 6.4.8 → 7.0.0.beta

data/lib/mongoid/association/embedded.rb

@@ -0,0 +1,4 @@
+require 'mongoid/association/embedded/cyclic'
+require 'mongoid/association/embedded/embedded_in'
+require 'mongoid/association/embedded/embeds_many'
+require 'mongoid/association/embedded/embeds_one'

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
@@ -8,7 +8,7 @@ module Mongoid
       module Batchable
         include Positional
 
-        # Insert new documents as a batch push ($push with $each). This ensures that
+        # Insert new documents as a batch push ($pushAll). This ensures that
         # all callbacks are run at the appropriate time and only 1 request is
         # made to the database.
         #
@@ -21,7 +21,7 @@ module Mongoid
         #
         # @since 3.0.0
         def batch_insert(docs)
-          execute_batch_push(docs)
+          execute_batch_insert(docs, "$pushAll")
         end
 
         # Clear all of the docs out of the relation in a single swipe.
@@ -38,8 +38,7 @@ 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 })
             )
             post_process_batch_remove(docs, :delete)
           end
@@ -59,8 +58,7 @@ 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 })
             )
             post_process_batch_remove(docs, method)
           end
@@ -80,18 +78,18 @@ 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
-            inserts = execute_batch_set(docs)
+            _target.clear and _unscoped.clear
+            inserts = execute_batch_insert(docs, "$set")
             add_atomic_sets(inserts)
           end
         end
@@ -110,64 +108,40 @@ 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
 
-        # Perform a batch persist of the provided documents with a $set.
+        # Perform a batch persist of the provided documents with the supplied
+        # operation.
         #
         # @api private
         #
-        #@example Perform a batch $set.
-        #   batchable.execute_batch_set(docs)
+        # @example Perform a batch operation.
+        #   batchable.execute_batch(docs, "$set")
         #
         # @param [ Array<Document> ] docs The docs to persist.
+        # @param [ String ] operation The atomic operation.
         #
         # @return [ Array<Hash> ] The inserts.
         #
-        # @since 7.0.0
-        def execute_batch_set(docs)
+        # @since 3.0.0
+        def execute_batch_insert(docs, operation)
           self.inserts_valid = true
           inserts = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$set' => { path => inserts }),
-                session: _session
+                positionally(selector, operation => { path => inserts })
             )
             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.
-        #
-        # @since 7.0.0
-        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
@@ -228,7 +202,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 +252,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 +301,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.rb

@@ -0,0 +1,154 @@
+require 'mongoid/association/embedded/embedded_in/binding'
+require 'mongoid/association/embedded/embedded_in/buildable'
+require 'mongoid/association/embedded/embedded_in/proxy'
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # The EmbeddedIn type association.
+      #
+      # @since 7.0
+      class EmbeddedIn
+        include Relatable
+        include Buildable
+
+        # The options available for this type of association, in addition to the
+        # common ones.
+        #
+        # @return [ Array<Symbol> ] The extra valid options.
+        #
+        # @since 7.0
+        ASSOCIATION_OPTIONS = [
+            :autobuild,
+            :cyclic,
+            :polymorphic,
+            :touch
+        ].freeze
+
+        # The complete list of valid options for this association, including
+        # the shared ones.
+        #
+        # @return [ Array<Symbol> ] The valid options.
+        #
+        # @since 7.0
+        VALID_OPTIONS = (ASSOCIATION_OPTIONS + SHARED_OPTIONS).freeze
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        #
+        # @since 7.0
+        def setup!
+          setup_instance_methods!
+          @owner_class.embedded = true
+          self
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 7.0
+        def embedded?; true; end
+
+        # The primary key
+        #
+        # @return [ nil ] Not relevant for this relation
+        def primary_key; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def stores_foreign_key?; false; end
+
+        # The default for validating the association object.
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def validation_default; false; end
+
+        # The key that is used to get the attributes for the associated object.
+        #
+        # @return [ String ] The name of the relation.
+        #
+        # @since 7.0
+        def key
+          @key ||= name.to_s
+        end
+
+        # Get the relation proxy class for this association type.
+        #
+        # @return [ Association::Embedded::EmbeddedIn::Proxy ] The proxy class.
+        #
+        # @since 7.0
+        def relation
+          Proxy
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true, false ] Whether this association is polymorphic.
+        #
+        # @since 7.0
+        def polymorphic?
+          !!@options[:polymorphic]
+        end
+
+        # The nested builder object.
+        #
+        # @param [ Hash ] attributes The attributes to use to build the association object.
+        # @param [ Hash ] options The options for the association.
+        #
+        # @return [ Association::Nested::One ] The Nested Builder object.
+        #
+        # @since 7.0
+        def nested_builder(attributes, options)
+          Nested::One.new(self, attributes, options)
+        end
+
+        private
+
+        def setup_instance_methods!
+          define_getter!
+          define_setter!
+          define_existence_check!
+          define_builder!
+          define_creator!
+          define_counter_cache_callbacks!
+          define_touchable!
+        end
+
+        def relation_complements
+          @relation_complements ||= [ Embedded::EmbedsMany,
+                                      Embedded::EmbedsOne ].freeze
+        end
+
+        def polymorphic_inverses(other = nil)
+          if other
+            matches = other.relations.values.select do |rel|
+              relation_complements.include?(rel.class) &&
+                  rel.as == name &&
+                  rel.relation_class_name == inverse_class_name
+            end
+            matches.collect { |m| m.name }
+          end
+        end
+
+        def determine_inverses(other)
+          matches = (other || relation_class).relations.values.select do |rel|
+            relation_complements.include?(rel.class) &&
+                rel.relation_class_name == inverse_class_name
+          end
+          if matches.size > 1
+            raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches)
+          end
+          matches.collect { |m| m.name } unless matches.blank?
+        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