mongoid 6.4.8 → 7.0.0.beta

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

@@ -0,0 +1,173 @@
+require 'mongoid/association/embedded/embeds_one/binding'
+require 'mongoid/association/embedded/embeds_one/buildable'
+require 'mongoid/association/embedded/embeds_one/proxy'
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # The EmbedsOne type association.
+      #
+      # @since 7.0
+      class EmbedsOne
+        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,
+            :as,
+            :cascade_callbacks,
+            :cyclic,
+            :store_as
+        ]
+
+        # 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_relations = @owner_class.embedded_relations.merge(name => self)
+          @owner_class.aliased_fields[name.to_s] = store_as if store_as
+          self
+        end
+
+        # The field key used to store the association object.
+        #
+        # @return [ String ] The field name.
+        #
+        # @since 7.0
+        def store_as
+          @store_as ||= (@options[:store_as].try(:to_s) || name.to_s)
+        end
+
+        # The key that is used to get the attributes for the associated object.
+        #
+        # @return [ String ] The name of the field used to store the relation.
+        #
+        # @since 7.0
+        def key
+          store_as.to_s
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 7.0
+        def embedded?; true; end
+
+        # Get the default validation setting for the relation. Determines if
+        # by default a validates associated will occur.
+        #
+        # @example Get the validation default.
+        #   Proxy.validation_default
+        #
+        # @return [ true, false ] The validation default.
+        #
+        # @since 2.1.9
+        def validation_default; true; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def stores_foreign_key?; false; end
+
+        # The primary key
+        #
+        # @return [ nil ] Not relevant for this relation
+        def primary_key; end
+
+        # Get the relation proxy class for this association type.
+        #
+        # @return [ Association::Embedded::EmbedsMany::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?
+          @polymorphic ||= !!@options[:as]
+        end
+
+        # The field used to store the type of the related object.
+        #
+        # @note Only relevant if the association is polymorphic.
+        #
+        # @return [ String, nil ] The field for storing the associated object's type.
+        #
+        # @since 7.0
+        def type
+          @type ||= "#{as}_type" if 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!
+          @owner_class.cyclic = true if cyclic?
+          @owner_class.validates_associated(name) if validate?
+        end
+
+        def relation_complements
+          @relation_complements ||= [ Embedded::EmbeddedIn ].freeze
+        end
+
+        def polymorphic_inverses(other = nil)
+          [ as ]
+        end
+
+        def determine_inverses(other)
+          matches = 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/one.rb → association/embedded/embeds_one/binding.rb}

@@ -1,16 +1,18 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Bindings
-      module Embedded
+  module Association
+    module Embedded
+      class EmbedsOne
 
-        # Binding class for embeds_one relations.
-        class One < Binding
+        # Binding class for all embeds_one relations.
+        #
+        # @since 7.0
+        class Binding
+          include Bindable
 
           # Binds the base object to the inverse of the relation. This is so we
           # are referenced to the actual objects themselves on both sides.
           #
-          # This case sets the metadata on the inverse object as well as the
+          # This case sets the association metadata on the inverse object as well as the
           # document itself.
           #
           # @example Bind the document.
@@ -19,9 +21,9 @@ module Mongoid
           #
           # @since 2.0.0.rc.1
           def bind_one
-            target.parentize(base)
+            _target.parentize(_base)
             binding do
-              target.do_or_do_not(metadata.inverse_setter(target), base)
+              _target.do_or_do_not(_association.inverse_setter(_target), _base)
             end
           end
 
@@ -35,7 +37,7 @@ module Mongoid
           # @since 2.0.0.rc.1
           def unbind_one
             binding do
-              target.do_or_do_not(metadata.inverse_setter(target), nil)
+              _target.do_or_do_not(_association.inverse_setter(_target), nil)
             end
           end
         end

data/lib/mongoid/{relations/builders/embedded/one.rb → association/embedded/embeds_one/buildable.rb}

@@ -1,21 +1,27 @@
-# encoding: utf-8
 module Mongoid
-  module Relations
-    module Builders
-      module Embedded
-        class One < Builder
+  module Association
+    module Embedded
+      class EmbedsOne
+
+        # Builder class for embeds_one 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 on the relation. Instantiates through the factory in order
           # to make sure subclasses and allocation are used if fitting.
           #
           # @example Build the document.
           #   Builder.new(meta, attrs).build
           #
+          # @param [ Document ] base The document this relation hangs off of.
+          # @param [ Document ] object The related document.
           # @param [ String ] _type Not used in this context.
           #
           # @return [ Document ] A single document.
-          def build(_type = nil)
+          def build(base, object, _type = nil)
             return object unless object.is_a?(Hash)
             if _loading? && base.persisted?
               Factory.from_db(klass, object)

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

@@ -0,0 +1,130 @@
+module Mongoid
+  module Association
+    module Embedded
+      class EmbedsOne
+
+        class Proxy < Association::One
+
+          # The valid options when defining this relation.
+          #
+          # @return [ Array<Symbol> ] The allowed options when defining this relation.
+          #
+          # @since 7.0
+          VALID_OPTIONS = [
+              :autobuild,
+              :as,
+              :cascade_callbacks,
+              :cyclic,
+              :store_as
+          ].freeze
+
+          # Instantiate a new embeds_one relation.
+          #
+          # @example Create the new proxy.
+          #   One.new(person, name, association)
+          #
+          # @param [ Document ] base The document this relation hangs off of.
+          # @param [ Document ] target The child document in the relation.
+          # @param [ Association ] association The association metadata.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              characterize_one(_target)
+              bind_one
+              characterize_one(_target)
+              _base._reset_memoized_children!
+              _target.save if persistable?
+            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)
+            if replacement != self
+              if _assigning?
+                _base.add_atomic_unset(_target) unless replacement
+              else
+                # The associated object will be replaced by the below update, so only
+                # run the callbacks and state-changing code by passing persist: false.
+                _target.destroy(persist: false) if persistable?
+              end
+              unbind_one
+              return nil unless replacement
+              replacement = Factory.build(klass, replacement) if replacement.is_a?(::Hash)
+              self._target = replacement
+              bind_one
+              characterize_one(_target)
+              _target.save if persistable?
+            end
+            self
+          end
+
+          private
+
+          # Instantiate the binding associated with this relation.
+          #
+          # @example Get the binding.
+          #   relation.binding([ address ])
+          #
+          # @return [ Binding ] The relation's binding.
+          #
+          # @since 2.0.0.rc.1
+          def binding
+            Binding.new(_base, _target, _association)
+          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?
+            _base.persisted? && !_binding? && !_building? && !_assigning?
+          end
+
+          class << self
+
+            # Returns true if the relation is an embedded one. In this case
+            # always true.
+            #
+            # @example Is this relation embedded?
+            #   Association::Embedded::EmbedsOne.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 [ Mongoid::Atomic::Paths::Embedded::One ]
+            #   The embedded one atomic path calculator.
+            #
+            # @since 2.1.0
+            def path(document)
+              Mongoid::Atomic::Paths::Embedded::One.new(document)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/macros.rb

@@ -0,0 +1,204 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+
+    # This module contains the core macros for defining relations between
+    # documents. They can be either embedded or referenced (relational).
+    module Macros
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :embedded, instance_reader: false
+        class_attribute :embedded_relations
+        class_attribute :relations
+        self.embedded = false
+        self.embedded_relations = BSON::Document.new
+        self.relations = BSON::Document.new
+      end
+
+      # This is convenience for libraries still on the old API.
+      #
+      # @example Get the associations.
+      #   person.associations
+      #
+      # @return [ Hash ] The relations.
+      #
+      # @since 2.3.1
+      def associations
+        self.relations
+      end
+
+      module ClassMethods
+
+        # Adds the relation back to the parent document. This macro is
+        # necessary to set the references from the child back to the parent
+        # document. If a child does not define this relation calling
+        # persistence methods on the child object will cause a save to fail.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embedded_in(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds the relation from a parent document to its children. The name
+        # of the relation needs to be a pluralized form of the child class
+        # name.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embeds_many(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds the relation from a parent document to its child. The name
+        # of the relation needs to be a singular form of the child class
+        # name.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_one :name
+        #   end
+        #
+        #   class Name
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embeds_one(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational association from the child Document to a Document in
+        # another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_one :game
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def belongs_to(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational association from a parent Document to many
+        # Documents in another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_many :posts
+        #   end
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def has_many(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational many-to-many association between many of this
+        # Document and many of another Document.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_and_belongs_to_many :preferences
+        #   end
+        #
+        #   class Preference
+        #     include Mongoid::Document
+        #     has_and_belongs_to_many :people
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        #
+        # @since 2.0.0.rc.1
+        def has_and_belongs_to_many(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        # Adds a relational association from the child Document to a Document in
+        # another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_one :game
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def has_one(name, options = {}, &block)
+          define_association!(__method__, name, options, &block)
+        end
+
+        private
+
+        def define_association!(macro_name, name, options = {}, &block)
+          Association::MACRO_MAPPING[macro_name].new(self, name, options, &block).tap do |assoc|
+            assoc.setup!
+            self.relations = self.relations.merge(name => assoc)
+          end
+        end
+      end
+    end
+  end
+end