mongoid 9.0.10 → 9.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fefd49681b6f78b222f201fbaea83af9f1599464034e52a73117c0ae94e201f2
-  data.tar.gz: d86f966109921d2a0f1a4ce0b78d81e0d722123c1d420f0f695385ca43687626
+  metadata.gz: 066d78f8b736bad08756e737ff7c0e1d0af9b97149366fc0b5b0a5997c3f1a63
+  data.tar.gz: b55ea0b166bd8d9a0f465e88507ee8db2c4cccc7166477aec4b07a94d98c0a43
 SHA512:
-  metadata.gz: '09799846ca2a44c7dc4d7aff76fba0f9fdcbe38c5bfb001dccd08eb467800f8fac675cecfa06be94eb76ca35f6f1b57b64557ed171e9c0040bcbe0a701d7827f'
-  data.tar.gz: bc0a741e2e26a84e84238f1461a26a29ae13584d9bd050dffc1ccd04f70e4e6a7fa63b20e7dcda8137ce3c37d383a5ae916b0d72ff950d4f330e66e0635ea89c
+  metadata.gz: 9e6529d35d0fba7786a830bec9ffc87937580c414d6925c5c14f3c799ea03599592ad943783690a29e24ae09f706b6462e42ec1058bd316a023c51d7467c457e
+  data.tar.gz: 6625aaf9412d9ef3e5141b06a019bc83c33446612c3c1b16361473fb5a3ac1a006e2f4d3c6cdf0daa36c0b2b4ee2a9702b135b380011226f219517a578e203ac

data/README.md

@@ -21,9 +21,9 @@ Compatibility
 
 Mongoid supports and is tested against:
 
-- MRI 2.7 - 3.2
-- JRuby 9.4
-- MongoDB server 3.6 - 7.0
+- MRI 2.7 - 4.0
+- JRuby 9.4 and 10.0
+- MongoDB server 3.6 - 8.2
 
 Issues
 ------

data/Rakefile

@@ -68,6 +68,37 @@ RSpec::Core::RakeTask.new('spec:progress') do |spec|
   spec.pattern = "spec/**/*_spec.rb"
 end
 
+RUBOCOPABLE = %w[ examples gemfiles perf lib spec mongoid.gemspec Gemfile Rakefile upload-api-docs ].freeze
+
+desc 'Run rubocop'
+task rubocop: %w[ rubocop:run ]
+
+namespace :rubocop do
+  desc 'Run rubocop on the codebase'
+  task :run do
+    Bundler.with_unbundled_env do
+      sh 'bundle', 'exec', 'rubocop', *RUBOCOPABLE, verbose: false
+    end
+  end
+
+  desc 'Add a git pre-commit hook that runs rubocop'
+  task :install_hook do
+    hook_path = File.join('.git', 'hooks', 'pre-commit')
+    hook_script = <<~HOOK
+      #!/usr/bin/env bash
+      set -e
+
+      echo "Running rubocop..."
+      rake rubocop
+    HOOK
+
+    File.write(hook_path, hook_script)
+    FileUtils.chmod('+x', hook_path)
+
+    puts "Git pre-commit hook installed at #{hook_path}."
+  end
+end
+
 desc 'Build and validate the evergreen config'
 task eg: %w[ eg:build eg:validate ]
 

data/lib/config/locales/en.yml

@@ -140,6 +140,32 @@ en:
             A collation option is only supported if the query is executed on a MongoDB server
             with version >= 3.4."
           resolution: "Remove the collation option from the query."
+        in_memory_regexp_timeout:
+          message: "Evaluating this query in memory exceeded the %{limit} second
+            limit that applies to conditions containing a regular expression."
+          summary: "Mongoid evaluates some conditions in the calling thread
+            rather than sending them to the server: queries against an embedded
+            association, removing documents from an association by condition,
+            and Document#_matches?. A regular expression in such a condition
+            runs locally. Mongoid limits the total time one in-memory
+            evaluation may spend matching, because both the cost of a single
+            match and the number of matches performed grow with the condition,
+            and a pattern built from end-user input can be made to consume an
+            unbounded amount of CPU. The limit is cumulative over the whole
+            evaluation rather than per match. Where the Ruby in use offers no
+            per-Regexp timeout the limit is enforced as wall clock over the
+            whole in-memory evaluation, so there it can be exceeded by a large
+            scan even when the pattern itself is cheap."
+          resolution: "Check whether the pattern in this query comes from user
+            input; if it does, validate it before querying. If the query is
+            legitimate and simply large, raise
+            Mongoid::Config.in_memory_regexp_time_limit, or set it to nil to
+            remove the limit entirely. The limit in force is the smaller of
+            that setting and any global Regexp.timeout the application has set,
+            so check both. On JRuby, and on MRI before 3.2, there is no
+            per-Regexp timeout, so what the limit bounds there is the elapsed
+            time of the whole in-memory evaluation rather than the time spent
+            matching."
         invalid_around_callback:
           message: "An around callback must contain a yield in its definition."
           summary: "The block needs to be yielded to for around callbacks to function as intended."
@@ -515,6 +541,25 @@ en:
             environment, Mongoid cannot load its configuration."
           resolution: "Please ensure an environment is set in one of the
             listed locations. The environment must be explicitly set."
+        no_encryption_schema:
+          message: "The encryption schema of client %{client} does not cover
+            %{namespace}."
+          summary: "%{klass} declares encrypted fields, but the namespace it
+            resolved to, %{namespace}, is not part of the automatic encryption
+            schema of client %{client}. The encryption schema is built once,
+            when the client is created, and is keyed by namespace, so a
+            database name that is only known later - a callable :database
+            option, Model.with(database:), Mongoid.override_database - is not
+            in it. Routing the model to a client that has no
+            auto_encryption_options has the same effect. Mongoid refuses the
+            operation because the driver would store the declared fields in
+            plaintext without reporting an error."
+          resolution: "Give the model a namespace that is known when the
+            client is created, and a client configured with
+            auto_encryption_options. If the model has to live in a database
+            chosen at runtime, configure one client per database, each with
+            its own auto_encryption_options, and select between them with
+            Model.with(client:) instead of switching the database."
         no_map_reduce_output:
           message: "No output location was specified for the map/reduce
             operation."

data/lib/mongoid/association/depending.rb

@@ -12,11 +12,15 @@ module Mongoid
       included do
         class_attribute :dependents
 
+        # Note the leading underscore: without it, ActiveSupport's
+        # class_attribute would generate a helper method for this attribute
+        # that collides with one it generates for :dependents.
+        #
         # @api private
-        class_attribute :dependents_owner
+        class_attribute :_dependents_owner
 
         self.dependents = []
-        self.dependents_owner = self
+        self._dependents_owner = self
       end
 
       class_methods do
@@ -57,9 +61,9 @@ module Mongoid
       def self.define_dependency!(association)
         validate!(association)
         association.inverse_class.tap do |klass|
-          if klass.dependents_owner != klass
+          if klass._dependents_owner != klass
             klass.dependents = []
-            klass.dependents_owner = klass
+            klass._dependents_owner = klass
           end
 
           if association.dependent && !klass.dependents.include?(association)

data/lib/mongoid/association/nested/many.rb

@@ -174,7 +174,7 @@ module Mongoid
         # @param [ Hash ] attrs The single document attributes to process.
         def update_nested_relation(parent, id, attrs)
           first = existing.first
-          converted = first ? convert_id(first.class, id) : id
+          converted = convert_id(first ? first.class : association.klass, id)
 
           if existing.where(_id: converted).exists?
             # document exists in association
@@ -184,15 +184,50 @@ module Mongoid
             else
               update_document(doc, attrs)
             end
-          else
+          elsif association.embedded?
+            raise Errors::DocumentNotFound.new(association.klass, id)
+          elsif destroyable?(attrs)
+            # A destroy of a document that is not in the association is
+            # ignored, rather than reaching for it outside the association.
+            nil
+          elsif Mongoid.allow_reparenting_via_nested_attributes?
+            Mongoid::Warnings.warn_reparenting_via_nested_attributes
+
             # push existing document to association
             doc = association.klass.unscoped.find(converted)
+            # find returns nil instead of raising when
+            # Mongoid.raise_not_found_error is false; a missing document
+            # must still be an error here, consistent with the other
+            # not-found branches.
+            raise Errors::DocumentNotFound.new(association.klass, id) if doc.nil?
+
             update_document(doc, attrs)
-            existing.push(doc) unless destroyable?(attrs)
+            existing.push(doc)
+          else
+            raise Errors::DocumentNotFound.new(association.klass, not_found_params(parent, id))
           end
 
           parent.children_may_have_changed!
         end
+
+        # The params to report when an id in the nested attributes could not
+        # be resolved within the association.
+        #
+        # @api private
+        #
+        # @param [ Document ] parent The parent document.
+        # @param [ String | BSON::ObjectId ] id of the related document.
+        #
+        # @return [ Hash | Object ] The params for the not found error.
+        def not_found_params(parent, id)
+          if association.is_a?(Association::Referenced::HasAndBelongsToMany)
+            # A many-to-many association has no foreign key on the child, so
+            # the id is only ever resolved within the association itself.
+            id
+          else
+            { _id: id, association.foreign_key => parent.id }
+          end
+        end
       end
     end
   end

data/lib/mongoid/association/nested/nested_buildable.rb

@@ -58,12 +58,26 @@ module Mongoid
         # @example Convert the id.
         #   builder.convert_id(Person, "4d371b444835d98b8b000010")
         #
+        # Ids arriving from a form are always scalars. A Hash or an Array
+        # here means the parameters were crafted, and letting one through
+        # would turn the id into a query operator, so they are rejected.
+        #
         # @param [ Class ] klass The class we're trying to convert for.
         # @param [ String ] id The id, usually coming from the form.
         #
         # @return [ BSON::ObjectId | String | Object ] The converted id.
+        #
+        # @raise [ Errors::DocumentNotFound ] if the id is not a scalar, or
+        #   cannot be converted to the type the class uses for its ids.
+        #   The BSON::Error rescue is defensive: a value that reaches
+        #   BSON::ObjectId.mongoize and raises there must not surface as an
+        #   unhandled BSON error in the caller.
         def convert_id(klass, id)
+          raise Errors::DocumentNotFound.new(klass, id) if id.is_a?(::Hash) || id.is_a?(::Array)
+
           klass.using_object_ids? ? BSON::ObjectId.mongoize(id) : id
+        rescue BSON::Error
+          raise Errors::DocumentNotFound.new(klass, id)
         end
 
         private

data/lib/mongoid/association/referenced/auto_save.rb

@@ -32,13 +32,24 @@ module Mongoid
           Threaded.exit_autosave(self)
         end
 
-        # Check if there is changes for auto-saving
+        # Check if there are changes for auto-saving. Returns true if the
+        # document is new, changed, or marked for destruction, or if any
+        # in-memory referenced child with autosave: true recursively
+        # satisfies the same condition.
         #
-        # @example Return true if there is changes on self or in
-        #           autosaved associations.
-        #   document.changed_for_autosave?
-        def changed_for_autosave?(doc)
-          doc.new_record? || doc.changed? || doc.marked_for_destruction?
+        # The seen set prevents infinite recursion when autosave associations
+        # form a cycle (e.g. a belongs_to with autosave: true whose target
+        # has a has_many with autosave: true pointing back).
+        #
+        # @param [ Document ] doc The document to check.
+        # @param [ Set ] seen Documents already visited (cycle guard).
+        #
+        # @return [ true | false ] Whether the document needs autosaving.
+        def changed_for_autosave?(doc, seen = Set.new)
+          return false unless seen.add?(doc)
+
+          doc.new_record? || doc.changed? || doc.marked_for_destruction? ||
+            autosave_children_changed?(doc, seen)
         end
 
         # Define the autosave method on an association's owning class for
@@ -60,6 +71,8 @@ module Mongoid
                 __autosaving__ do
                   if assoc_value = ivar(association.name)
                     Array(assoc_value).each do |doc|
+                      next unless changed_for_autosave?(doc)
+
                       pc = doc.persistence_context? ? doc.persistence_context : persistence_context.for_child(doc)
                       doc.with(pc) do |d|
                         d.save
@@ -72,6 +85,35 @@ module Mongoid
             klass.after_persist_parent save_method, unless: :autosaved?
           end
         end
+
+        private
+
+        # Returns true if any in-memory referenced child with autosave: true
+        # needs saving.
+        #
+        # @param [ Document ] doc The document whose children to check.
+        # @param [ Set ] seen Cycle guard passed through from changed_for_autosave?.
+        #
+        # @return [ true | false ]
+        def autosave_children_changed?(doc, seen)
+          if Mongoid.autosave_saves_unchanged_documents?
+            Mongoid::Warnings.warn_autosave_saves_unchanged_documents
+            return true
+          end
+
+          doc.class.relations.values.select { |a| a.autosave? && !a.embedded? }.any? do |assoc|
+            (assoc_value = doc.ivar(assoc.name)) &&
+              in_memory_docs(assoc_value).any? { |child| changed_for_autosave?(child, seen) }
+          end
+        end
+
+        # Returns the in-memory documents for an association value without
+        # triggering a database load of any unloaded documents. Association
+        # proxies expose in_memory for this purpose; a plain document (which
+        # belongs_to can store directly in the ivar) is itself in-memory.
+        def in_memory_docs(assoc_value)
+          assoc_value.respond_to?(:in_memory) ? assoc_value.in_memory : [ assoc_value ]
+        end
       end
     end
   end

data/lib/mongoid/association/referenced/has_many/proxy.rb

@@ -534,12 +534,111 @@ module Mongoid
           # @return [ Integer ] The number of documents deleted.
           def remove_all(conditions = nil, method = :delete_all)
             selector = conditions || {}
-            removed = klass.send(method, selector.merge!(criteria.selector))
+            selector.merge!(criteria.selector)
+
+            # Scanning before the delete means scanning only what is already in
+            # memory, so it is only done where there is a pattern whose cost has
+            # to be bounded. Everywhere else the delete comes first and the scan
+            # sees the survivors, which is what this association has always
+            # done.
+            #
+            # The limit is read once and carried into whichever branch is taken.
+            # Letting the branch below ask again would read it a second time,
+            # across a server round trip, and a limit that had become positive
+            # in the meantime would put a deadline on the delete_if -- a query,
+            # and an unbind of every match -- which is the arrangement this
+            # branch exists to avoid.
+            limit = Matcher::RegexpBudget.limit_for(selector)
+            return remove_all_bounded(selector, method, limit) if limit
+
+            removed = klass.send(method, selector)
+
+            # No scope around this. The scan runs after the delete, so the
+            # association this loads comes back holding only what the delete did
+            # not match, and there is no pattern here to bound in any case.
+            # Opening a scope would save _matches? from deciding once per
+            # document -- 0.48us against 1.74us for the match itself -- but a
+            # scope with nothing to bound suppresses that decision for
+            # everything nested inside it, and loading the association runs
+            # find callbacks. A pattern in a selector one of those evaluates
+            # would go unguarded, which costs more than the saving is worth on a
+            # path that has just made two round trips.
             _target.delete_if do |doc|
               doc._matches?(selector).tap do |b|
                 unbind_one(doc) if b
               end
             end
+
+            removed
+          end
+
+          # Deletes all related documents matching a selector that carries a
+          # regular expression, with the whole scan under one regexp budget.
+          #
+          # The scan runs before anything is deleted, so a budget that runs out
+          # leaves both the database and the association untouched rather than
+          # reporting a failure for a delete that has already happened. It also
+          # means the budget is closed by the time the association is mutated,
+          # so where the budget is enforced with Timeout there is no window for
+          # the exception to land in the middle of an unbind.
+          #
+          # @param [ Hash ] selector The selector to delete with.
+          # @param [ Symbol ] method The deletion method to call.
+          # @param [ Float ] limit The seconds the scan may spend, as read by
+          #   the caller when it chose this path.
+          #
+          # @return [ Integer ] The number of documents deleted.
+          def remove_all_bounded(selector, method, limit)
+            # Only what the association already holds. Iterating it instead
+            # would load the whole association before the delete, and for a
+            # broad pattern that is every document the association has: /.*/ is
+            # both the cheapest pattern an attacker can supply and the one that
+            # matches everything, so bounding the cost of the matching would
+            # have been paid for with an unbounded amount of memory. Nothing is
+            # missed by not loading, because the server evaluates the same
+            # selector for the delete itself.
+            #
+            # It also means the scan runs no query, so no deadline of ours can
+            # land on one. Where the budget is enforced with Timeout, covering
+            # a query would report a slow network as a regexp timeout and could
+            # deliver the asynchronous exception inside the driver's socket
+            # read.
+            documents = _target.in_memory
+
+            matching = Matcher::RegexpBudget.open_with(limit) do
+              documents.select { |doc| doc._matches?(selector) }
+            end
+
+            removed = klass.send(method, selector)
+
+            # The ids are already known to be in memory, so the loaded and added
+            # documents can be dropped directly. Enumerable#delete would look
+            # each one up by id and stop at the first hash that has it, which
+            # removes the wrong instance when both hashes hold one for the same
+            # id. Enumerable#delete_if drops it from both, as this does, but
+            # only after load_all!, which is the load this scan exists to avoid.
+            #
+            # Which documents get unbound has always depended on which ones
+            # happened to be in memory, and scanning only what is in memory
+            # keeps that. It matters for has_and_belongs_to_many, whose
+            # unbind_one pulls the id out of the foreign key array on _base and
+            # marks it dirty; the scan used to run after the delete, against an
+            # association that a cold proxy had just reloaded as holding only
+            # the survivors, so nothing matched and nothing was unbound.
+            #
+            # TODO: unbinding should not depend on what was in memory. Every
+            # matched document leaves the association, so every one of them
+            # should be unbound, which would also stop _base's foreign key
+            # array from keeping ids that no longer resolve. That is a
+            # behaviour change for has_and_belongs_to_many and belongs in a
+            # ticket of its own, with a release note; it should not ride along
+            # on this one.
+            matching.each do |doc|
+              unbind_one(doc)
+              _target._loaded.delete(doc._id)
+              _target._added.delete(doc._id)
+            end
+
             removed
           end
 

data/lib/mongoid/association/relatable.rb

@@ -172,6 +172,23 @@ module Mongoid
       end
       alias :klass :relation_class
 
+      # The class of the association target, or nil when the named class is
+      # not defined.
+      #
+      # An association may name a class that never gets defined. The
+      # association is then unusable, but its owner still has to be. Callers
+      # that walk every association of every model, rather than following the
+      # one the application asked for, use this instead of relation_class.
+      #
+      # @return [ Class | nil ] The association objects' class.
+      #
+      # @api private
+      def try_relation_class
+        relation_class
+      rescue NameError
+        nil
+      end
+
       # The class name of the object owning this association.
       #
       # @return [ String ] The owning objects' class name.

data/lib/mongoid/collection_configurable.rb

@@ -22,6 +22,14 @@ 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

data/lib/mongoid/config/defaults.rb

@@ -18,19 +18,23 @@ module Mongoid
         case version.to_s
         when /^[0-7]\./
           raise ArgumentError, "Version no longer supported: #{version}"
-        when "8.0"
+
+        when '8.0'
           self.legacy_readonly = true
 
-          load_defaults "8.1"
-        when "8.1"
+          load_defaults '8.1'
+
+        when '8.1'
           self.immutable_ids = false
           self.legacy_persistence_context_behavior = true
           self.around_callbacks_for_embeds = true
           self.prevent_multiple_calls_of_embedded_callbacks = false
 
-          load_defaults "9.0"
-        when "9.0"
+          load_defaults '9.0'
+
+        when '9.0'
           # All flag defaults currently reflect 9.0 behavior.
+
         else
           raise ArgumentError, "Unknown version: #{version}"
         end

data/lib/mongoid/config/encryption.rb

@@ -21,17 +21,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 +108,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 +150,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