mongoid 9.1.0 → 9.1.1

data/lib/mongoid/serializable.rb

@@ -127,10 +127,18 @@ module Mongoid
       inclusions = options[:include]
       relation_names(inclusions).each do |name|
         association = relations[name.to_s]
-        if association && relation = send(association.name)
-          attributes[association.name.to_s] =
-            relation.serializable_hash(relation_options(inclusions, options, name))
-        end
+        next unless association
+
+        relation =
+          if association.fallback?
+            without_autobuild { send(association.name) }
+          else
+            send(association.name)
+          end
+        next unless relation
+
+        attributes[association.name.to_s] =
+          relation.serializable_hash(relation_options(inclusions, options, name))
       end
     end
 

data/lib/mongoid/tasks/database.rb

@@ -83,6 +83,12 @@ module Mongoid
       #
       # @return [ Array<Hash> ] The list of undefined indexes by model.
       def undefined_indexes(models = ::Mongoid.models)
+        Threaded.with_collection_management do
+          undefined_indexes_for(models)
+        end
+      end
+
+      def undefined_indexes_for(models)
         undefined_by_model = {}
 
         models.each do |model|
@@ -116,15 +122,17 @@ module Mongoid
       #
       # @return [ Hash{Class => Array(Hash)}] The list of indexes that were removed by model.
       def remove_undefined_indexes(models = ::Mongoid.models)
-        undefined_indexes(models).each do |model, indexes|
-          indexes.each do |index|
-            key = index['key'].symbolize_keys
-            collection = model.collection
-            collection.indexes(session: model.send(:_session)).drop_one(key)
-            logger.info(
-              "MONGOID: Removed index '#{index['name']}' on collection " +
-              "'#{collection.name}' in database '#{collection.database.name}'."
-            )
+        Threaded.with_collection_management do
+          undefined_indexes(models).each do |model, indexes|
+            indexes.each do |index|
+              key = index['key'].symbolize_keys
+              collection = model.collection
+              collection.indexes(session: model.send(:_session)).drop_one(key)
+              logger.info(
+                "MONGOID: Removed index '#{index['name']}' on collection " +
+                "'#{collection.name}' in database '#{collection.database.name}'."
+              )
+            end
           end
         end
       end
@@ -172,6 +180,12 @@ module Mongoid
       #
       # @return [ Array<Class> ] The sharded models
       def shard_collections(models = ::Mongoid.models)
+        Threaded.with_collection_management do
+          shard_collections_for(models)
+        end
+      end
+
+      def shard_collections_for(models)
         models.map do |model|
           next if model.shard_config.nil?
 

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/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.1'
 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/has_and_belongs_to_many_spec.rb

@@ -90,8 +90,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
 

data/spec/integration/dots_and_dollars_spec.rb

@@ -253,10 +253,20 @@ describe 'Dots and Dollars' do
         DADMUser.where('$_amount': 0).first
       end
 
-      it 'raise an error' do
+      it 'raises an error' do
         expect do
           queried
-        end.to raise_error(Mongo::Error::OperationFailure)
+        end.to raise_error(Mongoid::Errors::InvalidQuery)
+      end
+
+      context 'when allow_unsafe_query_operators is true' do
+        config_override :allow_unsafe_query_operators, true
+
+        it 'raises an error from the server' do
+          expect do
+            queried
+          end.to raise_error(Mongo::Error::OperationFailure)
+        end
       end
     end
   end

data/spec/integration/encryption_spec.rb

@@ -33,19 +33,24 @@ describe 'Encryption' do
   around do |example|
     Mongoid.default_client[Crypt::Patient.collection_name].drop
     Mongoid.default_client[Crypt::Car.collection_name].drop
+    Mongoid.default_client[Crypt::Folder.collection_name].drop
     existing_key_id = Crypt::Patient.encrypt_metadata[:key_id]
     Crypt::Patient.set_key_id(data_key_id)
     Crypt::Car.set_key_id(data_key_id)
+    Crypt::Note.set_key_id(data_key_id)
     Mongoid::Config.send(:clients=, config)
     Mongoid::Clients.with_name(:key_vault)[key_vault_collection].drop
     Crypt::Patient.store_in(client: :encrypted)
     Crypt::Car.store_in(client: :encrypted, database: Crypt::Car.storage_options[:database])
+    Crypt::Folder.store_in(client: :encrypted)
 
     example.run
 
     Crypt::Patient.reset_storage_options!
+    Crypt::Folder.reset_storage_options!
     Crypt::Patient.set_key_id(existing_key_id)
     Crypt::Car.set_key_id(existing_key_id)
+    Crypt::Note.set_key_id(existing_key_id)
   end
 
   it 'encrypts and decrypts fields' do
@@ -85,6 +90,17 @@ describe 'Encryption' do
     end
   end
 
+  # Nothing about the parent document says it needs a schema: it has no
+  # encrypted field of its own and no encrypt_with. Its collection still needs
+  # one, or the embedded field goes out in the clear.
+  it 'stores an embedded field encrypted when the parent has no encrypted field' do
+    folder = Crypt::Folder.create!(note: Crypt::Note.new(text: 'SECRET'))
+    unencrypted_client[Crypt::Folder.collection.name].find(_id: folder.id).first.tap do |doc|
+      expect(doc['note']['text']).to be_a(BSON::Binary)
+      expect(doc['note']['text'].type).to eq(:ciphertext)
+    end
+  end
+
   it 'stores data encrypted in the non-default database' do
     car = Crypt::Car.create!(vin: 'VA1234')
     unencrypted_client
@@ -94,4 +110,139 @@ describe 'Encryption' do
       expect(doc[:vin].type).to eq(:ciphertext)
     end
   end
+
+  # The encryption schema map is keyed by namespace and built once, when the
+  # client is constructed. Whenever the namespace an encrypted model actually
+  # writes to is not in that map, the driver encrypts nothing and reports no
+  # error, so the field lands in the clear. Mongoid fails closed instead.
+  describe 'when the target namespace is not in the encryption schema map' do
+    let(:scratch_databases) do
+      %w[vehicles_dynamic vehicles_tenant_b vehicles_tenant_c tenant_a]
+    end
+
+    around do |example|
+      original_options = {
+        Crypt::DynamicCar => Crypt::DynamicCar.storage_options,
+        Crypt::TenantCar => Crypt::TenantCar.storage_options
+      }
+      existing_key_ids = original_options.keys.to_h { |model| [ model, model.encrypt_metadata[:key_id] ] }
+      original_options.each_key do |model|
+        model.set_key_id(data_key_id)
+        model.store_in(client: :encrypted)
+      end
+      clean_scratch_data
+      # The schema map is generated when the client is built, so the client has
+      # to be built after the storage options above are in place.
+      Mongoid::Clients.clear
+
+      example.run
+
+      clean_scratch_data
+      original_options.each { |model, options| model.storage_options = options }
+      existing_key_ids.each { |model, key_id| model.set_key_id(key_id) }
+      Mongoid::Clients.clear
+    end
+
+    def clean_scratch_data
+      scratch_databases.each { |database| unencrypted_client.use(database).database.drop }
+      # Crypt::Car writes into the shared 'vehicles' database, which other
+      # examples rely on, so remove only the documents these examples create.
+      unencrypted_client
+        .use(Crypt::Car.storage_options[:database])[Crypt::Car.collection_name.to_s]
+        .delete_many(vin: { '$in' => %w[CLIENT-1 CLIENT-2] })
+    end
+
+    # Reads with a client that has no automatic encryption, to see what really
+    # landed on disk.
+    def documents_with_plaintext_vin(database, collection, vin)
+      unencrypted_client.use(database)[collection].find(vin: vin).to_a
+    end
+
+    context 'when the database name is a callable' do
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::DynamicCar.create!(vin: 'DYNAMIC-1') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles_dynamic', Crypt::DynamicCar.collection_name.to_s, 'DYNAMIC-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the database name is a callable resolved per tenant' do
+      around do |example|
+        Thread.current[:tenant_database] = 'tenant_a'
+        example.run
+        Thread.current[:tenant_database] = nil
+      end
+
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::TenantCar.create!(vin: 'TENANT-1') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('tenant_a', Crypt::TenantCar.collection_name.to_s, 'TENANT-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the database is overridden for the block' do
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.with(database: 'vehicles_tenant_b') { |car| car.create!(vin: 'BLOCK-1') } }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles_tenant_b', Crypt::Car.collection_name.to_s, 'BLOCK-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the database is overridden globally' do
+      persistence_context_override :database, 'vehicles_tenant_c'
+
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.create!(vin: 'GLOBAL-1') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles_tenant_c', Crypt::Car.collection_name.to_s, 'GLOBAL-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the model is routed to a client without automatic encryption' do
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.with(client: :default) { |car| car.create!(vin: 'CLIENT-1') } }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles', Crypt::Car.collection_name.to_s, 'CLIENT-1')
+        ).to be_empty
+      end
+    end
+
+    context 'when the parent has no encrypted field of its own' do
+      it 'does not store the embedded field in plaintext', :aggregate_failures do
+        expect { Crypt::Folder.with(client: :default) { |folder| folder.create!(note: Crypt::Note.new(text: 'EMBEDDED-1')) } }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          unencrypted_client[Crypt::Folder.collection_name.to_s].find('note.text' => 'EMBEDDED-1').to_a
+        ).to be_empty
+      end
+    end
+
+    context 'when the client is overridden globally to one without automatic encryption' do
+      persistence_context_override :client, :default
+
+      it 'does not store the field in plaintext', :aggregate_failures do
+        expect { Crypt::Car.create!(vin: 'CLIENT-2') }
+          .to raise_error(Mongoid::Errors::NoEncryptionSchema)
+
+        expect(
+          documents_with_plaintext_vin('vehicles', Crypt::Car.collection_name.to_s, 'CLIENT-2')
+        ).to be_empty
+      end
+    end
+  end
 end

data/spec/integration/matcher_operator_data/regex.yml

@@ -135,6 +135,27 @@
       $regex: bar
   matches: false
 
+# Object#=~ is gone as of Ruby 3.2, so an element that cannot be matched
+# against has to be skipped rather than passed to =~.
+- name: array field value - element that cannot be matched against
+  document:
+    title:
+      - 42
+      - foo
+  query:
+    title:
+      $regex: foo
+  matches: true
+
+- name: array field value - no element can be matched against
+  document:
+    title:
+      - 42
+  query:
+    title:
+      $regex: foo
+  matches: false
+
 - name: true field value
   document:
     title: true