mongoid 5.4.1 → 6.1.1

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

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

data/lib/mongoid/contextual/map_reduce.rb

@@ -111,7 +111,6 @@ module Mongoid
       end
 
       # Specifies where the map/reduce output is to be stored.
-      # Please see MongoDB documentation for supported map reduce options.
       #
       # @example Store output in memory.
       #   map_reduce.out(inline: 1)
@@ -125,9 +124,6 @@ module Mongoid
       # @example Store output in a collection, reducing existing documents.
       #   map_reduce.out(reduce: "collection_name")
       #
-      # @example Return results from map reduce.
-      #   map_reduce.out(inline: 1)
-      #
       # @param [ Hash ] location The place to store the results.
       #
       # @return [ MapReduce ] The map/reduce object.

data/lib/mongoid/contextual/memory.rb

@@ -44,7 +44,7 @@ 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(
@@ -148,7 +148,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

data/lib/mongoid/contextual/mongo.rb

@@ -24,6 +24,7 @@ module Mongoid
                   :sort,
                   :batch_size,
                   :max_scan,
+                  :max_time_ms,
                   :snapshot,
                   :comment,
                   :read,
@@ -110,7 +111,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 +236,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,7 +338,7 @@ 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)
         apply_options
@@ -336,18 +351,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
@@ -583,10 +601,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

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

@@ -4,7 +4,9 @@ require "mongoid/criteria/includable"
 require "mongoid/criteria/inspectable"
 require "mongoid/criteria/marshalable"
 require "mongoid/criteria/modifiable"
+require "mongoid/criteria/queryable"
 require "mongoid/criteria/scopable"
+require "mongoid/criteria/options"
 
 module Mongoid
 
@@ -17,7 +19,7 @@ module Mongoid
   class Criteria
     include Enumerable
     include Contextual
-    include Origin::Queryable
+    include Queryable
     include Findable
     include Inspectable
     include Includable
@@ -25,6 +27,7 @@ module Mongoid
     include Modifiable
     include Scopable
     include Clients::Options
+    include Options
 
     # Static array used to check with method missing - we only need to ever
     # instantiate once.
@@ -208,7 +211,7 @@ module Mongoid
     #
     # @example Merge the criteria with a hash. The hash must contain a klass
     #   key and the key/value pairs correspond to method names/args.
-
+    #
     #   criteria.merge({
     #     klass: Band,
     #     where: { name: "Depeche Mode" },

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

@@ -173,7 +173,7 @@ 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)
+          unless invalid_key?(hash, key) || invalid_embedded_doc?(value)
             hash[key] = value
           end
           hash
@@ -216,6 +216,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.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+require "mongoid/criteria/queryable/extensions"
+require "mongoid/criteria/queryable/forwardable"
+require "mongoid/criteria/queryable/key"
+require "mongoid/criteria/queryable/macroable"
+require "mongoid/criteria/queryable/mergeable"
+require "mongoid/criteria/queryable/smash"
+require "mongoid/criteria/queryable/aggregable"
+require "mongoid/criteria/queryable/pipeline"
+require "mongoid/criteria/queryable/optional"
+require "mongoid/criteria/queryable/options"
+require "mongoid/criteria/queryable/selectable"
+require "mongoid/criteria/queryable/selector"
+
+module Mongoid
+  class Criteria
+
+    # A queryable is any object that needs queryable's dsl injected into it to build
+    # MongoDB queries. For example, a Mongoid::Criteria is an Queryable.
+    #
+    # @example Include queryable functionality.
+    #   class Criteria
+    #     include Queryable
+    #   end
+    module Queryable
+      include Mergeable
+      include Aggregable
+      include Selectable
+      include Optional
+
+      # @attribute [r] aliases The aliases.
+      # @attribute [r] driver The Mongo driver being used.
+      # @attribute [r] serializers The serializers.
+      attr_reader :aliases, :driver, :serializers
+
+      # Is this queryable equal to another object? Is true if the selector and
+      # options are equal.
+      #
+      # @example Are the objects equal?
+      #   queryable == criteria
+      #
+      # @param [ Object ] other The object to compare against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 1.0.0
+      def ==(other)
+        return false unless other.is_a?(Queryable)
+        selector == other.selector && options == other.options
+      end
+
+      # Initialize the new queryable. Will yield itself to the block if a block
+      # is provided for objects that need additional behaviour.
+      #
+      # @example Initialize the queryable.
+      #   Queryable.new
+      #
+      # @param [ Hash ] aliases The optional field aliases.
+      # @param [ Hash ] serializers The optional field serializers.
+      # @param [ Symbol ] driver The driver being used.
+      #
+      # @since 1.0.0
+      def initialize(aliases = {}, serializers = {}, driver = :mongo)
+        @aliases, @driver, @serializers = aliases, driver.to_sym, serializers
+        @options = Options.new(aliases, serializers)
+        @selector = Selector.new(aliases, serializers)
+        @pipeline = Pipeline.new(aliases)
+        @aggregating = nil
+        yield(self) if block_given?
+      end
+
+      # Handle the creation of a copy via #clone or #dup.
+      #
+      # @example Handle copy initialization.
+      #   queryable.initialize_copy(criteria)
+      #
+      # @param [ Queryable ] other The original copy.
+      #
+      # @since 1.0.0
+      def initialize_copy(other)
+        @options = other.options.__deep_copy__
+        @selector = other.selector.__deep_copy__
+        @pipeline = other.pipeline.__deep_copy__
+      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