mongoid 9.1.1 → 9.1.2

data/lib/mongoid/tasks/database.rb

@@ -64,15 +64,18 @@ module Mongoid
       # @param [ true | false ] wait whether to wait for the indexes to be
       #   built.
       def create_search_indexes(models = ::Mongoid.models, wait: true)
-        searchable = models.select { |m| m.search_index_specs.any? }
+        Threaded.with_collection_management do
+          searchable = models.select { |m| m.search_index_specs.any? }
 
-        # queue up the search index creation requests
-        index_names_by_model = searchable.each_with_object({}) do |model, obj|
-          logger.info("MONGOID: Creating search indexes on #{model}...")
-          obj[model] = model.create_search_indexes
-        end
+          # queue up the search index creation requests
+          index_names_by_model = searchable.each_with_object({}) do |model, obj|
+            logger.info("MONGOID: Creating search indexes on #{model}...")
+            obj[model] = model.create_search_indexes
+          end
 
-        wait_for_search_indexes(index_names_by_model) if wait
+          wait_for_search_indexes(index_names_by_model) if wait
+          index_names_by_model
+        end
       end
 
       # Return the list of indexes by model that exist in the database but aren't

data/lib/mongoid/touchable.rb

@@ -49,7 +49,7 @@ module Mongoid
 
         begin
           touches = _gather_touch_updates(Time.current, field)
-          _root.send(:persist_atomic_operations, '$set' => touches) if touches.present?
+          _root.persist_atomic_operations('$set' => touches) if touches.present?
           _run_touch_callbacks_from_root
         ensure
           _clear_touch_updates(field)
@@ -104,6 +104,33 @@ module Mongoid
         run_callbacks(:touch)
       end
 
+      # The root-relative paths that a touch of this document's parent chain
+      # writes: the (possibly aliased) +updated_at+ field of each touchable
+      # node in the chain, plus this document's custom touch field, if any.
+      #
+      # @api private
+      #
+      # @param [ Symbol, String, nil ] field The custom touch field.
+      #
+      # @return [ Array<String> ] The touchable paths.
+      def _touchable_chain_paths(field = nil)
+        field = database_field_name(field) if field
+
+        node = self
+        paths = []
+        loop do
+          if node.respond_to?(:updated_at=)
+            paths << node.atomic_attribute_name(node.database_field_name(:updated_at))
+          end
+          paths << node.atomic_attribute_name(field) if node.equal?(self) && field
+
+          break unless node._touchable_parent?
+
+          node = node._parent
+        end
+        paths
+      end
+
       # Indicates whether the parent exists and is touchable.
       #
       # @api private

data/lib/mongoid/version.rb

@@ -5,5 +5,5 @@ module Mongoid
   #
   # Note that this file is automatically updated via `rake candidate:create`.
   # Manual changes to this file will be overwritten by that rake task.
-  VERSION = '9.1.1'
+  VERSION = '9.1.2'
 end

data/lib/mongoid/warnings.rb

@@ -36,5 +36,9 @@ module Mongoid
     warning :autosave_saves_unchanged_documents, "Autosave associations are currently configured to save documents even if they haven't changed. " \
                                                  'This legacy behavior is deprecated. Set Mongoid.autosave_saves_unchanged_documents to false to ' \
                                                  'skip saving unchanged documents in autosave associations.'
+    warning :bypass_auto_encryption,
+            'auto_encryption_options includes bypass_auto_encryption: true. The driver ' \
+            'will not encrypt anything for this client: fields declared with encrypt: true ' \
+            'are written to the database unencrypted.'
   end
 end

data/spec/integration/associations/embedded_delayed_atomic_sets_spec.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module EmbeddedDelayedAtomicSetsSpec
+  class Section
+    include Mongoid::Document
+
+    field :content
+
+    embedded_in :parent, polymorphic: true
+  end
+
+  class Group
+    include Mongoid::Document
+
+    embedded_in :root
+    embeds_many :sections, class_name: 'EmbeddedDelayedAtomicSetsSpec::Section'
+    accepts_nested_attributes_for :sections
+  end
+
+  class Root
+    include Mongoid::Document
+
+    embeds_many :sections, class_name: 'EmbeddedDelayedAtomicSetsSpec::Section'
+    embeds_one :group, class_name: 'EmbeddedDelayedAtomicSetsSpec::Group'
+    accepts_nested_attributes_for :sections
+    accepts_nested_attributes_for :group
+  end
+end
+
+module NewEmbeddedChildSpec
+  class Member
+    include Mongoid::Document
+
+    field :name
+
+    embedded_in :team
+  end
+
+  class Team
+    include Mongoid::Document
+
+    embedded_in :org
+    embeds_many :members, class_name: 'NewEmbeddedChildSpec::Member'
+    accepts_nested_attributes_for :members
+  end
+
+  class Org
+    include Mongoid::Document
+
+    field :title
+
+    embeds_one :team, class_name: 'NewEmbeddedChildSpec::Team'
+    accepts_nested_attributes_for :team
+  end
+end
+
+RSpec.describe 'embedded delayed atomic sets' do
+  context 'with the same stored name' do
+    let!(:root) do
+      root = EmbeddedDelayedAtomicSetsSpec::Root.new
+      root.sections = [ EmbeddedDelayedAtomicSetsSpec::Section.new(content: 'root-original') ]
+      root.save!
+      root
+    end
+
+    def stored_document
+      EmbeddedDelayedAtomicSetsSpec::Root.collection.find(_id: root.id).first
+    end
+
+    def stored_contents(sections)
+      sections.to_a.map { |section| section['content'] }
+    end
+
+    def document_contents(sections)
+      sections.map(&:content)
+    end
+
+    # The persisted root has no group, so attributes= builds the new nested group
+    # while the root sections update is still pending.
+    it 'does not merge a new child into the parent association' do
+      reloaded = EmbeddedDelayedAtomicSetsSpec::Root.find(root.id)
+      reloaded.attributes = {
+        sections: [ { _id: reloaded.sections.first.id, content: 'root-updated' } ],
+        group: { sections: [ { content: 'group-new' } ] }
+      }
+      reloaded.save!
+
+      stored = stored_document
+      expect(stored_contents(stored['sections'])).to eq [ 'root-updated' ]
+      expect(stored_contents(stored.dig('group', 'sections'))).to eq [ 'group-new' ]
+      expect(document_contents(reloaded.sections)).to eq [ 'root-updated' ]
+      expect(document_contents(reloaded.group.sections)).to eq [ 'group-new' ]
+    end
+
+    it 'does not copy a new child into an empty parent association' do
+      reloaded = EmbeddedDelayedAtomicSetsSpec::Root.find(root.id)
+      reloaded.attributes = {
+        sections: [],
+        group: { sections: [ { content: 'group-new' } ] }
+      }
+      reloaded.save!
+
+      stored = stored_document
+      expect(stored).not_to have_key('sections')
+      expect(stored_contents(stored.dig('group', 'sections'))).to eq [ 'group-new' ]
+      expect(reloaded.sections).to be_empty
+      expect(document_contents(reloaded.group.sections)).to eq [ 'group-new' ]
+    end
+
+    it 'does not merge a new child when the parent association is unchanged' do
+      reloaded = EmbeddedDelayedAtomicSetsSpec::Root.find(root.id)
+      reloaded.attributes = { group: { sections: [ { content: 'group-new' } ] } }
+      reloaded.save!
+
+      stored = stored_document
+      expect(stored_contents(stored['sections'])).to eq [ 'root-original' ]
+      expect(stored_contents(stored.dig('group', 'sections'))).to eq [ 'group-new' ]
+      expect(document_contents(reloaded.sections)).to eq [ 'root-original' ]
+      expect(document_contents(reloaded.group.sections)).to eq [ 'group-new' ]
+    end
+
+    it 'updates an existing group and isolates a subsequently added group' do
+      root.group = EmbeddedDelayedAtomicSetsSpec::Group.new(
+        sections: [ EmbeddedDelayedAtomicSetsSpec::Section.new(content: 'group-original') ]
+      )
+      root.save!
+
+      reloaded = EmbeddedDelayedAtomicSetsSpec::Root.find(root.id)
+      reloaded.attributes = {
+        group: {
+          _id: reloaded.group.id,
+          sections: [ { _id: reloaded.group.sections.first.id, content: 'group-updated' } ]
+        }
+      }
+      reloaded.save!
+
+      stored = stored_document
+      expect(stored_contents(stored['sections'])).to eq [ 'root-original' ]
+      expect(stored_contents(stored.dig('group', 'sections'))).to eq [ 'group-updated' ]
+      expect(document_contents(reloaded.sections)).to eq [ 'root-original' ]
+      expect(document_contents(reloaded.group.sections)).to eq [ 'group-updated' ]
+
+      reloaded.group = nil
+      reloaded.save!
+      reloaded = EmbeddedDelayedAtomicSetsSpec::Root.find(root.id)
+      reloaded.attributes = {
+        sections: [ { _id: reloaded.sections.first.id, content: 'root-updated' } ],
+        group: { sections: [ { content: 'group-new' } ] }
+      }
+      reloaded.save!
+
+      stored = stored_document
+      expect(stored_contents(stored['sections'])).to eq [ 'root-updated' ]
+      expect(stored_contents(stored.dig('group', 'sections'))).to eq [ 'group-new' ]
+      expect(document_contents(reloaded.sections)).to eq [ 'root-updated' ]
+      expect(document_contents(reloaded.group.sections)).to eq [ 'group-new' ]
+    end
+
+    it 'does not merge a new child when updating the parent through nested attributes' do
+      reloaded = EmbeddedDelayedAtomicSetsSpec::Root.find(root.id)
+      reloaded.attributes = {
+        sections_attributes: {
+          '0' => { _id: reloaded.sections.first.id, content: 'root-updated' }
+        },
+        group: { sections: [ { content: 'group-new' } ] }
+      }
+      reloaded.save!
+
+      stored = stored_document
+      expect(stored_contents(stored['sections'])).to eq [ 'root-updated' ]
+      expect(stored_contents(stored.dig('group', 'sections'))).to eq [ 'group-new' ]
+      expect(document_contents(reloaded.sections)).to eq [ 'root-updated' ]
+      expect(document_contents(reloaded.group.sections)).to eq [ 'group-new' ]
+    end
+  end
+
+  context 'when assigning a new embeds_one child with nested embeds_many' do
+    let!(:org) { NewEmbeddedChildSpec::Org.create!(title: 't0') }
+
+    it 'does not write the nested array as a root-level field' do
+      reloaded = NewEmbeddedChildSpec::Org.find(org.id)
+      reloaded.attributes = { title: 't1', team: { members: [ { name: 'm1' } ] } }
+      reloaded.save!
+
+      stored = NewEmbeddedChildSpec::Org.collection.find(_id: org.id).first
+      expect(stored.keys).to match_array(%w[_id title team])
+      expect(stored.dig('team', 'members').map { |member| member['name'] }).to eq [ 'm1' ]
+    end
+
+    it 'does not write nested attributes at the root level' do
+      reloaded = NewEmbeddedChildSpec::Org.find(org.id)
+      reloaded.attributes = {
+        team_attributes: { members: [ { name: 'm1' } ] }
+      }
+      reloaded.save!
+
+      stored = NewEmbeddedChildSpec::Org.collection.find(_id: org.id).first
+      expect(stored.keys).to match_array(%w[_id title team])
+      expect(stored.dig('team', 'members').map { |member| member['name'] }).to eq [ 'm1' ]
+      expect(reloaded.team.members.map(&:name)).to eq [ 'm1' ]
+    end
+
+    it 'does not conflict when assigning to a newly built child' do
+      reloaded = NewEmbeddedChildSpec::Org.find(org.id)
+      reloaded.build_team
+      reloaded.team.attributes = { members: [ { name: 'm1' } ] }
+      reloaded.save!
+
+      stored = NewEmbeddedChildSpec::Org.collection.find(_id: org.id).first
+      expect(stored.dig('team', 'members').map { |member| member['name'] }).to eq [ 'm1' ]
+      expect(reloaded.team.members.map(&:name)).to eq [ 'm1' ]
+    end
+  end
+end

data/spec/integration/associations/has_and_belongs_to_many_spec.rb

@@ -60,6 +60,20 @@ module HabtmSpec
 end
 
 describe 'has_and_belongs_to_many associations' do
+  context 'when the stored foreign-key array is empty' do
+    it 'can reset and enumerate the association proxy' do
+      item = HabtmSpec::Item.create!(color_ids: [])
+      colors = item.reload.colors
+
+      expect_query(0) do
+        colors.reset
+        expect(colors.empty?).to be true
+        expect(colors.size).to be 0
+        expect(colors.to_a).to eq []
+      end
+    end
+  end
+
   context 'when an anonymous class defines a has_and_belongs_to_many association' do
     let(:klass) do
       Class.new do

data/spec/integration/atomic/modifiers_spec.rb

@@ -134,4 +134,287 @@ describe Mongoid::Atomic::Modifiers do
       expect(library.books[2].foreword).not_to be_nil
     end
   end
+
+  context 'when adding to a set on an existing embedded document and pushing a new one' do
+    let(:badges) { Array.new(2) { ModifierModels::Badge.create! } }
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(badges: [ badges[0] ]),
+                                       ModifierModels::Player.new(badges: [ badges[0] ])
+                                     ])
+    end
+
+    before do
+      roster.reload
+      roster.players.build
+      player = roster.players[0]
+      player.badge_ids = player.badge_ids + [ badges[1].id ]
+      roster.save!
+      roster.reload
+    end
+
+    it 'applies both operations' do
+      expect(roster.players.size).to eq(3)
+      expect(roster.players[0].badge_ids).to eq([ badges[0].id, badges[1].id ])
+      expect(roster.players[1].badge_ids).to eq([ badges[0].id ])
+    end
+  end
+
+  context 'when pulling all from an existing embedded document and pushing a new one' do
+    let(:badges) { Array.new(2) { ModifierModels::Badge.create! } }
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(badges: badges),
+                                       ModifierModels::Player.new
+                                     ])
+    end
+
+    before do
+      roster.reload
+      roster.players.build
+      player = roster.players[0]
+      player.badge_ids = player.badge_ids.drop(1)
+      roster.save!
+      roster.reload
+    end
+
+    it 'applies both operations' do
+      expect(roster.players.size).to eq(3)
+      expect(roster.players[0].badge_ids).to eq([ badges[1].id ])
+    end
+  end
+
+  context 'when unsetting a field on an existing embedded document and pushing a new one' do
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(medal: ModifierModels::Medal.new),
+                                       ModifierModels::Player.new
+                                     ])
+    end
+
+    before do
+      roster.reload
+      roster.players.build
+      roster.players[0].assign_attributes(medal: nil)
+      roster.save!
+      roster.reload
+    end
+
+    it 'applies both operations' do
+      expect(roster.players.size).to eq(3)
+      expect(roster.players[0].medal).to be_nil
+    end
+  end
+
+  context 'when unsetting an embedded field and pulling a sibling' do
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(medal: ModifierModels::Medal.new),
+                                       ModifierModels::Player.new(medal: ModifierModels::Medal.new)
+                                     ])
+    end
+
+    before do
+      roster.reload
+      roster.add_atomic_pull(roster.players[0])
+      roster.players[1].assign_attributes(medal: nil)
+    end
+
+    it 'fails without changing stored data' do
+      # $pull shifts array elements, so these operations cannot be safely
+      # applied in separate writes; MongoDB rejects them in a single write.
+      expect { roster.save! }.to raise_error(Mongo::Error::OperationFailure)
+
+      roster.reload
+      expect(roster.players.size).to eq(2)
+      expect(roster.players[0].medal).not_to be_nil
+      expect(roster.players[1].medal).not_to be_nil
+    end
+  end
+
+  context 'when changing foreign keys of a remaining nested document after pulling its sibling' do
+    let(:badges) { Array.new(2) { ModifierModels::Badge.create! } }
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(badges: [ badges[0] ]),
+                                       ModifierModels::Player.new(
+                                         badges: [ badges[0] ],
+                                         awards: [
+                                           ModifierModels::Award.new(name: 'first', badges: [ badges[0] ]),
+                                           ModifierModels::Award.new(name: 'second', badges: [ badges[0] ])
+                                         ]
+                                       )
+                                     ])
+    end
+
+    before do
+      roster.reload
+      first_player, second_player = roster.players.to_a
+      first_award, second_award = second_player.awards.to_a
+      # The change on the first player comes before the nested $pull on the
+      # same root. The change on the second award uses its position after
+      # the $pull.
+      change.call(first_player)
+      roster.players_attributes = [
+        { id: second_player.id, awards_attributes: [ { id: first_award.id, _destroy: true } ] }
+      ]
+      change.call(second_award)
+    end
+
+    context 'when adding to the foreign keys' do
+      let(:change) do
+        ->(doc) { doc.badge_ids = doc.badge_ids + [ badges[1].id ] }
+      end
+
+      it 'fails without changing stored data' do
+        # The $addToSet for the second award would hit the first award if it
+        # were applied before the $pull, so it stays in the same update.
+        expect { roster.save! }.to raise_error(Mongo::Error::OperationFailure)
+
+        roster.reload
+        expect(roster.players[0].badge_ids).to eq([ badges[0].id ])
+        expect(roster.players[1].awards.map(&:name)).to eq(%w[first second])
+        expect(roster.players[1].awards.map(&:badge_ids)).to eq([ [ badges[0].id ], [ badges[0].id ] ])
+      end
+    end
+
+    context 'when removing from the foreign keys' do
+      let(:change) do
+        ->(doc) { doc.badge_ids = [] }
+      end
+
+      it 'applies the change to the remaining nested document' do
+        roster.save!
+
+        roster.reload
+        expect(roster.players[0].badge_ids).to eq([])
+        expect(roster.players[1].awards.map(&:name)).to eq([ 'second' ])
+        expect(roster.players[1].awards[0].badge_ids).to eq([])
+      end
+    end
+  end
+
+  context 'when renaming a remaining nested document after pulling a preceding sibling and its sibling' do
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(nickname: 'a'),
+                                       ModifierModels::Player.new(nickname: 'b'),
+                                       ModifierModels::Player.new(
+                                         nickname: 'c',
+                                         awards: [
+                                           ModifierModels::Award.new(name: 'first'),
+                                           ModifierModels::Award.new(name: 'second')
+                                         ]
+                                       )
+                                     ])
+    end
+
+    before do
+      roster.reload
+      first_player, second_player, third_player = roster.players.to_a
+      first_award, second_award = third_player.awards.to_a
+      roster.players_attributes = [
+        { id: first_player.id, _destroy: true },
+        { id: second_player.id, nickname: 'B' },
+        { id: third_player.id, awards_attributes: [
+          { id: first_award.id, _destroy: true },
+          { id: second_award.id, name: 'SECOND' }
+        ] }
+      ]
+    end
+
+    it 'fails without changing stored data' do
+      # Both $pulls stay in the main update. The rename of the second award
+      # would hit the first award if it were applied before the nested $pull.
+      expect { roster.save! }.to raise_error(Mongo::Error::OperationFailure)
+
+      roster.reload
+      expect(roster.players.map(&:nickname)).to eq(%w[a b c])
+      expect(roster.players[2].awards.map(&:name)).to eq(%w[first second])
+    end
+  end
+
+  context 'when adding a nested document and pulling a sibling' do
+    let(:roster) do
+      ModifierModels::Roster.create!(players: [
+                                       ModifierModels::Player.new(nickname: 'a'),
+                                       ModifierModels::Player.new(
+                                         nickname: 'b',
+                                         awards: [ ModifierModels::Award.new(name: 'first') ]
+                                       )
+                                     ])
+    end
+
+    before do
+      roster.reload
+      first_player, second_player = roster.players.to_a
+      second_player.awards.build(name: 'second')
+      roster.players_attributes = [ { id: first_player.id, _destroy: true } ]
+    end
+
+    it 'applies both operations' do
+      roster.save!
+
+      roster.reload
+      expect(roster.players.map(&:nickname)).to eq([ 'b' ])
+      expect(roster.players[0].awards.map(&:name)).to eq(%w[first second])
+    end
+  end
+
+  context 'when assigning embeds_many attributes on a new embedded document' do
+    let(:cabinet) do
+      ModifierModels::Cabinet.create!
+    end
+
+    before do
+      cabinet.reload
+    end
+
+    context 'when the nested documents are assigned on the built document' do
+      before do
+        cabinet.build_drawer(matcher: 'all')
+        cabinet.drawer.assign_attributes(items: [ { name: 'a' } ])
+      end
+
+      it 'saves without conflicting $set paths' do
+        expect { cabinet.save! }.not_to raise_error
+
+        cabinet.reload
+        expect(cabinet.drawer.matcher).to eq('all')
+        expect(cabinet.drawer.items.map(&:name)).to eq([ 'a' ])
+      end
+    end
+
+    context 'when the nested documents are assigned via the parent' do
+      before do
+        cabinet.assign_attributes(drawer: { matcher: 'all', items: [ { name: 'a' } ] })
+      end
+
+      it 'saves without conflicting $set paths' do
+        expect { cabinet.save! }.not_to raise_error
+
+        cabinet.reload
+        expect(cabinet.drawer.matcher).to eq('all')
+        expect(cabinet.drawer.items.map(&:name)).to eq([ 'a' ])
+      end
+    end
+
+    context 'when an assigned child has its own embedded collection' do
+      let(:item) { ModifierModels::Item.new(name: 'a') }
+
+      before do
+        item.assign_attributes(widgets: [ { label: 'w' } ])
+        cabinet.build_drawer(matcher: 'all')
+        cabinet.drawer.assign_attributes(items: [ item ])
+      end
+
+      it 'does not write the child collection to the root document' do
+        expect { cabinet.save! }.not_to raise_error
+
+        stored = ModifierModels::Cabinet.collection.find(_id: cabinet.id).first
+        expect(stored.keys).to contain_exactly('_id', 'drawer')
+        expect(stored['drawer']['items'].first['widgets'].first['label']).to eq('w')
+      end
+    end
+  end
 end