mongoid 3.1.7 → 4.0.2

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
 

data/lib/mongoid/contextual/mongo.rb

@@ -2,10 +2,11 @@
 require "mongoid/contextual/atomic"
 require "mongoid/contextual/aggregable/mongo"
 require "mongoid/contextual/command"
-require "mongoid/contextual/eager"
 require "mongoid/contextual/find_and_modify"
 require "mongoid/contextual/geo_near"
 require "mongoid/contextual/map_reduce"
+require "mongoid/contextual/text_search"
+require "mongoid/relations/eager"
 
 module Mongoid
   module Contextual
@@ -13,7 +14,7 @@ module Mongoid
       include Enumerable
       include Aggregable::Mongo
       include Atomic
-      include Eager
+      include Relations::Eager
       include Queryable
 
       # @attribute [r] query The Moped query.
@@ -53,10 +54,10 @@ module Mongoid
       def count(document = false, &block)
         return super(&block) if block_given?
         if document.is_a?(Document)
-          return collection.find(criteria.and(_id: document.id).selector).count
+          return collection.find(criteria.and(_id: document._id).selector).count
         end
         return query.count(document) if document
-        cached? ? @count ||= query.count : query.count
+        try_cache(:count) { query.count }
       end
 
       # Delete all documents in the database that match the selector.
@@ -118,13 +119,11 @@ module Mongoid
       # @since 3.0.0
       def each(&block)
         if block_given?
-          selecting do
-            documents_for_iteration.each do |doc|
-              yield_document(doc, &block)
-            end
-            @cache_loaded = true
-            eager_loadable? ? docs : self
+          documents_for_iteration.each do |doc|
+            yield_document(doc, &block)
           end
+          @cache_loaded = true
+          self
         else
           to_enum
         end
@@ -143,7 +142,12 @@ module Mongoid
       #
       # @since 3.0.0
       def exists?
-        @exists ||= check_existence
+        return !documents.empty? if cached? && cache_loaded?
+        return @count > 0 if instance_variable_defined?(:@count)
+
+        try_cache(:exists) do
+          !!(query.dup.select(_id: 1).limit(1).first)
+        end
       end
 
       # Run an explain on the criteria.
@@ -189,9 +193,8 @@ module Mongoid
       #
       # @since 3.0.0
       def first
-        if cached? && cache_loaded?
-          documents.first
-        else
+        return documents.first if cached? && cache_loaded?
+        try_cache(:first) do
           with_sorting do
             with_eager_loading(query.first)
           end
@@ -199,6 +202,16 @@ module Mongoid
       end
       alias :one :first
 
+      # Return the first result without applying sort
+      #
+      # @api private
+      #
+      # @since 4.0.2
+      def find_first
+        return documents.first if cached? && cache_loaded?
+        with_eager_loading(query.first)
+      end
+
       # Execute a $geoNear command against the database.
       #
       # @example Find documents close to 10, 10.
@@ -257,7 +270,7 @@ module Mongoid
       # @since 3.0.0
       def initialize(criteria)
         @criteria, @klass, @cache = criteria, criteria.klass, criteria.options[:cache]
-        @collection = klass.collection
+        @collection = @klass.with(criteria.persistence_options || {}).collection
         criteria.send(:merge_type_selection)
         @query = collection.find(criteria.selector)
         apply_options
@@ -274,8 +287,10 @@ module Mongoid
       #
       # @since 3.0.0
       def last
-        with_inverse_sorting do
-          with_eager_loading(query.first)
+        try_cache(:last) do
+          with_inverse_sorting do
+            with_eager_loading(query.first)
+          end
         end
       end
 
@@ -330,14 +345,24 @@ module Mongoid
       # @note This method will return the raw db values - it performs no custom
       #   serialization.
       #
-      # @param [ String, Symbol ] field The field to pluck.
+      # @param [ String, Symbol, Array ] field Fields to pluck.
       #
-      # @return [ Array<Object> ] The plucked values.
+      # @return [ Array<Object, Array> ] The plucked values.
       #
       # @since 3.1.0
-      def pluck(field)
-        normalized = klass.database_field_name(field)
-        query.dup.select(normalized => 1).map{ |doc| doc[normalized] }.compact
+      def pluck(*fields)
+        normalized_select = fields.inject({}) do |hash, f|
+          hash[klass.database_field_name(f)] = 1
+          hash
+        end
+
+        query.dup.select(normalized_select).map do |doc|
+          if normalized_select.size == 1
+            doc[normalized_select.keys.first]
+          else
+            normalized_select.keys.map { |n| doc[n] }
+          end
+        end
       end
 
       # Skips the provided number of documents.
@@ -376,6 +401,20 @@ module Mongoid
         end
       end
 
+      # Execute a text command against the database.
+      #
+      # @example Find documents with the text "phase"
+      #   context.text_search("phase")
+      #
+      # @param [ String ] query The text search query.
+      #
+      # @return [ TextSearch ] The TextSearch command.
+      #
+      # @since 4.0.0
+      def text_search(query)
+        TextSearch.new(collection, criteria, query)
+      end
+
       # Update the first matching document atomically.
       #
       # @example Update the first matching document.
@@ -393,7 +432,7 @@ module Mongoid
       # Update all the matching documents atomically.
       #
       # @example Update all the matching documents.
-      #   context.update({ "$set" => { name: "Smiths" }})
+      #   context.update_all({ "$set" => { name: "Smiths" }})
       #
       # @param [ Hash ] attributes The new attributes for each document.
       #
@@ -406,21 +445,21 @@ module Mongoid
 
       private
 
-      # Checks if any documents exist in the database.
-      #
-      # @api private
+      # yield the block given or return the cached value
       #
-      # @example Check for document existsence.
-      #   context.check_existence
+      # @param [ String, Symbol ] key The instance variable name
       #
-      # @return [ true, false ] If documents exist.
+      # @return the result of the block
       #
-      # @since 3.1.0
-      def check_existence
-        if cached? && cache_loaded?
-          !documents.empty?
+      # @since 3.1.4
+      def try_cache(key, &block)
+        unless cached?
+          yield
         else
-          @count ? @count > 0 : !query.dup.select(_id: 1).limit(1).entries.first.nil?
+          unless ret = instance_variable_get("@#{key}")
+            instance_variable_set("@#{key}", ret = yield)
+          end
+          ret
         end
       end
 
@@ -593,7 +632,7 @@ module Mongoid
         if cached? && !documents.empty?
           documents
         elsif eager_loadable?
-          docs = query.map{ |doc| Factory.from_db(klass, doc) }
+          docs = query.map{ |doc| Factory.from_db(klass, doc, criteria.options[:fields]) }
           eager_load(docs)
           docs
         else
@@ -601,27 +640,6 @@ module Mongoid
         end
       end
 
-      # If we are limiting results, we need to set the field limitations on a
-      # thread local to avoid overriding the default values.
-      #
-      # @example Execute with selection.
-      #   context.selecting do
-      #     collection.find
-      #   end
-      #
-      # @return [ Object ] The yielded value.
-      #
-      # @since 2.4.4
-      def selecting
-        begin
-          fields = criteria.options[:fields]
-          Threaded.set_selection(criteria.object_id, fields) unless fields.blank?
-          yield
-        ensure
-          Threaded.delete_selection(criteria.object_id)
-        end
-      end
-
       # Yield to the document.
       #
       # @api private
@@ -636,7 +654,7 @@ module Mongoid
       # @since 3.0.0
       def yield_document(document, &block)
         doc = document.respond_to?(:_id) ?
-          document : Factory.from_db(klass, document, criteria.object_id)
+          document : Factory.from_db(klass, document, criteria.options[:fields])
         yield(doc)
         documents.push(doc) if cacheable?
       end

data/lib/mongoid/contextual/none.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    class None
+      include Enumerable
+      include Queryable
+
+      attr_reader :criteria, :klass
+
+      # Check if the context is equal to the other object.
+      #
+      # @example Check equality.
+      #   context == []
+      #
+      # @param [ Array ] other The other array.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 4.0.0
+      def ==(other)
+        other.is_a?(None)
+      end
+
+      # Iterate over the null context. There are no documents to iterate over
+      # in this case.
+      #
+      # @example Iterate over the context.
+      #   context.each do |doc|
+      #     puts doc.name
+      #   end
+      #
+      # @return [ Enumerator ] The enumerator.
+      #
+      # @since 4.0.0
+      def each
+        if block_given?
+          [].each { |doc| yield(doc) }
+          self
+        else
+          to_enum
+        end
+      end
+
+      # Do any documents exist for the context.
+      #
+      # @example Do any documents exist for the context.
+      #   context.exists?
+      #
+      # @return [ true, false ] If the count is more than zero.
+      #
+      # @since 4.0.0
+      def exists?; false; end
+
+      # Create the new null context.
+      #
+      # @example Create the new context.
+      #   Null.new(criteria)
+      #
+      # @param [ Criteria ] The criteria.
+      #
+      # @since 4.0.0
+      def initialize(criteria)
+        @criteria, @klass = criteria, criteria.klass
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the last document.
+      #   context.last
+      #
+      # @return [ nil ] Always nil.
+      #
+      # @since 4.0.0
+      def last; nil; end
+
+      # Always returns zero.
+      #
+      # @example Get the length of matching documents.
+      #   context.length
+      #
+      # @return [ Integer ] Always zero.
+      #
+      # @since 4.0.0
+      def length
+        entries.length
+      end
+      alias :size :length
+    end
+  end
+end