mongoid 6.4.8 → 7.0.0.beta

data/lib/mongoid/{relations/binding.rb → association/bindable.rb}

@@ -1,25 +1,25 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # Superclass for all objects that bind relations together.
-    class Binding
+    module Bindable
       include Threaded::Lifecycle
 
-      attr_reader :base, :target, :metadata
+      attr_reader :_base, :_target, :_association
 
       # Create the new binding.
       #
       # @example Initialize a binding.
-      #   Binding.new(base, target, metadata)
+      #   Binding.new(base, target, association)
       #
       # @param [ Document ] base The base of the binding.
       # @param [ Document, Array<Document> ] target The target of the binding.
-      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ Association ] association The association metadata.
       #
       # @since 2.0.0.rc.1
-      def initialize(base, target, metadata)
-        @base, @target, @metadata = base, target, metadata
+      def initialize(base, target, association)
+        @_base, @_target, @_association = base, target, association
       end
 
       # Execute the provided block inside a binding.
@@ -55,32 +55,12 @@ module Mongoid
       #
       # @since 3.0.0
       def check_inverse!(doc)
-        if !metadata.forced_nil_inverse? &&
-          !doc.respond_to?(metadata.foreign_key_setter)
+        unless _association.bindable?(doc)
           raise Errors::InverseNotFound.new(
-            base.class,
-            metadata.name,
-            doc.class,
-            metadata.foreign_key
-          )
-        end
-      end
-
-      # 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.
-      #
-      # @since 3.0.0
-      def check_inverses!(doc)
-        inverses = metadata.inverses(doc)
-        if inverses.count > 1 && base.send(metadata.foreign_key).nil?
-          raise Errors::InvalidSetPolymorphicRelation.new(
-            metadata.name, base.class.name, target.class.name
+              _base.class,
+              _association.name,
+              doc.class,
+              _association.foreign_key
           )
         end
       end
@@ -99,7 +79,7 @@ module Mongoid
       # @since 3.0.0
       def bind_foreign_key(keyed, id)
         unless keyed.frozen?
-          keyed.you_must(metadata.foreign_key_setter, id)
+          keyed.you_must(_association.foreign_key_setter, id)
         end
       end
 
@@ -116,8 +96,8 @@ module Mongoid
       #
       # @since 3.0.0
       def bind_polymorphic_type(typed, name)
-        if metadata.type
-          typed.you_must(metadata.type_setter, name)
+        if _association.type
+          typed.you_must(_association.type_setter, name)
         end
       end
 
@@ -134,8 +114,8 @@ module Mongoid
       #
       # @since 3.0.0
       def bind_polymorphic_inverse_type(typed, name)
-        if metadata.inverse_type
-          typed.you_must(metadata.inverse_type_setter, name)
+        if _association.inverse_type
+          typed.you_must(_association.inverse_type_setter, name)
         end
       end
 
@@ -152,8 +132,8 @@ module Mongoid
       #
       # @since 3.0.0
       def bind_inverse(doc, inverse)
-        if doc.respond_to?(metadata.inverse_setter)
-          doc.you_must(metadata.inverse_setter, inverse)
+        if doc.respond_to?(_association.inverse_setter)
+          doc.you_must(_association.inverse_setter, inverse)
         end
       end
 
@@ -169,31 +149,31 @@ module Mongoid
       # @since 3.0.0
       def bind_from_relational_parent(doc)
         check_inverse!(doc)
-        bind_foreign_key(doc, record_id(base))
-        bind_polymorphic_type(doc, base.class.name)
-        bind_inverse(doc, base)
+        bind_foreign_key(doc, record_id(_base))
+        bind_polymorphic_type(doc, _base.class.name)
+        bind_inverse(doc, _base)
       end
 
-      def record_id(base)
-        base.__send__(metadata.primary_key)
+      def record_id(_base)
+        _base.__send__(_association.primary_key)
       end
 
-      # Ensure that the metadata on the base is correct, for the cases
+      # Ensure that the association on the base is correct, for the cases
       # where we have multiple belongs to definitions and were are setting
       # different parents in memory in order.
       #
       # @api private
       #
-      # @example Set the base metadata.
-      #   binding.set_base_metadata
+      # @example Set the base association.
+      #   binding.set_base_association
       #
-      # @return [ true, false ] If the metadata changed.
+      # @return [ true, false ] If the association changed.
       #
       # @since 2.4.4
-      def set_base_metadata
-        inverse_metadata = metadata.inverse_metadata(target)
-        if inverse_metadata != metadata && !inverse_metadata.nil?
-          base.__metadata = inverse_metadata
+      def set_base_association
+        inverse_association = _association.inverse_association(_target)
+        if inverse_association != _association && !inverse_association.nil?
+          _base._association = inverse_association
         end
       end
 

data/lib/mongoid/association/builders.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module Mongoid
+  module Association
+
+    # This module is responsible for defining the build and create methods used
+    # in one to one relations.
+    #
+    # @example Methods that get created.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #   end
+    #
+    #   # The following methods get created:
+    #   person.build_name({ :first_name => "Durran" })
+    #   person.create_name({ :first_name => "Durran" })
+    #
+    # @since 2.0.0.rc.1
+    module Builders
+      extend ActiveSupport::Concern
+
+      private
+
+      # Parse out the attributes and the options from the args passed to a
+      # build_ or create_ methods.
+      #
+      # @example Parse the args.
+      #   doc.parse_args(:name => "Joe")
+      #
+      # @param [ Array ] args The arguments.
+      #
+      # @return [ Array<Hash> ] The attributes and options.
+      #
+      # @since 2.3.4
+      def parse_args(*args)
+        [ args.first || {}, args.size > 1 ? args[1] : {} ]
+      end
+
+      # Defines a builder method. This is defined as #build_name.
+      #
+      # @example
+      #   Person.define_builder!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_builder!(association)
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("build_#{association.name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.relation_class, attributes)
+            _building do
+              child = send("#{association.name}=", document)
+              child.run_callbacks(:build)
+              child
+            end
+          end
+        end
+      end
+
+      # Defines a creator method. This is defined as #create_name.
+      # After the object is built it will immediately save.
+      #
+      # @example
+      #   Person.define_creator!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_creator!(association)
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("create_#{association.name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.relation_class, attributes)
+            doc = _assigning do
+              send("#{association.name}=", document)
+            end
+            doc.save
+            save if new_record? && association.stores_foreign_key?
+            doc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations/constraint.rb → association/constrainable.rb}

@@ -1,26 +1,11 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # Used for converting foreign key values to the correct type based on the
     # types of ids that the document stores.
     #
-    # @note Durran: The name of this class is this way to match the metadata
-    #   getter, and foreign_key was already taken there.
-    class Constraint
-      attr_reader :metadata
-
-      # Create the new constraint with the metadata.
-      #
-      # @example Instantiate the constraint.
-      #   Constraint.new(metdata)
-      #
-      # @param [ Metadata ] metadata The metadata of the relation.
-      #
-      # @since 2.0.0.rc.7
-      def initialize(metadata)
-        @metadata = metadata
-      end
+    module Constrainable
 
       # Convert the supplied object to the appropriate type to set as the
       # foreign key for a relation.
@@ -33,10 +18,10 @@ module Mongoid
       # @return [ Object ] The object cast to the correct type.
       #
       # @since 2.0.0.rc.7
-      def convert(object)
-        return convert_polymorphic(object) if metadata.polymorphic?
-        klass, field = metadata.klass, metadata.klass.fields["_id"]
-        if klass.using_object_ids?
+      def convert_to_foreign_key(object)
+        return convert_polymorphic(object) if polymorphic?
+        field = relation_class.fields["_id"]
+        if relation_class.using_object_ids?
           BSON::ObjectId.mongoize(object)
         elsif object.is_a?(::Array)
           object.map!{ |obj| field.mongoize(obj) }
@@ -48,7 +33,11 @@ module Mongoid
       private
       
       def convert_polymorphic(object)
-        object.respond_to?(:id) ? object.id : object
+        if object.is_a?(Mongoid::Document)
+          object.id
+        else
+          BSON::ObjectId.mongoize(object)
+        end
       end
     end
   end

data/lib/mongoid/association/depending.rb

@@ -0,0 +1,116 @@
+module Mongoid
+  module Association
+
+    # This module defines the behaviour for setting up cascading deletes and
+    # nullifies for relations, and how to delegate to the appropriate strategy.
+    module Depending
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :dependents
+        self.dependents = []
+      end
+
+      # The valid dependent strategies.
+      #
+      # @since 7.0
+      STRATEGIES = [
+          :delete_all,
+          :destroy,
+          :nullify,
+          :restrict_with_exception,
+          :restrict_with_error
+      ]
+
+      # The error message when a strategy cannot delete objects because there are associated objects.
+      #
+      # @since 7.0
+      RESTRICT_ERROR_MSG = 'Cannot delete record because associated objects exist.'.freeze
+
+      # Attempt to add the cascading information for the document to know how
+      # to handle associated documents on a removal.
+      #
+      # @example Set up cascading information
+      #   Mongoid::Association::Depending.define_dependency!(association)
+      #
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Class ] The class of the document.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_dependency!(association)
+        validate!(association)
+        association.inverse_class.tap do |klass|
+          if association.dependent && !klass.dependents.include?(association)
+            klass.dependents.push(association)
+          end
+        end
+      end
+
+      def self.validate!(association)
+        unless STRATEGIES.include?(association.dependent)
+          raise Errors::InvalidDependentStrategy.new(association,
+                                                     association.dependent,
+                                                     STRATEGIES)
+        end
+      end
+
+      # Perform all cascading deletes, destroys, or nullifies. Will delegate to
+      # the appropriate strategy to perform the operation.
+      #
+      # @example Execute cascades.
+      #   document.apply_delete_dependencies!
+      #
+      # @since 2.0.0.rc.1
+      def apply_delete_dependencies!
+        dependents.each do |association|
+          if association.try(:dependent)
+            send("_dependent_#{association.dependent}!", association)
+          end
+        end
+      end
+
+      private
+
+      def _dependent_delete_all!(association)
+        if relation = send(association.name)
+          if relation.respond_to?(:dependents) && relation.dependents.blank?
+            relation.clear
+          else
+            ::Array.wrap(send(association.name)).each { |rel| rel.delete }
+          end
+        end
+      end
+
+      def _dependent_destroy!(association)
+        if relation = send(association.name)
+          if relation.is_a?(Enumerable)
+            relation.entries
+            relation.each { |doc| doc.destroy }
+          else
+            relation.destroy
+          end
+        end
+      end
+
+      def _dependent_nullify!(association)
+        if relation = send(association.name)
+          relation.nullify
+        end
+      end
+
+      def _dependent_restrict_with_exception!(association)
+        if (relation = send(association.name)) && !relation.blank?
+          raise Errors::DeleteRestriction.new(relation, association.name)
+        end
+      end
+
+      def _dependent_restrict_with_error!(association)
+        if (relation = send(association.name)) && !relation.blank?
+          errors.add(association.name, RESTRICT_ERROR_MSG)
+          throw(:abort, false)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations/eager.rb → association/eager_loadable.rb}

@@ -1,13 +1,13 @@
 # encoding: utf-8
-require "mongoid/relations/eager/base"
-require "mongoid/relations/eager/belongs_to"
-require "mongoid/relations/eager/has_one"
-require "mongoid/relations/eager/has_many"
-require "mongoid/relations/eager/has_and_belongs_to_many"
+require "mongoid/association/referenced/eager"
 
 module Mongoid
-  module Relations
-    module Eager
+  module Association
+
+    # This module defines the eager loading behavior for criteria.
+    #
+    # @since 7.0
+    module EagerLoadable
 
       def eager_loadable?
         !criteria.inclusions.empty?
@@ -23,11 +23,11 @@ module Mongoid
 
       def preload(relations, docs)
         relations.group_by(&:inverse_class_name)
-                 .values
-                 .each do |associations|
+            .values
+            .each do |associations|
           associations.group_by(&:relation)
-                      .each do |relation, association|
-            relation.eager_load_klass.new(association, docs).run
+              .each do |relation, association|
+            relation.eager_loader(association, docs).run
           end
         end
       end