mongoid 9.0.4 → 9.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ac7ac8e60ba9d953a5a809d17b7fca7a2501988cdec50d12348af3b7022f615
-  data.tar.gz: 27a2bceb132e4f6b33d8be6b70ac8074b8de421c5c1efdb03f3ad2fc97d62364
+  metadata.gz: bb0499892233035ab6e0b07f3df4d08dfe7129c1b32830288e9453478b8aba9d
+  data.tar.gz: 5b02bd092e46dfb2aadfa580f3c8b3b4548b82d2e354eba4768ee6c1772eed98
 SHA512:
-  metadata.gz: 31cea6e77afe05358ff9cdaf5bc861807a93ce9c89e7cfd9209c0f35a2df816fb8d4d595faafbab2665b2dab776f523d0b96eece4b249626f976ec685765d5a5
-  data.tar.gz: 1367fb446dae452b73227c099e72ed2f13bd2702434e8050c09f3c1ae2ad97b5346371252ce3cfa3442151353bd8c8ef9a409cd2de75edb7cdf20ff3322107c7
+  metadata.gz: 96c1585ccba204b4c316920662aa5e750f3e0dd46a7849ca142d8b42d8b94ba8516c16ae9a194a30dd648937b94ec9247371035ddf951d93ec251eeb06fa15cd
+  data.tar.gz: 057f7cf03935fe694f385f186d74e3468d928f44dac47695ab58319e050ae86c25039083c1bf3debebdf8fdea9025347365b0e341040898cfdf2e09acbf72b31

data/lib/mongoid/association/eager_loadable.rb

@@ -42,6 +42,9 @@ module Mongoid
         docs_map = {}
         queue = [ klass.to_s ]
 
+        # account for single-collection inheritance
+        queue.push(klass.root_class.to_s) if klass != klass.root_class
+
         while klass = queue.shift
           if as = assoc_map.delete(klass)
             as.each do |assoc|

data/lib/mongoid/interceptable.rb

@@ -152,9 +152,13 @@ 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)
+        _mongoid_run_child_callbacks_with_around(kind,
+                                                 children: children,
+                                                 &block)
       else
-        _mongoid_run_child_callbacks_without_around(kind, children: children, &block)
+        _mongoid_run_child_callbacks_without_around(kind,
+                                                    children: children,
+                                                    &block)
       end
     end
 
@@ -235,9 +239,6 @@ module Mongoid
         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

data/lib/mongoid/timestamps/created.rb

@@ -23,13 +23,20 @@ module Mongoid
       # @example Set the created at time.
       #   person.set_created_at
       def set_created_at
-        if !timeless? && !created_at
+        if able_to_set_created_at?
           now = Time.current
           self.updated_at = now if is_a?(Updated) && !updated_at_changed?
           self.created_at = now
         end
         clear_timeless_option
       end
+
+      # Is the created timestamp able to be set?
+      #
+      # @return [ true, false ] If the timestamp can be set.
+      def able_to_set_created_at?
+        !frozen? && !timeless? && !created_at
+      end
     end
   end
 end

data/lib/mongoid/traversable.rb

@@ -44,6 +44,18 @@ module Mongoid
         !!(superclass < Mongoid::Document)
       end
 
+      # Returns the root class of the STI tree that the current
+      # class participates in. If the class is not an STI subclass, this
+      # returns the class itself.
+      #
+      # @return [ Mongoid::Document ] the root of the STI tree
+      def root_class
+        root = self
+        root = root.superclass while root.hereditary?
+
+        root
+      end
+
       # When inheriting, we want to copy the fields from the parent class and
       # set the on the child to start, mimicking the behavior of the old
       # class_inheritable_accessor that was deprecated in Rails edge.

data/lib/mongoid/validatable/associated.rb

@@ -74,7 +74,7 @@ module Mongoid
           # use map.all? instead of just all?, because all? will do short-circuit
           # evaluation and terminate on the first failed validation.
           list.map do |value|
-            if value && !value.flagged_for_destroy? && (!value.persisted? || value.changed?)
+            if value && !value.flagged_for_destroy?
               value.validated? ? true : value.valid?
             else
               true

data/lib/mongoid/version.rb

@@ -2,5 +2,5 @@
 # rubocop:todo all
 
 module Mongoid
-  VERSION = "9.0.4"
+  VERSION = "9.0.5"
 end

data/spec/mongoid/association/eager_spec.rb

@@ -15,14 +15,36 @@ describe Mongoid::Association::EagerLoadable do
       Mongoid::Contextual::Mongo.new(criteria)
     end
 
+    let(:association_host) { Account }
+
     let(:inclusions) do
       includes.map do |key|
-        Account.reflect_on_association(key)
+        association_host.reflect_on_association(key)
       end
     end
 
     let(:doc) { criteria.first }
 
+    context 'when root is an STI subclass' do
+      # Driver has_one Vehicle
+      # Vehicle belongs_to Driver
+      # Truck is a Vehicle
+
+      before do
+        Driver.create!(vehicle: Truck.new)
+      end
+
+      let(:criteria) { Truck.all }
+      let(:includes) { %i[ driver ] }
+      let(:association_host) { Truck }
+
+      it 'preloads the driver' do
+        expect(doc.ivar(:driver)).to be false
+        context.preload(inclusions, [ doc ])
+        expect(doc.ivar(:driver)).to be == Driver.first
+      end
+    end
+
     context "when belongs_to" do
 
       let!(:account) do
@@ -43,7 +65,7 @@ describe Mongoid::Association::EagerLoadable do
       it "preloads the parent" do
         expect(doc.ivar(:person)).to be false
         context.preload(inclusions, [doc])
-        expect(doc.ivar(:person)).to eq(doc.person)
+        expect(doc.ivar(:person)).to be == person
       end
     end
 

data/spec/mongoid/association_spec.rb

@@ -115,6 +115,66 @@ describe Mongoid::Association do
         expect(name).to_not be_an_embedded_many
       end
     end
+
+    context "when validation depends on association" do
+      before(:all) do
+        class Author
+          include Mongoid::Document
+          embeds_many :books, cascade_callbacks: true
+          field :condition, type: Boolean
+        end
+
+        class Book
+          include Mongoid::Document
+          embedded_in :author
+          validate :parent_condition_is_not_true
+
+          def parent_condition_is_not_true
+            return unless author&.condition
+            errors.add :base, "Author condition is true."
+          end
+        end
+
+        Author.delete_all
+        Book.delete_all
+      end
+
+      let(:author) { Author.new }
+      let(:book) { Book.new }
+
+      context "when author is not persisted" do
+        it "is valid without books" do
+          expect(author.valid?).to be true
+        end
+
+        it "is valid with a book" do
+          author.books << book
+          expect(author.valid?).to be true
+        end
+
+        it "is not valid when condition is true with a book" do
+          author.condition = true
+          author.books << book
+          expect(author.valid?).to be false
+        end
+      end
+
+      context "when author is persisted" do
+        before do
+          author.books << book
+          author.save
+        end
+
+        it "remains valid initially" do
+          expect(author.valid?).to be true
+        end
+
+        it "becomes invalid when condition is set to true" do
+          author.update_attributes(condition: true)
+          expect(author.valid?).to be false
+        end
+      end
+    end
   end
 
   describe "#embedded_one?" do

data/spec/mongoid/interceptable_spec.rb

@@ -389,6 +389,84 @@ describe Mongoid::Interceptable do
         end
       end
     end
+
+    context 'with embedded grandchildren' do
+      IS = InterceptableSpec
+
+      context 'when creating' do
+        let(:registry) { IS::CallbackRegistry.new(only: %i[ before_save ]) }
+
+        let(:expected_calls) do
+          [
+            # the parent
+            [ IS::CbParent, :before_save ],
+
+            # the immediate child of the parent
+            [ IS::CbCascadedNode, :before_save ],
+
+            # the grandchild of the parent
+            [ IS::CbCascadedNode, :before_save ],
+          ]
+        end
+
+        let!(:parent) do
+          parent = IS::CbParent.new(registry)
+          child = IS::CbCascadedNode.new(registry)
+          grandchild = IS::CbCascadedNode.new(registry)
+
+          child.cb_cascaded_nodes = [ grandchild ]
+          parent.cb_cascaded_nodes = [ child ]
+
+          parent.tap(&:save)
+        end
+
+        it 'should cascade callbacks to grandchildren' do
+          expect(registry.calls).to be == expected_calls
+        end
+      end
+
+      context 'when updating' do
+        let(:registry) { IS::CallbackRegistry.new(only: %i[ before_update ]) }
+
+        let(:expected_calls) do
+          [
+            # the parent
+            [ IS::CbParent, :before_update ],
+
+            # the immediate child of the parent
+            [ IS::CbCascadedNode, :before_update ],
+
+            # the grandchild of the parent
+            [ IS::CbCascadedNode, :before_update ],
+          ]
+        end
+
+        let!(:parent) do
+          parent = IS::CbParent.new(nil)
+          child = IS::CbCascadedNode.new(nil)
+          grandchild = IS::CbCascadedNode.new(nil)
+
+          child.cb_cascaded_nodes = [ grandchild ]
+          parent.cb_cascaded_nodes = [ child ]
+
+          parent.save
+
+          parent.callback_registry = registry
+          child.callback_registry = registry
+          grandchild.callback_registry = registry
+
+          parent.name = 'updated'
+          child.name = 'updated'
+          grandchild.name = 'updated'
+
+          parent.tap(&:save)
+        end
+
+        it 'should cascade callbacks to grandchildren' do
+          expect(registry.calls).to be == expected_calls
+        end
+      end
+    end
   end
 
   describe ".before_destroy" do

data/spec/mongoid/interceptable_spec_models.rb

@@ -1,11 +1,13 @@
 # rubocop:todo all
 module InterceptableSpec
   class CallbackRegistry
-    def initialize
+    def initialize(only: [])
       @calls = []
+      @only = only
     end
 
     def record_call(cls, cb)
+      return unless @only.empty? || @only.any? { |pat| pat == cb }
       @calls << [cls, cb]
     end
 
@@ -16,6 +18,8 @@ module InterceptableSpec
     extend ActiveSupport::Concern
 
     included do
+      field :name, type: String
+
       %i(
         validation save create update
       ).each do |what|
@@ -35,199 +39,110 @@ module InterceptableSpec
         end
       end
     end
-  end
-
-  class CbHasOneParent
-    include Mongoid::Document
 
-    has_one :child, autosave: true, class_name: "CbHasOneChild", inverse_of: :parent
+    attr_accessor :callback_registry
 
-    def initialize(callback_registry)
+    def initialize(callback_registry, *args, **kwargs)
       @callback_registry = callback_registry
-      super()
+      super(*args, **kwargs)
     end
+  end
 
-    attr_accessor :callback_registry
-
+  module RootInsertable
     def insert_as_root
       @callback_registry&.record_call(self.class, :insert_into_database)
       super
     end
+  end
 
+  class CbHasOneParent
+    include Mongoid::Document
     include CallbackTracking
+    include RootInsertable
+
+    has_one :child, autosave: true, class_name: "CbHasOneChild", inverse_of: :parent
   end
 
   class CbHasOneChild
     include Mongoid::Document
+    include CallbackTracking
 
     belongs_to :parent, class_name: "CbHasOneParent", inverse_of: :child
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    include CallbackTracking
   end
 
   class CbHasManyParent
     include Mongoid::Document
+    include CallbackTracking
+    include RootInsertable
 
     has_many :children, autosave: true, class_name: "CbHasManyChild", inverse_of: :parent
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    def insert_as_root
-      @callback_registry&.record_call(self.class, :insert_into_database)
-      super
-    end
-
-    include CallbackTracking
   end
 
   class CbHasManyChild
     include Mongoid::Document
+    include CallbackTracking
 
     belongs_to :parent, class_name: "CbHasManyParent", inverse_of: :children
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    include CallbackTracking
   end
 
   class CbEmbedsOneParent
     include Mongoid::Document
+    include CallbackTracking
+    include RootInsertable
 
     field :name
 
     embeds_one :child, cascade_callbacks: true, class_name: "CbEmbedsOneChild", inverse_of: :parent
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    def insert_as_root
-      @callback_registry&.record_call(self.class, :insert_into_database)
-      super
-    end
-
-    include CallbackTracking
   end
 
   class CbEmbedsOneChild
     include Mongoid::Document
+    include CallbackTracking
 
     field :age
 
     embedded_in :parent, class_name: "CbEmbedsOneParent", inverse_of: :child
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    include CallbackTracking
   end
 
   class CbEmbedsManyParent
     include Mongoid::Document
+    include CallbackTracking
+    include RootInsertable
 
     embeds_many :children, cascade_callbacks: true, class_name: "CbEmbedsManyChild", inverse_of: :parent
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    def insert_as_root
-      @callback_registry&.record_call(self.class, :insert_into_database)
-      super
-    end
-
-    include CallbackTracking
   end
 
   class CbEmbedsManyChild
     include Mongoid::Document
+    include CallbackTracking
 
     embedded_in :parent, class_name: "CbEmbedsManyParent", inverse_of: :children
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
-
-    include CallbackTracking
   end
 
   class CbParent
     include Mongoid::Document
-
-    def initialize(callback_registry)
-      @callback_registry = callback_registry
-      super()
-    end
-
-    attr_accessor :callback_registry
+    include CallbackTracking
 
     embeds_many :cb_children
     embeds_many :cb_cascaded_children, cascade_callbacks: true
-
-    include CallbackTracking
+    embeds_many :cb_cascaded_nodes, cascade_callbacks: true, as: :parent
   end
 
   class CbChild
     include Mongoid::Document
+    include CallbackTracking
 
     embedded_in :cb_parent
-
-    def initialize(callback_registry, options)
-      @callback_registry = callback_registry
-      super(options)
-    end
-
-    attr_accessor :callback_registry
-
-    include CallbackTracking
   end
 
   class CbCascadedChild
     include Mongoid::Document
+    include CallbackTracking
 
     embedded_in :cb_parent
 
-    def initialize(callback_registry, options)
-      @callback_registry = callback_registry
-      super(options)
-    end
-
-    attr_accessor :callback_registry
-
     before_save :test_mongoid_state
 
-    include CallbackTracking
-
     private
 
     # Helps test that cascading child callbacks have access to the Mongoid
@@ -238,6 +153,15 @@ module InterceptableSpec
       Mongoid::Threaded.stack('interceptable').push(self)
     end
   end
+
+  class CbCascadedNode
+    include Mongoid::Document
+    include CallbackTracking
+
+    embedded_in :parent, polymorphic: true
+
+    embeds_many :cb_cascaded_nodes, cascade_callbacks: true, as: :parent
+  end
 end
 
 class InterceptableBand

data/spec/mongoid/timestamps/created_spec.rb

@@ -44,4 +44,27 @@ describe Mongoid::Timestamps::Created do
       expect(quiz.created_at).to be_within(10).of(Time.now.utc)
     end
   end
+
+  context "when the document is destroyed" do
+    let(:book) do
+      Book.create!
+    end
+
+    before do
+      Cover.before_save do
+        destroy if title == "delete me"
+      end
+    end
+
+    after do
+      Cover.reset_callbacks(:save)
+    end
+
+    it "does not set the created_at timestamp" do
+      book.covers << Cover.new(title: "delete me")
+      expect {
+        book.save
+      }.not_to raise_error
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mongoid
 version: !ruby/object:Gem::Version
-  version: 9.0.4
+  version: 9.0.5
 platform: ruby
 authors:
 - The MongoDB Ruby Team
 bindir: bin
 cert_chain: []
-date: 2025-01-08 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -1202,7 +1202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Elegant Persistence in Ruby for MongoDB.
 test_files: