mongoid 6.4.4 → 7.1.7

data/lib/mongoid/association/options.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+
+    module Options
+
+      # Returns the name of the parent to a polymorphic child.
+      #
+      # @return [ String, Symbol ] The name.
+      #
+      # @since 7.0
+      def as
+        @options[:as]
+      end
+
+      # Specify what happens to the associated object when the owner is destroyed.
+      #
+      # @return [ String ] The dependent option.
+      #
+      # @since 7.0
+      def dependent
+        @options[:dependent]
+      end
+
+      # The custom sorting options on the association.
+      #
+      # @return [ Criteria::Queryable::Key ] The custom sorting options.
+      #
+      # @since 7.0
+      def order
+        @options[:order]
+      end
+
+      # Whether to index the primary or foreign key field.
+      #
+      # @return [ true, false ]
+      #
+      # @since 7.0
+      def indexed?
+        @indexed ||= !!@options[:index]
+      end
+
+      # Whether the association is autobuilding.
+      #
+      # @return [ true, false ]
+      #
+      # @since 7.0
+      def autobuilding?
+        !!@options[:autobuild]
+      end
+
+      # Is the association cyclic.
+      #
+      # @return [ true, false ] Whether the association is cyclic.
+      #
+      # @since 7.0
+      def cyclic?
+        !!@options[:cyclic]
+      end
+
+      # The name the owning object uses to refer to this association.
+      #
+      # @return [ String ] The inverse_of option.
+      #
+      # @since 7.0
+      def inverse_of
+        @options[:inverse_of]
+      end
+
+      # Mongoid assumes that the field used to hold the primary key of the association is id.
+      # You can override this and explicitly specify the primary key with the :primary_key option.
+      #
+      # @return [ Symbol, String ] The primary key.
+      #
+      # @since 7.0
+      def primary_key
+        @primary_key ||= @options[:primary_key] ? @options[:primary_key].to_s : Relatable::PRIMARY_KEY_DEFAULT
+      end
+
+      # Options to save any loaded members and destroy members that are marked for destruction
+      # when the parent object is saved.
+      #
+      # @return [ true, false ] The autosave option.
+      #
+      # @since 7.0
+      def autosave
+        !!@options[:autosave]
+      end
+      alias :autosave? :autosave
+
+      # Whether the association is counter-cached.
+      #
+      # @return [ true, false ]
+      #
+      # @since 7.0
+      def counter_cached?
+        !!@options[:counter_cache]
+      end
+
+      # Whether this association is polymorphic.
+      #
+      # @return [ true, false ] Whether the association is polymorphic.
+      #
+      # @since 7.0
+      def polymorphic?; false; end
+
+      # Whether the association has callbacks cascaded down from the parent.
+      #
+      # @return [ true, false ] Whether callbacks are cascaded.
+      #
+      # @since 7.0
+      def cascading_callbacks?
+        !!@options[:cascade_callbacks]
+      end
+
+      # The store_as option.
+      #
+      # @return [ nil ] Default is nil.
+      #
+      # @since 7.0
+      def store_as; end
+
+      # Whether the association has forced nil inverse (So no foreign keys are saved).
+      #
+      # @return [ false ] Default is false.
+      #
+      # @since 7.0
+      def forced_nil_inverse?; false; end
+
+      # The field for saving the associated object's type.
+      #
+      # @return [ nil ] Default is nil.
+      #
+      # @since 7.0
+      def type; end
+
+      # The field for saving the associated object's type.
+      #
+      # @return [ nil ] Default is nil.
+      #
+      # @since 7.0
+      def touch_field
+        @touch_field ||= options[:touch] if (options[:touch].is_a?(String) || options[:touch].is_a?(Symbol))
+      end
+
+      private
+
+      def touchable?
+        !!@options[:touch]
+      end
+    end
+  end
+end

data/lib/mongoid/{relations → association}/proxy.rb

@@ -1,46 +1,62 @@
+# frozen_string_literal: true
 # encoding: utf-8
-require "mongoid/relations/marshalable"
+
+require "mongoid/association/marshalable"
 
 module Mongoid
-  module Relations
+  module Association
 
-    # This class is the superclass for all relation proxy objects, and contains
-    # common behaviour for all of them.
+    # This class is the superclass for all association proxy objects, and contains
+    # common behavior for all of them.
     class Proxy
+      extend Forwardable
+
       alias :extend_proxy :extend
 
       # We undefine most methods to get them sent through to the target.
       instance_methods.each do |method|
         undef_method(method) unless
-          method =~ /^(__.*|send|object_id|equal\?|respond_to\?|tap|public_send|extend_proxy|extend_proxies)$/
+          method =~ /\A(__.*|send|object_id|equal\?|respond_to\?|tap|public_send|extend_proxy|extend_proxies)\z/
       end
 
       include Threaded::Lifecycle
       include Marshalable
 
-      attr_accessor :base, :__metadata, :target
-      alias :relation_metadata :__metadata
+      # Model instance for the base of the association.
+      #
+      # For example, if a Post embeds_many Comments, _base is a particular
+      # instance of the Post model.
+      attr_accessor :_base
+
+      attr_accessor :_association
+
+      # Model instance for one to one associations, or array of model instances
+      # for one to many associations, for the target of the association.
+      #
+      # For example, if a Post embeds_many Comments, _target is an array of
+      # Comment models embedded in a particular Post.
+      attr_accessor :_target
 
       # Backwards compatibility with Mongoid beta releases.
-      delegate :foreign_key, :inverse_foreign_key, to: :__metadata
-      delegate :bind_one, :unbind_one, to: :binding
-      delegate :collection_name, to: :base
+      def_delegators :_association, :foreign_key, :inverse_foreign_key
+      def_delegators :binding, :bind_one, :unbind_one
+      def_delegator :_base, :collection_name
 
-      # Convenience for setting the target and the metadata properties since
+      # Convenience for setting the target and the association metadata properties since
       # all proxies will need to do this.
       #
       # @example Initialize the proxy.
-      #   proxy.init(person, name, metadata)
+      #   proxy.init(person, name, association)
       #
       # @param [ Document ] base The base document on the proxy.
       # @param [ Document, Array<Document> ] target The target of the proxy.
-      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ Association ] association The association metadata.
       #
       # @since 2.0.0.rc.1
-      def init(base, target, metadata)
-        @base, @target, @__metadata = base, target, metadata
+      def init(base, target, association)
+        @_base, @_target, @_association = base, target, association
         yield(self) if block_given?
-        extend_proxies(metadata.extension) if metadata.extension?
+        extend_proxies(association.extension) if association.extension
       end
 
       # Allow extension to be an array and extend each module
@@ -48,30 +64,30 @@ module Mongoid
         extension.flatten.each {|ext| extend_proxy(ext) }
       end
 
-      # Get the class from the metadata, or return nil if no metadata present.
+      # Get the class from the association, or return nil if no association present.
       #
       # @example Get the class.
       #   proxy.klass
       #
-      # @return [ Class ] The relation class.
+      # @return [ Class ] The association class.
       #
       # @since 3.0.15
       def klass
-        __metadata ? __metadata.klass : nil
+        _association ? _association.klass : nil
       end
 
-      # Resets the criteria inside the relation proxy. Used by many to many
-      # relations to keep the underlying ids array in sync.
+      # Resets the criteria inside the association proxy. Used by many to many
+      # associations to keep the underlying ids array in sync.
       #
-      # @example Reset the relation criteria.
+      # @example Reset the association criteria.
       #   person.preferences.reset_relation_criteria
       #
       # @since 3.0.14
       def reset_unloaded
-        target.reset_unloaded(criteria)
+        _target.reset_unloaded(criteria)
       end
 
-      # The default substitutable object for a relation proxy is the clone of
+      # The default substitutable object for an association proxy is the clone of
       # the target.
       #
       # @example Get the substitutable.
@@ -81,7 +97,7 @@ module Mongoid
       #
       # @since 2.1.6
       def substitutable
-        target
+        _target
       end
 
       protected
@@ -95,20 +111,20 @@ module Mongoid
       #
       # @since 2.0.0
       def collection
-        root = base._root
+        root = _base._root
         root.collection unless root.embedded?
       end
 
-      # Takes the supplied document and sets the metadata on it.
+      # Takes the supplied document and sets the association on it.
       #
-      # @example Set the metadata.
+      # @example Set the association metadata.
       #   proxt.characterize_one(name)
       #
       # @param [ Document ] document The document to set on.
       #
       # @since 2.0.0.rc.4
       def characterize_one(document)
-        document.__metadata = __metadata unless document.__metadata
+        document._association = _association unless document._association
       end
 
       # Default behavior of method missing should be to delegate all calls
@@ -118,7 +134,7 @@ module Mongoid
       # @param [ Array ] args The arguments passed to the method.
       #
       def method_missing(name, *args, &block)
-        target.send(name, *args, &block)
+        _target.send(name, *args, &block)
       end
 
       # When the base document illegally references an embedded document this
@@ -131,11 +147,11 @@ module Mongoid
       #
       # @since 2.0.0
       def raise_mixed
-        raise Errors::MixedRelations.new(base.class, __metadata.klass)
+        raise Errors::MixedRelations.new(_base.class, _association.klass)
       end
 
       # When the base is not yet saved and the user calls create or create!
-      # on the relation, this error will get raised.
+      # on the association, this error will get raised.
       #
       # @example Raise the error.
       #   relation.raise_unsaved(post)
@@ -146,30 +162,7 @@ module Mongoid
       #
       # @since 2.0.0.rc.6
       def raise_unsaved(doc)
-        raise Errors::UnsavedDocument.new(base, doc)
-      end
-
-      # Return the name of defined callback method
-      #
-      # @example returns the before_add callback method name
-      #   callback_method(:before_add)
-      #
-      # @param [ Symbol ] callback_name Which callback
-      #
-      # @return [ Array ] with callback methods to be executed, the array may have symbols and Procs
-      #
-      # @since 3.1.0
-      def callback_method(callback_name)
-        methods = []
-        metadata = __metadata[callback_name]
-        if metadata
-          if metadata.is_a?(Array)
-            methods.concat(metadata)
-          else
-            methods << metadata
-          end
-        end
-        methods
+        raise Errors::UnsavedDocument.new(_base, doc)
       end
 
       # Executes a callback method
@@ -181,33 +174,30 @@ module Mongoid
       #
       # @since 3.1.0
       def execute_callback(callback, doc)
-        callback_method = callback_method(callback)
-        if callback_method
-          callback_method.each do |c|
-            if c.is_a? Proc
-              c.call(base, doc)
-            else
-              base.send c, doc
-            end
+        _association.get_callbacks(callback).each do |c|
+          if c.is_a? Proc
+            c.call(_base, doc)
+          else
+            _base.send c, doc
           end
         end
       end
 
       class << self
 
-        # Apply ordering to the criteria if it was defined on the relation.
+        # Apply ordering to the criteria if it was defined on the association.
         #
         # @example Apply the ordering.
-        #   Proxy.apply_ordering(criteria, metadata)
+        #   Proxy.apply_ordering(criteria, association)
         #
         # @param [ Criteria ] criteria The criteria to modify.
-        # @param [ Metadata ] metadata The relation metadata.
+        # @param [ Association ] association The association metadata.
         #
         # @return [ Criteria ] The ordered criteria.
         #
         # @since 3.0.6
-        def apply_ordering(criteria, metadata)
-          metadata.order ? criteria.order_by(metadata.order) : criteria
+        def apply_ordering(criteria, association)
+          association.order ? criteria.order_by(association.order) : criteria
         end
       end
     end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+    module Referenced
+
+      module AutoSave
+        extend ActiveSupport::Concern
+
+        # Used to prevent infinite loops in associated autosaves.
+        #
+        # @example Is the document autosaved?
+        #   document.autosaved?
+        #
+        # @return [ true, false ] Has the document already been autosaved?
+        #
+        # @since 3.0.0
+        def autosaved?
+          Threaded.autosaved?(self)
+        end
+
+        # Begin the associated autosave.
+        #
+        # @example Begin autosave.
+        #   document.__autosaving__
+        #
+        # @since 3.1.3
+        def __autosaving__
+          Threaded.begin_autosave(self)
+          yield
+        ensure
+          Threaded.exit_autosave(self)
+        end
+
+        # Check if there is changes for auto-saving
+        #
+        # @example Return true if there is changes on self or in
+        #           autosaved associations.
+        #   document.changed_for_autosave?
+        #
+        # @since 3.1.3
+        def changed_for_autosave?(doc)
+          doc.new_record? || doc.changed? || doc.marked_for_destruction?
+        end
+
+        # Define the autosave method on an association's owning class for
+        # an associated object.
+        #
+        # @example Define the autosave method:
+        #   Association::Referenced::Autosave.define_autosave!(association)
+        #
+        # @param [ Association ] association The association for which autosaving is enabled.
+        #
+        # @return [ Class ] The association's owner class.
+        #
+        # @since 7.0
+        def self.define_autosave!(association)
+          association.inverse_class.tap do |klass|
+            save_method = :"autosave_documents_for_#{association.name}"
+            klass.send(:define_method, save_method) do
+              if before_callback_halted?
+                self.before_callback_halted = false
+              else
+                __autosaving__ do
+                  if relation = ivar(association.name)
+                    Array(relation).each do |doc|
+                      doc.with(persistence_context) do |d|
+                        d.save
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            klass.after_save save_method, unless: :autosaved?
+          end
+        end
+      end
+    end
+  end
+end