mongoid 5.4.1 → 7.4.0

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Nested
+      class One
+        include Buildable
+
+        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(@class_name, 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
+          @class_name = options[:class_name] ? options[:class_name].constantize : association.klass
+          @destroy = @attributes.delete(:_destroy)
+        end
+
+        private
+
+        # Is the id in the attributes 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 = association.klass.extract_id_field(attributes)
+          id = convert_id(existing.class, 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?
+          id = association.klass.extract_id_field(attributes)
+          destroyable? && !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?
+          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.
+        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

data/lib/mongoid/association/nested.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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 an association can be destroyed.
+      DESTROY_FLAGS = [1, "1", true, "true"].freeze
+    end
+  end
+end

data/lib/mongoid/association/one.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+
+    # This is the superclass for one to one relations and defines the common
+    # behavior or those proxies.
+    class One < Association::Proxy
+
+      # Clear this relation - same as calling #delete on the document.
+      #
+      # @example Clear the relation.
+      #   relation.clear
+      #
+      # @return [ true, false ] If the delete succeeded.
+      def clear
+        _target.delete
+      end
+
+      # Get all the documents in the relation that are loaded into memory.
+      #
+      # @example Get the in memory documents.
+      #   relation.in_memory
+      #
+      # @return [ Array<Document> ] The documents in memory.
+      def in_memory
+        [ _target ]
+      end
+
+      # Since method_missing is overridden we should override this as well.
+      #
+      # @example Does the proxy respond to the method?
+      #   relation.respond_to?(:name)
+      #
+      # @param [ Symbol ] name The method name.
+      #
+      # @return [ true, false ] If the proxy responds to the method.
+      def respond_to?(name, include_private = false)
+        _target.respond_to?(name, include_private) || super
+      end
+
+      # Evolve the proxy document into an object id.
+      #
+      # @example Evolve the proxy document.
+      #   proxy.__evolve_object_id__
+      #
+      # @return [ Object ] The proxy document's id.
+      def __evolve_object_id__
+        _target._id
+      end
+    end
+  end
+end

data/lib/mongoid/association/options.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+
+    module Options
+
+      # Returns the name of the parent to a polymorphic child.
+      #
+      # @return [ String, Symbol ] The name.
+      def as
+        @options[:as]
+      end
+
+      # Specify what happens to the associated object when the owner is destroyed.
+      #
+      # @return [ String ] The dependent option.
+      def dependent
+        @options[:dependent]
+      end
+
+      # The custom sorting options on the association.
+      #
+      # @return [ Criteria::Queryable::Key ] The custom sorting options.
+      def order
+        @options[:order]
+      end
+
+      # Whether to index the primary or foreign key field.
+      #
+      # @return [ true, false ]
+      def indexed?
+        @indexed ||= !!@options[:index]
+      end
+
+      # Whether the association is autobuilding.
+      #
+      # @return [ true, false ]
+      def autobuilding?
+        !!@options[:autobuild]
+      end
+
+      # Is the association cyclic.
+      #
+      # @return [ true, false ] Whether the association is cyclic.
+      def cyclic?
+        !!@options[:cyclic]
+      end
+
+      # The name the owning object uses to refer to this association.
+      #
+      # @return [ String ] The inverse_of option.
+      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.
+      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.
+      def autosave
+        !!@options[:autosave]
+      end
+      alias :autosave? :autosave
+
+      # Whether the association is counter-cached.
+      #
+      # @return [ true, false ]
+      def counter_cached?
+        !!@options[:counter_cache]
+      end
+
+      # Whether this association is polymorphic.
+      #
+      # @return [ true, false ] Whether the association is polymorphic.
+      def polymorphic?; false; end
+
+      # Whether the association has callbacks cascaded down from the parent.
+      #
+      # @return [ true, false ] Whether callbacks are cascaded.
+      def cascading_callbacks?
+        !!@options[:cascade_callbacks]
+      end
+
+      # The store_as option.
+      #
+      # @return [ nil ] Default is nil.
+      def store_as; end
+
+      # Whether the association has forced nil inverse (So no foreign keys are saved).
+      #
+      # @return [ false ] Default is false.
+      def forced_nil_inverse?; false; end
+
+      # The field for saving the associated object's type.
+      #
+      # @return [ nil ] Default is nil.
+      def type; end
+
+      # The field for saving the associated object's type.
+      #
+      # @return [ nil ] Default is nil.
+      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/association/proxy.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "mongoid/association/marshalable"
+
+module Mongoid
+  module Association
+
+    # 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 =~ /\A(?:__.*|send|object_id|equal\?|respond_to\?|respond_to_missing\?|tap|public_send|extend_proxy|extend_proxies)\z/
+      end
+
+      include Threaded::Lifecycle
+      include Marshalable
+
+      # 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.
+      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 association metadata properties since
+      # all proxies will need to do this.
+      #
+      # @example Initialize the proxy.
+      #   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 [ Association ] association The association metadata.
+      def init(base, target, association)
+        @_base, @_target, @_association = base, target, association
+        yield(self) if block_given?
+        extend_proxies(association.extension) if association.extension
+      end
+
+      # Allow extension to be an array and extend each module
+      def extend_proxies(*extension)
+        extension.flatten.each {|ext| extend_proxy(ext) }
+      end
+
+      # Get the class from the association, or return nil if no association present.
+      #
+      # @example Get the class.
+      #   proxy.klass
+      #
+      # @return [ Class ] The association class.
+      def klass
+        _association ? _association.klass : nil
+      end
+
+      # Resets the criteria inside the association proxy. Used by many to many
+      # associations to keep the underlying ids array in sync.
+      #
+      # @example Reset the association criteria.
+      #   person.preferences.reset_relation_criteria
+      def reset_unloaded
+        _target.reset_unloaded(criteria)
+      end
+
+      # The default substitutable object for an association proxy is the clone of
+      # the target.
+      #
+      # @example Get the substitutable.
+      #   proxy.substitutable
+      #
+      # @return [ Object ] A clone of the target.
+      def substitutable
+        _target
+      end
+
+      protected
+
+      # Get the collection from the root of the hierarchy.
+      #
+      # @example Get the collection.
+      #   relation.collection
+      #
+      # @return [ Collection ] The root's collection.
+      def collection
+        root = _base._root
+        root.collection unless root.embedded?
+      end
+
+      # Takes the supplied document and sets the association on it.
+      #
+      # @example Set the association metadata.
+      #   proxt.characterize_one(name)
+      #
+      # @param [ Document ] document The document to set on.
+      def characterize_one(document)
+        document._association = _association unless document._association
+      end
+
+      # Default behavior of method missing should be to delegate all calls
+      # to the target of the proxy. This can be overridden in special cases.
+      #
+      # @param [ String, Symbol ] name The name of the method.
+      # @param [ Array ] args The arguments passed to the method.
+      #
+      ruby2_keywords def method_missing(name, *args, &block)
+        _target.send(name, *args, &block)
+      end
+
+      # @api private
+      ruby2_keywords def respond_to_missing?(name, *args)
+        _target.respond_to?(name, *args)
+      end
+
+      # When the base document illegally references an embedded document this
+      # error will get raised.
+      #
+      # @example Raise the error.
+      #   relation.raise_mixed
+      #
+      # @raise [ Errors::MixedRelations ] The error.
+      def raise_mixed
+        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 association, this error will get raised.
+      #
+      # @example Raise the error.
+      #   relation.raise_unsaved(post)
+      #
+      # @param [ Document ] doc The child document getting created.
+      #
+      # @raise [ Errors::UnsavedDocument ] The error.
+      def raise_unsaved(doc)
+        raise Errors::UnsavedDocument.new(_base, doc)
+      end
+
+      # Executes a callback method
+      #
+      # @example execute the before add callback
+      #   execute_callback(:before_add)
+      #
+      # @param [ Symbol ] callback to be executed
+      def execute_callback(callback, doc)
+        _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 association.
+        #
+        # @example Apply the ordering.
+        #   Proxy.apply_ordering(criteria, association)
+        #
+        # @param [ Criteria ] criteria The criteria to modify.
+        # @param [ Association ] association The association metadata.
+        #
+        # @return [ Criteria ] The ordered criteria.
+        def apply_ordering(criteria, association)
+          association.order ? criteria.order_by(association.order) : criteria
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+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?
+        def autosaved?
+          Threaded.autosaved?(self)
+        end
+
+        # Begin the associated autosave.
+        #
+        # @example Begin autosave.
+        #   document.__autosaving__
+        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?
+        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.
+        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 assoc_value = ivar(association.name)
+                    Array(assoc_value).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

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