mongoid 6.4.8 → 7.0.0

data/lib/mongoid/association/referenced/has_one.rb

@@ -0,0 +1,204 @@
+require 'mongoid/association/referenced/has_one/binding'
+require 'mongoid/association/referenced/has_one/buildable'
+require 'mongoid/association/referenced/has_one/proxy'
+require 'mongoid/association/referenced/has_one/eager'
+
+module Mongoid
+  module Association
+    module Referenced
+
+      # The has_one association.
+      #
+      # @since 7.0
+      class HasOne
+        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 = [
+            :as,
+            :autobuild,
+            :autosave,
+            :dependent,
+            :foreign_key,
+            :primary_key
+        ].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
+
+        # The default foreign key suffix.
+        #
+        # @return [ String ] '_id'
+        #
+        # @since 7.0
+        FOREIGN_KEY_SUFFIX = '_id'.freeze
+
+        # The list of association complements.
+        #
+        # @return [ Array<Association> ] The association complements.
+        #
+        # @since 7.0
+        def relation_complements
+          @relation_complements ||= [ Referenced::BelongsTo ].freeze
+        end
+
+        # Setup the instance methods, fields, etc. on the association owning class.
+        #
+        # @return [ self ]
+        #
+        # @since 7.0
+        def setup!
+          setup_instance_methods!
+          self
+        end
+
+        # Get the foreign key field for saving the association reference.
+        #
+        # @return [ String ] The foreign key field for saving the
+        #   association reference.
+        #
+        # @since 7.0
+        def foreign_key
+          @foreign_key ||= @options[:foreign_key] ? @options[:foreign_key].to_s :
+                             default_foreign_key_field
+        end
+
+        # Is this association type embedded?
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def embedded?; false; end
+
+        # The default for validation the association object.
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 7.0
+        def validation_default; true; end
+
+        # Get the relation proxy class for this association type.
+        #
+        # @return [ Association::HasOne::Proxy ] The proxy class.
+        #
+        # @since 7.0
+        def relation
+          Proxy
+        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.
+        #
+        # @since 7.0
+        def nested_builder(attributes, options)
+          Nested::One.new(self, attributes, options)
+        end
+
+        # Is this association polymorphic?
+        #
+        # @return [ true, false ] Whether this association is polymorphic.
+        #
+        # @since 7.0
+        def polymorphic?
+          @polymorphic ||= !!as
+        end
+
+        # The type of this association if it's polymorphic.
+        #
+        # @note Only relevant for polymorphic relations.
+        #
+        # @return [ String, nil ] The type field.
+        #
+        # @since 7.0
+        def type
+          @type ||= "#{as}_type" if polymorphic?
+        end
+
+        # Whether trying to bind an object using this association should raise
+        # an error.
+        #
+        # @param [ Document ] doc The document to be bound.
+        #
+        # @return [ true, false ] Whether the document can be bound.
+        def bindable?(doc)
+          forced_nil_inverse? || (!!inverse && doc.fields.keys.include?(foreign_key))
+        end
+
+        def stores_foreign_key?; false; 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
+
+        private
+
+        # Setup the instance methods on the class having this association type.
+        #
+        # @return [ self ]
+        #
+        # @since 7.0
+        def setup_instance_methods!
+          define_getter!
+          define_setter!
+          define_existence_check!
+          define_builder!
+          define_creator!
+          define_autosaver!
+          polymorph!
+          define_dependency!
+          @owner_class.validates_associated(name) if validate?
+          self
+        end
+
+        def default_foreign_key_field
+          @default_foreign_key_field ||= "#{inverse}#{FOREIGN_KEY_SUFFIX}"
+        end
+
+        def polymorphic_inverses(other)
+          [ as ]
+        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
+
+        def default_primary_key
+          PRIMARY_KEY_DEFAULT
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/syncable.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Referenced
+
+      # This module handles the behaviour for synchronizing foreign keys between
+      # both sides of a many to many relations.
+      module Syncable
+
+        # Is the document able to be synced on the inverse side? This is only if
+        # the key has changed and the relation bindings have not been run.
+        #
+        # @example Are the foreign keys syncable?
+        #   document._syncable?(association)
+        #
+        # @param [ Association ] association The association metadata.
+        #
+        # @return [ true, false ] If we can sync.
+        #
+        # @since 2.1.0
+        def _syncable?(association)
+          !_synced?(association.foreign_key) && send(association.foreign_key_check)
+        end
+
+        # Get the synced foreign keys.
+        #
+        # @example Get the synced foreign keys.
+        #   document._synced
+        #
+        # @return [ Hash ] The synced foreign keys.
+        #
+        # @since 2.1.0
+        def _synced
+          @_synced ||= {}
+        end
+
+        # Has the document been synced for the foreign key?
+        #
+        # @example Has the document been synced?
+        #   document._synced?
+        #
+        # @param [ String ] foreign_key The foreign key.
+        #
+        # @return [ true, false ] If we can sync.
+        #
+        # @since 2.1.0
+        def _synced?(foreign_key)
+          !!_synced[foreign_key]
+        end
+
+        # Update the inverse keys on destroy.
+        #
+        # @example Update the inverse keys.
+        #   document.remove_inverse_keys(association)
+        #
+        # @param [ Association ] association The association.
+        #
+        # @return [ Object ] The updated values.
+        #
+        # @since 2.2.1
+        def remove_inverse_keys(association)
+          foreign_keys = send(association.foreign_key)
+          unless foreign_keys.nil? || foreign_keys.empty?
+            association.criteria(self, foreign_keys).pull(association.inverse_foreign_key => _id)
+          end
+        end
+
+        # Update the inverse keys for the relation.
+        #
+        # @example Update the inverse keys
+        #   document.update_inverse_keys(association)
+        #
+        # @param [ Association ] association The document association.
+        #
+        # @return [ Object ] The updated values.
+        #
+        # @since 2.1.0
+        def update_inverse_keys(association)
+          if changes.has_key?(association.foreign_key)
+            old, new = changes[association.foreign_key]
+            adds, subs = new - (old || []), (old || []) - new
+
+            # If we are autosaving we don't want a duplicate to get added - the
+            # $addToSet would run previously and then the $push and $each from the
+            # inverse on the autosave would cause this. We delete each id from
+            # what's in memory in case a mix of id addition and object addition
+            # had occurred.
+            if association.autosave?
+              send(association.name).in_memory.each do |doc|
+                adds.delete_one(doc._id)
+              end
+            end
+
+            unless adds.empty?
+              association.criteria(self, adds).without_options.add_to_set(association.inverse_foreign_key => _id)
+            end
+            unless subs.empty?
+              association.criteria(self, subs).without_options.pull(association.inverse_foreign_key => _id)
+            end
+          end
+        end
+
+        module ClassMethods
+
+          # Set up the syncing of many to many foreign keys.
+          #
+          # @example Set up the syncing.
+          #   Person._synced(association)
+          #
+          # @param [ Association ] association The association metadata.
+          #
+          # @since 2.1.0
+          def _synced(association)
+            unless association.forced_nil_inverse?
+              synced_save(association)
+              synced_destroy(association)
+            end
+          end
+
+          private
+
+          # Set up the sync of inverse keys that needs to happen on a save.
+          #
+          # If the foreign key field has changed and the document is not
+          # synced, $addToSet the new ids, $pull the ones no longer in the
+          # array from the inverse side.
+          #
+          # @example Set up the save syncing.
+          #   Person.synced_save(association)
+          #
+          # @param [ Association ] association The relation association.
+          #
+          # @return [ Class ] The class getting set up.
+          #
+          # @since 2.1.0
+          def synced_save(association)
+            set_callback(
+                :save,
+                :after,
+                if: ->(doc) { doc._syncable?(association) }
+            ) do |doc|
+              doc.update_inverse_keys(association)
+            end
+            self
+          end
+
+          # Set up the sync of inverse keys that needs to happen on a destroy.
+          #
+          # @example Set up the destroy syncing.
+          #   Person.synced_destroy(association)
+          #
+          # @param [ Association ] association The association metadata.
+          #
+          # @return [ Class ] The class getting set up.
+          #
+          # @since 2.2.1
+          def synced_destroy(association)
+            set_callback(
+                :destroy,
+                :after
+            ) do |doc|
+              doc.remove_inverse_keys(association)
+            end
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced.rb

@@ -0,0 +1,7 @@
+require 'mongoid/association/referenced/auto_save'
+require 'mongoid/association/referenced/counter_cache'
+require 'mongoid/association/referenced/syncable'
+require 'mongoid/association/referenced/belongs_to'
+require 'mongoid/association/referenced/has_many'
+require 'mongoid/association/referenced/has_and_belongs_to_many'
+require 'mongoid/association/referenced/has_one'

data/lib/mongoid/{relations → association}/reflections.rb

@@ -1,62 +1,66 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # The reflections module provides convenience methods that can retrieve
     # useful information about associations.
     module Reflections
       extend ActiveSupport::Concern
 
-      # Returns the relation metadata for the supplied name.
+      # Returns the association metadata for the supplied name.
       #
-      # @example Find relation metadata by name.
+      # @example Find relation association by name.
       #   person.reflect_on_association(:addresses)
       #
       # @param [ String, Symbol ] name The name of the relation to find.
       #
-      # @return [ Metadata ] The matching relation metadata.
+      # @return [ Association ] The matching association metadata.
       def reflect_on_association(name)
         self.class.reflect_on_association(name)
       end
 
-      # Returns all relation metadata for the supplied macros.
+      # Returns all association metadata for the supplied macros.
       #
-      # @example Find multiple relation metadata by macro.
+      # @example Find multiple association metadata by macro.
       #   person.reflect_on_all_associations(:embeds_many)
       #
       # @param [ Array<Symbol> ] macros The relation macros.
       #
-      # @return [ Array<Metadata> ] The matching relation metadata.
-      def reflect_on_all_associations(*macros)
+      # @return [ Array<Association> ] The matching association metadata.
+      def reflect_on_all_association(*macros)
         self.class.reflect_on_all_associations(*macros)
       end
 
       module ClassMethods
 
-        # Returns the relation metadata for the supplied name.
+        # Returns the association metadata for the supplied name.
         #
-        # @example Find relation metadata by name.
+        # @example Find association metadata by name.
         #   Person.reflect_on_association(:addresses)
         #
         # @param [ String, Symbol ] name The name of the relation to find.
         #
-        # @return [ Metadata ] The matching relation metadata.
+        # @return [ Association ] The matching association metadata.
         def reflect_on_association(name)
           relations[name.to_s]
         end
 
-        # Returns all relation metadata for the supplied macros.
+        # Returns all association metadata for the supplied macros.
         #
-        # @example Find multiple relation metadata by macro.
+        # @example Find multiple association metadata by macro.
         #   Person.reflect_on_all_associations(:embeds_many)
         #
         # @param [ Array<Symbol> ] macros The relation macros.
         #
-        # @return [ Array<Metadata> ] The matching relation metadata.
+        # @return [ Array<Association> ] The matching association metadata.
         def reflect_on_all_associations(*macros)
-          association_reflections = relations.values
-          association_reflections.select! { |reflection| macros.include?(reflection.macro) } unless macros.empty?
-          association_reflections
+          all_associations = relations.values
+          unless macros.empty?
+            all_associations.select! do |reflection|
+              macros.include?(Association::MACRO_MAPPING.key(reflection.class))
+            end
+          end
+          all_associations
         end
       end
     end