mongoid_heroku_stable 4.0.0

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

@@ -0,0 +1,290 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Referenced
+
+      # This class defines the behaviour for all relations that are a
+      # one-to-one between documents in different collections.
+      class One < Relations::One
+
+        # Instantiate a new references_one relation. Will set the foreign key
+        # and the base on the inverse object.
+        #
+        # @example Create the new relation.
+        #   Referenced::One.new(base, target, metadata)
+        #
+        # @param [ Document ] base The document this relation hangs off of.
+        # @param [ Document ] target The target (child) of the relation.
+        # @param [ Metadata ] metadata The relation's metadata.
+        def initialize(base, target, metadata)
+          init(base, target, metadata) do
+            raise_mixed if klass.embedded? && !klass.cyclic?
+            characterize_one(target)
+            bind_one
+            target.save if persistable?
+          end
+        end
+
+        # Removes the association between the base document and the target
+        # document by deleting the foreign key and the reference, orphaning
+        # the target document in the process.
+        #
+        # @example Nullify the relation.
+        #   person.game.nullify
+        #
+        # @since 2.0.0.rc.1
+        def nullify
+          unbind_one
+          target.save
+        end
+
+        # Substitutes the supplied target document for the existing document
+        # in the relation. If the new target is nil, perform the necessary
+        # deletion.
+        #
+        # @example Replace the relation.
+        #   person.game.substitute(new_game)
+        #
+        # @param [ Array<Document> ] replacement The replacement target.
+        #
+        # @return [ One ] The relation.
+        #
+        # @since 2.0.0.rc.1
+        def substitute(replacement)
+          unbind_one
+          if persistable?
+            if metadata.destructive?
+              send(metadata.dependent)
+            else
+              save if persisted?
+            end
+          end
+          One.new(base, replacement, metadata) if replacement
+        end
+
+        private
+
+        # Instantiate the binding associated with this relation.
+        #
+        # @example Get the binding.
+        #   relation.binding([ address ])
+        #
+        # @param [ Document ] new_target The new target of the relation.
+        #
+        # @return [ Binding ] The binding object.
+        def binding
+          Bindings::Referenced::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?
+        end
+
+        class << self
+
+          # Return the builder that is responsible for generating the documents
+          # that will be used by this relation.
+          #
+          # @example Get the builder.
+          #   Referenced::One.builder(meta, object)
+          #
+          # @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 new builder object.
+          #
+          # @since 2.0.0.rc.1
+          def builder(base, meta, object)
+            Builders::Referenced::One.new(base, meta, object)
+          end
+
+          # Get the standard criteria used for querying this relation.
+          #
+          # @example Get the criteria.
+          #   Proxy.criteria(meta, id, Model)
+          #
+          # @param [ Metadata ] metadata The metadata.
+          # @param [ Object ] object The value of the foreign key.
+          # @param [ Class ] type The optional type.
+          #
+          # @return [ Criteria ] The criteria.
+          #
+          # @since 2.1.0
+          def criteria(metadata, object, type = nil)
+            crit = metadata.klass.where(metadata.foreign_key => object)
+            if metadata.polymorphic?
+              crit = crit.where(metadata.type => type.name)
+            end
+            crit
+          end
+
+          # Get the criteria that is used to eager load a relation of this
+          # type.
+          #
+          # @example Get the eager load criteria.
+          #   Proxy.eager_load(metadata, criteria)
+          #
+          # @param [ Metadata ] metadata The relation metadata.
+          # @param [ Array<Object> ] ids The ids of the base docs.
+          #
+          # @return [ Criteria ] The criteria to eager load the relation.
+          #
+          # @since 2.2.0
+          def eager_load(metadata, ids)
+            eager_load_ids(metadata, ids) { |doc, key| IdentityMap.set_one(doc, key) }
+          end
+
+          # Returns true if the relation is an embedded one. In this case
+          # always false.
+          #
+          # @example Is this relation embedded?
+          #   Referenced::One.embedded?
+          #
+          # @return [ false ] Always false.
+          #
+          # @since 2.0.0.rc.1
+          def embedded?
+            false
+          end
+
+          # Get the foreign key for the provided name.
+          #
+          # @example Get the foreign key.
+          #   Referenced::One.foreign_key(:person)
+          #
+          # @param [ Symbol ] name The name.
+          #
+          # @return [ String ] The foreign key.
+          #
+          # @since 3.0.0
+          def foreign_key(name)
+            "#{name}#{foreign_key_suffix}"
+          end
+
+          # Get the default value for the foreign key.
+          #
+          # @example Get the default.
+          #   Referenced::One.foreign_key_default
+          #
+          # @return [ nil ] Always nil.
+          #
+          # @since 2.0.0.rc.1
+          def foreign_key_default
+            nil
+          end
+
+          # Returns the suffix of the foreign key field, either "_id" or "_ids".
+          #
+          # @example Get the suffix for the foreign key.
+          #   Referenced::One.foreign_key_suffix
+          #
+          # @return [ String ] "_id"
+          #
+          # @since 2.0.0.rc.1
+          def foreign_key_suffix
+            "_id"
+          end
+
+          # Returns the macro for this relation. Used mostly as a helper in
+          # reflection.
+          #
+          # @example Get the macro.
+          #   Referenced::One.macro
+          #
+          # @return [ Symbol ] :has_one.
+          def macro
+            :has_one
+          end
+
+          # Return the nested builder that is responsible for generating the documents
+          # that will be used by this relation.
+          #
+          # @example Get the nested builder.
+          #   Referenced::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 [ NestedBuilder ] 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 [ Root ] The root atomic path calculator.
+          #
+          # @since 2.1.0
+          def path(document)
+            Mongoid::Atomic::Paths::Root.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?
+          #   Referenced::One.stores_foreign_key?
+          #
+          # @return [ false ] Always 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
+            [ :as, :autobuild, :autosave, :dependent, :foreign_key, :primary_key ]
+          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/reflections.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # 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.
+      #
+      # @example Find relation 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.
+      def reflect_on_association(name)
+        self.class.reflect_on_association(name)
+      end
+
+      # Returns all relation metadata for the supplied macros.
+      #
+      # @example Find multiple relation metadata by macro.
+      #   person.reflect_on_all_associations(:embeds_many)
+      #
+      # @param [ Array<String, Symbol> ] *macros The relation macros.
+      #
+      # @return [ Array<Metadata> ] The matching relation metadata.
+      def reflect_on_all_associations(*macros)
+        self.class.reflect_on_all_associations(*macros)
+      end
+
+      module ClassMethods
+
+        # Returns the relation metadata for the supplied name.
+        #
+        # @example Find relation 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.
+        def reflect_on_association(name)
+          relations[name.to_s]
+        end
+
+        # Returns all relation metadata for the supplied macros.
+        #
+        # @example Find multiple relation metadata by macro.
+        #   Person.reflect_on_all_associations(:embeds_many)
+        #
+        # @param [ Array<String, Symbol> ] *macros The relation macros.
+        #
+        # @return [ Array<Metadata> ] The matching relation metadata.
+        def reflect_on_all_associations(*macros)
+          relations.values.select { |meta| macros.include?(meta.macro) }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/synchronization.rb

@@ -0,0 +1,169 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # This module handles the behaviour for synchronizing foreign keys between
+    # both sides of a many to many relations.
+    module Synchronization
+      extend ActiveSupport::Concern
+
+      # 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?(metadata)
+      #
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ true, false ] If we can sync.
+      #
+      # @since 2.1.0
+      def syncable?(metadata)
+        !synced?(metadata.foreign_key) && send(metadata.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(metadata)
+      #
+      # @param [ Metadata ] meta The document metadata.
+      #
+      # @return [ Object ] The updated values.
+      #
+      # @since 2.2.1
+      def remove_inverse_keys(meta)
+        foreign_keys = send(meta.foreign_key)
+        unless foreign_keys.nil? || foreign_keys.empty?
+          meta.criteria(foreign_keys, self.class).pull(meta.inverse_foreign_key => id)
+        end
+      end
+
+      # Update the inverse keys for the relation.
+      #
+      # @example Update the inverse keys
+      #   document.update_inverse_keys(metadata)
+      #
+      # @param [ Metadata ] meta The document metadata.
+      #
+      # @return [ Object ] The updated values.
+      #
+      # @since 2.1.0
+      def update_inverse_keys(meta)
+        if changes.has_key?(meta.foreign_key)
+          old, new = changes[meta.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 $pushAll 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 meta.autosave?
+            send(meta.name).in_memory.each do |doc|
+              adds.delete_one(doc.id)
+            end
+          end
+
+          unless adds.empty?
+            meta.criteria(adds, self.class).without_options.add_to_set(meta.inverse_foreign_key => id)
+          end
+          unless subs.empty?
+            meta.criteria(subs, self.class).without_options.pull(meta.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(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @since 2.1.0
+        def synced(metadata)
+          unless metadata.forced_nil_inverse?
+            synced_save(metadata)
+            synced_destroy(metadata)
+          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(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ Class ] The class getting set up.
+        #
+        # @since 2.1.0
+        def synced_save(metadata)
+          set_callback(
+            :save,
+            :after,
+            if: ->(doc){ doc.syncable?(metadata) }
+          ) do |doc|
+            doc.update_inverse_keys(metadata)
+          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(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ Class ] The class getting set up.
+        #
+        # @since 2.2.1
+        def synced_destroy(metadata)
+          set_callback(
+            :destroy,
+            :after
+          ) do |doc|
+            doc.remove_inverse_keys(metadata)
+          end
+          self
+        end
+      end
+    end
+  end
+end