mongoid 9.0.0 → 9.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b7f297f31cb9dbf9e703769a789969ef5de77ba9f7b0ebf998c0aec1c76524
-  data.tar.gz: 0aeb2382db008ef20fe7635546da3c13df040933b31005c859747d8cd16247f9
+  metadata.gz: 558b30b0a39cd36cd9a3e54695f4617a9fcc0d67300637d1299b487b7d911bda
+  data.tar.gz: eccf9c55bdde17fd38592427e0dd6b5545d3e605b94a4308a422ba332e20c183
 SHA512:
-  metadata.gz: de6b4d0dbf469baaa5900cbd968a82d74d3eaf1f2b52cc002ddbb37f1531a343c0b5e48a54b47e554a81a1389c7daf43653aa9338653fa7eb7c171d309dd2990
-  data.tar.gz: 1202e0a37c944780c9b9b7ffca7a89736df81d7dd8757bfd0c2c2ec6723e7ee1ebc088feeca7479a1103fc3290ff679282bc5241cf67335505e56e08a0fee1d6
+  metadata.gz: 420ac9d23abeecb04c19794df124fc80d4f99883e1156d4e3be42e79b4b2e5e5a558c6b650746784024f0477a800def3a2ded537b848d3e9b97fb5e5e220b1f0
+  data.tar.gz: 40bfdcaf862e3ae7d3d046d84d5f9f5eea4752b5559c869eda16e1bd00cbc9aaae3eef05a7e4bec497915619fb162a248ac8f4be3525068e81f28ae876af1a29

data/README.md

@@ -14,6 +14,8 @@ Mongoid has [extensive user documentation](https://www.mongodb.com/docs/mongoid/
 Mongoid is built on top of the MongoDB Ruby driver which has
 [its own user documentation](https://www.mongodb.com/docs/ruby-driver/current/).
 
+High-level Mongoid documentation including tutorials and the reference that were in the docs folder can now be found at the docs-mongoid repository, [here](https://github.com/mongodb/docs-mongoid).
+
 Compatibility
 -------------
 

data/Rakefile

@@ -2,7 +2,6 @@
 # rubocop:todo all
 
 require "bundler"
-require "bundler/gem_tasks"
 Bundler.setup
 
 ROOT = File.expand_path(File.join(File.dirname(__FILE__)))
@@ -11,25 +10,53 @@ $: << File.join(ROOT, 'spec/shared/lib')
 
 require "rake"
 require "rspec/core/rake_task"
-require 'mrss/spec_organizer'
 
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "mongoid/version"
-
-tasks = Rake.application.instance_variable_get('@tasks')
-tasks['release:do'] = tasks.delete('release')
-
-task :gem => :build
+# stands in for the Bundler-provided `build` task, which builds the
+# gem for this project. Our release process builds the gems in a
+# particular way, in a GitHub action. This task is just to help remind
+# developers of that fact.
 task :build do
-  system "gem build mongoid.gemspec"
+  abort <<~WARNING
+    `rake build` does nothing in this project. The gem must be built via
+    the `Mongoid Release` action on GitHub, which is triggered manually when
+    a new release is ready.
+  WARNING
 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 'gem', 'push', "mongoid-#{Mongoid::VERSION}.gem"
 end
 
 RSpec::Core::RakeTask.new("spec") do |spec|
@@ -96,6 +123,8 @@ RUN_PRIORITY = %i(
 )
 
 def spec_organizer
+  require 'mrss/spec_organizer'
+
   Mrss::SpecOrganizer.new(
     root: ROOT,
     classifiers: CLASSIFIERS,
@@ -131,16 +160,10 @@ task :docs => 'docs:yard'
 namespace :docs do
   desc "Generate yard documentation"
   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

data/lib/config/locales/en.yml

@@ -140,6 +140,10 @@ en:
             A collation option is only supported if the query is executed on a MongoDB server
             with version >= 3.4."
           resolution: "Remove the collation option from the query."
+        invalid_around_callback:
+          message: "An around callback must contain a yield in its definition."
+          summary: "The block needs to be yielded to for around callbacks to function as intended."
+          resolution: "Ensure there is a yield statement inside the body of the around callback."
         invalid_async_query_executor:
           message: "Invalid async_query_executor option: %{executor}."
           summary: "A invalid async query executor was specified.
@@ -676,6 +680,22 @@ en:
           resolution: "The _type field is a reserved one used by Mongoid to determine the
             class for instantiating an object. Please don't save data in this field or ensure
             that any values in this field correspond to valid models."
+        unrecognized_model_alias:
+          message: "Cannot find any model with type %{model_alias}"
+          summary: "A document is trying to load a polymorphic association, but the data refers to a type of object that can't be resolved (%{model_alias}). It might be that you've renamed the target class."
+          resolution: "Register the old name as an alias on the refactored target object, using `identify_as`. This will allow Mongoid to find the target type even if the name no longer matches what was stored in the database."
+        unrecognized_resolver:
+          message: "The model resolver %{resolver} was referenced, but never registered."
+          summary: "A polymorphic association has been configured to use a resolver
+            named %{resolver}, but that resolver has not yet been registered. This
+            might be a typo. Currently registered resolvers are: %{resolvers}."
+          resolution: "Register custom resolvers with
+            `Mongoid::ModelResolver.register_resolver` before attempting to query
+            a polymorphic association."
+        unregistered_class:
+          message: "The class %{klass} is not registered with the resolver %{resolver}."
+          summary: "A polymorphic association using the resolver %{resolver} has tried to link to a model of type %{klass}, but the resolver has no knowledge of any such model. This can happen if the association is configured to use a different resolver than the target mode."
+          resolution: "Make sure the target model is registered with the same resolver as the polymorphic association, using `identify_as`."
         unsaved_document:
           message: "Attempted to save %{document} before the parent %{base}."
           summary: "You cannot call create or create! through the

data/lib/mongoid/association/accessors.rb

@@ -42,7 +42,8 @@ module Mongoid
       #
       # @return [ Proxy ] The association.
       def create_relation(object, association, selected_fields = nil)
-        type = @attributes[association.inverse_type]
+        key = @attributes[association.inverse_type]
+        type = key ? association.resolver.model_for(key) : nil
         target = if t = association.build(self, object, type, selected_fields)
           association.create_relation(self, t)
         else
@@ -116,7 +117,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 Mongoid::Errors::AttributeNotLoaded.new(self.class, 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 Mongoid::Errors::AttributeNotLoaded.new(self.class, field_name) unless try_get_parent
         end
 
         if !reload && (value = ivar(name)) != false

data/lib/mongoid/association/nested/one.rb

@@ -53,12 +53,25 @@ module Mongoid
           @attributes = attributes.with_indifferent_access
           @association = association
           @options = options
-          @class_name = options[:class_name] ? options[:class_name].constantize : association.klass
+          @class_name = class_from(options[:class_name])
           @destroy = @attributes.delete(:_destroy)
         end
 
         private
 
+        # Coerces the argument into a class, or defaults to the association's class.
+        #
+        # @param [ String | Mongoid::Document | nil ] name_or_class the value to coerce
+        #
+        # @return [ Mongoid::Document ] the resulting class
+        def class_from(name_or_class)
+          case name_or_class
+          when nil, false then association.klass
+          when String then name_or_class.constantize
+          else name_or_class
+          end
+        end
+
         # Extracts and converts the id to the expected type.
         #
         # @return [ BSON::ObjectId | String | Object | nil ] The converted id,

data/lib/mongoid/association/referenced/belongs_to/binding.rb

@@ -23,7 +23,13 @@ module Mongoid
             binding do
               check_polymorphic_inverses!(_target)
               bind_foreign_key(_base, record_id(_target))
-              bind_polymorphic_inverse_type(_base, _target.class.name)
+
+              # set the inverse type (e.g. "#{name}_type") for new polymorphic associations
+              if _association.inverse_type && !_base.frozen?
+                key = _association.resolver.default_key_for(_target)
+                bind_polymorphic_inverse_type(_base, key)
+              end
+
               if inverse = _association.inverse(_target)
                 if set_base_association
                   if _base.referenced_many?

data/lib/mongoid/association/referenced/belongs_to/buildable.rb

@@ -33,7 +33,7 @@ module Mongoid
           end
 
           def query_criteria(object, type)
-            cls = type ? type.constantize : relation_class
+            cls = type ? (type.is_a?(String) ? type.constantize : type) : relation_class
             crit = cls.criteria
             crit = crit.apply_scope(scope)
             crit.where(primary_key => object)

data/lib/mongoid/association/referenced/belongs_to.rb

@@ -103,6 +103,21 @@ module Mongoid
           @polymorphic ||= !!@options[:polymorphic]
         end
 
+        # Returns the object responsible for converting polymorphic type references into
+        # class objects, and vice versa. This is obtained via the `:polymorphic` option
+        # that was given when the association was defined.
+        #
+        # See Mongoid::ModelResolver.resolver for how the `:polymorphic` option is 
+        # interpreted here.
+        #
+        # @raise KeyError if no such resolver has been registered under the given
+        #   identifier.
+        #
+        # @return [ nil | Mongoid::ModelResolver ] the resolver to use
+        def resolver
+          @resolver ||= Mongoid::ModelResolver.resolver(@options[:polymorphic])
+        end
+
         # The name of the field used to store the type of polymorphic association.
         #
         # @return [ String ] The field used to store the type of polymorphic association.

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

@@ -6,6 +6,7 @@ require 'mongoid/association/referenced/has_many/buildable'
 require 'mongoid/association/referenced/has_many/proxy'
 require 'mongoid/association/referenced/has_many/enumerable'
 require 'mongoid/association/referenced/has_many/eager'
+require 'mongoid/association/referenced/with_polymorphic_criteria'
 
 module Mongoid
   module Association
@@ -15,6 +16,7 @@ module Mongoid
       class HasMany
         include Relatable
         include Buildable
+        include WithPolymorphicCriteria
 
         # The options available for this type of association, in addition to the
         # common ones.
@@ -131,6 +133,12 @@ module Mongoid
         # @param [ Class ] object_class The object class.
         #
         # @return [ Mongoid::Criteria ] The criteria object.
+        #
+        # @deprecated in 9.0.x
+        #
+        # It appears as if this method is an artifact left over from a refactoring that renamed it
+        # `with_polymorphic_criterion`, and made it private. Regardless, this method isn't referenced
+        # anywhere else, and is unlikely to be useful to external clients. We should remove it.
         def add_polymorphic_criterion(criteria, object_class)
           if polymorphic?
             criteria.where(type => object_class.name)
@@ -138,6 +146,7 @@ module Mongoid
             criteria
           end
         end
+        Mongoid.deprecate(self, :add_polymorphic_criterion)
 
         # Is this association polymorphic?
         #
@@ -222,14 +231,6 @@ module Mongoid
           with_ordering(crit)
         end
 
-        def with_polymorphic_criterion(criteria, base)
-          if polymorphic?
-            criteria.where(type => base.class.name)
-          else
-            criteria
-          end
-        end
-
         def with_ordering(criteria)
           if order
             criteria.order_by(order)

data/lib/mongoid/association/referenced/has_one/buildable.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # rubocop:todo all
 
+require 'mongoid/association/referenced/with_polymorphic_criteria'
+
 module Mongoid
   module Association
     module Referenced
@@ -8,6 +10,7 @@ module Mongoid
 
         # The Builder behavior for has_one associations.
         module Buildable
+          include WithPolymorphicCriteria
 
           # This method either takes an _id or an object and queries for the
           # inverse side using the id or sets the object after clearing the
@@ -57,14 +60,6 @@ module Mongoid
             query_criteria(object, base).take
           end
 
-          def with_polymorphic_criterion(criteria, base)
-            if polymorphic?
-              criteria.where(type => base.class.name)
-            else
-              criteria
-            end
-          end
-
           def query?(object)
             object && !object.is_a?(Mongoid::Document)
           end

data/lib/mongoid/association/referenced/with_polymorphic_criteria.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Association
+    module Referenced
+      # Implements the `with_polymorphic_criteria` shared behavior.
+      #
+      # @api private
+      module WithPolymorphicCriteria
+        # If the receiver represents a polymorphic association, applies
+        # the polymorphic search criteria to the given `criteria` object.
+        #
+        # @param [ Mongoid::Criteria ] criteria the criteria to append to
+        #   if receiver is polymorphic.
+        # @param [ Mongoid::Document ] base the document to use when resolving
+        #   the polymorphic type keys.
+        #
+        # @return [ Mongoid::Criteria] the resulting criteria, which may be
+        #   the same as the input.
+        def with_polymorphic_criterion(criteria, base)
+          if polymorphic?
+            # 1. get the resolver for the inverse association
+            resolver = klass.reflect_on_association(as).resolver
+
+            # 2. look up the list of keys from the resolver, given base
+            keys = resolver.keys_for(base)
+
+            # 3. use equality if there is just one key, `in` if there are multiple
+            if keys.many?
+              criteria.where(type => { :$in => keys })
+            else
+              criteria.where(type => keys.first)
+            end
+          else
+            criteria
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/atomic_update_preparer.rb

@@ -25,7 +25,7 @@ module Mongoid
           if key.to_s.start_with?('$')
             (atomic_updates[key] ||= {}).update(prepare_operation(klass, key, value))
           else
-            (atomic_updates['$set'] ||= {})[key] = mongoize_for(key, klass, key, value)
+            (atomic_updates['$set'] ||= {})[key] = mongoize_for('$set', klass, key, value)
           end
         end
       end
@@ -43,24 +43,25 @@ module Mongoid
       def prepare_operation(klass, key, value)
         value.each_with_object({}) do |(key2, value2), hash|
           key2 = klass.database_field_name(key2)
-          hash[key2] = value_for(key, klass, value2)
+          hash[key2] = value_for(key, klass, key2, value2)
         end
       end
 
       # 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.
+      # @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, value)
+      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/attributes/nested.rb

@@ -60,7 +60,8 @@ module Mongoid
             re_define_method(meth) do |attrs|
               _assigning do
                 if association.polymorphic? and association.inverse_type
-                  options = options.merge!(:class_name => self.send(association.inverse_type))
+                  klass = association.resolver.model_for(send(association.inverse_type))
+                  options = options.merge!(:class_name => klass)
                 end
                 association.nested_builder(attrs, options).build(self)
               end

data/lib/mongoid/clients/sessions.rb

@@ -89,21 +89,22 @@ module Mongoid
         def transaction(options = {}, session_options: {})
           with_session(session_options) do |session|
             begin
-              session.start_transaction(options)
-              yield
-              commit_transaction(session)
+              session.with_transaction(options) do
+                yield
+              end
+              run_commit_callbacks(session)
             rescue *transactions_not_supported_exceptions
               raise Mongoid::Errors::TransactionsNotSupported
             rescue Mongoid::Errors::Rollback
-              abort_transaction(session)
+              run_abort_callbacks(session)
             rescue Mongoid::Errors::InvalidSessionNesting
               # Session should be ended here.
               raise Mongoid::Errors::InvalidTransactionNesting.new
             rescue Mongo::Error::InvalidSession, Mongo::Error::InvalidTransactionOperation => e
-              abort_transaction(session)
-              raise Mongoid::Errors::TransactionError(e)
+              run_abort_callbacks(session)
+              raise Mongoid::Errors::TransactionError.new(e)
             rescue StandardError => e
-              abort_transaction(session)
+              run_abort_callbacks(session)
               raise e
             end
           end
@@ -189,25 +190,21 @@ module Mongoid
           _session&.in_transaction? || false
         end
 
-        # Commits the active transaction on the session, and calls
-        # after_commit callbacks on modified documents.
+        # Runs after_commit callbacks on modified documents.
         #
         # @param [ Mongo::Session ] session Session on which
         #   a transaction is started.
-        def commit_transaction(session)
-          session.commit_transaction
+        def run_commit_callbacks(session)
           Threaded.clear_modified_documents(session).each do |doc|
             doc.run_after_callbacks(:commit)
           end
         end
 
-        # Aborts the active transaction on the session, and calls
-        # after_rollback callbacks on modified documents.
+        # Runs after_rollback callbacks on modified documents.
         #
         # @param [ Mongo::Session ] session Session on which
         #   a transaction is started.
-        def abort_transaction(session)
-          session.abort_transaction
+        def run_abort_callbacks(session)
           Threaded.clear_modified_documents(session).each do |doc|
             doc.run_after_callbacks(:rollback)
           end

data/lib/mongoid/composable.rb

@@ -5,6 +5,7 @@ require "mongoid/changeable"
 require "mongoid/collection_configurable"
 require "mongoid/encryptable"
 require "mongoid/findable"
+require 'mongoid/identifiable'
 require "mongoid/indexable"
 require "mongoid/inspectable"
 require "mongoid/interceptable"
@@ -44,6 +45,7 @@ module Mongoid
     include Attributes
     include Evolvable
     include Fields
+    include Identifiable
     include Indexable
     include Inspectable
     include Matchable

data/lib/mongoid/config.rb

@@ -171,6 +171,15 @@ module Mongoid
     # See https://jira.mongodb.org/browse/MONGOID-5658 for more details.
     option :around_callbacks_for_embeds, default: false
 
+    # When this flag is false, named scopes cannot unset a default scope.
+    # This is the traditional (and default) behavior in Mongoid 9 and earlier.
+    #
+    # Setting this flag to true will allow named scopes to unset the default
+    # scope. This will be the default in Mongoid 10.
+    #
+    # See https://jira.mongodb.org/browse/MONGOID-5785 for more details.
+    option :allow_scopes_to_unset_default_scope, default: false
+
     # Returns the Config singleton, for use in the configure DSL.
     #
     # @return [ self ] The Config singleton.

data/lib/mongoid/contextual/aggregable/memory.rb

@@ -90,11 +90,12 @@ module Mongoid
         # @example Get the sum for the provided block.
         #   aggregable.sum(&:likes)
         #
-        # @param [ Symbol ] field The field to sum.
+        # @param [ Symbol | Numeric ] field The field to sum, or the intial
+        #   value of the sum when a block is given.
         #
         # @return [ Numeric ] The sum value.
         def sum(field = nil)
-          return super() if block_given?
+          return super(field || 0) if block_given?
 
           aggregate_by(field, :sum) || 0
         end

data/lib/mongoid/contextual/aggregable/mongo.rb

@@ -96,11 +96,14 @@ module Mongoid
         # @example Get the sum for the provided block.
         #   aggregable.sum(&:likes)
         #
-        # @param [ Symbol ] field The field to sum.
+        # @param [ Symbol | Numeric ] field The field to sum, or the initial
+        #    value of the sum when a block is given.
         #
         # @return [ Float ] The sum value.
         def sum(field = nil)
-          block_given? ? super() : aggregates(field)["sum"] || 0
+          return super(field || 0) if block_given?
+
+          aggregates(field)["sum"] || 0
         end
 
         private

data/lib/mongoid/criteria/findable.rb

@@ -169,12 +169,12 @@ module Mongoid
         args.size > 1 || !args.first.is_a?(Hash) && args.first.resizable?
       end
 
-      # Convenience method of raising an invalid options error.
+      # Convenience method of raising an invalid find error.
       #
       # @example Raise the error.
       #   criteria.raise_invalid
       #
-      # @raise [ Errors::InvalidOptions ] The error.
+      # @raise [ Errors::InvalidFind ] The error.
       def raise_invalid
         raise Errors::InvalidFind.new
       end

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

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

@@ -17,6 +17,7 @@ require 'mongoid/timestamps'
 require 'mongoid/association'
 require 'mongoid/composable'
 require 'mongoid/touchable'
+require 'mongoid/model_resolver'
 
 module Mongoid
   # This is the base module for all domain objects that need to be persisted to
@@ -31,6 +32,7 @@ module Mongoid
 
     included do
       Mongoid.register_model(self)
+      Mongoid::ModelResolver.register(self)
     end
 
     # Regex for matching illegal BSON keys.

data/lib/mongoid/errors/invalid_around_callback.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # This error is raised when an around callback is
+    # defined by the user without a yield
+    class InvalidAroundCallback < MongoidError
+      # Create the new error.
+      #
+      # @api private
+      def initialize
+        super(compose_message('invalid_around_callback'))
+      end
+    end
+  end
+end