mongoid 6.4.8 → 7.0.0.beta

data/lib/mongoid/relations/embedded/one.rb

@@ -1,235 +0,0 @@
-# encoding: utf-8
-module Mongoid
-  module Relations
-    module Embedded
-
-      # This class defines the behaviour needed for embedded one to one
-      # relations.
-      class One < Relations::One
-
-        # The allowed options when defining this relation.
-        #
-        # @return [ Array<Symbol> ] The allowed options when defining this relation.
-        #
-        # @since 6.0.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, metadata)
-        #
-        # @param [ Document ] base The document this relation hangs off of.
-        # @param [ Document ] target The child document in the relation.
-        # @param [ Metadata ] metadata The relation's metadata
-        def initialize(base, target, metadata)
-          init(base, target, metadata) 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
-              target.destroy 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? && !_assigning?
-          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
-          Bindings::Embedded::One.new(base, target, __metadata)
-        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
-
-          # Return the builder that is responsible for generating the documents
-          # that will be used by this relation.
-          #
-          # @example Get the builder.
-          #   Embedded::One.builder(meta, object, person)
-          #
-          # @param [ Document ] base The base document.
-          # @param [ Metadata ] meta The metadata of the relation.
-          # @param [ Document, Hash ] object A document or attributes to build with.
-          #
-          # @return [ Builder ] A newly instantiated builder object.
-          #
-          # @since 2.0.0.rc.1
-          def builder(base, meta, object)
-            Builders::Embedded::One.new(base, meta, object)
-          end
-
-          # Returns true if the relation is an embedded one. In this case
-          # always true.
-          #
-          # @example Is this relation embedded?
-          #   Embedded::One.embedded?
-          #
-          # @return [ true ] true.
-          #
-          # @since 2.0.0.rc.1
-          def embedded?
-            true
-          end
-
-          # Returns the suffix of the foreign key field, either "_id" or "_ids".
-          #
-          # @example Get the suffix for the foreign key.
-          #   Referenced::Many.foreign_key_suffix
-          #
-          # @return [ nil ] nil.
-          #
-          # @since 3.0.0
-          def foreign_key_suffix
-            nil
-          end
-
-          # Returns the macro for this relation. Used mostly as a helper in
-          # reflection.
-          #
-          # @example Get the macro.
-          #   Mongoid::Relations::Embedded::One.macro
-          #
-          # @return [ Symbol ] :embeds_one.
-          #
-          # @since 2.0.0.rc.1
-          def macro
-            :embeds_one
-          end
-
-          # Return the nested builder that is responsible for generating
-          # the documents that will be used by this relation.
-          #
-          # @example Get the builder.
-          #   NestedAttributes::One.builder(attributes, options)
-          #
-          # @param [ Metadata ] metadata The relation metadata.
-          # @param [ Hash ] attributes The attributes to build with.
-          # @param [ Hash ] options The options for the builder.
-          #
-          # @option options [ true, false ] :allow_destroy Can documents be
-          #   deleted?
-          # @option options [ Integer ] :limit Max number of documents to
-          #   create at once.
-          # @option options [ Proc, Symbol ] :reject_if If documents match this
-          #   option then they are ignored.
-          # @option options [ true, false ] :update_only Only existing documents
-          #   can be modified.
-          #
-          # @return [ Builder ] A newly instantiated nested builder object.
-          #
-          # @since 2.0.0.rc.1
-          def nested_builder(metadata, attributes, options)
-            Builders::NestedAttributes::One.new(metadata, 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::One ]
-          #   The embedded one atomic path calculator.
-          #
-          # @since 2.1.0
-          def path(document)
-            Mongoid::Atomic::Paths::Embedded::One.new(document)
-          end
-
-          # Tells the caller if this relation is one that stores the foreign
-          # key on its own objects.
-          #
-          # @example Does this relation store a foreign key?
-          #   Embedded::One.stores_foreign_key?
-          #
-          # @return [ false ] false.
-          #
-          # @since 2.0.0.rc.1
-          def stores_foreign_key?
-            false
-          end
-
-          # Get the valid options allowed with this relation.
-          #
-          # @example Get the valid options.
-          #   Relation.valid_options
-          #
-          # @return [ Array<Symbol> ] The valid options.
-          #
-          # @since 2.1.0
-          def valid_options
-            VALID_OPTIONS
-          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
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/relations/macros.rb

@@ -1,367 +0,0 @@
-# encoding: utf-8
-module Mongoid
-  module Relations
-
-    # 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 = {}
-        self.relations = {}
-      end
-
-      # This is convenience for librarys 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)
-          meta = characterize(name, Embedded::In, options, &block)
-          self.embedded = true
-          relate(name, meta)
-          builder(name, meta).creator(name, meta)
-          touchable(meta)
-          add_counter_cache_callbacks(meta) if meta.counter_cached?
-          meta
-        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)
-          meta = characterize(name, Embedded::Many, options, &block)
-          self.cyclic = true if options[:cyclic]
-          relate(name, meta)
-          embed(name, meta)
-          validates_relation(meta)
-          meta
-        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)
-          meta = characterize(name, Embedded::One, options, &block)
-          self.cyclic = true if options[:cyclic]
-          relate(name, meta)
-          embed(name, meta)
-          builder(name, meta).creator(name, meta)
-          validates_relation(meta)
-          meta
-        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)
-          meta = reference_one_to_one(name, options, Referenced::In, &block)
-          aliased_fields[name.to_s] = meta.foreign_key
-          touchable(meta)
-          add_counter_cache_callbacks(meta) if meta.counter_cached?
-          validates(name, presence: true) if require_association?(options)
-          meta
-        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)
-          meta = characterize(name, Referenced::Many, options, &block)
-          relate(name, meta)
-          ids_getter(name, meta).ids_setter(name, meta)
-          reference(meta)
-          autosave(meta)
-          validates_relation(meta)
-          meta
-        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)
-          meta = characterize(name, Referenced::ManyToMany, options, &block)
-          relate(name, meta)
-          reference(meta, Array)
-          autosave(meta)
-          validates_relation(meta)
-          _synced(meta)
-          meta
-        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)
-          reference_one_to_one(name, options, Referenced::One, &block)
-        end
-
-        private
-
-        # Create the metadata for the relation.
-        #
-        # @api private
-        #
-        # @example Create the metadata.
-        #   Person.characterize(:posts, Referenced::Many, {})
-        #
-        # @param [ Symbol ] name The name of the relation.
-        # @param [ Object ] relation The type of relation.
-        # @param [ Hash ] options The relation options.
-        # @param [ Proc ] block Optional block for defining extensions.
-        #
-        # @return [ Metadata ] The metadata for the relation.
-        def characterize(name, relation, options, &block)
-          Metadata.new({
-            relation: relation,
-            extend: create_extension_module(name, &block),
-            inverse_class_name: self.name,
-            name: name
-          }.merge(options))
-        end
-
-        # Generate a named extension module suitable for marshaling
-        #
-        # @api private
-        #
-        # @example Get the module.
-        #   Person.create_extension_module(:posts, &block)
-        #
-        # @param [ Symbol ] name The name of the relation.
-        # @param [ Proc ] block Optional block for defining extensions.
-        #
-        # @return [ Module, nil ] The extension or nil.
-        #
-        # @since 2.1.0
-        def create_extension_module(name, &block)
-          if block
-            extension_module_name =
-              "#{self.to_s.demodulize}#{name.to_s.camelize}RelationExtension"
-            silence_warnings do
-              self.const_set(extension_module_name, Module.new(&block))
-            end
-            "#{self}::#{extension_module_name}".constantize
-          end
-        end
-
-        # Add an embedded relation metadata to the embedded relations.
-        #
-        # @api private
-        #
-        # @example Add the metadata to embedded relations.
-        #   Person.embed("addresses", metadata)
-        #
-        # @param [ String ] name The name of the relation.
-        # @param [ Metadata ] metadata The relation metadata.
-        #
-        # @since 3.0.0
-        def embed(name, metadata)
-          self.embedded_relations = embedded_relations.merge(name.to_s => metadata)
-          aliased_fields[name.to_s] = metadata.store_as if metadata.store_as
-        end
-
-        # Defines a field to be used as a foreign key in the relation and
-        # indexes it if defined.
-        #
-        # @api private
-        #
-        # @example Set up the relational fields and indexes.
-        #   Person.reference(metadata)
-        #
-        # @param [ Metadata ] metadata The metadata for the relation.
-        def reference(metadata, type = Object)
-          polymorph(metadata).cascade(metadata)
-          if metadata.relation.stores_foreign_key?
-            key = metadata.foreign_key
-            field(
-              key,
-              type: type,
-              identity: true,
-              overwrite: true,
-              metadata: metadata,
-              default: metadata.foreign_key_default
-            )
-            if metadata.indexed?
-              if metadata.polymorphic?
-                index({ key => 1, metadata.inverse_type => 1 }, { background: true })
-              else
-                index({ key => 1 }, { background: true })
-              end
-            end
-          end
-        end
-
-        # Handle common behaviour for referenced 1-1 relation setup.
-        #
-        # @api private
-        #
-        # @example Add the one to one behaviour.
-        #   Model.reference_one_to_one(:name, meta)
-        #
-        # @param [ Symbol ] name The name of the relation.
-        # @param [ Symbol ] options The association options.
-        # @param [ Metadata ] relation The relation.
-        #
-        # @return [ Class ] The model class.
-        #
-        # @since 3.0.0
-        def reference_one_to_one(name, options, relation, &block)
-          meta = characterize(name, relation, options, &block)
-          relate(name, meta)
-          reference(meta)
-          builder(name, meta).creator(name, meta).autosave(meta)
-          validates_relation(meta)
-          meta
-        end
-
-        # Creates a relation for the given name, metadata and relation. It adds
-        # the metadata to the relations hash and has the accessors set up.
-        #
-        # @example Set up the relation and accessors.
-        #   Person.relate(:addresses, Metadata)
-        #
-        # @param [ Symbol ] name The name of the relation.
-        # @param [ Metadata ] metadata The metadata for the relation.
-        def relate(name, metadata)
-          Fields::Validators::Macro.validate_relation(self, name)
-          self.relations = relations.merge(name.to_s => metadata)
-          getter(name, metadata).setter(name, metadata).existence_check(name)
-        end
-
-        def require_association?(options = {})
-          required = options[:required] if options.key?(:required)
-          required = !options[:optional] if options.key?(:optional) && required.nil?
-          required.nil? ? Mongoid.belongs_to_required_by_default : required
-        end
-      end
-    end
-  end
-end