mongoid 5.4.0 → 6.4.8

data/lib/mongoid/composable.rb

@@ -12,6 +12,7 @@ require "mongoid/scopable"
 require "mongoid/serializable"
 require "mongoid/shardable"
 require "mongoid/stateful"
+require "mongoid/cacheable"
 require "mongoid/traversable"
 require "mongoid/validatable"
 
@@ -32,7 +33,6 @@ module Mongoid
     include ActiveModel::Model
     include ActiveModel::ForbiddenAttributesProtection
     include ActiveModel::Serializers::JSON
-    include ActiveModel::Serializers::Xml
     include Atomic
     include Changeable
     include Clients
@@ -50,6 +50,7 @@ module Mongoid
     include Serializable
     include Shardable
     include Stateful
+    include Cacheable
     include Threaded::Lifecycle
     include Traversable
     include Validatable
@@ -74,16 +75,42 @@ module Mongoid
       Scopable,
       Serializable,
       Clients,
+      Clients::Options,
       Shardable,
       Stateful,
+      Cacheable,
       Threaded::Lifecycle,
       Traversable,
       Validatable,
       Equality,
+      Relations::Synchronization,
+      Relations::Macros,
       ActiveModel::Model,
       ActiveModel::Validations
     ]
 
+    # These are methods names defined in included blocks that may conflict
+    # with user-defined relation or field names.
+    # They won't be in the list of Module.instance_methods on which the
+    # #prohibited_methods code below is dependent so we must track them
+    # separately.
+    #
+    # @return [ Array<Symbol> ] A list of reserved method names.
+    #
+    # @since 6.0.0
+    RESERVED_METHOD_NAMES = [ :fields,
+                              :aliased_fields,
+                              :localized_fields,
+                              :index_specifications,
+                              :shard_key_fields,
+                              :nested_attributes,
+                              :readonly_attributes,
+                              :storage_options,
+                              :cascades,
+                              :cyclic,
+                              :cache_timestamp_format
+                            ]
+
     class << self
 
       # Get a list of methods that would be a bad idea to define as field names
@@ -98,7 +125,7 @@ module Mongoid
       def prohibited_methods
         @prohibited_methods ||= MODULES.flat_map do |mod|
           mod.instance_methods.map(&:to_sym)
-        end
+        end + RESERVED_METHOD_NAMES
       end
     end
   end

data/lib/mongoid/config.rb

@@ -25,6 +25,7 @@ module Mongoid
     option :use_activesupport_time_zone, default: true
     option :use_utc, default: false
     option :log_level, default: :info
+    option :belongs_to_required_by_default, default: true
     option :app_name, default: nil
 
     # Has Mongoid been configured? This is checking that at least a valid

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

@@ -23,7 +23,7 @@ module Mongoid
         #
         # @since 3.0.0
         def aggregates(field)
-          result = collection.find.aggregate(pipeline(field)).to_a
+          result = collection.find.aggregate(pipeline(field), session: _session).to_a
           if result.empty?
             { "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil }
           else

data/lib/mongoid/contextual/atomic.rb

@@ -109,16 +109,16 @@ module Mongoid
       # Perform an atomic $push/$each operation on the matching documents.
       #
       # @example Push the values to the matching docs.
-      #   context.push_each(members: [ "Alan", "Fletch" ])
+      #   context.push_all(members: [ "Alan", "Fletch" ])
       #
       # @param [ Hash ] pushes The operations.
       #
       # @return [ nil ] Nil.
       #
-      # @since 5.4.0
-      def push_each(pushes)
+      # @since 3.0.0
+      def push_all(pushes)
         push_each_updates = collect_operations(pushes).each.inject({}) do |ops, (field, elements)|
-          ops.merge!(field => { '$each' => elements })
+          ops.merge!(field => {'$each' => elements})
         end
         view.update_many("$push" => push_each_updates)
       end

data/lib/mongoid/contextual/map_reduce.rb

@@ -165,13 +165,13 @@ module Mongoid
       def raw
         validate_out!
         cmd = command
-        opts = { read: cmd.delete(:read).options } if cmd[:read]
-        @map_reduce.database.command(cmd, opts || {}).first
+        opts = { read: cmd.delete(:read) } if cmd[:read]
+        @map_reduce.database.command(cmd, (opts || {}).merge(session: _session)).first
       end
       alias :results :raw
 
       # Execute the map/reduce, returning the raw output.
-      # Useful when you don't care about map/reduce's ouptut.
+      # Useful when you don't care about map/reduce's output.
       #
       # @example Run the map reduce
       #   map_reduce.execute
@@ -249,6 +249,10 @@ module Mongoid
       def validate_out!
         raise Errors::NoMapReduceOutput.new({}) unless @map_reduce.out
       end
+
+      def _session
+        criteria.send(:_session)
+      end
     end
   end
 end

data/lib/mongoid/contextual/memory.rb

@@ -44,11 +44,12 @@ module Mongoid
         deleted = count
         removed = map do |doc|
           prepare_remove(doc)
-          doc.as_document
+          doc.send(:as_attributes)
         end
         unless removed.empty?
           collection.find(selector).update_one(
-            positionally(selector, "$pullAll" => { path => removed })
+            positionally(selector, "$pullAll" => { path => removed }),
+            session: _session
           )
         end
         deleted
@@ -148,7 +149,7 @@ module Mongoid
         @documents = criteria.documents.select do |doc|
           @root ||= doc._root
           @collection ||= root.collection
-          doc.matches?(criteria.selector)
+          doc._matches?(criteria.selector)
         end
         apply_sorting
         apply_options
@@ -303,7 +304,7 @@ module Mongoid
           updates["$set"].merge!(doc.atomic_updates["$set"] || {})
           doc.move_changes
         end
-        collection.find(selector).update_one(updates) unless updates["$set"].empty?
+        collection.find(selector).update_one(updates, session: _session) unless updates["$set"].empty?
       end
 
       # Get the limiting value.
@@ -444,6 +445,10 @@ module Mongoid
         doc._parent.remove_child(doc)
         doc.destroyed = true
       end
+
+      def _session
+        @criteria.send(:_session)
+      end
     end
   end
 end

data/lib/mongoid/contextual/mongo.rb

@@ -24,6 +24,7 @@ module Mongoid
                   :sort,
                   :batch_size,
                   :max_scan,
+                  :max_time_ms,
                   :snapshot,
                   :comment,
                   :read,
@@ -94,7 +95,8 @@ module Mongoid
       def destroy
         each.inject(0) do |count, doc|
           doc.destroy
-          count += 1
+          count += 1 if acknowledged_write?
+          count
         end
       end
       alias :destroy_all :destroy
@@ -110,7 +112,9 @@ module Mongoid
       #
       # @since 3.0.0
       def distinct(field)
-        view.distinct(klass.database_field_name(field))
+        view.distinct(klass.database_field_name(field)).map do |value|
+          value.class.demongoize(value)
+        end
       end
 
       # Iterate over the context. If provided a block, yield to a Mongoid
@@ -233,21 +237,33 @@ module Mongoid
       # @example Get the first document.
       #   context.first
       #
-      # @note Mongoid previously added an _id sort when no sort parameters were
-      #   provided explicitly by the user. This caused bad performance issues
-      #   and was not expected, so #first/#last will no longer guarantee order
-      #   if no sorting parameters are provided. For order guarantees - a sort
-      #   must be explicitly provided.
+      # @note Automatically adding a sort on _id when no other sort is
+      #   defined on the criteria has the potential to cause bad performance issues.
+      #   If you experience unexpected poor performance when using #first or #last
+      #   and have no sort defined on the criteria, use the option { id_sort: :none }.
+      #   Be aware that #first/#last won't guarantee order in this case.
+      #
+      # @param [ Hash ] opts The options for the query returning the first document.
+      #
+      # @option opts [ :none ] :id_sort Don't apply a sort on _id if no other sort
+      #   is defined on the criteria.
       #
       # @return [ Document ] The first document.
       #
       # @since 3.0.0
-      def first
+      def first(opts = {})
         return documents.first if cached? && cache_loaded?
         try_cache(:first) do
-          if raw_doc = view.limit(-1).first
-            doc = Factory.from_db(klass, raw_doc, criteria.options[:fields])
-            eager_load([doc]).first
+          if sort = view.sort || ({ _id: 1 } unless opts[:id_sort] == :none)
+            if raw_doc = view.sort(sort).limit(-1).first
+              doc = Factory.from_db(klass, raw_doc, criteria.options[:fields])
+              eager_load([doc]).first
+            end
+          else
+            if raw_doc = view.limit(-1).first
+              doc = Factory.from_db(klass, raw_doc, criteria.options[:fields])
+              eager_load([doc]).first
+            end
           end
         end
       end
@@ -323,9 +339,9 @@ module Mongoid
       # @since 3.0.0
       def initialize(criteria)
         @criteria, @klass, @cache = criteria, criteria.klass, criteria.options[:cache]
-        @collection = @klass.with(criteria.persistence_options || {}).collection
+        @collection = @klass.collection
         criteria.send(:merge_type_selection)
-        @view = collection.find(criteria.selector)
+        @view = collection.find(criteria.selector, session: _session)
         apply_options
       end
 
@@ -336,18 +352,21 @@ module Mongoid
       # @example Get the last document.
       #   context.last
       #
-      # @note Mongoid previously added an _id sort when no sort parameters were
-      #   provided explicitly by the user. This caused bad performance issues
-      #   and was not expected, so #first/#last will no longer guarantee order
-      #   if no sorting parameters are provided. For order guarantees - a sort
-      #   must be explicitly provided.
+      # @note Automatically adding a sort on _id when no other sort is
+      #   defined on the criteria has the potential to cause bad performance issues.
+      #   If you experience unexpected poor performance when using #first or #last
+      #   and have no sort defined on the criteria, use the option { id_sort: :none }.
+      #   Be aware that #first/#last won't guarantee order in this case.
+      #
+      # @param [ Hash ] opts The options for the query returning the first document.
       #
-      # @return [ Document ] The last document.
+      # @option opts [ :none ] :id_sort Don't apply a sort on _id if no other sort
+      #   is defined on the criteria.
       #
       # @since 3.0.0
-      def last
+      def last(opts = {})
         try_cache(:last) do
-          with_inverse_sorting do
+          with_inverse_sorting(opts) do
             if raw_doc = view.limit(-1).first
               doc = Factory.from_db(klass, raw_doc, criteria.options[:fields])
               eager_load([doc]).first
@@ -468,12 +487,16 @@ module Mongoid
       #   context.update({ "$set" => { name: "Smiths" }})
       #
       # @param [ Hash ] attributes The new attributes for the document.
+      # @param [ Hash ] opts The update operation options.
+      #
+      # @option opts [ Array ] :array_filters A set of filters specifying to which array elements
+      #   an update should apply.
       #
       # @return [ nil, false ] False if no attributes were provided.
       #
       # @since 3.0.0
-      def update(attributes = nil)
-        update_documents(attributes)
+      def update(attributes = nil, opts = {})
+        update_documents(attributes, :update_one, opts)
       end
 
       # Update all the matching documents atomically.
@@ -482,12 +505,16 @@ module Mongoid
       #   context.update_all({ "$set" => { name: "Smiths" }})
       #
       # @param [ Hash ] attributes The new attributes for each document.
+      # @param [ Hash ] opts The update operation options.
+      #
+      # @option opts [ Array ] :array_filters A set of filters specifying to which array elements
+      #   an update should apply.
       #
       # @return [ nil, false ] False if no attributes were provided.
       #
       # @since 3.0.0
-      def update_all(attributes = nil)
-        update_documents(attributes, :update_many)
+      def update_all(attributes = nil, opts = {})
+        update_documents(attributes, :update_many, opts)
       end
 
       private
@@ -523,10 +550,10 @@ module Mongoid
       # @return [ true, false ] If the update succeeded.
       #
       # @since 3.0.4
-      def update_documents(attributes, method = :update_one)
+      def update_documents(attributes, method = :update_one, opts = {})
         return false unless attributes
         attributes = Hash[attributes.map { |k, v| [klass.database_field_name(k.to_s), v] }]
-        view.send(method, attributes.__consolidate__(klass))
+        view.send(method, attributes.__consolidate__(klass), opts)
       end
 
       # Apply the field limitations.
@@ -583,10 +610,10 @@ module Mongoid
       #   context.with_inverse_sorting
       #
       # @since 3.0.0
-      def with_inverse_sorting
+      def with_inverse_sorting(opts = {})
         begin
-          if spec = criteria.options[:sort]
-            @view = view.sort(Hash[spec.map{|k, v| [k, -1*v]}])
+          if sort = criteria.options[:sort] || ( { _id: 1 } unless opts[:id_sort] == :none )
+            @view = view.sort(Hash[sort.map{|k, v| [k, -1*v]}])
           end
           yield
         ensure
@@ -678,6 +705,14 @@ module Mongoid
         yield(doc)
         documents.push(doc) if cacheable?
       end
+
+      def _session
+        @criteria.send(:_session)
+      end
+
+      def acknowledged_write?
+        collection.write_concern.nil? || collection.write_concern.acknowledged?
+      end
     end
   end
 end

data/lib/mongoid/contextual/none.rb

@@ -21,6 +21,18 @@ module Mongoid
         other.is_a?(None)
       end
 
+      # Allow distinct for null context.
+      #
+      # @example Get the distinct values.
+      #   context.distinct(:name)
+      #
+      # @param [ String, Symbol ] field the name of the field.
+      #
+      # @return [ Array ] Empty Array
+      def distinct(field)
+        []
+      end
+
       # Iterate over the null context. There are no documents to iterate over
       # in this case.
       #

data/lib/mongoid/copyable.rb

@@ -20,11 +20,18 @@ module Mongoid
       # _id and id field in the document would cause problems with Mongoid
       # elsewhere.
       attrs = clone_document.except("_id", "id")
-      begin
-        self.class.new(attrs)
-      rescue Errors::UnknownAttribute
-        self.class.send(:include, Attributes::Dynamic)
-        self.class.new(attrs)
+      dynamic_attrs = {}
+      attrs.reject! do |attr_name, value|
+        dynamic_attrs.merge!(attr_name => value) unless self.attribute_names.include?(attr_name)
+      end
+      self.class.new(attrs).tap do |object|
+        dynamic_attrs.each do |attr_name, value|
+          if object.respond_to?("#{attr_name}=")
+            object.send("#{attr_name}=", value)
+          else
+            object.attributes[attr_name] = value
+          end
+        end
       end
     end
     alias :dup :clone
@@ -40,7 +47,7 @@ module Mongoid
     #
     # @since 3.0.22
     def clone_document
-      attrs = as_document.__deep_copy__
+      attrs = as_attributes.__deep_copy__
       process_localized_attributes(self, attrs)
       attrs
     end

data/lib/mongoid/criteria/marshalable.rb

@@ -27,8 +27,8 @@ module Mongoid
       def marshal_load(data)
         @scoping_options, raw_selector, raw_options = data.pop(3)
         @klass, @driver, @inclusions, @documents, @strategy, @negating = data
-        @selector = load_hash(Origin::Selector, raw_selector)
-        @options = load_hash(Origin::Options, raw_options)
+        @selector = load_hash(Queryable::Selector, raw_selector)
+        @options = load_hash(Queryable::Options, raw_options)
       end
 
       private

data/lib/mongoid/criteria/modifiable.rb

@@ -3,6 +3,10 @@ module Mongoid
   class Criteria
     module Modifiable
 
+      # @attribute [r] create_attrs Additional attributes to add to the Document upon creation.
+      # @api private
+      attr_reader :create_attrs
+
       # Build a document given the selector and return it.
       # Complex criteria, such as $in and $or operations will get ignored.
       #
@@ -57,6 +61,9 @@ module Mongoid
 
       # Define attributes with which new documents will be created.
       #
+      # Note that if `find_or_create_by` is called after this in a method chain, the attributes in
+      # the query will override those from this method.
+      #
       # @example Define attributes to be used when a new document is created.
       #   Person.create_with(job: 'Engineer').find_or_create_by(employer: 'MongoDB')
       #
@@ -64,7 +71,9 @@ module Mongoid
       #
       # @since 5.1.0
       def create_with(attrs = {})
-        where(selector.merge(attrs))
+        tap do
+          (@create_attrs ||= {}).merge!(attrs)
+        end
       end
 
       # Find the first +Document+ given the conditions, or creates a new document
@@ -172,8 +181,9 @@ module Mongoid
       #
       # @since 3.0.0
       def create_document(method, attrs = nil, &block)
-        attributes = selector.reduce(attrs ? attrs.dup : {}) do |hash, (key, value)|
-          unless key.to_s =~ /\$/ || value.is_a?(Hash)
+        attrs = (create_attrs || {}).merge(attrs || {})
+        attributes = selector.reduce(attrs) do |hash, (key, value)|
+          unless invalid_key?(hash, key) || invalid_embedded_doc?(value)
             hash[key] = value
           end
           hash
@@ -216,6 +226,22 @@ module Mongoid
       def first_or(method, attrs = {}, &block)
         first || create_document(method, attrs, &block)
       end
+
+      private
+
+      def invalid_key?(hash, key)
+        # @todo Change this to BSON::String::ILLEGAL_KEY when ruby driver 2.3.0 is
+        # released and mongoid is updated to depend on driver >= 2.3.0
+        key.to_s =~ Mongoid::Document::ILLEGAL_KEY || hash.key?(key.to_sym) || hash.key?(key)
+      end
+
+      def invalid_embedded_doc?(value)
+        # @todo Change this to BSON::String::ILLEGAL_KEY when ruby driver 2.3.0 is
+        # released and mongoid is updated to depend on driver >= 2.3.0
+        value.is_a?(Hash) && value.any? do |key, v|
+          key.to_s =~ Mongoid::Document::ILLEGAL_KEY || invalid_embedded_doc?(v)
+        end
+      end
     end
   end
 end

data/lib/mongoid/criteria/options.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+
+    # Module containing functionality for getting options on a Criteria object.
+    #
+    # @since 6.0.0
+    module Options
+
+      private
+
+      def persistence_context
+        klass.persistence_context
+      end
+
+      def set_persistence_context(options)
+        PersistenceContext.set(klass, options)
+      end
+
+      def clear_persistence_context(original_cluster)
+        PersistenceContext.clear(klass, original_cluster)
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable/aggregable.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # Provides a DSL around crafting aggregation framework commands.
+      #
+      # @since 2.0.0
+      module Aggregable
+        extend Macroable
+
+        # @attribute [r] pipeline The aggregation pipeline.
+        attr_reader :pipeline
+
+        # @attribute [rw] aggregating Flag for whether or not we are aggregating.
+        attr_writer :aggregating
+
+        # Has the aggregable enter an aggregation state. Ie, are only aggregation
+        # operations allowed at this point on.
+        #
+        # @example Is the aggregable aggregating?
+        #   aggregable.aggregating?
+        #
+        # @return [ true, false ] If the aggregable is aggregating.
+        #
+        # @since 2.0.0
+        def aggregating?
+          !!@aggregating
+        end
+
+        # Add a group ($group) operation to the aggregation pipeline.
+        #
+        # @example Add a group operation being verbose.
+        #   aggregable.group(count: { "$sum" => 1 }, max: { "$max" => "likes" })
+        #
+        # @example Add a group operation using symbol shortcuts.
+        #   aggregable.group(:count.sum => 1, :max.max => "likes")
+        #
+        # @param [ Hash ] operation The group operation.
+        #
+        # @return [ Aggregable ] The aggregable.
+        #
+        # @since 2.0.0
+        def group(operation)
+          aggregation(operation) do |pipeline|
+            pipeline.group(operation)
+          end
+        end
+        key :avg, :override, "$avg"
+        key :max, :override, "$max"
+        key :min, :override, "$min"
+        key :sum, :override, "$sum"
+        key :last, :override, "$last"
+        key :push, :override, "$push"
+        key :first, :override, "$first"
+        key :add_to_set, :override, "$addToSet"
+
+        # Add a projection ($project) to the aggregation pipeline.
+        #
+        # @example Add a projection to the pipeline.
+        #   aggregable.project(author: 1, name: 0)
+        #
+        # @param [ Hash ] operation The projection to make.
+        #
+        # @return [ Aggregable ] The aggregable.
+        #
+        # @since 2.0.0
+        def project(operation = nil)
+          aggregation(operation) do |pipeline|
+            pipeline.project(operation)
+          end
+        end
+
+        # Add an unwind ($unwind) to the aggregation pipeline.
+        #
+        # @example Add an unwind to the pipeline.
+        #   aggregable.unwind(:field)
+        #
+        # @param [ String, Symbol ] field The name of the field to unwind.
+        #
+        # @return [ Aggregable ] The aggregable.
+        #
+        # @since 2.0.0
+        def unwind(field)
+          aggregation(field) do |pipeline|
+            pipeline.unwind(field)
+          end
+        end
+
+        private
+
+        # Add the aggregation operation.
+        #
+        # @api private
+        #
+        # @example Aggregate on the operation.
+        #   aggregation(operation) do |pipeline|
+        #     pipeline.push("$project" => operation)
+        #   end
+        #
+        # @param [ Hash ] operation The operation for the pipeline.
+        #
+        # @return [ Aggregable ] The cloned aggregable.
+        #
+        # @since 2.0.0
+        def aggregation(operation)
+          return self unless operation
+          clone.tap do |query|
+            unless aggregating?
+              query.pipeline.concat(query.selector.to_pipeline)
+              query.pipeline.concat(query.options.to_pipeline)
+              query.aggregating = true
+            end
+            yield(query.pipeline)
+          end
+        end
+      end
+    end
+  end
+end