mongoid 9.0.3 → 9.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 421d53636b0e90abcfa52bf637229588d434ff73f14574b1d316b72009f7236b
-  data.tar.gz: fafa07a7cc9b17de0abbb140ca3d021e3041bfe00b67a424c81f6c15018e607d
+  metadata.gz: 3ac7ac8e60ba9d953a5a809d17b7fca7a2501988cdec50d12348af3b7022f615
+  data.tar.gz: 27a2bceb132e4f6b33d8be6b70ac8074b8de421c5c1efdb03f3ad2fc97d62364
 SHA512:
-  metadata.gz: d4f2011d1f85178a8693d653518f06e7ad55c1363958e3577f80d040e3986b595bdcaade0e71696ff762e008c195ee23b4579458708bb9e916f7ddfa8e3b9352
-  data.tar.gz: 8b981e1bc4e904085ecedfe459d31c91d06ed353ba0ceef3d67865ea195f31a36539284246b54537fc5af8b54eafcf1a60415eb88c4850d7cdf3af378d449206
+  metadata.gz: 31cea6e77afe05358ff9cdaf5bc861807a93ce9c89e7cfd9209c0f35a2df816fb8d4d595faafbab2665b2dab776f523d0b96eece4b249626f976ec685765d5a5
+  data.tar.gz: 1367fb446dae452b73227c099e72ed2f13bd2702434e8050c09f3c1ae2ad97b5346371252ce3cfa3442151353bd8c8ef9a409cd2de75edb7cdf20ff3322107c7

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/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/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
@@ -105,11 +128,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/version.rb

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

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/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
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mongoid
 version: !ruby/object:Gem::Version
-  version: 9.0.3
+  version: 9.0.4
 platform: ruby
 authors:
 - The MongoDB Ruby Team
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2025-01-08 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.2
 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