mongoid 8.1.2 → 8.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2100bfc3ff5a707914028bbcca16fe61db68cfc271f2603b79a9f420baccdd3a
-  data.tar.gz: c1147f2941f122d45a5678ed2c9d95ab840a65e1f8883970384f846f979bfb9f
+  metadata.gz: '059cd4652349083d2098577aa1c6f1f90233ab91474ef0a3f97db4bef4843f9f'
+  data.tar.gz: ca14035b9902221fe082862ea061f83beb2abc41a9a3eeb10dd0f781a34e697e
 SHA512:
-  metadata.gz: 4710b315e359d87807dc3b882b39d929eb52bf53612bf2d37e6bbf409309b3116773eab6e810b8b7dbbbfc33f24e135758c757b3de43dca4c591881b39d1e2df
-  data.tar.gz: 758af68d937986c4a01963ff9e8c6f106276fc40805c1133966d88461eabd19ca7b41e412b50566fe962b180525a925bae529ff5b58846fa8433336d8880a6ad
+  metadata.gz: 358e801040678c844022e9e41bcdd3a5d482cbafbe608b623340c834d4b72545df547afa83d861d64431703d198c4347f6d9bada41c2960d38b46fdc1a243855
+  data.tar.gz: 8a2981f0a6d4bb4b2c24b6a636079ad3e3cbd1586791104deca7c118d0a08f8753a9a2ce564b416293ce337154c965f26a9ce34f44f087dd0fa8c981d58684da

data/lib/mongoid/association/embedded/embeds_many/proxy.rb

@@ -227,9 +227,24 @@ module Mongoid
           # @example Are there persisted documents?
           #   person.posts.exists?
           #
-          # @return [ true | false ] True is persisted documents exist, false if not.
-          def exists?
-            _target.any? { |doc| doc.persisted? }
+          # @param [ :none | nil | false | Hash | Object ] id_or_conditions
+          #   When :none (the default), returns true if any persisted
+          #   documents exist in the association. When nil or false, this
+          #   will always return false. When a Hash is given, this queries
+          #   the documents in the association for those that match the given
+          #   conditions, and returns true if any match which have been
+          #   persisted. Any other argument is interpreted as an id, and
+          #   queries for the existence of persisted documents in the
+          #   association with a matching _id.
+          #
+          # @return [ true | false ] True if persisted documents exist, false if not.
+          def exists?(id_or_conditions = :none)
+            case id_or_conditions
+            when :none then _target.any?(&:persisted?)
+            when nil, false then false
+            when Hash then where(id_or_conditions).any?(&:persisted?)
+            else where(_id: id_or_conditions).any?(&:persisted?)
+            end
           end
 
           # Finds a document in this association through several different

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

@@ -172,9 +172,18 @@ module Mongoid
           # @example Are there persisted documents?
           #   person.posts.exists?
           #
+          # @param [ :none | nil | false | Hash | Object ] id_or_conditions
+          #   When :none (the default), returns true if any persisted
+          #   documents exist in the association. When nil or false, this
+          #   will always return false. When a Hash is given, this queries
+          #   the documents in the association for those that match the given
+          #   conditions, and returns true if any match. Any other argument is
+          #   interpreted as an id, and queries for the existence of documents
+          #   in the association with a matching _id.
+          #
           # @return [ true | false ] True is persisted documents exist, false if not.
-          def exists?
-            criteria.exists?
+          def exists?(id_or_conditions = :none)
+            criteria.exists?(id_or_conditions)
           end
 
           # Find the matching document on the association, either based on id or

data/lib/mongoid/config.rb

@@ -185,6 +185,19 @@ module Mongoid
     # See https://jira.mongodb.org/browse/MONGOID-5542
     option :prevent_multiple_calls_of_embedded_callbacks, default: false
 
+    # When this flag is true, callbacks for embedded documents will not be
+    # called. This is the default in 8.x, but will be changed to false in 9.0.
+    #
+    # Setting this flag to true (as it is in 8.x) may lead to stack
+    # overflow errors if there are more than cicrca 1000 embedded
+    # documents in the root document's dependencies graph.
+    #
+    # It is strongly recommended to set this flag to false in 8.x, if you
+    # are not using around callbacks for embedded documents.
+    #
+    # See https://jira.mongodb.org/browse/MONGOID-5658 for more details.
+    option :around_callbacks_for_embeds, default: true
+
     # Returns the Config singleton, for use in the configure DSL.
     #
     # @return [ self ] The Config singleton.

data/lib/mongoid/contextual/mongo.rb

@@ -69,7 +69,12 @@ module Mongoid
       # @return [ Integer ] The number of matches.
       def count(options = {}, &block)
         return super(&block) if block_given?
-        view.count_documents(options)
+
+        if valid_for_count_documents?
+          view.count_documents(options)
+        else
+          view.count(options)
+        end
       end
 
       # Get the estimated number of documents matching the query.
@@ -1046,6 +1051,24 @@ module Mongoid
         limit ? docs : docs.first
       end
 
+      # Queries whether the current context is valid for use with
+      # the #count_documents? predicate. A context is valid if it
+      # does not include a `$where` operator.
+      #
+      # @return [ true | false ] whether or not the current context
+      #   excludes a `$where` operator.
+      def valid_for_count_documents?(hash = view.filter)
+        # Note that `view.filter` is a BSON::Document, and all keys in a
+        # BSON::Document are strings; we don't need to worry about symbol
+        # representations of `$where`.
+        hash.keys.each do |key|
+          return false if key == '$where'
+          return false if hash[key].is_a?(Hash) && !valid_for_count_documents?(hash[key])
+        end
+
+        true
+      end
+
       def raise_document_not_found_error
         raise Errors::DocumentNotFound.new(klass, nil, nil)
       end

data/lib/mongoid/deprecable.rb

@@ -27,7 +27,8 @@ module Mongoid
     # @param [ [ Symbol | Hash<Symbol, [ Symbol | String ]> ]... ] *method_descriptors
     #   The methods to deprecate, with optional replacement instructions.
     def deprecate(target_module, *method_descriptors)
-      Mongoid::Deprecation.deprecate_methods(target_module, *method_descriptors)
+      @_deprecator ||= Mongoid::Deprecation.new
+      @_deprecator.deprecate_methods(target_module, *method_descriptors)
     end
   end
 end

data/lib/mongoid/deprecation.rb

@@ -15,10 +15,10 @@ module Mongoid
     #
     # @return Array<Proc> The deprecation behavior.
     def behavior
-      @behavior ||= Array(->(message, callstack, _deprecation_horizon, _gem_name) {
+      @behavior ||= Array(->(*args) {
         logger = Mongoid.logger
-        logger.warn(message)
-        logger.debug(callstack.join("\n  ")) if debug
+        logger.warn(args[0])
+        logger.debug(args[1].join("\n  ")) if debug
       })
     end
   end

data/lib/mongoid/extensions/hash.rb

@@ -43,7 +43,7 @@ module Mongoid
               real_key = klass.database_field_name(key2)
 
               value.delete(key2) if real_key != key2
-              value[real_key] = (key == "$rename") ? value2.to_s : mongoize_for(key, klass, real_key, value2)
+              value[real_key] = value_for(key, klass, real_key, value2)
             end
             consolidated[key] ||= {}
             consolidated[key].update(value)
@@ -185,6 +185,24 @@ module Mongoid
 
       private
 
+      # Get the value for the provided operator, klass, key and value.
+      #
+      # This is necessary for special cases like $rename, $addToSet and $push.
+      #
+      # @param [ String ] operator The operator.
+      # @param [ Class ] klass The model class.
+      # @param [ String | Symbol ] key The field key.
+      # @param [ Object ] value The original value.
+      #
+      # @return [ Object ] Value prepared for the provided operator.
+      def value_for(operator, klass, key, value)
+        case operator
+        when "$rename" then value.to_s
+        when "$addToSet", "$push" then value.mongoize
+        else mongoize_for(operator, klass, operator, value)
+        end
+      end
+
       # Mongoize for the klass, key and value.
       #
       # @api private

data/lib/mongoid/interceptable.rb

@@ -140,6 +140,28 @@ module Mongoid
     #
     # @api private
     def _mongoid_run_child_callbacks(kind, children: nil, &block)
+      if Mongoid::Config.around_callbacks_for_embeds
+        _mongoid_run_child_callbacks_with_around(kind, children: children, &block)
+      else
+        _mongoid_run_child_callbacks_without_around(kind, children: children, &block)
+      end
+    end
+
+    # Execute the callbacks of given kind for embedded documents including
+    # around callbacks.
+    #
+    # @note This method is prone to stack overflow errors if the document
+    #   has a large number of embedded documents. It is recommended to avoid
+    #   using around callbacks for embedded documents until a proper solution
+    #   is implemented.
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array<Document> ] children Children to execute callbacks on. If
+    #  nil, callbacks will be executed on all cascadable children of
+    #  the document.
+    #
+    #  @api private
+    def _mongoid_run_child_callbacks_with_around(kind, children: nil, &block)
       child, *tail = (children || cascadable_children(kind))
       with_children = !Mongoid::Config.prevent_multiple_calls_of_embedded_callbacks
       if child.nil?
@@ -148,23 +170,91 @@ module Mongoid
         child.run_callbacks(child_callback_type(kind, child), with_children: with_children, &block)
       else
         child.run_callbacks(child_callback_type(kind, child), with_children: with_children) do
-          _mongoid_run_child_callbacks(kind, children: tail, &block)
+          _mongoid_run_child_callbacks_with_around(kind, children: tail, &block)
         end
       end
     end
 
-    # This is used to store callbacks to be executed later. A good use case for
-    # this is delaying the after_find and after_initialize callbacks until the
-    # associations are set on the document. This can also be used to delay
-    # applying the defaults on a document.
+    # Execute the callbacks of given kind for embedded documents without
+    # around callbacks.
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array<Document> ] children Children to execute callbacks on. If
+    #   nil, callbacks will be executed on all cascadable children of
+    #   the document.
+    #
+    # @api private
+    def _mongoid_run_child_callbacks_without_around(kind, children: nil, &block)
+      children = (children || cascadable_children(kind))
+      callback_list = _mongoid_run_child_before_callbacks(kind, children: children)
+      return false if callback_list == false
+      value = block&.call
+      callback_list.each do |_next_sequence, env|
+        env.value &&= value
+      end
+      return false if _mongoid_run_child_after_callbacks(callback_list: callback_list) == false
+
+      value
+    end
+
+    # Execute the before callbacks of given kind for embedded documents.
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array<Document> ] children Children to execute callbacks on.
+    # @param [ Array<ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment> ] callback_list List of
+    #   pairs of callback sequence and environment. This list will be later used
+    #   to execute after callbacks in reverse order.
+    #
+    # @api private
+    def _mongoid_run_child_before_callbacks(kind, children: [], callback_list: [])
+      children.each do |child|
+        chain = child.__callbacks[child_callback_type(kind, child)]
+        env = ActiveSupport::Callbacks::Filters::Environment.new(child, false, nil)
+        next_sequence = compile_callbacks(chain)
+        unless next_sequence.final?
+          Mongoid.logger.warn("Around callbacks are disabled for embedded documents. Skipping around callbacks for #{child.class.name}.")
+          Mongoid.logger.warn("To enable around callbacks for embedded documents, set Mongoid::Config.around_callbacks_for_embeds to true.")
+        end
+        next_sequence.invoke_before(env)
+        return false if env.halted
+        env.value = !env.halted
+        callback_list << [next_sequence, env]
+        if (grandchildren = child.send(:cascadable_children, kind))
+          _mongoid_run_child_before_callbacks(kind, children: grandchildren, callback_list: callback_list)
+        end
+      end
+      callback_list
+    end
+
+    # Execute the after callbacks.
+    #
+    # @param [ Array<ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment> ] callback_list List of
+    #   pairs of callback sequence and environment.
+    def _mongoid_run_child_after_callbacks(callback_list: [])
+      callback_list.reverse_each do |next_sequence, env|
+        next_sequence.invoke_after(env)
+        return false if env.halted
+      end
+    end
+
+    # Returns the stored callbacks to be executed later.
     #
-    # @return [ Array<Symbol> ] an array of symbols that represent the pending callbacks.
+    # @return [ Array<Symbol> ] Method symbols of the stored pending callbacks.
     #
     # @api private
     def pending_callbacks
       @pending_callbacks ||= [].to_set
     end
 
+    # Stores callbacks to be executed later. A good use case for
+    # this is delaying the after_find and after_initialize callbacks until the
+    # associations are set on the document. This can also be used to delay
+    # applying the defaults on a document.
+    #
+    # @param [ Array<Symbol> ] value Method symbols of the pending callbacks to store.
+    #
+    # @return [ Array<Symbol> ] Method symbols of the stored pending callbacks.
+    #
     # @api private
     def pending_callbacks=(value)
       @pending_callbacks = value
@@ -299,7 +389,7 @@ module Mongoid
         end
         self.class.send :define_method, name do
           env = ActiveSupport::Callbacks::Filters::Environment.new(self, false, nil)
-          sequence = chain.compile
+          sequence = compile_callbacks(chain)
           sequence.invoke_before(env)
           env.value = !env.halted
           sequence.invoke_after(env)
@@ -309,5 +399,24 @@ module Mongoid
       end
       send(name)
     end
+
+    # Compile the callback chain.
+    #
+    # This method hides the differences between ActiveSupport implementations
+    # before and after 7.1.
+    #
+    # @param [ ActiveSupport::Callbacks::CallbackChain ] chain The callback chain.
+    # @param [ Symbol | nil ] type The type of callback chain to compile.
+    #
+    # @return [ ActiveSupport::Callbacks::CallbackSequence ] The compiled callback sequence.
+    def compile_callbacks(chain, type = nil)
+      if chain.method(:compile).arity == 0
+        # ActiveSupport < 7.1
+        chain.compile
+      else
+        # ActiveSupport >= 7.1
+        chain.compile(type)
+      end
+    end
   end
 end

data/lib/mongoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mongoid
-  VERSION = "8.1.2"
+  VERSION = "8.1.4"
 end

data/spec/integration/callbacks_spec.rb

@@ -557,6 +557,7 @@ describe 'callbacks integration tests' do
 
   context 'nested embedded documents' do
     config_override :prevent_multiple_calls_of_embedded_callbacks, true
+    config_override :around_callbacks_for_embeds, true
 
     let(:logger) { Array.new }
 
@@ -581,4 +582,24 @@ describe 'callbacks integration tests' do
       expect(logger).to eq(%i[embedded_twice embedded_once root])
     end
   end
+
+  context 'cascade callbacks' do
+    ruby_version_gte '3.0'
+    config_override :around_callbacks_for_embeds, false
+
+    let(:book) do
+      Book.new
+    end
+
+    before do
+      1500.times do
+        book.pages.build
+      end
+    end
+
+    # https://jira.mongodb.org/browse/MONGOID-5658
+    it 'does not raise SystemStackError' do
+      expect { book.save! }.not_to raise_error(SystemStackError)
+    end
+  end
 end

data/spec/mongoid/association/embedded/embeds_many/proxy_spec.rb

@@ -2310,9 +2310,37 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
         person.addresses.create!(street: "Bond St")
       end
 
+      let(:address) { person.addresses.first }
+
       it "returns true" do
         expect(person.addresses.exists?).to be true
       end
+
+      context 'when given specifying conditions' do
+        context 'when the record exists in the association' do
+          it 'returns true by condition' do
+            expect(person.addresses.exists?(street: 'Bond St')).to be true
+          end
+
+          it 'returns true by id' do
+            expect(person.addresses.exists?(address._id)).to be true
+          end
+
+          it 'returns false when given false' do
+            expect(person.addresses.exists?(false)).to be false
+          end
+
+          it 'returns false when given nil' do
+            expect(person.addresses.exists?(nil)).to be false
+          end
+        end
+
+        context 'when the record does not exist in the association' do
+          it 'returns false' do
+            expect(person.addresses.exists?(street: 'Garfield Ave')).to be false
+          end
+        end
+      end
     end
 
     context "when no documents exist in the database" do
@@ -2324,6 +2352,13 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
       it "returns false" do
         expect(person.addresses.exists?).to be false
       end
+
+      context 'when given specifying conditions' do
+        it 'returns false' do
+          expect(person.addresses.exists?(street: 'Hyde Park Dr')).to be false
+          expect(person.addresses.exists?(street: 'Garfield Ave')).to be false
+        end
+      end
     end
   end
 

data/spec/mongoid/association/referenced/has_many/proxy_spec.rb

@@ -2395,6 +2395,42 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           end
         end
       end
+
+      context 'when invoked with specifying conditions' do
+        let(:other_person) { Person.create! }
+        let(:post) { person.posts.first }
+
+        before do
+          person.posts.create title: 'bumfuzzle'
+          other_person.posts.create title: 'bumbershoot'
+        end
+
+        context 'when the conditions match an associated record' do
+          it 'detects its existence by condition' do
+            expect(person.posts.exists?(title: 'bumfuzzle')).to be true
+            expect(other_person.posts.exists?(title: 'bumbershoot')).to be true
+          end
+
+          it 'detects its existence by id' do
+            expect(person.posts.exists?(post._id)).to be true
+          end
+
+          it 'returns false when given false' do
+            expect(person.posts.exists?(false)).to be false
+          end
+
+          it 'returns false when given nil' do
+            expect(person.posts.exists?(nil)).to be false
+          end
+        end
+
+        context 'when the conditions match an unassociated record' do
+          it 'does not detect its existence' do
+            expect(person.posts.exists?(title: 'bumbershoot')).to be false
+            expect(other_person.posts.exists?(title: 'bumfuzzle')).to be false
+          end
+        end
+      end
     end
 
     context "when documents exist in application but not in database" do
@@ -2465,6 +2501,12 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           end
         end
       end
+
+      context 'when invoked with specifying conditions' do
+        it 'returns false' do
+          expect(person.posts.exists?(title: 'hullaballoo')).to be false
+        end
+      end
     end
   end
 

data/spec/mongoid/contextual/mongo_spec.rb

@@ -158,6 +158,16 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when for_js is present' do
+      let(:context) do
+        Band.for_js('this.name == "Depeche Mode"')
+      end
+
+      it 'counts the expected records' do
+        expect(context.count).to eq(1)
+      end
+    end
   end
 
   describe "#estimated_count" do
@@ -3690,16 +3700,51 @@ describe Mongoid::Contextual::Mongo do
 
         context "when the attributes are in the correct type" do
 
-          before do
-            context.update_all("$set" => { name: "Smiths" })
+          context "when operation is $set" do
+
+            before do
+              context.update_all("$set" => { name: "Smiths" })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.name).to eq("Smiths")
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.name).to eq("Smiths")
+            end
           end
 
-          it "updates the first matching document" do
-            expect(depeche_mode.reload.name).to eq("Smiths")
+          context "when operation is $push" do
+
+            before do
+              depeche_mode.update_attribute(:genres, ["electronic"])
+              new_order.update_attribute(:genres, ["electronic"])
+              context.update_all("$push" => { genres: "pop" })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.genres).to eq(["electronic", "pop"])
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.genres).to eq(["electronic", "pop"])
+            end
           end
 
-          it "updates the last matching document" do
-            expect(new_order.reload.name).to eq("Smiths")
+          context "when operation is $addToSet" do
+
+            before do
+              context.update_all("$addToSet" => { genres: "electronic" })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.genres).to eq(["electronic"])
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.genres).to eq(["electronic"])
+            end
           end
         end