mongoid 9.0.11 → 9.1.1

data/lib/mongoid/clients/sessions.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Clients
-
     # Encapsulates behavior for using sessions and transactions.
     module Sessions
-
       # Add class method mixin functionality.
       #
       # @todo Replace with ActiveSupport::Concern
@@ -15,10 +12,9 @@ module Mongoid
       end
 
       module ClassMethods
-
         # Actions that can be used to trigger transactional callbacks.
         # @api private
-        CALLBACK_ACTIONS = [:create, :destroy, :update]
+        CALLBACK_ACTIONS = %i[create destroy update]
 
         # Execute a block within the context of a session.
         #
@@ -40,24 +36,21 @@ module Mongoid
         #
         # @yieldparam [ Mongo::Session ] The session being used for the block.
         def with_session(options = {})
-          if Threaded.get_session(client: persistence_context.client)
-            raise Mongoid::Errors::InvalidSessionNesting.new
-          end
+          raise Mongoid::Errors::InvalidSessionNesting.new if Threaded.get_session(client: persistence_context.client)
+
           session = persistence_context.client.start_session(options)
           Threaded.set_session(session, client: persistence_context.client)
           yield(session)
-        rescue Mongo::Error::InvalidSession => ex
-          if Mongo::Error::SessionsNotSupported === ex
-            raise Mongoid::Errors::SessionsNotSupported.new
-          else
-            raise ex
-          end
-        rescue Mongo::Error::OperationFailure => ex
-          if (ex.code == 40415 && ex.server_message =~ /startTransaction/) ||
-             (ex.code == 20 && ex.server_message =~ /Transaction/)
+        rescue Mongo::Error::InvalidSession => e
+          raise Mongoid::Errors::SessionsNotSupported.new if e.is_a?(Mongo::Error::SessionsNotSupported)
+
+          raise e
+        rescue Mongo::Error::OperationFailure => e
+          if (e.code == 40_415 && e.server_message =~ /startTransaction/) ||
+             (e.code == 20 && e.server_message =~ /Transaction/)
             raise Mongoid::Errors::TransactionsNotSupported.new
           else
-            raise ex
+            raise e
           end
         rescue *transactions_not_supported_exceptions
           raise Mongoid::Errors::TransactionsNotSupported
@@ -87,26 +80,22 @@ module Mongoid
         #   by MongoDB deployment or MongoDB driver.
         #
         # @yield Provided block will be executed inside a transaction.
-        def transaction(options = {}, session_options: {})
+        def transaction(options = {}, session_options: {}, &block)
           with_session(session_options) do |session|
-            begin
-              session.with_transaction(options) do
-                yield
-              end.tap { run_commit_callbacks(session) }
-            rescue *transactions_not_supported_exceptions
-              raise Mongoid::Errors::TransactionsNotSupported
-            rescue Mongoid::Errors::Rollback
-              run_abort_callbacks(session)
-            rescue Mongoid::Errors::InvalidSessionNesting
-              # Session should be ended here.
-              raise Mongoid::Errors::InvalidTransactionNesting.new
-            rescue Mongo::Error::InvalidSession, Mongo::Error::InvalidTransactionOperation => e
-              run_abort_callbacks(session)
-              raise Mongoid::Errors::TransactionError.new(e)
-            rescue StandardError => e
-              run_abort_callbacks(session)
-              raise e
-            end
+            session.with_transaction(options, &block).tap { run_commit_callbacks(session) }
+          rescue *transactions_not_supported_exceptions
+            raise Mongoid::Errors::TransactionsNotSupported
+          rescue Mongoid::Errors::Rollback
+            run_abort_callbacks(session)
+          rescue Mongoid::Errors::InvalidSessionNesting
+            # Session should be ended here.
+            raise Mongoid::Errors::InvalidTransactionNesting.new
+          rescue Mongo::Error::InvalidSession, Mongo::Error::InvalidTransactionOperation => e
+            run_abort_callbacks(session)
+            raise Mongoid::Errors::TransactionError.new(e)
+          rescue StandardError => e
+            run_abort_callbacks(session)
+            raise e
           end
         end
 
@@ -123,7 +112,7 @@ module Mongoid
 
         # Shortcut for +after_commit :hook, on: [ :create, :update ]+
         def after_save_commit(*args, &block)
-          set_options_for_callbacks!(args, on: [ :create, :update ])
+          set_options_for_callbacks!(args, on: %i[create update])
           set_callback(:commit, :after, *args, &block)
         end
 
@@ -216,14 +205,14 @@ module Mongoid
           options = args.extract_options!.merge(enforced_options)
           args << options
 
-          if options[:on]
-            fire_on = Array(options[:on])
-            assert_valid_transaction_action(fire_on)
-            options[:if] = [
-              -> { transaction_include_any_action?(fire_on) },
-              *options[:if]
-            ]
-          end
+          return unless options[:on]
+
+          fire_on = Array(options[:on])
+          assert_valid_transaction_action(fire_on)
+          options[:if] = [
+            -> { transaction_include_any_action?(fire_on) },
+            *options[:if]
+          ]
         end
 
         # Asserts that the given actions are valid for after_commit
@@ -232,9 +221,10 @@ module Mongoid
         # @param [ Array<Symbol> ] actions Actions to be checked.
         # @raise [ ArgumentError ] If any of the actions is not valid.
         def assert_valid_transaction_action(actions)
-          if (actions - CALLBACK_ACTIONS).any?
-            raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{CALLBACK_ACTIONS}"
-          end
+          return unless (actions - CALLBACK_ACTIONS).any?
+
+          raise ArgumentError,
+                ":on conditions for after_commit and after_rollback callbacks have to be one of #{CALLBACK_ACTIONS}"
         end
 
         def transaction_include_any_action?(actions)
@@ -274,17 +264,17 @@ module Mongoid
         # a model within a transaction, where the model is not itself
         # controlled by that transaction. this is potentially a bug, so
         # let's tell them about it.
-        if session.nil?
-          # This is hacky; we're hijacking Mongoid::Errors::MongoidError in
-          # order to get the spiffy error message translation. If we later
-          # decide to raise an error instead of just writing a message, we can
-          # subclass MongoidError and raise that exception here.
-          message = Errors::MongoidError.new.compose_message(
-            'client_session_mismatch',
-            model: self.class.name
-          )
-          logger.info(message)
-        end
+        return unless session.nil?
+
+        # This is hacky; we're hijacking Mongoid::Errors::MongoidError in
+        # order to get the spiffy error message translation. If we later
+        # decide to raise an error instead of just writing a message, we can
+        # subclass MongoidError and raise that exception here.
+        message = Errors::MongoidError.new.compose_message(
+          'client_session_mismatch',
+          model: self.class.name
+        )
+        logger.info(message)
       end
     end
   end

data/lib/mongoid/clients/storage_options.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Clients
-
     # Mixin module included into Mongoid::Document which adds
     # the ability to set the collection in which to store the
     # document by default.
@@ -46,7 +44,6 @@ module Mongoid
       end
 
       module ClassMethods
-
         # Give this model specific custom default storage options.
         #
         # @example Store this model by default in "artists"
@@ -82,7 +79,7 @@ module Mongoid
         # @return [ Class ] The model class.
         def store_in(options)
           Validators::Storage.validate(self, options)
-          self.storage_options = self.storage_options.merge(options)
+          self.storage_options = storage_options.merge(options)
         end
 
         # Reset the store_in options

data/lib/mongoid/clients/validators/storage.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Clients
     module Validators
-
       # Validates the options passed to :store_in.
       module Storage
         extend self
 
         # The valid options for storage.
-        VALID_OPTIONS = [ :collection, :collection_options, :database, :client ].freeze
+        VALID_OPTIONS = %i[collection collection_options database client].freeze
 
         # Validate the options provided to :store_in.
         #
@@ -37,6 +35,7 @@ module Mongoid
         # @return [ true | false ] If all keys are valid.
         def valid_keys?(options)
           return false unless options.is_a?(::Hash)
+
           options.keys.all? do |key|
             VALID_OPTIONS.include?(key)
           end

data/lib/mongoid/clients/validators.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "mongoid/clients/validators/storage"
+require 'mongoid/clients/validators/storage'

data/lib/mongoid/clients.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "mongoid/clients/factory"
-require "mongoid/clients/validators"
-require "mongoid/clients/storage_options"
-require "mongoid/clients/options"
-require "mongoid/clients/sessions"
+require 'mongoid/clients/factory'
+require 'mongoid/clients/validators'
+require 'mongoid/clients/storage_options'
+require 'mongoid/clients/options'
+require 'mongoid/clients/sessions'
 
 module Mongoid
-
   # Mixin module included into Mongoid::Document which adds
   # database client connection functionality. Also contains
   # singleton class methods related to managing database clients.
@@ -19,7 +17,6 @@ module Mongoid
     include Sessions
 
     class << self
-
       # Clear all clients from the current thread.
       #
       # @example Clear all clients.
@@ -75,8 +72,10 @@ module Mongoid
       def with_name(name)
         name_as_symbol = name.to_sym
         return clients[name_as_symbol] if clients[name_as_symbol]
+
         CREATE_LOCK.synchronize do
-          if (key_vault_client = Mongoid.clients.dig(name_as_symbol, :options, :auto_encryption_options, :key_vault_client))
+          if (key_vault_client = Mongoid.clients.dig(name_as_symbol, :options, :auto_encryption_options,
+                                                     :key_vault_client))
             clients[key_vault_client.to_sym] ||= Clients::Factory.create(key_vault_client)
           end
           clients[name_as_symbol] ||= Clients::Factory.create(name)
@@ -103,8 +102,6 @@ module Mongoid
         @clients ||= {}
       end
 
-      private
-
       CREATE_LOCK = Mutex.new
     end
   end

data/lib/mongoid/collection_configurable.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
-
   # Encapsulates behavior around defining collections.
   module CollectionConfigurable
     extend ActiveSupport::Concern
@@ -22,26 +20,32 @@ module Mongoid
       # @raise [ Errors::CreateCollectionFailure ] If collection creation failed.
       # @raise [ Errors::DropCollectionFailure ] If an attempt to drop collection failed.
       def create_collection(force: false)
+        Threaded.with_collection_management do
+          perform_create_collection(force: force)
+        end
+      end
+
+      private
+
+      def perform_create_collection(force:)
         if collection_name.empty?
           # This is most probably an anonymous class, we ignore them.
           return
         end
-        if collection_name.match(/^system\./)
+        if /^system\./.match?(collection_name)
           # We do not do anything with system collections.
           return
         end
-        if force
-          collection.drop
-        end
+
+        collection.drop if force
         if coll_options = collection.database.list_collections(filter: { name: collection_name.to_s }).first
-          if force
-            raise Errors::DropCollectionFailure.new(collection_name)
-          else
-            logger.debug(
-              "MONGOID: Collection '#{collection_name}' already exists " +
-              "in database '#{database_name}' with options '#{coll_options}'."
-            )
-          end
+          raise Errors::DropCollectionFailure.new(collection_name) if force
+
+          logger.debug(
+            "MONGOID: Collection '#{collection_name}' already exists " +
+            "in database '#{database_name}' with options '#{coll_options}'."
+          )
+
         else
           begin
             collection.database[collection_name, storage_options.fetch(:collection_options, {})].create

data/lib/mongoid/composable.rb

@@ -1,30 +1,28 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "mongoid/changeable"
-require "mongoid/collection_configurable"
-require "mongoid/encryptable"
-require "mongoid/findable"
+require 'mongoid/changeable'
+require 'mongoid/collection_configurable'
+require 'mongoid/encryptable'
+require 'mongoid/findable'
 require 'mongoid/identifiable'
-require "mongoid/indexable"
-require "mongoid/inspectable"
-require "mongoid/interceptable"
-require "mongoid/matcher"
-require "mongoid/matchable"
-require "mongoid/persistable"
-require "mongoid/reloadable"
+require 'mongoid/indexable'
+require 'mongoid/inspectable'
+require 'mongoid/interceptable'
+require 'mongoid/matcher'
+require 'mongoid/matchable'
+require 'mongoid/persistable'
+require 'mongoid/reloadable'
 require 'mongoid/search_indexable'
-require "mongoid/selectable"
-require "mongoid/scopable"
-require "mongoid/serializable"
-require "mongoid/shardable"
-require "mongoid/stateful"
-require "mongoid/cacheable"
-require "mongoid/traversable"
-require "mongoid/validatable"
+require 'mongoid/selectable'
+require 'mongoid/scopable'
+require 'mongoid/serializable'
+require 'mongoid/shardable'
+require 'mongoid/stateful'
+require 'mongoid/cacheable'
+require 'mongoid/traversable'
+require 'mongoid/validatable'
 
 module Mongoid
-
   # This module provides inclusions of all behavior in a Mongoid document.
   module Composable
     extend ActiveSupport::Concern
@@ -105,21 +103,19 @@ module Mongoid
     # separately.
     #
     # @return [ Array<Symbol> ] A list of reserved method names.
-    RESERVED_METHOD_NAMES = [ :fields,
-                              :aliased_fields,
-                              :localized_fields,
-                              :index_specifications,
-                              :shard_key_fields,
-                              :nested_attributes,
-                              :readonly_attributes,
-                              :storage_options,
-                              :cascades,
-                              :cyclic,
-                              :cache_timestamp_format
-                            ]
+    RESERVED_METHOD_NAMES = %i[fields
+                               aliased_fields
+                               localized_fields
+                               index_specifications
+                               shard_key_fields
+                               nested_attributes
+                               readonly_attributes
+                               storage_options
+                               cascades
+                               cyclic
+                               cache_timestamp_format]
 
     class << self
-
       # Get a list of methods that would be a bad idea to define as field names
       # or override when including Mongoid::Document.
       #

data/lib/mongoid/config/defaults.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Config
-
     # Encapsulates logic for loading defaults.
     module Defaults
-
       # Load the defaults for the feature flags in the given Mongoid version.
       # Note that this method will load the *new* functionality introduced in
       # the given Mongoid version.
@@ -33,7 +30,12 @@ module Mongoid
           load_defaults '9.0'
 
         when '9.0'
-          # All flag defaults currently reflect 9.0 behavior.
+          self.autosave_saves_unchanged_documents = true
+
+          load_defaults '9.1'
+
+        when '9.1'
+          # All flag defaults currently reflect 9.1 behavior.
 
         else
           raise ArgumentError, "Unknown version: #{version}"

data/lib/mongoid/config/encryption.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/extensions/boolean'
 require 'mongoid/stringified_symbol'
@@ -21,17 +20,25 @@ module Mongoid
       #
       # @return [ Hash ] The encryption schema map.
       def encryption_schema_map(default_database, models = ::Mongoid.models)
-        visited = Set.new
         models.each_with_object({}) do |model, map|
-          next if visited.include?(model)
-          visited << model
           next if model.embedded?
-          next unless model.encrypted?
+          next unless model.requires_encryption_schema?
 
           database = model.storage_options.fetch(:database) { default_database }
+          # A callable database name cannot be resolved here: the documented
+          # multi-tenant idiom has no correct value while the client is being
+          # built. Interpolating the callable would produce a key that never
+          # matches any namespace, so leave the model out of the map. Writes
+          # are refused later, by PersistenceContext, rather than silently
+          # going out unencrypted.
+          next if database.respond_to?(:call)
+
           key = "#{database}.#{model.collection_name}"
-          props = metadata_for(model).merge(properties_for(model, visited))
-          map[key] = props unless props.empty?
+          props = metadata_for(model).merge(properties_for(model, [ model ]))
+          # The root of a collection schema describes the document, so it is
+          # always an object. Saying so matters when a nested schema carries
+          # encryptMetadata: mongocryptd rejects the schema otherwise.
+          map[key] = { 'bsonType' => 'object' }.merge(props) unless props.empty?
         end
       end
 
@@ -100,11 +107,12 @@ module Mongoid
       # are marked as encrypted.
       #
       # @param [ Mongoid::Document ] model The model to generate the properties for.
-      # @param [ Set<Mongoid::Document> ] visited The set of models that have already been visited.
+      # @param [ Array<Mongoid::Document> ] path The models the walk is already
+      #   inside of, outermost first.
       #
       # @return [ Hash ] The encryption properties.
-      def properties_for(model, visited)
-        result = properties_for_fields(model).merge(properties_for_relations(model, visited))
+      def properties_for(model, path)
+        result = properties_for_fields(model).merge(properties_for_relations(model, path))
         if result.empty?
           {}
         else
@@ -141,20 +149,29 @@ module Mongoid
       # are configured to be encrypted.
       #
       # @param [ Mongoid::Document ] model The model to generate the properties for.
-      # @param [ Set<Mongoid::Document> ] visited The set of models that have already been visited.
+      # @param [ Array<Mongoid::Document> ] path The models the walk is already
+      #   inside of, outermost first.
       #
       # @return [ Hash ] The encryption properties.
-      def properties_for_relations(model, visited)
+      def properties_for_relations(model, path)
         model.relations.each_with_object({}) do |(name, relation), props|
-          next if visited.include?(relation.relation_class)
+          # relation_class constantizes, and a polymorphic embedded_in has no
+          # class to resolve, so the relation type has to be checked first.
           next unless relation.is_a?(Association::Embedded::EmbedsOne)
-          next unless relation.relation_class.encrypted?
 
-          visited << relation.relation_class
-          metadata_for(
-            relation.relation_class
-          ).merge(
-            properties_for(relation.relation_class, visited)
+          klass = relation.try_relation_class
+          # An association target does not have to be a Mongoid document, and
+          # the class it names does not have to exist.
+          next unless klass.respond_to?(:requires_encryption_schema?)
+          # Stop at a model the walk is already inside of, or a self-embedding
+          # model never terminates. The path covers the current branch only:
+          # a model embedded by two parents, or twice by one parent, has to be
+          # emitted at every place it appears.
+          next if path.include?(klass)
+          next unless klass.requires_encryption_schema?
+
+          metadata_for(klass).merge(
+            properties_for(klass, path + [ klass ])
           ).tap do |properties|
             props[name] = { 'bsonType' => 'object' }.merge(properties) unless properties.empty?
           end
@@ -182,8 +199,6 @@ module Mongoid
           DETERMINISTIC_ALGORITHM
         when false
           RANDOM_ALGORITHM
-        else
-          nil
         end
       end
 

data/lib/mongoid/config/environment.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Config
-
     # Encapsulates logic for getting environment information.
     module Environment
       extend self
@@ -25,13 +23,10 @@ module Mongoid
       # @return [ String ] The name of the current environment.
       # @api public
       def env_name
-        if defined?(::Rails)
-          return ::Rails.env
-        end
-        if defined?(::Sinatra)
-          return ::Sinatra::Base.environment.to_s
-        end
-        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] or raise Errors::NoEnvironment
+        return ::Rails.env if defined?(::Rails)
+        return ::Sinatra::Base.environment.to_s if defined?(::Sinatra)
+
+        ENV['RACK_ENV'] || ENV['MONGOID_ENV'] or raise Errors::NoEnvironment
       end
 
       # Load the yaml from the provided path and return the settings for the
@@ -51,9 +46,7 @@ module Mongoid
         env = environment ? environment.to_s : env_name
 
         contents = File.read(path)
-        if contents.empty?
-          raise Mongoid::Errors::EmptyConfigFile.new(path)
-        end
+        raise Mongoid::Errors::EmptyConfigFile.new(path) if contents.empty?
 
         # These are the classes that can be used in a Mongoid
         # configuration file in addition to standard YAML types.
@@ -62,15 +55,13 @@ module Mongoid
           Symbol,
           # BSON::Binary occur as keyId values for FLE (more precisely,
           # the keyIds are UUIDs).
-          BSON::Binary,
+          BSON::Binary
         ]
 
         result = ERB.new(contents).result
         data = YAML.safe_load(result, permitted_classes: permitted_classes, aliases: true)
 
-        unless data.is_a?(Hash)
-          raise Mongoid::Errors::InvalidConfigFile.new(path)
-        end
+        raise Mongoid::Errors::InvalidConfigFile.new(path) unless data.is_a?(Hash)
 
         data[env]
       end