mongoid 9.0.11 → 9.1.1

data/lib/mongoid/tasks/database.rake

@@ -1,62 +1,61 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 namespace :db do
   namespace :mongoid do
     task :load_models do
-      ::Mongoid.load_models
+      Mongoid.load_models
     end
 
-    desc "Create collections for Mongoid models"
-    task :create_collections => [:environment, :load_models] do
-      ::Mongoid::Tasks::Database.create_collections
+    desc 'Create collections for Mongoid models'
+    task create_collections: %i[environment load_models] do
+      Mongoid::Tasks::Database.create_collections
     end
 
-    desc "Create indexes specified in Mongoid models"
-    task :create_indexes => [:environment, :load_models] do
-      ::Mongoid::Tasks::Database.create_indexes
+    desc 'Create indexes specified in Mongoid models'
+    task create_indexes: %i[environment load_models] do
+      Mongoid::Tasks::Database.create_indexes
     end
 
-    desc "Create search indexes specified in Mongoid models"
-    task :create_search_indexes => [:environment, :load_models] do
+    desc 'Create search indexes specified in Mongoid models'
+    task create_search_indexes: %i[environment load_models] do
       wait = Mongoid::Utils.truthy_string?(ENV['WAIT_FOR_SEARCH_INDEXES'] || '1')
-      ::Mongoid::Tasks::Database.create_search_indexes(wait: wait)
+      Mongoid::Tasks::Database.create_search_indexes(wait: wait)
     end
 
-    desc "Remove indexes that exist in the database but are not specified in Mongoid models"
-    task :remove_undefined_indexes => [:environment, :load_models] do
-      ::Mongoid::Tasks::Database.remove_undefined_indexes
+    desc 'Remove indexes that exist in the database but are not specified in Mongoid models'
+    task remove_undefined_indexes: %i[environment load_models] do
+      Mongoid::Tasks::Database.remove_undefined_indexes
     end
 
-    desc "Remove indexes specified in Mongoid models"
-    task :remove_indexes => [:environment, :load_models] do
-      ::Mongoid::Tasks::Database.remove_indexes
+    desc 'Remove indexes specified in Mongoid models'
+    task remove_indexes: %i[environment load_models] do
+      Mongoid::Tasks::Database.remove_indexes
     end
 
-    desc "Remove search indexes specified in Mongoid models"
-    task :remove_search_indexes => [:environment, :load_models] do
-      ::Mongoid::Tasks::Database.remove_search_indexes
+    desc 'Remove search indexes specified in Mongoid models'
+    task remove_search_indexes: %i[environment load_models] do
+      Mongoid::Tasks::Database.remove_search_indexes
     end
 
-    desc "Shard collections with shard keys specified in Mongoid models"
-    task :shard_collections => [:environment, :load_models] do
-      ::Mongoid::Tasks::Database.shard_collections
+    desc 'Shard collections with shard keys specified in Mongoid models'
+    task shard_collections: %i[environment load_models] do
+      Mongoid::Tasks::Database.shard_collections
     end
 
-    desc "Drop the database of the default Mongoid client"
-    task :drop => :environment do
-      ::Mongoid::Clients.default.database.drop
+    desc 'Drop the database of the default Mongoid client'
+    task drop: :environment do
+      Mongoid::Clients.default.database.drop
     end
 
-    desc "Drop all non-system collections"
-    task :purge => :environment do
-      ::Mongoid.purge!
+    desc 'Drop all non-system collections'
+    task purge: :environment do
+      Mongoid.purge!
     end
 
     namespace :create_collections do
-      desc "Drop and create collections for Mongoid models"
-      task :force => [:environment, :load_models] do
-        ::Mongoid::Tasks::Database.create_collections(force: true)
+      desc 'Drop and create collections for Mongoid models'
+      task force: %i[environment load_models] do
+        Mongoid::Tasks::Database.create_collections(force: true)
       end
     end
   end

data/lib/mongoid/tasks/database.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Tasks
-
     # Utility module to manage database collections, indexes, sharding, etc.
     # Invoked from Rake tasks.
     module Database
@@ -42,6 +40,7 @@ module Mongoid
       def create_indexes(models = ::Mongoid.models)
         models.each do |model|
           next if model.index_specifications.empty?
+
           if !model.embedded? || model.cyclic?
             model.create_indexes
             logger.info("MONGOID: Created indexes on #{model}:")
@@ -84,24 +83,31 @@ 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|
-          unless model.embedded?
-            begin
-              model.collection.indexes(session: model.send(:_session)).each do |index|
-                # ignore default index
-                unless index['name'] == '_id_'
-                  key = index['key'].symbolize_keys
-                  spec = model.index_specification(key, index['name'])
-                  unless spec
-                    # index not specified
-                    undefined_by_model[model] ||= []
-                    undefined_by_model[model] << index
-                  end
-                end
-              end
-            rescue Mongo::Error::OperationFailure; end
+          next if model.embedded?
+
+          begin
+            model.collection.indexes(session: model.send(:_session)).each do |index|
+              # ignore default index
+              next if index['name'] == '_id_'
+
+              key = index['key'].symbolize_keys
+              spec = model.index_specification(key, index['name'])
+              next if spec
+
+              # index not specified
+              undefined_by_model[model] ||= []
+              undefined_by_model[model] << index
+            end
+          rescue Mongo::Error::OperationFailure
           end
         end
 
@@ -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
@@ -139,6 +147,7 @@ module Mongoid
       def remove_indexes(models = ::Mongoid.models)
         models.each do |model|
           next if model.embedded?
+
           begin
             model.remove_indexes
           rescue Mongo::Error::OperationFailure
@@ -155,6 +164,7 @@ module Mongoid
       def remove_search_indexes(models = ::Mongoid.models)
         models.each do |model|
           next if model.embedded?
+
           model.remove_search_indexes
         end
       end
@@ -170,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?
 
@@ -178,7 +194,7 @@ module Mongoid
             next
           end
 
-          unless model.collection.cluster.sharded?
+          unless model.collection.cluster.sharded? || model.collection.cluster.load_balanced?
             logger.warn("MONGOID: #{model} has shard config but is not persisted in a sharded cluster: #{model.collection.cluster.summary}")
             next
           end
@@ -194,17 +210,16 @@ module Mongoid
           # the error code when they are asked to collStats a non-existent
           # collection (https://jira.mongodb.org/browse/SERVER-50070).
           begin
-            stats = model.collection.database.command(collStats: model.collection.name).first
-          rescue Mongo::Error::OperationFailure => exc
+            model.collection.database.command(collStats: model.collection.name).first
+          rescue Mongo::Error::OperationFailure => e
             # Code 26 is database does not exist.
             # Code 8 is collection does not exist, as of 4.0.
             # On 3.6 and earlier match the text of exception message.
-            if exc.code == 26 || exc.code == 8 ||
-              exc.code.nil? && exc.message =~ /not found/
-            then
+            if e.code == 26 || e.code == 8 ||
+               (e.code.nil? && e.message =~ /not found/)
               model.collection.create
 
-              stats = model.collection.database.command(collStats: model.collection.name).first
+              model.collection.database.command(collStats: model.collection.name).first
             else
               raise
             end
@@ -220,13 +235,10 @@ module Mongoid
 
           begin
             admin_db.command(enableSharding: model.collection.database.name)
-          rescue Mongo::Error::OperationFailure => exc
+          rescue Mongo::Error::OperationFailure => e
             # Server 2.6 fails if sharding is already enabled
-            if exc.code == 23 || exc.code.nil? && exc.message =~ /already enabled/
-              # Nothing
-            else
-              raise
-            end
+            raise unless e.code == 23 || (e.code.nil? && e.message =~ /already enabled/)
+            # Nothing
           end
 
           begin

data/lib/mongoid/tasks/encryption.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Tasks
@@ -33,7 +32,7 @@ module Mongoid
           kms_providers: kms_providers
         )
         client_encryption_opts = {}.tap do |opts|
-          opts[:key_alt_names] = [key_alt_name] if key_alt_name
+          opts[:key_alt_names] = [ key_alt_name ] if key_alt_name
         end
         data_key_id = client_encryption.create_data_key(kms_provider_name, client_encryption_opts)
         {
@@ -58,27 +57,23 @@ module Mongoid
       def prepare_arguments(kms_provider_name, client_name)
         client = (client_name || 'default').to_s
         client_options = Mongoid.clients[client]
-        unless client_options.is_a?(Hash)
-          raise Errors::NoClientConfig.new(client)
-        end
+        raise Errors::NoClientConfig.new(client) unless client_options.is_a?(Hash)
+
         auto_encryption_options = client_options.dig(:options, :auto_encryption_options)
-        unless auto_encryption_options.is_a?(Hash)
-          raise Errors::InvalidAutoEncryptionConfiguration.new(client)
-        end
+        raise Errors::InvalidAutoEncryptionConfiguration.new(client) unless auto_encryption_options.is_a?(Hash)
+
         key_vault_namespace = auto_encryption_options[:key_vault_namespace]
-        unless key_vault_namespace.is_a?(String)
-          raise Errors::InvalidAutoEncryptionConfiguration.new(client)
-        end
+        raise Errors::InvalidAutoEncryptionConfiguration.new(client) unless key_vault_namespace.is_a?(String)
+
         kms_providers = auto_encryption_options[:kms_providers]
-        unless kms_providers.is_a?(Hash)
-          raise Errors::InvalidAutoEncryptionConfiguration.new(client)
-        end
+        raise Errors::InvalidAutoEncryptionConfiguration.new(client) unless kms_providers.is_a?(Hash)
+
         valid_kms_provider_name = get_kms_provider_name(kms_provider_name, kms_providers)
         unless kms_providers.key?(valid_kms_provider_name)
           raise Errors::InvalidAutoEncryptionConfiguration.new(client, valid_kms_provider_name)
         end
 
-        [valid_kms_provider_name, kms_providers, key_vault_namespace]
+        [ valid_kms_provider_name, kms_providers, key_vault_namespace ]
       end
 
       # Get kms provider name to use for creating a data key.

data/lib/mongoid/threaded/lifecycle.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Threaded
-    BIND = 'bind'.freeze
-    ASSIGN = 'assign'.freeze
-    BUILD = 'build'.freeze
-    LOAD = 'load'.freeze
-    CREATE = 'create'.freeze
-    
+    BIND = 'bind'
+    ASSIGN = 'assign'
+    BUILD = 'build'
+    LOAD = 'load'
+    CREATE = 'create'
+
     # This module contains convenience methods for document lifecycle that
     # resides on thread locals.
     module Lifecycle
@@ -129,7 +128,6 @@ module Mongoid
       end
 
       module ClassMethods
-
         # Execute a block in creating mode.
         #
         # @example Execute in creating mode.
@@ -144,7 +142,6 @@ module Mongoid
         ensure
           Threaded.exit_execution(CREATE)
         end
-
       end
     end
   end

data/lib/mongoid/threaded.rb

@@ -6,42 +6,73 @@ module Mongoid
   # This module contains logic for easy access to objects that have a lifecycle
   # on the current thread.
   module Threaded
-    DATABASE_OVERRIDE_KEY = '[mongoid]:db-override'
+    # The key for the shared thread- and fiber-local storage. It must be a
+    # symbol because keys for fiber-local storage must be symbols.
+    STORAGE_KEY = :'[mongoid]'
 
-    # Constant for the key to store clients.
-    CLIENTS_KEY = '[mongoid]:clients'
+    # Tracks which fiber owns the storage hash, to detect when a fiber has
+    # inherited (rather than created) its storage from a parent fiber.
+    STORAGE_OWNER_KEY = :'[mongoid]:owner'
+
+    DATABASE_OVERRIDE_KEY = 'db-override'
 
     # The key to override the client.
-    CLIENT_OVERRIDE_KEY = '[mongoid]:client-override'
+    CLIENT_OVERRIDE_KEY = 'client-override'
 
     # The key for the current thread's scope stack.
-    CURRENT_SCOPE_KEY = '[mongoid]:current-scope'
+    CURRENT_SCOPE_KEY = 'current-scope'
+
+    AUTOSAVES_KEY = 'autosaves'
 
-    AUTOSAVES_KEY = '[mongoid]:autosaves'
+    VALIDATIONS_KEY = 'validations'
 
-    VALIDATIONS_KEY = '[mongoid]:validations'
+    TOUCH_MERGED_KEY = 'touch-merged'
 
     STACK_KEYS = Hash.new do |hash, key|
-      hash[key] = "[mongoid]:#{key}-stack"
+      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 = '[mongoid]:sessions'
+    SESSIONS_KEY = 'sessions'
 
     # The key for storing documents modified inside transactions.
-    MODIFIED_DOCUMENTS_KEY = '[mongoid]:modified-documents'
+    MODIFIED_DOCUMENTS_KEY = 'modified-documents'
 
     # The key storing the default value for whether or not callbacks are
     # executed on documents.
-    EXECUTE_CALLBACKS = '[mongoid]:execute-callbacks'
+    EXECUTE_CALLBACKS = 'execute-callbacks'
+
+    # The key for the time left in the current in-memory regexp budget.
+    REGEXP_BUDGET_KEY = 'regexp-budget'
 
     extend self
 
-    # Queries the thread-local variable with the given name. If a block is
+    # Resets the current thread- or fiber-local storage to its initial state.
+    # This is useful for making sure the state is clean when starting a new
+    # thread or fiber.
+    #
+    # The value of Mongoid::Config.real_isolation_level is used to determine
+    # whether to reset the storage for the current thread or fiber.
+    def reset!
+      case Config.real_isolation_level
+      when :thread
+        Thread.current.thread_variable_set(STORAGE_KEY, nil)
+      when :fiber
+        Fiber[STORAGE_KEY] = {}
+        Fiber[STORAGE_OWNER_KEY] = Fiber.current.object_id
+      else
+        raise "Unknown isolation level: #{Config.real_isolation_level.inspect}"
+      end
+    end
+
+    # Queries the thread- or fiber-local variable with the given name. If a block is
     # given, and the variable does not already exist, the return value of the
     # block will be set as the value of the variable before returning it.
     #
-    # It is very important that applications (and espcially Mongoid)
+    # It is very important that applications (and especially Mongoid)
     # use this method instead of Thread#[], since Thread#[] is actually for
     # fiber-local variables, and Mongoid uses Fibers as an implementation
     # detail in some callbacks. Putting thread-local state in a fiber-local
@@ -57,7 +88,7 @@ module Mongoid
     # @return [ Object | nil ] the value of the queried variable, or nil if
     #   it is not set and no default was given.
     def get(key, &default)
-      result = Thread.current.thread_variable_get(key)
+      result = storage[key]
 
       if result.nil? && default
         result = yield
@@ -67,7 +98,7 @@ module Mongoid
       result
     end
 
-    # Sets a thread-local variable with the given name to the given value.
+    # Sets a variable in local storage with the given name to the given value.
     # See #get for a discussion of why this method is necessary, and why
     # Thread#[]= should be avoided in cascading callbacks on embedded children.
     #
@@ -75,35 +106,23 @@ module Mongoid
     # @param [ Object | nil ] value the value of the variable to set (or `nil`
     #   if you wish to unset the variable)
     def set(key, value)
-      Thread.current.thread_variable_set(key, value)
+      storage[key] = value
     end
 
-    # Removes the named variable from thread-local storage.
+    # Removes the named variable from local storage.
     #
     # @param [ String | Symbol ] key the name of the variable to remove.
     def delete(key)
-      set(key, nil)
+      storage.delete(key)
     end
 
-    # Queries the presence of a named variable in thread-local storage.
+    # Queries the presence of a named variable in local storage.
     #
     # @param [ String | Symbol ] key the name of the variable to query.
     #
     # @return [ true | false ] whether the given variable is present or not.
     def has?(key)
-      # Here we have a classic example of JRuby not behaving like MRI. In
-      # MRI, if you set a thread variable to nil, it removes it from the list
-      # and subsequent calls to thread_variable?(key) will return false. Not
-      # so with JRuby. Once set, you cannot unset the thread variable.
-      #
-      # However, because setting a variable to nil is supposed to remove it,
-      # we can assume a nil-valued variable doesn't actually exist.
-
-      # So, instead of this:
-      # Thread.current.thread_variable?(key)
-
-      # We have to do this:
-      !get(key).nil?
+      storage.key?(key)
     end
 
     # Begin entry into a named thread local stack.
@@ -152,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.
@@ -196,6 +245,17 @@ module Mongoid
       validations_for(document.class).push(document._id)
     end
 
+    # Mark that a document's touch updates have been merged into
+    # an atomic insert on the current thread.
+    #
+    # @example Begin touch merged.
+    #   Threaded.begin_touch_merged(doc)
+    #
+    # @param [ Document ] document The embedded document being inserted.
+    def begin_touch_merged(document)
+      touch_merged_for(document.class).push(document._id)
+    end
+
     # Exit autosaving a document on the current thread.
     #
     # @example Exit autosave.
@@ -216,6 +276,16 @@ module Mongoid
       validations_for(document.class).delete_one(document._id)
     end
 
+    # Clear the touch-merged flag for a document on the current thread.
+    #
+    # @example Exit touch merged.
+    #   Threaded.exit_touch_merged(doc)
+    #
+    # @param [ Document ] document The document to clear.
+    def exit_touch_merged(document)
+      touch_merged_for(document.class).delete_one(document._id)
+    end
+
     # Begin suppressing default scopes for given model on the current thread.
     #
     # @example Begin without default scope stack.
@@ -347,6 +417,19 @@ module Mongoid
       validations_for(document.class).include?(document._id)
     end
 
+    # Is the document flagged as having had its touch updates
+    # merged into an atomic insert?
+    #
+    # @example Is the document touch-merged?
+    #   Threaded.touch_merged?(doc)
+    #
+    # @param [ Document ] document The document to check.
+    #
+    # @return [ true | false ] If the document's touch was merged.
+    def touch_merged?(document)
+      touch_merged_for(document.class).include?(document._id)
+    end
+
     # Get all autosaves on the current thread.
     #
     # @example Get all autosaves.
@@ -391,6 +474,28 @@ module Mongoid
       validations[klass] ||= []
     end
 
+    # Get all touch-merged tracking on the current thread.
+    #
+    # @example Get all touch-merged.
+    #   Threaded.touch_merged
+    #
+    # @return [ Hash ] The current touch-merged tracking hash.
+    def touch_merged
+      get(TOUCH_MERGED_KEY) { {} }
+    end
+
+    # Get all touch-merged document IDs on the current thread for the class.
+    #
+    # @example Get all touch-merged.
+    #   Threaded.touch_merged_for(Sofa)
+    #
+    # @param [ Class ] klass The class to check.
+    #
+    # @return [ Array ] The current touch-merged document IDs.
+    def touch_merged_for(klass)
+      touch_merged[klass] ||= []
+    end
+
     # Cache a session for this thread for a client.
     #
     # @note For backward compatibility it is allowed to call this method without
@@ -508,5 +613,36 @@ module Mongoid
 
       delete(CURRENT_SCOPE_KEY) if scope.empty?
     end
+
+    # Returns the current thread- or fiber-local storage as a Hash.
+    def storage
+      case Config.real_isolation_level
+      when :thread
+        storage_hash = Thread.current.thread_variable_get(STORAGE_KEY)
+
+        unless storage_hash
+          storage_hash = {}
+          Thread.current.thread_variable_set(STORAGE_KEY, storage_hash)
+        end
+
+        storage_hash
+
+      when :fiber
+        # Fiber[] storage is inherited by child fibers, so multiple sibling
+        # fibers would otherwise share a single mutable hash. We detect
+        # inheritance by comparing the stored owner ID to the current fiber;
+        # on first access by a new fiber we copy the inherited state so each
+        # fiber starts with a snapshot of its parent's state rather than a
+        # shared reference.
+        if Fiber[STORAGE_OWNER_KEY] != Fiber.current.object_id
+          Fiber[STORAGE_KEY] = (Fiber[STORAGE_KEY] || {}).dup
+          Fiber[STORAGE_OWNER_KEY] = Fiber.current.object_id
+        end
+        Fiber[STORAGE_KEY]
+
+      else
+        raise "Unknown isolation level: #{Config.real_isolation_level.inspect}"
+      end
+    end
   end
 end

data/lib/mongoid/timestamps/created/short.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Timestamps
     module Created
-
       # Adds a created_at timestamp to the document, but it is stored as c_at
       # with a created_at alias.
       module Short
@@ -12,7 +10,8 @@ module Mongoid
 
         included do
           include Created
-          fields.delete("created_at")
+
+          fields.delete('created_at')
           field :c_at, type: Time, as: :created_at
         end
       end