mongoid 7.2.1 → 9.0.0

data/lib/mongoid/railties/console_sandbox.rb

@@ -0,0 +1,42 @@
+# rubocop:todo all
+require "mongoid/threaded"
+require "mongoid/errors/transactions_not_supported"
+
+# This method raises an error if the cluster the client is connected to
+# does not support transactions in any case. At the moment this is the case
+# of the standalone topology.
+#
+# Please note that if this method did not raise, it does not guarantee that
+# transactions are available for the cluster.
+#
+# @param [ Mongo::Client ] client Client connected to a cluster to be tested.
+#
+# @raise [ Mongoid::Errors::TransactionsNotSupported ] If the cluster
+#   definitely does not support transactions.
+def check_if_transactions_might_be_available!(client)
+  if client.cluster.single?
+    raise Mongoid::Errors::TransactionsNotSupported
+  end
+end
+
+# Starts a transaction that should include all the operations inside
+# the sandboxed console session. This transaction should not be ever committed.
+# When a user end the console session, the client will disconnect, and
+# the transaction will be automatically aborted therefore.
+#
+# @param [ Mongo::Client ] client Client to start the transaction.
+def start_sandbox_transaction(client)
+  session = client.start_session
+  ::Mongoid::Threaded.set_session(session, client: client)
+  session.start_transaction
+end
+
+# Prepares console sandbox mode. This method should be called when
+# a user starts rails console with '--sandbox' flag.
+def start_sandbox
+  Mongoid.persistence_context.client.tap do |client|
+    check_if_transactions_might_be_available!(client)
+    start_sandbox_transaction(client)
+  end
+end
+

data/lib/mongoid/railties/controller_runtime.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
   module Railties
@@ -47,9 +47,7 @@ module Mongoid
             messages << ("MongoDB: %.1fms" % mongoid_runtime.to_f) if mongoid_runtime
             messages
           end
-
         end
-
       end
 
       # The Collector of MongoDB runtime metric, that subscribes to Mongo
@@ -60,30 +58,47 @@ module Mongoid
 
         VARIABLE_NAME = "Mongoid.controller_runtime".freeze
 
+        # Call when event started. Does nothing.
+        #
+        # @return [ nil ] Nil.
         def started _; end
 
+        # Call when event completed. Updates the runtime value.
+        #
+        # @param [ Mongo::Event::Base ] e The monitoring event.
+        #
+        # @return [ Integer ] The current runtime value.
         def _completed e
-          Collector.runtime += e.duration
+          Collector.runtime += e.duration * 1000
         end
         alias :succeeded :_completed
         alias :failed :_completed
 
+        # Get the runtime value on the current thread.
+        #
+        # @return [ Integer ] The runtime value.
         def self.runtime
           Thread.current[VARIABLE_NAME] ||= 0
         end
 
+        # Set the runtime value on the current thread.
+        #
+        # @param [ Integer ] value The runtime value.
+        #
+        # @return [ Integer ] The runtime value.
         def self.runtime= value
           Thread.current[VARIABLE_NAME] = value
         end
 
+        # Reset the runtime value to zero the current thread.
+        #
+        # @return [ Integer ] The previous runtime value.
         def self.reset_runtime
           to_now = runtime
           self.runtime = 0
           to_now
         end
-
       end
-
     end
   end
 end

data/lib/mongoid/railties/database.rake

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 load 'mongoid/tasks/database.rake'
+load "mongoid/tasks/encryption.rake"
 
 namespace :db do
 
@@ -25,7 +27,7 @@ namespace :db do
 
   unless Rake::Task.task_defined?("db:setup")
     desc "Create the database, and initialize with the seed data"
-    task :setup => [ "db:create", "mongoid:create_indexes", "db:seed" ]
+    task :setup => [ "db:create", "mongoid:create_collections", "mongoid:create_indexes", "db:seed" ]
   end
 
   unless Rake::Task.task_defined?("db:reset")
@@ -55,15 +57,25 @@ namespace :db do
 
   unless Rake::Task.task_defined?("db:test:prepare")
     namespace :test do
-      task :prepare => "mongoid:create_indexes"
+      task :prepare => ["mongoid:create_collections", "mongoid:create_indexes"]
     end
   end
 
+  unless Rake::Task.task_defined?("db:create_collections")
+    desc "Create collections specified in Mongoid models"
+    task :create_collections => "mongoid:create_collections"
+  end
+
   unless Rake::Task.task_defined?("db:create_indexes")
     desc "Create indexes specified in Mongoid models"
     task :create_indexes => "mongoid:create_indexes"
   end
 
+  unless Rake::Task.task_defined?("db:create_search_indexes")
+    desc "Create search indexes specified in Mongoid models"
+    task :create_search_indexes => "mongoid:create_search_indexes"
+  end
+
   unless Rake::Task.task_defined?("db:remove_indexes")
     desc "Remove indexes specified in Mongoid models"
     task :remove_indexes => "mongoid:remove_indexes"
@@ -74,6 +86,11 @@ namespace :db do
     task :shard_collections => "mongoid:shard_collections"
   end
 
+  namespace :encryption do
+    desc "Create encryption key"
+    task :create_data_key =>  "mongoid:encryption:create_data_key"
+  end
+
   namespace :mongoid do
     task :load_models do
       ::Rails.application.eager_load! if defined?(::Rails)

data/lib/mongoid/reloadable.rb

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 module Mongoid
-
   # This module handles reloading behavior of documents.
-  #
-  # @since 4.0.0
   module Reloadable
-
     # Reloads the +Document+ attributes from the database. If the document has
     # not been saved then an error will get raised if the configuration option
     # was set. This can reload root documents or embedded documents.
@@ -18,19 +13,12 @@ module Mongoid
     # @raise [ Errors::DocumentNotFound ] If the document was deleted.
     #
     # @return [ Document ] The document, reloaded.
-    #
-    # @since 1.0.0
     def reload
       reloaded = _reload
-      if Mongoid.raise_not_found_error && reloaded.empty?
-        raise Errors::DocumentNotFound.new(self.class, _id, _id)
-      end
-      @attributes = reloaded
-      @attributes_before_type_cast = {}
-      changed_attributes.clear
-      reset_readonly
-      apply_defaults
-      reload_relations
+      check_for_deleted_document!(reloaded)
+
+      reset_object!(reloaded)
+
       run_callbacks(:find) unless _find_callbacks.empty?
       run_callbacks(:initialize) unless _initialize_callbacks.empty?
       self
@@ -38,6 +26,43 @@ module Mongoid
 
     private
 
+    # Resets the current object using the given attributes.
+    #
+    # @param [ Hash ] attributes The attributes to use to replace the current
+    #   attributes hash.
+    def reset_object!(attributes)
+      reset_atomic_updates!
+
+      @attributes = attributes
+      @attributes_before_type_cast = @attributes.dup
+      @changed_attributes = {}
+      @previous_changes = {}
+      @previous_attributes = {}
+      @previously_new_record = false
+
+      reset_readonly
+      apply_defaults
+      reload_relations
+    end
+
+    # Checks to see if the given attributes argument indicates that the object
+    # has been deleted. If the attributes are nil or an empty Hash, then
+    # we assume it has been deleted.
+    #
+    # If Mongoid.raise_not_found_error is false, this will do nothing.
+    #
+    # @param [ Hash | nil ] attributes The attributes hash retrieved from
+    #   the database
+    #
+    # @raise [ Errors::DocumentNotFound ] If the document was deleted.
+    def check_for_deleted_document!(attributes)
+      return unless Mongoid.raise_not_found_error
+      return unless attributes.nil? || attributes.empty?
+
+      shard_keys = atomic_selector.with_indifferent_access.slice(*shard_key_fields, :_id)
+      raise Errors::DocumentNotFound.new(self.class, _id, shard_keys)
+    end
+
     # Reload the document, determining if it's embedded or not and what
     # behavior to use.
     #
@@ -45,8 +70,6 @@ module Mongoid
     #   document._reload
     #
     # @return [ Hash ] The reloaded attributes.
-    #
-    # @since 2.3.2
     def _reload
       embedded? ? reload_embedded_document : reload_root_document
     end
@@ -57,8 +80,6 @@ module Mongoid
     #   document.reload_root_document
     #
     # @return [ Hash ] The reloaded attributes.
-    #
-    # @since 2.3.2
     def reload_root_document
       {}.merge(collection.find(atomic_selector, session: _session).read(mode: :primary).first || {})
     end
@@ -69,29 +90,11 @@ module Mongoid
     #   document.reload_embedded_document
     #
     # @return [ Hash ] The reloaded attributes.
-    #
-    # @since 2.3.2
     def reload_embedded_document
-      extract_embedded_attributes({}.merge(
-        collection(_root).find(_root.atomic_selector).read(mode: :primary).first
-      ))
-    end
-
-    # Extract only the desired embedded document from the attributes.
-    #
-    # @example Extract the embedded document.
-    #   document.extract_embedded_attributes(attributes)
-    #
-    # @param [ Hash ] attributes The document in the db.
-    #
-    # @return [ Hash ] The document's extracted attributes.
-    #
-    # @since 2.3.2
-    def extract_embedded_attributes(attributes)
-      atomic_position.split(".").inject(attributes) do |attrs, part|
-        attrs = attrs[part =~ /\d/ ? part.to_i : part]
-        attrs
-      end
+      Mongoid::Attributes::Embedded.traverse(
+        collection(_root).find(_root.atomic_selector, session: _session).read(mode: :primary).first,
+        atomic_position
+      )
     end
   end
 end

data/lib/mongoid/scopable.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
 
   # This module contains behavior for all Mongoid scoping - named scopes,
   # default scopes, and criteria accessors via scoped and unscoped.
-  #
-  # @since 4.0.0
   module Scopable
     extend ActiveSupport::Concern
 
@@ -26,9 +24,7 @@ module Mongoid
     # @example Apply the default scoping.
     #   document.apply_default_scoping
     #
-    # @return [ true, false ] If default scoping was applied.
-    #
-    # @since 4.0.0
+    # @return [ true | false ] If default scoping was applied.
     def apply_default_scoping
       if default_scoping
         default_scoping.call.selector.each do |field, value|
@@ -52,8 +48,6 @@ module Mongoid
       #   Band.scopes
       #
       # @return [ Hash ] The scopes defined for this class
-      #
-      # @since 3.1.4
       def scopes
         defined_scopes = {}
         ancestors.reverse.each do |klass|
@@ -81,13 +75,11 @@ module Mongoid
       #     default_scope ->{ where(active: true) }
       #   end
       #
-      # @param [ Proc, Criteria ] value The default scope.
+      # @param [ Proc | Criteria ] value The default scope.
       #
       # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
       #
       # @return [ Proc ] The default scope.
-      #
-      # @since 1.0.0
       def default_scope(value = nil)
         value = Proc.new { yield } if block_given?
         check_scope_validity(value)
@@ -99,9 +91,7 @@ module Mongoid
       # @example Can the default scope be applied?
       #   Band.default_scopable?
       #
-      # @return [ true, false ] If the default scope can be applied.
-      #
-      # @since 3.0.0
+      # @return [ true | false ] If the default scope can be applied.
       def default_scopable?
         default_scoping? && !Threaded.without_default_scope?(self)
       end
@@ -114,8 +104,6 @@ module Mongoid
       #   Model.queryable
       #
       # @return [ Criteria ] The queryable.
-      #
-      # @since 3.0.0
       def queryable
         crit = Threaded.current_scope(self) || Criteria.new(self)
         crit.embedded = true if (crit.klass.embedded? && !crit.klass.cyclic?)
@@ -141,8 +129,6 @@ module Mongoid
       #
       # @raise [ Errors::InvalidScope ] If the scope is not a proc.
       # @raise [ Errors::ScopeOverwrite ] If the scope name already exists.
-      #
-      # @since 1.0.0
       def scope(name, value, &block)
         normalized = name.to_sym
         check_scope_validity(value)
@@ -169,32 +155,31 @@ module Mongoid
       # @option options [ Array ] :sort Optional sorting options.
       #
       # @return [ Criteria ] A scoped criteria.
-      #
-      # @since 3.0.0
       def scoped(options = nil)
         queryable.scoped(options)
       end
 
-      # Get the criteria without the default scoping applied.
+      # Get the criteria without any scoping applied.
       #
       # @example Get the unscoped criteria.
       #   Band.unscoped
       #
-      # @example Yield to block with no default scoping.
+      # @example Yield to block with no scoping.
       #   Band.unscoped do
       #     Band.where(name: "Depeche Mode")
       #   end
       #
-      # @note This will force the default scope to be removed.
+      # @note This will force the default scope, as well as any scope applied
+      #   using ``.with_scope``, to be removed.
       #
-      # @return [ Criteria, Object ] The unscoped criteria or result of the
+      # @return [ Criteria | Object ] The unscoped criteria or result of the
       #   block.
-      #
-      # @since 3.0.0
       def unscoped
         if block_given?
           without_default_scope do
-            yield(self)
+            with_scope(nil) do
+              yield(self)
+            end
           end
         else
           queryable.unscoped
@@ -207,8 +192,6 @@ module Mongoid
       #   Model.with_default_scope
       #
       # @return [ Criteria ] The criteria.
-      #
-      # @since 3.0.0
       def with_default_scope
         queryable.with_default_scope
       end
@@ -223,14 +206,13 @@ module Mongoid
       # @param [ Criteria ] criteria The criteria to apply.
       #
       # @return [ Criteria ] The yielded criteria.
-      #
-      # @since 1.0.0
       def with_scope(criteria)
+        previous = Threaded.current_scope(self)
         Threaded.set_current_scope(criteria, self)
         begin
           yield criteria
         ensure
-          Threaded.set_current_scope(nil, self)
+          Threaded.set_current_scope(previous, self)
         end
       end
 
@@ -242,8 +224,6 @@ module Mongoid
       #   end
       #
       # @return [ Object ] The result of the block.
-      #
-      # @since 3.0.0
       def without_default_scope
         Threaded.begin_without_default_scope(self)
         yield
@@ -258,25 +238,23 @@ module Mongoid
       # @api private
       #
       # @example Warn or raise error if name exists.
-      #   Model.valid_scope_name?("test")
+      #   Model.check_scope_name("test")
       #
-      # @param [ String, Symbol ] name The name of the scope.
+      # @param [ String | Symbol ] name The name of the scope.
       #
       # @raise [ Errors::ScopeOverwrite ] If the name exists and configured to
       #   raise the error.
-      #
-      # @since 2.1.0
       def check_scope_name(name)
         if _declared_scopes[name] || respond_to?(name, true)
           if Mongoid.scope_overwrite_exception
             raise Errors::ScopeOverwrite.new(self.name, name)
           else
-            if Mongoid.logger
-              Mongoid.logger.warn(
-                "Creating scope :#{name}. " +
-                "Overwriting existing method #{self.name}.#{name}."
-              )
-            end
+            Mongoid.logger.warn(
+              "Creating scope :#{name} which conflicts with #{self.name}.#{name}. " +
+              "Calls to `Mongoid::Criteria##{name}` will delegate to " +
+              "`Mongoid::Criteria##{name}` for criteria with klass #{self.name} " +
+              "and will ignore the declared scope."
+            )
           end
         end
       end
@@ -292,8 +270,6 @@ module Mongoid
       # @param [ Object ] value The intended scope.
       #
       # @raise [ Errors::InvalidScope ] If the scope is not a valid object.
-      #
-      # @since 3.0.0
       def check_scope_validity(value)
         unless value.respond_to?(:call)
           raise Errors::InvalidScope.new(self, value)
@@ -311,13 +287,11 @@ module Mongoid
       # @param [ Symbol ] name The method/scope name.
       #
       # @return [ Method ] The defined method.
-      #
-      # @since 3.0.0
       def define_scope_method(name)
         singleton_class.class_eval do
-          define_method(name) do |*args|
+          define_method(name) do |*args, **kwargs|
             scoping = _declared_scopes[name]
-            scope = instance_exec(*args, &scoping[:scope])
+            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)
@@ -335,9 +309,7 @@ module Mongoid
       # @example Process the default scope.
       #   Model.process_default_scope(value)
       #
-      # @param [ Criteria, Proc ] value The default scope value.
-      #
-      # @since 3.0.5
+      # @param [ Criteria | Proc ] value The default scope value.
       def process_default_scope(value)
         if existing = default_scoping
           ->{ existing.call.merge(value.to_proc.call) }

data/lib/mongoid/search_indexable.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Mongoid
+  # Encapsulates behavior around managing search indexes. This feature
+  # is only supported when connected to an Atlas cluster.
+  module SearchIndexable
+    extend ActiveSupport::Concern
+
+    # Represents the status of the indexes returned by a search_indexes
+    # call.
+    #
+    # @api private
+    class Status
+      # @return [ Array<Hash> ] the raw index documents
+      attr_reader :indexes
+
+      # Create a new Status object.
+      #
+      # @param [ Array<Hash> ] indexes the raw index documents
+      def initialize(indexes)
+        @indexes = indexes
+      end
+
+      # Returns the subset of indexes that have status == 'READY'
+      #
+      # @return [ Array<Hash> ] index documents for "ready" indices
+      def ready
+        indexes.select { |i| i['status'] == 'READY' }
+      end
+
+      # Returns the subset of indexes that have status == 'PENDING'
+      #
+      # @return [ Array<Hash> ] index documents for "pending" indices
+      def pending
+        indexes.select { |i| i['status'] == 'PENDING' }
+      end
+
+      # Returns the subset of indexes that are marked 'queryable'
+      #
+      # @return [ Array<Hash> ] index documents for 'queryable' indices
+      def queryable
+        indexes.select { |i| i['queryable'] }
+      end
+
+      # Returns true if all the given indexes are 'ready' and 'queryable'.
+      #
+      # @return [ true | false ] ready status of all indexes
+      def ready?
+        indexes.all? { |i| i['status'] == 'READY' && i['queryable'] }
+      end
+    end
+
+    included do
+      cattr_accessor :search_index_specs
+      self.search_index_specs = []
+    end
+
+    # Implementations for the feature's class-level methods.
+    module ClassMethods
+      # Request the creation of all registered search indices. Note
+      # that the search indexes are created asynchronously, and may take
+      # several minutes to be fully available.
+      #
+      # @return [ Array<String> ] The names of the search indexes.
+      def create_search_indexes
+        return if search_index_specs.empty?
+
+        collection.search_indexes.create_many(search_index_specs)
+      end
+
+      # Waits for the named search indexes to be created.
+      #
+      # @param [ Array<String> ] names the list of index names to wait for
+      # @param [ Integer ] interval the number of seconds to wait before
+      #   polling again (only used when a progress callback is given).
+      #
+      # @yield [ SearchIndexable::Status ] the status object
+      def wait_for_search_indexes(names, interval: 5)
+        loop do
+          status = Status.new(get_indexes(names))
+          yield status if block_given?
+          break if status.ready?
+
+          sleep interval
+        end
+      end
+
+      # A convenience method for querying the search indexes available on the
+      # current model's collection.
+      #
+      # @param [ Hash ] options the options to pass through to the search
+      #   index query.
+      #
+      # @option options [ String ] :id The id of the specific index to query (optional)
+      # @option options [ String ] :name The name of the specific index to query (optional)
+      # @option options [ Hash ] :aggregate The options hash to pass to the
+      #    aggregate command (optional)
+      def search_indexes(options = {})
+        collection.search_indexes(options)
+      end
+
+      # Removes the search index specified by the given name or id. Either
+      # name OR id must be given, but not both.
+      #
+      # @param [ String | nil ] name the name of the index to remove
+      # @param [ String | nil ] id the id of the index to remove
+      def remove_search_index(name: nil, id: nil)
+        logger.info(
+          "MONGOID: Removing search index '#{name || id}' " \
+          "on collection '#{collection.name}'."
+        )
+
+        collection.search_indexes.drop_one(name: name, id: id)
+      end
+
+      # Request the removal of all registered search indexes. Note
+      # that the search indexes are removed asynchronously, and may take
+      # several minutes to be fully deleted.
+      #
+      # @note It would be nice if this could remove ONLY the search indexes
+      # that have been declared on the model, but because the model may not
+      # name the index, we can't guarantee that we'll know the name or id of
+      # the corresponding indexes. It is not unreasonable to assume, though,
+      # that the intention is for the model to declare, one-to-one, all
+      # desired search indexes, so removing all search indexes ought to suffice.
+      # If a specific index or set of indexes needs to be removed instead,
+      # consider using search_indexes.each with remove_search_index.
+      def remove_search_indexes
+        search_indexes.each do |spec|
+          remove_search_index id: spec['id']
+        end
+      end
+
+      # Adds an index definition for the provided single or compound keys.
+      #
+      # @example Create a basic index.
+      #   class Person
+      #     include Mongoid::Document
+      #     field :name, type: String
+      #     search_index({ ... })
+      #     search_index :name_of_index, { ... }
+      #   end
+      #
+      # @param [ Symbol | String | Hash ] name_or_defn Either the name of the index to
+      #    define, or the index definition.
+      # @param [ Hash ] defn The search index definition.
+      def search_index(name_or_defn, defn = nil)
+        name = name_or_defn
+        name, defn = nil, name if name.is_a?(Hash)
+
+        spec = { definition: defn }.tap { |s| s[:name] = name.to_s if name }
+        search_index_specs.push(spec)
+      end
+
+      private
+
+      # Retrieves the index records for the indexes with the given names.
+      #
+      # @param [ Array<String> ] names the index names to query
+      #
+      # @return [ Array<Hash> ] the raw index documents
+      def get_indexes(names)
+        collection.search_indexes.select { |i| names.include?(i['name']) }
+      end
+    end
+  end
+end