mongoid 9.0.1 → 9.0.3

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.
@@ -116,12 +117,15 @@ module Mongoid
     def client
       @client ||= begin
         client = Clients.with_name(client_name)
+        options = client_options
+
         if database_name_option
           client = client.use(database_name)
+          options = options.except(:database, 'database')
         end
-        unless client_options.empty?
-          client = client.with(client_options)
-        end
+
+        client = client.with(options) unless options.empty?
+
         client
       end
     end
@@ -281,6 +285,10 @@ module Mongoid
       # @api private
       PERSISTENCE_CONTEXT_KEY = :"[mongoid]:persistence_context"
 
+      def context_store
+        Threaded.get(PERSISTENCE_CONTEXT_KEY) { {} }
+      end
+
       # Get the persistence context for a given object from the thread local
       #   storage.
       #
@@ -291,8 +299,7 @@ module Mongoid
       #
       # @api private
       def get_context(object)
-        Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
-        Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id]
+        context_store[object.object_id]
       end
 
       # Store persistence context for a given object in the thread local
@@ -304,10 +311,9 @@ module Mongoid
       # @api private
       def store_context(object, context)
         if context.nil?
-          Thread.current[PERSISTENCE_CONTEXT_KEY]&.delete(object.object_id)
+          context_store.delete(object.object_id)
         else
-          Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
-          Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id] = context
+          context_store[object.object_id] = context
         end
       end
     end

data/lib/mongoid/railties/controller_runtime.rb

@@ -78,7 +78,7 @@ module Mongoid
         #
         # @return [ Integer ] The runtime value.
         def self.runtime
-          Thread.current[VARIABLE_NAME] ||= 0
+          Threaded.get(VARIABLE_NAME) { 0 }
         end
 
         # Set the runtime value on the current thread.
@@ -87,7 +87,7 @@ module Mongoid
         #
         # @return [ Integer ] The runtime value.
         def self.runtime= value
-          Thread.current[VARIABLE_NAME] = value
+          Threaded.set(VARIABLE_NAME, value)
         end
 
         # Reset the runtime value to zero the current thread.

data/lib/mongoid/serializable.rb

@@ -13,13 +13,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/threaded.rb

@@ -18,6 +18,7 @@ module Mongoid
     CURRENT_SCOPE_KEY = '[mongoid]:current-scope'
 
     AUTOSAVES_KEY = '[mongoid]:autosaves'
+
     VALIDATIONS_KEY = '[mongoid]:validations'
 
     STACK_KEYS = Hash.new do |hash, key|
@@ -36,6 +37,75 @@ module Mongoid
 
     extend self
 
+    # Queries the thread-local variable with the given name. If a block is
+    # given, and the variable does not already exist, the return value of the
+    # block will be set as the value of the variable before returning it.
+    #
+    # It is very important that applications (and espcially Mongoid)
+    # use this method instead of Thread#[], since Thread#[] is actually for
+    # fiber-local variables, and Mongoid uses Fibers as an implementation
+    # detail in some callbacks. Putting thread-local state in a fiber-local
+    # store will result in the state being invisible when relevant callbacks are
+    # run in a different fiber.
+    #
+    # Affected callbacks are cascading callbacks on embedded children.
+    #
+    # @param [ String | Symbol ] key the name of the variable to query
+    # @param [ Proc ] default an optional block that must return the default
+    #   (initial) value of this variable.
+    #
+    # @return [ Object | nil ] the value of the queried variable, or nil if
+    #   it is not set and no default was given.
+    def get(key, &default)
+      result = Thread.current.thread_variable_get(key)
+
+      if result.nil? && default
+        result = yield
+        set(key, result)
+      end
+
+      result
+    end
+
+    # Sets a thread-local variable with the given name to the given value.
+    # See #get for a discussion of why this method is necessary, and why
+    # Thread#[]= should be avoided in cascading callbacks on embedded children.
+    #
+    # @param [ String | Symbol ] key the name of the variable to set.
+    # @param [ Object | nil ] value the value of the variable to set (or `nil`
+    #   if you wish to unset the variable)
+    def set(key, value)
+      Thread.current.thread_variable_set(key, value)
+    end
+
+    # Removes the named variable from thread-local storage.
+    #
+    # @param [ String | Symbol ] key the name of the variable to remove.
+    def delete(key)
+      set(key, nil)
+    end
+
+    # Queries the presence of a named variable in thread-local storage.
+    #
+    # @param [ String | Symbol ] key the name of the variable to query.
+    #
+    # @return [ true | false ] whether the given variable is present or not.
+    def has?(key)
+      # Here we have a classic example of JRuby not behaving like MRI. In
+      # MRI, if you set a thread variable to nil, it removes it from the list
+      # and subsequent calls to thread_variable?(key) will return false. Not
+      # so with JRuby. Once set, you cannot unset the thread variable.
+      #
+      # However, because setting a variable to nil is supposed to remove it,
+      # we can assume a nil-valued variable doesn't actually exist.
+
+      # So, instead of this:
+      # Thread.current.thread_variable?(key)
+
+      # We have to do this:
+      !get(key).nil?
+    end
+
     # Begin entry into a named thread local stack.
     #
     # @example Begin entry into the stack.
@@ -55,7 +125,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def database_override
-      Thread.current[DATABASE_OVERRIDE_KEY]
+      get(DATABASE_OVERRIDE_KEY)
     end
 
     # Set the global database override.
@@ -67,7 +137,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def database_override=(name)
-      Thread.current[DATABASE_OVERRIDE_KEY] = name
+      set(DATABASE_OVERRIDE_KEY, name)
     end
 
     # Are in the middle of executing the named stack
@@ -103,7 +173,7 @@ module Mongoid
     #
     # @return [ Array ] The stack.
     def stack(name)
-      Thread.current[STACK_KEYS[name]] ||= []
+      get(STACK_KEYS[name]) { [] }
     end
 
     # Begin autosaving a document on the current thread.
@@ -177,7 +247,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def client_override
-      Thread.current[CLIENT_OVERRIDE_KEY]
+      get(CLIENT_OVERRIDE_KEY)
     end
 
     # Set the global client override.
@@ -189,7 +259,7 @@ module Mongoid
     #
     # @return [ String | Symbol ] The override.
     def client_override=(name)
-      Thread.current[CLIENT_OVERRIDE_KEY] = name
+      set(CLIENT_OVERRIDE_KEY, name)
     end
 
     # Get the current Mongoid scope.
@@ -202,12 +272,12 @@ module Mongoid
     #
     # @return [ Criteria ] The scope.
     def current_scope(klass = nil)
-      if klass && Thread.current[CURRENT_SCOPE_KEY].respond_to?(:keys)
-        Thread.current[CURRENT_SCOPE_KEY][
-            Thread.current[CURRENT_SCOPE_KEY].keys.find { |k| k <= klass }
-        ]
+      current_scope = get(CURRENT_SCOPE_KEY)
+
+      if klass && current_scope.respond_to?(:keys)
+        current_scope[current_scope.keys.find { |k| k <= klass }]
       else
-        Thread.current[CURRENT_SCOPE_KEY]
+        current_scope
       end
     end
 
@@ -220,7 +290,7 @@ module Mongoid
     #
     # @return [ Criteria ] The scope.
     def current_scope=(scope)
-      Thread.current[CURRENT_SCOPE_KEY] = scope
+      set(CURRENT_SCOPE_KEY, scope)
     end
 
     # Set the current Mongoid scope. Safe for multi-model scope chaining.
@@ -236,8 +306,8 @@ module Mongoid
       if scope.nil?
         unset_current_scope(klass)
       else
-        Thread.current[CURRENT_SCOPE_KEY] ||= {}
-        Thread.current[CURRENT_SCOPE_KEY][klass] = scope
+        current_scope = get(CURRENT_SCOPE_KEY) { {} }
+        current_scope[klass] = scope
       end
     end
 
@@ -284,7 +354,7 @@ module Mongoid
     #
     # @return [ Hash ] The current autosaves.
     def autosaves
-      Thread.current[AUTOSAVES_KEY] ||= {}
+      get(AUTOSAVES_KEY) { {} }
     end
 
     # Get all validations on the current thread.
@@ -294,7 +364,7 @@ module Mongoid
     #
     # @return [ Hash ] The current validations.
     def validations
-      Thread.current[VALIDATIONS_KEY] ||= {}
+      get(VALIDATIONS_KEY) { {} }
     end
 
     # Get all autosaves on the current thread for the class.
@@ -376,9 +446,7 @@ module Mongoid
     # @return [ Set<Mongoid::Document> ] Collection of modified documents before
     #   it was cleared.
     def clear_modified_documents(session)
-      modified_documents[session].dup
-    ensure
-      modified_documents[session].clear
+      modified_documents.delete(session) || []
     end
 
     # Queries whether document callbacks should be executed by default for the
@@ -390,8 +458,8 @@ module Mongoid
     # @return [ true | false ] Whether or not document callbacks should be
     #   executed by default.
     def execute_callbacks?
-      if Thread.current.key?(EXECUTE_CALLBACKS)
-        Thread.current[EXECUTE_CALLBACKS]
+      if has?(EXECUTE_CALLBACKS)
+        get(EXECUTE_CALLBACKS)
       else
         true
       end
@@ -404,7 +472,7 @@ module Mongoid
     # @param flag [ true | false ] Whether or not document callbacks should be
     #   executed by default.
     def execute_callbacks=(flag)
-      Thread.current[EXECUTE_CALLBACKS] = flag
+      set(EXECUTE_CALLBACKS, flag)
     end
 
     # Returns the thread store of sessions.
@@ -413,7 +481,7 @@ module Mongoid
     #
     # @api private
     def sessions
-      Thread.current[SESSIONS_KEY] ||= {}.compare_by_identity
+      get(SESSIONS_KEY) { {}.compare_by_identity }
     end
 
     # Returns the thread store of modified documents.
@@ -423,9 +491,7 @@ module Mongoid
     #
     # @api private
     def modified_documents
-      Thread.current[MODIFIED_DOCUMENTS_KEY] ||= Hash.new do |h, k|
-        h[k] = Set.new
-      end
+      get(MODIFIED_DOCUMENTS_KEY) { Hash.new { |h, k| h[k] = Set.new } }
     end
 
     private
@@ -435,10 +501,12 @@ module Mongoid
     #
     # @param klass [ Class ] the class to remove from the current scope.
     def unset_current_scope(klass)
-      return unless Thread.current[CURRENT_SCOPE_KEY]
+      return unless has?(CURRENT_SCOPE_KEY)
+
+      scope = get(CURRENT_SCOPE_KEY)
+      scope.delete(klass)
 
-      Thread.current[CURRENT_SCOPE_KEY].delete(klass)
-      Thread.current[CURRENT_SCOPE_KEY] = nil if Thread.current[CURRENT_SCOPE_KEY].empty?
+      delete(CURRENT_SCOPE_KEY) if scope.empty?
     end
   end
 end

data/lib/mongoid/timestamps/timeless.rb

@@ -46,6 +46,9 @@ module Mongoid
       class << self
         extend Forwardable
 
+        # The key to use to store the timeless table 
+        TIMELESS_TABLE_KEY = '[mongoid]:timeless'
+
         # Returns the in-memory thread cache of classes
         # for which to skip timestamping.
         #
@@ -53,7 +56,7 @@ module Mongoid
         #
         # @api private
         def timeless_table
-          Thread.current['[mongoid]:timeless'] ||= Hash.new
+          Threaded.get(TIMELESS_TABLE_KEY) { Hash.new }
         end
 
         def_delegators :timeless_table, :[]=, :[]

data/lib/mongoid/touchable.rb

@@ -195,7 +195,7 @@ module Mongoid
     # @return [ Hash ] The hash that contains touch callback suppression
     #   statuses
     def touch_callback_statuses
-      Thread.current[SUPPRESS_TOUCH_CALLBACKS_KEY] ||= {}
+      Threaded.get(SUPPRESS_TOUCH_CALLBACKS_KEY) { {} }
     end
 
     # Define the method that will get called for touching belongs_to

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
@@ -100,7 +105,11 @@ module Mongoid
         if value
           Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
           value = value.to_s
-          super
+          if defined?(::ActiveSupport::ClassAttribute)
+            ::ActiveSupport::ClassAttribute.redefine(self, 'discriminator_key', value)
+          else
+            super
+          end
         else
           # When discriminator key is set to nil, replace the class's definition
           # of the discriminator key reader (provided by class_attribute earlier)
@@ -114,7 +123,7 @@ module Mongoid
         # an existing field.
         # This condition also checks if the class has any descendants, because
         # if it doesn't then it doesn't need a discriminator key.
-        return unless !fields.key?(discriminator_key) && !descendants.empty?
+        return if fields.key?(discriminator_key) || descendants.empty?
 
         default_proc = -> { self.class.discriminator_value }
         field(discriminator_key, default: default_proc, type: String)

data/lib/mongoid/validatable/associated.rb

@@ -70,13 +70,16 @@ module Mongoid
           # Now, treating the target as an array, look at each element
           # and see if it is valid, but only if it has already been
           # persisted, or changed, and hasn't been flagged for destroy.
-          list.all? do |value|
+          #
+          # use map.all? instead of just all?, because all? will do short-circuit
+          # evaluation and terminate on the first failed validation.
+          list.map do |value|
             if value && !value.flagged_for_destroy? && (!value.persisted? || value.changed?)
               value.validated? ? true : value.valid?
             else
               true
             end
-          end
+          end.all?
         end
 
         document.errors.add(attribute, :invalid) unless valid

data/lib/mongoid/version.rb

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

data/spec/integration/active_job_spec.rb

@@ -2,31 +2,35 @@
 # rubocop:todo all
 
 require 'spec_helper'
-require 'active_job'
-require 'mongoid/railties/bson_object_id_serializer'
+begin
+  require 'active_job'
+  require 'mongoid/railties/bson_object_id_serializer'
 
-describe 'ActiveJob Serialization' do
-  skip unless defined?(ActiveJob)
+  describe 'ActiveJob Serialization' do
+    skip unless defined?(ActiveJob)
 
-  class TestBsonObjectIdSerializerJob < ActiveJob::Base
-    def perform(*args)
-      args
+    class TestBsonObjectIdSerializerJob < ActiveJob::Base
+      def perform(*args)
+        args
+      end
     end
-  end
 
-  let(:band) do
-    Band.create!
-  end
+    let(:band) do
+      Band.create!
+    end
 
-  before do
-    ActiveJob::Serializers.add_serializers(
-      [::Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer]
-    )
-  end
+    before do
+      ActiveJob::Serializers.add_serializers(
+        [::Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer]
+      )
+    end
 
-  it 'serializes and deserializes BSON::ObjectId' do
-    expect do
-      TestBsonObjectIdSerializerJob.perform_later(band.id)
-    end.not_to raise_error
+    it 'serializes and deserializes BSON::ObjectId' do
+      expect do
+        TestBsonObjectIdSerializerJob.perform_later(band.id)
+      end.not_to raise_error
+    end
   end
+rescue LoadError
+  RSpec.context.skip 'This test requires active_job'
 end