mongoid 9.0.3 → 9.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 421d53636b0e90abcfa52bf637229588d434ff73f14574b1d316b72009f7236b
-  data.tar.gz: fafa07a7cc9b17de0abbb140ca3d021e3041bfe00b67a424c81f6c15018e607d
+  metadata.gz: bb0499892233035ab6e0b07f3df4d08dfe7129c1b32830288e9453478b8aba9d
+  data.tar.gz: 5b02bd092e46dfb2aadfa580f3c8b3b4548b82d2e354eba4768ee6c1772eed98
 SHA512:
-  metadata.gz: d4f2011d1f85178a8693d653518f06e7ad55c1363958e3577f80d040e3986b595bdcaade0e71696ff762e008c195ee23b4579458708bb9e916f7ddfa8e3b9352
-  data.tar.gz: 8b981e1bc4e904085ecedfe459d31c91d06ed353ba0ceef3d67865ea195f31a36539284246b54537fc5af8b54eafcf1a60415eb88c4850d7cdf3af378d449206
+  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/attributes/readonly.rb

@@ -23,7 +23,7 @@ module Mongoid
       # @return [ true | false ] If the document is new, or if the field is not
       #   readonly.
       def attribute_writable?(name)
-        new_record? || (!readonly_attributes.include?(name) && _loaded?(name))
+        new_record? || (!self.class.readonly_attributes.include?(name) && _loaded?(name))
       end
 
       private
@@ -63,12 +63,17 @@ module Mongoid
         #   end
         #
         # @param [ Symbol... ] *names The names of the fields.
+        # @note When a parent class contains readonly attributes and is then
+        # inherited by a child class, the child class will inherit the
+        # parent's readonly attributes at the time of its creation.
+        # Updating the parent does not propagate down to child classes after wards.
         def attr_readonly(*names)
+          self.readonly_attributes = self.readonly_attributes.dup
           names.each do |name|
-            readonly_attributes << database_field_name(name)
+            self.readonly_attributes << database_field_name(name)
           end
         end
       end
     end
   end
-end
+end

data/lib/mongoid/criteria/queryable/selectable.rb

@@ -553,7 +553,7 @@ module Mongoid
         # @return [ Selectable ] The new selectable.
         def not(*criteria)
           if criteria.empty?
-            dup.tap { |query| query.negating = true }
+            dup.tap { |query| query.negating = !query.negating }
           else
             criteria.compact.inject(self.clone) do |c, new_s|
               if new_s.is_a?(Selectable)

data/lib/mongoid/equality.rb

@@ -18,6 +18,7 @@ module Mongoid
     #
     # @return [ Integer ] -1, 0, 1.
     def <=>(other)
+      return super unless other.is_a?(Mongoid::Equality)
       attributes["_id"].to_s <=> other.attributes["_id"].to_s
     end
 

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/loadable.rb

@@ -10,6 +10,13 @@ module Mongoid
     # (See #model_paths.)
     DEFAULT_MODEL_PATHS = %w( ./app/models ./lib/models ).freeze
 
+    # The default list of glob patterns that match paths to ignore when loading
+    # models. Defaults to '*/models/concerns/*', which Rails uses for extensions
+    # to models (and which cause errors when loaded out of order).
+    #
+    # See #ignore_patterns.
+    DEFAULT_IGNORE_PATTERNS = %w( */models/concerns/* ).freeze
+
     # Search a list of model paths to get every model and require it, so
     # that indexing and inheritance work in both development and production
     # with the same results.
@@ -24,17 +31,47 @@ module Mongoid
     #   for model files. These must either be absolute paths, or relative to
     #   the current working directory.
     def load_models(paths = model_paths)
-      paths.each do |path|
-        if preload_models.resizable?
-          files = preload_models.map { |model| "#{path}/#{model.underscore}.rb" }
+      files = files_under_paths(paths)
+
+      files.sort.each do |file|
+        load_model(file)
+      end
+
+      nil
+    end
+
+    # Given a list of paths, return all ruby files under that path (or, if
+    # `preload_models` is a list of model names, returns only the files for
+    # those named models).
+    #
+    # @param [ Array<String> ] paths the list of paths to search
+    #
+    # @return [ Array<String> ] the normalized file names, suitable for loading
+    #   via `require_dependency` or `require`.
+    def files_under_paths(paths)
+      paths.flat_map { |path| files_under_path(path) }
+    end
+
+    # Given a single path, returns all ruby files under that path (or, if
+    # `preload_models` is a list of model names, returns only the files for
+    # those named models).
+    #
+    # @param [ String ] path the path to search
+    #
+    # @return [ Array<String> ] the normalized file names, suitable for loading
+    #   via `require_dependency` or `require`.
+    def files_under_path(path)
+      files = if preload_models.resizable?
+          preload_models.
+            map { |model| "#{path}/#{model.underscore}.rb" }.
+            select { |file_name| File.exists?(file_name) }
         else
-          files = Dir.glob("#{path}/**/*.rb")
+          Dir.glob("#{path}/**/*.rb").
+            reject { |file_name| ignored?(file_name) }
         end
 
-        files.sort.each do |file|
-          load_model(file.gsub(/^#{path}\// , "").gsub(/\.rb$/, ""))
-        end
-      end
+      # strip the path and the suffix from each entry
+      files.map { |file| file.gsub(/^#{path}\// , "").gsub(/\.rb$/, "") }
     end
 
     # A convenience method for loading a model's file. If Rails'
@@ -71,6 +108,14 @@ module Mongoid
         DEFAULT_MODEL_PATHS
     end
 
+    # Returns the array of glob patterns that determine whether a given
+    # path should be ignored by the model loader.
+    #
+    # @return [ Array<String> ] the array of ignore patterns
+    def ignore_patterns
+      @ignore_patterns ||= DEFAULT_IGNORE_PATTERNS.dup
+    end
+
     # Sets the model paths to the given array of paths. These are the paths
     # where the application's model definitions are located.
     #
@@ -78,6 +123,25 @@ module Mongoid
     def model_paths=(paths)
       @model_paths = paths
     end
+
+    # Sets the ignore patterns to the given array of patterns. These are glob
+    # patterns that determine whether a given path should be ignored by the
+    # model loader or not.
+    #
+    # @param [ Array<String> ] patterns The list of glob patterns
+    def ignore_patterns=(patterns)
+      @ignore_patterns = patterns
+    end
+
+    # Returns true if the given file path matches any of the ignore patterns.
+    #
+    # @param [ String ] file_path The file path to consider
+    #
+    # @return [ true | false ] whether or not the given file path should be
+    #   ignored.
+    def ignored?(file_path)
+      ignore_patterns.any? { |pattern| File.fnmatch?(pattern, file_path) }
+    end
   end
 
 end

data/lib/mongoid/persistence_context.rb

@@ -138,7 +138,7 @@ module Mongoid
     # @return [ Symbol ] The client name for this persistence
     #   context.
     def client_name
-      @client_name ||= options[:client] ||
+      @client_name ||= __evaluate__(options[:client]) ||
                          Threaded.client_override ||
                          __evaluate__(storage_options[:client])
     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

@@ -8,6 +8,29 @@ module Mongoid
   # around traversing the document graph.
   module Traversable
     extend ActiveSupport::Concern
+    # This code is extracted from ActiveSupport so that we do not depend on
+    # their private API that may change at any time.
+    # This code should be reviewed and maybe removed when implementing
+    # https://jira.mongodb.org/browse/MONGOID-5832
+    class << self
+      # @api private
+      def __redefine(owner, name, value)
+        if owner.singleton_class?
+          owner.redefine_method(name) { value }
+          owner.send(:public, name)
+        end
+        owner.redefine_singleton_method(name) { value }
+        owner.singleton_class.send(:public, name)
+        owner.redefine_singleton_method("#{name}=") do |new_value|
+          if owner.equal?(self)
+            value = new_value
+          else
+            ::Mongoid::Traversable.redefine(self, name, new_value)
+          end
+        end
+        owner.singleton_class.send(:public, "#{name}=")
+      end
+    end
 
     # Class-level methods for the Traversable behavior.
     module ClassMethods
@@ -21,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.
@@ -105,11 +140,7 @@ module Mongoid
         if value
           Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
           value = value.to_s
-          if defined?(::ActiveSupport::ClassAttribute)
-            ::ActiveSupport::ClassAttribute.redefine(self, 'discriminator_key', value)
-          else
-            super
-          end
+          ::Mongoid::Traversable.__redefine(self, 'discriminator_key', value)
         else
           # When discriminator key is set to nil, replace the class's definition
           # of the discriminator key reader (provided by class_attribute earlier)

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.3"
+  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/attributes/readonly_spec.rb

@@ -266,7 +266,26 @@ describe Mongoid::Attributes::Readonly do
           expect(child.mother).to be_nil
         end
       end
+    end
+
+    context "when a subclass inherits readonly fields" do
+      let(:attributes) do
+        [:title, :terms]
+      end
+
+      before do
+        class OldPerson < Person
+          attr_readonly :age
+        end
+      end
 
+      it "ensures subclass inherits the readonly attributes from parent" do
+        expect(OldPerson.readonly_attributes.to_a).to include("title","terms")
+      end
+
+      it "ensures subclass does not modify parent's readonly attributes" do
+        expect(Person.readonly_attributes.to_a).not_to include("age")
+      end
     end
   end
 end

data/spec/mongoid/criteria/queryable/selectable_spec.rb

@@ -1939,6 +1939,35 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
+  describe "#not" do
+    context "when negating a criterion" do
+      let(:selection) do
+        query.not(field: /value/)
+      end
+
+      it "adds the $not selector" do
+        expect(selection.selector).to eq({
+          "field" => { "$not" => /value/ }
+        })
+      end
+
+      it "returns a cloned query" do
+        expect(selection).to_not equal(query)
+      end
+
+      context "when toggling negation state" do
+        it "negates the negating value" do
+          expect(query.negating).to be_nil 
+          negated_query = query.not
+          expect(negated_query.negating).to be true
+          double_negated_query = negated_query.not
+          expect(double_negated_query.negating).to be false
+        end
+      end
+    end
+  end
+
+
   describe Symbol do
 
     describe "#all" do

data/spec/mongoid/equality_spec.rb

@@ -189,6 +189,12 @@ describe Mongoid::Equality do
     it "compares based on the document id" do
       expect(first <=> second).to eq(-1)
     end
+    
+    it "doesn't break if one isn't a document" do
+      expect do
+        first <=> "Foo"
+      end.to_not raise_error
+    end
   end
 
   describe "#eql?" 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/loadable_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongoid::Loadable do
+  let(:lib_dir) { Pathname.new('../../lib').realpath(__dir__) }
+
+  shared_context 'with ignore_patterns' do
+    around do |example|
+      saved = Mongoid.ignore_patterns
+      Mongoid.ignore_patterns = ignore_patterns
+      example.run
+    ensure
+      Mongoid.ignore_patterns = saved
+    end
+  end
+
+  describe '#ignore_patterns' do
+    context 'when not explicitly set' do
+      it 'equals the default list of ignore patterns' do
+        expect(Mongoid.ignore_patterns).to eq Mongoid::Loadable::DEFAULT_IGNORE_PATTERNS
+      end
+    end
+
+    context 'when explicitly set' do
+      include_context 'with ignore_patterns'
+
+      let(:ignore_patterns) { %w[ pattern1 pattern2 ] }
+
+      it 'equals the list of specified patterns' do
+        expect(Mongoid.ignore_patterns).to eq ignore_patterns
+      end
+    end
+  end
+
+  describe '#files_under_path' do
+    let(:results) { Mongoid.files_under_path(lib_dir) }
+
+    include_context 'with ignore_patterns'
+
+    context 'when ignore_patterns is empty' do
+      let(:ignore_patterns) { [] }
+
+      it 'returns all ruby files' do
+        expect(results.length).to be > 10 # should be a bunch of them
+        expect(results).to include('rails/mongoid')
+      end
+    end
+
+    context 'when ignore_patterns is not empty' do
+      let(:ignore_patterns) { %w[ */rails/* ] }
+
+      it 'omits the ignored paths' do
+        expect(results.length).to be > 10 # should be a bunch of them
+        expect(results).not_to include('rails/mongoid')
+      end
+    end
+  end
+
+  describe '#files_under_paths' do
+    let(:paths) { [ lib_dir.join('mongoid'), lib_dir.join('rails') ] }
+    let(:results) { Mongoid.files_under_paths(paths) }
+
+    include_context 'with ignore_patterns'
+
+    context 'when ignore_patterns is empty' do
+      let(:ignore_patterns) { [] }
+
+      it 'returns all ruby files' do
+        expect(results.length).to be > 10 # should be a bunch
+        expect(results).to include('generators/mongoid/model/model_generator')
+        expect(results).to include('fields/encrypted')
+      end
+    end
+
+    context 'when ignore_patterns is not empty' do
+      let(:ignore_patterns) { %w[ */model/* */fields/* ] }
+
+      it 'returns all ruby files' do
+        expect(results.length).to be > 10 # should be a bunch
+        expect(results).not_to include('generators/mongoid/model/model_generator')
+        expect(results).not_to include('fields/encrypted')
+      end
+    end
+  end
+end

data/spec/mongoid/persistence_context_spec.rb

@@ -584,6 +584,14 @@ describe Mongoid::PersistenceContext do
         expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
       end
 
+      context 'when the client option is a proc' do
+        let(:options) { { client: -> { :alternative } } }
+
+        it 'evaluates the proc' do
+          expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+        end
+      end
+
       context 'when there is a client override' do
         persistence_context_override :client, :other
 

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,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mongoid
 version: !ruby/object:Gem::Version
-  version: 9.0.3
+  version: 9.0.5
 platform: ruby
 authors:
 - The MongoDB Ruby Team
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -830,6 +829,7 @@ files:
 - spec/mongoid/inspectable_spec.rb
 - spec/mongoid/interceptable_spec.rb
 - spec/mongoid/interceptable_spec_models.rb
+- spec/mongoid/loadable_spec.rb
 - spec/mongoid/loading_spec.rb
 - spec/mongoid/loggable_spec.rb
 - spec/mongoid/matcher/extract_attribute_data/numeric_keys.yml
@@ -1188,7 +1188,6 @@ metadata:
   documentation_uri: https://www.mongodb.com/docs/mongoid/
   homepage_uri: https://mongoid.org/
   source_code_uri: https://github.com/mongodb/mongoid
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -1203,8 +1202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.4.19
-signing_key: 
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Elegant Persistence in Ruby for MongoDB.
 test_files:
@@ -1552,6 +1550,7 @@ test_files:
 - spec/mongoid/inspectable_spec.rb
 - spec/mongoid/interceptable_spec.rb
 - spec/mongoid/interceptable_spec_models.rb
+- spec/mongoid/loadable_spec.rb
 - spec/mongoid/loading_spec.rb
 - spec/mongoid/loggable_spec.rb
 - spec/mongoid/matcher/extract_attribute_data/numeric_keys.yml