mongoid 9.1.0 → 9.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0182a5e78d9fecbf490a537bd4dcf5aba640683c566b400ff7c70b189201372f'
-  data.tar.gz: d194627c4d001e4b420652d52a8612e6f4c4209948259f3d1f4b33de4257920b
+  metadata.gz: 5bfb9894822f364261e1579143e0a4860a27dfe42437243938ecb2bc186a0819
+  data.tar.gz: f66924e8684458b2318f82bc7614f01823938e8c7cb3f19bf5246dd1098dd5b5
 SHA512:
-  metadata.gz: b0e2447ca53e3ac80aee5a4a29dc9fe45110ded5f35a6e25569b9aca9e34a1f48060ef17a2dc9257f4d4d5ec3d07d725679a1f83e6850fa24edb32099b471ff2
-  data.tar.gz: b41c4d87a55e8ba10c90b1998f36280021793c6c4816d54259642a29a23f39201afb5c272cf473545f0b14a47ea609e6be8b8b35e68ee5e39076c1f2ceaa64f1
+  metadata.gz: 16d064d36b9a6a425d2727afdb879da7a28dd25a5889de7dd6242120d69441fb666db16dec584b0e00c77aed32fcd0a5d900c7fc3ed8ddfe0fe2006b0053dbc2
+  data.tar.gz: 2d8c367c96724961cdd78354a8bf6d10cef2fa209cec4103741e26d43389286a173a8df301116121b2e9ad89495c7c5e268b4458dd8b22e6a2ddb4fbdd835eb0

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."
@@ -618,6 +663,10 @@ en:
             can only have values set when the document is a new record."
           resolution: "Don't define '%{name}' as readonly, or do not attempt
             to update its value after the document is persisted."
+        readonly_association:
+          message: "Attempted to modify the read-only association '%{name}' on '%{klass}'."
+          summary: "The :%{name} association is defined with :through and is read-only."
+          resolution: "To modify the association, update :%{through} directly."
         readonly_document:
           message: "Attempted to persist a readonly document of class '%{klass}'."
           summary: "Documents that are marked readonly cannot be persisted."

data/lib/mongoid/association/accessors.rb

@@ -301,7 +301,10 @@ module Mongoid
         association.inverse_class.tap do |klass|
           klass.re_define_method(name) do |reload = false|
             value = get_relation(name, association, nil, reload)
-            value = send("build_#{name}") if value.nil? && association.autobuilding? && !without_autobuild?
+            next value unless value.nil? && !without_autobuild?
+            next association.fallback if association.fallback?
+            next send("build_#{name}") if association.autobuilding?
+
             value
           end
         end
@@ -341,6 +344,11 @@ module Mongoid
         association.inverse_class.tap do |klass|
           klass.re_define_method("#{name}=") do |object|
             without_autobuild do
+              if association.fallback?
+                klass = association.polymorphic? ? Mongoid::Document : association.relation_class
+                object = nil unless object.is_a?(klass)
+              end
+
               if value = get_relation(name, association, object)
                 value = __build__(name, value, association) unless value.respond_to?(:substitute)
 

data/lib/mongoid/association/depending.rb

@@ -10,11 +10,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
@@ -55,9 +59,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
 
           klass.dependents.push(association) if association.dependent && !klass.dependents.include?(association)
@@ -96,17 +100,17 @@ module Mongoid
       private
 
       def _dependent_delete_all!(association)
-        return unless relation = send(association.name)
+        return unless relation = without_autobuild { send(association.name) }
 
         if relation.respond_to?(:dependents) && relation.dependents.blank?
           relation.clear
         else
-          ::Array.wrap(send(association.name)).each { |rel| rel.delete }
+          ::Array.wrap(relation).each { |rel| rel.delete }
         end
       end
 
       def _dependent_destroy!(association)
-        return unless relation = send(association.name)
+        return unless relation = without_autobuild { send(association.name) }
 
         if relation.is_a?(Enumerable)
           relation.entries
@@ -117,19 +121,19 @@ module Mongoid
       end
 
       def _dependent_nullify!(association)
-        return unless relation = send(association.name)
+        return unless relation = without_autobuild { send(association.name) }
 
         relation.nullify
       end
 
       def _dependent_restrict_with_exception!(association)
-        if (relation = send(association.name)) && !relation.blank?
+        if (relation = without_autobuild { send(association.name) }) && !relation.blank?
           raise Errors::DeleteRestriction.new(relation, association.name)
         end
       end
 
       def _dependent_restrict_with_error!(association)
-        return unless (relation = send(association.name)) && !relation.blank?
+        return unless (relation = without_autobuild { send(association.name) }) && !relation.blank?
 
         errors.add(association.name, :destroy_restrict_with_error_dependencies_exist)
         throw(:abort, false)

data/lib/mongoid/association/eager.rb

@@ -4,6 +4,15 @@ module Mongoid
   module Association
     # Base class for eager load preload functions.
     class Eager
+      # Build a preloader for the given arguments and run it.
+      #
+      # @param (see #initialize)
+      #
+      # @return [ Array ] The list of documents given.
+      def self.run(associations, docs, use_lookup = false, pipeline = [])
+        new(associations, docs, use_lookup, pipeline).run
+      end
+
       # Instantiate the eager load class.
       #
       # @example Create the new belongs to eager load preloader.

data/lib/mongoid/association/eager_load/discriminated_inclusion.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/eager_load/inclusion'
+
+module Mongoid
+  module Association
+    module EagerLoad
+      # Loads an inclusion that more than one subclass defines under the same name
+      # but pointing at different targets. A single $lookup can't serve them: they
+      # would all write to the same field and overwrite one another. So each
+      # subclass's inclusion is contributed into its own temporary field, carrying
+      # its own nested children, and a $set then routes every document to the field
+      # for its own type, by the discriminator.
+      #
+      # For Machine.eager_load(:widgets), where Lathe#widgets => Cog and
+      # Press#widgets => Belt, it emits:
+      #
+      #   { '$lookup' => { 'from' => 'cogs',  ..., 'as' => '__eager_load_widgets_Lathe' } },
+      #   { '$lookup' => { 'from' => 'belts', ..., 'as' => '__eager_load_widgets_Press' } },
+      #   { '$set' => {
+      #     'widgets' => { '$switch' => { 'branches' => [   # route each document to its
+      #       { 'case' => { '$eq' => [ '$_type', 'Lathe' ] }, 'then' => '$__eager_load_widgets_Lathe' },  # own type's matches
+      #       { 'case' => { '$eq' => [ '$_type', 'Press' ] }, 'then' => '$__eager_load_widgets_Press' }
+      #     ], 'default' => [] } }
+      #   } },
+      #   { '$unset' => [ '__eager_load_widgets_Lathe', '__eager_load_widgets_Press' ] }
+      #
+      # @api private
+      class DiscriminatedInclusion < Inclusion
+        def initialize(nodes)
+          super()
+          @nodes = nodes
+        end
+
+        # Append each subclass's lookup (into its own temporary field), the routing
+        # $set, and the cleanup $unset.
+        #
+        # @param [ Array<Hash> ] destination The pipeline the stages are appended to.
+        def contribute(destination, _chain)
+          fields = @nodes.map { |node| [ node, contribute_into_temporary(destination, node) ] }
+          destination << route_by_type(fields)
+          destination << { '$unset' => fields.map { |_node, field| field } }
+        end
+
+        private
+
+        # Let the node build its own $lookup (with its nested children) and redirect
+        # it to write into a temporary field instead of the shared association name.
+        def contribute_into_temporary(destination, node)
+          field = temporary_field(node)
+          captured = []
+          node.contribute(captured, [])
+          captured.first['$lookup']['as'] = field
+          destination.concat(captured)
+          field
+        end
+
+        def temporary_field(node)
+          "__eager_load_#{node.association.name}_#{owner(node).discriminator_value}"
+        end
+
+        # The $set that fills the association on each document from the temporary
+        # field matching its own type.
+        def route_by_type(fields)
+          branches = fields.map do |node, field|
+            {
+              'case' => { '$eq' => [ "$#{discriminator_key}", owner(node).discriminator_value ] },
+              'then' => "$#{field}"
+            }
+          end
+          { '$set' => { name => { '$switch' => { 'branches' => branches, 'default' => [] } } } }
+        end
+
+        def owner(node)
+          node.association.inverse_class
+        end
+
+        def name
+          @nodes.first.association.name.to_s
+        end
+
+        def discriminator_key
+          owner(@nodes.first).discriminator_key
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/eager_load/embedded_distributor.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    # Objects that carry out the aggregation-based eager load triggered by
+    # Criteria#eager_load.
+    module EagerLoad
+      # Distributes the results of a $lookup onto the embedded documents they
+      # belong to.
+      #
+      # A $lookup overwrites the single field it writes to, and it can't distribute
+      # its matches across the elements of an embedded array. So when the reference
+      # being eager-loaded lives on an embedded document, the matches are first
+      # collected in a temporary top-level field and then distributed down the
+      # embedded path onto each embedded document, merging into it (so the rest of
+      # the document is kept) and correlating by key. The temporary field is then
+      # dropped.
+      #
+      # For Computer.eager_load(port: :device) (Port belongs_to :device) it emits:
+      #
+      #   { '$lookup' => {                     # devices can't be written into
+      #     'from' => 'devices',               # the embedded port, so they are
+      #     'localField' => 'port.device_id',  # collected in a temp top-level
+      #     'foreignField' => '_id',           # field instead
+      #     'as' => '__eager_load_port_device'
+      #   } },
+      #   { '$set' => {
+      #     'port' => { '$mergeObjects' => [   # merge a 'device' key onto the port
+      #       '$port',
+      #       { 'device' => { '$filter' => { ... } } }   # this port's matches
+      #     ] }
+      #   } },
+      #   { '$unset' => '__eager_load_port_device' }  # drop the temp field
+      #
+      # @api private
+      class EmbeddedDistributor
+        # @param [ Mongoid::Association::Relatable ] association The referenced
+        #   inclusion being eager-loaded from within an embedded document.
+        # @param [ Array<Mongoid::Association::Relatable> ] chain The embedded
+        #   ancestors, from the root document inward, down to the association's owner.
+        # @param [ Hash ] lookup_stage The $lookup stage built for the association.
+        #
+        # @return [ EmbeddedDistributor ] The distributor.
+        class << self
+          def for(association:, chain:, lookup_stage:)
+            lookup = lookup_stage['$lookup']
+            new(association, chain, lookup_stage, lookup['localField'], lookup['foreignField'])
+          end
+
+          private :new
+        end
+
+        def initialize(association, chain, lookup_stage, local_field, foreign_field)
+          @association = association
+          @chain = chain
+          @lookup_stage = lookup_stage
+          @local_field = local_field
+          @foreign_field = foreign_field
+        end
+
+        # The stages that run the $lookup into a temporary field and then
+        # distribute its matches onto the embedded documents along the path.
+        #
+        # @return [ Array<Hash> ] The stages to append to the pipeline.
+        def stages
+          redirect_lookup_to_temporary_field
+          [
+            @lookup_stage,
+            { '$set' => {
+              root => distributed_value(@chain, "$#{root}")
+            } },
+            { '$unset' => temporary_field }
+          ]
+        end
+
+        private
+
+        # The $lookup runs at the top level, so it reads the local field by its
+        # full embedded path and writes the matches into the temporary field.
+        def redirect_lookup_to_temporary_field
+          lookup = @lookup_stage['$lookup']
+          lookup['localField'] = "#{path}.#{@local_field}"
+          lookup['as'] = temporary_field
+        end
+
+        def path
+          @chain.map(&:store_as).join('.')
+        end
+
+        def root
+          @chain.first.store_as
+        end
+
+        def temporary_field
+          "__eager_load_#{path.tr('.', '_')}_#{@association.name}"
+        end
+
+        # An embedded collection (embeds_many) is rebuilt with $map so each element
+        # keeps its own matches instead of collapsing onto the first; a single
+        # embedded document (embeds_one) receives its matches in place.
+        def distributed_value(chain, node)
+          head, *rest = chain
+          many = head.many?
+          element = many ? "$$#{head.store_as}" : node
+          child =
+            if rest.empty?
+              { @association.name.to_s => correlated_matches(element) }
+            else
+              segment = rest.first.store_as
+              { segment => distributed_value(rest, "#{element}.#{segment}") }
+            end
+          merged = { '$mergeObjects' => [ element, child ] }
+          return merge_into_present(node, merged) unless many
+
+          { '$map' => {
+            'input' => node,
+            'as' => head.store_as,
+            'in' => merged
+          } }
+        end
+
+        # Merge the matches into a single embedded document only when it exists, so
+        # an absent embeds_one stays absent instead of being synthesized from its
+        # matches alone.
+        def merge_into_present(node, merged)
+          { '$cond' => {
+            'if' => { '$ifNull' => [ node, false ] },
+            'then' => merged,
+            'else' => node
+          } }
+        end
+
+        # The matches that belong to a single embedded element.
+        def correlated_matches(element)
+          { '$filter' => {
+            'input' => "$#{temporary_field}",
+            'as' => 'match',
+            'cond' => { match_operator => [ "$$match.#{@foreign_field}", "#{element}.#{@local_field}" ] }
+          } }
+        end
+
+        # A has_and_belongs_to_many holds an array of foreign keys, so a match
+        # belongs when its key is among them ($in); every other association points
+        # at a single key ($eq).
+        def match_operator
+          @association.many_to_many? ? '$in' : '$eq'
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/eager_load/inclusion.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module EagerLoad
+      # Something an eager load contributes to the pipeline, in the role it plays
+      # while the pipeline is built. A root is asked to contribute and the whole
+      # tree follows by recursion. AssociationInclusion stands for a single
+      # association; DiscriminatedInclusion stands for a name several subclasses
+      # share.
+      #
+      # @api private
+      class Inclusion
+        # Add this inclusion's stages to the destination.
+        #
+        # @param [ Array<Hash> ] destination The pipeline (or sub-pipeline) the
+        #   stages are appended to.
+        # @param [ Array<Mongoid::Association::Relatable> ] chain The embedded path
+        #   accumulated from the ancestors above this inclusion (empty at the top).
+        def contribute(destination, chain)
+          raise NotImplementedError
+        end
+      end
+
+      # An inclusion that stands for a single association. The LookupPipeline holds
+      # the stage-building helpers the kinds lean on, and a node carries its own
+      # children, so the pipeline is built by recursion from the roots downward.
+      #
+      # @api private
+      class AssociationInclusion < Inclusion
+        class << self
+          # Builds the right kind of inclusion for the association. Each subclass
+          # decides whether it handles it (.for?); exactly one does.
+          #
+          # @param [ Mongoid::Association::Relatable ] association The inclusion.
+          # @param [ LookupPipeline ] pipeline The pipeline being built.
+          # @param [ Array<Inclusion> ] children The inclusions nested under it.
+          #
+          # @return [ AssociationInclusion ] The matching kind of inclusion.
+          def for(association, pipeline, children)
+            subclasses.find { |kind| kind.for?(association) }.new(association, pipeline, children)
+          end
+
+          # Whether this kind handles the given association.
+          #
+          # @param [ Mongoid::Association::Relatable ] association The inclusion.
+          #
+          # @return [ true | false ] Whether it handles it.
+          def for?(association)
+            raise NotImplementedError
+          end
+        end
+
+        # @return [ Mongoid::Association::Relatable ] The association this stands for.
+        attr_reader :association
+
+        def initialize(association, pipeline, children)
+          super()
+          @association = association
+          @pipeline = pipeline
+          @children = children
+        end
+      end
+
+      # A referenced inclusion: contributes a $lookup whose sub-pipeline holds its
+      # own children. When it lives inside an embedded document (a non-empty
+      # chain), the $lookup is distributed onto that embedded path instead of
+      # standing at the top level.
+      #
+      # For a has_many :albums it contributes:
+      #
+      #   { '$lookup' => {
+      #     'from' => 'albums',
+      #     'localField' => '_id',        # the band's _id...
+      #     'foreignField' => 'band_id',  # ...matched against each album's band_id
+      #     'as' => 'albums',             # matches are written to this field
+      #     'pipeline' => [
+      #       { '$sort' => {
+      #         '_id' => 1
+      #       } },
+      #       <children>
+      #     ]
+      #   } }
+      #
+      # @api private
+      class JoinedInclusion < AssociationInclusion
+        class << self
+          # The default kind: a referenced, non-polymorphic association, i.e. the
+          # one no sibling kind claims.
+          #
+          # @param [ Mongoid::Association::Relatable ] association The inclusion.
+          #
+          # @return [ true | false ] Whether it handles it.
+          def for?(association)
+            (superclass.subclasses - [ self ]).none? { |kind| kind.for?(association) }
+          end
+        end
+
+        # Append the $lookup, with the children in its sub-pipeline, to the
+        # destination; or distribute it onto the embedded path when nested in one.
+        #
+        # @param [ Array<Hash> ] destination The pipeline (or sub-pipeline) the
+        #   stages are appended to.
+        # @param [ Array<Mongoid::Association::Relatable> ] chain The embedded path
+        #   accumulated from the ancestors above this inclusion (empty at the top).
+        def contribute(destination, chain)
+          stage = @pipeline.lookup_stage_for(@association)
+          @children.each { |child| child.contribute(stage['$lookup']['pipeline'], []) }
+
+          if chain.empty?
+            destination << stage
+          else
+            destination.concat(@pipeline.distribute(@association, chain, stage))
+          end
+        end
+      end
+
+      # An embedded inclusion: it rides inside its own document, so it adds no
+      # stage of its own. Its children contribute to the same destination, with
+      # this document appended to their embedded path.
+      #
+      # For Computer.eager_load(port: :device) the :port inclusion emits nothing;
+      # it hands the path [ :port ] to :device, which EmbeddedDistributor then
+      # turns into stages.
+      #
+      # @api private
+      class EmbeddedInclusion < AssociationInclusion
+        class << self
+          # @param [ Mongoid::Association::Relatable ] association The inclusion.
+          #
+          # @return [ true | false ] Whether the association is embedded.
+          def for?(association)
+            association.embedded?
+          end
+        end
+
+        # Add no stage of its own; hand this document down the embedded path so the
+        # children distribute onto it.
+        #
+        # @param [ Array<Hash> ] destination The pipeline (or sub-pipeline) the
+        #   stages are appended to.
+        # @param [ Array<Mongoid::Association::Relatable> ] chain The embedded path
+        #   accumulated from the ancestors above this inclusion (empty at the top).
+        def contribute(destination, chain)
+          @children.each { |child| child.contribute(destination, chain + [ @association ]) }
+        end
+      end
+
+      # A polymorphic inclusion: its target collection varies per document, so it
+      # can't be a $lookup. It adds nothing here; PolymorphicPreloader resolves it
+      # after the roots are materialized.
+      #
+      # @api private
+      class DeferredInclusion < AssociationInclusion
+        class << self
+          # @param [ Mongoid::Association::Relatable ] association The inclusion.
+          #
+          # @return [ true | false ] Whether the association is polymorphic.
+          def for?(association)
+            association.polymorphic?
+          end
+        end
+
+        # Add nothing; PolymorphicPreloader resolves the association after the
+        # roots are materialized.
+        #
+        # @param [ Array<Hash> ] destination The pipeline (unused).
+        # @param [ Array<Mongoid::Association::Relatable> ] chain The embedded path (unused).
+        def contribute(destination, chain); end
+      end
+    end
+  end
+end