mongoid 2.3.5 → 2.4.0

data/lib/mongoid/persistence/atomic.rb

@@ -27,8 +27,11 @@ module Mongoid #:nodoc:
       # @example Add only a unique value on the field.
       #   person.add_to_set(:aliases, "Bond")
       #
+      # @example Add only the unique values to the field.
+      #   person.add_to_set(:aliases, [ "Bond", "James" ])
+      #
       # @param [ Symbol ] field The name of the field.
-      # @param [ Object ] value The value to add.
+      # @param [ Object, Array<Object> ] value The value or values to add.
       # @param [ Hash ] options The mongo persistence options.
       #
       # @return [ Array<Object> ] The new value of the field.

data/lib/mongoid/persistence/atomic/add_to_set.rb

@@ -20,7 +20,9 @@ module Mongoid #:nodoc:
           prepare do
             document[field] = [] unless document[field]
             values = document.send(field)
-            values.push(value) unless values.include?(value)
+            Array.wrap(value).each do |val|
+              values.push(val) unless values.include?(val)
+            end
             values.tap do
               if document.persisted?
                 collection.update(document.atomic_selector, operation("$addToSet"), options)
@@ -29,6 +31,20 @@ module Mongoid #:nodoc:
             end
           end
         end
+
+        # Get the atomic operation to perform.
+        #
+        # @example Get the operation.
+        #   add_to_set.operation("$addToSet")
+        #
+        # @param [ String ] modifier The modifier to use.
+        #
+        # @return [ Hash ] The atomic operation for the field and addition.
+        #
+        # @since 2.0.0
+        def operation(modifier)
+          { modifier => { path => value.is_a?(Array) ? { "$each" => value } : value}}
+        end
       end
     end
   end

data/lib/mongoid/persistence/atomic/sets.rb

@@ -17,7 +17,7 @@ module Mongoid #:nodoc:
         # @ssete 2.0.0
         def persist
           prepare do
-            value ? document[field] = value : @value = document[field]
+            document[field] = value
             document[field].tap do
               collection.update(document.atomic_selector, operation("$set"), options)
               document.remove_change(field)

data/lib/mongoid/railties/database.rake

@@ -78,7 +78,7 @@ namespace :db do
     desc 'Create the indexes defined on your mongoid models'
     task :create_indexes => :environment do
       engines_models_paths = Rails.application.railties.engines.map do |engine|
-        engine.paths["app/models"].paths
+        engine.paths["app/models"].expanded
       end
       root_models_paths = Rails.application.paths["app/models"]
       models_paths = engines_models_paths.push(root_models_paths).flatten

data/lib/mongoid/relations.rb

@@ -44,9 +44,7 @@ module Mongoid # :nodoc:
     include Reflections
     include Synchronization
 
-    included do
-      attr_accessor :metadata
-    end
+    attr_accessor :metadata
 
     # Determine if the document itself is embedded in another document via the
     # proper channels. (If it has a parent document.)

data/lib/mongoid/relations/auto_save.rb

@@ -25,7 +25,7 @@ module Mongoid # :nodoc:
             set_callback :save, :after do |document|
               relation = document.send(metadata.name)
               if relation
-                (relation.do_or_do_not(:in_memory) || relation.to_a).each do |doc|
+                (relation.do_or_do_not(:in_memory) || Array.wrap(relation)).each do |doc|
                   doc.save
                 end
               end

data/lib/mongoid/relations/builders.rb

@@ -68,7 +68,7 @@ module Mongoid # :nodoc:
               attributes, options = parse_args(*args)
               document = Factory.build(metadata.klass, attributes, options)
               _building do
-                send("#{name}=", document)
+                send("#{name}=", document).tap {|child| child.run_callbacks(:build) }
               end
             end
           end

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

@@ -1,12 +1,9 @@
 # encoding: utf-8
-require "mongoid/relations/embedded/sort"
-
 module Mongoid # :nodoc:
   module Relations #:nodoc:
     module Builders #:nodoc:
       module Embedded #:nodoc:
         class Many < Builder #:nodoc:
-          include Relations::Embedded::Sort
 
           # Builds the document out of the attributes using the provided
           # metadata on the relation. Instantiates through the factory in order
@@ -25,12 +22,11 @@ module Mongoid # :nodoc:
             [].tap do |docs|
               object.each do |attrs|
                 if _loading?
-                  docs << Factory.from_db(klass, attrs)
+                  docs.push(Factory.from_db(klass, attrs))
                 else
-                  docs << Factory.build(klass, attrs)
+                  docs.push(Factory.build(klass, attrs))
                 end
               end
-              sort_documents!(docs, metadata) if metadata.order
             end
           end
         end

data/lib/mongoid/relations/builders/nested_attributes/many.rb

@@ -92,7 +92,7 @@ module Mongoid # :nodoc:
           def process(parent, attrs)
             return if reject?(parent, attrs)
             if id = attrs.extract_id
-              doc = existing.find(convert_id(id))
+              doc = existing.find(convert_id(existing.first.class, id))
               if destroyable?(attrs)
                 existing.delete(doc)
                 doc.destroy unless doc.embedded?

data/lib/mongoid/relations/builders/nested_attributes/one.rb

@@ -69,7 +69,7 @@ module Mongoid # :nodoc:
           #
           # True if the id part of the logic will allow an update.
           def acceptable_id?
-            id = convert_id(attributes[:id])
+            id = convert_id(existing.class, attributes[:id])
             existing.id == id || id.nil? || (existing.id != id && update_only?)
           end
 

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

@@ -16,7 +16,7 @@ module Mongoid # :nodoc:
           # @return [ Array<Document> ] The documents.
           def build(type = nil)
             return object.try(:dup) unless query?
-            metadata.criteria(object)
+            metadata.criteria(object || [])
           end
 
           # Do we need to perform a database query? It will be so if the object we

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

@@ -11,7 +11,7 @@ module Mongoid # :nodoc:
         # @example Perform the cascading delete.
         #   strategy.cascade
         def cascade
-          relation.to_a.each { |doc| doc.delete } if relation
+          Array.wrap(relation).each { |doc| doc.delete } if relation
         end
       end
     end

data/lib/mongoid/relations/cyclic.rb

@@ -35,9 +35,11 @@ module Mongoid # :nodoc:
         # or its children.
         #
         # @since 2.0.0.rc.1
-        def recursively_embeds_many
-          self.cyclic = true
-          embeds_many cyclic_child_name, :class_name => self.name, :cyclic => true
+        def recursively_embeds_many(options = {})
+          embeds_many(
+            cyclic_child_name,
+            options.merge(:class_name => self.name, :cyclic => true)
+          )
           embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
         end
 
@@ -63,9 +65,11 @@ module Mongoid # :nodoc:
         # or its children.
         #
         # @since 2.0.0.rc.1
-        def recursively_embeds_one
-          self.cyclic = true
-          embeds_one cyclic_child_name(false), :class_name => self.name, :cyclic => true
+        def recursively_embeds_one(options = {})
+          embeds_one(
+            cyclic_child_name(false),
+            options.merge(:class_name => self.name, :cyclic => true)
+          )
           embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
         end
 

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

@@ -55,13 +55,13 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.0
         def atomically(modifier, &block)
-          updater = Threaded.update_consumer(collection_name) ||
-            Threaded.set_update_consumer(collection_name, MODIFIERS[modifier].new)
+          updater = Threaded.update_consumer(root_class) ||
+            Threaded.set_update_consumer(root_class, MODIFIERS[modifier].new)
           count_executions do
             block.call if block
           end.tap do
             if @executions.zero?
-              Threaded.set_update_consumer(collection_name, nil)
+              Threaded.set_update_consumer(root_class, nil)
               updater.execute(collection)
             end
           end

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

@@ -17,21 +17,42 @@ module Mongoid # :nodoc:
         # @example Push a document.
         #   person.addresses.push(address)
         #
+        # @param [ Document, Array<Document> ] *args Any number of documents.
+        def <<(*args)
+          docs = args.flatten
+          return concat(docs) if docs.size > 1
+          if doc = docs.first
+            append(doc)
+            doc.save if persistable? && !_assigning?
+          end
+        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.addresses.concat([ address_one, address_two ])
         #
-        # @param [ Document, Array<Document> ] *args Any number of documents.
-        def <<(*args)
+        # @param [ Array<Document> ] documents The docs to add.
+        #
+        # @return [ Array<Document> ] The documents.
+        #
+        # @since 2.4.0
+        def concat(documents)
           atomically(:$pushAll) do
-            args.flatten.each do |doc|
+            documents.each do |doc|
               next unless doc
               append(doc)
-              doc.save if persistable? && !_assigning?
+              doc.save if persistable?
             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.
@@ -58,6 +79,7 @@ module Mongoid # :nodoc:
             doc.identify
             append(doc)
             yield(doc) if block_given?
+            doc.run_callbacks(:build) { doc }
           end
         end
         alias :new :build
@@ -71,7 +93,10 @@ module Mongoid # :nodoc:
         # @return [ Many ] The empty relation.
         def clear
           tap do |proxy|
-            atomically(:$unset) { proxy.delete_all }
+            atomically(:$unset) do
+              proxy.delete_all
+              _unscoped.clear
+            end
           end
         end
 
@@ -145,8 +170,9 @@ 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 _assigning? && !doc.paranoid?
                 base.add_atomic_pull(doc)
               else
                 doc.delete(:suppress => true)
@@ -224,6 +250,8 @@ module Mongoid # :nodoc:
               integrate(doc)
               doc._index = index
             end
+            @_unscoped = target.dup
+            @target = scope(target)
           end
         end
 
@@ -263,7 +291,9 @@ module Mongoid # :nodoc:
                 if replacement.first.is_a?(Hash)
                   replacement = Many.builder(base, metadata, replacement).build
                 end
-                proxy.target = replacement.compact
+                docs = replacement.compact
+                proxy.target = docs
+                self._unscoped = docs.dup
                 if _assigning?
                   base.delayed_atomic_sets[metadata.name.to_s] = proxy.as_document
                 end
@@ -287,23 +317,25 @@ module Mongoid # :nodoc:
         # @since 2.0.0.rc.1
         def as_document
           [].tap do |attributes|
-            target.each do |doc|
-              attributes << doc.as_document
+            _unscoped.each do |doc|
+              attributes.push(doc.as_document)
             end
           end
         end
 
-        # Get a criteria for the embedded documents without the default scoping
-        # applied.
+        # Return the relation with all previous scoping removed. This is the
+        # exact representation of the docs in the database.
         #
-        # @example Get the unscoped criteria.
+        # @example Get the unscoped documents.
         #   person.addresses.unscoped
         #
-        # @return [ Criteria ] The unscoped criteria.
+        # @return [ Criteria ] The unscoped relation.
         #
-        # @since 2.2.1
+        # @since 2.4.0
         def unscoped
-          criteria(false)
+          klass.criteria(true, false).tap do |criterion|
+            criterion.documents = _unscoped
+          end
         end
 
         private
@@ -319,6 +351,7 @@ module Mongoid # :nodoc:
         # @since 2.0.0.rc.1
         def append(document)
           target.push(document)
+          _unscoped.push(document)
           integrate(document)
           document._index = target.size - 1
         end
@@ -344,8 +377,8 @@ module Mongoid # :nodoc:
         #   relation.criteria
         #
         # @return [ Criteria ] A new criteria.
-        def criteria(scoped = true)
-          klass.criteria(true, scoped).tap do |criterion|
+        def criteria
+          klass.criteria(true).tap do |criterion|
             criterion.documents = target
           end
         end
@@ -402,11 +435,29 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def reindex
-          target.each_with_index do |doc, index|
+          _unscoped.each_with_index do |doc, index|
             doc._index = index
           end
         end
 
+        # Apply the metadata ordering or the default scoping to the provided
+        # documents.
+        #
+        # @example Apply scoping.
+        #   person.addresses.scope(target)
+        #
+        # @param [ Array<Document> ] docs The documents to scope.
+        #
+        # @return [ Array<Document> ] The scoped docs.
+        #
+        # @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
+        end
+
         # Remove all documents from the relation, either with a delete or a
         # destroy depending on what this was called through.
         #
@@ -422,6 +473,7 @@ module Mongoid # :nodoc:
           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
@@ -429,6 +481,32 @@ module Mongoid # :nodoc:
           end
         end
 
+        # Get the internal unscoped documents.
+        #
+        # @example Get the unscoped documents.
+        #   relation._unscoped
+        #
+        # @return [ Array<Document> ] The unscoped documents.
+        #
+        # @since 2.4.0
+        def _unscoped
+          @_unscoped ||= []
+        end
+
+        # Set the internal unscoped documents.
+        #
+        # @example Set the unscoped documents.
+        #   relation._unscoped = docs
+        #
+        # @param [ Array<Document> ] docs The documents.
+        #
+        # @return [ Array<Document ] The unscoped docs.
+        #
+        # @since 2.4.0
+        def _unscoped=(docs)
+          @_unscoped = docs
+        end
+
         class << self
 
           # Return the builder that is responsible for generating the documents

data/lib/mongoid/relations/macros.rb

@@ -76,6 +76,7 @@ module Mongoid # :nodoc:
         # @param [ Proc ] block Optional block for defining extensions.
         def embeds_many(name, options = {}, &block)
           characterize(name, Embedded::Many, options, &block).tap do |meta|
+            self.cyclic = true if options[:cyclic]
             relate(name, meta)
             validates_relation(meta)
           end
@@ -102,6 +103,7 @@ module Mongoid # :nodoc:
         # @param [ Proc ] block Optional block for defining extensions.
         def embeds_one(name, options = {}, &block)
           characterize(name, Embedded::One, options, &block).tap do |meta|
+            self.cyclic = true if options[:cyclic]
             relate(name, meta)
             builder(name, meta).creator(name, meta)
             validates_relation(meta)