mongoid 9.0.11 → 9.1.1

data/lib/mongoid/persistable/updatable.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Persistable
-
     # Defines behavior for persistence operations that update existing
     # documents.
     module Updatable
-
       # Update a single attribute and persist the entire document.
       # This skips validation but fires the callbacks.
       #
@@ -22,7 +19,7 @@ module Mongoid
       #
       # @return [ true | false ] True if save was successful, false if not.
       def update_attribute(name, value)
-        as_writable_attribute!(name, value) do |access|
+        as_writable_attribute!(name, value) do |_access|
           normalized = name.to_s
           process_attribute(normalized, value)
           save(validate: false)
@@ -41,7 +38,7 @@ module Mongoid
         assign_attributes(attributes)
         save
       end
-      alias :update_attributes :update
+      alias update_attributes update
 
       # Update the document attributes in the database and raise an error if
       # validation failed.
@@ -63,7 +60,7 @@ module Mongoid
         end
         result
       end
-      alias :update_attributes! :update!
+      alias update_attributes! update!
 
       private
 
@@ -98,13 +95,15 @@ module Mongoid
       # @return [ true | false ] The result of the update.
       def prepare_update(options = {})
         raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
+
         enforce_immutability_of_id_field!
         ensure_client_compatibility!
         return false if performing_validations?(options) &&
-          invalid?(options[:context] || :update)
+                        invalid?(options[:context] || :update)
+
         process_flagged_destroys
         update_children = cascadable_children(:update)
-        process_touch_option(options, update_children) do
+        process_touch_option(options) do
           run_all_callbacks_for_update(update_children) do
             result = yield(self)
             self.previously_new_record = false
@@ -140,12 +139,11 @@ module Mongoid
             # of foo.0.bars while adding another foo. Each conflicting update
             # is applied using its own write.
             conflicts.each_pair do |modifier, changes|
-
               # Group the changes according to their root key which is
               # the top-level association name.
               # This handles at least the cases described in MONGOID-4982.
               conflicting_change_groups = changes.group_by do |key, _|
-                key.split(".", 2).first
+                key.split('.', 2).first
               end.values
 
               # Apply changes in batches. Pop one change from each
@@ -154,7 +152,7 @@ module Mongoid
               while batched_changes = conflicting_change_groups.map(&:pop).compact.to_h.presence
                 coll.find(selector).update_one(
                   positionally(selector, modifier => batched_changes),
-                  session: _session,
+                  session: _session
                 )
               end
             end
@@ -162,24 +160,22 @@ module Mongoid
         end
       end
 
-      # If there is a touch option and it is false, this method will call the
-      # timeless method so that the updated_at attribute is not updated. It
-      # will call the timeless method on all of the cascadable children as
-      # well. Note that timeless is cleared in the before_update callback.
+      # If there is a touch option and it is false, this method suppresses
+      # timestamping for the duration of the update using a block-based
+      # timeless scope, which covers this document and every cascaded child
+      # (at any nesting depth), and also suppresses touch callbacks.
       #
       # @param [ Hash ] options The options.
-      # @param [ Array<Document> ] children The children that the :update
-      #   callbacks will be executed on.
       #
       # @option options [ true | false ] :touch Whether or not the updated_at
       #   attribute will be updated with the current time.
-      def process_touch_option(options, children)
+      def process_touch_option(options, &block)
         if options.fetch(:touch, true)
           yield
         else
-          timeless
-          children.each(&:timeless)
-          suppress_touch_callbacks { yield }
+          Mongoid::Timestamps::Timeless.with_timeless do
+            suppress_touch_callbacks(&block)
+          end
         end
       end
 
@@ -199,13 +195,10 @@ module Mongoid
         # (somehow?) create the address with a nil _id first, before then
         # saving it *again* with the correct _id.
 
-        if _id_changed? && !_id_was.nil? && persisted?
-          if Mongoid::Config.immutable_ids
-            raise Errors::ImmutableAttribute.new(:_id, _id)
-          else
-            Mongoid::Warnings.warn_mutable_ids
-          end
-        end
+        return unless _id_changed? && !_id_was.nil? && persisted?
+        raise Errors::ImmutableAttribute.new(:_id, _id) if Mongoid::Config.immutable_ids
+
+        Mongoid::Warnings.warn_mutable_ids
       end
 
       # Consolidates all the callback invocations into a single place, to
@@ -213,22 +206,19 @@ module Mongoid
       #
       # @param [ Array<Document> ] update_children The children that the
       #   :update callbacks will be executed on.
-      def run_all_callbacks_for_update(update_children)
+      def run_all_callbacks_for_update(update_children, &block)
         run_callbacks(:commit, with_children: true, skip_if: -> { in_transaction? }) do
           run_callbacks(:save, with_children: false) do
             run_callbacks(:update, with_children: false) do
               run_callbacks(:persist_parent, with_children: false) do
                 _mongoid_run_child_callbacks(:save) do
-                  _mongoid_run_child_callbacks(:update, children: update_children) do
-                    yield
-                  end # _mongoid_run_child_callbacks :update
+                  _mongoid_run_child_callbacks(:update, children: update_children, &block) # _mongoid_run_child_callbacks :update
                 end # _mongoid_run_child_callbacks :save
               end # :persist_parent
             end # :update
           end # :save
         end # :commit
       end
-
     end
   end
 end

data/lib/mongoid/persistable/upsertable.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Persistable
-
     # Defines behavior for persistence operations that upsert documents.
     module Upsertable
-
       # Perform an upsert of the document. If the document does not exist in the
       # database, then Mongo will insert a new one, otherwise the fields will get
       # overwritten with new values on the existing document.
@@ -36,18 +33,18 @@ module Mongoid
       def upsert(options = {})
         prepare_upsert(options) do
           if options[:replace]
-            if options[:set_on_insert]
-              raise ArgumentError, "cannot specify :set_on_insert with `replace: true`"
-            end
+            raise ArgumentError, 'cannot specify :set_on_insert with `replace: true`' if options[:set_on_insert]
 
             collection.find(atomic_selector).replace_one(
-              as_attributes, upsert: true, session: _session)
+              as_attributes, upsert: true, session: _session
+            )
           else
-            attrs = { "$set" => as_attributes }
-            attrs["$setOnInsert"] = options[:set_on_insert] if options[:set_on_insert]
+            attrs = { '$set' => as_attributes }
+            attrs['$setOnInsert'] = options[:set_on_insert] if options[:set_on_insert]
 
             collection.find(atomic_selector).update_one(
-              attrs, upsert: true, session: _session)
+              attrs, upsert: true, session: _session
+            )
           end
         end
       end
@@ -71,6 +68,7 @@ module Mongoid
       def prepare_upsert(options = {})
         raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
         return false if performing_validations?(options) && invalid?(:upsert)
+
         result = run_callbacks(:upsert) do
           yield(self)
           true

data/lib/mongoid/persistable.rb

@@ -1,26 +1,24 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "mongoid/persistable/creatable"
-require "mongoid/persistable/deletable"
-require "mongoid/persistable/destroyable"
-require "mongoid/persistable/incrementable"
-require "mongoid/persistable/logical"
-require "mongoid/persistable/maxable"
-require "mongoid/persistable/minable"
-require "mongoid/persistable/multipliable"
-require "mongoid/persistable/poppable"
-require "mongoid/persistable/pullable"
-require "mongoid/persistable/pushable"
-require "mongoid/persistable/renamable"
-require "mongoid/persistable/savable"
-require "mongoid/persistable/settable"
-require "mongoid/persistable/updatable"
-require "mongoid/persistable/upsertable"
-require "mongoid/persistable/unsettable"
+require 'mongoid/persistable/creatable'
+require 'mongoid/persistable/deletable'
+require 'mongoid/persistable/destroyable'
+require 'mongoid/persistable/incrementable'
+require 'mongoid/persistable/logical'
+require 'mongoid/persistable/maxable'
+require 'mongoid/persistable/minable'
+require 'mongoid/persistable/multipliable'
+require 'mongoid/persistable/poppable'
+require 'mongoid/persistable/pullable'
+require 'mongoid/persistable/pushable'
+require 'mongoid/persistable/renamable'
+require 'mongoid/persistable/savable'
+require 'mongoid/persistable/settable'
+require 'mongoid/persistable/updatable'
+require 'mongoid/persistable/upsertable'
+require 'mongoid/persistable/unsettable'
 
 module Mongoid
-
   # Contains general behavior for persistence operations.
   module Persistable
     extend ActiveSupport::Concern
@@ -44,7 +42,7 @@ module Mongoid
     include Unsettable
 
     # The atomic operations that deal with arrays or sets in the db.
-    LIST_OPERATIONS = [ "$addToSet", "$push", "$pull", "$pullAll" ].freeze
+    LIST_OPERATIONS = [ '$addToSet', '$push', '$pull', '$pullAll' ].freeze
 
     # Execute operations atomically (in a single database call) for everything
     # that would happen inside the block. This method supports nesting further
@@ -174,9 +172,7 @@ module Mongoid
     def post_process_persist(result, options = {})
       post_persist unless result == false
       errors.clear unless performing_validations?(options)
-      if in_transaction?
-        Threaded.add_modified_document(_session, self)
-      end
+      Threaded.add_modified_document(_session, self) if in_transaction?
       true
     end
 
@@ -193,6 +189,7 @@ module Mongoid
     # @return [ Object ] The result of the operation.
     def prepare_atomic_operation
       raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
+
       operations = yield({})
       persist_or_delay_atomic_operation(operations)
       self
@@ -229,6 +226,7 @@ module Mongoid
     #   document._mongoid_remove_atomic_context_changes
     def _mongoid_remove_atomic_context_changes
       return unless executing_atomically?
+
       _mongoid_atomic_context_changed_fields.each { |f| remove_change f }
     end
 
@@ -241,6 +239,7 @@ module Mongoid
     #   document._mongoid_reset_atomic_context_changes!
     def _mongoid_reset_atomic_context_changes!
       return unless executing_atomically?
+
       _mongoid_atomic_context_changed_fields.each { |f| reset_attribute! f }
     end
 
@@ -252,6 +251,7 @@ module Mongoid
     #   document._mongoid_push_atomic_context
     def _mongoid_push_atomic_context
       return unless executing_atomically?
+
       @atomic_context = {}
       @atomic_updates_to_execute_stack << @atomic_context
     end
@@ -264,6 +264,7 @@ module Mongoid
     #   document._mongoid_pop_atomic_context
     def _mongoid_pop_atomic_context
       return unless executing_atomically?
+
       @atomic_updates_to_execute_stack.pop
       @atomic_context = @atomic_updates_to_execute_stack.last
     end
@@ -309,10 +310,10 @@ module Mongoid
     #
     # @param [ Hash ] operations The atomic operations.
     def persist_atomic_operations(operations)
-      if persisted? && operations && !operations.empty?
-        selector = atomic_selector
-        _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
-      end
+      return unless persisted? && operations && !operations.empty?
+
+      selector = atomic_selector
+      _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
     end
   end
 end

data/lib/mongoid/persistence_context.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
-
   # Object encapsulating logic for setting/getting a collection and database name
   # and a client with particular options to use when persisting models.
   class PersistenceContext
@@ -24,16 +22,15 @@ module Mongoid
     #
     # @return [ Array<Symbol> ] The list of extra options besides client options
     #   that determine the persistence context.
-    EXTRA_OPTIONS = [ :client,
-                      :collection,
-                      :collection_options
-                    ].freeze
+    EXTRA_OPTIONS = %i[client
+                       collection
+                       collection_options].freeze
 
     # The full list of valid persistence context options.
     #
     # @return [ Array<Symbol> ] The full list of options defining the persistence
     #   context.
-    VALID_OPTIONS = ( Mongo::Client::VALID_OPTIONS + EXTRA_OPTIONS ).freeze
+    VALID_OPTIONS = (Mongo::Client::VALID_OPTIONS + EXTRA_OPTIONS).freeze
 
     # Initialize the persistence context object.
     #
@@ -79,9 +76,11 @@ module Mongoid
     # @return [ Mongo::Collection ] The collection for this persistence
     #   context.
     def collection(parent = nil)
-      parent ?
-        parent.collection.with(client_options.except(:database, "database")) :
+      if parent
+        parent.collection.with(client_options.except(:database, 'database'))
+      else
         client[collection_name.to_sym]
+      end
     end
 
     # Get the collection name for this persistence context.
@@ -92,8 +91,8 @@ module Mongoid
     # @return [ String ] The collection name for this persistence
     #   context.
     def collection_name
-      @collection_name ||= (__evaluate__(options[:collection] ||
-                             storage_options[:collection]))
+      @collection_name ||= __evaluate__(options[:collection] ||
+                             storage_options[:collection])
     end
 
     # Get the database name for this persistence context.
@@ -126,6 +125,8 @@ module Mongoid
 
         client = client.with(options) unless options.empty?
 
+        verify_encryption_schema!(client)
+
         client
       end
     end
@@ -139,8 +140,8 @@ module Mongoid
     #   context.
     def client_name
       @client_name ||= __evaluate__(options[:client]) ||
-                         Threaded.client_override ||
-                         __evaluate__(storage_options[:client])
+                       Threaded.client_override ||
+                       __evaluate__(storage_options[:client])
     end
 
     # Determine if this persistence context is equal to another.
@@ -153,6 +154,7 @@ module Mongoid
     # @return [ true | false ] Whether the two persistence contexts are equal.
     def ==(other)
       return false unless other.is_a?(PersistenceContext)
+
       options == other.options
     end
 
@@ -168,7 +170,7 @@ module Mongoid
     #
     # @api private
     def reusable_client?
-      @options.keys == [:client]
+      @options.keys == [ :client ]
     end
 
     # The subset of provided options that may be used as storage
@@ -187,38 +189,68 @@ module Mongoid
 
     def set_options!(opts)
       @options ||= opts.each.reduce({}) do |_options, (key, value)|
-                     unless VALID_OPTIONS.include?(key.to_sym)
-                       raise Errors::InvalidPersistenceOption.new(key.to_sym, VALID_OPTIONS)
-                     end
-                     value ? _options.merge!(key => value) : _options
-                   end
+        raise Errors::InvalidPersistenceOption.new(key.to_sym, VALID_OPTIONS) unless VALID_OPTIONS.include?(key.to_sym)
+
+        value ? _options.merge!(key => value) : _options
+      end
     end
 
     def __evaluate__(name)
       return nil unless name
+
       name.respond_to?(:call) ? name.call.to_sym : name.to_sym
     end
 
+    # Refuse to use a client that would store a model's encrypted fields in
+    # plaintext.
+    #
+    # The automatic encryption schema is keyed by namespace and is built once,
+    # when the client is created. The driver looks the target namespace up in
+    # that schema, and when it is absent it asks the server for a schema
+    # instead; a collection without a validator then yields no encryption at
+    # all, and no error. Checking the namespace here is what turns that silent
+    # downgrade into a failure.
+    #
+    # @param [ Mongo::Client ] client The client this context resolved to.
+    #
+    # @raise [ Errors::NoEncryptionSchema ] if the model needs an encryption
+    #   schema and the client's schema does not cover the target namespace.
+    def verify_encryption_schema!(client)
+      klass = @object.is_a?(Class) ? @object : @object.class
+      # A model whose encrypted fields all live on embedded models declares no
+      # encryption of its own, and still needs a schema for its collection.
+      return unless klass.respond_to?(:requires_encryption_schema?) && klass.requires_encryption_schema?
+      # An embedded document is persisted as part of its parent, so the
+      # parent's context is what governs the namespace.
+      return if klass.embedded?
+      # Collection and index management sends no document data, so it does not
+      # need an encryption-capable client.
+      return if Threaded.managing_collection?
+
+      schema_map = client.options.dig(:auto_encryption_options, :schema_map)
+      namespace = "#{client.database.name}.#{collection_name}"
+      return if schema_map&.key?(namespace)
+
+      raise Errors::NoEncryptionSchema.new(klass, namespace, client_name)
+    end
+
     def client_options
       @client_options ||= begin
-        opts = options.select do |k, v|
-                              Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
-                            end
-        if opts[:read].is_a?(Symbol)
-          opts[:read] = {mode: opts[:read]}
+        opts = options.select do |k, _v|
+          Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
         end
+        opts[:read] = { mode: opts[:read] } if opts[:read].is_a?(Symbol)
         opts
       end
     end
 
     def database_name_option
       @database_name_option ||= options[:database] ||
-                                  Threaded.database_override ||
-                                  storage_options[:database]
+                                Threaded.database_override ||
+                                storage_options[:database]
     end
 
     class << self
-
       # Set the persistence context for a particular class or model instance.
       #
       # If there already is a persistence context set, options in the existing
@@ -235,13 +267,11 @@ module Mongoid
       def set(object, options_or_context)
         existing_context = get_context(object)
         existing_options = if existing_context
-          existing_context.options
-        else
-          {}
-        end
-        if options_or_context.is_a?(PersistenceContext)
-          options_or_context = options_or_context.options
-        end
+                             existing_context.options
+                           else
+                             {}
+                           end
+        options_or_context = options_or_context.options if options_or_context.is_a?(PersistenceContext)
         new_options = existing_options.merge(options_or_context)
         context = PersistenceContext.new(object, new_options)
         store_context(object, context)
@@ -269,10 +299,8 @@ module Mongoid
       # @param [ Mongoid::PersistenceContext ] original_context The original persistence
       #   context that was set before this context was used.
       def clear(object, cluster = nil, original_context = nil)
-        if context = get(object)
-          unless cluster.nil? || context.cluster.equal?(cluster)
-            context.client.close unless context.reusable_client?
-          end
+        if (context = get(object)) && !(cluster.nil? || context.cluster.equal?(cluster)) && !context.reusable_client?
+          context.client.close
         end
       ensure
         store_context(object, original_context)
@@ -283,7 +311,7 @@ module Mongoid
       # Key to store persistence contexts in the thread local storage.
       #
       # @api private
-      PERSISTENCE_CONTEXT_KEY = :"[mongoid]:persistence_context"
+      PERSISTENCE_CONTEXT_KEY = :'[mongoid]:persistence_context'
 
       def context_store
         Threaded.get(PERSISTENCE_CONTEXT_KEY) { {} }
@@ -292,7 +320,7 @@ module Mongoid
       # Get the persistence context for a given object from the thread local
       #   storage.
       #
-      # @param [ Object ] object Object to get the persistance context for.
+      # @param [ Object ] object Object to get the persistence context for.
       #
       # @return [ Mongoid::PersistenceContext | nil ] The persistence context
       #   for the object if previously stored, otherwise nil.
@@ -305,7 +333,7 @@ module Mongoid
       # Store persistence context for a given object in the thread local
       #   storage.
       #
-      # @param [ Object ] object Object to store the persistance context for.
+      # @param [ Object ] object Object to store the persistence context for.
       # @param [ Mongoid::PersistenceContext ] context Context to store
       #
       # @api private

data/lib/mongoid/pluckable.rb

@@ -100,7 +100,6 @@ module Mongoid
     #
     # @return [ Object ] The value at the next level.
     #
-    # rubocop:disable Metrics/ParameterLists
     def descend(part, current, method_name, field, part_count, is_translation)
       # 1. If curr is an array fetch from all elements in the array.
       # 2. If the field is localized, and is not an _translations field
@@ -127,6 +126,5 @@ module Mongoid
         fetch_and_demongoize(current, method_name, field)
       end
     end
-    # rubocop:enable Metrics/ParameterLists
   end
 end

data/lib/mongoid/positional.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
-
   # This module is responsible for taking update selectors and switching out
   # the indexes for the $ positional operator where appropriate.
   module Positional
-
     # Takes the provided selector and atomic operations and replaces the
     # indexes of the embedded documents with the positional operator when
     # needed.
@@ -32,11 +29,10 @@ module Mongoid
     #
     # @return [ Hash ] The new operations.
     def positionally(selector, operations, processed = {})
-      if selector.size == 1 || selector.values.any? { |val| val.nil? }
-        return operations
-      end
-      keys = selector.keys.map{ |m| m.sub('._id','') } - ['_id']
-      keys = keys.sort_by { |s| s.length*-1 }
+      return operations if selector.size == 1 || selector.values.any? { |val| val.nil? }
+
+      keys = selector.keys.map { |m| m.sub('._id', '') } - [ '_id' ]
+      keys = keys.sort_by { |s| s.length * -1 }
       process_operations(keys, operations, processed)
     end
 
@@ -62,9 +58,7 @@ module Mongoid
       matches = position.scan(/\.\d+\./)
       if matches.size == 1
         keys.each do |kk|
-          if position =~ /\A#{kk}\.\d+\.(.*)\z/
-            return "#{kk}.$.#{$1}"
-          end
+          return "#{kk}.$.#{::Regexp.last_match(1)}" if position =~ /\A#{kk}\.\d+\.(.*)\z/
         end
       end
       position