mongoid 3.1.6 → 4.0.0

data/lib/mongoid/{dirty.rb → changeable.rb}

@@ -1,6 +1,10 @@
 # encoding: utf-8
 module Mongoid
-  module Dirty
+
+  # Defines behaviour for dirty tracking.
+  #
+  # @since 4.0.0
+  module Changeable
     extend ActiveSupport::Concern
 
     # Get the changed attributes for the document.
@@ -80,7 +84,6 @@ module Mongoid
     #
     # @since 2.1.0
     def move_changes
-      @_children = nil
       @previous_changes = changes
       Atomic::UPDATES.each do |update|
         send(update).clear
@@ -245,6 +248,15 @@ module Mongoid
       attributes[attr] = changed_attributes.delete(attr) if attribute_changed?(attr)
     end
 
+    def reset_attribute_to_default!(attr)
+      attr = database_field_name(attr)
+      if field = fields[attr]
+        __send__("#{attr}=", field.eval_default(self))
+      else
+        __send__("#{attr}=", nil)
+      end
+    end
+
     module ClassMethods
 
       private
@@ -267,6 +279,7 @@ module Mongoid
         create_dirty_default_change_check(name, meth)
         create_dirty_previous_value_accessor(name, meth)
         create_dirty_reset(name, meth)
+        create_dirty_reset_to_default(name, meth)
       end
 
       # Creates the dirty change accessor.
@@ -370,6 +383,23 @@ module Mongoid
           end
         end
       end
+
+      # Creates the dirty change reset to default.
+      #
+      # @example Create the reset.
+      #   Model.create_dirty_reset_to_default("name", "alias")
+      #
+      # @param [ String ] name The attribute name.
+      # @param [ String ] meth The name of the accessor.
+      #
+      # @since 3.0.0
+      def create_dirty_reset_to_default(name, meth)
+        generated_methods.module_eval do
+          re_define_method("reset_#{meth}_to_default!") do
+            reset_attribute_to_default!(name)
+          end
+        end
+      end
     end
   end
 end

data/lib/mongoid/composable.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+require "mongoid/changeable"
+require "mongoid/findable"
+require "mongoid/indexable"
+require "mongoid/inspectable"
+require "mongoid/interceptable"
+require "mongoid/matchable"
+require "mongoid/persistable"
+require "mongoid/reloadable"
+require "mongoid/selectable"
+require "mongoid/scopable"
+require "mongoid/serializable"
+require "mongoid/shardable"
+require "mongoid/stateful"
+require "mongoid/traversable"
+require "mongoid/validatable"
+
+module Mongoid
+
+  # This module provides inclusions of all behaviour in a Mongoid document.
+  #
+  # @since 4.0.0
+  module Composable
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend Findable
+    end
+
+    include ActiveModel::Model
+    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Atomic
+    include Changeable
+    include Attributes
+    include Evolvable
+    include Fields
+    include Indexable
+    include Inspectable
+    include Matchable
+    include Persistable
+    include Relations
+    include Reloadable
+    include Scopable
+    include Selectable
+    include Serializable
+    include Sessions
+    include Shardable
+    include Stateful
+    include Threaded::Lifecycle
+    include Traversable
+    include Validatable
+    include Interceptable
+    include Copyable
+    include Equality
+
+    MODULES = [
+      Atomic,
+      Attributes,
+      Copyable,
+      Changeable,
+      Evolvable,
+      Fields,
+      Indexable,
+      Inspectable,
+      Interceptable,
+      Matchable,
+      Persistable,
+      Relations,
+      Reloadable,
+      Scopable,
+      Serializable,
+      Sessions,
+      Shardable,
+      Stateful,
+      Threaded::Lifecycle,
+      Traversable,
+      Validatable,
+      Equality,
+      ActiveModel::Model,
+      ActiveModel::Validations
+    ]
+
+    class << self
+
+      # Get a list of methods that would be a bad idea to define as field names
+      # or override when including Mongoid::Document.
+      #
+      # @example Bad thing!
+      #   Mongoid::Components.prohibited_methods
+      #
+      # @return [ Array<Symbol> ]
+      #
+      # @since 2.1.8
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map{ |m| m.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/options.rb

@@ -20,7 +20,7 @@ module Mongoid
       # Define a configuration option with a default.
       #
       # @example Define the option.
-      #   Options.option(:persist_in_safe_mode, :default => false)
+      #   Options.option(:persist_in_safe_mode, :default => true)
       #
       # @param [ Symbol ] name The name of the configuration option.
       # @param [ Hash ] options Extras for the option.

data/lib/mongoid/config.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 require "mongoid/config/environment"
-require "mongoid/config/inflections"
 require "mongoid/config/options"
 require "mongoid/config/validators"
 
@@ -11,23 +10,18 @@ module Mongoid
   module Config
     extend self
     extend Options
-    include ActiveModel::Observing
 
     delegate :logger=, to: ::Mongoid
     delegate :logger, to: ::Mongoid
 
     LOCK = Mutex.new
 
-    option :allow_dynamic_fields, default: true
-    option :identity_map_enabled, default: false
     option :include_root_in_json, default: false
     option :include_type_for_serialization, default: false
     option :preload_models, default: false
-    option :protect_sensitive_fields, default: true
     option :raise_not_found_error, default: true
     option :scope_overwrite_exception, default: false
-    # @todo: Remove at 4.0
-    option :skip_version_check, default: false
+    option :duplicate_fields_exception, default: false
     option :use_activesupport_time_zone, default: true
     option :use_utc, default: false
 
@@ -54,7 +48,7 @@ module Mongoid
     # @param [ String ] name The database name.
     #
     # @since 3.0.0
-    def connect_to(name, options = { consistency: :eventual })
+    def connect_to(name, options = { read: :primary })
       self.sessions = {
         default: {
           database: name,
@@ -72,7 +66,7 @@ module Mongoid
     #
     # @return [ Array<String> ] An array of bad field names.
     def destructive_fields
-      Components.prohibited_methods
+      Composable.prohibited_methods
     end
 
     # Load the settings from a compliant mongoid.yml file. This can be used for

data/lib/mongoid/contextual/aggregable/mongo.rb

@@ -12,7 +12,7 @@ module Mongoid
         #
         # @param [ String, Symbol ] field The field name.
         #
-        # @return [ Hash ] The aggregate values in the form:
+        # @return [ Hash ] count is a number of documents with the provided field. If there're none, then count is 0 and max, min, sum, avg are nil.
         #   {
         #     "count" => 2.0,
         #     "max" => 1000.0,
@@ -23,15 +23,11 @@ module Mongoid
         #
         # @since 3.0.0
         def aggregates(field)
-          if query.count > 0
-            result = collection.aggregate(pipeline(field)).to_a
-            if result.empty?
-              { "count" => query.count, "avg" => 0, "sum" => 0 }
-            else
-              result.first
-            end
+          result = collection.aggregate(pipeline(field)).to_a
+          if result.empty?
+            { "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil }
           else
-            { "count" => 0 }
+            result.first
           end
         end
 
@@ -129,6 +125,8 @@ module Mongoid
           db_field = "$#{database_field_name(field)}"
           pipeline = []
           pipeline << { "$match" => criteria.nin(field => nil).selector }
+          pipeline << { "$sort" => criteria.options[:sort] } if criteria.options[:sort]
+          pipeline << { "$skip" => criteria.options[:skip] } if criteria.options[:skip]
           pipeline << { "$limit" => criteria.options[:limit] } if criteria.options[:limit]
           pipeline << {
             "$group"  => {

data/lib/mongoid/contextual/atomic.rb

@@ -6,84 +6,76 @@ module Mongoid
       # Execute an atomic $addToSet on the matching documents.
       #
       # @example Add the value to the set.
-      #   context.add_to_set(:members, "Dave")
+      #   context.add_to_set(members: "Dave", genres: "Electro")
       #
-      # @param [ String, Symbol ] field The name of the field to add to.
-      # @param [ Object ] value The single value to add.
+      # @param [ Hash ] adds The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def add_to_set(field, value)
-        query.update_all("$addToSet" => { database_field_name(field) => value })
+      def add_to_set(adds)
+        query.update_all("$addToSet" => collect_operations(adds))
       end
 
       # Perform an atomic $bit operation on the matching documents.
       #
       # @example Perform the bitwise op.
-      #   context.bit(:likes, { and: 14, or: 4 })
+      #   context.bit(likes: { and: 14, or: 4 })
       #
-      # @param [ String, Symbol ] field The name of the field to operate on.
-      # @param [ Hash ] value The bitwise operations to perform. Keys may be
-      #   "and" or "or" and must have numeric values.
+      # @param [ Hash ] bits The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def bit(field, value)
-        query.update_all("$bit" => { database_field_name(field) => value })
+      def bit(bits)
+        query.update_all("$bit" => collect_operations(bits))
       end
 
       # Perform an atomic $inc operation on the matching documents.
       #
       # @example Perform the atomic increment.
-      #   context.inc(:likes, 10)
+      #   context.inc(likes: 10)
       #
-      # @param [ String, Symbol ] field The field to increment.
-      # @param [ Integer ] value The amount to increment by.
+      # @param [ Hash ] incs The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def inc(field, value)
-        query.update_all("$inc" => { database_field_name(field) => value })
+      def inc(incs)
+        query.update_all("$inc" => collect_operations(incs))
       end
 
       # Perform an atomic $pop operation on the matching documents.
       #
       # @example Pop the first value on the matches.
-      #   context.pop(:members, -1)
+      #   context.pop(members: -1)
       #
       # @example Pop the last value on the matches.
-      #   context.pop(:members, 1)
+      #   context.pop(members: 1)
       #
-      # @param [ String, Symbol ] field The name of the array field to pop
-      #   from.
-      # @param [ Integer ] value 1 to pop from the end, -1 to pop from the
-      #   front.
+      # @param [ Hash ] pops The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def pop(field, value)
-        query.update_all("$pop" => { database_field_name(field) => value })
+      def pop(pops)
+        query.update_all("$pop" => collect_operations(pops))
       end
 
       # Perform an atomic $pull operation on the matching documents.
       #
       # @example Pull the value from the matches.
-      #   context.pull(:members, "Dave")
+      #   context.pull(members: "Dave")
       #
       # @note Expression pulling is not yet supported.
       #
-      # @param [ String, Symbol ] field The field to pull from.
-      # @param [ Object ] value The single value to pull.
+      # @param [ Hash ] pulls The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def pull(field, value)
-        query.update_all("$pull" => { database_field_name(field) => value })
+      def pull(pulls)
+        query.update_all("$pull" => collect_operations(pulls))
       end
 
       # Perform an atomic $pullAll operation on the matching documents.
@@ -91,74 +83,73 @@ module Mongoid
       # @example Pull all the matching values from the matches.
       #   context.pull_all(:members, [ "Alan", "Vince" ])
       #
-      # @param [ String, Symbol ] field The field to pull from.
-      # @param [ Array<Object> ] values The values to pull.
+      # @param [ Hash ] pulls The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def pull_all(field, values)
-        query.update_all("$pullAll" => { database_field_name(field) => values })
+      def pull_all(pulls)
+        query.update_all("$pullAll" => collect_operations(pulls))
       end
 
       # Perform an atomic $push operation on the matching documents.
       #
       # @example Push the value to the matching docs.
-      #   context.push(:members, "Alan")
+      #   context.push(members: "Alan")
       #
-      # @param [ String, Symbol ] field The field to push to.
-      # @param [ Object ] value The value to push.
+      # @param [ Hash ] pushes The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def push(field, value)
-        query.update_all("$push" => { database_field_name(field) => value })
+      def push(pushes)
+        query.update_all("$push" => collect_operations(pushes))
       end
 
       # Perform an atomic $pushAll operation on the matching documents.
       #
       # @example Push the values to the matching docs.
-      #   context.push(:members, [ "Alan", "Fletch" ])
+      #   context.push(members: [ "Alan", "Fletch" ])
       #
-      # @param [ String, Symbol ] field The field to push to.
-      # @param [ Array<Object> ] values The values to push.
+      # @param [ Hash ] pushes The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def push_all(field, values)
-        query.update_all("$pushAll" => { database_field_name(field) => values })
+      def push_all(pushes)
+        query.update_all("$pushAll" => collect_operations(pushes))
       end
 
       # Perform an atomic $rename of fields on the matching documents.
       #
       # @example Rename the fields on the matching documents.
-      #   context.rename(:members, :artists)
+      #   context.rename(members: :artists)
       #
-      # @param [ String, Symbol ] old_name The old field name.
-      # @param [ String, Symbol ] new_name The new field name.
+      # @param [ Hash ] renames The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def rename(old_name, new_name)
-        query.update_all("$rename" => { database_field_name(old_name) => new_name.to_s })
+      def rename(renames)
+        operations = renames.inject({}) do |ops, (old_name, new_name)|
+          ops[old_name] = new_name.to_s
+          ops
+        end
+        query.update_all("$rename" => collect_operations(operations))
       end
 
       # Perform an atomic $set of fields on the matching documents.
       #
       # @example Set the field value on the matches.
-      #   context.set(:name, "Depeche Mode")
+      #   context.set(name: "Depeche Mode")
       #
-      # @param [ String, Symbol ] field The name of the field.
-      # @param [ Object ] value The value to set.
+      # @param [ Hash ] sets The operations.
       #
       # @return [ nil ] Nil.
       #
       # @since 3.0.0
-      def set(field, value)
-        query.update_all("$set" => { database_field_name(field) => value })
+      def set(sets)
+        query.update_all("$set" => collect_operations(sets))
       end
 
       # Perform an atomic $unset of a field on the matching documents.
@@ -175,6 +166,15 @@ module Mongoid
         fields = args.__find_args__.collect { |f| [database_field_name(f), true] }
         query.update_all("$unset" => Hash[fields])
       end
+
+      private
+
+      def collect_operations(ops)
+        ops.inject({}) do |operations, (field, value)|
+          operations[database_field_name(field)] = value.mongoize
+          operations
+        end
+      end
     end
   end
 end

data/lib/mongoid/contextual/geo_near.rb

@@ -213,7 +213,7 @@ module Mongoid
       # @since 3.0.0
       def documents
         results["results"].map do |attributes|
-          doc = Factory.from_db(criteria.klass, attributes["obj"], criteria.object_id)
+          doc = Factory.from_db(criteria.klass, attributes["obj"], criteria.options[:fields])
           doc.attributes["geo_near_distance"] = attributes["dis"]
           doc
         end

data/lib/mongoid/contextual/map_reduce.rb

@@ -268,7 +268,9 @@ module Mongoid
       # @since 3.0.0
       def documents
         return results["results"] if results.has_key?("results")
-        session[output_collection].find
+        query = session[output_collection].find
+        query.no_timeout if criteria.options[:timeout] == false
+        query
       end
 
       # Get the collection that the map/reduce results were stored in.
@@ -314,7 +316,7 @@ module Mongoid
       # @since 3.0.15
       def __session__
         if command[:out][:inline] != 1
-          session.with(consistency: :strong)
+          session.with(read: :primary)
         else
           session
         end

data/lib/mongoid/contextual/memory.rb

@@ -1,14 +1,15 @@
 # encoding: utf-8
 require "mongoid/contextual/aggregable/memory"
+require "mongoid/relations/eager"
 
 module Mongoid
   module Contextual
     class Memory
       include Enumerable
       include Aggregable::Memory
-      include Eager
+      include Relations::Eager
       include Queryable
-      include Mongoid::Atomic::Positionable
+      include Positional
 
       # @attribute [r] root The root document.
       # @attribute [r] path The atomic path.
@@ -102,7 +103,7 @@ module Mongoid
           documents_for_iteration.each do |doc|
             yield(doc)
           end
-          # eager_loadable? ? docs : self
+          self
         else
           to_enum
         end
@@ -130,7 +131,7 @@ module Mongoid
       # @since 3.0.0
       def first
         doc = documents.first
-        eager_load_one(doc) if eager_loadable?(doc)
+        eager_load_one(doc)
         doc
       end
       alias :one :first
@@ -164,7 +165,7 @@ module Mongoid
       # @since 3.0.0
       def last
         doc = documents.last
-        eager_load_one(doc) if eager_loadable?(doc)
+        eager_load_one(doc)
         doc
       end
 
@@ -196,6 +197,17 @@ module Mongoid
         self
       end
 
+      def pluck(*fields)
+        fields = Array.wrap(fields)
+        documents.map do |doc|
+          if fields.size == 1
+            doc[fields.first]
+          else
+            fields.map { |n| doc[n] }.compact
+          end
+        end.compact
+      end
+
       # Skips the provided number of documents.
       #
       # @example Skip the documents.
@@ -294,7 +306,7 @@ module Mongoid
           updates["$set"].merge!(doc.atomic_updates["$set"] || {})
           doc.move_changes
         end
-        collection.find(selector).update(updates)
+        collection.find(selector).update(updates) unless updates["$set"].empty?
       end
 
       # Get the limiting value.