mongoid 6.4.4 → 7.3.2

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+    module Referenced
+      module CounterCache
+        extend ActiveSupport::Concern
+
+        # Reset the given counter using the .count() query from the
+        # db. This method is usuful in case that a counter got
+        # corrupted, or a new counter was added to the collection.
+        #
+        # @example Reset the given counter cache
+        #   post.reset_counters(:comments)
+        #
+        # @param [ Symbol, Array ] counters One or more counter caches to reset
+        #
+        # @since 4.0.0
+        def reset_counters(*counters)
+          self.class.with(persistence_context) do |_class|
+            _class.reset_counters(self, *counters)
+          end
+        end
+
+        module ClassMethods
+
+          # Reset the given counter using the .count() query from the
+          # db. This method is usuful in case that a counter got
+          # corrupted, or a new counter was added to the collection.
+          #
+          # @example Reset the given counter cache
+          #   Post.reset_counters('50e0edd97c71c17ea9000001', :comments)
+          #
+          # @param [ String ] id The id of the object that will be reset.
+          # @param [ Symbol, Array ] counters One or more counter caches to reset
+          #
+          # @since 3.1.0
+          def reset_counters(id, *counters)
+            document = id.is_a?(Document) ? id : find(id)
+            counters.each do |name|
+              relation_association = relations[name]
+              counter_name = relation_association.inverse_association.counter_cache_column_name
+              document.update_attribute(counter_name, document.send(name).count)
+            end
+          end
+
+          # Update the given counters by the value factor. It uses the
+          # atomic $inc command.
+          #
+          # @example Add 5 to comments counter and remove 2 from likes
+          #   counter.
+          #   Post.update_counters('50e0edd97c71c17ea9000001',
+          #              :comments_count => 5, :likes_count => -2)
+          #
+          # @param [ String ] id The id of the object to update.
+          # @param [ Hash ] counters
+          #
+          # @since 3.1.0
+          def update_counters(id, counters)
+            where(:_id => id).inc(counters)
+          end
+
+          # Increment the counter name from the entries that match the
+          # id by one. This method is used on associations callbacks
+          # when counter_cache is enabled
+          #
+          # @example Increment comments counter
+          #   Post.increment_counter(:comments_count, '50e0edd97c71c17ea9000001')
+          #
+          # @param [ Symbol ] counter_name Counter cache name
+          # @param [ String ] id The id of the object that will have its counter incremented.
+          #
+          # @since 3.1.0
+          def increment_counter(counter_name, id)
+            update_counters(id, counter_name.to_sym => 1)
+          end
+
+          # Decrement the counter name from the entries that match the
+          # id by one. This method is used on associations callbacks
+          # when counter_cache is enabled
+          #
+          # @example Decrement comments counter
+          #   Post.decrement_counter(:comments_count, '50e0edd97c71c17ea9000001')
+          #
+          # @param [ Symbol ] counter_name Counter cache name
+          # @param [ String ] id The id of the object that will have its counter decremented.
+          #
+          # @since 3.1.0
+          def decrement_counter(counter_name, id)
+            update_counters(id, counter_name.to_sym => -1)
+          end
+        end
+
+        # Add the callbacks responsible for update the counter cache field.
+        #
+        # @api private
+        #
+        # @example Add the touchable.
+        #   Mongoid::Association::Referenced::CounterCache.define_callbacks!(association)
+        #
+        # @param [ Association ] association The association.
+        #
+        # @return [ Class ] The association's owning class.
+        #
+        # @since 7.0
+        def self.define_callbacks!(association)
+          name = association.name
+          cache_column = association.counter_cache_column_name.to_sym
+
+          association.inverse_class.tap do |klass|
+            klass.after_update do
+              if record = __send__(name)
+                foreign_key = association.foreign_key
+
+                if attribute_changed?(foreign_key)
+                  original, current = attribute_change(foreign_key)
+
+                  unless original.nil?
+                    record.class.with(persistence_context) do |_class|
+                      _class.decrement_counter(cache_column, original)
+                    end
+                  end
+
+                  unless current.nil?
+                    record[cache_column] = (record[cache_column] || 0) + 1
+                    record.class.with(record.persistence_context) do |_class|
+                      _class.increment_counter(cache_column, current) if record.persisted?
+                    end
+                  end
+                end
+              end
+            end
+
+            klass.after_create do
+              if record = __send__(name)
+                record[cache_column] = (record[cache_column] || 0) + 1
+
+                if record.persisted?
+                  record.class.with(record.persistence_context) do |_class|
+                    _class.increment_counter(cache_column, record._id)
+                  end
+                  record.remove_change(cache_column)
+                end
+              end
+            end
+
+            klass.before_destroy do
+              if record = __send__(name)
+                record[cache_column] = (record[cache_column] || 0) - 1 unless record.frozen?
+
+                if record.persisted?
+                  record.class.with(record.persistence_context) do |_class|
+                    _class.decrement_counter(cache_column, record._id)
+                  end
+                  record.remove_change(cache_column)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+    module Referenced
+      module Eager
+
+        # Base class for eager load preload functions.
+        #
+        # @since 4.0.0
+        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
+          #
+          # @since 4.0.0
+          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.
+          #
+          # @since 4.0.0
+          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
+          #
+          # @since 4.0.0
+          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.
+          #
+          # @since 4.0.0
+          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.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
+          #
+          # @since 4.0.0
+          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.
+          #
+          # @since 4.0.0
+          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
+          #
+          # @since 4.0.0
+          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.
+          #
+          # @since 4.0.0
+          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
+          #
+          # @since 4.0.0
+          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.
+          #
+          # @since 4.0.0
+          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,77 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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.
+          #
+          # @since 2.0.0.rc.1
+          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)
+          #
+          # @since 2.0.0.rc.1
+          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,43 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Association
+    module Referenced
+      class HasAndBelongsToMany
+
+        # The Builder behavior for has_and_belongs_to_many associations.
+        #
+        # @since 7.0
+        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