mongoid 9.1.0 → 9.1.1

data/lib/mongoid/errors/in_memory_regexp_timeout.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # This error is raised when evaluating a query in memory exceeds
+    # Mongoid::Config.in_memory_regexp_time_limit.
+    #
+    # What the limit bounds depends on the Ruby in use. Where per-Regexp
+    # timeouts are available it is the time spent executing regular
+    # expressions; elsewhere it is the elapsed time of the whole in-memory
+    # evaluation. The message is worded to hold either way.
+    class InMemoryRegexpTimeout < MongoidError
+      # Create the new error.
+      #
+      # @example Create the new in-memory regexp timeout error.
+      #   InMemoryRegexpTimeout.new(5.0)
+      #
+      # @param [ Float ] limit The limit that was exceeded, in seconds. Not
+      #   always the configured one: a global Regexp.timeout stricter than the
+      #   configuration takes its place.
+      def initialize(limit)
+        super(compose_message('in_memory_regexp_timeout', limit: limit))
+      end
+    end
+  end
+end

data/lib/mongoid/errors/mixed_client_configuration.rb

@@ -16,7 +16,7 @@ module Mongoid
         super(
           compose_message(
             'mixed_client_configuration',
-            { name: name, config: config }
+            { name: name, config: ConfigRedactor.redact(config) }
           )
         )
       end

data/lib/mongoid/errors/no_client_database.rb

@@ -15,7 +15,7 @@ module Mongoid
         super(
           compose_message(
             'no_client_database',
-            { name: name, config: config }
+            { name: name, config: ConfigRedactor.redact(config) }
           )
         )
       end

data/lib/mongoid/errors/no_client_hosts.rb

@@ -15,7 +15,7 @@ module Mongoid
         super(
           compose_message(
             'no_client_hosts',
-            { name: name, config: config }
+            { name: name, config: ConfigRedactor.redact(config) }
           )
         )
       end

data/lib/mongoid/errors/no_encryption_schema.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # This error is raised when a model declares encrypted fields, but the
+    # namespace it is about to be persisted to is not covered by the automatic
+    # encryption schema of the client in use. Without a schema the driver has
+    # nothing to encrypt with, and the fields would be stored in plaintext.
+    class NoEncryptionSchema < MongoidError
+      # Create the new error.
+      #
+      # @example Create the error.
+      #   NoEncryptionSchema.new(Band, 'music.bands', :default)
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String ] namespace The namespace the model resolved to.
+      # @param [ String | Symbol ] client The name of the client in use.
+      def initialize(klass, namespace, client)
+        super(
+          compose_message(
+            'no_encryption_schema',
+            { klass: klass, namespace: namespace, client: client }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/readonly_association.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # Raised when attempting to write to a :through association, which is
+    # read-only.
+    class ReadonlyAssociation < MongoidError
+      # Instantiate the exception.
+      #
+      # @example Create the error.
+      #   ReadonlyAssociation.new(Physician, association)
+      #
+      # @param [ Class ] klass The owner class.
+      # @param [ Mongoid::Association::Relatable ] association The through association.
+      def initialize(klass, association)
+        super(
+          compose_message(
+            'readonly_association',
+            {
+              klass: klass,
+              name: association.name,
+              through: association.options[:through]
+            }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'mongoid/errors/mongoid_error'
+require 'mongoid/errors/config_redactor'
 require 'mongoid/errors/ambiguous_relationship'
 require 'mongoid/errors/attribute_not_loaded'
 require 'mongoid/errors/callback'
@@ -11,6 +12,7 @@ require 'mongoid/errors/document_not_found'
 require 'mongoid/errors/empty_config_file'
 require 'mongoid/errors/immutable_attribute'
 require 'mongoid/errors/in_memory_collation_not_supported'
+require 'mongoid/errors/in_memory_regexp_timeout'
 require 'mongoid/errors/invalid_auto_encryption_configuration'
 require 'mongoid/errors/invalid_around_callback'
 require 'mongoid/errors/invalid_async_query_executor'
@@ -51,6 +53,7 @@ require 'mongoid/errors/mixed_client_configuration'
 require 'mongoid/errors/nested_attributes_metadata_not_found'
 require 'mongoid/errors/no_default_client'
 require 'mongoid/errors/no_environment'
+require 'mongoid/errors/no_encryption_schema'
 require 'mongoid/errors/no_map_reduce_output'
 require 'mongoid/errors/no_metadata'
 require 'mongoid/errors/no_parent'
@@ -60,6 +63,7 @@ require 'mongoid/errors/no_client_database'
 require 'mongoid/errors/no_client_hosts'
 require 'mongoid/errors/readonly_attribute'
 require 'mongoid/errors/readonly_document'
+require 'mongoid/errors/readonly_association'
 require 'mongoid/errors/rollback'
 require 'mongoid/errors/sessions_not_supported'
 require 'mongoid/errors/scope_overwrite'

data/lib/mongoid/extensions/vector.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Extensions
+    # Adds type-casting behavior to BSON::Vector class so that a field
+    # declared with +type: BSON::Vector+ is stored as a BSON binary of the
+    # vector subtype and read back as a BSON::Vector.
+    #
+    # Querying by an exact vector value (e.g. +where(embedding: vector)+) is
+    # not supported: BSON::Vector subclasses Array, so the criteria selector
+    # treats it as a list of elements rather than a scalar. Use Atlas Vector
+    # Search ($vectorSearch) for similarity queries on vector fields.
+    module Vector
+      # Turn the object from the ruby type we deal with to a Mongo friendly
+      # type.
+      #
+      # @example Mongoize the object.
+      #   object.mongoize
+      #
+      # @return [ BSON::Binary | nil ] The object as a vector binary.
+      def mongoize
+        BSON::Vector.mongoize(self)
+      end
+
+      module ClassMethods
+        # Mongoize an object of any type to how it's stored in the db.
+        #
+        # @example Mongoize the object.
+        #   BSON::Vector.mongoize(vector)
+        #
+        # @param [ Object ] object The object to Mongoize.
+        #
+        # @return [ BSON::Binary | nil ] A vector binary or nil.
+        def mongoize(object)
+          case object
+          when BSON::Vector then BSON::Binary.from_vector(object)
+          when BSON::Binary then object
+          end
+        end
+
+        # Convert the object from its mongo friendly ruby type back to a
+        # BSON::Vector.
+        #
+        # @example Demongoize the object.
+        #   BSON::Vector.demongoize(binary)
+        #
+        # @param [ Object ] object The object to demongoize.
+        #
+        # @return [ BSON::Vector | nil ] The vector or nil.
+        def demongoize(object)
+          case object
+          when BSON::Binary then (object.type == :vector) ? object.as_vector : nil
+          when BSON::Vector then object
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(BSON::Vector)
+  BSON::Vector.include Mongoid::Extensions::Vector
+  BSON::Vector.extend(Mongoid::Extensions::Vector::ClassMethods)
+end

data/lib/mongoid/extensions.rb

@@ -26,3 +26,4 @@ require 'mongoid/extensions/symbol'
 require 'mongoid/extensions/time'
 require 'mongoid/extensions/time_with_zone'
 require 'mongoid/extensions/true_class'
+require 'mongoid/extensions/vector'

data/lib/mongoid/field_readable.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mongoid
+  # Reads the value of a field name from a document without dispatching the
+  # name as an arbitrary method.
+  #
+  # Field names may come from application input, where a name like +destroy+
+  # or +attributes+ would delete the document or disclose its contents.
+  # Declared field and association names are validated when they are declared
+  # (see Mongoid.destructive_fields), so a name that resolves to one of them
+  # is safe to send to a document. Any other name is read from the attributes
+  # hash, which is what the database-backed query contexts do.
+  #
+  # @api private
+  module FieldReadable
+    private
+
+    # Read the value of the given field name from the given document.
+    #
+    # @param [ Document ] document The document to read from.
+    # @param [ String | Symbol ] name The name of the field.
+    #
+    # @return [ Object | nil ] The value of the field, or nil when the name
+    #   is neither a declared field nor present in the attributes.
+    def read_field_value(document, name)
+      name = name.to_s
+      # A blank name cannot name a field. Return nil, which is what reading
+      # one has always done.
+      return nil if name.blank?
+
+      if (meth = readable_method_for(document.class, name))
+        document.public_send(meth)
+      else
+        document.attributes[document.class.database_field_name(name)]
+      end
+    end
+
+    # Resolve the given name to a method that is declared by the given class,
+    # and therefore safe to send to one of its instances.
+    #
+    # @param [ Class ] klass The document class.
+    # @param [ String ] name The name of the field.
+    #
+    # @return [ String | nil ] The method to send, or nil when the name is
+    #   not declared by the class.
+    def readable_method_for(klass, name)
+      # Fields, associations, and field aliases each define a reader of their
+      # own name. Note that associations must be resolved before aliases: a
+      # belongs_to aliases its own name to its foreign key, and reading
+      # `band` must give the document, not the id.
+      return name if klass.relations.key?(name) ||
+                     klass.fields.key?(name) ||
+                     klass.aliased_fields.key?(name)
+
+      # An association may also be named by its `store_as`, which has no
+      # reader of its own, or by its ids accessor, which does.
+      if (assoc = klass.relations[klass.aliased_associations[name]])
+        return (assoc.store_as == name) ? assoc.name.to_s : name
+      end
+
+      # Localized fields also get a _translations reader, which does not
+      # appear in the fields hash.
+      base = name.delete_suffix(Fields::TRANSLATIONS_SFX)
+      return nil if base == name
+
+      name if klass.fields[klass.database_field_name(base)]&.localized?
+    end
+  end
+end

data/lib/mongoid/indexable.rb

@@ -24,18 +24,9 @@ module Mongoid
       def create_indexes
         return unless index_specifications
 
-        default_options = { background: Config.background_indexing }
-
-        index_specifications.each do |spec|
-          key, options = spec.key, default_options.merge(spec.options)
-          if database = options[:database]
-            with(database: database) do |klass|
-              klass.collection.indexes(session: _session).create_one(key, options.except(:database))
-            end
-          else
-            collection.indexes(session: _session).create_one(key, options)
-          end
-        end and true
+        Threaded.with_collection_management do
+          perform_create_indexes
+        end
       end
 
       # Send the actual index removal comments to the MongoDB driver,
@@ -46,20 +37,9 @@ module Mongoid
       #
       # @return [ true ] If the operation succeeded.
       def remove_indexes
-        indexed_database_names.each do |database|
-          with(database: database) do |klass|
-            klass.collection.indexes(session: _session).each do |spec|
-              next if spec['name'] == '_id_'
-
-              klass.collection.indexes(session: _session).drop_one(spec['key'])
-              logger.info(
-                "MONGOID: Removed index '#{spec['name']}' on collection " +
-                "'#{klass.collection.name}' in database '#{database}'."
-              )
-            end
-          rescue Mongo::Error::OperationFailure
-          end
-        end and true
+        Threaded.with_collection_management do
+          perform_remove_indexes
+        end
       end
 
       # Add the default indexes to the root document if they do not already
@@ -119,6 +99,38 @@ module Mongoid
 
       private
 
+      def perform_create_indexes
+        default_options = { background: Config.background_indexing }
+
+        index_specifications.each do |spec|
+          key, options = spec.key, default_options.merge(spec.options)
+          if database = options[:database]
+            with(database: database) do |klass|
+              klass.collection.indexes(session: _session).create_one(key, options.except(:database))
+            end
+          else
+            collection.indexes(session: _session).create_one(key, options)
+          end
+        end and true
+      end
+
+      def perform_remove_indexes
+        indexed_database_names.each do |database|
+          with(database: database) do |klass|
+            klass.collection.indexes(session: _session).each do |spec|
+              next if spec['name'] == '_id_'
+
+              klass.collection.indexes(session: _session).drop_one(spec['key'])
+              logger.info(
+                "MONGOID: Removed index '#{spec['name']}' on collection " +
+                "'#{klass.collection.name}' in database '#{database}'."
+              )
+            end
+          rescue Mongo::Error::OperationFailure
+          end
+        end and true
+      end
+
       # Get the names of all databases for this model that have index
       # definitions.
       #

data/lib/mongoid/matchable.rb

@@ -16,7 +16,12 @@ module Mongoid
     #
     # @return [ true | false ] True if matches, false if not.
     def _matches?(selector)
-      Matcher::Expression.matches?(self, selector)
+      # Opens a regexp budget for this document only. Callers that match many
+      # documents against one selector open a budget of their own first, and
+      # this one joins it rather than giving every document a fresh limit.
+      Matcher::RegexpBudget.open(selector) do
+        Matcher::Expression.matches?(self, selector)
+      end
     end
   end
 end

data/lib/mongoid/matcher/eq_impl_with_regexp.rb

@@ -18,10 +18,8 @@ module Mongoid
       # @api private
       module_function def matches?(_original_operator, value, condition)
         case condition
-        when Regexp
-          value.respond_to?(:=~) && value =~ condition
-        when ::BSON::Regexp::Raw
-          value.respond_to?(:=~) && value =~ condition.compile
+        when Regexp, ::BSON::Regexp::Raw
+          value.respond_to?(:=~) && RegexpBudget.match?(value, condition)
         else
           if value.is_a?(Time) && condition.is_a?(Time)
             EqImpl.time_eq?(value, condition)

data/lib/mongoid/matcher/regex.rb

@@ -16,24 +16,23 @@ module Mongoid
       #
       # @api private
       module_function def matches?(_exists, value, condition)
-        condition = case condition
-                    when Regexp
-                      condition
-                    when BSON::Regexp::Raw
-                      condition.compile
-                    else
-                      # Note that strings must have been converted to a regular expression
-                      # instance already (with $options taken into account, if provided).
-                      raise Errors::InvalidQuery, "$regex requires a regular expression argument: #{Errors::InvalidQuery.truncate_expr(condition)}"
-                    end
+        unless condition.is_a?(Regexp) || condition.is_a?(BSON::Regexp::Raw)
+          # Note that strings must have been converted to a regular expression
+          # instance already (with $options taken into account, if provided).
+          raise Errors::InvalidQuery, "$regex requires a regular expression argument: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
 
+        # The condition is compiled by RegexpBudget rather than here, so that
+        # the budget's timeout can be baked into the pattern.
         case value
         when Array
+          # Object#=~ is gone as of Ruby 3.2, so an element that cannot be
+          # matched against has to be rejected rather than passed to =~.
           value.any? do |v|
-            v =~ condition
+            v.respond_to?(:=~) && RegexpBudget.match?(v, condition)
           end
         when String
-          value =~ condition
+          RegexpBudget.match?(value, condition)
         else
           false
         end