mongoid 9.0.11 → 9.1.1

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/association/referenced/with_polymorphic_criteria'
 
@@ -7,7 +6,6 @@ module Mongoid
   module Association
     module Referenced
       class HasOne
-
         # The Builder behavior for has_one associations.
         module Buildable
           include WithPolymorphicCriteria
@@ -22,11 +20,15 @@ module Mongoid
           # @param [ nil ] selected_fields Must be nil.
           #
           # @return [ Document ] A single document.
-          def build(base, object, type = nil, selected_fields = nil)
+          def build(base, object, _type = nil, selected_fields = nil)
             if query?(object)
-              if !base.new_record?
-                execute_query(object, base)
+              # Handle array of hashes from $lookup aggregation
+              if object.is_a?(Array) && object.all? { |o| o.is_a?(Hash) }
+                doc = object.first
+                return doc ? Factory.execute_from_db(klass, doc, nil, selected_fields, execute_callbacks: false) : nil
               end
+
+              execute_query(object, base) unless base.new_record?
             else
               clear_associated(object)
               object
@@ -38,10 +40,10 @@ module Mongoid
           def clear_associated(object)
             unless inverse
               raise Errors::InverseNotFound.new(
-                  @owner_class,
-                  name,
-                  object.class,
-                  foreign_key,
+                @owner_class,
+                name,
+                object.class,
+                foreign_key
               )
             end
             if object && (associated = object.send(inverse))

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
@@ -7,7 +6,6 @@ module Mongoid
       class HasOne
         # Eager class for has_one associations.
         class Eager < Association::Eager
-
           private
 
           def preload
@@ -28,7 +26,6 @@ module Mongoid
           def key
             @association.foreign_key
           end
-
         end
       end
     end

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/association/referenced/has_one/binding'
 require 'mongoid/association/referenced/has_one/buildable'
@@ -9,7 +8,6 @@ require 'mongoid/association/referenced/has_one/eager'
 module Mongoid
   module Association
     module Referenced
-
       # The has_one association.
       class HasOne
         include Relatable
@@ -19,14 +17,15 @@ module Mongoid
         # common ones.
         #
         # @return [ Array<Symbol> ] The extra valid options.
-        ASSOCIATION_OPTIONS = [
-            :as,
-            :autobuild,
-            :autosave,
-            :dependent,
-            :foreign_key,
-            :primary_key,
-            :scope,
+        ASSOCIATION_OPTIONS = %i[
+          as
+          autobuild
+          autosave
+          dependent
+          fallback
+          foreign_key
+          primary_key
+          scope
         ].freeze
 
         # The complete list of valid options for this association, including
@@ -38,7 +37,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.
         #
@@ -60,19 +59,26 @@ module Mongoid
         # @return [ String ] The foreign key field 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
 
         # Get the association proxy class for this association type.
         #
@@ -120,7 +126,9 @@ module Mongoid
         # Does this association type store the foreign key?
         #
         # @return [ false ] Always false.
-        def stores_foreign_key?; false; end
+        def stores_foreign_key?
+          false
+        end
 
         # Get the path calculator for the supplied document.
         #
@@ -163,19 +171,17 @@ 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
-
-          end
-          if matches.size > 1
-            raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches)
+              rel.relation_class_name == inverse_class_name
           end
+          raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches) if matches.size > 1
+
           matches.collect { |m| m.name } unless matches.blank?
         end
 

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasOneThrough
+        # Two-query eager preloader for has_one :through associations.
+        class Eager < Association::Eager
+          private
+
+          def preload
+            @docs.each { |d| set_relation(d, nil) }
+
+            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?
+
+            intermediates = through_assoc.klass.where(through_fk => { '$in' => owner_ids }).to_a
+            intermediate_to_target = build_intermediate_to_target(intermediates, through_fk, source_assoc)
+
+            @docs.each do |doc|
+              owner_key_val = doc.public_send(owner_pk)
+              target = intermediate_to_target[owner_key_val]
+              proxy = target ? HasOneThrough::Proxy.new(doc, target, @association) : nil
+              doc.set_relation(@association.name, proxy) unless doc.blank?
+            end
+          end
+
+          def build_intermediate_to_target(intermediates, through_fk, source_assoc)
+            if source_assoc.stores_foreign_key?
+              # FK is on the intermediate (e.g. belongs_to :store => intermediate.store_id)
+              source_fk_values = intermediates.filter_map { |i| i.public_send(source_assoc.foreign_key) }.uniq
+              targets = source_assoc.klass.where(source_assoc.primary_key => { '$in' => source_fk_values }).to_a
+              targets_by_key = targets.index_by { |t| t.public_send(source_assoc.primary_key) }
+              intermediates.to_h do |i|
+                [ i.public_send(through_fk), targets_by_key[i.public_send(source_assoc.foreign_key)] ]
+              end
+            else
+              # FK is on the source (e.g. has_one :store => store.franchise_id)
+              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_fk = targets.index_by { |t| t.public_send(source_assoc.foreign_key) }
+              intermediates.index_by { |i| i.public_send(through_fk) }.transform_values do |i|
+                targets_by_fk[i.public_send(source_pk)]
+              end
+            end
+          end
+
+          # Required by the base class contract. Not called by this preloader
+          # because preload manages document traversal directly without using
+          # the grouped_docs / keys_from_docs machinery from the base class.
+          def group_by_key
+            @association.through_association.primary_key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasOneThrough
+        # Read-only proxy for has_one :through associations.
+        # Instances are returned by the association getter. Write attempts raise
+        # ReadonlyAssociation.
+        class Proxy < Association::One
+          module ClassMethods
+            def eager_loader(association, docs)
+              Eager.new(association, docs)
+            end
+
+            # Returns true if the association is an embedded one. In this case
+            # always false.
+            #
+            # @return [ false ] Always false.
+            def embedded?
+              false
+            end
+          end
+
+          extend ClassMethods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/referenced/has_one_through/proxy'
+require 'mongoid/association/referenced/has_one_through/eager'
+
+module Mongoid
+  module Association
+    module Referenced
+      # Metadata class for has_one :through associations.
+      class HasOneThrough
+        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[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
+
+        # 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
+            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
+
+        # Through associations never store a foreign key on the owner document.
+        #
+        # @return [ false ]
+        def stores_foreign_key?
+          false
+        end
+
+        # Resolve the target by delegating through the intermediate proxy.
+        # Unlike other association types, this returns a document (or nil)
+        # directly rather than a Mongoid::Criteria, because the two-hop
+        # traversal is performed eagerly via the existing association proxy.
+        #
+        # @param [ Document ] base The owner document.
+        #
+        # @return [ Document | nil ]
+        def criteria(base)
+          through_target = base.public_send(through_association.name)
+          return nil if through_target.nil?
+
+          through_target.public_send(source_association.name)
+        end
+
+        # The default for validating the association object.
+        #
+        # @return [ false ]
+        def validation_default
+          false
+        end
+
+        private
+
+        def setup_instance_methods!
+          define_through_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}")
+              doc = assoc.criteria(self)
+              proxy = doc ? HasOneThrough::Proxy.new(self, doc, assoc) : nil
+              set_relation(assoc_name, proxy)
+            end
+            instance_variable_get("@_#{assoc_name}")
+          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/syncable.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Referenced
-
       # This module handles the behavior for synchronizing foreign keys between
       # both sides of a many to many associations.
       module Syncable
-
         # Is the document able to be synced on the inverse side? This is only if
         # the key has changed and the association bindings have not been run.
         #
@@ -54,9 +51,9 @@ module Mongoid
         # @return [ Object ] The updated values.
         def remove_inverse_keys(association)
           foreign_keys = send(association.foreign_key)
-          unless foreign_keys.nil? || foreign_keys.empty?
-            association.criteria(self, foreign_keys).pull(association.inverse_foreign_key => _id)
-          end
+          return if foreign_keys.nil? || foreign_keys.empty?
+
+          association.criteria(self, foreign_keys).pull(association.inverse_foreign_key => _id)
         end
 
         # Update the inverse keys for the association.
@@ -68,32 +65,31 @@ module Mongoid
         #
         # @return [ Object ] The updated values.
         def update_inverse_keys(association)
-          if previous_changes.has_key?(association.foreign_key)
-            old, new = previous_changes[association.foreign_key]
-            adds, subs = new - (old || []), (old || []) - new
+          return unless previous_changes.has_key?(association.foreign_key)
 
-            # If we are autosaving we don't want a duplicate to get added - the
-            # $addToSet would run previously and then the $push and $each from the
-            # inverse on the autosave would cause this. We delete each id from
-            # what's in memory in case a mix of id addition and object addition
-            # had occurred.
-            if association.autosave?
-              send(association.name).in_memory.each do |doc|
-                adds.delete_one(doc._id)
-              end
-            end
+          old, new = previous_changes[association.foreign_key]
+          adds, subs = new - (old || []), (old || []) - new
 
-            unless adds.empty?
-              association.criteria(self, adds).without_options.add_to_set(association.inverse_foreign_key => _id)
-            end
-            unless subs.empty?
-              association.criteria(self, subs).without_options.pull(association.inverse_foreign_key => _id)
+          # If we are autosaving we don't want a duplicate to get added - the
+          # $addToSet would run previously and then the $push and $each from the
+          # inverse on the autosave would cause this. We delete each id from
+          # what's in memory in case a mix of id addition and object addition
+          # had occurred.
+          if association.autosave?
+            send(association.name).in_memory.each do |doc|
+              adds.delete_one(doc._id)
             end
           end
+
+          unless adds.empty?
+            association.criteria(self, adds).without_options.add_to_set(association.inverse_foreign_key => _id)
+          end
+          return if subs.empty?
+
+          association.criteria(self, subs).without_options.pull(association.inverse_foreign_key => _id)
         end
 
         module ClassMethods
-
           # Set up the syncing of many to many foreign keys.
           #
           # @example Set up the syncing.
@@ -101,10 +97,10 @@ module Mongoid
           #
           # @param [ Mongoid::Association::Relatable ] association The association metadata.
           def _synced(association)
-            unless association.forced_nil_inverse?
-              synced_save(association)
-              synced_destroy(association)
-            end
+            return if association.forced_nil_inverse?
+
+            synced_save(association)
+            synced_destroy(association)
           end
 
           private
@@ -123,9 +119,9 @@ module Mongoid
           # @return [ Class ] The class getting set up.
           def synced_save(association)
             set_callback(
-                :save,
-                :after,
-                if: ->(doc) { doc._syncable?(association) }
+              :save,
+              :after,
+              if: ->(doc) { doc._syncable?(association) }
             ) do |doc|
               doc.update_inverse_keys(association)
             end
@@ -142,8 +138,8 @@ module Mongoid
           # @return [ Class ] The class getting set up.
           def synced_destroy(association)
             set_callback(
-                :destroy,
-                :after
+              :destroy,
+              :after
             ) do |doc|
               doc.remove_inverse_keys(association)
             end

data/lib/mongoid/association/referenced.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/association/referenced/auto_save'
 require 'mongoid/association/referenced/counter_cache'
@@ -8,3 +7,5 @@ require 'mongoid/association/referenced/belongs_to'
 require 'mongoid/association/referenced/has_many'
 require 'mongoid/association/referenced/has_and_belongs_to_many'
 require 'mongoid/association/referenced/has_one'
+require 'mongoid/association/referenced/has_one_through'
+require 'mongoid/association/referenced/has_many_through'

data/lib/mongoid/association/reflections.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
-
     # The reflections module provides convenience methods that can retrieve
     # useful information about associations.
     module Reflections
@@ -34,7 +32,6 @@ module Mongoid
       end
 
       module ClassMethods
-
         # Returns the association metadata for the supplied name.
         #
         # @example Find association metadata by name.