mongoid 6.4.2 → 7.0.3

data/lib/mongoid/association/embedded/embedded_in.rb

@@ -0,0 +1,154 @@
+require 'mongoid/association/embedded/embedded_in/binding'
+require 'mongoid/association/embedded/embedded_in/buildable'
+require 'mongoid/association/embedded/embedded_in/proxy'
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # The EmbeddedIn type association.
+      #
+      # @since 7.0
+      class EmbeddedIn
+        include Relatable
+        include Buildable
+
+        # The options available for this type of association, in addition to the
+        # common ones.
+        #
+        # @return [ Array<Symbol> ] The extra valid options.
+        #
+        # @since 7.0
+        ASSOCIATION_OPTIONS = [
+            :autobuild,
+            :cyclic,
+            :polymorphic,
+            :touch
+        ].freeze
+
+        # The complete list of valid options for this association, including
+        # the shared ones.
+        #
+        # @return [ Array<Symbol> ] The valid options.
+        #
+        # @since 7.0
+        VALID_OPTIONS = (ASSOCIATION_OPTIONS + SHARED_OPTIONS).freeze
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        #
+        # @since 7.0
+        def setup!
+          setup_instance_methods!
+          @owner_class.embedded = true
+          self
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 7.0
+        def embedded?; true; end
+
+        # The primary key
+        #
+        # @return [ nil ] Not relevant for this relation
+        def primary_key; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def stores_foreign_key?; false; end
+
+        # The default for validating the association object.
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def validation_default; false; end
+
+        # The key that is used to get the attributes for the associated object.
+        #
+        # @return [ String ] The name of the relation.
+        #
+        # @since 7.0
+        def key
+          @key ||= name.to_s
+        end
+
+        # Get the relation proxy class for this association type.
+        #
+        # @return [ Association::Embedded::EmbeddedIn::Proxy ] The proxy class.
+        #
+        # @since 7.0
+        def relation
+          Proxy
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true, false ] Whether this association is polymorphic.
+        #
+        # @since 7.0
+        def polymorphic?
+          !!@options[:polymorphic]
+        end
+
+        # The nested builder object.
+        #
+        # @param [ Hash ] attributes The attributes to use to build the association object.
+        # @param [ Hash ] options The options for the association.
+        #
+        # @return [ Association::Nested::One ] The Nested Builder object.
+        #
+        # @since 7.0
+        def nested_builder(attributes, options)
+          Nested::One.new(self, attributes, options)
+        end
+
+        private
+
+        def setup_instance_methods!
+          define_getter!
+          define_setter!
+          define_existence_check!
+          define_builder!
+          define_creator!
+          define_counter_cache_callbacks!
+          define_touchable!
+        end
+
+        def relation_complements
+          @relation_complements ||= [ Embedded::EmbedsMany,
+                                      Embedded::EmbedsOne ].freeze
+        end
+
+        def polymorphic_inverses(other = nil)
+          if other
+            matches = other.relations.values.select do |rel|
+              relation_complements.include?(rel.class) &&
+                  rel.as == name &&
+                  rel.relation_class_name == inverse_class_name
+            end
+            matches.collect { |m| m.name }
+          end
+        end
+
+        def determine_inverses(other)
+          matches = (other || relation_class).relations.values.select do |rel|
+            relation_complements.include?(rel.class) &&
+                rel.relation_class_name == inverse_class_name
+          end
+          if matches.size > 1
+            raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches)
+          end
+          matches.collect { |m| m.name } unless matches.blank?
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations/bindings/embedded/many.rb → association/embedded/embeds_many/binding.rb}

@@ -1,11 +1,13 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Bindings
-      module Embedded
+  module Association
+    module Embedded
+      class EmbedsMany
 
-        # Binding class for embeds_many relations.
-        class Many < Binding
+        # Binding class for all embeds_many relations.
+        #
+        # @since 7.0
+        class Binding
+          include Bindable
 
           # Binds a single document with the inverse relation. Used
           # specifically when appending to the proxy.
@@ -17,9 +19,9 @@ module Mongoid
           #
           # @since 2.0.0.rc.1
           def bind_one(doc)
-            doc.parentize(base)
+            doc.parentize(_base)
             binding do
-              doc.do_or_do_not(metadata.inverse_setter(target), base)
+              doc.do_or_do_not(_association.inverse_setter(_target), _base)
             end
           end
 
@@ -33,7 +35,7 @@ module Mongoid
           # @since 2.0.0.rc.1
           def unbind_one(doc)
             binding do
-              doc.do_or_do_not(metadata.inverse_setter(target), nil)
+              doc.do_or_do_not(_association.inverse_setter(_target), nil)
             end
           end
         end

data/lib/mongoid/{relations/builders/embedded/many.rb → association/embedded/embeds_many/buildable.rb}

@@ -1,22 +1,28 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Builders
-      module Embedded
-        class Many < Builder
+  module Association
+    module Embedded
+      class EmbedsMany
+
+        # Builder class for embeds_many associations.
+        #
+        # @since 7.0
+        module Buildable
+          include Threaded::Lifecycle
 
           # Builds the document out of the attributes using the provided
-          # metadata on the relation. Instantiates through the factory in order
+          # association metadata. Instantiates through the factory in order
           # to make sure subclasses and allocation are used if fitting. This
           # case will return many documents.
           #
           # @example Build the documents.
           #   Builder.new(meta, attrs).build
           #
+          # @param [ Object ] base The base object.
+          # @param [ Object ] object The object to use to build the relation.
           # @param [ String ] type Not used in this context.
           #
           # @return [ Array<Document ] The documents.
-          def build(type = nil)
+          def build(base, object, type = nil)
             return [] if object.blank?
             return object if object.first.is_a?(Document)
             docs = []