mongoid 7.4.0 → 8.0.1

data/lib/mongoid/association/relatable.rb

@@ -242,7 +242,7 @@ module Mongoid
       #
       # @return [ String ] The foreign key check.
       def foreign_key_check
-        @foreign_key_check ||= "#{foreign_key}_changed?" if (stores_foreign_key? && foreign_key)
+        @foreign_key_check ||= "#{foreign_key}_previously_changed?" if (stores_foreign_key? && foreign_key)
       end
 
       # Create an association proxy object using the owner and target.
@@ -299,6 +299,35 @@ module Mongoid
                       end
       end
 
+      # @return [ Array<String> ] The associations above this one in the inclusion tree.
+      attr_accessor :parent_inclusions
+
+      def parent_inclusions
+        @parent_inclusions ||= []
+      end
+
+      # Is this association an embeds_many or has_many association?
+      #
+      # @return [ true | false ] true if it is a *_many association, false if not.
+      def many?
+        [Referenced::HasMany, Embedded::EmbedsMany].any? { |a| self.is_a?(a) }
+      end
+
+      # Is this association an embeds_one or has_one association?
+      #
+      # @return [ true | false ] true if it is a *_one association, false if not.
+      def one?
+        [Referenced::HasOne, Embedded::EmbedsOne].any? { |a| self.is_a?(a) }
+      end
+
+      # Is this association an embedded_in or belongs_to association?
+      #
+      # @return [ true | false ] true if it is an embedded_in or belongs_to
+      #   association, false if not.
+      def in_to?
+        [Referenced::BelongsTo, Embedded::EmbeddedIn].any? { |a| self.is_a?(a) }
+      end
+
       private
 
       # Gets the model classes with inverse associations of this model. This is used to determine
@@ -404,10 +433,15 @@ module Mongoid
       def namespace_hierarchy(mod)
         parent = Object
         hier = [parent]
-        mod.name.split('::').each do |part|
-          parent = parent.const_get(part)
-          hier << parent
+
+        # name is not present on anonymous modules
+        if mod.name
+          mod.name.split('::').each do |part|
+            parent = parent.const_get(part)
+            hier << parent
+          end
         end
+
         hier.reverse
       end
 

data/lib/mongoid/atomic/paths/embedded/many.rb

@@ -34,6 +34,25 @@ module Mongoid
             locator = document.new_record? ? "" : ".#{document._index}"
             "#{pos}#{"." unless pos.blank?}#{document._association.store_as}#{locator}"
           end
+
+          class << self
+
+            # Get the position of where the document would go for the given
+            # association. The use case for this function is when trying to
+            # persist an empty list for an embedded association. All of the
+            # existing functions for getting the position to store a document
+            # require passing in a document to store, which we don't have when
+            # trying to store the empty list.
+            #
+            # @param [ Document ] parent The parent document to store in.
+            # @param [ Association ] association The association.
+            #
+            # @return [ String ] The position string.
+            def position_without_document(parent, association)
+              pos = parent.atomic_position
+              "#{pos}#{"." unless pos.blank?}#{association.store_as}"
+            end
+          end
         end
       end
     end

data/lib/mongoid/attributes/processing.rb

@@ -43,11 +43,18 @@ module Mongoid
       # @return [ true, false ] True if pending, false if not.
       def pending_attribute?(key, value)
         name = key.to_s
-        if relations.has_key?(name)
+
+        aliased = if aliased_associations.key?(name)
+          aliased_associations[name]
+        else
+          name
+        end
+
+        if relations.has_key?(aliased)
           pending_relations[name] = value
           return true
         end
-        if nested_attributes.has_key?(name)
+        if nested_attributes.has_key?(aliased)
           pending_nested[name] = value
           return true
         end

data/lib/mongoid/attributes.rb

@@ -86,10 +86,26 @@ module Mongoid
     def read_attribute(name)
       field = fields[name.to_s]
       raw = read_raw_attribute(name)
-      field ? field.demongoize(raw) : raw
+      process_raw_attribute(name.to_s, raw, field)
     end
     alias :[] :read_attribute
 
+
+    # Process the raw attribute values just read from the documents attributes.
+    #
+    # @param [ String ] name The name of the attribute to get.
+    # @param [ Object ] raw The raw attribute value.
+    # @param [ Field | nil ] field The field to use for demongoization or nil.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @api private
+    def process_raw_attribute(name, raw, field)
+      value = field ? field.demongoize(raw) : raw
+      attribute_will_change!(name) if value.resizable?
+      value
+    end
+
     # Read a value from the attributes before type cast. If the value has not
     # yet been assigned then this will return the attribute's existing value
     # using read_raw_attribute.
@@ -121,6 +137,7 @@ module Mongoid
     # @raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due
     #   to being flagged as reaodnly.
     def remove_attribute(name)
+      validate_writable_field_name!(name.to_s)
       as_writable_attribute!(name) do |access|
         _assigning do
           attribute_will_change!(access)
@@ -143,6 +160,8 @@ module Mongoid
     # @param [ String, Symbol ] name The name of the attribute to update.
     # @param [ Object ] value The value to set for the attribute.
     def write_attribute(name, value)
+      validate_writable_field_name!(name.to_s)
+
       field_name = database_field_name(name)
 
       if attribute_missing?(field_name)
@@ -151,7 +170,6 @@ module Mongoid
 
       if attribute_writable?(field_name)
         _assigning do
-          validate_attribute_value(field_name, value)
           localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
           typed_value = typed_value_for(field_name, value)
@@ -164,6 +182,11 @@ module Mongoid
           else
             attributes[field_name] = typed_value
           end
+
+          # when writing an attribute, also remove it from the unsets,
+          # so that removing then writing doesn't result in a removal.
+          delayed_atomic_unsets.delete(field_name)
+
           typed_value
         end
       else
@@ -266,7 +289,11 @@ module Mongoid
       end
 
       if hash_dot_syntax?(normalized)
-        attributes.__nested__(normalized)
+        if fields.key?(normalized)
+          attributes[normalized]
+        else
+          attributes.__nested__(normalized)
+        end
       else
         attributes[normalized]
       end
@@ -325,30 +352,6 @@ module Mongoid
 
     private
 
-    # Validates an attribute value as being assignable to the specified field.
-    #
-    # For now, only Hash and Array fields are validated, and the value is
-    # being checked to be of an appropriate type (i.e. either Hash or Array,
-    # respectively, or nil).
-    #
-    # This method takes the name of the field as stored in the document
-    # in the database, not (necessarily) the Ruby method name used to read/write
-    # the said field.
-    #
-    # @param [ String, Symbol ] field_name The name of the field.
-    # @param [ Object ] value The value to be validated.
-    def validate_attribute_value(field_name, value)
-      return if value.nil?
-      field = fields[field_name]
-      return unless field
-      validatable_types = [ Hash, Array ]
-      if validatable_types.include?(field.type)
-        unless value.is_a?(field.type)
-          raise Mongoid::Errors::InvalidValue.new(field.type, value.class)
-        end
-      end
-    end
-
     def lookup_attribute_presence(name, value)
       if localized_fields.has_key?(name) && value
         value = localized_fields[name].send(:lookup, value)

data/lib/mongoid/changeable.rb

@@ -62,13 +62,14 @@ module Mongoid
 
     # Call this method after save, so the changes can be properly switched.
     #
-    # This will unset the memoized children array, set new record to
+    # This will unset the memoized children array, set new record flag to
     # false, set the document as validated, and move the dirty changes.
     #
     # @example Move the changes to previous.
     #   person.move_changes
     def move_changes
       @previous_changes = changes
+      @previous_attributes = attributes.dup
       Atomic::UPDATES.each do |update|
         send(update).clear
       end
@@ -81,6 +82,7 @@ module Mongoid
     #   document.post_persist
     def post_persist
       reset_persisted_descendants
+      reset_attributes_before_type_cast
       move_changes
     end
 
@@ -133,6 +135,13 @@ module Mongoid
 
     private
 
+    # Get attributes of the document before the document was saved.
+    #
+    # @return [ Hash ] Previous attributes
+    def previous_attributes
+      @previous_attributes ||= {}
+    end
+
     # Get the old and new value for the provided attribute.
     #
     # @example Get the attribute change.
@@ -185,6 +194,25 @@ module Mongoid
       attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
     end
 
+    # Get the previous attribute value that was changed
+    # before the document was saved.
+    #
+    # It the document has not been saved yet, or was just loaded from database,
+    # this method returns nil for all attributes.
+    #
+    # @param [ String ] attr The attribute name.
+    #
+    # @return [ Object | nil ] Attribute value before the document was saved,
+    #   or nil if the document has not been saved yet.
+    def attribute_previously_was(attr)
+      attr = database_field_name(attr)
+      if previous_changes.key?(attr)
+        previous_changes[attr].first
+      else
+        previous_attributes[attr]
+      end
+    end
+
     # Flag an attribute as going to change.
     #
     # @example Flag the attribute.
@@ -221,6 +249,10 @@ module Mongoid
       end
     end
 
+    def reset_attributes_before_type_cast
+      @attributes_before_type_cast = @attributes.dup
+    end
+
     module ClassMethods
 
       private
@@ -291,7 +323,7 @@ module Mongoid
         end
       end
 
-      # Creates the dirty change previous value accessor.
+      # Creates the dirty change previous value accessors.
       #
       # @example Create the accessor.
       #   Model.create_dirty_previous_value_accessor("name", "alias")
@@ -303,6 +335,9 @@ module Mongoid
           re_define_method("#{meth}_was") do
             attribute_was(name)
           end
+          re_define_method("#{meth}_previously_was") do
+            attribute_previously_was(name)
+          end
         end
       end
 

data/lib/mongoid/clients/options.rb

@@ -45,6 +45,10 @@ module Mongoid
             PersistenceContext.new(self.class)
       end
 
+      def persistence_context?
+        !!(PersistenceContext.get(self) || PersistenceContext.get(self.class))
+      end
+
       private
 
       def set_persistence_context(options_or_context)

data/lib/mongoid/clients/sessions.rb

@@ -43,13 +43,7 @@ module Mongoid
         Threaded.set_session(session)
         yield(session)
       rescue Mongo::Error::InvalidSession => ex
-        if
-          # Driver 2.13.0+
-          defined?(Mongo::Error::SessionsNotSupported) &&
-            Mongo::Error::SessionsNotSupported === ex ||
-          # Legacy drivers
-          ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
-        then
+        if Mongo::Error::SessionsNotSupported === ex
           raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
         end
         raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
@@ -100,13 +94,7 @@ module Mongoid
           Threaded.set_session(session)
           yield(session)
         rescue Mongo::Error::InvalidSession => ex
-          if
-            # Driver 2.13.0+
-            defined?(Mongo::Error::SessionsNotSupported) &&
-              Mongo::Error::SessionsNotSupported === ex ||
-            # Legacy drivers
-            ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
-          then
+          if Mongo::Error::SessionsNotSupported === ex
             raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
           end
           raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)

data/lib/mongoid/config/environment.rb

@@ -44,21 +44,37 @@ module Mongoid
       #   override the current Mongoid environment.
       #
       # @return [ Hash ] The settings.
+      #
       # @api private
       def load_yaml(path, environment = nil)
         env = environment ? environment.to_s : env_name
-        contents = File.new(path).read
+
+        contents = File.read(path)
         if contents.empty?
           raise Mongoid::Errors::EmptyConfigFile.new(path)
         end
-        data = if RUBY_VERSION.start_with?("2.5")
-          YAML.safe_load(ERB.new(contents).result, [Symbol], [], true)
+
+        # These are the classes that can be used in a Mongoid
+        # configuration file in addition to standard YAML types.
+        permitted_classes = [
+          # Symbols occur as values for read preference, for example.
+          Symbol,
+          # BSON::Binary occur as keyId values for FLE (more precisely,
+          # the keyIds are UUIDs).
+          BSON::Binary,
+        ]
+
+        result = ERB.new(contents).result
+        data = if RUBY_VERSION < '2.6'
+          YAML.safe_load(result, permitted_classes, [], true)
         else
-          YAML.safe_load(ERB.new(contents).result, permitted_classes: [Symbol], aliases: true)
+          YAML.safe_load(result, permitted_classes: permitted_classes, aliases: true)
         end
+
         unless data.is_a?(Hash)
           raise Mongoid::Errors::InvalidConfigFile.new(path)
         end
+
         data[env]
       end
     end

data/lib/mongoid/config.rb

@@ -23,7 +23,8 @@ module Mongoid
     # database name is not explicitly defined.
     option :app_name, default: nil
 
-    # Create indexes in background by default.
+    # (Deprecated) In MongoDB 4.0 and earlier, set whether to create
+    # indexes in the background by default. (default: false)
     option :background_indexing, default: false
 
     # Mark belongs_to associations as required by default, so that saving a
@@ -74,42 +75,55 @@ module Mongoid
     # Return stored times as UTC.
     option :use_utc, default: false
 
+    # Store BigDecimals as Decimal128s instead of strings in the db.
+    option :map_big_decimal_to_decimal128, default: true
+
     # Update embedded documents correctly when setting it, unsetting it
     # and resetting it. See MONGOID-5206 and MONGOID-5240 for more details.
-    option :broken_updates, default: true
+    option :broken_updates, default: false
 
     # Maintain legacy behavior of === on Mongoid documents, which returns
     # true in a number of cases where Ruby's === implementation would
     # return false.
-    option :legacy_triple_equals, default: true
+    option :legacy_triple_equals, default: false
 
     # When exiting a nested `with_scope' block, set the current scope to
     # nil instead of the parent scope for backwards compatibility.
-    option :broken_scoping, default: true
+    option :broken_scoping, default: false
 
     # Maintain broken behavior of sum over empty result sets for backwards
     # compatibility.
-    option :broken_aggregables, default: true
+    option :broken_aggregables, default: false
 
     # Ignore aliased fields in embedded documents when performing pluck and
     # distinct operations, for backwards compatibility.
-    option :broken_alias_handling, default: true
+    option :broken_alias_handling, default: false
 
     # Maintain broken `and' behavior when using the same operator on the same
     # field multiple times for backwards compatibility.
-    option :broken_and, default: true
+    option :broken_and, default: false
 
     # Use millisecond precision when comparing Time objects with the _matches?
     # function.
-    option :compare_time_by_ms, default: false
+    option :compare_time_by_ms, default: true
 
     # Use bson-ruby's implementation of as_json for BSON::ObjectId instead of
     # the one monkey-patched into Mongoid.
-    option :object_id_as_json_oid, default: true
+    option :object_id_as_json_oid, default: false
 
     # Maintain legacy behavior of pluck and distinct, which does not
     # demongoize the values on returning them.
-    option :legacy_pluck_distinct, default: true
+    option :legacy_pluck_distinct, default: false
+
+    # Combine chained operators, which use the same field and operator,
+    # using and's instead of overwriting them.
+    option :overwrite_chained_operators, default: false
+
+    # When this flag is true, the attributes method on a document will return
+    # a BSON::Document when that document is retrieved from the database, and
+    # a Hash otherwise. When this flag is false, the attributes method will
+    # always return a Hash.
+    option :legacy_attributes, default: false
 
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.
@@ -202,6 +216,7 @@ module Mongoid
       configuration = settings.with_indifferent_access
       self.options = configuration[:options]
       self.clients = configuration[:clients]
+      Mongo.options = configuration[:driver_options] || {}
       set_log_levels
     end
 

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

@@ -27,9 +27,13 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to average.
         #
-        # @return [ Float ] The average.
+        # @return [ Numeric ] The average.
         def avg(field)
-          count > 0 ? sum(field).to_f / count.to_f : nil
+          total = count { |doc| !doc.send(field).nil? }
+          return nil unless total > 0
+
+          total = total.to_f if total.is_a?(Integer)
+          sum(field) / total
         end
 
         # Get the max value of the provided field. If provided a block, will
@@ -46,10 +50,12 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to max.
         #
-        # @return [ Float, Document ] The max value or document with the max
+        # @return [ Numeric | Document ] The max value or document with the max
         #   value.
         def max(field = nil)
-          block_given? ? super() : aggregate_by(field, :max_by)
+          return super() if block_given?
+
+          aggregate_by(field, :max)
         end
 
         # Get the min value of the provided field. If provided a block, will
@@ -66,10 +72,12 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to min.
         #
-        # @return [ Float, Document ] The min value or document with the min
+        # @return [ Numeric | Document ] The min value or document with the min
         #   value.
         def min(field = nil)
-          block_given? ? super() : aggregate_by(field, :min_by)
+          return super() if block_given?
+
+          aggregate_by(field, :min)
         end
 
         # Get the sum value of the provided field. If provided a block, will
@@ -83,13 +91,11 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to sum.
         #
-        # @return [ Float ] The sum value.
+        # @return [ Numeric ] The sum value.
         def sum(field = nil)
-          if block_given?
-            super()
-          else
-            count > 0 ? super(0) { |doc| doc.public_send(field) } : 0
-          end
+          return super() if block_given?
+
+          aggregate_by(field, :sum) || 0
         end
 
         private
@@ -99,14 +105,16 @@ module Mongoid
         # @api private
         #
         # @example Aggregate by the field and method.
-        #   aggregable.aggregate_by(:name, :min_by)
+        #   aggregable.aggregate_by(:likes, :min_by)
         #
         # @param [ Symbol ] field The field to aggregate on.
         # @param [ Symbol ] method The method (min_by or max_by).
         #
-        # @return [ Integer ] The aggregate.
+        # @return [ Numeric | nil ] The aggregate.
         def aggregate_by(field, method)
-          count > 0 ? send(method) { |doc| doc.public_send(field) }.public_send(field) : nil
+          return nil unless any?
+
+          map { |doc| doc.public_send(field) }.compact.public_send(method)
         end
       end
     end

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

@@ -26,7 +26,7 @@ module Mongoid
         #   If no documents are found, then returned Hash will have
         #   count, sum of 0 and max, min, avg of nil.
         def aggregates(field)
-          result = collection.find.aggregate(pipeline(field), session: _session).to_a
+          result = collection.aggregate(pipeline(field), session: _session).to_a
           if result.empty?
             if Mongoid.broken_aggregables
               { "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil }

data/lib/mongoid/contextual/map_reduce.rb

@@ -121,7 +121,7 @@ module Mongoid
       # @return [ MapReduce ] The map/reduce object.
       def out(location)
         normalized = location.dup
-        normalized.update_values do |value|
+        normalized.transform_values! do |value|
           value.is_a?(::Symbol) ? value.to_s : value
         end
         @map_reduce = @map_reduce.out(normalized)
@@ -147,7 +147,7 @@ module Mongoid
       def raw
         validate_out!
         cmd = command
-        opts = { read: cmd.delete(:read) } if cmd[:read]
+        opts = { read: criteria.options.fetch(:read) } if criteria.options[:read]
         @map_reduce.database.command(cmd, (opts || {}).merge(session: _session)).first
       end
       alias :results :raw