mongoid 9.0.0 → 9.0.2

data/lib/mongoid/errors/unrecognized_model_alias.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # Raised when a polymorphic association is queried, but the type of the
+    # association cannot be resolved. This usually happens when the data in
+    # the database references a type that no longer exists.
+    #
+    # For example, consider the following model:
+    #
+    #   class Manager
+    #     include Mongoid::Document
+    #     belongs_to :unit, polymorphic: true
+    #   end
+    #
+    # Imagine there is a document in the `managers` collection that looks
+    # something like this:
+    #
+    #   { _id: ..., unit_id: ..., unit_type: 'Department::Engineering' }
+    #
+    # If, at some point in your refactoring, you rename the `Department::Engineering`
+    # model to something else, Mongoid will no longer be able to resolve the
+    # type of this association, and asking for `manager.unit` will raise this
+    # exception.
+    #
+    # To fix this exception, you can add an alias to the model class so that it
+    # can still be found, even after renaming it:
+    #
+    #   module Engineering
+    #     class Department
+    #       include Mongoid::Document
+    #
+    #       identify_as 'Department::Engineering'
+    #
+    #       # ...
+    #     end
+    #   end
+    #
+    # Better practice would be to use unique strings instead of class names to
+    # identify these polymorphic types in the database (e.g. 'dept' instead of
+    # 'Department::Engineering').
+    class UnrecognizedModelAlias < MongoidError
+      def initialize(model_alias)
+        super(
+          compose_message(
+            'unrecognized_model_alias',
+            model_alias: model_alias.inspect
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/unrecognized_resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # Raised when a model resolver is referenced, but not registered.
+    #
+    #   class Manager
+    #     include Mongoid::Document
+    #     belongs_to :unit, polymorphic: :org
+    #   end
+    #
+    # If `:org` has not previously been registered as a model resolver,
+    # Mongoid will raise UnrecognizedResolver when it tries to resolve
+    # a manager's unit.
+    class UnrecognizedResolver < MongoidError
+      def initialize(resolver)
+        super(
+          compose_message(
+            'unrecognized_resolver',
+            resolver: resolver.inspect,
+            resolvers: [ :default, *Mongoid::ModelResolver.resolvers.keys ].inspect
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/unregistered_class.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+    # Raised when Mongoid tries to query the identifier to use for a given
+    # class in a polymorphic association, but the class has not previously
+    # been registered by resolver that was used for the query.
+    #
+    # Here's an exammple:
+    #
+    #   class Department
+    #     include Mongoid::Document
+    #     has_many :managers, as: :unit
+    #   end
+    #
+    #   class Manager
+    #     include Mongoid::Document
+    #     belongs_to :unit, polymorphic: :org
+    #   end
+    #
+    # The Manager class is configured to use a custom resolver named `:org`
+    # when resolving the polymorphic `unit` association. However, the `Department`
+    # class is not registered with that resolver. When the program tries to
+    # associate a manager record with a department, it will not be able to find
+    # the required key in the `:org` resolver, and will fail with this exception.
+    #
+    # The solution is to make sure the `Department` class is properly registered
+    # with the `:org` resolver:
+    #
+    #   class Department
+    #     include Mongoid::Document
+    #     identify_as resolver: :org
+    #     has_many :managers, as: :unit
+    #   end
+    class UnregisteredClass < MongoidError
+      def initialize(klass, resolver)
+        super(
+          compose_message(
+            'unregistered_class',
+            klass: klass,
+            resolver: resolver.inspect
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors.rb

@@ -13,6 +13,7 @@ require "mongoid/errors/empty_config_file"
 require "mongoid/errors/immutable_attribute"
 require "mongoid/errors/in_memory_collation_not_supported"
 require "mongoid/errors/invalid_auto_encryption_configuration"
+require "mongoid/errors/invalid_around_callback"
 require "mongoid/errors/invalid_async_query_executor"
 require "mongoid/errors/invalid_collection"
 require "mongoid/errors/invalid_config_file"
@@ -68,6 +69,9 @@ require "mongoid/errors/transaction_error"
 require "mongoid/errors/transactions_not_supported"
 require "mongoid/errors/unknown_attribute"
 require "mongoid/errors/unknown_model"
+require 'mongoid/errors/unrecognized_model_alias'
+require 'mongoid/errors/unrecognized_resolver'
+require 'mongoid/errors/unregistered_class'
 require "mongoid/errors/unsaved_document"
 require "mongoid/errors/unsupported_javascript"
 require "mongoid/errors/validations"

data/lib/mongoid/fields.rb

@@ -49,6 +49,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.
@@ -101,8 +106,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
@@ -408,7 +413,8 @@ module Mongoid
       #
       # @api private
       def database_field_name(name, relations, aliased_fields, aliased_associations)
-        return nil unless name.present?
+        return "" unless name.present?
+
         key = name.to_s
         segment, remaining = key.split('.', 2)
 
@@ -725,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
 
@@ -745,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/identifiable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'mongoid/model_resolver'
+
+module Mongoid
+  # Implements the "identify_as" interface (for specifying type aliases
+  # for document classes).
+  module Identifiable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Specifies aliases that may be used to identify this document
+      # class in polymorphic situations. By default, classes are identified
+      # by their class names, but alternative aliases may be used instead,
+      # if desired.
+      #
+      # @param [ Array<String | Symbol> ] aliases the list of aliases to
+      #   assign to this class.
+      # @param [ Mongoid::ModelResolver::Interface | Symbol | :default ] resolver the
+      #   resolver instance to use when registering the type. If :default, the default
+      #   `ModelResolver` instance will be used. If any other symbol, it must identify a
+      #   previously registered ModelResolver instance.
+      def identify_as(*aliases, resolver: :default)
+        Mongoid::ModelResolver.resolver(resolver).register(self, *aliases)
+      end
+    end
+  end
+end

data/lib/mongoid/interceptable.rb

@@ -161,11 +161,6 @@ module Mongoid
     # Execute the callbacks of given kind for embedded documents including
     # around callbacks.
     #
-    # @note This method is prone to stack overflow errors if the document
-    #   has a large number of embedded documents. It is recommended to avoid
-    #   using around callbacks for embedded documents until a proper solution
-    #   is implemented.
-    #
     # @param [ Symbol ] kind The type of callback to execute.
     # @param [ Array<Document> ] children Children to execute callbacks on. If
     #  nil, callbacks will be executed on all cascadable children of
@@ -173,17 +168,27 @@ module Mongoid
     #
     #  @api private
     def _mongoid_run_child_callbacks_with_around(kind, children: nil, &block)
-      child, *tail = (children || cascadable_children(kind))
+      children = (children || cascadable_children(kind))
       with_children = !Mongoid::Config.prevent_multiple_calls_of_embedded_callbacks
-      if child.nil?
-        block&.call
-      elsif tail.empty?
-        child.run_callbacks(child_callback_type(kind, child), with_children: with_children, &block)
-      else
-        child.run_callbacks(child_callback_type(kind, child), with_children: with_children) do
-          _mongoid_run_child_callbacks_with_around(kind, children: tail, &block)
+
+      return block&.call if children.empty?
+
+      fibers = children.map do |child|
+        Fiber.new do
+          child.run_callbacks(child_callback_type(kind, child), with_children: with_children) do
+            Fiber.yield
+          end
         end
       end
+
+      fibers.each do |fiber|
+        fiber.resume
+        raise Mongoid::Errors::InvalidAroundCallback unless fiber.alive?
+      end
+
+      block&.call
+
+      fibers.reverse.each(&:resume)
     end
 
     # Execute the callbacks of given kind for embedded documents without

data/lib/mongoid/model_resolver.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Mongoid
+  # The default class for resolving model classes based on discriminant keys.
+  # Given a key, it will return the corresponding model class, if any. By
+  # default, it looks for classes with names that match the given keys, but
+  # additional mappings may be provided.
+  #
+  # It is also possible to instantiate multiple resolvers---and even implement
+  # your own---so that different sets of classes can use independent resolution
+  # mechanics.
+  class ModelResolver
+    # The mutex instance used to make the `.instance` method thread-safe.
+    #
+    # @api private
+    INSTANCE_MUTEX = Mutex.new
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :register
+
+      # Returns the default instance of the ModelResolver.
+      #
+      # @return [ Mongoid::ModelResolver ] the default ModelResolver instance.
+      def instance
+        @instance ||= INSTANCE_MUTEX.synchronize { @instance ||= new }
+      end
+
+      # Returns the map of registered resolvers. The default resolver is not
+      # included here.
+      #
+      # @return [ Hash<Symbol => Mongoid::ModelResolver::Interface> ] the hash of
+      #   resolver instances, mapped by symbol identifier.
+      def resolvers
+        @resolvers ||= {}
+      end
+
+      # Returns the resolver instance that corresponds to the argument.
+      #
+      # @param [ nil | true | false Symbol | String | Mongoid::ModelResolver::Interface ] identifier_or_object
+      #   When nil or false, returns nil. When true or :default, corresponds to the default resolver.
+      #   When any other symbol or string, corresponds to the registered resolver with that identifier.
+      #   Otherwise, it must be a resolver instance itself.
+      #
+      # @raise Mongoid::Errors::UnrecognizedResolver if the given identifier is a
+      #   symbol or string and it does not match any registered resolver.
+      #
+      # @return [ Mongoid::ModelResolver::Interface ] the resolver instance corresponding to the
+      #   given argument.
+      def resolver(identifier_or_object = :default)
+        case identifier_or_object
+        when nil, false then nil
+        when true, :default then instance
+        when String, Symbol
+          resolvers.fetch(identifier_or_object.to_sym) do |key|
+            raise Mongoid::Errors::UnrecognizedResolver, key
+          end
+        else identifier_or_object
+        end
+      end
+
+      # Register the given resolver under the given name.
+      #
+      # @param [ Mongoid::ModelResolver::Interface ] resolver the resolver to register.
+      # @param [ String | Symbol ] name the identifier to use to register the resolver.
+      def register_resolver(resolver, name)
+        resolvers[name.to_sym] = resolver
+        self
+      end
+    end
+
+    # Instantiates a new ModelResolver instance.
+    def initialize
+      @key_to_model = {}
+      @model_to_keys = {}
+    end
+
+    # Registers the given model class with the given keys. In addition to the given keys, the
+    # class name itself will be included as a key to identify the class. Keys are given in priority
+    # order, with highest priority keys first and lowest last. The class name, if not given explicitly,
+    # is always given lowest priority.
+    #
+    # If called more than once, newer keys have higher priority than older keys. All duplicate keys will
+    # be removed.
+    #
+    # @param [ Mongoid::Document ] klass the document class to register
+    # @param [ Array<String> ] *keys the list of keys to use as an alias (optional)
+    def register(klass, *keys)
+      default_key = klass.name
+
+      @model_to_keys[klass] = [ *keys, *@model_to_keys[klass], default_key ].uniq
+      @key_to_model[default_key] = klass
+
+      keys.each do |key|
+        @key_to_model[key] = klass
+      end
+
+      self
+    end
+
+    # The `Interface` concern represents the interface that custom resolvers
+    # must implement.
+    concerning :Interface do
+      # Returns the default (highest priority) key for the given record. This is typically
+      # the key that will be used when saving a new polymorphic association.
+      #
+      # @param [ Mongoid::Document ] record the record instance for which to query the default key.
+      #
+      # @raise Mongoid::Errors::UnregisteredClass if the record's class has not been registered with this resolver.
+      #
+      # @return [ String ] the default key for the record's class.
+      def default_key_for(record)
+        keys_for(record).first
+      end
+
+      # Returns the list of all keys for the given record's class, in priority order (with highest
+      # priority keys first).
+      #
+      # @param [ Mongoid::Document] record the record instance for which to query the registered keys.
+      #
+      # @raise Mongoid::Errors::UnregisteredClass if the record's class has not been registered with this resolver.
+      #
+      # @return [ Array<String> ] the list of keys that have been registered for the given class.
+      def keys_for(record)
+        @model_to_keys.fetch(record.class) do |klass|
+          # figure out which resolver this is
+          resolver = if self == Mongoid::ModelResolver.instance
+                       :default
+                     else
+                       Mongoid::ModelResolver.resolvers.keys.detect { |k| Mongoid::ModelResolver.resolvers[k] == self }
+                     end
+          resolver ||= self # if it hasn't been registered, we'll show it the best we can
+          raise Mongoid::Errors::UnregisteredClass.new(klass, resolver)
+        end
+      end
+
+      # Returns the document class that has been registered by the given key.
+      #
+      # @param [ String ] key the key by which to query the corresponding class.
+      #
+      # @raise Mongoid::Errors::UnrecognizedModelAlias if the given key has not
+      #   been registered with this resolver.
+      #
+      # @return [ Class ] the document class that has been registered with the given key.
+      def model_for(key)
+        @key_to_model.fetch(key) do
+          raise Mongoid::Errors::UnrecognizedModelAlias, key
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence_context.rb

@@ -25,7 +25,8 @@ module Mongoid
     # @return [ Array<Symbol> ] The list of extra options besides client options
     #   that determine the persistence context.
     EXTRA_OPTIONS = [ :client,
-                      :collection
+                      :collection,
+                      :collection_options
                     ].freeze
 
     # The full list of valid persistence context options.

data/lib/mongoid/scopable.rb

@@ -294,7 +294,13 @@ module Mongoid
             scope = instance_exec(*args, **kwargs, &scoping[:scope])
             extension = scoping[:extension]
             to_merge = scope || queryable
-            criteria = to_merge.empty_and_chainable? ? to_merge : with_default_scope.merge(to_merge)
+
+            criteria = if Mongoid.allow_scopes_to_unset_default_scope
+                         to_merge
+                       else
+                         to_merge.empty_and_chainable? ? to_merge : with_default_scope.merge(to_merge)
+                       end
+
             criteria.extend(extension)
             criteria
           end

data/lib/mongoid/touchable.rb

@@ -78,7 +78,7 @@ module Mongoid
         field = database_field_name(field)
 
         write_attribute(:updated_at, now) if respond_to?("updated_at=")
-        write_attribute(field, now) if field
+        write_attribute(field, now) if field.present?
 
         touches = _extract_touches_from_atomic_sets(field) || {}
         touches.merge!(_parent._gather_touch_updates(now) || {}) if _touchable_parent?
@@ -212,12 +212,6 @@ module Mongoid
     #
     # @return [ Symbol ] The method name.
     def define_relation_touch_method(name, association)
-      relation_classes = if association.polymorphic?
-                           association.send(:inverse_association_classes)
-                         else
-                           [ association.relation_class ]
-                         end
-
       method_name = "touch_#{name}_after_create_or_destroy"
       association.inverse_class.class_eval do
         define_method(method_name) do

data/lib/mongoid/traversable.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'mongoid/fields/validators/macro'
+require 'mongoid/model_resolver'
 
 module Mongoid
   # Mixin module included in Mongoid::Document to provide behavior
@@ -32,6 +33,10 @@ module Mongoid
       # rubocop:disable Metrics/AbcSize
       def inherited(subclass)
         super
+
+        # Register the new subclass with the resolver subsystem
+        Mongoid::ModelResolver.register(subclass)
+
         @_type = nil
         subclass.aliased_fields = aliased_fields.dup
         subclass.localized_fields = localized_fields.dup

data/lib/mongoid/version.rb

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

data/spec/integration/associations/belongs_to_spec.rb

@@ -2,8 +2,40 @@
 # rubocop:todo all
 
 require 'spec_helper'
+require 'support/feature_sandbox'
+
 require_relative '../../mongoid/association/referenced/has_one_models'
 
+def quarantine(context, polymorphic:, dept_aliases:, team_aliases:)
+  state = {}
+
+  context.before(:context) do
+    state[:quarantine] = FeatureSandbox.start_quarantine
+
+    # Have to eval this, because otherwise we get syntax errors when defining a class
+    # inside a method.
+    #
+    # I know the scissors are sharp! But I want to run with them anwyay!
+    Object.class_eval <<-RUBY
+      class SandboxManager; include Mongoid::Document; end
+      class SandboxDepartment; include Mongoid::Document; end
+      class SandboxTeam; include Mongoid::Document; end
+    RUBY
+
+    SandboxManager.belongs_to :unit, polymorphic: polymorphic
+
+    SandboxDepartment.identify_as *dept_aliases, resolver: polymorphic
+    SandboxDepartment.has_many :sandbox_managers, as: :unit
+
+    SandboxTeam.identify_as *team_aliases, resolver: polymorphic
+    SandboxTeam.has_one :sandbox_manager, as: :unit
+  end
+
+  context.after(:context) do
+    FeatureSandbox.end_quarantine(state[:quarantine])
+  end
+end
+
 describe 'belongs_to associations' do
   context 'referencing top level classes when source class is namespaced' do
     let(:college) { HomCollege.create! }
@@ -31,4 +63,101 @@ describe 'belongs_to associations' do
       expect(instance.movie).to eq movie
     end
   end
+
+  context 'when the association is polymorphic' do
+    let(:dept_manager) { SandboxManager.create(unit: department) }
+    let(:team_manager) { SandboxManager.create(unit: team) }
+    let(:department) { SandboxDepartment.create }
+    let(:team) { SandboxTeam.create }
+
+    shared_context 'it finds the associated records' do
+      it 'successfully finds the manager\'s unit' do
+        expect(dept_manager.reload.unit).to be == department
+        expect(team_manager.reload.unit).to be == team
+      end
+
+      it 'successfully finds the unit\'s manager' do
+        dept_manager; team_manager # make sure these are created first...
+
+        expect(department.reload.sandbox_managers).to be == [ dept_manager ]
+        expect(team.reload.sandbox_manager).to be == team_manager
+      end
+    end
+
+    shared_context 'it searches for alternative aliases' do
+      it 'successfully finds the corresponding unit when unit_type is a different alias' do
+        dept_manager.update unit_type: 'sandbox_dept'
+        dept_manager.reload
+
+        team_manager.update unit_type: 'group'
+        team_manager.reload
+
+        expect(dept_manager.reload.unit_type).to be == 'sandbox_dept'
+        expect(dept_manager.unit).to be == department
+
+        expect(team_manager.reload.unit_type).to be == 'group'
+        expect(team_manager.unit).to be == team
+      end
+    end
+
+    context 'when the association uses the default resolver' do
+      context 'when there are no aliases given' do
+        quarantine(self, polymorphic: true, dept_aliases: [], team_aliases: [])
+
+        it 'populates the unit_type with the class name' do
+          expect(dept_manager.unit_type).to be == 'SandboxDepartment'
+          expect(team_manager.unit_type).to be == 'SandboxTeam'
+        end
+
+        it_behaves_like 'it finds the associated records'
+      end
+
+      context 'when there are multiple aliases given' do
+        quarantine(self, polymorphic: true, dept_aliases: %w[ dept sandbox_dept ], team_aliases: %w[ team group ])
+
+        it 'populates the unit_type with the first alias' do
+          expect(dept_manager.unit_type).to be == 'dept'
+          expect(team_manager.unit_type).to be == 'team'
+        end
+
+        it_behaves_like 'it finds the associated records'
+        it_behaves_like 'it searches for alternative aliases'
+      end
+    end
+
+    context 'when the association uses a registered resolver' do
+      before(:context) { Mongoid::ModelResolver.register_resolver Mongoid::ModelResolver.new, :sandbox }
+      quarantine(self, polymorphic: :sandbox, dept_aliases: %w[ dept sandbox_dept ], team_aliases: %w[ team group ])
+
+      it 'does not include the aliases in the default resolver' do
+        expect(Mongoid::ModelResolver.instance.keys_for(SandboxDepartment.new)).not_to include('dept')
+      end
+
+      it 'populates the unit_type with the first alias' do
+        expect(dept_manager.unit_type).to be == 'dept'
+        expect(team_manager.unit_type).to be == 'team'
+      end
+
+      it_behaves_like 'it finds the associated records'
+      it_behaves_like 'it searches for alternative aliases'
+    end
+
+    context 'when the association uses an unregistered resolver' do
+      quarantine(self, polymorphic: Mongoid::ModelResolver.new,
+        dept_aliases: %w[ dept sandbox_dept ],
+        team_aliases: %w[ team group ])
+
+      it 'does not include the aliases in the default resolver' do
+        expect(Mongoid::ModelResolver.instance.keys_for(SandboxDepartment.new)).not_to include('dept')
+      end
+
+      it 'populates the unit_type with the first alias' do
+        expect(dept_manager.unit_type).to be == 'dept'
+        expect(team_manager.unit_type).to be == 'team'
+      end
+
+      it_behaves_like 'it finds the associated records'
+      it_behaves_like 'it searches for alternative aliases'
+    end
+  end
 end