mongoid 9.1.0 → 9.1.2

data/lib/mongoid/threaded.rb

@@ -32,6 +32,9 @@ module Mongoid
       hash[key] = "#{key}-stack"
     end
 
+    # The name of the stack tracking collection and index management.
+    COLLECTION_MANAGEMENT = :collection_management
+
     # The key for the current thread's sessions.
     SESSIONS_KEY = 'sessions'
 
@@ -42,6 +45,9 @@ module Mongoid
     # executed on documents.
     EXECUTE_CALLBACKS = 'execute-callbacks'
 
+    # The key for the time left in the current in-memory regexp budget.
+    REGEXP_BUDGET_KEY = 'regexp-budget'
+
     extend self
 
     # Resets the current thread- or fiber-local storage to its initial state.
@@ -165,6 +171,36 @@ module Mongoid
       !stack(name).empty?
     end
 
+    # Execute the block as collection or index management.
+    #
+    # Creating, dropping and inspecting collections and indexes sends no
+    # document data, so these operations are exempt from the encryption schema
+    # check that PersistenceContext applies to reads and writes. Without the
+    # exemption, tasks such as db:mongoid:create_collections would need an
+    # encryption-capable client to run.
+    #
+    # @example Create a collection.
+    #   Threaded.with_collection_management { model.create_collection }
+    #
+    # @return [ Object ] The result of the block.
+    def with_collection_management
+      begin_execution(COLLECTION_MANAGEMENT)
+      yield
+    ensure
+      exit_execution(COLLECTION_MANAGEMENT)
+    end
+
+    # Is collection or index management being executed?
+    #
+    # @example Is a collection being managed?
+    #   Threaded.managing_collection?
+    #
+    # @return [ true | false ] Whether collection or index management is in
+    #   progress on the current thread.
+    def managing_collection?
+      executing?(COLLECTION_MANAGEMENT)
+    end
+
     # Exit from a named thread local stack.
     #
     # @example Exit from the stack.

data/lib/mongoid/timestamps/timeless.rb

@@ -22,13 +22,20 @@ module Mongoid
         true
       end
 
-      # Begin an execution that should skip timestamping.
+      # Skip timestamping for the duration of the given block, or (in the
+      # deprecated, block-less form) for the next persistence operation.
       #
-      # @example Save a document but don't timestamp.
+      # @example Save a document but don't timestamp (block form).
+      #   person.timeless { person.save }
+      #
+      # @example Save a document but don't timestamp (deprecated chained form).
       #   person.timeless.save
       #
-      # @return [ Document ] The document this was called on.
-      def timeless
+      # @return [ Object | Document ] The return value of the block, or (in the
+      #   block-less form) the document this was called on.
+      def timeless(&block)
+        return Timeless.with_timeless(&block) if block
+
         self.class.timeless
         self
       end
@@ -47,6 +54,9 @@ module Mongoid
         # The key to use to store the timeless table
         TIMELESS_TABLE_KEY = '[mongoid]:timeless'
 
+        # The key to use to store the block-based timeless flag.
+        TIMELESS_FLAG_KEY = '[mongoid]:timeless-flag'
+
         # Returns the in-memory thread cache of classes
         # for which to skip timestamping.
         #
@@ -58,16 +68,78 @@ module Mongoid
         end
 
         def_delegators :timeless_table, :[]=, :[]
+
+        # Skip timestamping for the duration of the given block, on the
+        # current thread or fiber. This applies to every document persisted
+        # while the block is executing, regardless of class, including
+        # cascaded embedded children at any nesting depth.
+        #
+        # @example Skip timestamping for a block.
+        #   Mongoid::Timestamps::Timeless.with_timeless do
+        #     person.save
+        #   end
+        #
+        # @return [ Object ] The return value of the block.
+        def with_timeless
+          # Only the outermost block owns the flag: if we are already inside a
+          # timeless scope, we leave the suppression in place when this block
+          # ends. This avoids tracking a nesting depth that could drift out of
+          # sync.
+          already_timeless = suppressing_timestamps?
+          set_suppressing_timestamps(true) unless already_timeless
+          yield
+        ensure
+          set_suppressing_timestamps(false) unless already_timeless
+        end
+
+        # Whether a block-based timeless scope is currently active on this
+        # thread/fiber.
+        #
+        # @return [ true | false ] Whether timestamps are being suppressed.
+        #
+        # @api private
+        def suppressing_timestamps?
+          !!Threaded.get(TIMELESS_FLAG_KEY) { false }
+        end
+
+        # Set whether a block-based timeless scope is active on this
+        # thread/fiber.
+        #
+        # @param [ true | false ] value Whether to suppress timestamps.
+        #
+        # @api private
+        def set_suppressing_timestamps(value)
+          Threaded.set(TIMELESS_FLAG_KEY, value)
+        end
       end
 
       module ClassMethods
-        # Begin an execution that should skip timestamping.
+        # Skip timestamping for the duration of the given block, or (in the
+        # deprecated, block-less form) for the next persistence operation.
+        #
+        # @example Create a document but don't timestamp (block form).
+        #   Person.timeless { Person.create(title: "Sir") }
         #
-        # @example Create a document but don't timestamp.
+        # @example Create a document but don't timestamp (deprecated form).
         #   Person.timeless.create(:title => "Sir")
         #
-        # @return [ Class ] The class this was called on.
-        def timeless
+        # @return [ Object | Class ] The return value of the block, or (in the
+        #   block-less form) the class this was called on.
+        def timeless(&block)
+          return Timeless.with_timeless(&block) if block
+
+          locations = caller_locations
+
+          # if this is called from the #timeless instance method, look up one
+          # level higher for the call site
+          locations.shift if locations[0].path == __FILE__
+
+          Mongoid.deprecation_warning(
+            :timeless_sans_block,
+            'Calling #timeless without a block is deprecated; pass a block ' \
+            'instead, e.g. `record.timeless { record.save }`.',
+            locations
+          )
           counter = 0
           counter += 1 if self < Mongoid::Timestamps::Created
           counter += 1 if self < Mongoid::Timestamps::Updated
@@ -109,12 +181,14 @@ module Mongoid
           Timeless[name] = (counter == 0) ? nil : counter
         end
 
-        # Returns whether the current class should skip timestamping.
+        # Returns whether the current class should skip timestamping. This is
+        # true when either a block-based timeless scope is active on the
+        # current thread/fiber, or the deprecated per-class counter is set.
         #
         # @return [ true | false ] Whether the current class should
         #   skip timestamping.
         def timeless?
-          !!Timeless[name]
+          Timeless.suppressing_timestamps? || !!Timeless[name]
         end
       end
     end

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

@@ -211,7 +211,7 @@ module Mongoid
       # @api private
       def self.add_discriminator_mapping(value, klass = self)
         self.discriminator_mapping ||= {}
-        self.discriminator_mapping[value] = klass
+        discriminator_mapping[value] = klass
         superclass.add_discriminator_mapping(value, klass) if hereditary?
       end
 
@@ -225,7 +225,7 @@ module Mongoid
       #
       # @api private
       def self.get_discriminator_mapping(value)
-        self.discriminator_mapping[value] if self.discriminator_mapping
+        discriminator_mapping[value] if discriminator_mapping
       end
     end
 

data/lib/mongoid/validatable/associated.rb

@@ -67,12 +67,13 @@ module Mongoid
         valid = document.validating do
           # Now, treating the target as an array, look at each element
           # and see if it is valid, but only if it has already been
-          # persisted, or changed, and hasn't been flagged for destroy.
+          # persisted, or changed, and hasn't been flagged for destroy
+          # or already destroyed.
           #
           # use map.all? instead of just all?, because all? will do short-circuit
           # evaluation and terminate on the first failed validation.
           list.map do |value|
-            if value && !value.flagged_for_destroy? && (!value.persisted? || value.changed?)
+            if needs_validation?(value)
               value.validated? || value.valid?
             else
               true
@@ -120,6 +121,21 @@ module Mongoid
       def get_target_documents_for_other(target)
         Array.wrap(target)
       end
+
+      # Returns true if the given value should be validated as part of
+      # an associated validation. Destroyed and flagged-for-destroy
+      # documents are skipped, as are persisted documents that haven't
+      # changed.
+      #
+      # @param [ Mongoid::Document | nil ] value The value to check.
+      #
+      # @return [ true | false ] Whether the value needs validation.
+      def needs_validation?(value)
+        value &&
+          !value.flagged_for_destroy? &&
+          !value.destroyed? &&
+          (!value.persisted? || value.changed?)
+      end
     end
   end
 end

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.0'
+  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/app_spec.rb

@@ -435,7 +435,13 @@ describe 'Mongoid application tests' do
     end
     gemfile_lines << "gem 'mongoid', path: '#{File.expand_path(BASE)}'\n"
 
-    # Rails 6.0 and 6.1 need logger gem on Ruby 2.7+ due to stdlib changes
+    # json 3.0 removed the quirks_mode and max_nesting keywords that
+    # ActiveSupport::JSON (every 7.x) still passes to JSON.generate and
+    # JSON.parse, so a freshly resolved bundle picks a 3.x json and the app
+    # fails to encode any response with ArgumentError: unknown keyword:
+    # quirks_mode. Cap json at 2.x, which still accepts those keywords.
+    gemfile_lines << "gem 'json', '< 3'\n" # Rails 6.0 and 6.1 need logger gem on Ruby 2.7+ due to stdlib changes
+
     gemfile_lines << "gem 'logger'\n" if rails_version && rails_version.to_f < 7.0 && RUBY_VERSION >= '2.7'
 
     if rails_version

data/spec/integration/associations/belongs_to_spec.rb

@@ -99,6 +99,19 @@ describe 'belongs_to associations' do
         expect(team_manager.reload.unit_type).to eq 'group'
         expect(team_manager.unit).to eq team
       end
+
+      it 'eager-loads the corresponding unit when unit_type is a different alias' do
+        dept_manager.update unit_type: 'sandbox_dept'
+        team_manager.update unit_type: 'group'
+
+        managers = SandboxManager.where(:_id.in => [ dept_manager.id, team_manager.id ])
+                                 .includes(:unit)
+                                 .to_a
+        units_by_id = managers.to_h { |m| [ m.id, m.ivar(:unit) ] }
+
+        expect(units_by_id[dept_manager.id]).to eq department
+        expect(units_by_id[team_manager.id]).to eq team
+      end
     end
 
     context 'when the association uses the default resolver' do

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
@@ -90,8 +104,23 @@ describe 'has_and_belongs_to_many associations' do
                         })
     end
 
-    it 'does not raise on save' do
-      expect { image_block.save! }.not_to raise_error
+    # The nested attributes are processed before the attachment_ids
+    # assignment is applied, so at that point the id is not yet in the
+    # association and resolving it requires a collection-wide lookup.
+    context 'when allow_reparenting_via_nested_attributes is false' do
+      config_override :allow_reparenting_via_nested_attributes, false
+
+      it 'raises a document not found error' do
+        expect { image_block.save! }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    context 'when allow_reparenting_via_nested_attributes is true' do
+      config_override :allow_reparenting_via_nested_attributes, true
+
+      it 'does not raise on save' do
+        expect { image_block.save! }.not_to raise_error
+      end
     end
   end