mongoid 2.0.2 → 2.1.0

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

@@ -5,46 +5,65 @@ module Mongoid # :nodoc:
 
       # This class defines the behaviour for all relations that are a
       # many-to-many between documents in different collections.
-      class ManyToMany < Referenced::Many
+      class ManyToMany < Many
 
         # 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
+        #   person.posts << post
         #
         # @example Push a document.
-        #   person.addresses.push(address)
+        #   person.posts.push(post)
         #
         # @example Concat with other documents.
-        #   person.addresses.concat([ address_one, address_two ])
+        #   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)
-          args.flatten.each do |doc|
-            return doc unless doc
-            append(doc, options)
-            base.add_to_set(metadata.foreign_key, doc.id)
-            doc.save if base.persisted? && !options[:binding]
+          batched do
+            [].tap do |ids|
+              args.flatten.each do |doc|
+                next unless doc
+                append(doc)
+                if persistable?
+                  ids.push(doc.id)
+                  doc.save
+                else
+                  base.send(metadata.foreign_key).push(doc.id)
+                end
+              end
+              if persistable?
+                base.push_all(metadata.foreign_key, ids)
+                base.synced[metadata.foreign_key] = false
+              end
+            end
           end
         end
         alias :concat :<<
         alias :push :<<
 
-        # Builds a new document in the relation and appends it to the target.
-        # Takes an optional type if you want to specify a subclass.
+        # Build a new document from the attributes and append it to this
+        # relation without saving.
         #
         # @example Build a new document on the relation.
-        #   person.people.build(:name => "Bozo")
+        #   person.posts.build(:title => "A new post")
         #
-        # @param [ Hash ] attributes The attributes to build the document with.
-        # @param [ Class ] type Optional class to build the document with.
+        # @param [ Hash ] attributes The attributes of the new document.
+        # @param [ Class ] type The optional subclass to build.
         #
         # @return [ Document ] The new document.
-        def build(attributes = {}, type = nil, &block)
-          super.tap do |doc|
+        #
+        # @since 2.0.0.beta.1
+        def build(attributes = {}, type = nil)
+          Factory.build(type || klass, attributes).tap do |doc|
             base.send(metadata.foreign_key).push(doc.id)
+            append(doc)
+            yield(doc) if block_given?
           end
         end
         alias :new :build
@@ -53,16 +72,19 @@ module Mongoid # :nodoc:
         # save the document if the parent has been persisted.
         #
         # @example Create and save the new document.
-        #   person.preferences.create(:text => "Testing")
+        #   person.posts.create(:text => "Testing")
         #
         # @param [ Hash ] attributes The attributes to create with.
         # @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.add_to_set(metadata.foreign_key, doc.id)
-            doc.save if base.persisted?
+          super.tap do |doc|
+            base.send(metadata.foreign_key).delete_one(doc.id)
+            base.push(metadata.foreign_key, doc.id)
+            base.synced[metadata.foreign_key] = false
           end
         end
 
@@ -71,7 +93,7 @@ module Mongoid # :nodoc:
         # error if validation fails.
         #
         # @example Create and save the new document.
-        #   person.preferences.create!(:text => "Testing")
+        #   person.posts.create!(:text => "Testing")
         #
         # @param [ Hash ] attributes The attributes to create with.
         # @param [ Class ] type The optional type of document to create.
@@ -79,72 +101,63 @@ module Mongoid # :nodoc:
         # @raise [ Errors::Validations ] If validation failed.
         #
         # @return [ Document ] The newly created document.
-        def create!(attributes = nil, type = nil, &block)
-          build(attributes, type, &block).tap do |doc|
-            base.add_to_set(metadata.foreign_key, doc.id)
-            doc.save! if base.persisted?
-          end
-        end
-
-        # Delete a single document from the relation.
-        #
-        # @example Delete a document.
-        #   person.preferences.delete(preference)
-        #
-        # @param [ Document ] document The document to delete.
         #
-        # @since 2.0.0.rc.1
-        def delete(document, options = {})
-          target.delete(document).tap do |doc|
-            binding.unbind_one(doc, default_options.merge!(options)) if doc
+        # @since 2.0.0.beta.1
+        def create!(attributes = nil, type = nil, &block)
+          super.tap do |doc|
+            base.send(metadata.foreign_key).delete_one(doc.id)
+            base.push(metadata.foreign_key, doc.id)
+            base.synced[metadata.foreign_key] = false
           end
         end
 
-        # Deletes all related documents from the database given the supplied
-        # conditions.
+        # 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 all documents in the relation.
-        #   person.preferences.delete_all
+        # @example Delete the document.
+        #   person.posts.delete(post)
         #
-        # @example Conditonally delete all documents in the relation.
-        #   person.preferences.delete_all(:conditions => { :title => "Testing" })
+        # @param [ Document ] document The document to remove.
         #
-        # @param [ Hash ] conditions Optional conditions to delete with.
+        # @return [ Document ] The matching document.
         #
-        # @return [ Integer ] The number of documents deleted.
-        def delete_all(conditions = nil)
-          remove_all(conditions, :delete_all)
-        end
-
-        # Destroys all related documents from the database given the supplied
-        # conditions.
-        #
-        # @example Destroy all documents in the relation.
-        #   person.preferences.destroy_all
-        #
-        # @example Conditonally destroy all documents in the relation.
-        #   person.preferences.destroy_all(:conditions => { :title => "Testing" })
-        #
-        # @param [ Hash ] conditions Optional conditions to destroy with.
-        #
-        # @return [ Integer ] The number of documents destroyd.
-        def destroy_all(conditions = nil)
-          remove_all(conditions, :destroy_all)
+        # @since 2.1.0
+        def delete(document)
+          super.tap do |doc|
+            if doc && persistable?
+              base.pull(metadata.foreign_key, doc.id)
+              base.synced[metadata.foreign_key] = false
+            end
+          end
         end
 
         # Instantiate a new references_many relation. Will set the foreign key
         # and the base on the inverse object.
         #
         # @example Create the new relation.
-        #   Referenced::ManyToMany.new(base, target, metadata)
+        #   Referenced::Many.new(base, target, metadata)
         #
         # @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.
+        #
+        # @since 2.0.0.beta.1
         def initialize(base, target, metadata)
-          init(base, target, metadata) do
-            unless base.frozen?
-              base.send(metadata.foreign_key_setter, target.map(&:id))
+          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)
+                if persistable?
+                  base.push(metadata.foreign_key, doc.id)
+                  base.synced[metadata.foreign_key] = false
+                  doc.save
+                else
+                  base.send(metadata.foreign_key).push(doc.id)
+                end
+              end
             end
           end
         end
@@ -158,79 +171,42 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def nullify
-          load! and target.each do |doc|
-            base.send(metadata.foreign_key).delete(doc.id)
-            dereference(doc)
+          # @todo: Durran: This is wrong.
+          criteria.update(metadata.inverse_foreign_key => [])
+          # We need to update the inverse as well.
+          target.clear do |doc|
+            unbind_one(doc)
           end
-          target.clear
         end
         alias :nullify_all :nullify
 
-        # Substitutes the supplied target documents for the existing documents
-        # in the relation. If the new target is nil, perform the necessary
-        # deletion.
-        #
-        # @example Replace the relation.
-        #   person.posts.substitute(new_name)
-        #
-        # @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?
-        #
-        # @return [ Many ] The relation.
-        #
-        # @since 2.0.0.rc.1
-        def substitute(new_target, options = {})
-          tap do |relation|
-            if new_target
-              binding.unbind(options)
-              relation.target = new_target.to_a
-              base.send(metadata.foreign_key_setter, new_target.map(&:id))
-              bind(options)
-            else
-              relation.target = unbind(options)
-            end
-          end
-        end
+        private
 
-        # 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
+        # Appends the document to the target array, updating the index on the
+        # document at the same time.
         #
-        # @param [ Hash ] options The options to bind with.
+        # @example Append the document to the relation.
+        #   relation.append(document)
         #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
+        # @param [ Document ] document The document to append to the target.
         #
         # @since 2.0.0.rc.1
-        def unbind(options = {})
-          target.each(&:delete) if base.persisted?
-          binding.unbind(options)
-          []
+        def append(document)
+          target.push(document)
+          characterize_one(document)
+          bind_one(document)
         end
 
-        private
-
         # Instantiate the binding associated with this relation.
         #
         # @example Get the binding.
         #   relation.binding([ address ])
         #
-        # @param [ Array<Document> ] new_target The new documents to bind with.
-        #
         # @return [ Binding ] The binding.
         #
         # @since 2.0.0.rc.1
-        def binding(new_target = nil)
-          Bindings::Referenced::ManyToMany.new(base, new_target || target, metadata)
+        def binding
+          Bindings::Referenced::ManyToMany.new(base, target, metadata)
         end
 
         # Returns the criteria object for the target class with its documents set
@@ -241,44 +217,7 @@ module Mongoid # :nodoc:
         #
         # @return [ Criteria ] A new criteria.
         def criteria
-          if metadata.inverse
-            metadata.klass.any_in(metadata.inverse_foreign_key => [ base.id ])
-          else
-            metadata.klass.where(:_id => { "$in" => base.send(metadata.foreign_key) })
-          end
-        end
-
-        # Dereferences the supplied document from the base of the relation.
-        #
-        # @example Dereference the document.
-        #   person.preferences.dereference(preference)
-        #
-        # @param [ Document ] document The document to dereference.
-        def dereference(document)
-          document.send(metadata.inverse_foreign_key).delete(base.id)
-          document.send(metadata.inverse(document)).target.delete(base)
-          document.save
-        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(:conditions => { :num => 1 }, true)
-        #
-        # @param [ Hash ] conditions Conditions to filter by.
-        # @param [ true, false ] destroy If true then destroy, else delete.
-        #
-        # @return [ Integer ] The number of documents removed.
-        def remove_all(conditions = {}, method = :destroy)
-          cond = conditions || {}
-          target.delete_if do |doc|
-            doc.matches?(cond[:conditions] || {})
-          end
-          ids = criteria.merge(cond).only(:_id).map(&:_id)
-          criteria.merge(cond).send(method).tap do
-            base.pull_all(metadata.foreign_key, ids)
-          end
+          ManyToMany.criteria(metadata, base.send(metadata.foreign_key))
         end
 
         class << self
@@ -296,8 +235,12 @@ module Mongoid # :nodoc:
           # @return [ Builder ] A new builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Referenced::ManyToMany.new(meta, object)
+          def builder(meta, object, loading = false)
+            Builders::Referenced::ManyToMany.new(meta, object, loading)
+          end
+
+          def criteria(metadata, object, type = nil)
+            metadata.klass.any_in(:_id => object)
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -374,6 +317,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.
           #
@@ -386,6 +343,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, :dependent, :foreign_key, :index, :order ]
+          end
         end
       end
     end

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

@@ -7,28 +7,6 @@ module Mongoid # :nodoc:
       # one-to-one between documents in different collections.
       class One < 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.
-        #   person.game.bind(:continue => false)
-        #
-        # @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)
-          target.save if base.persisted? && !options[:binding]
-        end
-
         # Instantiate a new references_one relation. Will set the foreign key
         # and the base on the inverse object.
         #
@@ -40,24 +18,13 @@ module Mongoid # :nodoc:
         # @param [ Metadata ] metadata The relation's metadata.
         def initialize(base, target, metadata)
           init(base, target, metadata) do
+            raise_mixed if klass.embedded?
             characterize_one(target)
+            bind_one
+            target.save if persistable?
           end
         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 [ One ] The relation.
-        #
-        # @since 2.0.0.rc.5
-        def load!(options = {})
-          raise_mixed if klass.embedded?
-          super(options)
-        end
-
         # Removes the association between the base document and the target
         # document by deleting the foreign key and the reference, orphaning
         # the target document in the process.
@@ -67,32 +34,29 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def nullify
-          target.send(metadata.foreign_key_setter, nil)
-          target.send(:remove_instance_variable, "@#{metadata.inverse(target)}")
-          base.send(:remove_instance_variable, "@#{metadata.name}")
+          unbind_one
           target.save
         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.
+        # Substitutes the supplied target document for the existing document
+        # in the relation. If the new target is nil, perform the necessary
+        # deletion.
         #
-        # @example Unbind the relation.
-        #   person.game.unbind(name, :continue => true)
+        # @example Replace the relation.
+        #   person.game.substitute(new_game)
         #
-        # @param [ Document ] old_target The previous target of the relation.
-        # @param [ Hash ] options The options to bind with.
+        # @param [ Array<Document> ] replacement The replacement target.
         #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
+        # @return [ One ] The relation.
         #
         # @since 2.0.0.rc.1
-        def unbind(old_target, options = {})
-          binding(old_target).unbind(options)
-          if base.persisted? && !old_target.destroyed? && !options[:binding]
-            old_target.delete
+        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
 
@@ -106,8 +70,20 @@ module Mongoid # :nodoc:
         # @param [ Document ] new_target The new target of the relation.
         #
         # @return [ Binding ] The binding object.
-        def binding(new_target = nil)
-          Bindings::Referenced::One.new(base, new_target || target, metadata)
+        def binding
+          Bindings::Referenced::One.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?
+          base.persisted? && !binding? && !building?
         end
 
         class << self
@@ -125,8 +101,24 @@ module Mongoid # :nodoc:
           # @return [ Builder ] A new builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Referenced::One.new(meta, object)
+          def builder(meta, object, loading = false)
+            Builders::Referenced::One.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
@@ -203,6 +195,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.
           #
@@ -215,6 +221,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 ]
+          end
         end
       end
     end