mongoid 9.0.1 → 9.0.2

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/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.1"
+  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

data/spec/integration/persistence/collection_options_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable RSpec/LeakyConstantDeclaration
+# rubocop:disable Lint/ConstantDefinitionInBlock
+describe 'Collection options' do
+  before(:all) do
+    class CollectionOptionsCapped
+      include Mongoid::Document
+
+      store_in collection_options: {
+        capped: true,
+        size: 25_600
+      }
+    end
+  end
+
+  after(:all) do
+    CollectionOptionsCapped.collection.drop
+    Mongoid.deregister_model(CollectionOptionsCapped)
+    Object.send(:remove_const, :CollectionOptionsCapped)
+  end
+
+  before do
+    CollectionOptionsCapped.collection.drop
+    # We should create the collection explicitly to apply collection options.
+    CollectionOptionsCapped.create_collection
+  end
+
+  it 'creates a document' do
+    expect { CollectionOptionsCapped.create! }.not_to raise_error
+  end
+end
+# rubocop:enable Lint/ConstantDefinitionInBlock
+# rubocop:enable RSpec/LeakyConstantDeclaration

data/spec/mongoid/association/embedded/embeds_many_query_spec.rb

@@ -28,6 +28,10 @@ describe Mongoid::Association::Embedded::EmbedsMany do
       expect(legislator.attributes.keys).to eq(['_id', 'a'])
     end
 
+    it 'allows accessing the parent' do
+      expect { legislator.congress }.not_to raise_error
+    end
+
     context 'when using only with $' do
       before do
         Patient.destroy_all

data/spec/mongoid/association/referenced/belongs_to/proxy_spec.rb

@@ -2,6 +2,7 @@
 # rubocop:todo all
 
 require "spec_helper"
+require 'support/models/canvas'
 require_relative '../belongs_to_models.rb'
 
 describe Mongoid::Association::Referenced::BelongsTo::Proxy do

data/spec/mongoid/association/referenced/belongs_to_spec.rb

@@ -4,6 +4,10 @@
 require "spec_helper"
 require_relative './has_one_models'
 
+BELONGS_TO_RESOLVER_ID__ = :__belongs_to_resolver_id
+BELONGS_TO_RESOLVER = Mongoid::ModelResolver.new
+Mongoid::ModelResolver.register_resolver BELONGS_TO_RESOLVER, BELONGS_TO_RESOLVER_ID__
+
 describe Mongoid::Association::Referenced::BelongsTo do
 
   before do
@@ -199,47 +203,76 @@ describe Mongoid::Association::Referenced::BelongsTo do
 
       context 'when the polymorphic option is provided' do
 
-        context 'when the polymorphic option is true' do
+        [ true, :default ].each do |opt|
+          context "when the polymorphic option is #{opt.inspect}" do
+            let(:options) { { polymorphic: opt } }
+            before { association }
 
-          let(:options) do
-            {
-              polymorphic: true
-            }
+            it 'set the polymorphic attribute on the owner class' do
+              expect(belonging_class.polymorphic).to be(true)
+            end
+
+            it 'sets up a field for the inverse type' do
+              expect(belonging_class.fields.keys).to include(association.inverse_type)
+            end
+
+            it 'uses the default resolver' do
+              expect(association.resolver).to be == Mongoid::ModelResolver.instance
+            end
           end
+        end
 
-          before do
-            association
+        [ false, nil ].each do |opt|
+          context "when the polymorphic option is #{opt.inspect}" do
+            let(:options) { { polymorphic: opt } }
+
+            it 'does not set the polymorphic attribute on the owner class' do
+              expect(belonging_class.polymorphic).to be(false)
+            end
+
+            it 'does not set up a field for the inverse type' do
+              expect(belonging_class.fields.keys).not_to include(association.inverse_type)
+            end
+
+            it 'does not use a resolver' do
+              expect(association.resolver).to be_nil
+            end
           end
+        end
 
-          it 'set the polymorphic attribute on the owner class' do
-            expect(belonging_class.polymorphic).to be(true)
+        context 'when the polymorphic option is set to an unregistered id' do
+          let(:options) { { polymorphic: :bogus } }
+
+          # This behavior is intentional, so that the resolver can be registered after the classes
+          # are loaded.
+          it 'does not immediately raise an exception' do
+            expect { association }.not_to raise_error
           end
 
-          it 'sets up a field for the inverse type' do
-            expect(belonging_class.fields.keys).to include(association.inverse_type)
+          it 'raises error when resolver is accessed' do
+            expect { association.resolver }.to raise_error(Mongoid::Errors::UnrecognizedResolver)
           end
         end
 
-        context 'when the polymorphic option is false' do
+        context 'when the polymorphic option is set to a registered id' do
+          let(:options) { { polymorphic: BELONGS_TO_RESOLVER_ID__ } }
+          before { association }
 
-          let(:options) do
-            {
-              polymorphic: false
-            }
+          it 'set the polymorphic attribute on the owner class' do
+            expect(belonging_class.polymorphic).to be(true)
           end
 
-          it 'does not set the polymorphic attribute on the owner class' do
-            expect(belonging_class.polymorphic).to be(false)
+          it 'sets up a field for the inverse type' do
+            expect(belonging_class.fields.keys).to include(association.inverse_type)
           end
 
-          it 'does not set up a field for the inverse type' do
-            expect(belonging_class.fields.keys).not_to include(association.inverse_type)
+          it 'connects the association to the corresponding resolver' do
+            expect(association.resolver).to be == BELONGS_TO_RESOLVER
           end
         end
       end
 
       context 'when the polymorphic option is not provided' do
-
         it 'does not set the polymorphic attribute on the owner class' do
           expect(belonging_class.polymorphic).to be(false)
         end
@@ -247,6 +280,10 @@ describe Mongoid::Association::Referenced::BelongsTo do
         it 'does not set up a field for the inverse type' do
           expect(belonging_class.fields.keys).not_to include(association.inverse_type)
         end
+
+        it 'does not use a resolver' do
+          expect(association.resolver).to be_nil
+        end
       end
     end
 

data/spec/mongoid/association/referenced/has_many/buildable_spec.rb

@@ -100,6 +100,10 @@ describe Mongoid::Association::Referenced::HasMany::Buildable do
         Post.where(association.foreign_key => object, 'ratable_type' => 'Rating')
       end
 
+      before do
+        Post.belongs_to :ratable, polymorphic: true
+      end
+
       it "adds the type to the criteria" do
         expect(documents).to eq(criteria)
       end

data/spec/mongoid/attributes/nested_spec.rb

@@ -2,6 +2,7 @@
 # rubocop:todo all
 
 require "spec_helper"
+require 'support/models/sandwich'
 require_relative '../association/referenced/has_many_models'
 require_relative '../association/referenced/has_and_belongs_to_many_models'
 require_relative './nested_spec_models'

data/spec/mongoid/clients/transactions_spec.rb

@@ -282,7 +282,7 @@ describe Mongoid::Clients::Sessions do
               end
             end
 
-            include_examples 'it aborts the transaction', Mongoid::Errors::InvalidTransactionNesting
+            include_examples 'it aborts the transaction', Mongoid::Errors::TransactionError
           end
         end
       end
@@ -591,7 +591,7 @@ describe Mongoid::Clients::Sessions do
             end
 
             it 'raises an error' do
-              expect(error).to be_a(Mongoid::Errors::InvalidTransactionNesting)
+              expect(error).to be_a(Mongoid::Errors::TransactionError)
             end
 
             it 'does not execute any operations' do