mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/relations/proxy.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # This class is the superclass for all relation proxy objects, and contains
     # common behaviour for all of them.
@@ -18,9 +18,9 @@ module Mongoid # :nodoc:
       attr_accessor :base, :loaded, :metadata, :target
 
       # Backwards compatibility with Mongoid beta releases.
-      delegate :klass, :to => :metadata
-      delegate :bind_one, :unbind_one, :to => :binding
-      delegate :collection_name, :to => :base
+      delegate :klass, :foreign_key, :inverse_foreign_key, to: :metadata
+      delegate :bind_one, :unbind_one, to: :binding
+      delegate :collection_name, to: :base
 
       # Convenience for setting the target and the metadata properties since
       # all proxies will need to do this.
@@ -52,6 +52,35 @@ module Mongoid # :nodoc:
         target
       end
 
+      # Tell the next persistance operation to store in a specific collection,
+      # database or session.
+      #
+      # @example Save the current document to a different collection.
+      #   model.with(collection: "secondary").save
+      #
+      # @example Save the current document to a different database.
+      #   model.with(database: "secondary").save
+      #
+      # @example Save the current document to a different session.
+      #   model.with(session: "replica_set").save
+      #
+      # @example Save with a combination of options.
+      #   model.with(session: "sharded", database: "secondary").save
+      #
+      # @param [ Hash ] options The storage options.
+      #
+      # @option options [ String, Symbol ] :collection The collection name.
+      # @option options [ String, Symbol ] :database The database name.
+      # @option options [ String, Symbol ] :session The session name.
+      #
+      # @return [ Document ] The current document.
+      #
+      # @since 3.0.0
+      def with(options)
+        Threaded.set_persistence_options(klass, options)
+        self
+      end
+
       protected
 
       # Get the collection from the root of the hierarchy.
@@ -67,22 +96,6 @@ module Mongoid # :nodoc:
         root.collection unless root.embedded?
       end
 
-      # Return a new document for the type of class we want to instantiate.
-      # If the type is provided use that, otherwise the klass from the
-      # metadata.
-      #
-      # @example Get an instantiated document.
-      #   proxy.instantiated(Person)
-      #
-      # @param [ Class ] type The type of class to instantiate.
-      #
-      # @return [ Document ] The freshly created document.
-      #
-      # @since 2.0.0.rc.1
-      def instantiated(type = nil)
-        type ? type.new : metadata.klass.new
-      end
-
       # Takes the supplied document and sets the metadata on it.
       #
       # @example Set the metadata.
@@ -132,16 +145,32 @@ module Mongoid # :nodoc:
         raise Errors::UnsavedDocument.new(base, doc)
       end
 
-      # Get the class of the root document in the hierarchy.
-      #
-      # @example Get the root's class.
-      #   proxy.root_class
-      #
-      # @return [ Class ] The root class.
-      #
-      # @since 2.1.8
-      def root_class
-        @root_class ||= base._root.class
+      class << self
+
+        # Get the criteria that is used to eager load a relation of this
+        # type.
+        #
+        # @example Get the eager load criteria.
+        #   Proxy.eager_load(metadata, criteria)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        # @param [ Array<Object> ] ids The ids of the base docs.
+        #
+        # @return [ Criteria ] The criteria to eager load the relation.
+        #
+        # @since 2.2.0
+        def eager_load_ids(metadata, ids)
+          cleared = false
+          klass, foreign_key = metadata.klass, metadata.foreign_key
+          klass.any_in(foreign_key => ids).each do |doc|
+            selector = { foreign_key => doc.send(foreign_key) }
+            unless cleared
+              IdentityMap.clear_many(klass, selector)
+              cleared = true
+            end
+            yield(doc, foreign_key => doc.send(foreign_key))
+          end
+        end
       end
     end
   end

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Referenced #:nodoc:
+module Mongoid
+  module Relations
+    module Referenced
 
       # This class handles all behaviour for relations that are either
       # one-to-many or one-to-one, where the foreign key is store on this side
@@ -25,6 +25,18 @@ module Mongoid # :nodoc:
           end
         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.
+        #
+        # @example Nullify the relation.
+        #   person.game.nullify
+        #
+        def nullify
+          unbind_one
+          target.save
+        end
+
         # Substitutes the supplied target documents for the existing document
         # in the relation.
         #
@@ -38,12 +50,11 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def substitute(replacement)
-          tap do |proxy|
-            proxy.unbind_one
-            return nil unless replacement
-            proxy.target = replacement
-            proxy.bind_one
-          end
+          unbind_one
+          return nil unless replacement
+          self.target = replacement
+          bind_one
+          self
         end
 
         private
@@ -107,7 +118,7 @@ module Mongoid # :nodoc:
           #
           # @since 2.1.0
           def criteria(metadata, object, type = nil)
-            type.where(:_id => object)
+            type.where(_id: object)
           end
 
           # Get the criteria that is used to eager load a relation of this
@@ -124,8 +135,8 @@ module Mongoid # :nodoc:
           # @since 2.2.0
           def eager_load(metadata, ids)
             raise Errors::EagerLoad.new(metadata.name) if metadata.polymorphic?
-            klass, foreign_key = metadata.klass, metadata.foreign_key
-            klass.any_in("_id" => ids).each do |doc|
+            klass, _ = metadata.klass, metadata.foreign_key
+            klass.any_in("_id" => ids.uniq).each do |doc|
               IdentityMap.set(doc)
             end
           end
@@ -143,6 +154,20 @@ module Mongoid # :nodoc:
             false
           end
 
+          # Get the foreign key for the provided name.
+          #
+          # @example Get the foreign key.
+          #   Referenced::In.foreign_key(:person)
+          #
+          # @param [ Symbol ] name The name.
+          #
+          # @return [ String ] The foreign key.
+          #
+          # @since 3.0.0
+          def foreign_key(name)
+            "#{name}#{foreign_key_suffix}"
+          end
+
           # Get the default value for the foreign key.
           #
           # @example Get the default.
@@ -173,9 +198,9 @@ module Mongoid # :nodoc:
           # @example Get the macro.
           #   Referenced::In.macro
           #
-          # @return [ Symbol ] :referenced_in
+          # @return [ Symbol ] :belongs_to
           def macro
-            :referenced_in
+            :belongs_to
           end
 
           # Return the nested builder that is responsible for generating the documents
@@ -240,7 +265,7 @@ module Mongoid # :nodoc:
           #
           # @since 2.1.0
           def valid_options
-            [ :autosave, :foreign_key, :index, :polymorphic, :touch ]
+            [ :autobuild, :autosave, :dependent, :foreign_key, :index, :polymorphic, :touch ]
           end
 
           # Get the default validation setting for the relation. Determines if

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

@@ -1,15 +1,14 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Relations #:nodoc:
-    module Referenced #:nodoc:
+module Mongoid
+  module Relations
+    module Referenced
 
       # This class defines the behaviour for all relations that are a
       # one-to-many between documents in different collections.
       class Many < Relations::Many
-        include Batch
 
-        delegate :count, :to => :criteria
-        delegate :first, :in_memory, :last, :reset, :uniq, :to => :target
+        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.
@@ -35,17 +34,13 @@ module Mongoid #:nodoc:
             append(doc)
             doc.save if persistable? && !_assigning? && !doc.validated?
           end
+          self
         end
         alias :push :<<
 
         # Appends an array of documents to the relation. Performs a batch
         # insert of the documents instead of persisting one at a time.
         #
-        # @note When performing batch inserts the *after* callbacks will get
-        #   executed before the documents have actually been persisted to the
-        #   database due to an issue with Active Support's callback system - we
-        #   cannot explicitly fire the after callbacks by themselves.
-        #
         # @example Concat with other documents.
         #   person.posts.concat([ post_one, post_two ])
         #
@@ -55,13 +50,14 @@ module Mongoid #:nodoc:
         #
         # @since 2.4.0
         def concat(documents)
-          batched do
-            documents.each do |doc|
-              next unless doc
-              append(doc)
-              doc.save if persistable?
-            end
+          inserts = []
+          documents.each do |doc|
+            next unless doc
+            append(doc)
+            save_or_delay(doc, inserts) if persistable?
           end
+          persist_delayed(inserts)
+          self
         end
 
         # Build a new document from the attributes and append it to this
@@ -87,66 +83,15 @@ module Mongoid #:nodoc:
             options, type = {}, options
           end
 
-          Factory.build(type || klass, attributes, options).tap do |doc|
-            append(doc)
-            doc.apply_proc_defaults
-            yield(doc) if block_given?
-            doc.run_callbacks(:build) { doc }
-          end
+          doc = Factory.build(type || klass, attributes, options)
+          append(doc)
+          doc.apply_post_processed_defaults
+          yield(doc) if block_given?
+          doc.run_callbacks(:build) { doc }
+          doc
         end
         alias :new :build
 
-        # Creates a new document on the references many relation. This will
-        # save the document if the parent has been persisted.
-        #
-        # @example Create and save the new document.
-        #   person.posts.create(:text => "Testing")
-        #
-        # @overload create(attributes = nil, options = {}, type = nil)
-        #   @param [ Hash ] attributes The attributes to create with.
-        #   @param [ Hash ] options The scoped assignment options.
-        #   @param [ Class ] type The optional type of document to create.
-        #
-        # @overload create(attributes = nil, type = nil)
-        #   @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, options = {}, type = nil, &block)
-          build(attributes, options, type, &block).tap do |doc|
-            base.persisted? ? doc.save : raise_unsaved(doc)
-          end
-        end
-
-        # Creates a new document on the references many relation. This will
-        # save the document if the parent has been persisted and will raise an
-        # error if validation fails.
-        #
-        # @example Create and save the new document.
-        #   person.posts.create!(:text => "Testing")
-        #
-        # @overload create!(attributes = nil, options = {}, type = nil)
-        #   @param [ Hash ] attributes The attributes to create with.
-        #   @param [ Hash ] options The scoped assignment options.
-        #   @param [ Class ] type The optional type of document to create.
-        #
-        # @overload create!(attributes = nil, type = nil)
-        #   @param [ Hash ] attributes The attributes to create with.
-        #   @param [ Class ] type The optional type of document to create.
-        #
-        # @raise [ Errors::Validations ] If validation failed.
-        #
-        # @return [ Document ] The newly created document.
-        #
-        # @since 2.0.0.beta.1
-        def create!(attributes = nil, options = {}, type = nil, &block)
-          build(attributes, options, 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.
@@ -175,7 +120,7 @@ module Mongoid #:nodoc:
         #   person.posts.delete_all
         #
         # @example Conditonally delete all documents in the relation.
-        #   person.posts.delete_all(:conditions => { :title => "Testing" })
+        #   person.posts.delete_all({ :title => "Testing" })
         #
         # @param [ Hash ] conditions Optional conditions to delete with.
         #
@@ -193,7 +138,7 @@ module Mongoid #:nodoc:
         #   person.posts.destroy_all
         #
         # @example Conditonally destroy all documents in the relation.
-        #   person.posts.destroy_all(:conditions => { :title => "Testing" })
+        #   person.posts.destroy_all({ :title => "Testing" })
         #
         # @param [ Hash ] conditions Optional conditions to destroy with.
         #
@@ -230,27 +175,13 @@ module Mongoid #:nodoc:
         # @example Find by multiple ids.
         #   person.posts.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
         #
-        # @example Conditionally find all matching documents.
-        #   person.posts.find(:all, :conditions => { :title => "Sir" })
-        #
-        # @example Conditionally find the first document.
-        #   person.posts.find(:first, :conditions => { :title => "Sir" })
-        #
-        # @example Conditionally find the last document.
-        #   person.posts.find(:last, :conditions => { :title => "Sir" })
-        #
-        # @note This will keep matching documents in memory for iteration
-        #   later.
-        #
-        # @param [ Moped::BSON::ObjectId, Array<Moped::BSON::ObjectId> ] arg The ids.
+        # @param [ BSON::ObjectId, Array<BSON::ObjectId> ] arg The ids.
         #
         # @return [ Document, Criteria ] The matching document(s).
         #
         # @since 2.0.0.beta.1
         def find(*args)
-          matching = criteria.find(*args)
-          Array(matching).each { |doc| target.push(doc) }
-          matching
+          criteria.find(*args)
         end
 
         # Instantiate a new references_many relation. Will set the foreign key
@@ -279,7 +210,7 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.0.rc.1
         def nullify
-          criteria.update(metadata.foreign_key => nil)
+          criteria.update(foreign_key => nil)
           target.clear do |doc|
             unbind_one(doc)
           end
@@ -321,19 +252,18 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.0.rc.1
         def substitute(replacement)
-          tap do |proxy|
-            if replacement
-              new_docs, docs = replacement.compact.uniq, []
-              new_ids = new_docs.map { |doc| doc.id }
-              remove_not_in(new_ids)
-              new_docs.each do |doc|
-                docs.push(doc) if doc.send(metadata.foreign_key) != base.id
-              end
-              proxy.concat(docs)
-            else
-              proxy.purge
+          if replacement
+            new_docs, docs = replacement.compact, []
+            new_ids = new_docs.map { |doc| doc.id }
+            remove_not_in(new_ids)
+            new_docs.each do |doc|
+              docs.push(doc) if doc.send(foreign_key) != base.id
             end
+            concat(docs)
+          else
+            purge
           end
+          self
         end
 
         # Get a criteria for the documents without the default scoping
@@ -347,7 +277,7 @@ module Mongoid #:nodoc:
         # @since 2.4.0
         def unscoped
           klass.unscoped.where(
-            metadata.foreign_key => Conversions.flag(base.id, metadata)
+            foreign_key => Conversions.flag(base.id, metadata)
           )
         end
 
@@ -404,7 +334,7 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.0.beta.1
         def criteria
-          Many.criteria(metadata, Conversions.flag(base.id, metadata))
+          Many.criteria(metadata, Conversions.flag(base.id, metadata), base.class)
         end
 
         # Perform the necessary cascade operations for documents that just got
@@ -450,6 +380,27 @@ module Mongoid #:nodoc:
           end
         end
 
+        # Persist all the delayed batch inserts.
+        #
+        # @api private
+        #
+        # @example Persist the delayed batch inserts.
+        #   relation.persist_delayed([ doc ])
+        #
+        # @param [ Array<Document> ] inserts The delayed inserts.
+        #
+        # @since 3.0.0
+        def persist_delayed(inserts)
+          if inserts.any?
+            collection.insert(inserts.map(&:as_document))
+            inserts.each do |doc|
+              doc.new_record = false
+              doc.run_after_callbacks(:create, :save)
+              doc.post_persist
+            end
+          end
+        end
+
         # Are we able to persist this relation?
         #
         # @example Can we persist the relation?
@@ -469,7 +420,7 @@ module Mongoid #:nodoc:
         #   person.posts.delete_all
         #
         # @example Conditonally delete all documents in the relation.
-        #   person.posts.delete_all(:conditions => { :title => "Testing" })
+        #   person.posts.delete_all({ :title => "Testing" })
         #
         # @param [ Hash ] conditions Optional conditions to delete with.
         # @param [ Symbol ] The deletion method to call.
@@ -478,21 +429,19 @@ module Mongoid #:nodoc:
         #
         # @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
+          selector = conditions || {}
+          removed = klass.send(method, selector.merge!(criteria.selector))
+          target.delete_if do |doc|
+            if doc.matches?(selector)
+              unbind_one(doc) and true
             end
           end
+          removed
         end
 
         # Remove all the documents in the proxy that do not have the provided
         # ids.
         #
-        # @todo: Durran: Refactor 3.0. Temp for bug fix in 2.4.
-        #
         # @example Remove all documents without the ids.
         #   proxy.remove_not_in([ id ])
         #
@@ -500,17 +449,16 @@ module Mongoid #:nodoc:
         #
         # @since 2.4.0
         def remove_not_in(ids)
-          removed = criteria.not_in(:_id => ids)
+          removed = criteria.not_in(_id: ids)
           if metadata.destructive?
             removed.delete_all
           else
-            removed.update(metadata.foreign_key => nil)
+            removed.update(foreign_key => nil)
           end
           in_memory.each do |doc|
             if !ids.include?(doc.id)
               unbind_one(doc)
-              added.try { |p| p.delete_one(doc) }
-              loaded.try { |p| p.delete_one(doc) }
+              target.delete(doc)
               if metadata.destructive?
                 doc.destroyed = true
               end
@@ -518,6 +466,27 @@ module Mongoid #:nodoc:
           end
         end
 
+        # Save a persisted document immediately or delay a new document for
+        # batch insert.
+        #
+        # @api private
+        #
+        # @example Save or delay the document.
+        #   relation.save_or_delay(doc, [])
+        #
+        # @param [ Document ] doc The document.
+        # @param [ Array<Document> ] inserts The inserts.
+        #
+        # @since 3.0.0
+        def save_or_delay(doc, inserts)
+          if doc.new_record? && doc.valid?(:create)
+            inserts.push(doc)
+            doc.run_before_callbacks(:save, :create)
+          else
+            doc.save
+          end
+        end
+
         class << self
 
           # Return the builder that is responsible for generating the documents
@@ -551,7 +520,18 @@ module Mongoid #:nodoc:
           #
           # @since 2.1.0
           def criteria(metadata, object, type = nil)
-            metadata.klass.where(metadata.foreign_key => object)
+            crit = metadata.klass.where(metadata.foreign_key => object)
+
+            if metadata.polymorphic?
+              crit = crit.where(metadata.type => type.name)
+            end
+
+            inverse_metadata = metadata.inverse_metadata(metadata.klass)
+            if inverse_metadata && inverse_metadata.inverse_of_field
+              crit = crit.any_in(inverse_metadata.inverse_of_field => [metadata.name, nil])
+            end
+
+            crit
           end
 
           # Eager load the relation based on the criteria.
@@ -566,16 +546,7 @@ module Mongoid #:nodoc:
           #
           # @since 2.2.0
           def eager_load(metadata, ids)
-            cleared = false
-            klass, foreign_key = metadata.klass, metadata.foreign_key
-            klass.any_in(foreign_key => ids).each do |doc|
-              base_id = doc.send(foreign_key)
-              unless cleared
-                IdentityMap.clear_many(klass, foreign_key => base_id)
-                cleared = true
-              end
-              IdentityMap.set_many(doc, foreign_key => base_id)
-            end
+            eager_load_ids(metadata, ids) { |doc, key| IdentityMap.set_many(doc, key) }
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -591,6 +562,20 @@ module Mongoid #:nodoc:
             false
           end
 
+          # Get the foreign key for the provided name.
+          #
+          # @example Get the foreign key.
+          #   Referenced::Many.foreign_key(:person)
+          #
+          # @param [ Symbol ] name The name.
+          #
+          # @return [ String ] The foreign key.
+          #
+          # @since 3.0.0
+          def foreign_key(name)
+            "#{name}#{foreign_key_suffix}"
+          end
+
           # Get the default value for the foreign key.
           #
           # @example Get the default.
@@ -621,9 +606,9 @@ module Mongoid #:nodoc:
           # @example Get the macro.
           #   Referenced::Many.macro
           #
-          # @return [ Symbol ] :references_many
+          # @return [ Symbol ] :has_many
           def macro
-            :references_many
+            :has_many
           end
 
           # Return the nested builder that is responsible for generating the documents