mongoid 3.1.6 → 4.0.2

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/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/contextual.rb

@@ -2,6 +2,7 @@
 require "mongoid/contextual/queryable"
 require "mongoid/contextual/mongo"
 require "mongoid/contextual/memory"
+require "mongoid/contextual/none"
 
 module Mongoid
   module Contextual
@@ -48,6 +49,7 @@ module Mongoid
     #
     # @since 3.0.0
     def create_context
+      return None.new(self) if empty_and_chainable?
       embedded ? Memory.new(self) : Mongo.new(self)
     end
   end

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

@@ -81,7 +81,7 @@ module Mongoid
           if block_given?
             super()
           else
-            count > 0 ? super(0) { |doc| doc.send(field) } : 0
+            count > 0 ? super(0) { |doc| doc.public_send(field) } : 0
           end
         end
 
@@ -101,7 +101,7 @@ module Mongoid
         #
         # @since 3.0.0
         def aggregate_by(field, method)
-          count > 0 ? send(method) { |doc| doc.send(field) }.send(field) : nil
+          count > 0 ? send(method) { |doc| doc.public_send(field) }.public_send(field) : nil
         end
       end
     end

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,10 +131,11 @@ 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
+      alias :find_first :first
 
       # Create the new in memory context.
       #
@@ -164,7 +166,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 +198,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 +307,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.
@@ -409,12 +422,11 @@ module Mongoid
       #
       # @since 3.0.0
       def in_place_sort(values)
-        values.keys.reverse.each do |field|
-          documents.sort! do |a, b|
+        documents.sort! do |a, b|
+          values.map do |field, direction|
             a_value, b_value = a[field], b[field]
-            value = compare(a_value.__sortable__, b_value.__sortable__)
-            values[field] < 0 ? value * -1 : value
-          end
+            direction * compare(a_value.__sortable__, b_value.__sortable__)
+          end.find { |value| !value.zero? } || 0
         end
       end