mongoid 7.1.11 → 7.2.0.rc1

data/lib/mongoid/query_cache.rb

@@ -17,8 +17,13 @@ module Mongoid
       # @return [ Hash ] The hash of cached queries.
       #
       # @since 4.0.0
+      # @api private
       def cache_table
-        Thread.current["[mongoid]:query_cache"] ||= {}
+        if defined?(Mongo::QueryCache)
+          raise NotImplementedError, "Mongoid does not expose driver's query cache table"
+        else
+          Thread.current["[mongoid]:query_cache"] ||= {}
+        end
       end
 
       # Clear the query cache.
@@ -30,7 +35,11 @@ module Mongoid
       #
       # @since 4.0.0
       def clear_cache
-        Thread.current["[mongoid]:query_cache"] = nil
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.clear
+        else
+          Thread.current["[mongoid]:query_cache"] = nil
+        end
       end
 
       # Set whether the cache is enabled.
@@ -42,7 +51,11 @@ module Mongoid
       #
       # @since 4.0.0
       def enabled=(value)
-        Thread.current["[mongoid]:query_cache:enabled"] = value
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.enabled = value
+        else
+          Thread.current["[mongoid]:query_cache:enabled"] = value
+        end
       end
 
       # Is the query cache enabled on the current thread?
@@ -54,7 +67,11 @@ module Mongoid
       #
       # @since 4.0.0
       def enabled?
-        !!Thread.current["[mongoid]:query_cache:enabled"]
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.enabled?
+        else
+          !!Thread.current["[mongoid]:query_cache:enabled"]
+        end
       end
 
       # Execute the block while using the query cache.
@@ -65,12 +82,18 @@ module Mongoid
       # @return [ Object ] The result of the block.
       #
       # @since 4.0.0
-      def cache
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = true
-        yield
-      ensure
-        QueryCache.enabled = enabled
+      def cache(&block)
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.cache(&block)
+        else
+          enabled = QueryCache.enabled?
+          QueryCache.enabled = true
+          begin
+            yield
+          ensure
+            QueryCache.enabled = enabled
+          end
+        end
       end
 
       # Execute the block with the query cache disabled.
@@ -79,12 +102,18 @@ module Mongoid
       #   QueryCache.uncached { collection.find }
       #
       # @return [ Object ] The result of the block.
-      def uncached
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = false
-        yield
-      ensure
-        QueryCache.enabled = enabled
+      def uncached(&block)
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.uncached(&block)
+        else
+          enabled = QueryCache.enabled?
+          QueryCache.enabled = false
+          begin
+            yield
+          ensure
+            QueryCache.enabled = enabled
+          end
+        end
       end
     end
 
@@ -127,6 +156,7 @@ module Mongoid
     # the database if the same query has already been executed.
     #
     # @since 5.0.0
+    # @deprecated This class is only used with driver versions 2.13 and lower.
     class CachedCursor < Mongo::Cursor
 
       # We iterate over the cached documents if they exist already in the
@@ -164,12 +194,10 @@ module Mongoid
 
       def process(result)
         documents = super
-
         if @cursor_id.zero? && !@after_first_batch
           @cached_documents ||= []
           @cached_documents.concat(documents)
         end
-
         @after_first_batch = true
         documents
       end
@@ -179,6 +207,7 @@ module Mongoid
     # operations.
     #
     # @since 4.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module Base
 
       def alias_query_cache_clear(*method_names)
@@ -198,6 +227,7 @@ module Mongoid
     # cached cursor or a regular cursor on iteration.
     #
     # @since 5.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module View
       extend ActiveSupport::Concern
 
@@ -228,24 +258,19 @@ module Mongoid
         else
           @cursor = nil
           unless @cursor = cached_cursor
-
-            if driver_supports_cursor_sessions?
-              session = client.send(:get_session, @options)
-              read_with_retry(session, server_selector) do |server|
-                result = send_initial_query(server, session)
-                @cursor = get_cursor(result, server, session)
-              end
-            else
-              read_with_retry do
-                server = server_selector.select_server(cluster)
-                result = send_initial_query(server)
-                @cursor = get_cursor(result, server)
+            session = client.send(:get_session, @options)
+            read_with_retry(session, server_selector) do |server|
+              result = send_initial_query(server, session)
+              if result.cursor_id == 0 || result.cursor_id.nil?
+                @cursor = CachedCursor.new(view, result, server, session: session)
+                QueryCache.cache_table[cache_key] = @cursor
+              else
+                @cursor = Mongo::Cursor.new(view, result, server, session: session)
               end
             end
           end
-
           if block_given?
-            if limit && limit != -1
+            if limit
               @cursor.to_a[0...limit].each do |doc|
                 yield doc
               end
@@ -270,44 +295,19 @@ module Mongoid
         cursor || QueryCache.cache_table[cache_key]
       end
 
-      def get_cursor(result, server, session = nil)
-        if result.cursor_id == 0 || result.cursor_id.nil?
-          cursor = if session
-            CachedCursor.new(view, result, server, session: session)
-          else
-            CachedCursor.new(view, result, server)
-          end
-
-          QueryCache.cache_table[cache_key] = cursor
-        else
-          cursor = if session
-            Mongo::Cursor.new(view, result, server, session: session)
-          else
-            Mongo::Cursor.new(view, result, server)
-          end
-        end
-
-        cursor
-      end
-
       def cache_key
         [ collection.namespace, selector, limit, skip, sort, projection, collation ]
       end
 
       def system_collection?
-        collection.namespace =~ /\Asystem./
-      end
-
-      def driver_supports_cursor_sessions?
-        # Driver versions 2.9 and newer support passing in a session to the
-        # cursor object.
-        (Mongo::VERSION.split('.').map(&:to_i) <=> [2, 9, 0]) > 0
+        collection.name.start_with?('system.')
       end
     end
 
     # Adds behavior to the query cache for collections.
     #
     # @since 5.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module Collection
       extend ActiveSupport::Concern
 
@@ -326,6 +326,8 @@ module Mongoid
   end
 end
 
-Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
-Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
-Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
+unless defined?(Mongo::QueryCache)
+  Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
+  Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
+  Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
+end

data/lib/mongoid/reloadable.rb

@@ -21,11 +21,6 @@ module Mongoid
     #
     # @since 1.0.0
     def reload
-      if @atomic_selector
-        # Clear atomic_selector cache for sharded clusters. MONGOID-5076
-        remove_instance_variable('@atomic_selector')
-      end
-
       reloaded = _reload
       if Mongoid.raise_not_found_error && reloaded.empty?
         raise Errors::DocumentNotFound.new(self.class, _id, _id)
@@ -65,7 +60,7 @@ module Mongoid
     #
     # @since 2.3.2
     def reload_root_document
-      {}.merge(collection.find({ _id: _id }, session: _session).read(mode: :primary).first || {})
+      {}.merge(collection.find(atomic_selector, session: _session).read(mode: :primary).first || {})
     end
 
     # Reload the embedded document.
@@ -78,7 +73,7 @@ module Mongoid
     # @since 2.3.2
     def reload_embedded_document
       extract_embedded_attributes({}.merge(
-        collection(_root).find(_id: _root._id).read(mode: :primary).first
+        collection(_root).find(_root.atomic_selector).read(mode: :primary).first
       ))
     end
 

data/lib/mongoid/serializable.rb

@@ -80,7 +80,7 @@ module Mongoid
 
       only = Array.wrap(options[:only]).map(&:to_s)
       except = Array.wrap(options[:except]).map(&:to_s)
-      except |= ['_type'] unless Mongoid.include_type_for_serialization
+      except |= [self.class.discriminator_key] unless Mongoid.include_type_for_serialization
 
       if !only.empty?
         names &= only

data/lib/mongoid/tasks/database.rb

@@ -123,7 +123,7 @@ module Mongoid
           next if model.shard_config.nil?
 
           if model.embedded? && !model.cyclic?
-            logger.warn("MONGOID: #{model} has shard config but is embedded")
+            logger.warn("MONGOID: #{model} has shard config but is emdedded")
             next
           end
 

data/lib/mongoid/traversable.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
+require "mongoid/fields/validators/macro"
+
 module Mongoid
 
   # Provides behavior around traversing the document graph.
@@ -17,6 +19,105 @@ module Mongoid
       @__parent = p
     end
 
+    # Module used for prepending to the various discriminator_*= methods
+    #
+    # @api private
+    module DiscriminatorAssignment
+      def discriminator_key=(value)
+        if hereditary?
+          raise Errors::InvalidDiscriminatorKeyTarget.new(self, self.superclass)
+        end
+
+        _mongoid_clear_types
+
+        if value
+          Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
+          value = value.to_s
+          super
+        else
+          # When discriminator key is set to nil, replace the class's definition
+          # of the discriminator key reader (provided by class_attribute earlier)
+          # and re-delegate to Mongoid.
+          class << self
+            delegate :discriminator_key, to: ::Mongoid
+          end
+        end
+
+        # This condition checks if the new discriminator key would overwrite
+        # 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.
+        if !fields.has_key?(self.discriminator_key) && !descendants.empty?
+          default_proc = lambda { self.class.discriminator_value }
+          field(self.discriminator_key, default: default_proc, type: String)
+        end
+      end
+
+      def discriminator_value=(value)
+        value ||= self.name
+        _mongoid_clear_types
+        add_discriminator_mapping(value)
+        @discriminator_value = value
+      end
+    end
+
+    # Module used for prepending the discriminator_value method.
+    #
+    # A separate module was needed because the subclasses of this class
+    # need to be manually prepended with the discriminator_value and can't
+    # rely on being a class_attribute because the .discriminator_value
+    # method is overriden by every subclass in the inherited method.
+    #
+    # @api private
+    module DiscriminatorRetrieval
+
+      # Get the name on the reading side if the discriminator_value is nil
+      def discriminator_value
+        @discriminator_value || self.name
+      end
+    end
+
+    included do
+      class_attribute :discriminator_key, instance_accessor: false
+
+      class << self
+        delegate :discriminator_key, to: ::Mongoid
+        prepend DiscriminatorAssignment
+        include DiscriminatorRetrieval
+
+        # @api private
+        #
+        # @return [ Hash<String, Class> ] The current mapping of discriminator_values to classes
+        attr_accessor :discriminator_mapping
+      end
+
+      # Add a discriminator mapping to the parent class. This mapping is used when
+      # receiving a document to identify its class.
+      #
+      # @param [ String ] value The discriminator_value that was just set
+      # @param [ Class ] The class the discriminator_value was set on
+      #
+      # @api private
+      def self.add_discriminator_mapping(value, klass=self)
+        self.discriminator_mapping ||= {}
+        self.discriminator_mapping[value] = klass
+        superclass.add_discriminator_mapping(value, klass) if hereditary?
+      end
+
+      # Get the discriminator mapping from the parent class. This method returns nil if there
+      # is no mapping for the given value.
+      #
+      # @param [ String ] value The discriminator_value to retrieve
+      #
+      # @return [ Class | nil ] klass The class corresponding to the given discriminator_value. If
+      #                               the value is not in the mapping, this method returns nil.
+      #
+      # @api private
+      def self.get_discriminator_mapping(value)
+        self.discriminator_mapping[value] if self.discriminator_mapping
+      end
+    end
+
     # Get all child +Documents+ to this +Document+, going n levels deep if
     # necessary. This is used when calling update persistence operations from
     # the root document, where changes in the entire tree need to be
@@ -201,14 +302,20 @@ module Mongoid
         subclass.pre_processed_defaults = pre_processed_defaults.dup
         subclass.post_processed_defaults = post_processed_defaults.dup
         subclass._declared_scopes = Hash.new { |hash,key| self._declared_scopes[key] }
+        subclass.discriminator_value = subclass.name
+
+        # We need to do this here because the discriminator_value method is
+        # overriden in the subclass above.
+        class << subclass
+          include DiscriminatorRetrieval
+        end
 
         # We only need the _type field if inheritance is in play, but need to
         # add to the root class as well for backwards compatibility.
-        unless fields.has_key?("_type")
-          field(:_type, default: self.name, type: String)
+        unless fields.has_key?(self.discriminator_key)
+          default_proc = lambda { self.class.discriminator_value }
+          field(self.discriminator_key, default: default_proc, type: String)
         end
-        subclass_default = subclass.name || ->{ self.class.name }
-        subclass.field(:_type, default: subclass_default, type: String, overwrite: true)
       end
     end
   end

data/lib/mongoid/validatable/associated.rb

@@ -43,7 +43,7 @@ module Mongoid
         ensure
           document.exit_validate
         end
-        document.errors.add(attribute, :invalid, **options) unless valid
+        document.errors.add(attribute, :invalid, options) unless valid
       end
     end
   end

data/lib/mongoid/validatable/presence.rb

@@ -34,15 +34,15 @@ module Mongoid
             document.errors.add(
               attribute,
               :blank_in_locale,
-              **options.merge(location: _locale)
+              options.merge(location: _locale)
             ) if not_present?(_value)
           end
         elsif document.relations.has_key?(attribute.to_s)
           if relation_or_fk_missing?(document, attribute, value)
-            document.errors.add(attribute, :blank, **options)
+            document.errors.add(attribute, :blank, options)
           end
         else
-          document.errors.add(attribute, :blank, **options) if not_present?(value)
+          document.errors.add(attribute, :blank, options) if not_present?(value)
         end
       end
 

data/lib/mongoid/validatable/uniqueness.rb

@@ -68,7 +68,7 @@ module Mongoid
       # @since 2.4.10
       def add_error(document, attribute, value)
         document.errors.add(
-          attribute, :taken, **options.except(:case_sensitive, :scope).merge(value: value)
+          attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value)
         )
       end
 

data/lib/mongoid/version.rb

@@ -2,5 +2,5 @@
 # encoding: utf-8
 
 module Mongoid
-  VERSION = "7.1.11"
+  VERSION = "7.2.0.rc1"
 end

data/lib/mongoid.rb

@@ -6,7 +6,6 @@ require "support/ruby_version"
 require "forwardable"
 require "time"
 require "set"
-require "ruby2_keywords"
 
 require "active_support"
 require "active_support/core_ext"
@@ -112,4 +111,27 @@ module Mongoid
   #
   # @since 1.0.0
   def_delegators Config, *(Config.public_instance_methods(false) - [ :logger=, :logger ])
+
+
+  # Module used to prepend the discriminator key assignment function to change
+  # the value assigned to the discriminator key to a string.
+  #
+  # @api private
+  module GlobalDiscriminatorKeyAssignment
+    # This class is used for obtaining the method definition location for
+    # Mongoid methods.
+    class InvalidFieldHost
+      include Mongoid::Document
+    end
+
+    def discriminator_key=(value)
+      Mongoid::Fields::Validators::Macro.validate_field_name(InvalidFieldHost, value)
+      value = value.to_s
+      super
+    end
+  end
+
+  class << self
+    prepend GlobalDiscriminatorKeyAssignment
+  end
 end

data/lib/rails/generators/mongoid/config/config_generator.rb

@@ -15,14 +15,7 @@ module Mongoid
       end
 
       def app_name
-        app_cls = Rails.application.class
-        parent = begin
-          # Rails 6.1+
-          app_cls.module_parent_name
-        rescue NoMethodError
-          app_cls.parent.to_s
-        end
-        parent.underscore
+        Rails::Application.subclasses.first.parent.to_s.underscore
       end
 
       def create_config_file

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -57,7 +57,7 @@ development:
         # connect: :direct
 
         # Changes the default time in seconds the server monitors refresh their status
-        # via hello commands. (default: 10)
+        # via ismaster commands. (default: 10)
         # heartbeat_frequency: 10
 
         # The time in seconds for selecting servers for a near read preference. (default: 0.015)