mongoid 3.1.5 → 8.0.2

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      module Eager
+
+        # Base class for eager load preload functions.
+        class Base
+
+          # Instantiate the eager load class.
+          #
+          # @example Create the new belongs to eager load preloader.
+          #   BelongsTo.new(association, parent_docs)
+          #
+          # @param [ Array<Association> ] associations Associations to eager load
+          # @param [ Array<Document> ] docs Documents to preload the associations
+          #
+          # @return [ Base ] The eager load preloader
+          def initialize(associations, docs)
+            @associations = associations
+            @docs = docs
+            @grouped_docs = {}
+          end
+
+          # Run the preloader.
+          #
+          # @example Preload the associations into the documents.
+          #   loader.run
+          #
+          # @return [ Array ] The list of documents given.
+          def run
+            @loaded = []
+            while shift_association
+              preload
+              @loaded << @docs.collect { |d| d.send(@association.name) if d.respond_to?(@association.name) }
+            end
+            @loaded.flatten
+          end
+
+          protected
+
+          # Preload the current association.
+          #
+          # This method should be implemented in the subclass
+          #
+          # @example Preload the current association into the documents.
+          #   loader.preload
+          def preload
+            raise NotImplementedError
+          end
+
+          # Retrieves the documents referenced by the association, and
+          # yields each one sequentially to the provided block. If the
+          # association is not polymorphic, all documents are retrieved in
+          # a single query. If the association is polymorphic, one query is
+          # issued per association target class.
+          def each_loaded_document(&block)
+            each_loaded_document_of_class(@association.klass, keys_from_docs, &block)
+          end
+
+          # Retrieves the documents of the specified class, that have the
+          # foreign key included in the specified list of keys.
+          #
+          # When the documents are retrieved, the set of inclusions applied
+          # is the set of inclusions applied to the host document minus the
+          # association that is being eagerly loaded.
+          private def each_loaded_document_of_class(cls, keys)
+            # Note: keys should not include nil elements.
+            # Upstream code is responsible for eliminating nils from keys.
+            return cls.none if keys.empty?
+
+            criteria = cls.criteria
+            criteria = criteria.apply_scope(@association.scope)
+            criteria = criteria.any_in(key => keys)
+            criteria.inclusions = criteria.inclusions - [@association]
+            criteria.each do |doc|
+              yield doc
+            end
+          end
+
+          # Set the pre-loaded document into its parent.
+          #
+          # @example Set docs into parent with pk = "foo"
+          #   loader.set_on_parent("foo", docs)
+          #
+          # @param [ ObjectId ] id parent`s id
+          # @param [ Document | Array ] element to push into the parent
+          def set_on_parent(id, element)
+            grouped_docs[id].each do |d|
+              set_relation(d, element)
+            end
+          end
+
+          # Return a hash with the current documents grouped by key.
+          #
+          # Documents that do not have a value for the association being loaded
+          # are not returned.
+          #
+          # @example Return a hash with the current documents grouped by key.
+          #   loader.grouped_docs
+          #
+          # @return [ Hash ] hash with grouped documents.
+          def grouped_docs
+            @grouped_docs[@association.name] ||= @docs.group_by do |doc|
+              doc.send(group_by_key) if doc.respond_to?(group_by_key)
+            end.reject do |k, v|
+              k.nil?
+            end
+          end
+
+          # Group the documents and return the keys.
+          #
+          # This method omits nil keys (i.e. keys from documents that do not
+          # have a value for the association being loaded).
+          #
+          # @example
+          #   loader.keys_from_docs
+          #
+          # @return [ Array ] keys, ids
+          def keys_from_docs
+            grouped_docs.keys
+          end
+
+          # Return the key to group the current documents.
+          #
+          # This method should be implemented in the subclass
+          #
+          # @example Return the key for group
+          #   loader.group_by_key
+          #
+          # @return [ Symbol ] Key to group by the current documents.
+          def group_by_key
+            raise NotImplementedError
+          end
+
+          # Set the pre-loaded document into its parent.
+          #
+          # @example Set docs into parent using the current association name.
+          #   loader.set_relation(doc, docs)
+          #
+          # @param [ Document ] doc The object to set the association on
+          # @param [ Document | Array ] element to set into the parent
+          def set_relation(doc, element)
+            doc.set_relation(@association.name, element) unless doc.blank?
+          end
+
+          private
+
+          # Shift the current association metadata
+          #
+          # @example Shift the current association.
+          #   loader.shift_association
+          #
+          # @return [ Association ] The association object.
+          def shift_association
+            @association = @associations.shift
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/has_and_belongs_to_many/binding.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasAndBelongsToMany
+
+        # Binding class for all has_and_belongs_to_many associations.
+        class Binding
+          include Bindable
+
+          # Binds a single document with the inverse association. Used
+          # specifically when appending to the proxy.
+          #
+          # @example Bind one document.
+          #   person.preferences.bind_one(preference)
+          #
+          # @param [ Document ] doc The single document to bind.
+          def bind_one(doc)
+            binding do
+              inverse_keys = doc.you_must(_association.inverse_foreign_key)
+              if inverse_keys
+                record_id = inverse_record_id(doc)
+                unless inverse_keys.include?(record_id)
+                  doc.you_must(_association.inverse_foreign_key_setter, inverse_keys.push(record_id))
+                end
+                doc.reset_relation_criteria(_association.inverse)
+              end
+              _base._synced[_association.foreign_key] = true
+              doc._synced[_association.inverse_foreign_key] = true
+            end
+          end
+
+          # Unbind a single document.
+          #
+          # @example Unbind the document.
+          #   person.preferences.unbind_one(document)
+          def unbind_one(doc)
+            binding do
+              _base.send(_association.foreign_key).delete_one(record_id(doc))
+              inverse_keys = doc.you_must(_association.inverse_foreign_key)
+              if inverse_keys
+                inverse_keys.delete_one(inverse_record_id(doc))
+                doc.reset_relation_criteria(_association.inverse)
+              end
+              _base._synced[_association.foreign_key] = true
+              doc._synced[_association.inverse_foreign_key] = true
+            end
+          end
+
+          # Find the inverse id referenced by inverse_keys
+          def inverse_record_id(doc)
+            if pk = _association.options[:inverse_primary_key]
+              _base.send(pk)
+            else
+              inverse_association = determine_inverse_association(doc)
+              if inverse_association
+                _base.__send__(inverse_association.primary_key)
+              else
+                _base._id
+              end
+            end
+          end
+
+          def determine_inverse_association(doc)
+            doc.relations[_base.class.name.demodulize.underscore.pluralize]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/has_and_belongs_to_many/buildable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasAndBelongsToMany
+
+        # The Builder behavior for has_and_belongs_to_many associations.
+        module Buildable
+
+          # This builder either takes a hash and queries for the
+          # object or an array of documents, where it will just return them.
+          #
+          # @example Build the documents.
+          #   relation.build(association, attrs)
+          #
+          # @param [ Object ] base The base object.
+          # @param [ Object ] object The object to use to build the association.
+          # @param [ String ] type Not used in this context.
+          # @param [ nil ] selected_fields Must be nil.
+          #
+          # @return [ Array<Document> ] The documents.
+          def build(base, object, type = nil, selected_fields = nil)
+            if query?(object)
+              query_criteria(object)
+            else
+              object.try(:dup)
+            end
+          end
+
+          private
+
+          def query?(object)
+            object.nil? || Array(object).all? { |d| !d.is_a?(Mongoid::Document) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/has_and_belongs_to_many/eager.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasAndBelongsToMany
+
+        # Eager class for has_and_belongs_to_many associations.
+        class Eager < Association::Referenced::Eager::Base
+
+          private
+
+          def preload
+            @docs.each do |d|
+              set_relation(d, [])
+            end
+
+            entries = {}
+            each_loaded_document do |doc|
+              entries[doc.send(key)] = doc
+            end
+
+            @docs.each do |d|
+              keys = d.send(group_by_key)
+              docs = entries.values_at(*keys).compact
+              set_relation(d, docs)
+            end
+          end
+
+          def keys_from_docs
+            keys = Set.new
+            @docs.each do |d|
+              keys += d.send(group_by_key)
+            end
+            keys.to_a
+          end
+
+          def set_relation(doc, element)
+            doc.__build__(@association.name, element, @association) unless doc.blank?
+          end
+
+          def group_by_key
+            @association.foreign_key
+          end
+
+          def key
+            @association.primary_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/association/referenced/has_and_belongs_to_many/proxy.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasAndBelongsToMany
+
+        # This class defines the behavior for all associations that are a
+        # many-to-many between documents in different collections.
+        class Proxy < Referenced::HasMany::Proxy
+
+          # Appends a document or array of documents to the association. Will set
+          # the parent and update the index in the process.
+          #
+          # @example Append a document.
+          #   person.posts << post
+          #
+          # @example Push a document.
+          #   person.posts.push(post)
+          #
+          # @example Concat with other documents.
+          #   person.posts.concat([ post_one, post_two ])
+          #
+          # @param [ Document | Array<Document> ] args Any number of documents.
+          #
+          # @return [ Array<Document> ] The loaded docs.
+          def <<(*args)
+            docs = args.flatten
+            return concat(docs) if docs.size > 1
+            if doc = docs.first
+              append(doc) do
+                # We ignore the changes to the value for the foreign key in the
+                # changed_attributes hash in this block of code for two reasons:
+                #
+                # 1) The add_to_set method deletes the value for the foreign
+                #    key in the changed_attributes hash, but if we enter this
+                #    method with a value for the foreign key in the
+                #    changed_attributes hash, then we want it to exist outside
+                #    this method as well. It's used later on in the Syncable
+                #    module to set the inverse foreign keys.
+                # 2) The reset_unloaded method accesses the value for the foreign
+                #    key on _base, which causes it to get added to the
+                #    changed_attributes hash. This happens because when reading
+                #    a "resizable" attribute, it is automatically added to the
+                #    changed_attributes hash. This is true only for the foreign
+                #    key value for HABTM associations as the other associations
+                #    use strings for their foreign key values. For consistency
+                #    with the other associations, we ignore this addition to
+                #    the changed_attributes hash.
+                #    See MONGOID-4843 for a longer discussion about this.
+                reset_foreign_key_changes do
+                  _base.add_to_set(foreign_key => doc.public_send(_association.primary_key))
+
+                  if child_persistable?(doc)
+                    doc.save
+                  end
+                  reset_unloaded
+                end
+              end
+            end
+            unsynced(_base, foreign_key) and self
+          end
+
+          alias :push :<<
+
+          # Appends an array of documents to the association. Performs a batch
+          # insert of the documents instead of persisting one at a time.
+          #
+          # @example Concat with other documents.
+          #   person.posts.concat([ post_one, post_two ])
+          #
+          # @param [ Array<Document> ] documents The docs to add.
+          #
+          # @return [ Array<Document> ] The documents.
+          def concat(documents)
+            ids, docs, inserts = {}, [], []
+            documents.each do |doc|
+              next unless doc
+              append(doc)
+              if persistable? || _creating?
+                ids[doc.public_send(_association.primary_key)] = true
+                save_or_delay(doc, docs, inserts)
+              else
+                existing = _base.public_send(foreign_key)
+                unless existing.include?(doc.public_send(_association.primary_key))
+                  existing.push(doc.public_send(_association.primary_key)) and unsynced(_base, foreign_key)
+                end
+              end
+            end
+            if persistable? || _creating?
+              _base.push(foreign_key => ids.keys)
+            end
+            persist_delayed(docs, inserts)
+            self
+          end
+
+          # Build a new document from the attributes and append it to this
+          # association without saving.
+          #
+          # @example Build a new document on the association.
+          #   person.posts.build(:title => "A new post")
+          #
+          # @param [ Hash ] attributes The attributes of the new document.
+          # @param [ Class ] type The optional subclass to build.
+          #
+          # @return [ Document ] The new document.
+          def build(attributes = {}, type = nil)
+            doc = Factory.execute_build(type || klass, attributes, execute_callbacks: false)
+            append(doc)
+            doc.apply_post_processed_defaults
+            _base.public_send(foreign_key).push(doc.public_send(_association.primary_key))
+            unsynced(doc, inverse_foreign_key)
+            yield(doc) if block_given?
+            doc.run_pending_callbacks
+            doc
+          end
+
+          alias :new :build
+
+          # Delete the document from the association. This will set the foreign key
+          # on the document to nil. If the dependent options on the association are
+          # :delete_all or :destroy the appropriate removal will occur.
+          #
+          # @example Delete the document.
+          #   person.posts.delete(post)
+          #
+          # @param [ Document ] document The document to remove.
+          #
+          # @return [ Document ] The matching document.
+          def delete(document)
+            doc = super
+            if doc && persistable?
+              _base.pull(foreign_key => doc.public_send(_association.primary_key))
+              _target._unloaded = criteria
+              unsynced(_base, foreign_key)
+            end
+            doc
+          end
+
+          # Removes all associations between the base document and the target
+          # documents by deleting the foreign keys and the references, orphaning
+          # the target documents in the process.
+          #
+          # @example Nullify the association.
+          #   person.preferences.nullify
+          #
+          # @param [ Array<Document> ] replacement The replacement documents.
+          def nullify(replacement = [])
+            _target.each do |doc|
+              execute_callback :before_remove, doc
+            end
+            unless _association.forced_nil_inverse?
+              if field = _association.options[:inverse_primary_key]
+                ipk = _base.public_send(field)
+              else
+                ipk = _base._id
+              end
+              if replacement
+                objects_to_clear = _base.public_send(foreign_key) - replacement.collect do |object|
+                  object.public_send(_association.primary_key)
+                end
+                criteria(objects_to_clear).pull(inverse_foreign_key => ipk)
+              else
+                criteria.pull(inverse_foreign_key => ipk)
+              end
+            end
+            if persistable?
+              _base.set(foreign_key => _base.public_send(foreign_key).clear)
+            end
+            after_remove_error = nil
+            many_to_many = _target.clear do |doc|
+              unbind_one(doc)
+              unless _association.forced_nil_inverse?
+                doc.changed_attributes.delete(inverse_foreign_key)
+              end
+              begin
+                execute_callback :after_remove, doc
+              rescue => e
+                after_remove_error = e
+              end
+            end
+            raise after_remove_error if after_remove_error
+            many_to_many
+          end
+
+          alias :nullify_all :nullify
+          alias :clear :nullify
+          alias :purge :nullify
+
+          # Substitutes the supplied target documents for the existing documents
+          # in the association. If the new target is nil, perform the necessary
+          # deletion.
+          #
+          # @example Replace the association.
+          # person.preferences.substitute([ new_post ])
+          #
+          # @param [ Array<Document> ] replacement The replacement target.
+          #
+          # @return [ Many ] The association.
+          def substitute(replacement)
+            purge(replacement)
+            unless replacement.blank?
+              push(replacement.compact.uniq)
+            else
+              reset_unloaded
+              clear_foreign_key_changes
+            end
+            self
+          end
+
+          # Get a criteria for the documents without the default scoping
+          # applied.
+          #
+          # @example Get the unscoped criteria.
+          #   person.preferences.unscoped
+          #
+          # @return [ Criteria ] The unscoped criteria.
+          def unscoped
+            klass.unscoped.any_in(_id: _base.public_send(foreign_key))
+          end
+
+          private
+
+          # Clears the foreign key from the changed_attributes hash.
+          #
+          # This is, in general, used to clear the foreign key from the
+          # changed_attributes hash for consistency with the other referenced
+          # associations.
+          #
+          # @api private
+          def clear_foreign_key_changes
+            _base.changed_attributes.delete(foreign_key)
+          end
+
+          # Reset the value in the changed_attributes hash for the foreign key
+          # to its value before executing the given block.
+          #
+          # @api private
+          def reset_foreign_key_changes
+            if _base.changed_attributes.key?(foreign_key)
+              fk = _base.changed_attributes[foreign_key].dup
+              yield if block_given?
+              _base.changed_attributes[foreign_key] = fk
+            else
+              yield if block_given?
+              clear_foreign_key_changes
+            end
+          end
+
+          # Appends the document to the target array, updating the index on the
+          # document at the same time.
+          #
+          # @example Append the document to the association.
+          #   relation.append(document)
+          #
+          # @param [ Document ] document The document to append to the target.
+          def append(document)
+            execute_callbacks_around(:add, document) do
+              _target.push(document)
+              characterize_one(document)
+              bind_one(document)
+              yield if block_given?
+            end
+          end
+
+          # Instantiate the binding associated with this association.
+          #
+          # @example Get the binding.
+          #   relation.binding([ address ])
+          #
+          # @return [ Binding ] The binding.
+          def binding
+            HasAndBelongsToMany::Binding.new(_base, _target, _association)
+          end
+
+          # Determine if the child document should be persisted.
+          #
+          # @api private
+          #
+          # @example Is the child persistable?
+          #   relation.child_persistable?(doc)
+          #
+          # @param [ Document ] doc The document.
+          #
+          # @return [ true | false ] If the document can be persisted.
+          def child_persistable?(doc)
+            (persistable? || _creating?) &&
+                !(doc.persisted? && _association.forced_nil_inverse?)
+          end
+
+          # Returns the criteria object for the target class with its documents set
+          # to target.
+          #
+          # @example Get a criteria for the association.
+          #   relation.criteria
+          #
+          # @return [ Criteria ] A new criteria.
+          def criteria(id_list = nil)
+            _association.criteria(_base, id_list)
+          end
+
+          # Flag the base as unsynced with respect to the foreign key.
+          #
+          # @api private
+          #
+          # @example Flag as unsynced.
+          #   relation.unsynced(doc, :preference_ids)
+          #
+          # @param [ Document ] doc The document to flag.
+          # @param [ Symbol ] key The key to flag on the document.
+          #
+          # @return [ true ] true.
+          def unsynced(doc, key)
+            doc._synced[key] = false
+            true
+          end
+
+          class << self
+
+            # Get the Eager object for this type of association.
+            #
+            # @example Get the eager loader object
+            #
+            # @param [ Association ] association The association object.
+            # @param [ Array<Document> ] docs The array of documents.
+            def eager_loader(association, docs)
+              Eager.new(association, docs)
+            end
+
+            # Returns true if the association is an embedded one. In this case
+            # always false.
+            #
+            # @example Is this association embedded?
+            #   Referenced::ManyToMany.embedded?
+            #
+            # @return [ false ] Always false.
+            def embedded?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end