mongoid 2.0.2 → 2.1.0

data/lib/mongoid/relations/one.rb

@@ -6,41 +6,16 @@ module Mongoid # :nodoc:
     # behaviour or those proxies.
     class One < Proxy
 
-      # Will load the target into an array if the target had not already been
-      # loaded.
+      # Get all the documents in the relation that are loaded into memory.
       #
-      # @example Load the relation into memory.
-      #   relation.load!
+      # @example Get the in memory documents.
+      #   relation.in_memory
       #
-      # @return [ One ] The relation.
+      # @return [ Array<Document> ] The documents in memory.
       #
-      # @since 2.0.0.rc.5
-      def load!(options = {})
-        tap do |relation|
-          unless relation.loaded?
-            relation.bind(options)
-            relation.loaded = true
-          end
-        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 ] other A document to replace the target.
-      #
-      # @return [ Document, nil ] The relation or nil.
-      #
-      # @since 2.0.0.rc.1
-      def substitute(new_target, options = {})
-        old_target = target
-        tap do |relation|
-          relation.target = new_target
-          new_target ? bind(options) : (unbind(old_target, options) and return nil)
-        end
+      # @since 2.1.0
+      def in_memory
+        [ target ]
       end
     end
   end

data/lib/mongoid/relations/options.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module contains the validating logic for options passed to relation
+    # macros.
+    module Options
+      extend self
+
+      # These options are available to all relations.
+      COMMON = [
+        :class_name,
+        :extend,
+        :inverse_class_name,
+        :inverse_of,
+        :name,
+        :relation,
+        :validate
+      ]
+
+      # Determine if the provided options are valid for the relation.
+      #
+      # @example Check the options.
+      #   Options.validate!(:name => :comments)
+      #
+      # @param [ Hash ] options The options to check.
+      #
+      # @raise [ ArgumentError ] If the options are invalid.
+      #
+      # @return [ true, false ] If the options are valid.
+      #
+      # @since 2.1.0
+      def validate!(options)
+        valid_options = options[:relation].valid_options.concat(COMMON)
+        options.keys.each do |key|
+          if !valid_options.include?(key)
+            raise Errors::InvalidOptions.new(
+              options[:name],
+              key,
+              valid_options
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/proxy.rb

@@ -17,6 +17,8 @@ module Mongoid # :nodoc:
       # Backwards compatibility with Mongoid beta releases.
       delegate :klass, :to => :metadata
 
+      delegate :bind_one, :unbind_one, :to => :binding
+
       # Convenience for setting the target and the metadata properties since
       # all proxies will need to do this.
       #
@@ -28,14 +30,38 @@ module Mongoid # :nodoc:
       # @param [ Metadata ] metadata The relation's metadata.
       #
       # @since 2.0.0.rc.1
-      def init(base, target, metadata, &block)
+      def init(base, target, metadata)
         @base, @target, @metadata = base, target, metadata
-        block.call if block
-        extend Module.new(&metadata.extension) if metadata.extension?
+        yield(self) if block_given?
+        extend metadata.extension if metadata.extension?
       end
 
       protected
 
+      # Is the current thread in binding mode?
+      #
+      # @example Is the current thread in binding mode?
+      #   proxy.binding?
+      #
+      # @return [ true, false ] If the thread is binding.
+      #
+      # @since 2.1.0
+      def binding?
+        Threaded.binding?
+      end
+
+      # Is the current thread in building mode?
+      #
+      # @example Is the current thread in building mode?
+      #   proxy.building?
+      #
+      # @return [ true, false ] If the thread is building.
+      #
+      # @since 2.1.0
+      def building?
+        Threaded.building?
+      end
+
       # Get the collection from the root of the hierarchy.
       #
       # @example Get the collection.
@@ -65,31 +91,6 @@ module Mongoid # :nodoc:
         type ? type.new : metadata.klass.new
       end
 
-      # Determines if the target been loaded into memory or not.
-      #
-      # @example Is the proxy loaded?
-      #   proxy.loaded?
-      #
-      # @return [ true, false ] True if loaded, false if not.
-      #
-      # @since 2.0.0.rc.1
-      def loaded?
-        !!@loaded
-      end
-
-      # Takes the supplied documents and sets the metadata on them. Used when
-      # creating new documents and adding them to the relation.
-      #
-      # @example Set the metadata.
-      #   proxy.characterize(addresses)
-      #
-      # @param [ Array<Document> ] documents The documents to set metadata on.
-      #
-      # @since 2.0.0.rc.4
-      def characterize(documents)
-        documents.each { |doc| characterize_one(doc) }
-      end
-
       # Takes the supplied document and sets the metadata on it.
       #
       # @example Set the metadata.

data/lib/mongoid/relations/referenced/batch.rb

@@ -36,12 +36,11 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.2, batch-relational-insert
         def batched(&block)
-          inserter = Thread.current[:mongoid_batch_insert] ||= Insert.new
+          inserter = Threaded.insert ||= Insert.new
           count_executions(&block)
         ensure
           if @executions.zero?
-            Thread.current[:mongoid_batch_insert] = nil
-            raise_mixed if embedded?
+            Threaded.insert = nil
             inserter.execute(collection)
           end
         end

data/lib/mongoid/relations/referenced/in.rb

@@ -9,27 +9,6 @@ module Mongoid # :nodoc:
       # collection.
       class In < Relations::One
 
-        # Binds the base object to the inverse of the relation. This is so we
-        # are referenced to the actual objects themselves and dont hit the
-        # database twice when setting the relations up.
-        #
-        # This is called after first creating the relation, or if a new object
-        # is set on the relation.
-        #
-        # @example Bind the relation.
-        #   game.person.bind
-        #
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def bind(options = {})
-          binding.bind(options)
-        end
-
         # Instantiate a new referenced_in relation.
         #
         # @example Create the new relation.
@@ -42,6 +21,7 @@ module Mongoid # :nodoc:
         def initialize(base, target, metadata)
           init(base, target, metadata) do
             characterize_one(target)
+            bind_one
           end
         end
 
@@ -57,37 +37,16 @@ module Mongoid # :nodoc:
         # @return [ In, nil ] The relation or nil.
         #
         # @since 2.0.0.rc.1
-        def substitute(new_target, options = {})
-          old_target = target
-          tap do |relation|
-            relation.target = new_target
-            if new_target
-              bind(options)
-            else
-              unbind(old_target, options)
-              nil
-            end
+        def substitute(replacement)
+          tap do |proxy|
+            proxy.unbind_one
+            proxy.target.delete if persistable?
+            return nil unless replacement
+            proxy.target = replacement
+            proxy.bind_one
           end
         end
 
-        # Unbinds the base object to the inverse of the relation. This occurs
-        # when setting a side of the relation to nil.
-        #
-        # @example Unbind the relation.
-        #   game.person.unbind
-        #
-        # @param [ Document, Array<Document> ] old_target The previous target.
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def unbind(old_target, options = {})
-          binding(old_target).unbind(options)
-        end
-
         private
 
         # Instantiate the binding associated with this relation.
@@ -100,8 +59,20 @@ module Mongoid # :nodoc:
         # @return [ Binding ] The binding object.
         #
         # @since 2.0.0.rc.1
-        def binding(new_target = nil)
-          Bindings::Referenced::In.new(base, new_target || target, metadata)
+        def binding
+          Bindings::Referenced::In.new(base, target, metadata)
+        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
@@ -119,8 +90,24 @@ module Mongoid # :nodoc:
           # @return [ Builder ] A new builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Referenced::In.new(meta, object)
+          def builder(meta, object, loading = false)
+            Builders::Referenced::In.new(meta, object, loading)
+          end
+
+          # Get the standard criteria used for querying this relation.
+          #
+          # @example Get the criteria.
+          #   Proxy.criteria(meta, id, Model)
+          #
+          # @param [ Metadata ] metadata The metadata.
+          # @param [ Object ] object The value of the foreign key.
+          # @param [ Class ] type The optional type.
+          #
+          # @return [ Criteria ] The criteria.
+          #
+          # @since 2.1.0
+          def criteria(metadata, object, type = nil)
+            type.where(:_id => object)
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -197,6 +184,20 @@ module Mongoid # :nodoc:
             Builders::NestedAttributes::One.new(metadata, 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 [ Root ] The root atomic path calculator.
+          #
+          # @since 2.1.0
+          def path(document)
+            Mongoid::Atomic::Paths::Root.new(document)
+          end
+
           # Tells the caller if this relation is one that stores the foreign
           # key on its own objects.
           #
@@ -209,6 +210,18 @@ module Mongoid # :nodoc:
           def stores_foreign_key?
             true
           end
+
+          # Get the valid options allowed with this relation.
+          #
+          # @example Get the valid options.
+          #   Relation.valid_options
+          #
+          # @return [ Array<Symbol> ] The valid options.
+          #
+          # @since 2.1.0
+          def valid_options
+            [ :autosave, :foreign_key, :index, :polymorphic ]
+          end
         end
       end
     end

data/lib/mongoid/relations/referenced/many.rb

@@ -8,6 +8,9 @@ module Mongoid #:nodoc:
       class Many < Relations::Many
         include Batch
 
+        delegate :count, :to => :criteria
+        delegate :first, :in_memory, :last, :reset, :uniq, :to => :target
+
         # Appends a document or array of documents to the relation. Will set
         # the parent and update the index in the process.
         #
@@ -21,43 +24,41 @@ module Mongoid #:nodoc:
         #   person.posts.concat([ post_one, post_two ])
         #
         # @param [ Document, Array<Document> ] *args Any number of documents.
+        #
+        # @return [ Array<Document> ] The loaded docs.
+        #
+        # @since 2.0.0.beta.1
         def <<(*args)
-          options = default_options(args)
           batched do
             args.flatten.each do |doc|
-              return doc unless doc
-              append(doc, options)
-              doc.save if base.persisted? && !options[:binding]
+              next unless doc
+              append(doc)
+              doc.save if persistable?
             end
           end
         end
         alias :concat :<<
         alias :push :<<
 
-        # Binds the base object to the inverse of the relation. This is so we
-        # are referenced to the actual objects themselves and dont hit the
-        # database twice when setting the relations up.
-        #
-        # This is called after first creating the relation, or if a new object
-        # is set on the relation.
+        # Build a new document from the attributes and append it to this
+        # relation without saving.
         #
-        # @example Bind the relation.
-        #   person.posts.bind
+        # @example Build a new document on the relation.
+        #   person.posts.build(:title => "A new post")
         #
-        # @param [ Hash ] options The options to bind with.
+        # @param [ Hash ] attributes The attributes of the new document.
+        # @param [ Class ] type The optional subclass to build.
         #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
+        # @return [ Document ] The new document.
         #
-        # @since 2.0.0.rc.1
-        def bind(options = {})
-          binding.bind(options)
-          target.map(&:save) if base.persisted? && !options[:binding]
+        # @since 2.0.0.beta.1
+        def build(attributes = {}, type = nil)
+          Factory.build(type || klass, attributes).tap do |doc|
+            append(doc)
+            yield(doc) if block_given?
+          end
         end
-
-        alias :concat :<<
-        alias :push :<<
+        alias :new :build
 
         # Clear the relation. Will delete the documents from the db if they are
         # already persisted.
@@ -66,24 +67,14 @@ module Mongoid #:nodoc:
         #   person.posts.clear
         #
         # @return [ Many ] The relation emptied.
-        def clear(options = {})
-          load! and tap do |relation|
-            relation.unbind(default_options(options))
-            target.clear
-          end
-        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 in memory.
-        #
-        # @example Get the count of persisted documents.
-        #   person.posts.count
         #
-        # @return [ Integer ] The total number of persisted documents.
-        def count
-          criteria.count
+        # @since 2.0.0.beta.1
+        def clear
+          criteria.delete_all
+          target.clear do |doc|
+            unbind_one(doc)
+            doc.destroyed = true
+          end
         end
 
         # Creates a new document on the references many relation. This will
@@ -96,6 +87,8 @@ module Mongoid #:nodoc:
         # @param [ Class ] type The optional type of document to create.
         #
         # @return [ Document ] The newly created document.
+        #
+        # @since 2.0.0.beta.1
         def create(attributes = nil, type = nil, &block)
           build(attributes, type, &block).tap do |doc|
             base.persisted? ? doc.save : raise_unsaved(doc)
@@ -115,12 +108,35 @@ module Mongoid #:nodoc:
         # @raise [ Errors::Validations ] If validation failed.
         #
         # @return [ Document ] The newly created document.
+        #
+        # @since 2.0.0.beta.1
         def create!(attributes = nil, type = nil, &block)
           build(attributes, type, &block).tap do |doc|
             base.persisted? ? doc.save! : raise_unsaved(doc)
           end
         end
 
+        # Delete the document from the relation. This will set the foreign key
+        # on the document to nil. If the dependent options on the relation are
+        # :delete or :destroy the appropriate removal will occur.
+        #
+        # @example Delete the document.
+        #   person.posts.delete(post)
+        #
+        # @param [ Document ] document The document to remove.
+        #
+        # @return [ Document ] The matching document.
+        #
+        # @since 2.1.0
+        def delete(document)
+          target.delete(document) do |doc|
+            if doc
+              unbind_one(doc)
+              cascade!(doc)
+            end
+          end
+        end
+
         # Deletes all related documents from the database given the supplied
         # conditions.
         #
@@ -133,13 +149,10 @@ module Mongoid #:nodoc:
         # @param [ Hash ] conditions Optional conditions to delete with.
         #
         # @return [ Integer ] The number of documents deleted.
+        #
+        # @since 2.0.0.beta.1
         def delete_all(conditions = nil)
-          raise_mixed if klass.embedded?
-          selector = (conditions || {})[:conditions] || {}
-          target.delete_if { |doc| doc.matches?(selector) }
-          metadata.klass.delete_all(
-            :conditions => criteria.selector.merge(selector)
-          )
+          remove_all(conditions, :delete_all)
         end
 
         # Destroys all related documents from the database given the supplied
@@ -154,13 +167,27 @@ module Mongoid #:nodoc:
         # @param [ Hash ] conditions Optional conditions to destroy with.
         #
         # @return [ Integer ] The number of documents destroyd.
+        #
+        # @since 2.0.0.beta.1
         def destroy_all(conditions = nil)
-          raise_mixed if klass.embedded?
-          selector = (conditions || {})[:conditions] || {}
-          target.delete_if { |doc| doc.matches?(selector) }
-          metadata.klass.destroy_all(
-            :conditions => criteria.selector.merge(selector)
-          )
+          remove_all(conditions, :destroy_all)
+        end
+
+        # Iterate over each document in the relation and yield to the provided
+        # block.
+        #
+        # @note This will load the entire relation into memory.
+        #
+        # @example Iterate over the documents.
+        #   person.posts.each do |post|
+        #     post.save
+        #   end
+        #
+        # @return [ Array<Document> ] The loaded docs.
+        #
+        # @since 2.1.0
+        def each
+          target.each { |doc| yield(doc) if block_given? }
         end
 
         # Find the matchind document on the association, either based on id or
@@ -186,6 +213,8 @@ module Mongoid #:nodoc:
         # @param [ Hash ] options The options to search with.
         #
         # @return [ Document, Criteria ] The matching document(s).
+        #
+        # @since 2.0.0.beta.1
         def find(*args)
           criteria.find(*args)
         end
@@ -199,26 +228,17 @@ module Mongoid #:nodoc:
         # @param [ Document ] base The document this relation hangs off of.
         # @param [ Array<Document> ] target The target of the relation.
         # @param [ Metadata ] metadata The relation's metadata.
-        def initialize(base, target, metadata)
-          init(base, target, metadata)
-        end
-
-        # Will load the target into an array if the target had not already been
-        # loaded.
-        #
-        # @example Load the relation into memory.
-        #   relation.load!
         #
-        # @return [ Many ] The relation.
-        #
-        # @since 2.0.0.rc.5
-        def load!(options = {})
-          raise_mixed if klass.embedded?
-          tap do |relation|
-            unless relation.loaded?
-              relation.target = target.entries
-              relation.bind(options)
-              relation.loaded = true
+        # @since 2.0.0.beta.1
+        def initialize(base, target, metadata)
+          init(base, Targets::Enumerable.new(target), metadata) do |proxy|
+            raise_mixed if klass.embedded?
+            batched do
+              proxy.in_memory do |doc|
+                characterize_one(doc)
+                bind_one(doc)
+                doc.save if persistable?
+              end
             end
           end
         end
@@ -232,7 +252,10 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.0.rc.1
         def nullify
-          clear(:binding => true, :continue => true, :nullify => true)
+          criteria.update(metadata.foreign_key => nil)
+          target.clear do |doc|
+            unbind_one(doc)
+          end
         end
         alias :nullify_all :nullify
 
@@ -241,44 +264,18 @@ module Mongoid #:nodoc:
         # deletion.
         #
         # @example Replace the relation.
-        #   person.posts.substitute(new_name)
+        #   person.posts.substitute([ new_post ])
         #
-        # @param [ Array<Document> ] target The replacement target.
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
+        # @param [ Array<Document> ] replacement The replacement target.
         #
         # @return [ Many ] The relation.
         #
         # @since 2.0.0.rc.1
-        def substitute(target, options = {})
-          tap { target ? (@target = target.to_a; bind(options)) : (@target = unbind(options)) }
-        end
-
-        # Unbinds the base object to the inverse of the relation. This occurs
-        # when setting a side of the relation to nil.
-        #
-        # Will delete the object if necessary.
-        #
-        # @example Unbind the target.
-        #   person.posts.unbind
-        #
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def unbind(options = {})
-          binding.unbind(options)
-          unless base.new_record?
-            target.each(&:delete) unless options[:binding]
-            target.each(&:save) if options[:nullify]
+        def substitute(replacement)
+          tap do |proxy|
+            proxy.clear
+            proxy.push(replacement) if replacement
           end
-          []
         end
 
         private
@@ -292,11 +289,10 @@ module Mongoid #:nodoc:
         # @param [ Document ] document The document to append to the target.
         #
         # @since 2.0.0.rc.1
-        def append(document, options = {})
-          init_target if !initialized? && !loaded?
+        def append(document)
           target.push(document)
           characterize_one(document)
-          binding.bind_one(document, options)
+          bind_one(document)
         end
 
         # Instantiate the binding associated with this relation.
@@ -309,8 +305,8 @@ module Mongoid #:nodoc:
         # @return [ Binding ] The binding.
         #
         # @since 2.0.0.rc.1
-        def binding(new_target = nil)
-          Bindings::Referenced::Many.new(base, new_target || target, metadata)
+        def binding
+          Bindings::Referenced::Many.new(base, target, metadata)
         end
 
         # Get the collection of the relation in question.
@@ -320,9 +316,9 @@ module Mongoid #:nodoc:
         #
         # @return [ Collection ] The collection of the relation.
         #
-        # @since 2.0.2, batch-relational-insert
+        # @since 2.0.2
         def collection
-          metadata.klass.collection
+          klass.collection
         end
 
         # Get the value for the foreign key in convertable or unconvertable
@@ -341,7 +337,7 @@ module Mongoid #:nodoc:
           if inverse.using_object_ids? || base.id.is_a?(BSON::ObjectId)
             base.id
           else
-            Mongoid::Criterion::Unconvertable.new(base.id)
+            Criterion::Unconvertable.new(base.id)
           end
         end
 
@@ -352,38 +348,31 @@ module Mongoid #:nodoc:
         #   relation.criteria
         #
         # @return [ Criteria ] A new criteria.
-        def criteria
-          raise_mixed if klass.embedded?
-          metadata.klass.where(metadata.foreign_key => convertable)
-        end
-
-        # Tells if the target array been initialized.
         #
-        # @example Is the target initialized?
-        #   relation.initialized?
-        #
-        # @return [ true, false ] If the target is an array.
-        #
-        # @since 2.0.0
-        def initialized?
-          !!@initialized
+        # @since 2.0.0.beta.1
+        def criteria
+          Many.criteria(metadata, convertable)
         end
 
-        # Initializes the target of the proxy as an empty array instead of
-        # hitting the database.
+        # Perform the necessary cascade operations for documents that just got
+        # deleted or nullified.
         #
-        # @example Initialize the target.
-        #   relation.init_target
+        # @example Cascade the change.
+        #   relation.cascade!(document)
         #
-        # @raise [ Errors::MixedRelations ] If the class is embedded.
+        # @param [ Document ] document The document to cascade on.
         #
-        # @return [ true ] Always true.
+        # @return [ true, false ] If the metadata is destructive.
         #
-        # @since 2.0.0
-        def init_target
-          raise_mixed if klass.embedded?
-          @target = []
-          @initialized = true
+        # @since 2.1.0
+        def cascade!(document)
+          if persistable?
+            if metadata.destructive?
+              document.send(metadata.dependent)
+            else
+              document.save
+            end
+          end
         end
 
         # If the target array does not respond to the supplied method then try to
@@ -396,11 +385,53 @@ module Mongoid #:nodoc:
         # @param [ Proc ] block Optional block to pass.
         #
         # @return [ Criteria, Object ] A Criteria or return value from the target.
+        #
+        # @since 2.0.0.beta.1
         def method_missing(name, *args, &block)
-          load!(:binding => true) and return super if [].respond_to?(name)
-          klass = metadata.klass
-          klass.send(:with_scope, criteria) do
-            criteria.send(name, *args, &block)
+          if target.respond_to?(name)
+            target.send(name, *args, &block)
+          else
+            klass.send(:with_scope, criteria) do
+              criteria.send(name, *args, &block)
+            end
+          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
+
+        # Deletes all related documents from the database given the supplied
+        # conditions.
+        #
+        # @example Delete all documents in the relation.
+        #   person.posts.delete_all
+        #
+        # @example Conditonally delete all documents in the relation.
+        #   person.posts.delete_all(:conditions => { :title => "Testing" })
+        #
+        # @param [ Hash ] conditions Optional conditions to delete with.
+        # @param [ Symbol ] The deletion method to call.
+        #
+        # @return [ Integer ] The number of documents deleted.
+        #
+        # @since 2.1.0
+        def remove_all(conditions = nil, method = :delete_all)
+          selector = (conditions || {})[:conditions] || {}
+          klass.send(method, :conditions => selector.merge!(criteria.selector)).tap do
+            target.delete_if do |doc|
+              if doc.matches?(selector)
+                unbind_one(doc) and true
+              end
+            end
           end
         end
 
@@ -419,8 +450,24 @@ module Mongoid #:nodoc:
           # @return [ Builder ] A new builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Referenced::Many.new(meta, object || [])
+          def builder(meta, object, loading = false)
+            Builders::Referenced::Many.new(meta, object || [], loading)
+          end
+
+          # Get the standard criteria used for querying this relation.
+          #
+          # @example Get the criteria.
+          #   Proxy.criteria(meta, id, Model)
+          #
+          # @param [ Metadata ] metadata The metadata.
+          # @param [ Object ] object The value of the foreign key.
+          # @param [ Class ] type The optional type.
+          #
+          # @return [ Criteria ] The criteria.
+          #
+          # @since 2.1.0
+          def criteria(metadata, object, type = nil)
+            metadata.klass.where(metadata.foreign_key => object)
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -497,6 +544,20 @@ module Mongoid #:nodoc:
             Builders::NestedAttributes::Many.new(metadata, 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 [ Root ] The root atomic path calculator.
+          #
+          # @since 2.1.0
+          def path(document)
+            Mongoid::Atomic::Paths::Root.new(document)
+          end
+
           # Tells the caller if this relation is one that stores the foreign
           # key on its own objects.
           #
@@ -509,6 +570,18 @@ module Mongoid #:nodoc:
           def stores_foreign_key?
             false
           end
+
+          # Get the valid options allowed with this relation.
+          #
+          # @example Get the valid options.
+          #   Relation.valid_options
+          #
+          # @return [ Array<Symbol> ] The valid options.
+          #
+          # @since 2.1.0
+          def valid_options
+            [ :as, :autosave, :dependent, :foreign_key, :order ]
+          end
         end
       end
     end