mongoid 6.4.8 → 7.5.4

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class BelongsTo
+
+        # Binding class for belongs_to 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 on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind the documents.
+          #   game.person.bind(:continue => true)
+          #   game.person = Person.new
+          def bind_one
+            binding do
+              check_polymorphic_inverses!(_target)
+              bind_foreign_key(_base, record_id(_target))
+              bind_polymorphic_inverse_type(_base, _target.class.name)
+              if inverse = _association.inverse(_target)
+                if set_base_association
+                  if _base.referenced_many?
+                    _target.__send__(inverse).push(_base)
+                  else
+                    _target.set_relation(inverse, _base)
+                  end
+                end
+              end
+            end
+          end
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   game.person.unbind(:continue => true)
+          #   game.person = nil
+          def unbind_one
+            binding do
+              inverse = _association.inverse(_target)
+              bind_foreign_key(_base, nil)
+              bind_polymorphic_inverse_type(_base, nil)
+              if inverse
+                set_base_association
+                if _base.referenced_many?
+                  _target.__send__(inverse).delete(_base)
+                else
+                  _target.set_relation(inverse, nil)
+                end
+              end
+            end
+          end
+
+          private
+
+          # Check for problems with multiple inverse definitions.
+          #
+          # @api private
+          #
+          # @example Check for inverses errors.
+          #   binding.check_inverses!(doc)
+          #
+          # @param [ Document ] doc The document to check.
+          def check_polymorphic_inverses!(doc)
+            inverses = _association.inverses(doc)
+            if inverses.length > 1 && _base.send(_association.foreign_key).nil?
+              raise Errors::InvalidSetPolymorphicRelation.new(
+                  _association.name, _base.class.name, _target.class.name
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class BelongsTo
+
+        # The Builder behavior for belongs_to 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.
+          #
+          # @example Build the document.
+          #   relation.build(meta, attrs)
+          #
+          # @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)
+            return object unless query?(object)
+            execute_query(object, type)
+          end
+
+          private
+
+          def execute_query(object, type)
+            query_criteria(object, type).limit(1).first(id_sort: :none)
+          end
+
+          def query_criteria(object, type)
+            cls = type ? type.constantize : relation_class
+            crit = cls.criteria
+            crit = crit.apply_scope(scope)
+            crit.where(primary_key => object)
+          end
+
+          def query?(object)
+            object && !object.is_a?(Mongoid::Document)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class BelongsTo
+
+        # Eager class for belongs_to associations.
+        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
+
+          # Retrieves the documents referenced by the association, and
+          # yields each one sequentially to the provided block. If the
+          # association is not polymorphic, all documents are retrieved in
+          # a single query. If the association is polymorphic, one query is
+          # issued per association target class.
+          def each_loaded_document(&block)
+            if @association.polymorphic?
+              keys_by_type_from_docs.each do |type, keys|
+                each_loaded_document_of_class(Object.const_get(type), keys, &block)
+              end
+            else
+              super
+            end
+          end
+
+          # Returns a map from association target class name to foreign key
+          # values for the documents of that association target class,
+          # as referenced by this association.
+          def keys_by_type_from_docs
+            inverse_type_field = @association.inverse_type
+
+            @docs.each_with_object({}) do |doc, keys_by_type|
+              next unless doc.respond_to?(inverse_type_field) && doc.respond_to?(group_by_key)
+              inverse_type_name = doc.send(inverse_type_field)
+              # If a particular document does not have a value for this
+              # association, inverse_type_name will be nil.
+              next if inverse_type_name.nil?
+
+              key_value = doc.send(group_by_key)
+              # If a document has the *_type field set but the corresponding
+              # *_id field not set, the key value here will be nil.
+              next unless key_value
+
+              keys_by_type[inverse_type_name] ||= []
+              keys_by_type[inverse_type_name].push(key_value)
+            end
+          end
+
+          def group_by_key
+            @association.foreign_key
+          end
+
+          def key
+            @association.primary_key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class BelongsTo
+
+        # This class handles all behavior for associations that are either
+        # one-to-many or one-to-one, where the foreign key is stored on this side
+        # of the association and the reference is to document(s) in another
+        # collection.
+        class Proxy < Association::One
+          include Evolvable
+
+          # Instantiate a new belongs_to association proxy.
+          #
+          # @example Create the new proxy.
+          #   Association::BelongsTo::Proxy.new(game, person, association)
+          #
+          # @param [ Document ] base The document this association hangs off of.
+          # @param [ Document, Array<Document> ] target The target (parent) of the
+          #   association.
+          # @param [ Association ] association The association object.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              characterize_one(_target)
+              bind_one
+            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 documents for the existing document
+          # in the association.
+          #
+          # @example Substitute the association.
+          #   name.substitute(new_name)
+          #
+          # @param [ Document, Array<Document> ] replacement The replacement.
+          #
+          # @return [ self, nil ] The association or nil.
+          def substitute(replacement)
+            unbind_one
+            if replacement
+              self._target = normalize(replacement)
+              bind_one
+              self
+            end
+          end
+
+          private
+
+          # Instantiate the binding associated with this association.
+          #
+          # @example Get the binding object.
+          #   binding([ address ])
+          #
+          # @return [ Binding ] The binding object.
+          def binding
+            BelongsTo::Binding.new(_base, _target, _association)
+          end
+
+          # Normalize the value provided as a replacement for substitution.
+          #
+          # @api private
+          #
+          # @example Normalize the substitute.
+          #   proxy.normalize(id)
+          #
+          # @param [ Document, Object ] replacement The replacement object.
+          #
+          # @return [ Document ] The document.
+          def normalize(replacement)
+            return replacement if replacement.is_a?(Document)
+            _association.build(klass, replacement)
+          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?
+            _target.persisted? && !_binding? && !_building?
+          end
+
+          class << self
+
+            # Get the Eager object for this type of association.
+            #
+            # @example Get the eager loader object
+            #
+            # @param [ Association ] association The association object.
+            # @param [ Array<Document> ] docs The array of documents.
+            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?
+            #   Association::BelongsTo::Proxy.embedded?
+            #
+            # @return [ false ] Always false.
+            def embedded?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/referenced/belongs_to/binding'
+require 'mongoid/association/referenced/belongs_to/buildable'
+require 'mongoid/association/referenced/belongs_to/proxy'
+require 'mongoid/association/referenced/belongs_to/eager'
+
+module Mongoid
+  module Association
+    module Referenced
+
+      # The BelongsTo type association.
+      class BelongsTo
+        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 = [
+            :autobuild,
+            :autosave,
+            :counter_cache,
+            :dependent,
+            :foreign_key,
+            :index,
+            :polymorphic,
+            :primary_key,
+            :touch,
+            :optional,
+            :required,
+            :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 type of the field holding the foreign key.
+        #
+        # @return [ Object ]
+        FOREIGN_KEY_FIELD_TYPE = Object
+
+        # 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 ||= [ HasMany, HasOne ].freeze
+        end
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        def setup!
+          setup_instance_methods!
+          @owner_class.aliased_fields[name.to_s] = foreign_key
+          self
+        end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ true ] Always true.
+        def stores_foreign_key?; true; end
+
+        # Is this association type embedded?
+        #
+        # @return [ false ] Always false.
+        def embedded?; false; end
+
+        # The default for validation the association object.
+        #
+        # @return [ false ] Always false.
+        def validation_default; false; end
+
+        # Get the foreign key field for saving the association reference.
+        #
+        # @return [ String ] The foreign key field for saving the association reference.
+        def foreign_key
+          @foreign_key ||= @options[:foreign_key] ? @options[:foreign_key].to_s :
+                             default_foreign_key_field
+        end
+
+        # Get the association proxy class for this association type.
+        #
+        # @return [ Association::BelongsTo::Proxy ] The proxy class.
+        def relation
+          Proxy
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true, false ] Whether this association is polymorphic.
+        def polymorphic?
+          @polymorphic ||= !!@options[:polymorphic]
+        end
+
+        # The name of the field used to store the type of polymorphic association.
+        #
+        # @return [ String ] The field used to store the type of polymorphic association.
+        def inverse_type
+          (@inverse_type ||= "#{name}_type") if polymorphic?
+        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::One ] The Nested Builder object.
+        def nested_builder(attributes, options)
+          Nested::One.new(self, attributes, options)
+        end
+
+        # Get the path calculator for the supplied document.
+        #
+        # @example Get the path calculator.
+        #   association.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 setup_instance_methods!
+          define_getter!
+          define_setter!
+          define_existence_check!
+          define_builder!
+          define_creator!
+          define_autosaver!
+          define_counter_cache_callbacks!
+          polymorph!
+          define_dependency!
+          create_foreign_key_field!
+          setup_index!
+          define_touchable!
+          @owner_class.validates_associated(name) if validate?
+          @owner_class.validates(name, presence: true) if require_association?
+        end
+
+        def index_spec
+          if polymorphic?
+            { key => 1, inverse_type => 1 }
+          else
+            { key => 1 }
+          end
+        end
+
+        def default_primary_key
+          PRIMARY_KEY_DEFAULT
+        end
+
+        def default_foreign_key_field
+          @default_foreign_key_field ||= "#{name}#{FOREIGN_KEY_SUFFIX}"
+        end
+
+        def polymorph!
+          if polymorphic?
+            @owner_class.polymorphic = true
+            @owner_class.field(inverse_type, type: String)
+          end
+        end
+
+        def polymorphic_inverses(other = nil)
+          if other
+            matches = other.relations.values.select do |rel|
+              relation_complements.include?(rel.class) &&
+                  rel.as == name &&
+                  rel.relation_class_name == inverse_class_name
+            end
+            matches.collect { |m| m.name }
+          end
+        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)
+          end
+          matches.collect { |m| m.name }
+        end
+
+        # If set to true, then the associated object will be validated when this object is saved
+        def require_association?
+          required = @options[:required] if @options.key?(:required)
+          required = !@options[:optional] if @options.key?(:optional) && required.nil?
+          required.nil? ? Mongoid.belongs_to_required_by_default : required
+        end
+
+        def create_foreign_key_field!
+          @owner_class.field(
+              foreign_key,
+              type: FOREIGN_KEY_FIELD_TYPE,
+              identity: true,
+              overwrite: true,
+              association: self,
+              default: nil
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      module CounterCache
+        extend ActiveSupport::Concern
+
+        # Reset the given counter using the .count() query from the
+        # db. This method is useful in case that a counter got
+        # corrupted, or a new counter was added to the collection.
+        #
+        # @example Reset the given counter cache
+        #   post.reset_counters(:comments)
+        #
+        # @param [ Symbol, Array ] counters One or more counter caches to reset
+        def reset_counters(*counters)
+          self.class.with(persistence_context) do |_class|
+            _class.reset_counters(self, *counters)
+          end
+        end
+
+        module ClassMethods
+
+          # Reset the given counter using the .count() query from the
+          # db. This method is useful in case that a counter got
+          # corrupted, or a new counter was added to the collection.
+          #
+          # @example Reset the given counter cache
+          #   Post.reset_counters('50e0edd97c71c17ea9000001', :comments)
+          #
+          # @param [ String ] id The id of the object that will be reset.
+          # @param [ Symbol, Array ] counters One or more counter caches to reset
+          def reset_counters(id, *counters)
+            document = id.is_a?(Document) ? id : find(id)
+            counters.each do |name|
+              relation_association = relations[name]
+              counter_name = relation_association.inverse_association.counter_cache_column_name
+              document.update_attribute(counter_name, document.send(name).count)
+            end
+          end
+
+          # Update the given counters by the value factor. It uses the
+          # atomic $inc command.
+          #
+          # @example Add 5 to comments counter and remove 2 from likes
+          #   counter.
+          #   Post.update_counters('50e0edd97c71c17ea9000001',
+          #              :comments_count => 5, :likes_count => -2)
+          #
+          # @param [ String ] id The id of the object to update.
+          # @param [ Hash ] counters
+          def update_counters(id, counters)
+            where(:_id => id).inc(counters)
+          end
+
+          # Increment the counter name from the entries that match the
+          # id by one. This method is used on associations callbacks
+          # when counter_cache is enabled
+          #
+          # @example Increment comments counter
+          #   Post.increment_counter(:comments_count, '50e0edd97c71c17ea9000001')
+          #
+          # @param [ Symbol ] counter_name Counter cache name
+          # @param [ String ] id The id of the object that will have its counter incremented.
+          def increment_counter(counter_name, id)
+            update_counters(id, counter_name.to_sym => 1)
+          end
+
+          # Decrement the counter name from the entries that match the
+          # id by one. This method is used on associations callbacks
+          # when counter_cache is enabled
+          #
+          # @example Decrement comments counter
+          #   Post.decrement_counter(:comments_count, '50e0edd97c71c17ea9000001')
+          #
+          # @param [ Symbol ] counter_name Counter cache name
+          # @param [ String ] id The id of the object that will have its counter decremented.
+          def decrement_counter(counter_name, id)
+            update_counters(id, counter_name.to_sym => -1)
+          end
+        end
+
+        # Add the callbacks responsible for update the counter cache field.
+        #
+        # @api private
+        #
+        # @example Add the touchable.
+        #   Mongoid::Association::Referenced::CounterCache.define_callbacks!(association)
+        #
+        # @param [ Association ] association The association.
+        #
+        # @return [ Class ] The association's owning class.
+        def self.define_callbacks!(association)
+          name = association.name
+          cache_column = association.counter_cache_column_name.to_sym
+
+          association.inverse_class.tap do |klass|
+            klass.after_update do
+              if record = __send__(name)
+                foreign_key = association.foreign_key
+
+                if attribute_changed?(foreign_key)
+                  original, current = attribute_change(foreign_key)
+
+                  unless original.nil?
+                    record.class.with(persistence_context) do |_class|
+                      _class.decrement_counter(cache_column, original)
+                    end
+                  end
+
+                  unless current.nil?
+                    record[cache_column] = (record[cache_column] || 0) + 1
+                    record.class.with(record.persistence_context) do |_class|
+                      _class.increment_counter(cache_column, current) if record.persisted?
+                    end
+                  end
+                end
+              end
+            end
+
+            klass.after_create do
+              if record = __send__(name)
+                record[cache_column] = (record[cache_column] || 0) + 1
+
+                if record.persisted?
+                  record.class.with(record.persistence_context) do |_class|
+                    _class.increment_counter(cache_column, record._id)
+                  end
+                  record.remove_change(cache_column)
+                end
+              end
+            end
+
+            klass.before_destroy do
+              if record = __send__(name)
+                record[cache_column] = (record[cache_column] || 0) - 1 unless record.frozen?
+
+                if record.persisted?
+                  record.class.with(record.persistence_context) do |_class|
+                    _class.decrement_counter(cache_column, record._id)
+                  end
+                  record.remove_change(cache_column)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end