mongoid 6.4.8 → 7.0.13

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

@@ -0,0 +1,121 @@
+module Mongoid
+  module Association
+    module Embedded
+      class EmbeddedIn
+
+        class Proxy < Association::One
+
+          # Instantiate a new embedded_in relation.
+          #
+          # @example Create the new relation.
+          #   Association::Embedded::EmbeddedIn.new(person, address, association)
+          #
+          # @param [ Document ] base The document the relation hangs off of.
+          # @param [ Document ] target The target (parent) of the relation.
+          # @param [ Association ] association The association metadata.
+          #
+          # @return [ In ] The proxy.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              characterize_one(_target)
+              bind_one
+            end
+          end
+
+          # Substitutes the supplied target documents for the existing document
+          # in the relation.
+          #
+          # @example Substitute the new document.
+          #   person.name.substitute(new_name)
+          #
+          # @param [ Document ] replacement A document to replace the target.
+          #
+          # @return [ Document, nil ] The relation or nil.
+          #
+          # @since 2.0.0.rc.1
+          def substitute(replacement)
+            unbind_one
+            unless replacement
+              _base.delete if persistable?
+              return nil
+            end
+            _base.new_record = true
+            self._target = replacement
+            bind_one
+            self
+          end
+
+          private
+
+          # Instantiate the binding associated with this relation.
+          #
+          # @example Get the binding.
+          #   binding([ address ])
+          #
+          # @return [ Binding ] A binding object.
+          #
+          # @since 2.0.0.rc.1
+          def binding
+            Binding.new(_base, _target, _association)
+          end
+
+          # Characterize the document.
+          #
+          # @example Set the base association.
+          #   object.characterize_one(document)
+          #
+          # @param [ Document ] document The document to set the association metadata on.
+          #
+          # @since 2.1.0
+          def characterize_one(document)
+            unless _base._association
+              _base._association = _association.inverse_association(document)
+            end
+          end
+
+          # Are we able to persist this relation?
+          #
+          # @example Can we persist the relation?
+          #   relation.persistable?
+          #
+          # @return [ true, false ] If the relation is persistable.
+          #
+          # @since 2.1.0
+          def persistable?
+            _target.persisted? && !_binding? && !_building?
+          end
+
+          class << self
+
+            # Returns true if the relation is an embedded one. In this case
+            # always true.
+            #
+            # @example Is this relation embedded?
+            #   Association::Embedded::EmbeddedIn.embedded?
+            #
+            # @return [ true ] true.
+            #
+            # @since 2.0.0.rc.1
+            def embedded?
+              true
+            end
+
+            # Get the path calculator for the supplied document.
+            #
+            # @example Get the path calculator.
+            #   Proxy.path(document)
+            #
+            # @param [ Document ] document The document to calculate on.
+            #
+            # @return [ Root ] The root atomic path calculator.
+            #
+            # @since 2.1.0
+            def path(document)
+              Mongoid::Atomic::Paths::Root.new(document)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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 = []