mongoid 9.0.11 → 9.1.1

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

@@ -157,7 +157,7 @@ module Mongoid
           # @example Delete all documents in the association.
           #   person.posts.delete_all
           #
-          # @example Conditonally delete all documents in the association.
+          # @example Conditionally delete all documents in the association.
           #   person.posts.delete_all({ :title => "Testing" })
           #
           # @param [ Hash ] conditions Optional conditions to delete with.
@@ -260,9 +260,13 @@ module Mongoid
           #
           # @return [ Document | Array<Document> | nil ] A document or matching documents.
           def find(*args, &block)
-            matching = criteria.find(*args, &block)
-            Array(matching).each { |doc| _target.push(doc) }
-            matching
+            if block_given? && args.empty?
+              detect(&block)
+            else
+              matching = criteria.find(*args, &block)
+              Array(matching).each { |doc| _target.push(doc) }
+              matching
+            end
           end
 
           # Removes all associations between the base document and the target
@@ -475,7 +479,7 @@ module Mongoid
           #
           # @return [ Criteria | Object ] A Criteria or return value from the target.
           #
-          # TODO: make sure we are consistingly using respond_to_missing
+          # TODO: make sure we are consistently using respond_to_missing
           #   anywhere we define method_missing.
           # rubocop:disable Style/MissingRespondToMissing
           ruby2_keywords def method_missing(name, *args, &block)
@@ -525,7 +529,7 @@ module Mongoid
           # @example Delete all documents in the association.
           #   person.posts.delete_all
           #
-          # @example Conditonally delete all documents in the association.
+          # @example Conditionally delete all documents in the association.
           #   person.posts.delete_all({ :title => "Testing" })
           #
           # @param [ Hash ] conditions Optional conditions to delete with.
@@ -534,12 +538,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/referenced/has_many.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/association/referenced/has_many/binding'
 require 'mongoid/association/referenced/has_many/buildable'
@@ -11,7 +10,6 @@ require 'mongoid/association/referenced/with_polymorphic_criteria'
 module Mongoid
   module Association
     module Referenced
-
       # The has_many association.
       class HasMany
         include Relatable
@@ -22,18 +20,18 @@ module Mongoid
         # common ones.
         #
         # @return [ Array<Symbol> ] The extra valid options.
-        ASSOCIATION_OPTIONS = [
-            :after_add,
-            :after_remove,
-            :as,
-            :autosave,
-            :before_add,
-            :before_remove,
-            :dependent,
-            :foreign_key,
-            :order,
-            :primary_key,
-            :scope,
+        ASSOCIATION_OPTIONS = %i[
+          after_add
+          after_remove
+          as
+          autosave
+          before_add
+          before_remove
+          dependent
+          foreign_key
+          order
+          primary_key
+          scope
         ].freeze
 
         # The complete list of valid options for this association, including
@@ -45,7 +43,7 @@ module Mongoid
         # The default foreign key suffix.
         #
         # @return [ String ] '_id'
-        FOREIGN_KEY_SUFFIX = '_id'.freeze
+        FOREIGN_KEY_SUFFIX = '_id'
 
         # The list of association complements.
         #
@@ -78,30 +76,38 @@ module Mongoid
           self
         end
 
-
         # Get the foreign key field on the inverse for saving the association reference.
         #
         # @return [ String ] The foreign key field on the inverse for saving the
         #   association reference.
         def foreign_key
-          @foreign_key ||= @options[:foreign_key] ? @options[:foreign_key].to_s :
+          @foreign_key ||= if @options[:foreign_key]
+                             @options[:foreign_key].to_s
+                           else
                              default_foreign_key_field
+                           end
         end
 
         # Is this association type embedded?
         #
         # @return [ false ] Always false.
-        def embedded?; false; end
+        def embedded?
+          false
+        end
 
         # The default for validation the association object.
         #
         # @return [ true ] Always true.
-        def validation_default; true; end
+        def validation_default
+          true
+        end
 
         # Does this association type store the foreign key?
         #
         # @return [ true ] Always true.
-        def stores_foreign_key?; false; end
+        def stores_foreign_key?
+          false
+        end
 
         # Get the association proxy class for this association type.
         #
@@ -200,18 +206,18 @@ module Mongoid
           @default_foreign_key_field ||= "#{inverse}#{FOREIGN_KEY_SUFFIX}"
         end
 
-        def polymorphic_inverses(other)
+        def polymorphic_inverses(_other)
           [ as ]
         end
 
         def determine_inverses(other)
           matches = (other || relation_class).relations.values.select do |rel|
             relation_complements.include?(rel.class) &&
-                rel.relation_class_name == inverse_class_name
-
+              rel.relation_class_name == inverse_class_name
           end
           if matches.size > 1
             return [ default_inverse.name ] if default_inverse
+
             raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches)
           end
           matches.collect { |m| m.name } unless matches.blank?
@@ -242,7 +248,7 @@ module Mongoid
         def with_inverse_field_criterion(criteria)
           inverse_association = inverse_association(klass)
           if inverse_association.try(:inverse_of)
-            criteria.any_in(inverse_association.inverse_of => [name, nil])
+            criteria.any_in(inverse_association.inverse_of => [ name, nil ])
           else
             criteria
           end

data/lib/mongoid/association/referenced/has_many_through/eager.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasManyThrough
+        # Two-query eager preloader for has_many :through associations.
+        class Eager < Association::Eager
+          private
+
+          def preload
+            @docs.each { |d| set_relation(d, []) }
+
+            through_assoc = @association.through_association
+            source_assoc  = @association.source_association
+
+            owner_pk   = through_assoc.primary_key
+            through_fk = through_assoc.foreign_key
+
+            owner_ids = @docs.filter_map { |d| d.public_send(owner_pk) }.uniq
+            return if owner_ids.empty?
+
+            # Step 1: load all intermediate records
+            intermediates = through_assoc.klass
+                                         .where(through_fk => { '$in' => owner_ids })
+                                         .to_a
+
+            # Step 2: map owner FK values to arrays of target docs
+            targets_by_owner_fk = build_targets_map(intermediates, through_fk, source_assoc)
+
+            # Step 3: set relation on each owner doc
+            @docs.each do |doc|
+              key_val = doc.public_send(owner_pk)
+              set_relation(doc, targets_by_owner_fk[key_val] || [])
+            end
+          end
+
+          # Build a Hash mapping each owner FK value to an array of target docs.
+          # Uses two different strategies depending on where the FK lives.
+          def build_targets_map(intermediates, through_fk, source_assoc)
+            if source_assoc.stores_foreign_key?
+              fk_on_intermediate_targets_map(intermediates, through_fk, source_assoc)
+            else
+              fk_on_source_targets_map(intermediates, through_fk, source_assoc)
+            end
+          end
+
+          # FK is on the intermediate (e.g. appointment.patient_id -> belongs_to :patient).
+          def fk_on_intermediate_targets_map(intermediates, through_fk, source_assoc)
+            source_fk_vals = intermediates.filter_map { |i| i.public_send(source_assoc.foreign_key) }.uniq
+            targets = source_assoc.klass.where(
+              source_assoc.primary_key => { '$in' => source_fk_vals }
+            ).to_a
+            targets_by_pk = targets.group_by { |t| t.public_send(source_assoc.primary_key) }
+
+            result = Hash.new { |h, k| h[k] = [] }
+            intermediates.each do |i|
+              owner_fk_val = i.public_send(through_fk)
+              matched = targets_by_pk[i.public_send(source_assoc.foreign_key)] || []
+              result[owner_fk_val].concat(matched)
+            end
+            result
+          end
+
+          # FK is on the source (e.g. reader.book_id -> has_many :readers on Book).
+          def fk_on_source_targets_map(intermediates, through_fk, source_assoc)
+            source_pk = source_assoc.primary_key
+            intermediate_pks = intermediates.filter_map { |i| i.public_send(source_pk) }.uniq
+            targets = source_assoc.klass.where(
+              source_assoc.foreign_key => { '$in' => intermediate_pks }
+            ).to_a
+            targets_by_source_fk = targets.group_by { |t| t.public_send(source_assoc.foreign_key) }
+
+            result = Hash.new { |h, k| h[k] = [] }
+            intermediates.each do |i|
+              owner_fk_val = i.public_send(through_fk)
+              matched = targets_by_source_fk[i.public_send(source_pk)] || []
+              result[owner_fk_val].concat(matched)
+            end
+            result
+          end
+
+          def set_relation(doc, element)
+            return if doc.blank?
+
+            proxy = HasManyThrough::Proxy.new(doc, @association, preloaded: element)
+            doc.set_relation(@association.name, proxy)
+          end
+
+          # Required by base class contract. Not called from preload since this
+          # class manages its own two-query traversal directly.
+          def group_by_key
+            @association.through_association.primary_key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasManyThrough
+        # Read-only proxy for has_many :through associations. Wraps the lazy
+        # Criteria returned by the association and raises ReadonlyAssociation on
+        # any write attempt.
+        class Proxy
+          extend Forwardable
+          include Enumerable
+
+          module ClassMethods
+            def eager_loader(association, docs)
+              Eager.new(association, docs)
+            end
+
+            def embedded?
+              false
+            end
+          end
+
+          extend ClassMethods
+
+          # Enumerable methods use the preloaded array when available; query
+          # methods always delegate to criteria so callers get a Criteria back.
+          def_delegators :_source,
+                         :each, :to_a, :first, :last, :count, :size, :length,
+                         :exists?, :any?, :none?, :empty?
+
+          def_delegators :criteria,
+                         :where, :pluck, :limit, :skip, :order_by, :only, :without,
+                         :sum, :avg, :min, :max
+
+          READONLY_METHODS = %i[
+            << push concat substitute build new create create!
+            delete delete_one delete_all destroy_all clear nullify
+          ].freeze
+
+          def initialize(base, association, preloaded: nil)
+            @_base        = base
+            @_association = association
+            @preloaded    = preloaded
+          end
+
+          def criteria
+            @criteria ||= @_association.criteria(@_base)
+          end
+
+          private
+
+          def _source
+            @preloaded || criteria
+          end
+
+          public
+
+          READONLY_METHODS.each do |meth|
+            define_method(meth) do |*|
+              raise Mongoid::Errors::ReadonlyAssociation.new(@_base.class, @_association)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/referenced/has_many_through/proxy'
+require 'mongoid/association/referenced/has_many_through/eager'
+
+module Mongoid
+  module Association
+    module Referenced
+      # Metadata class for has_many :through associations.
+      class HasManyThrough
+        include Relatable
+
+        # The options available for this type of association, in addition to the
+        # common ones.
+        #
+        # @return [ Array<Symbol> ] The extra valid options.
+        ASSOCIATION_OPTIONS = %i[order source through].freeze
+
+        # The complete list of valid options for this association, including
+        # the shared ones.
+        #
+        # @return [ Array<Symbol> ] The valid options.
+        VALID_OPTIONS = (ASSOCIATION_OPTIONS + SHARED_OPTIONS).freeze
+
+        # The list of association complements.
+        #
+        # @return [ Array ]
+        def relation_complements
+          [].freeze
+        end
+
+        # Setup instance methods on the owner class.
+        #
+        # @return [ self ]
+        def setup!
+          setup_instance_methods!
+          self
+        end
+
+        # Is this association embedded?
+        #
+        # @return [ false ]
+        def embedded?
+          false
+        end
+
+        # The proxy class for this association type.
+        #
+        # @return [ Class ]
+        def relation
+          Proxy
+        end
+
+        # Through associations never store a foreign key on the owner document.
+        #
+        # @return [ false ]
+        def stores_foreign_key?
+          false
+        end
+
+        # The intermediate association metadata on the owner class.
+        # Resolved lazily to allow forward references.
+        #
+        # @return [ Mongoid::Association::Relatable ]
+        def through_association
+          @through_association ||= begin
+            assoc = @owner_class.relations[@options[:through].to_s] ||
+                    raise(
+                      Errors::InvalidRelationOption.new(
+                        @owner_class, name, :through, @options[:through]
+                      )
+                    )
+            if assoc.embedded?
+              raise(
+                Errors::InvalidRelationOption.new(
+                  @owner_class, name, :through,
+                  'through association must be a referenced association, not embedded'
+                )
+              )
+            end
+            assoc
+          end
+        end
+
+        # The source association metadata on the intermediate class.
+        # Resolved lazily to allow forward references.
+        #
+        # @return [ Mongoid::Association::Relatable ]
+        def source_association
+          @source_association ||= begin
+            source_name = (@options[:source] || name.to_s.singularize).to_s
+            assoc = through_association.klass.relations[source_name] ||
+                    raise(
+                      Errors::InvalidRelationOption.new(
+                        @owner_class, name, :source, source_name
+                      )
+                    )
+            if assoc.is_a?(Referenced::HasAndBelongsToMany)
+              raise(
+                Errors::InvalidRelationOption.new(
+                  @owner_class, name, :source,
+                  'has_and_belongs_to_many is not supported as a :through source'
+                )
+              )
+            end
+            assoc
+          end
+        end
+
+        # Return a Criteria scoped to the target documents reachable from base
+        # via the through association. Performs two queries: one against the
+        # intermediate collection, one against the source collection.
+        #
+        # @param [ Document ] base The owner document.
+        #
+        # @return [ Mongoid::Criteria ]
+        def criteria(base)
+          through_crit = through_association.criteria(base)
+
+          crit = if source_association.stores_foreign_key?
+                   # FK is on the intermediate (e.g. appointment.patient_id -> belongs_to :patient)
+                   target_pk = source_association.primary_key # '_id' on Patient
+                   source_fk = source_association.foreign_key # 'patient_id' on Appointment
+                   source_association.klass.where(
+                     target_pk => { '$in' => key_values(through_crit, source_fk) }
+                   )
+                 else
+                   # FK is on the source (e.g. reader.book_id -> has_many :readers on Book)
+                   source_pk = source_association.primary_key # '_id' on intermediate (Book)
+                   source_fk = source_association.foreign_key # 'book_id' on Reader
+                   source_association.klass.where(
+                     source_fk => { '$in' => key_values(through_crit, source_pk) }
+                   )
+                 end
+          order ? crit.order_by(order) : crit
+        end
+
+        # The default for validating the association object.
+        #
+        # @return [ false ]
+        def validation_default
+          false
+        end
+
+        private
+
+        # Pluck the given key from the criteria, dropping intermediates that
+        # have no value for it. A nil in an $in array matches every document
+        # whose queried field is null or absent, which would return documents
+        # outside the association. An empty result correctly matches nothing.
+        # Mirrors what the eager loader does.
+        #
+        # @param [ Mongoid::Criteria ] criteria The intermediate criteria.
+        # @param [ String ] key The key to pluck.
+        #
+        # @return [ Array<Object> ] The usable key values.
+        def key_values(criteria, key)
+          criteria.pluck(key).compact.uniq
+        end
+
+        def setup_instance_methods!
+          define_through_getter!
+          define_through_ids_getter!
+          define_readonly_setter!
+          define_existence_check!
+          self
+        end
+
+        def define_through_getter!
+          assoc = self
+          assoc_name = name
+          @owner_class.re_define_method(assoc_name) do |reload = false|
+            if reload || !instance_variable_defined?("@_#{assoc_name}")
+              set_relation(assoc_name, HasManyThrough::Proxy.new(self, assoc))
+            end
+            instance_variable_get("@_#{assoc_name}")
+          end
+        end
+
+        def define_through_ids_getter!
+          assoc_name = name
+          ids_method = :"#{assoc_name.to_s.singularize}_ids"
+          @owner_class.re_define_method(ids_method) do
+            send(assoc_name).pluck(:_id)
+          end
+        end
+
+        def define_readonly_setter!
+          assoc = self
+          @owner_class.re_define_method(:"#{name}=") do |_object|
+            raise Mongoid::Errors::ReadonlyAssociation.new(self.class, assoc)
+          end
+        end
+
+        def default_primary_key
+          PRIMARY_KEY_DEFAULT
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/has_one/binding.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Referenced
       class HasOne
-
         # Binding class for has_one associations.
         class Binding
           include Bindable