mongoid 6.4.8 → 7.0.13

data/lib/mongoid/association/nested/one.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Nested
+      class One
+        include Buildable
+
+        attr_accessor :destroy
+
+
+        # Builds the relation 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 relation, a replacement of the relation with a new
+        #   document, or a removal of the relation.
+        #
+        # @param [ Document ] parent The parent document.
+        #
+        # @return [ Document ] The built document.
+        #
+        # @since 2.0.0
+        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(@class_name, attributes))
+          elsif delete?
+            parent.send(association.setter, nil)
+          end
+        end
+
+        # Create the new builder for nested attributes on one-to-one
+        # relations.
+        #
+        # @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.
+        #
+        # @since 2.0.0
+        def initialize(association, attributes, options)
+          @attributes = attributes.with_indifferent_access
+          @association = association
+          @options = options
+          @class_name = options[:class_name] ? options[:class_name].constantize : association.klass
+          @destroy = @attributes.delete(:_destroy)
+        end
+
+        private
+
+        # Is the id in the attribtues acceptable for allowing an update to
+        # the existing relation?
+        #
+        # @api private
+        #
+        # @example Is the id acceptable?
+        #   one.acceptable_id?
+        #
+        # @return [ true, false ] If the id part of the logic will allow an update.
+        #
+        # @since 2.0.0
+        def acceptable_id?
+          id = convert_id(existing.class, attributes[:id])
+          existing._id == id || id.nil? || (existing._id != id && update_only?)
+        end
+
+        # Can the existing relation be deleted?
+        #
+        # @example Can the existing object be deleted?
+        #   one.delete?
+        #
+        # @return [ true, false ] If the relation should be deleted.
+        #
+        # @since 2.0.0
+        def delete?
+          destroyable? && !attributes[:id].nil?
+        end
+
+        # Can the existing relation potentially be destroyed?
+        #
+        # @example Is the object destroyable?
+        #   one.destroyable?({ :_destroy => "1" })
+        #
+        # @return [ true, false ] If the relation can potentially be
+        #   destroyed.
+        #
+        # @since 2.0.0
+        def destroyable?
+          Nested::DESTROY_FLAGS.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.
+        #
+        # @since 2.0.0
+        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.
+        #
+        # @since 2.0.0
+        def update?
+          existing && !destroyable? && acceptable_id?
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/nested.rb

@@ -0,0 +1,15 @@
+require 'mongoid/association/nested/nested_buildable'
+require 'mongoid/association/nested/many'
+require 'mongoid/association/nested/one'
+
+module Mongoid
+  module Association
+    module Nested
+
+      # The flags indicating that a relation can be destroyed.
+      #
+      # @since 7.0
+      DESTROY_FLAGS = [1, "1", true, "true"].freeze
+    end
+  end
+end

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

@@ -1,10 +1,10 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # This is the superclass for one to one relations and defines the common
     # behaviour or those proxies.
-    class One < Proxy
+    class One < Association::Proxy
 
       # Clear this relation - same as calling #delete on the document.
       #
@@ -15,7 +15,7 @@ module Mongoid
       #
       # @since 3.0.0
       def clear
-        target.delete
+        _target.delete
       end
 
       # Get all the documents in the relation that are loaded into memory.
@@ -27,7 +27,7 @@ module Mongoid
       #
       # @since 2.1.0
       def in_memory
-        [ target ]
+        [ _target ]
       end
 
       # Since method_missing is overridden we should override this as well.
@@ -41,7 +41,7 @@ module Mongoid
       #
       # @since 2.1.8
       def respond_to?(name, include_private = false)
-        target.respond_to?(name, include_private) || super
+        _target.respond_to?(name, include_private) || super
       end
 
       # Evolve the proxy document into an object id.
@@ -53,7 +53,7 @@ module Mongoid
       #
       # @since 4.0.0
       def __evolve_object_id__
-        target._id
+        _target._id
       end
     end
   end

data/lib/mongoid/association/options.rb

@@ -0,0 +1,152 @@
+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 relation.
+      #
+      # @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 relation cyclic.
+      #
+      # @return [ true, false ] Whether the relation is cyclic.
+      #
+      # @since 7.0
+      def cyclic?
+        !!@options[:cyclic]
+      end
+
+      # The name the owning object uses to refer to this relation.
+      #
+      # @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 relation 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,8 +1,8 @@
 # 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.
@@ -12,35 +12,47 @@ module Mongoid
       # 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 :foreign_key, :inverse_foreign_key, to: :_association
       delegate :bind_one, :unbind_one, to: :binding
-      delegate :collection_name, to: :base
+      delegate :collection_name, to: :_base
 
-      # 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,7 +60,7 @@ 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
@@ -57,7 +69,7 @@ module Mongoid
       #
       # @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
@@ -68,7 +80,7 @@ module Mongoid
       #
       # @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
@@ -81,7 +93,7 @@ module Mongoid
       #
       # @since 2.1.6
       def substitutable
-        target
+        _target
       end
 
       protected
@@ -95,20 +107,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 +130,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,7 +143,7 @@ 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!
@@ -146,30 +158,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,14 +170,11 @@ 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
@@ -198,16 +184,16 @@ module Mongoid
         # Apply ordering to the criteria if it was defined on the relation.
         #
         # @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,79 @@
+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 relations.
+        #   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