mongoid 3.0.23 → 3.1.0

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

@@ -17,7 +17,7 @@ module Mongoid
         # @since 2.1.0
         def persist
           prepare do
-            document.attributes.delete(field)
+            fields.each { |f| document.attributes.delete(f) }
             execute("$unset")
           end
         end

data/lib/mongoid/persistence/operations/embedded/insert.rb

@@ -16,7 +16,9 @@ module Mongoid
         #     false
         #   );
         class Insert
-          include Insertion, Operations
+          include Insertion
+          include Operations
+          include Mongoid::Atomic::Positionable
 
           # Insert the new document in the database. If the document's parent is a
           # new record, we will call save on the parent, otherwise we will $push
@@ -32,7 +34,8 @@ module Mongoid
               if parent.new_record?
                 parent.insert
               else
-                collection.find(parent.atomic_selector).update(inserts)
+                selector = parent.atomic_selector
+                collection.find(selector).update(positionally(selector, inserts))
               end
             end
           end

data/lib/mongoid/persistence/operations/embedded/remove.rb

@@ -14,7 +14,9 @@ module Mongoid
         #     false
         #   );
         class Remove
-          include Deletion, Operations
+          include Deletion
+          include Operations
+          include Mongoid::Atomic::Positionable
 
           # Remove the document from the database. If the parent is a new record,
           # it will get removed in Ruby only. If the parent is not a new record
@@ -29,7 +31,8 @@ module Mongoid
             prepare do |doc|
               parent.remove_child(doc) if notifying_parent?
               if parent.persisted?
-                collection.find(parent.atomic_selector).update(deletes)
+                selector = parent.atomic_selector
+                collection.find(selector).update(positionally(selector, deletes))
               end
             end
           end

data/lib/mongoid/persistence/operations/update.rb

@@ -30,7 +30,9 @@ module Mongoid
       #   );
       #
       class Update
-        include Modification, Operations
+        include Modification
+        include Operations
+        include Mongoid::Atomic::Positionable
 
         # Persist the document that is to be updated to the database. This will
         # only write changed fields via MongoDB's $set modifier operation.
@@ -42,9 +44,11 @@ module Mongoid
         def persist
           prepare do
             unless updates.empty?
-              collection.find(selector).update(updates)
+              collection.find(selector).update(positionally(selector, updates))
               conflicts.each_pair do |key, value|
-                collection.find(selector).update({ key => value })
+                collection.find(selector).update(
+                  positionally(selector, { key => value })
+                )
               end
             end
           end

data/lib/mongoid/railties/database.rake

@@ -5,6 +5,11 @@ namespace :db do
     task :drop => "mongoid:drop"
   end
 
+  unless Rake::Task.task_defined?("db:purge")
+    desc "Drop all collections except the system collections"
+    task :purge => "mongoid:purge"
+  end
+
   unless Rake::Task.task_defined?("db:seed")
     # if another ORM has defined db:seed, don"t run it twice.
     desc "Load the seed data from db/seeds.rb"
@@ -61,36 +66,24 @@ namespace :db do
   end
 
   namespace :mongoid 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"].expanded
-      end
-      root_models_paths = Rails.application.paths["app/models"]
-      models_paths = engines_models_paths.push(root_models_paths).flatten
-
-      models_paths.each do |path|
-        ::Rails::Mongoid.create_indexes("#{path}/**/*.rb")
-      end
+      ::Rails::Mongoid.create_indexes
     end
 
     desc "Remove the indexes defined on your mongoid models without questions!"
     task :remove_indexes => :environment do
-      engines_models_paths = Rails.application.railties.engines.map do |engine|
-        engine.paths["app/models"].expanded
-      end
-      root_models_paths = Rails.application.paths["app/models"]
-      models_paths = engines_models_paths.push(root_models_paths).flatten
-
-      models_paths.each do |path|
-        ::Rails::Mongoid.remove_indexes("#{path}/**/*.rb")
-      end
+      ::Rails::Mongoid.remove_indexes
     end
 
     desc "Drops the database for the current Rails.env"
     task :drop => :environment do
       ::Mongoid::Sessions.default.drop
     end
+
+    desc "Drop all collections except the system collections"
+    task :purge => :environment do
+      ::Mongoid.purge!
+    end
   end
 end

data/lib/mongoid/relations.rb

@@ -4,6 +4,7 @@ require "mongoid/relations/auto_save"
 require "mongoid/relations/cascading"
 require "mongoid/relations/constraint"
 require "mongoid/relations/conversions"
+require "mongoid/relations/counter_cache"
 require "mongoid/relations/cyclic"
 require "mongoid/relations/proxy"
 require "mongoid/relations/bindings"
@@ -43,6 +44,7 @@ module Mongoid
     include Reflections
     include Synchronization
     include Touchable
+    include CounterCache
 
     attr_accessor :metadata
 

data/lib/mongoid/relations/accessors.rb

@@ -113,11 +113,7 @@ module Mongoid
         else
           _building do
             _loading do
-              # @note In the case where the record is new and we are binding,
-              # we want to avoid an extra database query when we know it is not
-              # necessary.
-              key = (new_record? && _binding?) ? nil : attributes[metadata.key]
-              __build__(name, key, metadata)
+              __build__(name, attributes[metadata.key], metadata)
             end
           end
         end
@@ -128,6 +124,30 @@ module Mongoid
         end
       end
 
+      # @todo: Durran: Refactor before release, but this fixes the issue with
+      # the extra queries.
+      def get_relation_for_set(name, metadata, object)
+        variable = "@#{name}"
+        value = if instance_variable_defined?(variable)
+          instance_variable_get(variable)
+        else
+          _building do
+            _loading do
+              if needs_no_database_query?(object, metadata)
+                __build__(name, object, metadata)
+              else
+                __build__(name, attributes[metadata.key], metadata)
+              end
+            end
+          end
+        end
+      end
+
+      def needs_no_database_query?(object, metadata)
+        object.is_a?(Document) && !object.embedded? &&
+          object.id == attributes[metadata.key]
+      end
+
       # Is the current code executing without autobuild functionality?
       #
       # @example Is autobuild disabled?
@@ -151,10 +171,10 @@ module Mongoid
       #
       # @since 3.0.0
       def without_autobuild
-        Threaded.begin("without_autobuild")
+        Threaded.begin_execution("without_autobuild")
         yield
       ensure
-        Threaded.exit("without_autobuild")
+        Threaded.exit_execution("without_autobuild")
       end
 
       module ClassMethods
@@ -241,8 +261,10 @@ module Mongoid
         def setter(name, metadata)
           re_define_method("#{name}=") do |object|
             without_autobuild do
-              if metadata.many? || get_relation(name, metadata)
+              if metadata.many?
                 set_relation(name, get_relation(name, metadata).substitute(object.substitutable))
+              elsif value = get_relation_for_set(name, metadata, object)
+                set_relation(name, value.substitute(object.substitutable))
               else
                 __build__(name, object.substitutable, metadata)
               end

data/lib/mongoid/relations/binding.rb

@@ -190,12 +190,16 @@ module Mongoid
       # @since 3.0.0
       def bind_from_relational_parent(doc)
         check_inverse!(doc)
-        bind_foreign_key(doc, base.id)
+        bind_foreign_key(doc, record_id(base))
         bind_polymorphic_type(doc, base.class.name)
         bind_inverse(doc, base)
         bind_inverse_of_field(doc, metadata.name)
       end
 
+      def record_id(base)
+        base.__send__(metadata.primary_key)
+      end
+
       # Ensure that the metadata on the base is correct, for the cases
       # where we have multiple belongs to definitions and were are setting
       # different parents in memory in order.

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

@@ -21,7 +21,7 @@ module Mongoid
           def bind_one
             binding do
               check_inverses!(target)
-              bind_foreign_key(base, target.id)
+              bind_foreign_key(base, record_id(target))
               bind_polymorphic_inverse_type(base, target.class.name)
               if inverse = metadata.inverse(target)
                 if set_base_metadata

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

@@ -20,7 +20,7 @@ module Mongoid
             binding do
               inverse_keys = doc.you_must(metadata.inverse_foreign_key)
               if inverse_keys
-                inverse_keys.push(base.id)
+                inverse_keys.push(record_id(base))
                 doc.reset_relation_criteria(metadata.inverse)
               end
               base.synced[metadata.foreign_key] = true
@@ -36,10 +36,10 @@ module Mongoid
           # @since 2.0.0.rc.1
           def unbind_one(doc)
             binding do
-              base.send(metadata.foreign_key).delete_one(doc.id)
+              base.send(metadata.foreign_key).delete_one(record_id(doc))
               inverse_keys = doc.you_must(metadata.inverse_foreign_key)
               if inverse_keys
-                inverse_keys.delete_one(base.id)
+                inverse_keys.delete_one(record_id(base))
                 doc.reset_relation_criteria(metadata.inverse)
               end
               base.synced[metadata.foreign_key] = true

data/lib/mongoid/relations/counter_cache.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module CounterCache
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Reset the given counter using the .count() query from the
+        # db. This method is usuful in case that a counter got
+        # corrupted, or a new counter was added to the collection.
+        #
+        # @example Reset the given counter cache
+        #   Post.reset_counters('50e0edd97c71c17ea9000001', :comments)
+        #
+        # @param [ String ] The id of the object that will be reset.
+        # @param [ Symbol, Array ] One or more counter caches to reset
+        #
+        # @since 3.1.0
+        def reset_counters(id, *counters)
+          object = find(id)
+          counters.each do |name|
+            meta = reflect_on_association(name)
+            inverse = meta.klass.reflect_on_association(meta.inverse)
+            counter_name = inverse.counter_cache_column_name
+            object.update_attribute(counter_name, object.send(name).count)
+          end
+        end
+
+        # Update the given counters by the value factor. It uses the
+        # atomic $inc command.
+        #
+        # @example Add 5 to comments counter and remove 2 from likes
+        #   counter.
+        #   Post.update_counters('50e0edd97c71c17ea9000001',
+        #              :comments_count => 5, :likes_count => -2)
+        #
+        # @param [ String ] The id of the object to update.
+        # @param [ Hash ] Key = counter_cahe and Value = factor.
+        #
+        # @since 3.1.0
+        def update_counters(id, counters)
+          counters.map do |key, value|
+            where(:_id => id).inc(key, value)
+          end
+        end
+
+        # Increment the counter name from the entries that match the
+        # id by one. This method is used on associations callbacks
+        # when counter_cache is enable
+        #
+        # @example Increment comments counter
+        #   Post.increment_counter(:comments_count, '50e0edd97c71c17ea9000001')
+        #
+        # @param [ Symbol ] Counter cache name
+        # @param [ String ] The id of the object that will be reset.
+        #
+        # @since 3.1.0
+        def increment_counter(counter_name, id)
+          update_counters(id, counter_name.to_sym => 1)
+        end
+
+        # Decrement the counter name from the entries that match the
+        # id by one. This method is used on associations callbacks
+        # when counter_cache is enable
+        #
+        # @example Decrement comments counter
+        #   Post.decrement_counter(:comments_count, '50e0edd97c71c17ea9000001')
+        #
+        # @param [ Symbol ] Counter cache name
+        # @param [ String ] The id of the object that will be reset.
+        #
+        # @since 3.1.0
+        def decrement_counter(counter_name, id)
+          update_counters(id, counter_name.to_sym => -1)
+        end
+
+        private
+
+        # Add the callbacks responsible for update the counter cache field
+        #
+        # @api private
+        #
+        # @example Add the touchable.
+        #   Person.add_counter_callbacks(meta)
+        #
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @since 3.1.0
+        def add_counter_cache_callbacks(meta)
+          name = meta.name
+          cache_column = meta.counter_cache_column_name.to_sym
+
+          after_create do
+            record = __send__(name)
+            record.class.increment_counter(cache_column, record.id) if record.try(:persisted?)
+          end
+
+          before_destroy do
+            record = __send__(name)
+            record.class.decrement_counter(cache_column, record.id) if record.try(:persisted?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module Mongoid
       # Contains behaviour for executing operations in batch on embedded
       # documents.
       module Batchable
+        include Mongoid::Atomic::Positionable
 
         # Insert new documents as a batch push ($pushAll). This ensures that
         # all callbacks are run at the appropriate time and only 1 request is
@@ -36,7 +37,9 @@ module Mongoid
         def batch_clear(docs)
           pre_process_batch_remove(docs, :delete)
           unless docs.empty?
-            collection.find(selector).update("$unset" => { path => true })
+            collection.find(selector).update(
+              positionally(selector, "$unset" => { path => true })
+            )
             post_process_batch_remove(docs, :delete)
           end
           _unscoped.clear
@@ -53,8 +56,10 @@ module Mongoid
         # @since 3.0.0
         def batch_remove(docs, method = :delete)
           removals = pre_process_batch_remove(docs, method)
-          if !docs.empty?
-            collection.find(selector).update("$pullAll" => { path => removals })
+          if !docs.empty? && !_assigning?
+            collection.find(selector).update(
+              positionally(selector, "$pullAll" => { path => removals })
+            )
             post_process_batch_remove(docs, method)
           end
           Threaded.clear_options!
@@ -126,7 +131,9 @@ module Mongoid
           self.inserts_valid = true
           inserts = pre_process_batch_insert(docs)
           if insertable?
-            collection.find(selector).update(operation => { path => inserts })
+            collection.find(selector).update(
+              positionally(selector, operation => { path => inserts })
+            )
             post_process_batch_insert(docs)
           end
           inserts
@@ -289,6 +296,7 @@ module Mongoid
         def pre_process_batch_remove(docs, method)
           docs.map do |doc|
             self.path = doc.atomic_path unless path
+            execute_callback :before_remove, doc
             if !_assigning? && !metadata.versioned?
               doc.cascade!
               doc.run_before_callbacks(:destroy) if method == :destroy
@@ -296,6 +304,7 @@ module Mongoid
             target.delete_one(doc)
             _unscoped.delete_one(doc)
             unbind_one(doc)
+            execute_callback :after_remove, doc
             doc.as_document
           end
         end

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

@@ -130,6 +130,7 @@ module Mongoid
         #
         # @since 2.0.0.rc.1
         def delete(document)
+          execute_callback :before_remove, document
           doc = target.delete_one(document)
           if doc && !_binding?
             _unscoped.delete_one(doc) unless doc.paranoid?
@@ -145,6 +146,7 @@ module Mongoid
             end
           end
           reindex
+          execute_callback :after_remove, document
           doc
         end
 
@@ -175,6 +177,28 @@ module Mongoid
           remove_all(conditions, :delete)
         end
 
+        # Delete all the documents for which the provided block returns true.
+        #
+        # @example Delete the matching documents.
+        #   person.addresses.delete_if do |doc|
+        #     doc.state = "GA"
+        #   end
+        #
+        # @return [ Many, Enumerator ] The relation or an enumerator if no
+        #   block was provided.
+        #
+        # @since 3.1.0
+        def delete_if
+          if block_given?
+            target.each do |doc|
+              delete(doc) if yield(doc)
+            end
+            self
+          else
+            super
+          end
+        end
+
         # Destroy all the documents in the association whilst running callbacks.
         #
         # @example Destroy all documents from the relation.
@@ -318,10 +342,12 @@ module Mongoid
         #
         # @since 2.0.0.rc.1
         def append(document)
+          execute_callback :before_add, document
           target.push(*scope([document]))
           _unscoped.push(document)
           integrate(document)
           document._index = _unscoped.size - 1
+          execute_callback :after_add, document
         end
 
         # Instantiate the binding associated with this relation.
@@ -608,7 +634,10 @@ module Mongoid
           #
           # @since 2.1.0
           def valid_options
-            [ :as, :cascade_callbacks, :cyclic, :order, :versioned, :store_as ]
+            [
+              :as, :cascade_callbacks, :cyclic, :order, :versioned, :store_as,
+              :before_add, :after_add, :before_remove, :after_remove
+            ]
           end
 
           # Get the default validation setting for the relation. Determines if