mongoid 6.4.8 → 7.0.0

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

@@ -0,0 +1,310 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Referenced
+      class HasAndBelongsToMany
+
+        # This class defines the behaviour for all relations 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 relation. 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.
+          #
+          # @since 2.0.0.beta.1
+          def <<(*args)
+            docs = args.flatten
+            return concat(docs) if docs.size > 1
+            if doc = docs.first
+              append(doc)
+              _base.add_to_set(foreign_key => doc.send(_association.primary_key))
+              if child_persistable?(doc)
+                doc.save
+              end
+            end
+            unsynced(_base, foreign_key) and self
+          end
+
+          alias :push :<<
+
+          # Appends an array of documents to the relation. 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.
+          #
+          # @since 2.4.0
+          def concat(documents)
+            ids, docs, inserts = {}, [], []
+            documents.each do |doc|
+              next unless doc
+              append(doc)
+              if persistable? || _creating?
+                ids[doc._id] = true
+                save_or_delay(doc, docs, inserts)
+              else
+                existing = _base.send(foreign_key)
+                unless existing.include?(doc._id)
+                  existing.push(doc._id) 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
+          # relation without saving.
+          #
+          # @example Build a new document on the relation.
+          #   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.
+          #
+          # @since 2.0.0.beta.1
+          def build(attributes = {}, type = nil)
+            doc = Factory.build(type || klass, attributes)
+            _base.send(foreign_key).push(doc._id)
+            append(doc)
+            doc.apply_post_processed_defaults
+            unsynced(doc, inverse_foreign_key)
+            yield(doc) if block_given?
+            doc
+          end
+
+          alias :new :build
+
+          # Delete the document from the relation. This will set the foreign key
+          # on the document to nil. If the dependent options on the relation are
+          # :delete 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.
+          #
+          # @since 2.1.0
+          def delete(document)
+            doc = super
+            if doc && persistable?
+              _base.pull(foreign_key => doc.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 relation.
+          #   person.preferences.nullify
+          #
+          # @param [ Array<Document> ] replacement The replacement documents.
+          #
+          # @since 2.0.0.rc.1
+          def nullify(replacement = [])
+            _target.each do |doc|
+              execute_callback :before_remove, doc
+            end
+            unless _association.forced_nil_inverse?
+              if replacement
+                objects_to_clear = _base.send(foreign_key) - replacement.collect(&:id)
+                criteria(objects_to_clear).pull(inverse_foreign_key => _base._id)
+              else
+                criteria.pull(inverse_foreign_key => _base._id)
+              end
+            end
+            if persistable?
+              _base.set(foreign_key => _base.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 relation. If the new target is nil, perform the necessary
+          # deletion.
+          #
+          # @example Replace the relation.
+          # person.preferences.substitute([ new_post ])
+          #
+          # @param [ Array<Document> ] replacement The replacement target.
+          #
+          # @return [ Many ] The relation.
+          #
+          # @since 2.0.0.rc.1
+          def substitute(replacement)
+            purge(replacement)
+            unless replacement.blank?
+              push(replacement.compact.uniq)
+            else
+              reset_unloaded
+            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.
+          #
+          # @since 2.4.0
+          def unscoped
+            klass.unscoped.any_in(_id: _base.send(foreign_key))
+          end
+
+          private
+
+          # Appends the document to the target array, updating the index on the
+          # document at the same time.
+          #
+          # @example Append the document to the relation.
+          #   relation.append(document)
+          #
+          # @param [ Document ] document The document to append to the target.
+          #
+          # @since 2.0.0.rc.1
+          def append(document)
+            execute_callback :before_add, document
+            _target.push(document)
+            characterize_one(document)
+            bind_one(document)
+            execute_callback :after_add, document
+          end
+
+          # Instantiate the binding associated with this relation.
+          #
+          # @example Get the binding.
+          #   relation.binding([ address ])
+          #
+          # @return [ Binding ] The binding.
+          #
+          # @since 2.0.0.rc.1
+          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.
+          #
+          # @since 3.0.20
+          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 relation.
+          #   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.
+          #
+          # @since 3.0.0
+          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.
+            #
+            # @since 7.0
+            def eager_loader(association, docs)
+              Eager.new(association, docs)
+            end
+
+            # Returns true if the relation is an embedded one. In this case
+            # always false.
+            #
+            # @example Is this relation embedded?
+            #   Referenced::ManyToMany.embedded?
+            #
+            # @return [ false ] Always false.
+            #
+            # @since 2.0.0.rc.1
+            def embedded?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,290 @@
+require 'mongoid/association/referenced/has_and_belongs_to_many/binding'
+require 'mongoid/association/referenced/has_and_belongs_to_many/buildable'
+require 'mongoid/association/referenced/has_and_belongs_to_many/proxy'
+require 'mongoid/association/referenced/has_and_belongs_to_many/eager'
+
+module Mongoid
+  module Association
+    module Referenced
+
+      # The HasAndBelongsToMany type association.
+      #
+      # @since 7.0
+      class HasAndBelongsToMany
+        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 = [
+            :after_add,
+            :after_remove,
+            :autosave,
+            :before_add,
+            :before_remove,
+            :counter_cache,
+            :dependent,
+            :foreign_key,
+            :index,
+            :order,
+            :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 type of the field holding the foreign key.
+        #
+        # @return [ Array ]
+        #
+        # @since 7.0
+        FOREIGN_KEY_FIELD_TYPE = Array
+
+        # The default foreign key suffix.
+        #
+        # @return [ String ] '_ids'
+        #
+        # @since 7.0
+        FOREIGN_KEY_SUFFIX = '_ids'.freeze
+
+        # The list of association complements.
+        #
+        # @return [ Array<Association> ] The association complements.
+        #
+        # @since 7.0
+        def relation_complements
+          @relation_complements ||= [ self.class ].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
+
+        # Is this association type embedded?
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def embedded?; false; end
+
+        # The default for validation the association object.
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 7.0
+        def validation_default; true; end
+
+        # Are ids only saved on this side of the relation?
+        #
+        # @return [ true, false ] Whether this association has a forced nil inverse.
+        #
+        # @since 7.0
+        def forced_nil_inverse?
+          @forced_nil_inverse ||= @options.key?(:inverse_of) && !@options[:inverse_of]
+        end
+
+        # Does this association type store the foreign key?
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 7.0
+        def stores_foreign_key?; true; end
+
+        # Get the relation proxy class for this association type.
+        #
+        # @return [ Association::HasAndBelongsToMany::Proxy ] The proxy class.
+        #
+        # @since 7.0
+        def relation
+          Proxy
+        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
+
+        # The criteria used for querying this relation.
+        #
+        # @return [ Mongoid::Criteria ] The criteria used for querying this relation.
+        #
+        # @since 7.0
+        def criteria(base, id_list = nil)
+          query_criteria(id_list || base.send(foreign_key))
+        end
+
+        # Get the foreign key field on the inverse.
+        #
+        # @return [ String ] The foreign key field for saving the association reference
+        #  on the inverse side.
+        #
+        # @since 7.0
+        def inverse_foreign_key
+          if @options.key?(:inverse_of)
+            inverse_of ? "#{inverse_of.to_s.singularize}#{FOREIGN_KEY_SUFFIX}" : nil
+          else
+            "#{inverse_class_name.demodulize.underscore}#{FOREIGN_KEY_SUFFIX}"
+          end
+        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
+
+        # Get the foreign key setter on the inverse.
+        #
+        # @return [ String ] The foreign key setter for saving the association reference
+        #  on the inverse side.
+        #
+        # @since 7.0
+        def inverse_foreign_key_setter
+          @inverse_foreign_key_setter ||= "#{inverse_foreign_key}=" if inverse_foreign_key
+        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.
+        #
+        # @since 7.0
+        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.
+        #   association.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
+
+        def setup_instance_methods!
+          define_getter!
+          define_setter!
+          define_dependency!
+          define_existence_check!
+          define_autosaver!
+          define_counter_cache_callbacks!
+          create_foreign_key_field!
+          setup_index!
+          setup_syncing!
+          @owner_class.validates_associated(name) if validate?
+          self
+        end
+
+        def index_spec
+          { key => 1 }
+        end
+
+        def default_primary_key
+          PRIMARY_KEY_DEFAULT
+        end
+
+        def default_foreign_key_field
+          @default_foreign_key_field ||= "#{name.to_s.singularize}#{FOREIGN_KEY_SUFFIX}"
+        end
+
+        def setup_syncing!
+          unless forced_nil_inverse?
+            synced_save
+            synced_destroy
+          end
+        end
+
+        def synced_destroy
+          assoc = self
+          inverse_class.set_callback(
+              :destroy,
+              :after
+          ) do |doc|
+            doc.remove_inverse_keys(assoc)
+          end
+        end
+
+        def synced_save
+          assoc = self
+          inverse_class.set_callback(
+              :save,
+              :after,
+              if: ->(doc){ doc._syncable?(assoc) }
+          ) do |doc|
+            doc.update_inverse_keys(assoc)
+          end
+        end
+
+        def create_foreign_key_field!
+          @owner_class.field(
+              foreign_key,
+              type: FOREIGN_KEY_FIELD_TYPE,
+              identity: true,
+              overwrite: true,
+              association: self,
+              default: nil
+          )
+        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 with_ordering(criteria)
+          if order
+            criteria.order_by(order)
+          else
+            criteria
+          end
+        end
+
+        def query_criteria(id_list)
+          crit = relation_class.all_of(primary_key => {"$in" => id_list || []})
+          with_ordering(crit)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations/bindings/referenced/many.rb → association/referenced/has_many/binding.rb}

@@ -1,11 +1,12 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
-    module Bindings
-      module Referenced
+  module Association
+    module Referenced
+      class HasMany
 
-        # Binding class for references_many relations.
-        class Many < Binding
+        # Binding class for has_many associations.
+        class Binding
+          include Bindable
 
           # Binds a single document with the inverse relation. Used
           # specifically when appending to the proxy.

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Referenced
+      class HasMany
+
+        # The Builder behavior for has_many associations.
+        #
+        # @since 7.0
+        module Buildable
+
+          # This method either takes an _id or an object and queries for the
+          # inverse side using the id or sets the object.
+          #
+          # @example Build the document.
+          #   relation.build(meta, attrs)
+          #
+          # @param [ Object ] base The base object.
+          # @param [ Object ] object The object to use to build the relation.
+          # @param [ String ] type The type of document to query for.
+          #
+          # @return [ Document ] A single document.
+          def build(base, object, type = nil)
+            return (object || []) unless query?(object)
+            return [] if object.is_a?(Array)
+            query_criteria(object, base)
+          end
+
+          private
+
+          def query?(object)
+            object && Array(object).all? { |d| !d.is_a?(Mongoid::Document) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+    module Referenced
+      class HasMany
+
+        # Eager class for has_many associations.
+        class Eager < Association::Referenced::Eager::Base
+
+          private
+
+          def preload
+            @docs.each do |d|
+              set_relation(d, [])
+            end
+
+            entries = Hash.new { |hash, key| hash[key] = [] }
+            each_loaded_document do |doc|
+              fk = doc.send(key)
+              entries[fk] << doc
+            end
+
+            entries.each do |id, docs|
+              set_on_parent(id, docs)
+            end
+          end
+
+          def set_relation(doc, element)
+            doc.__build__(@association.name, element, @association) unless doc.blank?
+          end
+
+          def group_by_key
+            @association.primary_key
+          end
+
+          def key
+            @association.foreign_key
+          end
+        end
+      end
+    end
+  end
+end