mongoid 8.1.3 → 8.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 561c6173b8a11bb858b0df7dc72cec9e96767e7780572ecbc1233c11de84fb6a
-  data.tar.gz: 1bc15420d04291843d26e52d1d04f2689d3e28b25db115d5a5f2c765b872fd30
+  metadata.gz: 21db50efa946dce1a9e43718d0e15d37c0e4373c9d693123d21cfe13b8afb3bf
+  data.tar.gz: 7d01ee5d5a8eb3c81a92c3055e94bf8bb90a8a911258401459b5e447c45a220c
 SHA512:
-  metadata.gz: 112499f5ac9998aa952c851ac4e6d64014bf35fcfeeed0b29bdb5fac5519866657b8f7fe087a001033cee7adcf1f07a7eb4b4c68dcef2611cbf36a1aef22d31c
-  data.tar.gz: 43f784a2d2d5782f464f064d35bd384a6711a2355f6a1cd3f9529372184928ecac9d2e74e4cf90092857733945a10c08452ede7e1a4cbba903d3617d5ccbf601
+  metadata.gz: f1e10a0cb03863509acb1d150460e4f7c475092b45bb65f7619ecd8f0384d4ed6e92416565a07e6e900af26fbf26b32c4cd2c9418c4dfbe1f858da451a3e9378
+  data.tar.gz: e2e75603f8ba8f3debead96161f81350ced4696aac125ba0b17f48a94a42cc48e867651deb1b6a60c3d57f48fa237f26ac61775f3c2be3750f62fc2b66d27661

data/Rakefile

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "bundler"
-require "bundler/gem_tasks"
 Bundler.setup
 
 ROOT = File.expand_path(File.join(File.dirname(__FILE__)))
@@ -10,34 +9,53 @@ $: << File.join(ROOT, 'spec/shared/lib')
 
 require "rake"
 require "rspec/core/rake_task"
-require 'mrss/spec_organizer'
-require 'rubygems/package'
-require 'rubygems/security/policies'
-
-def signed_gem?(path_to_gem)
-  Gem::Package.new(path_to_gem, Gem::Security::HighSecurity).verify
-  true
-rescue Gem::Security::Exception => e
-  false
-end
-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "mongoid/version"
 
-tasks = Rake.application.instance_variable_get('@tasks')
-tasks['release:do'] = tasks.delete('release')
+if File.exist?('./spec/shared/lib/tasks/candidate.rake')
+  load 'spec/shared/lib/tasks/candidate.rake'
+end
 
-task :gem => :build
+desc 'Build the gem'
 task :build do
-  system "gem build mongoid.gemspec"
+  command = %w[ gem build ]
+  command << "--output=#{ENV['GEM_FILE_NAME']}" if ENV['GEM_FILE_NAME']
+  command << (ENV['GEMSPEC'] || 'mongoid.gemspec')
+  system(*command)
 end
 
-task :install => :build do
-  system "sudo gem install mongoid-#{Mongoid::VERSION}.gem"
+# `rake version` is used by the deployment system so get the release version
+# of the product beng deployed. It must do nothing more than just print the
+# product version number.
+# 
+# See the mongodb-labs/driver-github-tools/ruby/publish Github action.
+desc "Print the current value of Mongoid::VERSION"
+task :version do
+  require 'mongoid/version'
+
+  puts Mongoid::VERSION
 end
 
+# overrides the default Bundler-provided `release` task, which also
+# builds the gem. Our release process assumes the gem has already
+# been built (and signed via GPG), so we just need `rake release` to
+# push the gem to rubygems.
 task :release do
-  raise "Please use ./release.sh to release"
+  require 'mongoid/version'
+
+  if ENV['GITHUB_ACTION'].nil?
+    abort <<~WARNING
+      `rake release` must be invoked from the `Mongoid Release` GitHub action,
+      and must not be invoked locally. This ensures the gem is properly signed
+      and distributed by the appropriate user.
+
+      Note that it is the `rubygems/release-gem@v1` step in the `Mongoid Release`
+      action that invokes this task. Do not rename or remove this task, or the
+      release-gem step will fail. Reimplement this task with caution.
+
+      mongoid-#{Mongoid::VERSION}.gem was NOT pushed to RubyGems.
+    WARNING
+  end
+
+  system 'bundle', 'exec', 'gem', 'push', "mongoid-#{Mongoid::VERSION}.gem"
 end
 
 RSpec::Core::RakeTask.new("spec") do |spec|
@@ -64,6 +82,8 @@ RUN_PRIORITY = %i(
 )
 
 def spec_organizer
+  require 'mrss/spec_organizer'
+
   Mrss::SpecOrganizer.new(
     root: ROOT,
     classifiers: CLASSIFIERS,
@@ -99,32 +119,10 @@ task :docs => 'docs:yard'
 namespace :docs do
   desc "Generate yard documention"
   task :yard do
+    require "mongoid/version"
+
     out = File.join('yard-docs', Mongoid::VERSION)
     FileUtils.rm_rf(out)
     system "yardoc -o #{out} --title mongoid-#{Mongoid::VERSION}"
   end
 end
-
-namespace :release do
-  task :check_private_key do
-    unless File.exist?('gem-private_key.pem')
-      raise "No private key present, cannot release"
-    end
-  end
-end
-
-desc 'Verifies that all built gems in pkg/ are valid'
-task :verify do
-  gems = Dir['pkg/*.gem']
-  if gems.empty?
-    puts 'There are no gems in pkg/ to verify'
-  else
-    gems.each do |gem|
-      if signed_gem?(gem)
-        puts "#{gem} is signed"
-      else
-        abort "#{gem} is not signed"
-      end
-    end
-  end
-end

data/lib/mongoid/association/accessors.rb

@@ -115,7 +115,11 @@ module Mongoid
         # during binding or when cascading callbacks. Whenever we retrieve
         # associations within the codebase, we use without_autobuild.
         if !without_autobuild? && association.embedded? && attribute_missing?(field_name)
-          raise ActiveModel::MissingAttributeError, "Missing attribute: '#{field_name}'"
+          # We always allow accessing the parent document of an embedded one.
+          try_get_parent = association.is_a?(
+                             Mongoid::Association::Embedded::EmbeddedIn
+                           ) && field_name == association.key
+          raise ActiveModel::MissingAttributeError, "Missing attribute: '#{field_name}'" unless try_get_parent
         end
 
         if !reload && (value = ivar(name)) != false

data/lib/mongoid/association/eager_loadable.rb

@@ -31,6 +31,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/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/embedded/embeds_one/proxy.rb

@@ -32,8 +32,8 @@ module Mongoid
               bind_one
               characterize_one(_target)
               update_attributes_hash(_target)
-              _base._reset_memoized_descendants!
               _target.save if persistable?
+              _base._reset_memoized_descendants!
             end
           end
 

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

@@ -422,11 +422,28 @@ module Mongoid
           #
           # @return [ Integer ] The size of the enumerable.
           def size
-            count = (_unloaded ? _unloaded.count : _loaded.count)
-            if count.zero?
-              count + _added.count
+            # If _unloaded is present, then it will match the set of documents
+            # that belong to this association, which have already been persisted
+            # to the database. This set of documents must be considered when
+            # computing the size of the association, along with anything that has
+            # since been added.
+            if _unloaded
+              if _added.any?
+                # Note that _added may include records that _unloaded already
+                # matches. This is the case if the association is assigned an array
+                # of items and some of them were already elements of the association.
+                #
+                # we need to thus make sure _unloaded.count excludes any elements
+                # that already exist in _added.
+
+                count = _unloaded.not(:_id.in => _added.values.map(&:id)).count
+                count + _added.values.count
+              else
+                _unloaded.count
+              end
+
             else
-              count + _added.values.count { |d| d.new_record? }
+              _loaded.count + _added.count
             end
           end
 

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

@@ -178,13 +178,15 @@ module Mongoid
     #
     # @return [ Object ] The associated path.
     def atomic_paths
-      @atomic_paths ||= begin
-        if _association
-          _association.path(self)
-        else
-          Atomic::Paths::Root.new(self)
-        end
-      end
+      return @atomic_paths if @atomic_paths
+
+      paths = if _association
+                _association.path(self)
+              else
+                Atomic::Paths::Root.new(self)
+              end
+
+      paths.tap { @atomic_paths = paths unless new_record? }
     end
 
     # Get all the attributes that need to be pulled.

data/lib/mongoid/attributes/readonly.rb

@@ -22,7 +22,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
@@ -62,12 +62,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/contextual/mongo.rb

@@ -1091,7 +1091,7 @@ module Mongoid
       end
 
       def retrieve_nth_to_last_with_limit(n, limit)
-        v = view.sort(inverse_sorting).skip(n).limit(limit || 1)
+        v = view.sort(inverse_sorting).limit(limit || 1)
         v = v.skip(n) if n > 0
         raw_docs = v.to_a.reverse
         process_raw_docs(raw_docs, limit)

data/lib/mongoid/criteria/queryable/extensions/numeric.rb

@@ -43,7 +43,21 @@ module Mongoid
             #
             # @return [ Object ] The converted number.
             def __numeric__(object)
-              object.to_s.match?(/\A[-+]?[0-9]*[0-9.]0*\z/) ? object.to_i : Float(object)
+              str = object.to_s
+              raise ArgumentError if str.empty?
+
+              # These requirements seem a bit odd, but they're explicitly specified in the tests,
+              # so we're obligated to keep them, for now. (This code was rewritten from a one-line
+              # regex, due to security concerns with a polynomial regex being used on uncontrolled
+              # data).
+
+              str = str.chop if str.end_with?('.')
+              return 0 if str.empty?
+
+              result = Integer(str) rescue Float(object)
+
+              integer = result.to_i
+              integer == result ? integer : result
             end
 
             # Evolve the object to an integer.

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

@@ -552,7 +552,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/document.rb

@@ -133,7 +133,14 @@ module Mongoid
     #
     # @return [ Hash ] A hash of all attributes in the hierarchy.
     def as_document
-      BSON::Document.new(as_attributes)
+      attrs = as_attributes
+
+      # legacy attributes have a tendency to leak internal state via
+      # `as_document`; we have to deep_dup the attributes here to prevent
+      # that.
+      attrs = attrs.deep_dup if Mongoid.legacy_attributes
+
+      BSON::Document.new(attrs)
     end
 
     # Calls #as_json on the document with additional, Mongoid-specific options.

data/lib/mongoid/equality.rb

@@ -17,6 +17,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/extensions/hash.rb

@@ -49,7 +49,7 @@ module Mongoid
             consolidated[key].update(value)
           else
             consolidated["$set"] ||= {}
-            consolidated["$set"].update(key => mongoize_for(key, klass, key, value))
+            consolidated["$set"].update(key => mongoize_for("$set", klass, key, value))
           end
         end
         consolidated
@@ -187,7 +187,7 @@ module Mongoid
 
       # Get the value for the provided operator, klass, key and value.
       #
-      # This is necessary for special cases like $rename, $addToSet and $push.
+      # This is necessary for special cases like $rename, $addToSet, $push, $pull and $pop.
       #
       # @param [ String ] operator The operator.
       # @param [ Class ] klass The model class.
@@ -198,8 +198,8 @@ module Mongoid
       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)
+        when "$addToSet", "$push", '$pull', '$pop' then value.mongoize
+        else mongoize_for(operator, klass, key, value)
         end
       end
 

data/lib/mongoid/fields.rb

@@ -47,6 +47,11 @@ module Mongoid
     # @api private
     INVALID_BSON_CLASSES = [ BSON::Decimal128, BSON::Int32, BSON::Int64 ].freeze
 
+    # The suffix for generated translated fields.
+    # 
+    # @api private
+    TRANSLATIONS_SFX = '_translations'
+
     module ClassMethods
       # Returns the list of id fields for this model class, as both strings
       # and symbols.
@@ -99,8 +104,8 @@ module Mongoid
           ar.each_with_index do |fn, i|
             key = fn
             unless klass.fields.key?(fn) || klass.relations.key?(fn)
-              if tr = fn.match(/(.*)_translations\z/)&.captures&.first
-                key = tr
+              if fn.end_with?(TRANSLATIONS_SFX)
+                key = fn.delete_suffix(TRANSLATIONS_SFX)
               else
                 key = fn
               end
@@ -405,12 +410,12 @@ module Mongoid
       #
       # @api private
       def database_field_name(name, relations, aliased_fields, aliased_associations)
+        return '' unless name.present?
+
         if Mongoid.broken_alias_handling
-          return nil unless name
           normalized = name.to_s
           aliased_fields[normalized] || normalized
         else
-          return nil unless name.present?
           key = name.to_s
           segment, remaining = key.split('.', 2)
 
@@ -726,11 +731,11 @@ module Mongoid
       # @api private
       def create_translations_getter(name, meth)
         generated_methods.module_eval do
-          re_define_method("#{meth}_translations") do
+          re_define_method("#{meth}#{TRANSLATIONS_SFX}") do
             attributes[name] ||= {}
             attributes[name].with_indifferent_access
           end
-          alias_method :"#{meth}_t", :"#{meth}_translations"
+          alias_method :"#{meth}_t", :"#{meth}#{TRANSLATIONS_SFX}"
         end
       end
 
@@ -746,14 +751,14 @@ module Mongoid
       # @api private
       def create_translations_setter(name, meth, field)
         generated_methods.module_eval do
-          re_define_method("#{meth}_translations=") do |value|
+          re_define_method("#{meth}#{TRANSLATIONS_SFX}=") do |value|
             attribute_will_change!(name)
             value&.transform_values! do |_value|
               field.type.mongoize(_value)
             end
             attributes[name] = value
           end
-          alias_method :"#{meth}_t=", :"#{meth}_translations="
+          alias_method :"#{meth}_t=", :"#{meth}#{TRANSLATIONS_SFX}="
         end
       end
 

data/lib/mongoid/interceptable.rb

@@ -43,8 +43,6 @@ module Mongoid
       # @api private
       define_model_callbacks :persist_parent
 
-      define_model_callbacks :commit, :rollback, only: :after
-
       attr_accessor :before_callback_halted
     end
 
@@ -143,9 +141,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
 
@@ -221,9 +223,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/matcher.rb

@@ -35,11 +35,25 @@ module Mongoid
     # from and behaves identically to association traversal for the purposes
     # of, for example, subsequent array element retrieval.
     #
-    # @param [ Document | Hash ] document The document to extract from.
+    # @param [ Document | Hash | String ] document The document to extract from.
     # @param [ String ] key The key path to extract.
     #
     # @return [ Object | Array ] Field value or values.
     module_function def extract_attribute(document, key)
+      # The matcher system will wind up sending atomic values to this as well,
+      # when attepting to match more complex types. If anything other than a
+      # Document or a Hash is given, we'll short-circuit the logic and just
+      # return an empty array.
+      return [] unless document.is_a?(Hash) || document.is_a?(Document)
+
+      # Performance optimization; if the key does not include a '.' character,
+      # it must reference an immediate attribute of the document.
+      unless key.include?('.')
+        hash = document.respond_to?(:attributes) ? document.attributes : document
+        key = find_exact_key(hash, key)
+        return key ? [ hash[key] ] : []
+      end
+
       if document.respond_to?(:as_attributes, true)
         # If a document has hash fields, as_attributes would keep those fields
         # as Hash instances which do not offer indifferent access.

data/lib/mongoid/serializable.rb

@@ -12,13 +12,13 @@ module Mongoid
     included do
 
       class << self
-        # Note that this intentionally only delegates :include_root_in_json
-        # and not :include_root_in_json? - delegating the latter produces
-        # wrong behavior.
-        # Also note that this intentionally uses the ActiveSupport delegation
-        # functionality and not the Ruby standard library one.
-        # See https://jira.mongodb.org/browse/MONGOID-4849.
-        delegate :include_root_in_json, to: ::Mongoid
+        def include_root_in_json
+          @include_root_in_json.nil? ? ::Mongoid.include_root_in_json : @include_root_in_json
+        end
+
+        def include_root_in_json=(new_value)
+          @include_root_in_json = new_value
+        end
       end
     end
 

data/lib/mongoid/timestamps/created.rb

@@ -22,13 +22,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?
           time = Time.configured.now
           self.updated_at = time if is_a?(Updated) && !updated_at_changed?
           self.created_at = time
         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/touchable.rb

@@ -25,7 +25,7 @@ module Mongoid
         current = Time.configured.now
         field = database_field_name(field)
         write_attribute(:updated_at, current) if respond_to?("updated_at=")
-        write_attribute(field, current) if field
+        write_attribute(field, current) if field.present?
 
         # If the document being touched is embedded, touch its parents
         # all the way through the composition hierarchy to the root object,

data/lib/mongoid/traversable.rb

@@ -7,6 +7,29 @@ module Mongoid
   # Provides behavior 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
 
     def _parent
       @__parent ||= nil
@@ -30,7 +53,7 @@ module Mongoid
         if value
           Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
           value = value.to_s
-          super
+          ::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)
@@ -300,6 +323,18 @@ module Mongoid
         !!(Mongoid::Document > superclass)
       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.