mongoid 7.5.2 → 7.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e67e9eccd518e5c987bbca2d4943a461d7ceaf382abd091842806fb300dffb1e
-  data.tar.gz: 441f04f551b51c8b5f3300e4158fd7d0b6b0c3406b39dfa073bf1ce11cead324
+  metadata.gz: 27b0f244fe4642a684c267744270dd8e72b2b3ae1074b3621c24b31e979299b6
+  data.tar.gz: a79526be9f430f3777a35b2c27271175eca415c57ab2ae0346e3050b52f9311f
 SHA512:
-  metadata.gz: 31d1d76cbe4923b0cb2a54a62d3758183a80ef8c8833448760115d2299153724e8cb2e6160745989357f6a4bbd3e6873380e73f500e13ffb14b307dfa503a3a9
-  data.tar.gz: 9c3acad387939c0bfe4746102e73e24124597bf311adbd3ce301bfe9a6882a066dadbb67ccb05a470a983c6b0d55ca43cce01f247111cd9d64efb2653614fbd8
+  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/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/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.2"
+  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/contextual/mongo_spec.rb

@@ -1554,9 +1554,9 @@ describe Mongoid::Contextual::Mongo do
           expect(context.send(method)).to eq(depeche_mode)
         end
 
-        context 'when calling #last' do
+        context "when calling ##{method}" do
 
-          it 'returns the last document, sorted by _id' do
+          it 'returns the requested document, sorted by _id' do
             expect(context.send(method)).to eq(depeche_mode)
             expect(context.last).to eq(rolling_stones)
           end
@@ -1571,7 +1571,7 @@ describe Mongoid::Contextual::Mongo do
             expect(context.send(method, opts)).to eq(depeche_mode)
           end
 
-          context 'when calling #last' do
+          context "when calling ##{method}" do
 
             it 'doesn\'t apply a sort on _id' do
               expect(context.send(method, opts)).to eq(depeche_mode)
@@ -1883,6 +1883,16 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
+      context "when given an empty hash" do
+        let(:context) { described_class.new(criteria) }
+        let(:criteria) { Band.criteria }
+        let(:docs) { context.send(method, {}) }
+
+        it "behaves as if limit is nil" do
+          expect(docs).to eq(depeche_mode)
+        end
+      end
+      
       context "when calling #first then #last" do
 
         let(:context) do
@@ -2358,6 +2368,16 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context "when given an empty hash" do
+      let(:context) { described_class.new(criteria) }
+      let(:criteria) { Band.criteria }
+      let(:docs) { context.last({}) }
+
+      it "behaves as if limit is nil" do
+        expect(docs).to eq(rolling_stones)
+      end
+    end
   end
 
   describe "#initialize" do

data/spec/mongoid/shardable_models.rb

@@ -59,3 +59,17 @@ end
 class SmNotSharded
   include Mongoid::Document
 end
+
+class SmReviewAuthor
+  include Mongoid::Document
+  embedded_in :review, class_name: "SmReview", touch: false
+  field :name, type: String
+end
+
+class SmReview
+  include Mongoid::Document
+
+  embeds_one :author, class_name: "SmReviewAuthor"
+
+  shard_key "author.name" => 1
+end