mongoid 7.5.1 → 7.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35ea6871ead43684bcaba29452a4d21a63d40a2703e5a954c60318bc4242759f
-  data.tar.gz: bb819713b38b1639d9e0ccc4ac95bd171a054fc1025b330cbac492f980d93015
+  metadata.gz: 27b0f244fe4642a684c267744270dd8e72b2b3ae1074b3621c24b31e979299b6
+  data.tar.gz: a79526be9f430f3777a35b2c27271175eca415c57ab2ae0346e3050b52f9311f
 SHA512:
-  metadata.gz: 80981e2b9473bac38edf29ee73aa49f4f5932b577ee8095e1af9407f113e9a156f5860049300c8b486ec66ff267ec8fd9b91007697d3d6e953cc65580e29e4b9
-  data.tar.gz: 45077ad45b7d833dddaee515736c3faf54b5472e684a1e0e4220c1bff1b6ba6b9284bea082b235eb7371540af95481e728ad09c082ae40f5cf3d6d77f45e2f11
+  metadata.gz: 88c97668e4474dc109a910b2faa28f08b4c105b02e0f43611df3f2122e1232d9c3b2bfaedaf8aebebccf4358c40bc65c6bd04cfdc252c8ceca286aecf5b2d77e
+  data.tar.gz: ec9a56811c18fcf4cdeb238a7aa85eb350bc86513d9a883cd8f603122189af3da71bd0eea3a830ac06a26af30424648af935bf633f56ec740d045e94209b24fe

data/lib/mongoid/association/embedded/batchable.rb

@@ -80,7 +80,8 @@ module Mongoid
         def batch_replace(docs)
           if docs.blank?
             if _assigning? && !empty?
-              _base.delayed_atomic_sets.clear
+              _base.delayed_atomic_sets.delete(path)
+              clear_atomic_path_cache
               _base.add_atomic_unset(first)
               target_duplicate = _target.dup
               pre_process_batch_remove(target_duplicate, :delete)
@@ -92,7 +93,8 @@ module Mongoid
             _base.delayed_atomic_sets.clear unless _assigning?
             docs = normalize_docs(docs).compact
             _target.clear and _unscoped.clear
-            _base.delayed_atomic_unsets.clear
+            _base.delayed_atomic_unsets.delete(path)
+            clear_atomic_path_cache
             inserts = execute_batch_set(docs)
             add_atomic_sets(inserts)
           end
@@ -234,7 +236,22 @@ module Mongoid
         #
         # @return [ String ] The atomic path.
         def path
-          @path ||= _unscoped.first.atomic_path
+          @path ||= if _unscoped.empty?
+            Mongoid::Atomic::Paths::Embedded::Many.position_without_document(_base, _association)
+          else
+            _unscoped.first.atomic_path
+          end
+        end
+
+        # Clear the cache for path and atomic_paths. This method is used when
+        # the path method is used, and the association has not been set on the
+        # document yet, which can cause path and atomic_paths to be calculated
+        # incorrectly later.
+        #
+        # @api private
+        def clear_atomic_path_cache
+          self.path = nil
+          _base.instance_variable_set("@atomic_paths", nil)
         end
 
         # Set the atomic path.

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

@@ -15,7 +15,7 @@ module Mongoid
     # plural model name.
     #
     # If new_record?     - will append /new
-    # If not             - will append /id-updated_at.to_s(cache_timestamp_format)
+    # If not             - will append /id-updated_at.to_formatted_s(cache_timestamp_format)
     # Without updated_at - will append /id
     #
     # This is usually called inside a cache() block
@@ -26,7 +26,7 @@ module Mongoid
     # @return [ String ] the string with or without updated_at
     def cache_key
       return "#{model_key}/new" if new_record?
-      return "#{model_key}/#{_id}-#{updated_at.utc.to_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
+      return "#{model_key}/#{_id}-#{updated_at.utc.to_formatted_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
       "#{model_key}/#{_id}"
     end
   end

data/lib/mongoid/config.rb

@@ -116,6 +116,12 @@ module Mongoid
     # using and's instead of overwriting them.
     option :overwrite_chained_operators, default: true
 
+    # 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: true
+
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.
     #

data/lib/mongoid/contextual/mongo.rb

@@ -260,16 +260,16 @@ module Mongoid
       #
       # @return [ Document ] The first document.
       def first(limit_or_opts = nil)
-        limit = limit_or_opts unless limit_or_opts.is_a?(Hash)
+        limit, opts = extract_limit_and_opts(limit_or_opts)
         if cached? && cache_loaded?
           return limit ? documents.first(limit) : documents.first
         end
         try_numbered_cache(:first, limit) do
-          if limit_or_opts.try(:key?, :id_sort)
+          if opts.key?(:id_sort)
             Mongoid::Warnings.warn_id_sort_deprecated
           end
           sorted_view = view
-          if sort = view.sort || ({ _id: 1 } unless limit_or_opts.try(:fetch, :id_sort) == :none)
+          if sort = view.sort || ({ _id: 1 } unless opts[:id_sort] == :none)
             sorted_view = view.sort(sort)
           end
           if raw_docs = sorted_view.limit(limit || 1).to_a
@@ -376,12 +376,12 @@ module Mongoid
       #
       # @return [ Document ] The last document.
       def last(limit_or_opts = nil)
-        limit = limit_or_opts unless limit_or_opts.is_a?(Hash)
+        limit, opts = extract_limit_and_opts(limit_or_opts)
         if cached? && cache_loaded?
           return limit ? documents.last(limit) : documents.last
         end
         res = try_numbered_cache(:last, limit) do
-          with_inverse_sorting(limit_or_opts) do
+          with_inverse_sorting(opts) do
             if raw_docs = view.limit(limit || 1).to_a
               process_raw_docs(raw_docs, limit)
             end
@@ -612,6 +612,23 @@ module Mongoid
         end
       end
 
+      # Extract the limit and opts from the given argument, so that code
+      # can operate without having to worry about the current type and
+      # state of the argument.
+      #
+      # @param [ nil | Integer | Hash ] limit_or_opts The value to pull the
+      #   limit and option hash from.
+      #
+      # @return [ Array<nil | Integer, Hash> ] A 2-array of the limit and the
+      #   option hash.
+      def extract_limit_and_opts(limit_or_opts)
+        case limit_or_opts
+        when nil, Integer then [ limit_or_opts, {} ]
+        when Hash then [ nil, limit_or_opts ]
+        else raise ArgumentError, "expected nil, Integer, or Hash"
+        end
+      end
+
       # Update the documents for the provided method.
       #
       # @api private
@@ -676,10 +693,10 @@ module Mongoid
       # @example Apply the inverse sorting params to the given block
       #   context.with_inverse_sorting
       def with_inverse_sorting(opts = {})
-        Mongoid::Warnings.warn_id_sort_deprecated if opts.try(:key?, :id_sort)
+        Mongoid::Warnings.warn_id_sort_deprecated if opts.key?(:id_sort)
 
         begin
-          if sort = criteria.options[:sort] || ( { _id: 1 } unless opts.try(:fetch, :id_sort) == :none )
+          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

data/lib/mongoid/document.rb

@@ -277,8 +277,15 @@ module Mongoid
       #   criteria.
       #
       # @return [ Document ] A new document.
+      #
+      # @api private
       def instantiate(attrs = nil, selected_fields = nil)
-        attributes = attrs || {}
+        attributes = if Mongoid.legacy_attributes
+          attrs
+        else
+          attrs&.to_h
+        end || {}
+
         doc = allocate
         doc.__selected_fields = selected_fields
         doc.instance_variable_set(:@attributes, attributes)

data/lib/mongoid/persistence_context.rb

@@ -122,6 +122,21 @@ module Mongoid
       options == other.options
     end
 
+    # Whether the client of the context can be reused later, and therefore should
+    # not be closed.
+    #
+    # If the persistence context is requested with :client option only, it means
+    # that the context should use a client configured in mongoid.yml.
+    # Such clients should not be closed when the context is cleared since they
+    # will be reused later.
+    #
+    # @return [ true | false ] True if client can be reused, otherwise false.
+    #
+    # @api private
+    def reusable_client?
+      @options.keys == [:client]
+    end
+
     private
 
     def set_options!(opts)
@@ -172,8 +187,7 @@ module Mongoid
       #
       # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
       def set(object, options_or_context)
-        key = "[mongoid][#{object.object_id}]:context"
-        existing_context = Thread.current[key]
+        existing_context = get_context(object)
         existing_options = if existing_context
           existing_context.options
         else
@@ -184,7 +198,7 @@ module Mongoid
         end
         new_options = existing_options.merge(options_or_context)
         context = PersistenceContext.new(object, new_options)
-        Thread.current[key] = context
+        store_context(object, context)
       end
 
       # Get the persistence context for a particular class or model instance.
@@ -196,7 +210,7 @@ module Mongoid
       #
       # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
       def get(object)
-        Thread.current["[mongoid][#{object.object_id}]:context"]
+        get_context(object)
       end
 
       # Clear the persistence context for a particular class or model instance.
@@ -211,11 +225,48 @@ module Mongoid
       def clear(object, cluster = nil, original_context = nil)
         if context = get(object)
           unless cluster.nil? || context.cluster.equal?(cluster)
-            context.client.close
+            context.client.close unless context.reusable_client?
           end
         end
       ensure
-        Thread.current["[mongoid][#{object.object_id}]:context"] = original_context
+        store_context(object, original_context)
+      end
+
+      private
+
+      # Key to store persistence contexts in the thread local storage.
+      #
+      # @api private
+      PERSISTENCE_CONTEXT_KEY = :"[mongoid]:persistence_context"
+
+      # Get the persistence context for a given object from the thread local
+      #   storage.
+      #
+      # @param [ Object ] object Object to get the persistance context for.
+      #
+      # @return [ Mongoid::PersistenceContext | nil ] The persistence context
+      #   for the object if previously stored, otherwise nil.
+      #
+      # @api private
+      def get_context(object)
+        Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
+        Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id]
+      end
+
+      # Store persistence context for a given object in the thread local
+      #   storage.
+      #
+      # @param [ Object ] object Object to store the persistance context for.
+      # @param [ Mongoid::PersistenceContext ] context Context to store
+      #
+      # @api private
+      def store_context(object, context)
+        if context.nil?
+          Thread.current[PERSISTENCE_CONTEXT_KEY]&.delete(object.object_id)
+        else
+          Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
+          Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id] = context
+        end
       end
     end
   end

data/lib/mongoid/shardable.rb

@@ -47,18 +47,22 @@ module Mongoid
       self.class.shard_key_fields
     end
 
-    # Returns the selector that would match the current version of this
-    # document.
+    # Returns the selector that would match the defined shard keys. If
+    # `prefer_persisted` is false (the default), it uses the current values
+    # of the specified shard keys, otherwise, it will try to use whatever value
+    # was most recently persisted.
+    #
+    # @param [ true | false ] prefer_persisted Whether to use the current
+    #   value of the shard key fields, or to use their most recently persisted
+    #   values.
     #
     # @return [ Hash ] The shard key selector.
     #
     # @api private
-    def shard_key_selector
-      selector = {}
-      shard_key_fields.each do |field|
-        selector[field.to_s] = send(field)
+    def shard_key_selector(prefer_persisted: false)
+      shard_key_fields.each_with_object({}) do |field, selector|
+        selector[field.to_s] = shard_key_field_value(field.to_s, prefer_persisted: prefer_persisted)
       end
-      selector
     end
 
     # Returns the selector that would match the existing version of this
@@ -72,11 +76,31 @@ module Mongoid
     #
     # @api private
     def shard_key_selector_in_db
-      selector = {}
-      shard_key_fields.each do |field|
-        selector[field.to_s] = new_record? ? send(field) : attribute_was(field)
+      shard_key_selector(prefer_persisted: true)
+    end
+
+    # Returns the value for the named shard key. If the field identifies
+    # an embedded document, the key will be parsed and recursively evaluated.
+    # If `prefer_persisted` is true, the value last persisted to the database
+    # will be returned, regardless of what the current value of the attribute
+    # may be.
+    #
+    # @param [String] field The name of the field to evaluate
+    # @param [ true|false ] prefer_persisted Whether or not to prefer the
+    #   persisted value over the current value.
+    #
+    # @return [ Object ] The value of the named field.
+    #
+    # @api private
+    def shard_key_field_value(field, prefer_persisted:)
+      if field.include?(".")
+        relation, remaining = field.split(".", 2)
+        send(relation)&.shard_key_field_value(remaining, prefer_persisted: prefer_persisted)
+      elsif prefer_persisted && !new_record?
+        attribute_was(field)
+      else
+        send(field)
       end
-      selector
     end
 
     module ClassMethods

data/lib/mongoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mongoid
-  VERSION = "7.5.1"
+  VERSION = "7.5.3"
 end

data/spec/mongoid/association/embedded/embeds_many/proxy_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative '../embeds_many_models.rb'
 
 describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
 
@@ -4649,4 +4650,24 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
       end
     end
   end
+
+  context "when using assign_attributes with an already populated array" do
+    let(:post) { EmmPost.create! }
+
+    before do
+      post.assign_attributes(company_tags: [{id: BSON::ObjectId.new, title: 'a'}],
+        user_tags: [{id: BSON::ObjectId.new, title: 'b'}])
+      post.save!
+      post.reload
+      post.assign_attributes(company_tags: [{id: BSON::ObjectId.new, title: 'c'}],
+        user_tags: [])
+      post.save!
+      post.reload
+    end
+
+    it "has the correct embedded documents" do
+      expect(post.company_tags.length).to eq(1)
+      expect(post.company_tags.first.title).to eq("c")
+    end
+  end
 end

data/spec/mongoid/association/embedded/embeds_many_models.rb

@@ -67,3 +67,124 @@ class EmmOuter
 
   field :level, :type => Integer
 end
+
+class EmmCustomerAddress
+  include Mongoid::Document
+
+  embedded_in :addressable, polymorphic: true, inverse_of: :work_address
+end
+
+class EmmFriend
+  include Mongoid::Document
+
+  embedded_in :befriendable, polymorphic: true
+end
+
+class EmmCustomer
+  include Mongoid::Document
+
+  embeds_one :home_address, class_name: 'EmmCustomerAddress', as: :addressable
+  embeds_one :work_address, class_name: 'EmmCustomerAddress', as: :addressable
+
+  embeds_many :close_friends, class_name: 'EmmFriend', as: :befriendable
+  embeds_many :acquaintances, class_name: 'EmmFriend', as: :befriendable
+end
+
+class EmmUser
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  embeds_many :orders, class_name: 'EmmOrder'
+end
+
+class EmmOrder
+  include Mongoid::Document
+
+  field :amount, type: Integer
+
+  embedded_in :user, class_name: 'EmmUser'
+end
+
+module EmmSpec
+  # There is also a top-level Car class defined.
+  class Car
+    include Mongoid::Document
+
+    embeds_many :doors
+  end
+
+  class Door
+    include Mongoid::Document
+
+    embedded_in :car
+  end
+
+  class Tank
+    include Mongoid::Document
+
+    embeds_many :guns
+    embeds_many :emm_turrets
+    # This association references a model that is not in our module,
+    # and it does not define class_name hence Mongoid will not be able to
+    # figure out the inverse for this association.
+    embeds_many :emm_hatches
+
+    # class_name is intentionally unqualified, references a class in the
+    # same module. Rails permits class_name to be unqualified like this.
+    embeds_many :launchers, class_name: 'Launcher'
+  end
+
+  class Gun
+    include Mongoid::Document
+
+    embedded_in :tank
+  end
+
+  class Launcher
+    include Mongoid::Document
+
+    # class_name is intentionally unqualified.
+    embedded_in :tank, class_name: 'Tank'
+  end
+end
+
+# This is intentionally on top level.
+class EmmTurret
+  include Mongoid::Document
+
+  embedded_in :tank, class_name: 'EmmSpec::Tank'
+end
+
+# This is intentionally on top level.
+class EmmHatch
+  include Mongoid::Document
+
+  # No :class_name option on this association intentionally.
+  embedded_in :tank
+end
+
+class EmmPost
+  include Mongoid::Document
+
+  embeds_many :company_tags, class_name: "EmmCompanyTag"
+  embeds_many :user_tags, class_name: "EmmUserTag"
+end
+
+
+class EmmCompanyTag
+  include Mongoid::Document
+
+  field :title, type: String
+
+  embedded_in :post, class_name: "EmmPost"
+end
+
+
+class EmmUserTag
+  include Mongoid::Document
+
+  field :title, type: String
+
+  embedded_in :post, class_name: "EmmPost"
+end
+

data/spec/mongoid/association/referenced/has_and_belongs_to_many/proxy_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative "../has_and_belongs_to_many_models.rb"
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
 
@@ -3770,4 +3771,33 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
       expect(p2.d_ids).to match_array([d2.id])
     end
   end
+
+  # This test is for MONGOID-5344 which tests that the initial call to
+  # signature_ids refers to the same array as subsequent calls to signature_ids.
+  # Prior to the change in that ticket, this test broke because the array
+  # returned from write_attribute (which is triggered the first time the
+  # foreign key array is referenced, to set the default), refers to a different
+  # array to the one stored in the attributes hash. This happened because,
+  # when retrieving a document from the database, the attributes hash is actually
+  # a BSON::Document, which applies a transformation to the array before
+  # storing it.
+  context "when executing concat on foreign key array from the db" do
+    config_override :legacy_attributes, false
+
+    before do
+      HabtmmContract.create!
+      HabtmmSignature.create!
+    end
+
+    let!(:contract) { HabtmmContract.first }
+    let!(:signature) { HabtmmSignature.first }
+
+    before do
+      contract.signature_ids.concat([signature.id])
+    end
+
+    it "works on the first attempt" do
+      expect(contract.signature_ids).to eq([signature.id])
+    end
+  end
 end

data/spec/mongoid/association/referenced/has_many/proxy_spec.rb

@@ -4089,4 +4089,24 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       expect(band.same_name).to eq([agent])
     end
   end
+
+  context "when executing concat on foreign key array from the db" do
+    config_override :legacy_attributes, false
+
+    before do
+      Agent.create!
+      Basic.create!
+    end
+
+    let!(:agent) { Agent.first }
+    let!(:basic) { Basic.first }
+
+    before do
+      agent.basic_ids.concat([basic.id])
+    end
+
+    it "works on the first attempt" do
+      expect(agent.basic_ids).to eq([basic.id])
+    end
+  end
 end

data/spec/mongoid/attributes_spec.rb

@@ -1675,6 +1675,50 @@ describe Mongoid::Attributes do
         end
       end
     end
+
+    context "when comparing the object_ids of the written value" do
+      config_override :legacy_attributes, false
+
+      before do
+        Person.create!
+      end
+
+      let(:person) do
+        Person.first
+      end
+
+      context "when the field is not resizable" do
+        let(:test) do
+          person.write_attribute(:test, "aliased field to test")
+        end
+
+        it "has the same object_id as the attributes hash value" do
+          expect(test.object_id).to eq(person.test.object_id)
+        end
+      end
+
+      context "when the field is resizable" do
+
+        let(:arrays) do
+          person.write_attribute(:arrays, [])
+        end
+
+        it "has the same object_id as the attributes hash value" do
+          expect(arrays.object_id).to eq(person.arrays.object_id)
+        end
+      end
+
+      context "when the field is a HABTM foreign key array" do
+
+        let(:preference_ids) do
+          person.write_attribute(:preference_ids, [])
+        end
+
+        it "has the same object_id as the attributes hash value" do
+          expect(preference_ids.object_id).to eq(person.preference_ids.object_id)
+        end
+      end
+    end
   end
 
   describe "#typed_value_for" do

data/spec/mongoid/cacheable_spec.rb

@@ -45,7 +45,7 @@ describe Mongoid::Cacheable do
         context "with the default cache_timestamp_format" do
 
           let!(:updated_at) do
-            document.updated_at.utc.to_s(:nsec)
+            document.updated_at.utc.to_formatted_s(:nsec)
           end
 
           it "has the id and updated_at key name" do
@@ -64,7 +64,7 @@ describe Mongoid::Cacheable do
           end
 
           let!(:updated_at) do
-            document.updated_at.utc.to_s(:number)
+            document.updated_at.utc.to_formatted_s(:number)
           end
 
           it "has the id and updated_at key name" do
@@ -103,7 +103,7 @@ describe Mongoid::Cacheable do
       end
 
       let!(:updated_at) do
-        agent.updated_at.utc.to_s(:nsec)
+        agent.updated_at.utc.to_formatted_s(:nsec)
       end
 
       it "has the id and updated_at key name" do