mongoid 6.4.8 → 7.0.0

data/lib/mongoid/association/relatable.rb

@@ -0,0 +1,415 @@
+require 'mongoid/association/constrainable'
+require 'mongoid/association/options'
+
+module Mongoid
+  module Association
+
+    # This module provides behaviors shared between Association types.
+    #
+    # @since 7.0
+    module Relatable
+      include Constrainable
+      include Options
+
+      # The options shared between all association types.
+      #
+      # @return [ Array<Symbol> ] The shared options.
+      #
+      # @since 7.0
+      SHARED_OPTIONS = [
+                         :class_name,
+                         :inverse_of,
+                         :validate,
+                         :extend
+                       ].freeze
+
+      # The primary key default.
+      #
+      # @return [ String ] The primary key field default.
+      #
+      # @since 7.0
+      PRIMARY_KEY_DEFAULT = '_id'.freeze
+
+      # The name of the association.
+      #
+      # @return [ Symbol ] The name of the relation.
+      #
+      # @since 7.0
+      attr_reader :name
+
+      # The options on this association.
+      #
+      # @return [ Hash ] The options.
+      #
+      # @since 7.0
+      attr_reader :options
+
+      # Initialize the Association.
+      #
+      # @param [ Class ] _class The class of the model who owns this relation.
+      # @param [ Symbol ] name The name of the association.
+      # @param [ Hash ] opts The relation options.
+      # @param [ Block ] block The optional block.
+      #
+      # @since 7.0
+      def initialize(_class, name, opts = {}, &block)
+        @owner_class = _class
+        @name = name
+        @options = opts
+        @extension = nil
+        create_extension!(&block)
+        validate!
+      end
+
+      # Compare this association to another.
+      #
+      # @return [ Object ] The object to compare to this association.
+      #
+      # @since 7.0
+      def ==(other)
+        relation_class_name == other.relation_class_name &&
+          inverse_class_name == other.inverse_class_name &&
+            name == other.name &&
+              options == other.options
+      end
+
+      # Get the callbacks for a given type.
+      #
+      # @param [ Symbol ] callback_type The type of callback type.
+      #
+      # @return [ Array<Proc, Symbol> ] A list of the callbacks, either method
+      #   names or Procs.
+      #
+      # @since 7.0
+      def get_callbacks(callback_type)
+        Array(options[callback_type])
+      end
+
+      # Get the type setter.
+      # @note Only relevant for polymorphic relations that take the :as option.
+      #
+      # @return [ String ] The type setter method.
+      #
+      # @since 7.0
+      def type_setter
+        @type_setter ||= type.__setter__
+      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.
+      #
+      # @since 7.0
+      def bindable?(doc); false; end
+
+      # Get the inverse names.
+      #
+      # @param [ Object ] other The other model class or model object to use when
+      #   determining inverses.
+      #
+      # @return [ Array<Symbol> ] The list of inverse names.
+      #
+      # @since 7.0
+      def inverses(other = nil)
+        return [ inverse_of ] if inverse_of
+        if polymorphic?
+          polymorphic_inverses(other)
+        else
+          determine_inverses(other)
+        end
+      end
+
+      # Get the inverse's association metadata.
+      #
+      # @param [ Object ] other The other model class or model object to use when
+      #   determining inverses.
+      #
+      # @return [ Association ] The inverse's association metadata.
+      #
+      # @since 7.0
+      def inverse_association(other = nil)
+        (other || relation_class).relations[inverse(other)]
+      end
+
+      # Get the inverse type.
+      #
+      # @return [ nil ] Default is nil for an association.
+      #
+      # @since 7.0
+      def inverse_type; end
+
+      # The class name of the relation object(s).
+      #
+      # @return [ String ] The relation objects' class name.
+      #
+      # @since 7.0
+      def relation_class_name
+        @class_name ||= @options[:class_name] || ActiveSupport::Inflector.classify(name)
+      end
+      alias :class_name :relation_class_name
+
+      # The class of the relation object(s).
+      #
+      # @return [ String ] The relation objects' class.
+      #
+      # @since 7.0
+      def klass
+        @klass ||= relation_class_name.constantize
+      end
+      alias :relation_class :klass
+
+      # The class name of the object owning this relation.
+      #
+      # @return [ String ] The owning objects' class name.
+      #
+      # @since 7.0
+      def inverse_class_name
+        @inverse_class_name ||= @owner_class.name
+      end
+
+      # The class of the object owning this relation.
+      #
+      # @return [ String ] The owning objects' class.
+      #
+      # @since 7.0
+      def inverse_class
+        @owner_class
+      end
+      alias :inverse_klass :inverse_class
+
+      # The foreign key field if this relation stores a foreign key.
+      # Otherwise, the primary key.
+      #
+      # @return [ Symbol, String ] The primary key.
+      #
+      # @since 7.0
+      def key
+        stores_foreign_key? ? foreign_key : primary_key
+      end
+
+      # The name of the setter on this object for assigning an associated object.
+      #
+      # @return [ String ] The setter name.
+      #
+      # @since 7.0
+      def setter
+        @setter ||= "#{name}="
+      end
+
+      # The name of the inverse setter method.
+      #
+      # @return [ String ] The name of the inverse setter.
+      #
+      # @since 7.0
+      def inverse_setter(other = nil)
+        @inverse_setter ||= "#{inverses(other).first}=" unless inverses(other).blank?
+      end
+
+      # The name of the foreign key setter method.
+      #
+      # @return [ String ] The name of the foreign key setter.
+      #
+      # @since 7.0
+      def foreign_key_setter
+        # note: You can't check if this association stores foreign key
+        # See HasOne and HasMany binding, they referenced foreign_key_setter
+        @foreign_key_setter ||= "#{foreign_key}=" if foreign_key
+      end
+
+      # The atomic path for this relation.
+      #
+      # @return [  Mongoid::Atomic::Paths::Root ] The atomic path object.
+      #
+      # @since 7.0
+      def path(document)
+        relation.path(document)
+      end
+
+      # Gets the setter for the field that sets the type of document on a
+      # polymorphic relation.
+      #
+      # @example Get the inverse type setter.
+      #   association.inverse_type_setter
+      #
+      # @return [ String ] The name of the setter.
+      #
+      # @since 7.0
+      def inverse_type_setter
+        @inverse_type_setter ||= inverse_type.__setter__
+      end
+
+      # Get the name of the method to check if the foreign key has changed.
+      #
+      # @example Get the foreign key check method.
+      #   association.foreign_key_check
+      #
+      # @return [ String ] The foreign key check.
+      #
+      # @since 7.0
+      def foreign_key_check
+        @foreign_key_check ||= "#{foreign_key}_changed?" if (stores_foreign_key? && foreign_key)
+      end
+
+      # Create a relation proxy object using the owner and target.
+      #
+      # @param [ Document ] owner The document this relation hangs off of.
+      # @param [ Document, Array<Document> ] target The target (parent) of the
+      #   relation.
+      #
+      # @return [ Proxy ]
+      #
+      # @since 7.0
+      def create_relation(owner, target)
+        relation.new(owner, target, self)
+      end
+
+      # Whether the dependent method is destructive.
+      #
+      # @return [ true, false ] If the dependent method is destructive.
+      #
+      # @since 7.0
+      def destructive?
+        @destructive ||= !!(dependent && (dependent == :delete_all || dependent == :destroy))
+      end
+
+      # Get the counter cache column name.
+      #
+      # @return [ String ] The counter cache column name.
+      #
+      # @since 7.0
+      def counter_cache_column_name
+        @counter_cache_column_name ||= (@options[:counter_cache].is_a?(String) ||
+            @options[:counter_cache].is_a?(Symbol)) ?
+            @options[:counter_cache] : "#{inverse || inverse_class_name.demodulize.underscore.pluralize}_count"
+      end
+
+      # Get the extension.
+      #
+      # @return [ Module ] The extension module, if one has been defined.
+      #
+      # @since 7.0
+      def extension
+        @extension ||= @options[:extend]
+      end
+
+      # Get the inverse name.
+      #
+      # @return [ Symbol ] The inverse name.
+      #
+      # @since 7.0
+      def inverse(other = nil)
+        candidates = inverses(other)
+        candidates.detect { |c| c } if candidates
+      end
+
+      # Whether the associated object(s) should be validated.
+      #
+      # @return [ true, false ] If the associated object(s)
+      #   should be validated.
+      #
+      # @since 7.0
+      def validate?
+        @validate ||= if @options[:validate].nil?
+                        validation_default
+                      else
+                        !!@options[:validate]
+                      end
+      end
+
+      private
+
+      def setup_index!
+        @owner_class.index(index_spec, background: true) if indexed?
+      end
+
+      def define_touchable!
+        if touchable?
+          Association::Touchable.define_touchable!(self)
+        end
+      end
+
+      def define_autosaver!
+        if autosave?
+          Association::Referenced::AutoSave.define_autosave!(self)
+        end
+      end
+
+      def define_builder!
+        Association::Builders.define_builder!(self)
+      end
+
+      def define_creator!
+        Association::Builders.define_creator!(self)
+      end
+
+      def define_getter!
+        Association::Accessors.define_getter!(self)
+      end
+
+      def define_setter!
+        Association::Accessors.define_setter!(self)
+      end
+
+      def define_existence_check!
+        Association::Accessors.define_existence_check!(self)
+      end
+
+      def define_ids_getter!
+        Association::Accessors.define_ids_getter!(self)
+      end
+
+      def define_ids_setter!
+        Association::Accessors.define_ids_setter!(self)
+      end
+
+      def define_counter_cache_callbacks!
+        if counter_cached?
+          Association::Referenced::CounterCache.define_callbacks!(self)
+        end
+      end
+
+      def define_dependency!
+        if dependent
+          Association::Depending.define_dependency!(self)
+        end
+      end
+
+      def validate!
+        @options.keys.each do |opt|
+          unless self.class::VALID_OPTIONS.include?(opt)
+            raise Errors::InvalidRelationOption.new(@owner_class, name, opt, self.class::VALID_OPTIONS)
+          end
+        end
+
+        [name, "#{name}?".to_sym, "#{name}=".to_sym].each do |n|
+          if Mongoid.destructive_fields.include?(n)
+            raise Errors::InvalidRelation.new(@owner_class, n)
+          end
+        end
+      end
+
+      def polymorph!
+        if polymorphic?
+          @owner_class.polymorphic = true
+        end
+      end
+
+      def create_extension!(&block)
+        if block
+          extension_module_name = "#{@owner_class.to_s.demodulize}#{name.to_s.camelize}RelationExtension"
+          silence_warnings do
+            @owner_class.const_set(extension_module_name, Module.new(&block))
+          end
+          @extension = "#{@owner_class}::#{extension_module_name}".constantize
+        end
+      end
+
+      def default_inverse
+        @default_inverse ||= klass.relations[inverse_klass.name.underscore]
+      end
+    end
+  end
+end

data/lib/mongoid/association/touchable.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Touchable
+
+      module InstanceMethods
+
+        # Touch the document, in effect updating its updated_at timestamp and
+        # optionally the provided field to the current time. If any belongs_to
+        # relations exist with a touch option, they will be updated as well.
+        #
+        # @example Update the updated_at timestamp.
+        #   document.touch
+        #
+        # @example Update the updated_at and provided timestamps.
+        #   document.touch(:audited)
+        #
+        # @note This will not autobuild relations if those options are set.
+        #
+        # @param [ Symbol ] field The name of an additional field to update.
+        #
+        # @return [ true/false ] false if record is new_record otherwise true.
+        #
+        # @since 3.0.0
+        def touch(field = nil)
+          return false if _root.new_record?
+          current = Time.now
+          field = database_field_name(field)
+          write_attribute(:updated_at, current) if respond_to?("updated_at=")
+          write_attribute(field, current) if field
+
+          touches = touch_atomic_updates(field)
+          unless touches["$set"].blank?
+            selector = atomic_selector
+            _root.collection.find(selector).update_one(positionally(selector, touches), session: session)
+          end
+          run_callbacks(:touch)
+          true
+        end
+      end
+
+      extend self
+
+      # Add the association to the touchable relations if the touch option was
+      # provided.
+      #
+      # @example Add the touchable.
+      #   Model.define_touchable!(assoc)
+      #
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Class ] The model class.
+      #
+      # @since 3.0.0
+      def define_touchable!(association)
+        name = association.name
+        method_name = define_relation_touch_method(name, association)
+        association.inverse_class.tap do |klass|
+          klass.after_save method_name
+          klass.after_destroy method_name
+          klass.after_touch method_name
+        end
+      end
+
+      private
+
+      # Define the method that will get called for touching belongs_to
+      # relations.
+      #
+      # @api private
+      #
+      # @example Define the touch relation.
+      #   Model.define_relation_touch_method(:band)
+      #   Model.define_relation_touch_method(:band, :band_updated_at)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      # @param [ Association ] association The association metadata.
+      #
+      # @since 3.1.0
+      #
+      # @return [ Symbol ] The method name.
+      def define_relation_touch_method(name, association)
+        association.relation_class.send(:include, InstanceMethods)
+        method_name = "touch_#{name}_after_create_or_destroy"
+        association.inverse_class.class_eval <<-TOUCH, __FILE__, __LINE__ + 1
+            def #{method_name}
+              without_autobuild do
+                relation = __send__(:#{name})
+                relation.touch #{":#{association.touch_field}" if association.touch_field} if relation
+              end
+            end
+        TOUCH
+        method_name.to_sym
+      end
+    end
+  end
+end

data/lib/mongoid/association.rb

@@ -0,0 +1,150 @@
+require 'mongoid/association/accessors'
+require 'mongoid/association/builders'
+require 'mongoid/association/bindable'
+require 'mongoid/association/depending'
+require 'mongoid/association/proxy'
+require 'mongoid/association/touchable'
+
+require 'mongoid/association/many'
+require 'mongoid/association/one'
+require 'mongoid/association/relatable'
+require 'mongoid/association/nested'
+require 'mongoid/association/referenced'
+require 'mongoid/association/embedded'
+require 'mongoid/association/macros'
+
+require 'mongoid/association/reflections'
+require 'mongoid/association/eager_loadable'
+
+module Mongoid
+  module Association
+    extend ActiveSupport::Concern
+    include Embedded::Cyclic
+    include Referenced::AutoSave
+    include Referenced::CounterCache
+    include Referenced::Syncable
+    include Accessors
+    include Depending
+    include Builders
+    include Macros
+    include Reflections
+
+    # Map the macros to their corresponding Association classes.
+    #
+    # @return [ Hash ] The mapping from macros to their Association class.
+    #
+    # @since 7.0
+    MACRO_MAPPING = {
+        embeds_one: Association::Embedded::EmbedsOne,
+        embeds_many: Association::Embedded::EmbedsMany,
+        embedded_in: Association::Embedded::EmbeddedIn,
+        has_one: Association::Referenced::HasOne,
+        has_many: Association::Referenced::HasMany,
+        has_and_belongs_to_many: Association::Referenced::HasAndBelongsToMany,
+        belongs_to: Association::Referenced::BelongsTo,
+    }.freeze
+
+    attr_accessor :_association
+
+    included do
+      class_attribute :polymorphic
+      self.polymorphic = false
+    end
+
+    # Determine if the document itself is embedded in another document via the
+    # proper channels. (If it has a parent document.)
+    #
+    # @example Is the document embedded?
+    #   address.embedded?
+    #
+    # @return [ true, false ] True if the document has a parent document.
+    #
+    # @since 2.0.0.rc.1
+    def embedded?
+      @embedded ||= (cyclic ? _parent.present? : self.class.embedded?)
+    end
+
+    # Determine if the document is part of an embeds_many relation.
+    #
+    # @example Is the document in an embeds many?
+    #   address.embedded_many?
+    #
+    # @return [ true, false ] True if in an embeds many.
+    #
+    # @since 2.0.0.rc.1
+    def embedded_many?
+      _association && _association.is_a?(Association::Embedded::EmbedsMany)
+    end
+
+    # Determine if the document is part of an embeds_one relation.
+    #
+    # @example Is the document in an embeds one?
+    #   address.embedded_one?
+    #
+    # @return [ true, false ] True if in an embeds one.
+    #
+    # @since 2.0.0.rc.1
+    def embedded_one?
+      _association && _association.is_a?(Association::Embedded::EmbedsOne)
+    end
+
+    # Get the association name for this document. If no association was defined
+    #   an error will be raised.
+    #
+    # @example Get the association name.
+    #   document.association_name
+    #
+    # @raise [ Errors::NoMetadata ] If no association metadata is present.
+    #
+    # @return [ Symbol ] The association name.
+    #
+    # @since 3.0.0
+    def association_name
+      raise Errors::NoMetadata.new(self.class.name) unless _association
+      _association.name
+    end
+
+    # Determine if the document is part of an references_many relation.
+    #
+    # @example Is the document in a references many?
+    #   post.referenced_many?
+    #
+    # @return [ true, false ] True if in a references many.
+    #
+    # @since 2.0.0.rc.1
+    def referenced_many?
+      _association && _association.is_a?(Association::Referenced::HasMany)
+    end
+
+    # Determine if the document is part of an references_one relation.
+    #
+    # @example Is the document in a references one?
+    #   address.referenced_one?
+    #
+    # @return [ true, false ] True if in a references one.
+    #
+    # @since 2.0.0.rc.1
+    def referenced_one?
+      _association && _association.is_a?(Association::Referenced::HasOne)
+    end
+
+    # Convenience method for iterating through the loaded relations and
+    # reloading them.
+    #
+    # @example Reload the relations.
+    #   document.reload_relations
+    #
+    # @return [ Hash ] The association metadata.
+    #
+    # @since 2.1.6
+    def reload_relations
+      relations.each_pair do |name, meta|
+        if instance_variable_defined?("@_#{name}")
+          if _parent.nil? || instance_variable_get("@_#{name}") != _parent
+            remove_instance_variable("@_#{name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/atomic/paths/embedded/many.rb

@@ -35,7 +35,7 @@ module Mongoid
           def position
             pos = parent.atomic_position
             locator = document.new_record? ? "" : ".#{document._index}"
-            "#{pos}#{"." unless pos.blank?}#{document.__metadata.store_as}#{locator}"
+            "#{pos}#{"." unless pos.blank?}#{document._association.store_as}#{locator}"
           end
         end
       end

data/lib/mongoid/atomic/paths/embedded/one.rb

@@ -34,7 +34,7 @@ module Mongoid
           # @since 2.1.0
           def position
             pos = parent.atomic_position
-            "#{pos}#{"." unless pos.blank?}#{document.__metadata.store_as}"
+            "#{pos}#{"." unless pos.blank?}#{document._association.store_as}"
           end
         end
       end