mongoid 6.4.4 → 7.5.1

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

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/referenced/has_many/binding'
+require 'mongoid/association/referenced/has_many/buildable'
+require 'mongoid/association/referenced/has_many/proxy'
+require 'mongoid/association/referenced/has_many/enumerable'
+require 'mongoid/association/referenced/has_many/eager'
+
+module Mongoid
+  module Association
+    module Referenced
+
+      # The has_many association.
+      class HasMany
+        include Relatable
+        include Buildable
+
+        # The options available for this type of association, in addition to the
+        # 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,
+        ].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 default foreign key suffix.
+        #
+        # @return [ String ] '_id'
+        FOREIGN_KEY_SUFFIX = '_id'.freeze
+
+        # The list of association complements.
+        #
+        # @return [ Array<Association> ] The association complements.
+        def relation_complements
+          @relation_complements ||= [ Referenced::BelongsTo ].freeze
+        end
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        def setup!
+          setup_instance_methods!
+          self
+        end
+
+        # Setup the instance methods on the class having this association type.
+        #
+        # @return [ self ]
+        def setup_instance_methods!
+          define_getter!
+          define_ids_getter!
+          define_setter!
+          define_ids_setter!
+          define_existence_check!
+          define_autosaver!
+          polymorph!
+          define_dependency!
+          @owner_class.validates_associated(name) if validate?
+          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 :
+                             default_foreign_key_field
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ false ] Always false.
+        def embedded?; false; end
+
+        # The default for validation the association object.
+        #
+        # @return [ true ] Always true.
+        def validation_default; true; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ true ] Always true.
+        def stores_foreign_key?; false; end
+
+        # Get the association proxy class for this association type.
+        #
+        # @return [ Association::HasMany::Proxy ] The proxy class.
+        def relation
+          Proxy
+        end
+
+        # The criteria used for querying this association.
+        #
+        # @return [ Mongoid::Criteria ] The criteria used for querying this association.
+        def criteria(base)
+          query_criteria(base.send(primary_key), base)
+        end
+
+        # The type of this association if it's polymorphic.
+        #
+        # @note Only relevant for polymorphic associations.
+        #
+        # @return [ String, nil ] The type field.
+        def type
+          @type ||= "#{as}_type" if polymorphic?
+        end
+
+        # Add polymorphic query criteria to a Criteria object, if this association is
+        #  polymorphic.
+        #
+        # @param [ Mongoid::Criteria ] criteria The criteria object to add to.
+        # @param [ Class ] object_class The object class.
+        #
+        # @return [ Mongoid::Criteria ] The criteria object.
+        def add_polymorphic_criterion(criteria, object_class)
+          if polymorphic?
+            criteria.where(type => object_class.name)
+          else
+            criteria
+          end
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true, false ] Whether this association is polymorphic.
+        def polymorphic?
+          @polymorphic ||= !!as
+        end
+
+        # Whether trying to bind an object using this association should raise
+        # an error.
+        #
+        # @param [ Document ] doc The document to be bound.
+        #
+        # @return [ true, false ] Whether the document can be bound.
+        def bindable?(doc)
+          forced_nil_inverse? || (!!inverse && doc.fields.keys.include?(foreign_key))
+        end
+
+        # The nested builder object.
+        #
+        # @param [ Hash ] attributes The attributes to use to build the association object.
+        # @param [ Hash ] options The options for the association.
+        #
+        # @return [ Association::Nested::Many ] The Nested Builder object.
+        def nested_builder(attributes, options)
+          Nested::Many.new(self, attributes, options)
+        end
+
+        # Get the path calculator for the supplied document.
+        #
+        # @example Get the path calculator.
+        #   Proxy.path(document)
+        #
+        # @param [ Document ] document The document to calculate on.
+        #
+        # @return [ Root ] The root atomic path calculator.
+        def path(document)
+          Mongoid::Atomic::Paths::Root.new(document)
+        end
+
+        # Get the scope to be applied when querying the association.
+        #
+        # @return [ Proc | Symbol | nil ] The association scope, if any.
+        def scope
+          @options[:scope]
+        end
+
+        private
+
+        def default_foreign_key_field
+          @default_foreign_key_field ||= "#{inverse}#{FOREIGN_KEY_SUFFIX}"
+        end
+
+        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
+            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?
+        end
+
+        def default_primary_key
+          PRIMARY_KEY_DEFAULT
+        end
+
+        def query_criteria(object, base)
+          crit = klass.criteria
+          crit = crit.apply_scope(scope)
+          crit = crit.where(foreign_key => object)
+          crit = with_polymorphic_criterion(crit, base)
+          crit.association = self
+          crit.parent_document = base
+          with_ordering(crit)
+        end
+
+        def with_polymorphic_criterion(criteria, base)
+          if polymorphic?
+            criteria.where(type => base.class.name)
+          else
+            criteria
+          end
+        end
+
+        def with_ordering(criteria)
+          if order
+            criteria.order_by(order)
+          else
+            criteria
+          end
+        end
+
+        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])
+          else
+            criteria
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasOne
+
+        # Binding class for has_one associations.
+        class Binding
+          include Bindable
+
+          # Binds the base object to the inverse of the association. This is so we
+          # are referenced to the actual objects themselves on both sides.
+          #
+          # This case sets the association metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind the document.
+          #   person.game.bind(:continue => true)
+          #   person.game = Game.new
+          def bind_one
+            binding do
+              bind_from_relational_parent(_target)
+            end
+          end
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   person.game.unbind(:continue => true)
+          #   person.game = nil
+          def unbind_one
+            binding do
+              unbind_from_relational_parent(_target)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasOne
+
+        # The Builder behavior for has_one associations.
+        module Buildable
+
+          # This method either takes an _id or an object and queries for the
+          # inverse side using the id or sets the object after clearing the
+          # associated object.
+          #
+          # @param [ Object ] base The base object.
+          # @param [ Object ] object The object to use to build the association.
+          # @param [ String ] type The type of the association.
+          # @param [ nil ] selected_fields Must be nil.
+          #
+          # @return [ Document ] A single document.
+          def build(base, object, type = nil, selected_fields = nil)
+            if query?(object)
+              if !base.new_record?
+                execute_query(object, base)
+              end
+            else
+              clear_associated(object)
+              object
+            end
+          end
+
+          private
+
+          def clear_associated(object)
+            unless inverse
+              raise Errors::InverseNotFound.new(
+                  @owner_class,
+                  name,
+                  object.class,
+                  foreign_key,
+              )
+            end
+            if object && (associated = object.send(inverse))
+              associated.substitute(nil)
+            end
+          end
+
+          def query_criteria(object, base)
+            crit = klass.criteria
+            crit = crit.apply_scope(scope)
+            crit = crit.where(foreign_key => object)
+            with_polymorphic_criterion(crit, base)
+          end
+
+          def execute_query(object, base)
+            query_criteria(object, base).limit(1).first(id_sort: :none)
+          end
+
+          def with_polymorphic_criterion(criteria, base)
+            if polymorphic?
+              criteria.where(type => base.class.name)
+            else
+              criteria
+            end
+          end
+
+          def query?(object)
+            object && !object.is_a?(Mongoid::Document)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+
+      class HasOne
+
+        class Eager < Association::Referenced::Eager::Base
+
+          private
+
+          def preload
+            @docs.each do |d|
+              set_relation(d, nil)
+            end
+
+            each_loaded_document do |doc|
+              id = doc.send(key)
+              set_on_parent(id, doc)
+            end
+          end
+
+          def group_by_key
+            @association.primary_key
+          end
+
+          def key
+            @association.foreign_key
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      module NestedAttributes
+        class One < NestedBuilder
+
+          attr_accessor :destroy
+
+          # Builds the association depending on the attributes and the options
+          # passed to the macro.
+          #
+          # @example Build a 1-1 nested document.
+          #   one.build(person, as: :admin)
+          #
+          # @note This attempts to perform 3 operations, either one of an update of
+          #   the existing association, a replacement of the association with a new
+          #   document, or a removal of the association.
+          #
+          # @param [ Document ] parent The parent document.
+          #
+          # @return [ Document ] The built document.
+          def build(parent)
+            return if reject?(parent, attributes)
+            @existing = parent.send(association.name)
+            if update?
+              attributes.delete_id
+              existing.assign_attributes(attributes)
+            elsif replace?
+              parent.send(association.setter, Factory.build(association.klass, attributes))
+            elsif delete?
+              parent.send(association.setter, nil)
+            end
+          end
+
+          # Create the new builder for nested attributes on one-to-one
+          # associations.
+          #
+          # @example Instantiate the builder.
+          #   One.new(association, attributes)
+          #
+          # @param [ Association ] association The association metadata.
+          # @param [ Hash ] attributes The attributes hash to attempt to set.
+          # @param [ Hash ] options The options defined.
+          def initialize(association, attributes, options)
+            @attributes = attributes.with_indifferent_access
+            @association = association
+            @options = options
+            @destroy = @attributes.delete(:_destroy)
+          end
+
+          private
+
+          # Is the id in the attribtues acceptable for allowing an update to
+          # the existing association?
+          #
+          # @api private
+          #
+          # @example Is the id acceptable?
+          #   one.acceptable_id?
+          #
+          # @return [ true, false ] If the id part of the logic will allow an update.
+          def acceptable_id?
+            id = convert_id(existing.class, attributes[:_id])
+            existing._id == id || id.nil? || (existing._id != id && update_only?)
+          end
+
+          # Can the existing association be deleted?
+          #
+          # @example Can the existing object be deleted?
+          #   one.delete?
+          #
+          # @return [ true, false ] If the association should be deleted.
+          def delete?
+            destroyable? && !attributes[:_id].nil?
+          end
+
+          # Can the existing association potentially be destroyed?
+          #
+          # @example Is the object destroyable?
+          #   one.destroyable?({ :_destroy => "1" })
+          #
+          # @return [ true, false ] If the association can potentially be
+          #   destroyed.
+          def destroyable?
+            [ 1, "1", true, "true" ].include?(destroy) && allow_destroy?
+          end
+
+          # Is the document to be replaced?
+          #
+          # @example Is the document to be replaced?
+          #   one.replace?
+          #
+          # @return [ true, false ] If the document should be replaced.
+          def replace?
+            !existing && !destroyable? && !attributes.blank?
+          end
+
+          # Should the document be updated?
+          #
+          # @example Should the document be updated?
+          #   one.update?
+          #
+          # @return [ true, false ] If the object should have its attributes updated.
+          def update?
+            existing && !destroyable? && acceptable_id?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasOne
+
+        # This class defines the behavior for all associations that are a
+        # one-to-one between documents in different collections.
+        class Proxy < Association::One
+
+          # Instantiate a new references_one association. Will set the foreign key
+          # and the base on the inverse object.
+          #
+          # @example Create the new association.
+          #   Referenced::One.new(base, target, association)
+          #
+          # @param [ Document ] base The document this association hangs off of.
+          # @param [ Document ] target The target (child) of the association.
+          # @param [ Association ] association The association metadata.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              raise_mixed if klass.embedded? && !klass.cyclic?
+              characterize_one(_target)
+              bind_one
+              _target.save if persistable?
+            end
+          end
+
+          # Removes the association between the base document and the target
+          # document by deleting the foreign key and the reference, orphaning
+          # the target document in the process.
+          #
+          # @example Nullify the association.
+          #   person.game.nullify
+          def nullify
+            unbind_one
+            _target.save
+          end
+
+          # Substitutes the supplied target document for the existing document
+          # in the association. If the new target is nil, perform the necessary
+          # deletion.
+          #
+          # @example Replace the association.
+          #   person.game.substitute(new_game)
+          #
+          # @param [ Array<Document> ] replacement The replacement target.
+          #
+          # @return [ One ] The association.
+          def substitute(replacement)
+            # If the same object currently associated is being assigned,
+            # rebind the association and save the target but do not destroy
+            # the target.
+
+            unbind_one
+            if persistable?
+              # TODO can this entire method be skipped if self == replacement?
+              if _association.destructive? && self != replacement
+                send(_association.dependent)
+              else
+                save if persisted?
+              end
+            end
+            HasOne::Proxy.new(_base, replacement, _association) if replacement
+          end
+
+          private
+
+          # Instantiate the binding associated with this association.
+          #
+          # @example Get the binding.
+          #   relation.binding([ address ])
+          #
+          # @return [ Binding ] The binding object.
+          def binding
+            HasOne::Binding.new(_base, _target, _association)
+          end
+
+          # Are we able to persist this association?
+          #
+          # @example Can we persist the association?
+          #   relation.persistable?
+          #
+          # @return [ true, false ] If the association is persistable.
+          def persistable?
+            _base.persisted? && !_binding? && !_building?
+          end
+
+          class << self
+
+            def eager_loader(association, docs)
+              Eager.new(association, docs)
+            end
+
+            # Returns true if the association is an embedded one. In this case
+            # always false.
+            #
+            # @example Is this association embedded?
+            #   Referenced::One.embedded?
+            #
+            # @return [ false ] Always false.
+            def embedded?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end