mongoid 3.1.5 → 8.0.2

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/embedded/embeds_many/binding'
+require 'mongoid/association/embedded/embeds_many/buildable'
+require 'mongoid/association/embedded/embeds_many/proxy'
+
+module Mongoid
+  module Association
+    module Embedded
+
+      # The EmbedsMany type association.
+      class EmbedsMany
+        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.
+        ASSOCIATION_OPTIONS = [
+            :as,
+            :cascade_callbacks,
+            :cyclic,
+            :order,
+            :store_as,
+            :before_add,
+            :after_add,
+            :before_remove,
+            :after_remove
+        ]
+
+        # The complete list of valid options for this association, including
+        # the shared ones.
+        #
+        # @return [ Array<Symbol> ] The valid options.
+        VALID_OPTIONS = (ASSOCIATION_OPTIONS + SHARED_OPTIONS).freeze
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        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 list of association objects.
+        #
+        # @return [ String ] The field name.
+        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 association.
+        def key
+          store_as.to_s
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ true ] Always true.
+        def embedded?; true; end
+
+        # Get the default validation setting for the association. Determines if
+        # by default a validates associated will occur.
+        #
+        # @example Get the validation default.
+        #   Proxy.validation_default
+        #
+        # @return [ true ] Always true.
+        def validation_default; true; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ false ] Always false.
+        def stores_foreign_key?; false; end
+
+        # The primary key
+        #
+        # @return [ nil ] Not relevant for this association
+        def primary_key; end
+
+        # Get the association proxy class for this association type.
+        #
+        # @return [ Association::Embedded::EmbedsMany::Proxy ] The proxy class.
+        def relation
+          Proxy
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true | false ] Whether this association is polymorphic.
+        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.
+        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::Many ] The Nested Builder object.
+        def nested_builder(attributes, options)
+          Nested::Many.new(self, attributes, options)
+        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::Many ]
+        #   The embedded many atomic path calculator.
+        def path(document)
+          Mongoid::Atomic::Paths::Embedded::Many.new(document)
+        end
+
+        # Get a criteria object for searching given a parent and children documents.
+        #
+        # @param [ Document ] base The base document.
+        # @param [ Document ] target The children documents.
+        def criteria(base, target)
+          criterion = klass.scoped
+          criterion.embedded = true
+          criterion.documents = target
+          criterion.parent_document = base
+          criterion.association = self
+          apply_ordering(criterion)
+        end
+
+        private
+
+        def apply_ordering(criteria)
+          order ? criteria.order_by(order) : criteria
+        end
+
+        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) &&
+              # https://jira.mongodb.org/browse/MONGOID-4882
+              rel.relation_class_name.sub(/\A::/, '') == 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/association/embedded/embeds_one/binding.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Embedded
+      class EmbedsOne
+
+        # Binding class for all embeds_one 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 metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind the document.
+          #   person.name.bind(:continue => true)
+          #   person.name = Name.new
+          def bind_one
+            _target.parentize(_base)
+            binding do
+              _target.do_or_do_not(_association.inverse_setter(_target), _base)
+            end
+          end
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   person.name.unbind(:continue => true)
+          #   person.name = nil
+          def unbind_one
+            binding do
+              _target.do_or_do_not(_association.inverse_setter(_target), nil)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Embedded
+      class EmbedsOne
+
+        # Builder class for embeds_one associations.
+        module Buildable
+          include Threaded::Lifecycle
+
+          # Builds the document out of the attributes using the provided
+          # association metadata on the association. 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 association hangs off of.
+          # @param [ Document ] object The related document.
+          # @param [ String ] _type Not used in this context.
+          # @param [ Hash ] selected_fields Fields which were retrieved via
+          #   #only. If selected_fields are specified, fields not listed in it
+          #   will not be accessible in the built document.
+          #
+          # @return [ Document ] A single document.
+          def build(base, object, _type = nil, selected_fields = nil)
+            if object.is_a?(Hash)
+              if _loading? && base.persisted?
+                Factory.execute_from_db(klass, object, nil, selected_fields, execute_callbacks: false)
+              else
+                Factory.build(klass, object)
+              end
+            else
+              clear_associated(object)
+              object
+            end
+          end
+
+          private
+
+          def clear_associated(doc)
+            if doc && (inv = inverse(doc))
+              if associated = doc.ivar(inv)
+                associated.substitute(nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Embedded
+      class EmbedsOne
+
+        class Proxy < Association::One
+
+          # The valid options when defining this association.
+          #
+          # @return [ Array<Symbol> ] The allowed options when defining this association.
+          VALID_OPTIONS = [
+              :autobuild,
+              :as,
+              :cascade_callbacks,
+              :cyclic,
+              :store_as
+          ].freeze
+
+          # Instantiate a new embeds_one association.
+          #
+          # @example Create the new proxy.
+          #   One.new(person, name, association)
+          #
+          # @param [ Document ] base The document this association hangs off of.
+          # @param [ Document ] target The child document in the association.
+          # @param [ Association ] association The association metadata.
+          def initialize(base, target, association)
+            init(base, target, association) do
+              characterize_one(_target)
+              bind_one
+              characterize_one(_target)
+              update_attributes_hash(_target)
+              _base._reset_memoized_descendants!
+              _target.save if persistable?
+            end
+          end
+
+          # Substitutes the supplied target documents for the existing document
+          # in the association.
+          #
+          # @example Substitute the new document.
+          #   person.name.substitute(new_name)
+          #
+          # @param [ Document ] replacement A document to replace the target.
+          #
+          # @return [ Document | nil ] The association or nil.
+          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 if non-nil, so only
+                # run the callbacks and state-changing code by passing persist: false in that case.
+                _target.destroy(persist: !replacement) if persistable?
+
+                unless Mongoid.broken_updates
+                  # A little explanation on why this is needed... Say we have three assignments:
+                  #
+                  # canvas.palette = palette
+                  # canvas.palette = nil
+                  # canvas.palette = palette
+                  # Where canvas embeds_one palette.
+                  #
+                  # Previously, what was happening was, on the first assignment,
+                  # palette was considered a "new record" (new_record?=true) and
+                  # thus palette was being inserted into the database. However,
+                  # on the third assignment, we're trying to reassign the palette,
+                  # palette is no longer considered a new record, because it had
+                  # been inserted previously. This is not exactly accurate,
+                  # because the second assignment ultimately removed the palette
+                  # from the database, so it needs to be reinserted. Since the
+                  # palette's new_record is false, Mongoid ends up "updating" the
+                  # document, which doesn't reinsert it into the database.
+                  #
+                  # The change I introduce here, respecifies palette as a "new
+                  # record" when it gets removed from the database, so if it is
+                  # reassigned, it will be reinserted into the database.
+                  _target.new_record = true
+                end
+              end
+              unbind_one
+              unless replacement
+                update_attributes_hash(replacement)
+                return nil
+              end
+              replacement = Factory.build(klass, replacement) if replacement.is_a?(::Hash)
+              self._target = replacement
+              characterize_one(_target)
+              bind_one
+              update_attributes_hash(_target)
+              _target.save if persistable?
+            end
+            self
+          end
+
+          private
+
+          # Instantiate the binding associated with this association.
+          #
+          # @example Get the binding.
+          #   relation.binding([ address ])
+          #
+          # @return [ Binding ] The association's binding.
+          def binding
+            Binding.new(_base, _target, _association)
+          end
+
+          # Are we able to persist this association?
+          #
+          # @example Can we persist the association?
+          #   relation.persistable?
+          #
+          # @return [ true | false ] If the association is persistable.
+          def persistable?
+            _base.persisted? && !_binding? && !_building? && !_assigning?
+          end
+
+          # Update the _base's attributes hash with the _target's attributes
+          #
+          # @param replacement [ Document | nil ] The doc to use to update the
+          #   attributes hash.
+          #
+          # @api private
+          def update_attributes_hash(replacement)
+            if replacement
+              _base.attributes.merge!(_association.store_as => replacement.attributes)
+            else
+              _base.attributes.delete(_association.store_as)
+            end
+          end
+
+          class << self
+
+            # Returns true if the association is an embedded one. In this case
+            # always true.
+            #
+            # @example Is this association embedded?
+            #   Association::Embedded::EmbedsOne.embedded?
+            #
+            # @return [ true ] true.
+            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.
+            def path(document)
+              Mongoid::Atomic::Paths::Embedded::One.new(document)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+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.
+      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.
+        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.
+        VALID_OPTIONS = (ASSOCIATION_OPTIONS + SHARED_OPTIONS).freeze
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        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.
+        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 association.
+        def key
+          store_as.to_s
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ true ] Always true.
+        def embedded?; true; end
+
+        # Get the default validation setting for the association. Determines if
+        # by default a validates associated will occur.
+        #
+        # @example Get the validation default.
+        #   Proxy.validation_default
+        #
+        # @return [ true | false ] The validation default.
+        def validation_default; true; end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ false ] Always false.
+        def stores_foreign_key?; false; end
+
+        # The primary key
+        #
+        # @return [ nil ] Not relevant for this association
+        def primary_key; end
+
+        # Get the association proxy class for this association type.
+        #
+        # @return [ Association::Embedded::EmbedsMany::Proxy ] The proxy class.
+        def relation
+          Proxy
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true | false ] Whether this association is polymorphic.
+        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.
+        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.
+        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) &&
+              # https://jira.mongodb.org/browse/MONGOID-4882
+              rel.relation_class_name.sub(/\A::/, '') == 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/association/embedded.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mongoid/association/embedded/cyclic'
+require 'mongoid/association/embedded/embedded_in'
+require 'mongoid/association/embedded/embeds_many'
+require 'mongoid/association/embedded/embeds_one'