mongoid 9.0.10 → 9.1.0

data/lib/mongoid/association/many.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
-
     # This is the superclass for all many to one and many to many association
     # proxies.
     class Many < Association::Proxy
       extend Forwardable
       include ::Enumerable
 
-      def_delegators :criteria, :avg, :max, :min, :sum
+      %i[avg max min sum].each do |method|
+        define_method(method) do |*args, &block|
+          if _target.respond_to?(:_loaded?) && _target._loaded?
+            _target.public_send(method, *args, &block)
+          else
+            criteria.public_send(method, *args, &block)
+          end
+        end
+      end
       def_delegators :_target, :length, :size, :any?
 
       # Is the association empty?
@@ -178,6 +184,19 @@ module Mongoid
         criteria.unscoped
       end
 
+      # For compatibility with Rails' caching. Returns a string based on the
+      # given timestamp, and includes the number of records in the relation
+      # in the version.
+      #
+      # @param [ String | Symbol ] timestamp_column the timestamp column to
+      #   use when constructing the key.
+      #
+      # @return [ String ] the cache version string
+      def cache_version(timestamp_column = :updated_at)
+        @cache_version ||= {}
+        @cache_version[timestamp_column] ||= compute_cache_version(timestamp_column)
+      end
+
       private
 
       def _session
@@ -198,6 +217,59 @@ module Mongoid
         attrs[klass.discriminator_key] = type.discriminator_value if type
         where(attrs).first || send(method, attrs, type, &block)
       end
+
+      # Computes the cache version for the relation using the given
+      # timestamp colum; see `#cache_version`.
+      #
+      # @param [ String | Symbol ] timestamp_column the timestamp column to
+      #   use when constructing the key.
+      #
+      # @return [ String ] the cache version string
+      def compute_cache_version(timestamp_column)
+        timestamp_column = timestamp_column.to_s
+
+        # has_many
+        loaded = if _target.respond_to?(:_loaded?)
+                   _target._loaded?
+                 else
+                   true
+                 end # embeds_many
+
+        size, timestamp = if loaded
+                            analyze_loaded_target(timestamp_column)
+                          else
+                            analyze_unloaded_target(timestamp_column)
+                          end
+
+        if timestamp
+          "#{size}-#{timestamp.utc.to_formatted_s(klass.cache_timestamp_format)}"
+        else
+          size.to_s
+        end
+      end
+
+      # Return a 2-tuple of the number of elements in the relation, and the
+      # largest timestamp value.
+      def analyze_loaded_target(timestamp_column)
+        newest = _target.select { |elem| elem.respond_to?(timestamp_column) }
+                        .max { |a, b| a[timestamp_column] <=> b[timestamp_column] }
+        [ _target.length, newest ? newest[timestamp_column] : nil ]
+      end
+
+      # Returns a 2-tuple of the number of elements in the relation, and the
+      # largest timestamp value. This will query the database to perform a
+      # $sum and a $max.
+      def analyze_unloaded_target(timestamp_column)
+        pipeline = criteria
+                   .group(_id: nil,
+                          count: { '$sum' => 1 },
+                          latest: { '$max' => "$#{timestamp_column}" })
+                   .pipeline
+
+        result = klass.collection.aggregate(pipeline).to_a.first
+
+        result ? [ result['count'], result['latest'] ] : [ 0 ]
+      end
     end
   end
 end

data/lib/mongoid/association/marshalable.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
-
     # Mixin module for Mongoid::Association::Proxy which adds
     # custom Marshal.dump functionality.
     module Marshalable
-
       # Provides the data needed to Marshal.dump an association proxy.
       #
       # @example Dump the proxy.

data/lib/mongoid/association/nested/many.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Nested
-
       # Builder class used to perform #accepts_nested_attributes_for
       # attribute assignment on many-to-n associations.
       class Many
@@ -17,6 +15,9 @@ module Mongoid
         # the existing association, a replacement of the association with a new
         # document, or a removal of the association.
         #
+        # It raises an argument error if the attributes are not a Hash or an
+        # Array of key/value pairs.
+        #
         # @example Build the nested attrs.
         #   many.build(person)
         #
@@ -26,14 +27,18 @@ module Mongoid
         # @return [ Array ] The attributes.
         def build(parent, options = {})
           @existing = parent.send(association.name)
-          if over_limit?(attributes)
-            raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
-          end
+          raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit]) if over_limit?(attributes)
+
           attributes.each do |attrs|
             if attrs.is_a?(::Hash)
               process_attributes(parent, attrs.with_indifferent_access)
-            else
+            elsif attrs.is_a?(Array) && attrs.length > 1 && attrs[1].respond_to?(:with_indifferent_access)
               process_attributes(parent, attrs[1].with_indifferent_access)
+            elsif attrs.is_a?(Array) && attrs.length.even?
+              process_attributes(parent, Hash[*attrs].with_indifferent_access)
+            else
+              raise ArgumentError,
+                    "Attributes for nested association '#{association.name}' must be a Hash or an Array of key/value pairs."
             end
           end
         end
@@ -48,13 +53,13 @@ module Mongoid
         # @param [ Hash ] attributes The attributes hash to attempt to set.
         # @param [ Hash ] options The options defined.
         def initialize(association, attributes, options = {})
-          if attributes.respond_to?(:with_indifferent_access)
-            @attributes = attributes.with_indifferent_access.sort do |a, b|
-              a[0].to_i <=> b[0].to_i
-            end
-          else
-            @attributes = attributes
-          end
+          @attributes = if attributes.respond_to?(:with_indifferent_access)
+                          attributes.with_indifferent_access.sort do |a, b|
+                            a[0].to_i <=> b[0].to_i
+                          end
+                        else
+                          attributes
+                        end
           @association = association
           @options = options
           @class_name = options[:class_name] ? options[:class_name].constantize : association.klass
@@ -184,11 +189,17 @@ module Mongoid
             else
               update_document(doc, attrs)
             end
-          else
+          elsif association.embedded?
+            raise Errors::DocumentNotFound.new(association.klass, id)
+          elsif association.is_a?(Association::Referenced::HasAndBelongsToMany) || Mongoid.allow_reparenting_via_nested_attributes?
+            Mongoid::Warnings.warn_reparenting_via_nested_attributes if Mongoid.allow_reparenting_via_nested_attributes?
+
             # push existing document to association
             doc = association.klass.unscoped.find(converted)
             update_document(doc, attrs)
             existing.push(doc) unless destroyable?(attrs)
+          else
+            raise Errors::DocumentNotFound.new(association.klass, { _id: id, association.foreign_key => parent.id })
           end
 
           parent.children_may_have_changed!

data/lib/mongoid/association/nested/nested_buildable.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Nested
-
       # Mixin module containing common functionality used to
       # perform #accepts_nested_attributes_for attribute assignment
       # on associations.
       module Buildable
-
         attr_accessor :attributes, :existing, :association, :options
 
         # Determines if destroys are allowed for this document.
@@ -33,12 +30,12 @@ module Mongoid
         # @return [ true | false ] True and call proc or method if rejectable, false if not.
         def reject?(document, attrs)
           case callback = options[:reject_if]
-            when Symbol
-              document.method(callback).arity == 0 ? document.send(callback) : document.send(callback, attrs)
-            when Proc
-              callback.call(attrs)
-            else
-              false
+          when Symbol
+            (document.method(callback).arity == 0) ? document.send(callback) : document.send(callback, attrs)
+          when Proc
+            callback.call(attrs)
+          else
+            false
           end
         end
 

data/lib/mongoid/association/nested/one.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Nested
-
       # Builder class used to perform #accepts_nested_attributes_for
       # attribute assignment on one-to-n associations.
       class One
@@ -27,6 +25,7 @@ module Mongoid
         # @return [ Document ] The built document.
         def build(parent)
           return if reject?(parent, attributes)
+
           @existing = parent.send(association.name)
           if update?
             delete_id(attributes)
@@ -158,11 +157,9 @@ module Mongoid
 
           # otherwise, an attempt has been made to set the _id of an existing,
           # persisted document.
-          if Mongoid::Config.immutable_ids
-            raise Errors::ImmutableAttribute.new(:_id, id)
-          else
-            Mongoid::Warnings.warn_mutable_ids
-          end
+          raise Errors::ImmutableAttribute.new(:_id, id) if Mongoid::Config.immutable_ids
+
+          Mongoid::Warnings.warn_mutable_ids
         end
       end
     end

data/lib/mongoid/association/nested.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/association/nested/nested_buildable'
 require 'mongoid/association/nested/many'
@@ -8,9 +7,8 @@ require 'mongoid/association/nested/one'
 module Mongoid
   module Association
     module Nested
-
       # The flags indicating that an association can be destroyed.
-      DESTROY_FLAGS = [1, "1", true, "true"].freeze
+      DESTROY_FLAGS = [ 1, '1', true, 'true' ].freeze
     end
   end
 end

data/lib/mongoid/association/one.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
-
     # This is the superclass for one to one relations and defines the common
     # behavior or those proxies.
     class One < Association::Proxy
-
       # Clear this relation - same as calling #delete on the document.
       #
       # @example Clear the relation.

data/lib/mongoid/association/options.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
-
     # Options context used for all association types.
     module Options
-
       # Returns the name of the parent to a polymorphic child.
       #
       # @return [ String | Symbol ] The name.
@@ -71,7 +68,7 @@ module Mongoid
       def autosave
         !!@options[:autosave]
       end
-      alias :autosave? :autosave
+      alias autosave? autosave
 
       # Whether the association is counter-cached.
       #
@@ -83,7 +80,9 @@ module Mongoid
       # Whether this association is polymorphic.
       #
       # @return [ true | false ] Whether the association is polymorphic.
-      def polymorphic?; false; end
+      def polymorphic?
+        false
+      end
 
       # Whether the association has callbacks cascaded down from the parent.
       #
@@ -100,7 +99,9 @@ module Mongoid
       # Whether the association has forced nil inverse (So no foreign keys are saved).
       #
       # @return [ false ] Default is false.
-      def forced_nil_inverse?; false; end
+      def forced_nil_inverse?
+        false
+      end
 
       # The field for saving the associated object's type.
       #
@@ -111,7 +112,7 @@ module Mongoid
       #
       # @return [ nil ] Default is nil.
       def touch_field
-        @touch_field ||= options[:touch] if (options[:touch].is_a?(String) || options[:touch].is_a?(Symbol))
+        @touch_field ||= options[:touch] if options[:touch].is_a?(String) || options[:touch].is_a?(Symbol)
       end
 
       # Whether the association object should be automatically touched

data/lib/mongoid/association/referenced/auto_save.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Referenced
-
       # Mixin module included into Mongoid::Document which adds
       # the ability to automatically save opposite-side documents
       # in referenced associations when saving the subject document.
@@ -32,13 +30,24 @@ module Mongoid
           Threaded.exit_autosave(self)
         end
 
-        # Check if there is changes for auto-saving
+        # Check if there are changes for auto-saving. Returns true if the
+        # document is new, changed, or marked for destruction, or if any
+        # in-memory referenced child with autosave: true recursively
+        # satisfies the same condition.
+        #
+        # The seen set prevents infinite recursion when autosave associations
+        # form a cycle (e.g. a belongs_to with autosave: true whose target
+        # has a has_many with autosave: true pointing back).
         #
-        # @example Return true if there is changes on self or in
-        #           autosaved associations.
-        #   document.changed_for_autosave?
-        def changed_for_autosave?(doc)
-          doc.new_record? || doc.changed? || doc.marked_for_destruction?
+        # @param [ Document ] doc The document to check.
+        # @param [ Set ] seen Documents already visited (cycle guard).
+        #
+        # @return [ true | false ] Whether the document needs autosaving.
+        def changed_for_autosave?(doc, seen = Set.new)
+          return false unless seen.add?(doc)
+
+          doc.new_record? || doc.changed? || doc.marked_for_destruction? ||
+            autosave_children_changed?(doc, seen)
         end
 
         # Define the autosave method on an association's owning class for
@@ -60,6 +69,8 @@ module Mongoid
                 __autosaving__ do
                   if assoc_value = ivar(association.name)
                     Array(assoc_value).each do |doc|
+                      next unless changed_for_autosave?(doc)
+
                       pc = doc.persistence_context? ? doc.persistence_context : persistence_context.for_child(doc)
                       doc.with(pc) do |d|
                         d.save
@@ -72,6 +83,35 @@ module Mongoid
             klass.after_persist_parent save_method, unless: :autosaved?
           end
         end
+
+        private
+
+        # Returns true if any in-memory referenced child with autosave: true
+        # needs saving.
+        #
+        # @param [ Document ] doc The document whose children to check.
+        # @param [ Set ] seen Cycle guard passed through from changed_for_autosave?.
+        #
+        # @return [ true | false ]
+        def autosave_children_changed?(doc, seen)
+          if Mongoid.autosave_saves_unchanged_documents?
+            Mongoid::Warnings.warn_autosave_saves_unchanged_documents
+            return true
+          end
+
+          doc.class.relations.values.select { |a| a.autosave? && !a.embedded? }.any? do |assoc|
+            (assoc_value = doc.ivar(assoc.name)) &&
+              in_memory_docs(assoc_value).any? { |child| changed_for_autosave?(child, seen) }
+          end
+        end
+
+        # Returns the in-memory documents for an association value without
+        # triggering a database load of any unloaded documents. Association
+        # proxies expose in_memory for this purpose; a plain document (which
+        # belongs_to can store directly in the ivar) is itself in-memory.
+        def in_memory_docs(assoc_value)
+          assoc_value.respond_to?(:in_memory) ? assoc_value.in_memory : [ assoc_value ]
+        end
       end
     end
   end

data/lib/mongoid/association/referenced/belongs_to/binding.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Referenced
       class BelongsTo
-
         # Binding class for belongs_to associations.
         class Binding
           include Bindable
@@ -30,14 +28,12 @@ module Mongoid
                 bind_polymorphic_inverse_type(_base, key)
               end
 
-              if inverse = _association.inverse(_target)
-                if set_base_association
-                  if _base.referenced_many?
-                    _target.__send__(inverse).push(_base)
-                  else
-                    remove_associated(_target)
-                    _target.set_relation(inverse, _base)
-                  end
+              if (inverse = _association.inverse(_target)) && set_base_association
+                if _base.referenced_many?
+                  _target.__send__(inverse).push(_base)
+                else
+                  remove_associated(_target)
+                  _target.set_relation(inverse, _base)
                 end
               end
             end
@@ -77,11 +73,11 @@ module Mongoid
           # @param [ Document ] doc The document to check.
           def check_polymorphic_inverses!(doc)
             inverses = _association.inverses(doc)
-            if inverses.length > 1 && _base.send(_association.foreign_key).nil?
-              raise Errors::InvalidSetPolymorphicRelation.new(
-                  _association.name, _base.class.name, _target.class.name
-              )
-            end
+            return unless inverses.length > 1 && _base.send(_association.foreign_key).nil?
+
+            raise Errors::InvalidSetPolymorphicRelation.new(
+              _association.name, _base.class.name, _target.class.name
+            )
           end
         end
       end

data/lib/mongoid/association/referenced/belongs_to/buildable.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Referenced
       class BelongsTo
-
         # The Builder behavior for belongs_to associations.
         module Buildable
-
           # This method either takes an _id or an object and queries for the
           # inverse side using the id or sets the object.
           #
@@ -21,8 +18,25 @@ module Mongoid
           # @param [ nil ] selected_fields Must be nil.
           #
           # @return [ Document ] A single document.
-          def build(base, object, type = nil, selected_fields = nil)
+          def build(_base, object, type = nil, selected_fields = nil)
             return object unless query?(object)
+
+            # Handle array from $lookup aggregation (returns array even for belongs_to)
+            if object.is_a?(Array)
+              first = object.first
+              case first
+              when nil, Mongoid::Document then return first
+              when Hash then return Factory.execute_from_db(klass, first, nil, selected_fields,
+                                                            execute_callbacks: false)
+              else raise ArgumentError, 'Cannot build belongs_to association from array'
+              end
+            end
+
+            # Handle single hash from $lookup with $unwind
+            if object.is_a?(Hash)
+              return Factory.execute_from_db(klass, object, nil, selected_fields, execute_callbacks: false)
+            end
+
             execute_query(object, type)
           end
 
@@ -33,7 +47,11 @@ module Mongoid
           end
 
           def query_criteria(object, type)
-            cls = type ? (type.is_a?(String) ? type.constantize : type) : relation_class
+            cls = if type
+                    type.is_a?(String) ? type.constantize : type
+                  else
+                    relation_class
+                  end
             crit = cls.criteria
             crit = crit.apply_scope(scope)
             crit.where(primary_key => object)

data/lib/mongoid/association/referenced/belongs_to/eager.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Referenced
       class BelongsTo
-
         # Eager class for belongs_to associations.
         class Eager < Association::Eager
-
           private
 
           def preload
@@ -45,6 +42,7 @@ module Mongoid
 
             @docs.each_with_object({}) do |doc, keys_by_type|
               next unless doc.respond_to?(inverse_type_field) && doc.respond_to?(group_by_key)
+
               inverse_type_name = doc.send(inverse_type_field)
               # If a particular document does not have a value for this
               # association, inverse_type_name will be nil.