mongoid 6.4.8 → 7.0.0.beta

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

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

@@ -0,0 +1,210 @@
+require 'mongoid/association/embedded/embeds_many/binding'
+require 'mongoid/association/embedded/embeds_many/buildable'
+require 'mongoid/association/embedded/embeds_many/proxy'
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # The EmbedsMany type association.
+      #
+      # @since 7.0
+      class EmbedsMany
+        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 = [
+            :as,
+            :cascade_callbacks,
+            :cyclic,
+            :order,
+            :store_as,
+            :before_add,
+            :after_add,
+            :before_remove,
+            :after_remove
+        ]
+
+        # 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_relations = @owner_class.embedded_relations.merge(name => self)
+          @owner_class.aliased_fields[name.to_s] = store_as if store_as
+          self
+        end
+
+        # The field key used to store the list of association objects.
+        #
+        # @return [ String ] The field name.
+        #
+        # @since 7.0
+        def store_as
+          @store_as ||= (@options[:store_as].try(:to_s) || name.to_s)
+        end
+
+        # The key that is used to get the attributes for the associated object.
+        #
+        # @return [ String ] The name of the field used to store the relation.
+        #
+        # @since 7.0
+        def key
+          store_as.to_s
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 7.0
+        def embedded?; true; end
+
+        # Get the default validation setting for the relation. Determines if
+        # by default a validates associated will occur.
+        #
+        # @example Get the validation default.
+        #   Proxy.validation_default
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 2.1.9
+        def validation_default; true; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def stores_foreign_key?; false; end
+
+        # The primary key
+        #
+        # @return [ nil ] Not relevant for this relation
+        def primary_key; end
+
+        # Get the relation proxy class for this association type.
+        #
+        # @return [ Association::Embedded::EmbedsMany::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?
+          @polymorphic ||= !!@options[:as]
+        end
+
+        # The field used to store the type of the related object.
+        #
+        # @note Only relevant if the association is polymorphic.
+        #
+        # @return [ String, nil ] The field for storing the associated object's type.
+        #
+        # @since 7.0
+        def type
+          @type ||= "#{as}_type" if 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::Many ] The Nested Builder object.
+        #
+        # @since 7.0
+        def nested_builder(attributes, options)
+          Nested::Many.new(self, attributes, options)
+        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 [ Mongoid::Atomic::Paths::Embedded::Many ]
+        #   The embedded many atomic path calculator.
+        #
+        # @since 2.1.0
+        def path(document)
+          Mongoid::Atomic::Paths::Embedded::Many.new(document)
+        end
+
+        # Get a criteria object for searching given a parent and children documents.
+        #
+        # @param [ Document ] base The base document.
+        # @param [ Document ] target The children documents.
+        #
+        # @since 7.0
+        def criteria(base, target)
+          criterion = klass.scoped
+          criterion.embedded = true
+          criterion.documents = target
+          criterion.parent_document = base
+          criterion.association = self
+          apply_ordering(criterion)
+        end
+
+        private
+
+        def apply_ordering(criteria)
+          order ? criteria.order_by(order) : criteria
+        end
+
+        def setup_instance_methods!
+          define_getter!
+          define_setter!
+          define_existence_check!
+          define_builder!
+          define_creator!
+          @owner_class.cyclic = true if cyclic?
+          @owner_class.validates_associated(name) if validate?
+        end
+
+        def relation_complements
+          @relation_complements ||= [ Embedded::EmbeddedIn ].freeze
+        end
+
+        def polymorphic_inverses(other = nil)
+          [ as ]
+        end
+
+        def determine_inverses(other)
+          matches = 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/{relations/bindings/embedded/many.rb → association/embedded/embeds_many/binding.rb}

@@ -1,11 +1,13 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Bindings
-      module Embedded
+  module Association
+    module Embedded
+      class EmbedsMany
 
-        # Binding class for embeds_many relations.
-        class Many < Binding
+        # Binding class for all embeds_many relations.
+        #
+        # @since 7.0
+        class Binding
+          include Bindable
 
           # Binds a single document with the inverse relation. Used
           # specifically when appending to the proxy.
@@ -17,9 +19,9 @@ module Mongoid
           #
           # @since 2.0.0.rc.1
           def bind_one(doc)
-            doc.parentize(base)
+            doc.parentize(_base)
             binding do
-              doc.do_or_do_not(metadata.inverse_setter(target), base)
+              doc.do_or_do_not(_association.inverse_setter(_target), _base)
             end
           end
 
@@ -33,7 +35,7 @@ module Mongoid
           # @since 2.0.0.rc.1
           def unbind_one(doc)
             binding do
-              doc.do_or_do_not(metadata.inverse_setter(target), nil)
+              doc.do_or_do_not(_association.inverse_setter(_target), nil)
             end
           end
         end

data/lib/mongoid/{relations/builders/embedded/many.rb → association/embedded/embeds_many/buildable.rb}

@@ -1,22 +1,28 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Builders
-      module Embedded
-        class Many < Builder
+  module Association
+    module Embedded
+      class EmbedsMany
+
+        # Builder class for embeds_many associations.
+        #
+        # @since 7.0
+        module Buildable
+          include Threaded::Lifecycle
 
           # Builds the document out of the attributes using the provided
-          # metadata on the relation. Instantiates through the factory in order
+          # association metadata. Instantiates through the factory in order
           # to make sure subclasses and allocation are used if fitting. This
           # case will return many documents.
           #
           # @example Build the documents.
           #   Builder.new(meta, attrs).build
           #
+          # @param [ Object ] base The base object.
+          # @param [ Object ] object The object to use to build the relation.
           # @param [ String ] type Not used in this context.
           #
           # @return [ Array<Document ] The documents.
-          def build(type = nil)
+          def build(base, object, type = nil)
             return [] if object.blank?
             return object if object.first.is_a?(Document)
             docs = []

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

@@ -0,0 +1,529 @@
+require 'mongoid/association/embedded/batchable'
+
+module Mongoid
+  module Association
+    module Embedded
+      class EmbedsMany
+
+        class Proxy < Association::Many
+          include Batchable
+
+          # Appends a document or array of documents to the relation. Will set
+          # the parent and update the index in the process.
+          #
+          # @example Append a document.
+          #   person.addresses << address
+          #
+          # @example Push a document.
+          #   person.addresses.push(address)
+          #
+          # @param [ Document, Array<Document> ] args Any number of documents.
+          def <<(*args)
+            docs = args.flatten
+            return concat(docs) if docs.size > 1
+            if doc = docs.first
+              append(doc)
+              doc.save if persistable? && !_assigning?
+            end
+            self
+          end
+
+          alias :push :<<
+
+          # Get this relation as as its representation in the database.
+          #
+          # @example Convert the relation to an attributes hash.
+          #   person.addresses.as_document
+          #
+          # @return [ Array<Hash> ] The relation as stored in the db.
+          #
+          # @since 2.0.0.rc.1
+          def as_document
+            as_attributes.collect { |attrs| BSON::Document.new(attrs) }
+          end
+
+          # Appends an array of documents to the relation. Performs a batch
+          # insert of the documents instead of persisting one at a time.
+          #
+          # @example Concat with other documents.
+          #   person.addresses.concat([ address_one, address_two ])
+          #
+          # @param [ Array<Document> ] docs The docs to add.
+          #
+          # @return [ Array<Document> ] The documents.
+          #
+          # @since 2.4.0
+          def concat(docs)
+            batch_insert(docs) unless docs.empty?
+            self
+          end
+
+          # Builds a new document in the relation and appends it to the target.
+          # Takes an optional type if you want to specify a subclass.
+          #
+          # @example Build a new document on the relation.
+          #   person.people.build(:name => "Bozo")
+          #
+          # @param [ Hash ] attributes The attributes to build the document with.
+          # @param [ Class ] type Optional class to build the document with.
+          #
+          # @return [ Document ] The new document.
+          def build(attributes = {}, type = nil)
+            doc = Factory.build(type || _association.klass, attributes)
+            append(doc)
+            doc.apply_post_processed_defaults
+            yield(doc) if block_given?
+            doc.run_callbacks(:build) { doc }
+            _base._reset_memoized_children!
+            doc
+          end
+
+          alias :new :build
+
+          # Clear the relation. Will delete the documents from the db if they are
+          # already persisted.
+          #
+          # @example Clear the relation.
+          #   person.addresses.clear
+          #
+          # @return [ self ] The empty relation.
+          def clear
+            batch_clear(_target.dup)
+            self
+          end
+
+          # Returns a count of the number of documents in the association that have
+          # actually been persisted to the database.
+          #
+          # Use #size if you want the total number of documents.
+          #
+          # @example Get the count of persisted documents.
+          #   person.addresses.count
+          #
+          # @return [ Integer ] The total number of persisted embedded docs, as
+          #   flagged by the #persisted? method.
+          def count
+            _target.select { |doc| doc.persisted? }.size
+          end
+
+          # Delete the supplied document from the target. This method is proxied
+          # in order to reindex the array after the operation occurs.
+          #
+          # @example Delete the document from the relation.
+          #   person.addresses.delete(address)
+          #
+          # @param [ Document ] document The document to be deleted.
+          #
+          # @return [ Document, nil ] The deleted document or nil if nothing deleted.
+          #
+          # @since 2.0.0.rc.1
+          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)
+              end
+            end
+            reindex
+            execute_callback :after_remove, document
+            doc
+          end
+
+          # Delete all the documents in the association without running callbacks.
+          #
+          # @example Delete all documents from the relation.
+          #   person.addresses.delete_all
+          #
+          # @example Conditionally delete documents from the relation.
+          #   person.addresses.delete_all({ :street => "Bond" })
+          #
+          # @param [ Hash ] conditions Conditions on which documents to delete.
+          #
+          # @return [ Integer ] The number of documents deleted.
+          def delete_all(conditions = {})
+            remove_all(conditions, :delete)
+          end
+
+          # Delete all the documents for which the provided block returns true.
+          #
+          # @example Delete the matching documents.
+          #   person.addresses.delete_if do |doc|
+          #     doc.state == "GA"
+          #   end
+          #
+          # @return [ Many, Enumerator ] The relation or an enumerator if no
+          #   block was provided.
+          #
+          # @since 3.1.0
+          def delete_if
+            if block_given?
+              dup_target = _target.dup
+              dup_target.each do |doc|
+                delete(doc) if yield(doc)
+              end
+              self
+            else
+              super
+            end
+          end
+
+          # Destroy all the documents in the association whilst running callbacks.
+          #
+          # @example Destroy all documents from the relation.
+          #   person.addresses.destroy_all
+          #
+          # @example Conditionally destroy documents from the relation.
+          #   person.addresses.destroy_all({ :street => "Bond" })
+          #
+          # @param [ Hash ] conditions Conditions on which documents to destroy.
+          #
+          # @return [ Integer ] The number of documents destroyed.
+          def destroy_all(conditions = {})
+            remove_all(conditions, :destroy)
+          end
+
+          # Determine if any documents in this relation exist in the database.
+          #
+          # @example Are there persisted documents?
+          #   person.posts.exists?
+          #
+          # @return [ true, false ] True is persisted documents exist, false if not.
+          def exists?
+            count > 0
+          end
+
+          # Finds a document in this association through several different
+          # methods.
+          #
+          # @example Find a document by its id.
+          #   person.addresses.find(BSON::ObjectId.new)
+          #
+          # @example Find documents for multiple ids.
+          #   person.addresses.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
+          #
+          # @param [ Array<Object> ] args Various arguments.
+          #
+          # @return [ Array<Document>, Document ] A single or multiple documents.
+          def find(*args)
+            criteria.find(*args)
+          end
+
+          # Instantiate a new embeds_many relation.
+          #
+          # @example Create the new relation.
+          #   Many.new(person, addresses, association)
+          #
+          # @param [ Document ] base The document this relation hangs off of.
+          # @param [ Array<Document> ] target The child documents of the relation.
+          # @param [ Association ] association The association metadata
+          #
+          # @return [ Many ] The proxy.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              _target.each_with_index do |doc, index|
+                integrate(doc)
+                doc._index = index
+              end
+              @_unscoped = _target.dup
+              @_target = scope(_target)
+            end
+          end
+
+          # Get all the documents in the relation that are loaded into memory.
+          #
+          # @example Get the in memory documents.
+          #   relation.in_memory
+          #
+          # @return [ Array<Document> ] The documents in memory.
+          #
+          # @since 2.1.0
+          def in_memory
+            _target
+          end
+
+          # Pop documents off the relation. This can be a single document or
+          # multiples, and will automatically persist the changes.
+          #
+          # @example Pop a single document.
+          #   relation.pop
+          #
+          # @example Pop multiple documents.
+          #   relation.pop(3)
+          #
+          # @param [ Integer ] count The number of documents to pop, or 1 if not
+          #   provided.
+          #
+          # @return [ Document, Array<Document> ] The popped document(s).
+          #
+          # @since 3.0.0
+          def pop(count = nil)
+            if count
+              if docs = _target[_target.size - count, _target.size]
+                docs.each { |doc| delete(doc) }
+              end
+            else
+              delete(_target[-1])
+            end
+          end
+
+          # Substitutes the supplied target documents for the existing documents
+          # in the relation.
+          #
+          # @example Substitute the relation's target.
+          #   person.addresses.substitute([ address ])
+          #
+          # @param [ Array<Document> ] docs The replacement docs.
+          #
+          # @return [ Many ] The proxied relation.
+          #
+          # @since 2.0.0.rc.1
+          def substitute(docs)
+            batch_replace(docs)
+            self
+          end
+
+          # Return the relation with all previous scoping removed. This is the
+          # exact representation of the docs in the database.
+          #
+          # @example Get the unscoped documents.
+          #   person.addresses.unscoped
+          #
+          # @return [ Criteria ] The unscoped relation.
+          #
+          # @since 2.4.0
+          def unscoped
+            criterion = klass.unscoped
+            criterion.embedded = true
+            criterion.documents = _unscoped.delete_if(&:marked_for_destruction?)
+            criterion
+          end
+
+          private
+
+          def object_already_related?(document)
+            _target.any? { |existing| existing.id && existing === document }
+          end
+
+          # Appends the document to the target array, updating the index on the
+          # document at the same time.
+          #
+          # @example Append to the document.
+          #   relation.append(document)
+          #
+          # @param [ Document ] document The document to append to the target.
+          #
+          # @since 2.0.0.rc.1
+          def append(document)
+            execute_callback :before_add, document
+            unless object_already_related?(document)
+              _target.push(*scope([document]))
+            end
+            _unscoped.push(document)
+            integrate(document)
+            document._index = _unscoped.size - 1
+            execute_callback :after_add, document
+          end
+
+          # Instantiate the binding associated with this relation.
+          #
+          # @example Create the binding.
+          #   relation.binding([ address ])
+          #
+          # @return [ Binding ] The many binding.
+          #
+          # @since 2.0.0.rc.1
+          def binding
+            Binding.new(_base, _target, _association)
+          end
+
+          # Returns the "#{criteria}"# object for the target class with its documents set
+          # to target.
+          #
+          # @example Get a criteria for the relation.
+          #   relation.criteria
+          #
+          # @return [ Criteria ] A new criteria.
+          def criteria
+            @criteria ||= _association.criteria(_base, _target)
+          end
+
+          # Deletes one document from the target and unscoped.
+          #
+          # @api private
+          #
+          # @example Delete one document.
+          #   relation.delete_one(doc)
+          #
+          # @param [ Document ] document The document to delete.
+          #
+          # @since 2.4.7
+          def delete_one(document)
+            _target.delete_one(document)
+            _unscoped.delete_one(document)
+            reindex
+          end
+
+          # Integrate the document into the relation. will set its metadata and
+          # attempt to bind the inverse.
+          #
+          # @example Integrate the document.
+          #   relation.integrate(document)
+          #
+          # @param [ Document ] document The document to integrate.
+          #
+          # @since 2.1.0
+          def integrate(document)
+            characterize_one(document)
+            bind_one(document)
+          end
+
+          # If the target array does not respond to the supplied method then try to
+          # find a named scope or criteria on the class and send the call there.
+          #
+          # If the method exists on the array, use the default proxy behavior.
+          #
+          # @param [ Symbol, String ] name The name of the method.
+          # @param [ Array ] args The method args
+          # @param [ Proc ] block Optional block to pass.
+          #
+          # @return [ Criteria, Object ] A Criteria or return value from the target.
+          def method_missing(name, *args, &block)
+            return super if _target.respond_to?(name)
+            klass.send(:with_scope, criteria) do
+              criteria.public_send(name, *args, &block)
+            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?
+            _base.persisted? && !_binding?
+          end
+
+          # Reindex all the target elements. This is useful when performing
+          # operations on the proxied target directly and the indices need to
+          # match that on the database side.
+          #
+          # @example Reindex the relation.
+          #   person.addresses.reindex
+          #
+          # @since 2.0.0.rc.1
+          def reindex
+            _unscoped.each_with_index do |doc, index|
+              doc._index = index
+            end
+          end
+
+          # Apply the association ordering or the default scoping to the provided
+          # documents.
+          #
+          # @example Apply scoping.
+          #   person.addresses.scope(target)
+          #
+          # @param [ Array<Document> ] docs The documents to scope.
+          #
+          # @return [ Array<Document> ] The scoped docs.
+          #
+          # @since 2.4.0
+          def scope(docs)
+            return docs unless _association.order || _association.klass.default_scoping?
+            crit = _association.klass.order_by(_association.order)
+            crit.embedded = true
+            crit.documents = docs
+            crit.entries
+          end
+
+          # Remove all documents from the relation, either with a delete or a
+          # destroy depending on what this was called through.
+          #
+          # @example Destroy documents from the relation.
+          #   relation.remove_all({ :num => 1 }, true)
+          #
+          # @param [ Hash ] conditions Conditions to filter by.
+          # @param [ true, false ] method :delete or :destroy.
+          #
+          # @return [ Integer ] The number of documents removed.
+          def remove_all(conditions = {}, method = :delete)
+            criteria = where(conditions || {})
+            removed = criteria.size
+            batch_remove(criteria, method)
+            removed
+          end
+
+          # Get the internal unscoped documents.
+          #
+          # @example Get the unscoped documents.
+          #   relation._unscoped
+          #
+          # @return [ Array<Document> ] The unscoped documents.
+          #
+          # @since 2.4.0
+          def _unscoped
+            @_unscoped ||= []
+          end
+
+          # Set the internal unscoped documents.
+          #
+          # @example Set the unscoped documents.
+          #   relation._unscoped = docs
+          #
+          # @param [ Array<Document> ] docs The documents.
+          #
+          # @return [ Array<Document ] The unscoped docs.
+          #
+          # @since 2.4.0
+          def _unscoped=(docs)
+            @_unscoped = docs
+          end
+
+          def as_attributes
+            attributes = []
+            _unscoped.each do |doc|
+              attributes.push(doc.as_document)
+            end
+            attributes
+          end
+
+          class << self
+
+            # Returns true if the relation is an embedded one. In this case
+            # always true.
+            #
+            # @example Is the relation embedded?
+            #   Association::Embedded::EmbedsMany.embedded?
+            #
+            # @return [ true ] true.
+            #
+            # @since 2.0.0.rc.1
+            def embedded?
+              true
+            end
+
+            # Returns the suffix of the foreign key field, either "_id" or "_ids".
+            #
+            # @example Get the suffix for the foreign key.
+            #   Association::Embedded::EmbedsMany.foreign_key_suffix
+            #
+            # @return [ nil ] nil.
+            #
+            # @since 3.0.0
+            def foreign_key_suffix
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end