mongoid 2.4.10 → 3.0.0.rc

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

@@ -1,12 +1,14 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Embedded #:nodoc:
+require "mongoid/relations/embedded/batchable"
+
+module Mongoid
+  module Relations
+    module Embedded
 
       # This class handles the behaviour for a document that embeds many other
       # documents within in it as an array.
       class Many < Relations::Many
-        include Atomic
+        include Batchable
 
         # Appends a document or array of documents to the relation. Will set
         # the parent and update the index in the process.
@@ -25,6 +27,7 @@ module Mongoid # :nodoc:
             append(doc)
             doc.save if persistable? && !_assigning?
           end
+          self
         end
         alias :push :<<
 
@@ -37,37 +40,27 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def as_document
-          [].tap do |attributes|
-            _unscoped.each do |doc|
-              attributes.push(doc.as_document)
-            end
+          attributes = []
+          _unscoped.each do |doc|
+            attributes.push(doc.as_document)
           end
+          attributes
         end
 
         # 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.addresses.concat([ address_one, address_two ])
         #
-        # @param [ Array<Document> ] documents The docs to add.
+        # @param [ Array<Document> ] docs The docs to add.
         #
         # @return [ Array<Document> ] The documents.
         #
         # @since 2.4.0
-        def concat(documents)
-          atomically(:$pushAll) do
-            documents.each do |doc|
-              next unless doc
-              append(doc)
-              doc.save if persistable?
-            end
-          end
+        def concat(docs)
+          batch_insert(docs)
+          self
         end
 
         # Builds a new document in the relation and appends it to the target.
@@ -87,17 +80,15 @@ module Mongoid # :nodoc:
         #
         # @return [ Document ] The new document.
         def build(attributes = {}, options = {}, type = nil)
-          if options.is_a? Class
+          if options.is_a?(Class)
             options, type = {}, options
           end
-
-          Factory.build(type || metadata.klass, attributes, options).tap do |doc|
-            doc.identify
-            append(doc)
-            doc.apply_proc_defaults
-            yield(doc) if block_given?
-            doc.run_callbacks(:build) { doc }
-          end
+          doc = Factory.build(type || metadata.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
 
@@ -109,12 +100,8 @@ module Mongoid # :nodoc:
         #
         # @return [ Many ] The empty relation.
         def clear
-          tap do |proxy|
-            atomically(:$unset) do
-              proxy.delete_all
-              _unscoped.clear
-            end
-          end
+          batch_clear(target.dup)
+          self
         end
 
         # Returns a count of the number of documents in the association that have
@@ -131,49 +118,6 @@ module Mongoid # :nodoc:
           target.select { |doc| doc.persisted? }.size
         end
 
-        # Create a new document in the relation. This is essentially the same
-        # as doing a #build then #save on the new document.
-        #
-        # @example Create a new document in the relation.
-        #   person.movies.create(:name => "Bozo")
-        #
-        # @overload create(attributes = {}, options = {}, type = nil)
-        #   @param [ Hash ] attributes The attributes to build the document with.
-        #   @param [ Hash ] options The scoped assignment options.
-        #   @param [ Class ] type Optional class to create the document with.
-        #
-        # @overload create(attributes = {}, type = nil)
-        #   @param [ Hash ] attributes The attributes to build the document with.
-        #   @param [ Class ] type Optional class to create the document with.
-        #
-        # @return [ Document ] The newly created document.
-        def create(attributes = {}, options = {}, type = nil, &block)
-          build(attributes, options, type, &block).tap { |doc| doc.save }
-        end
-
-        # Create a new document in the relation. This is essentially the same
-        # as doing a #build then #save on the new document. If validation
-        # failed on the document an error will get raised.
-        #
-        # @example Create the document.
-        #   person.addresses.create!(:street => "Unter der Linden")</tt>
-        #
-        # @overload create!(attributes = {}, options = {}, type = nil)
-        #   @param [ Hash ] attributes The attributes to build the document with.
-        #   @param [ Hash ] options The scoped assignment options.
-        #   @param [ Class ] type Optional class to create the document with.
-        #
-        # @overload create!(attributes = {}, type = nil)
-        #   @param [ Hash ] attributes The attributes to build the document with.
-        #   @param [ Class ] type Optional class to create the document with.
-        #
-        # @raise [ Errors::Validations ] If a validation error occured.
-        #
-        # @return [ Document ] The newly created document.
-        def create!(attributes = {}, options = {}, type = nil, &block)
-          build(attributes, options, type, &block).tap { |doc| doc.save! }
-        end
-
         # Delete the supplied document from the target. This method is proxied
         # in order to reindex the array after the operation occurs.
         #
@@ -186,22 +130,22 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def delete(document)
-          target.delete_one(document).tap do |doc|
-            _unscoped.delete_one(doc)
-            if doc && !_binding?
-              if _assigning?
-                if doc.paranoid?
-                  doc.destroy(:suppress => true)
-                else
-                  base.add_atomic_pull(doc)
-                end
+          doc = target.delete_one(document)
+          _unscoped.delete_one(doc)
+          if doc && !_binding?
+            if _assigning?
+              if doc.paranoid?
+                doc.destroy(suppress: true)
               else
-                doc.delete(:suppress => true)
+                base.add_atomic_pull(doc)
               end
-              unbind_one(doc)
+            else
+              doc.delete(suppress: true)
             end
-            reindex
+            unbind_one(doc)
           end
+          reindex
+          doc
         end
 
         # Delete all the documents in the association without running callbacks.
@@ -210,13 +154,13 @@ module Mongoid # :nodoc:
         #   person.addresses.delete_all
         #
         # @example Conditionally delete documents from the relation.
-        #   person.addresses.delete_all(:conditions => { :street => "Bond" })
+        #   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 = {})
-          atomically(:$pull) { remove_all(conditions, :delete) }
+          remove_all(conditions, :delete)
         end
 
         # Destroy all the documents in the association whilst running callbacks.
@@ -225,13 +169,13 @@ module Mongoid # :nodoc:
         #   person.addresses.destroy_all
         #
         # @example Conditionally destroy documents from the relation.
-        #   person.addresses.destroy_all(:conditions => { :street => "Bond" })
+        #   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 = {})
-          atomically(:$pull) { remove_all(conditions, :destroy) }
+          remove_all(conditions, :destroy)
         end
 
         # Finds a document in this association through several different
@@ -243,11 +187,6 @@ module Mongoid # :nodoc:
         # @example Find documents for multiple ids.
         #   person.addresses.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
         #
-        # @example Find documents based on conditions.
-        #   person.addresses.find(:all, :conditions => { :number => 10 })
-        #   person.addresses.find(:first, :conditions => { :number => 10 })
-        #   person.addresses.find(:last, :conditions => { :number => 10 })
-        #
         # @param [ Array<Object> ] args Various arguments.
         #
         # @return [ Array<Document>, Document ] A single or multiple documents.
@@ -288,54 +227,45 @@ module Mongoid # :nodoc:
           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> ] new_target The replacement array.
-        # @param [ true, false ] building Are we in build mode?
+        # @param [ Array<Document> ] docs The replacement docs.
         #
         # @return [ Many ] The proxied relation.
         #
         # @since 2.0.0.rc.1
-        def substitute(replacement)
-          tap do |proxy|
-            if replacement.blank?
-              if _assigning? && !proxy.empty?
-                base.atomic_unsets.push(_unscoped.first.atomic_path)
-              end
-              proxy.clear
-            else
-              atomically(:$set) do
-                base.delayed_atomic_sets.clear
-                if replacement.first.is_a?(Hash)
-                  replacement = replacement.map do |doc|
-                    attributes = { :metadata => metadata, :_parent => base }
-                    attributes.merge!(doc)
-                    Factory.build(klass, attributes)
-                  end
-                end
-                docs = replacement.compact
-                proxy.target = docs
-                self._unscoped = docs.dup
-                proxy.target.each_with_index do |doc, index|
-                  integrate(doc)
-                  doc._index = index
-                  doc.save if base.persisted? && !_assigning?
-                end
-                if _assigning?
-                  name = _unscoped.first.atomic_path
-                  base._children.each do |child|
-                    child.delayed_atomic_sets.clear
-                  end
-                  base.instance_variable_set(:@_children, nil)
-                  base.delayed_atomic_sets[name] = proxy.as_document
-                end
-              end
-            end
-          end
+        def substitute(docs)
+          batch_replace(docs)
+          self
         end
 
         # Return the relation with all previous scoping removed. This is the
@@ -348,9 +278,10 @@ module Mongoid # :nodoc:
         #
         # @since 2.4.0
         def unscoped
-          klass.criteria(true, false).tap do |criterion|
-            criterion.documents = _unscoped
-          end
+          criterion = klass.unscoped
+          criterion.embedded = true
+          criterion.documents = _unscoped
+          criterion
         end
 
         private
@@ -393,9 +324,10 @@ module Mongoid # :nodoc:
         #
         # @return [ Criteria ] A new criteria.
         def criteria
-          klass.criteria(true).tap do |criterion|
-            criterion.documents = target
-          end
+          criterion = klass.scoped
+          criterion.embedded = true
+          criterion.documents = target
+          criterion
         end
 
         # Deletes one document from the target and unscoped.
@@ -484,32 +416,27 @@ module Mongoid # :nodoc:
         # @since 2.4.0
         def scope(docs)
           return docs unless metadata.order || metadata.klass.default_scoping?
-          metadata.klass.criteria(true).order_by(metadata.order).tap do |crit|
-            crit.documents = docs
-          end.entries
+          crit = metadata.klass.order_by(metadata.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(:conditions => { :num => 1 }, true)
+        #   relation.remove_all({ :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 = :delete)
-          criteria = find(:all, conditions || {})
-          criteria.size.tap do
-            criteria.each do |doc|
-              target.delete_one(doc)
-              _unscoped.delete_one(doc)
-              doc.send(method, :suppress => true) unless _assigning?
-              unbind_one(doc)
-            end
-            reindex
-          end
+          criteria = where(conditions || {})
+          removed = criteria.size
+          batch_remove(criteria, method)
+          removed
         end
 
         # Get the internal unscoped documents.
@@ -571,6 +498,18 @@ module Mongoid # :nodoc:
             true
           end
 
+          # Returns the suffix of the foreign key field, either "_id" or "_ids".
+          #
+          # @example Get the suffix for the foreign key.
+          #   Referenced::Many.foreign_key_suffix
+          #
+          # @return [ nil ] nil.
+          #
+          # @since 3.0.0
+          def foreign_key_suffix
+            nil
+          end
+
           # Returns the macro for this relation. Used mostly as a helper in
           # reflection.
           #
@@ -647,7 +586,7 @@ module Mongoid # :nodoc:
           #
           # @since 2.1.0
           def valid_options
-            [ :as, :cascade_callbacks, :cyclic, :order, :versioned ]
+            [ :as, :cascade_callbacks, :cyclic, :order, :versioned, :store_as ]
           end
 
           # Get the default validation setting for the relation. Determines if

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Embedded #:nodoc:
+module Mongoid
+  module Relations
+    module Embedded
 
       # This class defines the behaviour needed for embedded one to one
       # relations.
@@ -35,17 +35,16 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def substitute(replacement)
-          tap do |proxy|
-            if _assigning?
-              base.atomic_unsets.push(proxy.atomic_path)
-            else
-              proxy.delete if persistable?
-            end
-            proxy.unbind_one
-            return nil unless replacement
-            proxy.target = replacement
-            proxy.bind_one
+          if _assigning?
+            base.atomic_unsets.push(atomic_path)
+          else
+            delete if persistable?
           end
+          unbind_one
+          return nil unless replacement
+          self.target = replacement
+          bind_one
+          self
         end
 
         private
@@ -108,6 +107,18 @@ module Mongoid # :nodoc:
             true
           end
 
+          # Returns the suffix of the foreign key field, either "_id" or "_ids".
+          #
+          # @example Get the suffix for the foreign key.
+          #   Referenced::Many.foreign_key_suffix
+          #
+          # @return [ nil ] nil.
+          #
+          # @since 3.0.0
+          def foreign_key_suffix
+            nil
+          end
+
           # Returns the macro for this relation. Used mostly as a helper in
           # reflection.
           #
@@ -184,7 +195,7 @@ module Mongoid # :nodoc:
           #
           # @since 2.1.0
           def valid_options
-            [ :as, :cascade_callbacks, :cyclic ]
+            [ :autobuild, :as, :cascade_callbacks, :cyclic, :store_as ]
           end
 
           # Get the default validation setting for the relation. Determines if