mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/relations/cascading.rb

@@ -2,9 +2,10 @@
 require "mongoid/relations/cascading/delete"
 require "mongoid/relations/cascading/destroy"
 require "mongoid/relations/cascading/nullify"
+require "mongoid/relations/cascading/restrict"
 
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # This module defines the behaviour for setting up cascading deletes and
     # nullifies for relations, and how to delegate to the approriate strategy.
@@ -33,7 +34,7 @@ module Mongoid # :nodoc:
         end
       end
 
-      module ClassMethods #:nodoc:
+      module ClassMethods
 
         # Attempt to add the cascading information for the document to know how
         # to handle associated documents on a removal.
@@ -47,7 +48,8 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def cascade(metadata)
-          tap { self.cascades += [ metadata.name.to_s ] if metadata.dependent? }
+          cascades.push(metadata.name.to_s) if metadata.dependent?
+          self
         end
       end
     end

data/lib/mongoid/relations/cascading/delete.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Cascading #:nodoc:
+module Mongoid
+  module Relations
+    module Cascading
       class Delete
 
         attr_accessor :document, :relation, :metadata
@@ -32,9 +32,7 @@ module Mongoid # :nodoc:
         def cascade
           if relation
             if relation.cascades.empty?
-              safety = Threaded.safety_options
               relation.clear
-              Threaded.safety_options = safety
             else
               ::Array.wrap(relation).each { |doc| doc.delete }
             end

data/lib/mongoid/relations/cascading/destroy.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Cascading #:nodoc:
+module Mongoid
+  module Relations
+    module Cascading
       class Destroy
 
         attr_accessor :document, :relation, :metadata

data/lib/mongoid/relations/cascading/nullify.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Cascading #:nodoc:
+module Mongoid
+  module Relations
+    module Cascading
       class Nullify
 
         attr_accessor :document, :relation, :metadata

data/lib/mongoid/relations/cascading/restrict.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Cascading
+      class Restrict
+
+        attr_accessor :document, :relation, :metadata
+
+        # Initialize the new cascade strategy, which will set up the relation
+        # and the metadata.
+        #
+        # @example Instantiate the strategy
+        #   Strategy.new(document, metadata)
+        #
+        # @param [ Document ] document The document to cascade from.
+        # @param [ Metadata ] metadata The relation's metadata.
+        #
+        # @return [ Strategy ] The new strategy.
+        def initialize(document, metadata)
+          @document, @metadata = document, metadata
+          @relation = document.send(metadata.name)
+        end
+
+        # Execute the cascading deletion for the relation if it already exists.
+        # This should be optimized in the future potentially not to load all
+        # objects from the db.
+        #
+        # @example Perform the cascading delete.
+        #   strategy.cascade
+        def cascade
+          raise Errors::DeleteRestriction.new(document, metadata.name) unless relation.blank?
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/relations/constraint.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # Used for converting foreign key values to the correct type based on the
     # types of ids that the document stores.
@@ -35,7 +35,8 @@ module Mongoid # :nodoc:
       # @since 2.0.0.rc.7
       def convert(object)
         return object if metadata.polymorphic?
-        BSON::ObjectId.convert(metadata.klass, object)
+        klass = metadata.klass
+        klass.using_object_ids? ? BSON::ObjectId.mongoize(object) : object
       end
     end
   end

data/lib/mongoid/relations/conversions.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # Contains utility methods for object id conversion.
     module Conversions
@@ -23,11 +23,10 @@ module Mongoid #:nodoc:
         if inverse.using_object_ids? || object.is_a?(BSON::ObjectId)
           object
         else
-          object.tap do |obj|
-            if obj.is_a?(String)
-              obj.unconvertable_to_bson = true
-            end
+          if object.is_a?(String)
+            object.unconvertable_to_bson = true
           end
+          object
         end
       end
     end

data/lib/mongoid/relations/cyclic.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # This module provides convenience macros for using cyclic embedded
     # relations.
@@ -11,7 +11,7 @@ module Mongoid # :nodoc:
         class_attribute :cyclic
       end
 
-      module ClassMethods #:nodoc:
+      module ClassMethods
 
         # Create a cyclic embedded relation that creates a tree hierarchy for
         # the document and many embedded child documents.
@@ -38,9 +38,9 @@ module Mongoid # :nodoc:
         def recursively_embeds_many(options = {})
           embeds_many(
             cyclic_child_name,
-            options.merge(:class_name => self.name, :cyclic => true)
+            options.merge(class_name: self.name, cyclic: true)
           )
-          embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
+          embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
         end
 
         # Create a cyclic embedded relation that creates a single self
@@ -68,9 +68,9 @@ module Mongoid # :nodoc:
         def recursively_embeds_one(options = {})
           embeds_one(
             cyclic_child_name(false),
-            options.merge(:class_name => self.name, :cyclic => true)
+            options.merge(class_name: self.name, cyclic: true)
           )
-          embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
+          embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
         end
 
         private

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

@@ -0,0 +1,346 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Embedded
+
+      # Contains behaviour for executing operations in batch on embedded
+      # documents.
+      module Batchable
+
+        # Insert new documents as a batch push ($pushAll). This ensures that
+        # all callbacks are run at the appropriate time and only 1 request is
+        # made to the database.
+        #
+        # @example Execute the batch push.
+        #   batchable.batch_insert([ doc_one, doc_two ])
+        #
+        # @param [ Array<Document> ] docs The docs to add.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        #
+        # @since 3.0.0
+        def batch_insert(docs)
+          execute_batch_insert(docs, "$pushAll")
+        end
+
+        # Clear all of the docs out of the relation in a single swipe.
+        #
+        # @example Clear all docs.
+        #   batchable.batch_clear(docs)
+        #
+        # @param [ Array<Document> ] docs The docs to clear.
+        #
+        # @return [ Array ] The empty array.
+        #
+        # @since 3.0.0
+        def batch_clear(docs)
+          pre_process_batch_remove(docs, :delete)
+          unless docs.empty?
+            collection.find(selector).update("$unset" => { path => true })
+            post_process_batch_remove(docs, :delete)
+          end
+          _unscoped.clear
+        end
+
+        # Batch remove the provided documents as a $pullAll.
+        #
+        # @example Batch remove the documents.
+        #   batchable.batch_remove([ doc_one, doc_two ])
+        #
+        # @param [ Array<Document> ] docs The docs to remove.
+        # @param [ Symbol ] method Delete or destroy.
+        #
+        # @since 3.0.0
+        def batch_remove(docs, method = :delete)
+          removals = pre_process_batch_remove(docs, method)
+          if !docs.empty? && !_assigning?
+            collection.find(selector).update("$pullAll" => { path => removals })
+            post_process_batch_remove(docs, method)
+          end
+          Threaded.clear_options!
+          reindex
+        end
+
+        # Batch replace the provided documents as a $set.
+        #
+        # @example Batch replace the documents.
+        #   batchable.batch_replace([ doc_one, doc_two ])
+        #
+        # @param [ Array<Document> ] docs The docs to replace with.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        #
+        # @since 3.0.0
+        def batch_replace(docs)
+          if docs.blank?
+            if _assigning? && !empty?
+              base.atomic_unsets.push(first.atomic_path)
+            end
+            batch_remove(target.dup)
+          else
+            base.delayed_atomic_sets.clear
+            docs = normalize_docs(docs).compact
+            target.clear and _unscoped.clear
+            inserts = execute_batch_insert(docs, "$set")
+            add_atomic_sets(inserts)
+          end
+        end
+
+        private
+
+        # Add the atomic sets to the base document.
+        #
+        # @api private
+        #
+        # @example Add the atomic sets.
+        #   batchable.add_atomic_sets([{ field: value }])
+        #
+        # @param [ Array<Hash> ] sets The atomic sets.
+        #
+        # @since 3.0.0
+        def add_atomic_sets(sets)
+          if _assigning?
+            base.collect_children.each do |child|
+              child.delayed_atomic_sets.clear
+            end
+            base.delayed_atomic_sets[path] = sets
+          end
+        end
+
+        # Perform a batch persist of the provided documents with the supplied
+        # operation.
+        #
+        # @api private
+        #
+        # @example Perform a batch operation.
+        #   batchable.execute_batch(docs, "$set")
+        #
+        # @param [ Array<Document> ] docs The docs to persist.
+        # @param [ String ] operation The atomic operation.
+        #
+        # @return [ Array<Hash> ] The inserts.
+        #
+        # @since 3.0.0
+        def execute_batch_insert(docs, operation)
+          self.inserts_valid = true
+          inserts = pre_process_batch_insert(docs)
+          if insertable?
+            collection.find(selector).update(operation => { path => inserts })
+            post_process_batch_insert(docs)
+          end
+          inserts
+        end
+
+        # Are we in a state to be able to batch insert?
+        #
+        # @api private
+        #
+        # @example Can inserts be performed?
+        #   batchable.insertable?
+        #
+        # @return [ true, false ] If inserts can be performed.
+        #
+        # @since 3.0.0
+        def insertable?
+          persistable? && !_assigning? && inserts_valid
+        end
+
+        # Are the inserts currently valid?
+        #
+        # @api private
+        #
+        # @example Are the inserts currently valid.
+        #   batchable.inserts_valid
+        #
+        # @return [ true, false ] If inserts are currently valid.
+        #
+        # @since 3.0.0
+        def inserts_valid
+          @inserts_valid
+        end
+
+        # Set the inserts valid flag.
+        #
+        # @api private
+        #
+        # @example Set the flag.
+        #   batchable.inserts_valid = true
+        #
+        # @param [ true, false ] value The flag.
+        #
+        # @return [ true, false ] The flag.
+        #
+        # @since 3.0.0
+        def inserts_valid=(value)
+          @inserts_valid = value
+        end
+
+        # Normalize the documents, in case they were provided as an array of
+        # hashes.
+        #
+        # @api private
+        #
+        # @example Normalize the docs.
+        #   batchable.normalize_docs(docs)
+        #
+        # @param [ Array<Hash, Document> ] docs The docs to normalize.
+        #
+        # @return [ Array<Document> ] The docs.
+        #
+        # @since 3.0.0
+        def normalize_docs(docs)
+          if docs.first.is_a?(::Hash)
+            docs.map do |doc|
+              attributes = { metadata: metadata, _parent: base }
+              attributes.merge!(doc)
+              Factory.build(klass, attributes)
+            end
+          else
+            docs
+          end
+        end
+
+        # Get the atomic path.
+        #
+        # @api private
+        #
+        # @example Get the atomic path.
+        #   batchable.path
+        #
+        # @return [ String ] The atomic path.
+        #
+        # @since 3.0.0
+        def path
+          @path ||= _unscoped.first.atomic_path
+        end
+
+        # Set the atomic path.
+        #
+        # @api private
+        #
+        # @example Set the atomic path.
+        #   batchable.path = "addresses"
+        #
+        # @param [ String ] value The path.
+        #
+        # @return [ String ] The path.
+        #
+        # @since 3.0.0
+        def path=(value)
+          @path = value
+        end
+
+        # Get the selector for executing atomic operations on the collection.
+        #
+        # @api private
+        #
+        # @example Get the selector.
+        #   batchable.selector
+        #
+        # @return [ Hash ] The atomic selector.
+        #
+        # @since 3.0.0
+        def selector
+          @selector ||= base.atomic_selector
+        end
+
+        # Pre processes the batch insert for the provided documents.
+        #
+        # @api private
+        #
+        # @example Pre process the documents.
+        #   batchable.pre_process_batch_insert(docs)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        #
+        # @return [ Array<Hash> ] The documents as an array of hashes.
+        #
+        # @since 3.0.0
+        def pre_process_batch_insert(docs)
+          docs.map do |doc|
+            next unless doc
+            append(doc)
+            if persistable? && !_assigning?
+              self.path = doc.atomic_path unless path
+              if doc.valid?(:create)
+                doc.run_before_callbacks(:save, :create)
+              else
+                self.inserts_valid = false
+              end
+            end
+            doc.as_document
+          end
+        end
+
+        # Pre process the batch removal.
+        #
+        # @api private
+        #
+        # @example Pre process the documents.
+        #   batchable.pre_process_batch_remove(docs, :delete)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        # @param [ Symbol ] method Delete or destroy.
+        #
+        # @return [ Array<Hash> ] The documents as hashes.
+        #
+        # @since 3.0.0
+        def pre_process_batch_remove(docs, method)
+          docs.map do |doc|
+            self.path = doc.atomic_path unless path
+            if !_assigning? && !metadata.versioned?
+              doc.cascade!
+              doc.run_before_callbacks(:destroy) if method == :destroy
+            end
+            target.delete_one(doc)
+            _unscoped.delete_one(doc)
+            unbind_one(doc)
+            doc.as_document
+          end
+        end
+
+        # Post process the documents after batch insert.
+        #
+        # @api private
+        #
+        # @example Post process the documents.
+        #   batchable.post_process_batch_insert(docs)
+        #
+        # @param [ Array<Documents> ] docs The inserted docs.
+        #
+        # @return [ Enumerable ] The document enum.
+        #
+        # @since 3.0.0
+        def post_process_batch_insert(docs)
+          docs.each do |doc|
+            doc.new_record = false
+            doc.run_after_callbacks(:create, :save)
+            doc.post_persist
+          end
+        end
+
+        # Post process the batch removal.
+        #
+        # @api private
+        #
+        # @example Post process the documents.
+        #   batchable.post_process_batch_remove(docs, :delete)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        # @param [ Symbol ] method Delete or destroy.
+        #
+        # @return [ Array<Document> ] The documents.
+        #
+        # @since 3.0.0
+        def post_process_batch_remove(docs, method)
+          docs.each do |doc|
+            doc.run_after_callbacks(:destroy) if method == :destroy
+            doc.freeze
+            doc.destroyed = true
+            IdentityMap.remove(doc)
+          end
+        end
+      end
+    end
+  end
+end