mongoid 7.4.0 → 8.0.1

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

@@ -154,7 +154,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :elem_match
           end
 
-          __override__(criterion, "$elemMatch")
+          and_or_override(criterion, "$elemMatch")
         end
         key :elem_match, :override, "$elemMatch"
 
@@ -227,19 +227,6 @@ module Mongoid
           __merge__(criterion)
         end
 
-        # Alias for +geo_spatial+.
-        #
-        # @deprecated
-        def geo_spacial(criterion)
-          # Duplicate method body so that we can raise this exception with
-          # geo_spacial as the indicated operator rather than geo_spatial.
-          if criterion.nil?
-            raise Errors::CriteriaArgumentRequired, :geo_spacial
-          end
-
-          __merge__(criterion)
-        end
-
         key :intersects_line, :override, "$geoIntersects", "$geometry" do |value|
           { "type" => LINE_STRING, "coordinates" => value }
         end
@@ -270,7 +257,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :eq
           end
 
-          __override__(criterion, "$eq")
+          and_or_override(criterion, "$eq")
         end
         key :eq, :override, "$eq"
 
@@ -290,7 +277,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :gt
           end
 
-          __override__(criterion, "$gt")
+          and_or_override(criterion, "$gt")
         end
         key :gt, :override, "$gt"
 
@@ -310,7 +297,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :gte
           end
 
-          __override__(criterion, "$gte")
+          and_or_override(criterion, "$gte")
         end
         key :gte, :override, "$gte"
 
@@ -366,7 +353,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :lt
           end
 
-          __override__(criterion, "$lt")
+          and_or_override(criterion, "$lt")
         end
         key :lt, :override, "$lt"
 
@@ -386,7 +373,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :lte
           end
 
-          __override__(criterion, "$lte")
+          and_or_override(criterion, "$lte")
         end
         key :lte, :override, "$lte"
 
@@ -423,7 +410,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :mod
           end
 
-          __override__(criterion, "$mod")
+          and_or_override(criterion, "$mod")
         end
         key :mod, :override, "$mod"
 
@@ -443,7 +430,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :ne
           end
 
-          __override__(criterion, "$ne")
+          and_or_override(criterion, "$ne")
         end
         alias :excludes :ne
         key :ne, :override, "$ne"
@@ -464,7 +451,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :near
           end
 
-          __override__(criterion, "$near")
+          and_or_override(criterion, "$near")
         end
         key :near, :override, "$near"
 
@@ -484,7 +471,7 @@ module Mongoid
             raise Errors::CriteriaArgumentRequired, :near_sphere
           end
 
-          __override__(criterion, "$nearSphere")
+          and_or_override(criterion, "$nearSphere")
         end
         key :near_sphere, :override, "$nearSphere"
 
@@ -679,16 +666,7 @@ module Mongoid
                 end]
               end
             end
-            # Should be able to do:
-            #where('$or' => exprs)
-            # But since that is broken do instead:
-            clone.tap do |query|
-              if query.selector['$or']
-                query.selector.store('$or', query.selector['$or'] + exprs)
-              else
-                query.selector.store('$or', exprs)
-              end
-            end
+            self.and('$or' => exprs)
           end
         end
 
@@ -874,7 +852,7 @@ module Mongoid
         # @param [ Hash ] criterion The criterion.
         def typed_override(criterion, operator)
           if criterion
-            criterion.update_values do |value|
+            criterion.transform_values! do |value|
               yield(value)
             end
           end
@@ -924,6 +902,22 @@ module Mongoid
           end
         end
 
+        # Combine operator expessions onto a Criteria using either
+        # an override or ands depending on the status of the
+        # Mongoid.overwrite_chained_operators feature flag.
+        #
+        # @param [ Hash ] The criterion to add to the criteria.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Criteria ] The resulting criteria.
+        def and_or_override(criterion, operator)
+          if Mongoid.overwrite_chained_operators
+            __override__(criterion, operator)
+          else
+            and_with_operator(criterion, operator)
+          end
+        end
+
         class << self
 
           # Get the methods on the selectable that can be forwarded to from a model.

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

@@ -53,8 +53,7 @@ module Mongoid
             store_name = name
             store_value = evolve_multi(value)
           else
-            store_name = localized_key(name, serializer)
-            store_value = evolve(serializer, value)
+            store_name, store_value = store_creds(name, serializer, value)
           end
           super(store_name, store_value)
         end
@@ -74,6 +73,24 @@ module Mongoid
 
         private
 
+        # Get the store name and store value. If the value is of type range,
+        # we need may need to change the store_name as well as the store_value,
+        # therefore, we cannot just use the evole method.
+        #
+        # @param [ String ] name The name of the field.
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Object ] value The value to serialize.
+        #
+        # @return [ Array<String, String> ] The store name and store value.
+        def store_creds(name, serializer, value)
+          store_name = localized_key(name, serializer)
+          if Range === value
+            evolve_range(store_name, serializer, value)
+          else
+            [ store_name, evolve(serializer, value) ]
+          end
+        end
+
         # Evolves a multi-list selection, like an $and or $or criterion, and
         # performs the necessary serialization.
         #
@@ -103,11 +120,10 @@ module Mongoid
               # some reason, although per its documentation Smash supposedly
               # owns both.
               name, serializer = storage_pair(key)
-              final_key = localized_key(name, serializer)
               # This performs type conversions on the value and transformations
               # that depend on the type of the field that the value is stored
               # in, but not transformations that have to do with query shape.
-              evolved_value = evolve(serializer, value)
+              final_key, evolved_value = store_creds(name, serializer, value)
 
               # This builds a query shape around the value, when the query
               # involves complex keys. For example, {:foo.lt => 5} produces
@@ -139,6 +155,8 @@ module Mongoid
             evolve_hash(serializer, value)
           when Array
             evolve_array(serializer, value)
+          when Range
+            value.__evolve_range__(serializer: serializer)
           else
             (serializer || value.class).evolve(value)
           end
@@ -182,6 +200,73 @@ module Mongoid
           end
         end
 
+        # Evolve a single key selection with range values. This method traverses
+        # the association tree to build a query for the given value and
+        # serializer. There are three parts to the query here:
+        #
+        # (1) "klass.child.gchild" => {
+        #       "$elemMatch" => {
+        #     (2) "ggchild.field" => (3) { "$gte" => 6, "$lte" => 10 }
+        #       }
+        #     }
+        # (1) The first n fields are dotted together until the last
+        #     embeds_many or field of type array. In the above case, gchild
+        #     would be an embeds_many or Array, and ggchild would be an
+        #     embeds_one or a hash.
+        # (2) The last fields are used inside the $elemMatch. This one is
+        #     actually optional, and will be ignored if the last field is an
+        #     array or embeds_many. If the last field is an array (1), (2) and
+        #     (3) will look like:
+        #
+        #       "klass.child.gchild.ggchild.field" => {
+        #         { "$elemMatch" => { "$gte" => 6, "$lte" => 10 } }
+        #       }
+        #
+        # (3) This is calculated by:
+        #
+        #       value.__evolve_range__(serializer: serializer).
+        #
+        # @api private
+        #
+        # @param [ String ] key The to store the range for.
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Range ] value The Range to serialize.
+        #
+        # @return [ Array<String, Hash> ] The store name and serialized Range.
+        def evolve_range(key, serializer, value)
+          v = value.__evolve_range__(serializer: serializer)
+          assocs = []
+          Fields.traverse_association_tree(key, serializers, associations, aliased_associations) do |meth, obj, is_field|
+            assocs.push([meth, obj, is_field])
+          end
+
+          # Iterate backwards until you get a field with type
+          # Array or an embeds_many association.
+          inner_key = ""
+          loop do
+            # If there are no arrays or embeds_many associations, just return
+            # the key and value without $elemMatch.
+            return [ key, v ] if assocs.empty?
+
+            meth, obj, is_field = assocs.last
+            break if (is_field && obj.type == Array) || (!is_field && obj.is_a?(Association::Embedded::EmbedsMany))
+
+            assocs.pop
+            inner_key = "#{meth}.#{inner_key}"
+          end
+
+          # If the last array or embeds_many association is the last field,
+          # the inner key (2) is ignored, and the outer key (1) is the original
+          # key.
+          if inner_key.blank?
+            [ key, { "$elemMatch" => v }]
+          else
+            store_key = assocs.map(&:first).join('.')
+            store_value = { "$elemMatch" => { inner_key.chop => v } }
+            [ store_key,  store_value ]
+          end
+        end
+
         # Determines if the selection is a multi-select, like an $and or $or or $nor
         # selection.
         #

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

@@ -8,8 +8,16 @@ module Mongoid
       class Smash < Hash
 
         # @attribute [r] aliases The aliases.
+        attr_reader :aliases
+
         # @attribute [r] serializers The serializers.
-        attr_reader :aliases, :serializers
+        attr_reader :serializers
+
+        # @attribute [r] associations The associations.
+        attr_reader :associations
+
+        # @attribute [r] aliased_associations The aliased_associations.
+        attr_reader :aliased_associations
 
         # Perform a deep copy of the smash.
         #
@@ -18,7 +26,7 @@ module Mongoid
         #
         # @return [ Smash ] The copied hash.
         def __deep_copy__
-          self.class.new(aliases, serializers) do |copy|
+          self.class.new(aliases, serializers, associations, aliased_associations) do |copy|
             each_pair do |key, value|
               copy.store(key, value.__deep_copy__)
             end
@@ -36,8 +44,15 @@ module Mongoid
         #   responsible for serializing values. The keys of the hash must be
         #   strings that match the field name, and the values must respond to
         #   #localized? and #evolve(object).
-        def initialize(aliases = {}, serializers = {})
-          @aliases, @serializers = aliases, serializers
+        # @param [ Hash ] associations An optional hash of names to association
+        #   objects.
+        # @param [ Hash ] aliased_associations An optional hash of mappings from
+        #   aliases for associations to their actual field names in the database.
+        def initialize(aliases = {}, serializers = {}, associations = {}, aliased_associations = {})
+          @aliases = aliases
+          @serializers = serializers
+          @associations = associations
+          @aliased_associations = aliased_associations
           yield(self) if block_given?
         end
 
@@ -86,8 +101,26 @@ module Mongoid
         #   serializer.
         def storage_pair(key)
           field = key.to_s
-          name = aliases[field] || field
-          [ name, serializers[name] ]
+          name = Fields.database_field_name(field, associations, aliases, aliased_associations)
+          [ name, get_serializer(name) ]
+        end
+
+        private
+
+        # Retrieves the serializer for the given name. If the name exists in
+        # the serializers hash then return that immediately, otherwise
+        # recursively look through the associations and find the appropriate
+        # field.
+        #
+        # @param [ String ] name The name of the db field.
+        #
+        # @return [ Object ] The serializer.
+        def get_serializer(name)
+          if s = serializers[name]
+            s
+          else
+            Fields.traverse_association_tree(name, serializers, associations, aliased_associations)
+          end
         end
       end
     end

data/lib/mongoid/criteria/queryable.rb

@@ -33,9 +33,10 @@ module Mongoid
       include Optional
 
       # @attribute [r] aliases The aliases.
-      # @attribute [r] driver The Mongo driver being used.
+      attr_reader :aliases
+
       # @attribute [r] serializers The serializers.
-      attr_reader :aliases, :driver, :serializers
+      attr_reader :serializers
 
       # Is this queryable equal to another object? Is true if the selector and
       # options are equal.
@@ -59,11 +60,15 @@ module Mongoid
       #
       # @param [ Hash ] aliases The optional field aliases.
       # @param [ Hash ] serializers The optional field serializers.
+      # @param [ Hash ] associations The optional associations.
+      # @param [ Hash ] aliased_associations The optional aliased associations.
       # @param [ Symbol ] driver The driver being used.
-      def initialize(aliases = {}, serializers = {}, driver = :mongo)
-        @aliases, @driver, @serializers = aliases, driver.to_sym, serializers
-        @options = Options.new(aliases, serializers)
-        @selector = Selector.new(aliases, serializers)
+      #
+      # @api private
+      def initialize(aliases = {}, serializers = {}, associations = {}, aliased_associations = {})
+        @aliases, @serializers = aliases, serializers
+        @options = Options.new(aliases, serializers, associations, aliased_associations)
+        @selector = Selector.new(aliases, serializers, associations, aliased_associations)
         @pipeline = Pipeline.new(aliases)
         @aggregating = nil
         yield(self) if block_given?

data/lib/mongoid/criteria.rb

@@ -112,31 +112,6 @@ module Mongoid
       entries.as_json(options)
     end
 
-    # Tells the criteria that the cursor that gets returned needs to be
-    # cached. This is so multiple iterations don't hit the database multiple
-    # times, however this is not advisable when working with large data sets
-    # as the entire results will get stored in memory.
-    #
-    # @example Flag the criteria as cached.
-    #   criteria.cache
-    #
-    # @return [ Criteria ] The cloned criteria.
-    def cache
-      crit = clone
-      crit.options.merge!(cache: true)
-      crit
-    end
-
-    # Will return true if the cache option has been set.
-    #
-    # @example Is the criteria cached?
-    #   criteria.cached?
-    #
-    # @return [ true, false ] If the criteria is flagged as cached.
-    def cached?
-      options[:cache] == true
-    end
-
     # Get the documents from the embedded criteria.
     #
     # @example Get the documents.
@@ -230,7 +205,7 @@ module Mongoid
       @klass = klass
       @embedded = nil
       @none = nil
-      klass ? super(klass.aliased_fields, klass.fields) : super({}, {})
+      klass ? super(klass.aliased_fields, klass.fields, klass.relations, klass.aliased_associations) : super({}, {}, {}, {})
     end
 
     # Merges another object with this +Criteria+ and returns a new criteria.

data/lib/mongoid/deprecable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "mongoid/deprecation"
+
+module Mongoid
+
+  # Adds ability to declare Mongoid-specific deprecations.
+  #
+  # @api private
+  module Deprecable
+
+    # Declares method(s) as deprecated.
+    #
+    # @example Deprecate a method.
+    #   Mongoid.deprecate(Cat, :meow); Cat.new.meow
+    #   #=> Mongoid.logger.warn("meow is deprecated and will be removed from Mongoid 8.0")
+    #
+    # @example Deprecate a method and declare the replacement method.
+    #   Mongoid.deprecate(Cat, meow: :speak); Cat.new.meow
+    #   #=> Mongoid.logger.warn("meow is deprecated and will be removed from Mongoid 8.0 (use speak instead)")
+    #
+    # @example Deprecate a method and give replacement instructions.
+    #   Mongoid.deprecate(Cat, meow: 'eat :catnip instead'); Cat.new.meow
+    #   #=> Mongoid.logger.warn("meow is deprecated and will be removed from Mongoid 8.0 (eat :catnip instead)")
+    #
+    # @param [ Module ] target_module The parent which contains the method.
+    # @param [ Symbol | Hash<Symbol, [Symbol|String]> ] method_descriptors
+    #   The methods to deprecate, with optional replacement instructions.
+    def deprecate(target_module, *method_descriptors)
+      Mongoid::Deprecation.deprecate_methods(target_module, *method_descriptors)
+    end
+  end
+end
+
+# Ensure Mongoid.deprecate can be used during initialization
+Mongoid.extend(Mongoid::Deprecable)

data/lib/mongoid/deprecation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Utility class for logging deprecation warnings.
+  class Deprecation < ::ActiveSupport::Deprecation
+
+    @gem_name = 'Mongoid'
+
+    # Per change policy, deprecations will be removed in the next major version.
+    @deprecation_horizon = "#{Mongoid::VERSION.split('.').first.to_i + 1}.0".freeze
+
+    # Overrides default ActiveSupport::Deprecation behavior
+    # to use Mongoid's logger.
+    #
+    # @return Array<Proc> The deprecation behavior.
+    def behavior
+      @behavior ||= Array(->(message, callstack, _deprecation_horizon, _gem_name) {
+        logger = Mongoid.logger
+        logger.warn(message)
+        logger.debug(callstack.join("\n  ")) if debug
+      })
+    end
+  end
+end

data/lib/mongoid/document.rb

@@ -100,21 +100,8 @@ module Mongoid
     # @param [ Hash ] attrs The attributes to set up the document with.
     #
     # @return [ Document ] A new document.
-    def initialize(attrs = nil)
-      @__parent = nil
-      _building do
-        @new_record = true
-        @attributes ||= {}
-        apply_pre_processed_defaults
-        apply_default_scoping
-        process_attributes(attrs) do
-          yield(self) if block_given?
-        end
-        apply_post_processed_defaults
-        # @todo: #2586: Need to have access to parent document in these
-        #   callbacks.
-        run_callbacks(:initialize) unless _initialize_callbacks.empty?
-      end
+    def initialize(attrs = nil, &block)
+      construct_document(attrs, execute_callbacks: true, &block)
     end
 
     # Return the model name of the document.
@@ -137,16 +124,6 @@ module Mongoid
       (persisted? || destroyed?) ? [ _id.to_s ] : nil
     end
 
-    # Return an array with this +Document+ only in it.
-    #
-    # @example Return the document in an array.
-    #   document.to_a
-    #
-    # @return [ Array<Document> ] An array with the document as its only item.
-    def to_a
-      [ self ]
-    end
-
     # Return a hash of the entire document hierarchy from this document and
     # below. Used when the attributes are needed for everything and not just
     # the current document.
@@ -180,7 +157,7 @@ module Mongoid
     def as_json(options = nil)
       rv = super
       if options && options[:compact]
-        Mongoid.logger.warn('#as_json :compact option is deprecated. Please call #compact on the returned Hash object instead.')
+        Mongoid::Warnings.warn_as_json_compact_deprecated
         rv = rv.compact
       end
       rv
@@ -228,6 +205,38 @@ module Mongoid
 
     private
 
+    # Does the construction of a document.
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+    #   should be run.
+    #
+    # @return [ Document ] A new document.
+    #
+    # @api private
+    def construct_document(attrs = nil, execute_callbacks: true)
+      @__parent = nil
+      _building do
+        @new_record = true
+        @attributes ||= {}
+        apply_pre_processed_defaults
+        apply_default_scoping
+        process_attributes(attrs) do
+          yield(self) if block_given?
+        end
+        @attributes_before_type_cast = @attributes.merge(attributes_before_type_cast)
+
+        if execute_callbacks
+          apply_post_processed_defaults
+          run_callbacks(:initialize) unless _initialize_callbacks.empty?
+        else
+          pending_callbacks << :apply_post_processed_defaults
+          pending_callbacks << :initialize
+        end
+      end
+      self
+    end
+
     # Returns the logger
     #
     # @return [ Logger ] The configured logger or a default Logger instance.
@@ -245,6 +254,14 @@ module Mongoid
       @model_cache_key ||= self.class.model_name.cache_key
     end
 
+    # Returns a hash of the attributes.
+    #
+    # Note this method modifies the attributes hash that already exists on the
+    # class and returns it. This means that the hash returned by this method
+    # refers to the same hash as calling #attributes on the instance. See
+    # MONGOID-4476 for an explanation on how this is used.
+    #
+    # @return [ Hash ] The attributes hash.
     def as_attributes
       return attributes if frozen?
       embedded_relations.each_pair do |name, meta|
@@ -273,20 +290,67 @@ module Mongoid
       # @param [ Hash ] attrs The hash of attributes to instantiate with.
       # @param [ Integer ] selected_fields The selected fields from the
       #   criteria.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      def instantiate(attrs = nil, selected_fields = nil, &block)
+        instantiate_document(attrs, selected_fields, execute_callbacks: true, &block)
+      end
+
+      # Instantiate the document.
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      # @param [ Integer ] selected_fields The selected fields from the
+      #   criteria.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
       #
       # @return [ Document ] A new document.
-      def instantiate(attrs = nil, selected_fields = nil)
-        attributes = attrs || {}
+      #
+      # @api private
+      def instantiate_document(attrs = nil, selected_fields = nil, execute_callbacks: true)
+        attributes = if Mongoid.legacy_attributes
+          attrs
+        else
+          attrs&.to_h
+        end || {}
+
         doc = allocate
         doc.__selected_fields = selected_fields
         doc.instance_variable_set(:@attributes, attributes)
-        doc.apply_defaults
-        yield(doc) if block_given?
-        doc.run_callbacks(:find) unless doc._find_callbacks.empty?
-        doc.run_callbacks(:initialize) unless doc._initialize_callbacks.empty?
+        # TODO: remove the to_h when the legacy_attributes flag is removed.
+        # The to_h ensures that we don't accidentally make attributes_before_type_cast
+        # a BSON::Document.
+        doc.instance_variable_set(:@attributes_before_type_cast, attributes&.to_h.dup)
+
+        if execute_callbacks
+          doc.apply_defaults
+          yield(doc) if block_given?
+          doc.run_callbacks(:find) unless doc._find_callbacks.empty?
+          doc.run_callbacks(:initialize) unless doc._initialize_callbacks.empty?
+        else
+          yield(doc) if block_given?
+          doc.pending_callbacks += [:apply_defaults, :find, :initialize]
+        end
+
         doc
       end
 
+      # Allocates and constructs a document.
+      #
+      # @param [ Hash ] attrs The attributes to set up the document with.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      #
+      # @api private
+      def construct_document(attrs = nil, execute_callbacks: true)
+        doc = allocate
+        doc.send(:construct_document, attrs, execute_callbacks: execute_callbacks)
+      end
+
       # Returns all types to query for when using this class as the base.
       #
       # @example Get the types.