mongoid 7.4.0 → 8.0.1

data/lib/mongoid/findable.rb

@@ -38,12 +38,16 @@ module Mongoid
       :max,
       :min,
       :none,
+      :pick,
       :pluck,
       :read,
       :sum,
+      :take,
+      :take!,
+      :tally,
       :text_search,
       :update,
-      :update_all
+      :update_all,
 
     # Returns a count of records in the database.
     # If you want to specify conditions use where.
@@ -118,6 +122,13 @@ module Mongoid
     # strings will be transparently converted to +BSON::ObjectId+ instances
     # during query construction.
     #
+    # If this method is given a block, it delegates to +Enumerable#find+ and
+    # returns the first document of those found by the current Crieria object
+    # for which the block returns a truthy value. If both a block and ids are
+    # given, the block is ignored and the documents for the given ids are
+    # returned. If a block and a Proc are given, the method delegates to
+    # +Enumerable#find+ and uses the proc as the default.
+    #
     # The +find+ method takes into account the default scope defined on the
     # model class, if any.
     #
@@ -128,8 +139,13 @@ module Mongoid
     #
     # @raise Errors::DocumentNotFound If not all documents are found and
     #   the +raise_not_found_error+ Mongoid configuration option is truthy.
-    def find(*args)
-      with_default_scope.find(*args)
+    def find(*args, &block)
+      empty_or_proc = args.empty? || (args.length == 1 && args.first.is_a?(Proc))
+      if block_given? && empty_or_proc
+        with_default_scope.find(*args, &block)
+      else
+        with_default_scope.find(*args)
+      end
     end
 
     # Find the first +Document+ given the conditions.
@@ -179,9 +195,11 @@ module Mongoid
     # @example Find the first document.
     #   Person.first
     #
+    # @param [ Integer ] limit The number of documents to return.
+    #
     # @return [ Document ] The first matching document.
-    def first
-      with_default_scope.first
+    def first(limit = nil)
+      with_default_scope.first(limit)
     end
     alias :one :first
 
@@ -190,9 +208,11 @@ module Mongoid
     # @example Find the last document.
     #   Person.last
     #
+    # @param [ Integer ] limit The number of documents to return.
+    #
     # @return [ Document ] The last matching document.
-    def last
-      with_default_scope.last
+    def last(limit = nil)
+      with_default_scope.last(limit)
     end
   end
 end

data/lib/mongoid/indexable/specification.rb

@@ -86,7 +86,7 @@ module Mongoid
       # @api private
       #
       # @example Normalize the index options.
-      #   specification.normalize_options(drop_dups: true)
+      #   specification.normalize_options(unique: true)
       #
       # @param [ Hash ] opts The index options.
       #

data/lib/mongoid/indexable/validators/options.rb

@@ -13,7 +13,6 @@ module Mongoid
           :database,
           :default_language,
           :language_override,
-          :drop_dups,
           :name,
           :sparse,
           :unique,
@@ -98,6 +97,10 @@ module Mongoid
             unless VALID_TYPES.include?(value)
               raise Errors::InvalidIndex.new(klass, spec, options)
             end
+
+            if value == "geoHaystack"
+              Mongoid::Warnings.warn_geo_haystack_deprecated
+            end
           end
         end
       end

data/lib/mongoid/interceptable.rb

@@ -27,7 +27,7 @@ module Mongoid
       :before_save,
       :before_update,
       :before_upsert,
-      :before_validation
+      :before_validation,
     ].freeze
 
     included do
@@ -37,6 +37,12 @@ module Mongoid
       define_model_callbacks :build, :find, :initialize, :touch, only: :after
       define_model_callbacks :create, :destroy, :save, :update, :upsert
 
+      # This callback is used internally by Mongoid to save association
+      # targets for referenced associations after the parent model is persisted.
+      #
+      # @api private
+      define_model_callbacks :persist_parent
+
       attr_accessor :before_callback_halted
     end
 
@@ -109,22 +115,76 @@ module Mongoid
     #   end
     #
     # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array ] args Any options.
-    #
-    # @return [ Document ] The document
-    ruby2_keywords def run_callbacks(kind, *args, &block)
-      cascadable_children(kind).each do |child|
-        if child.run_callbacks(child_callback_type(kind, child), *args) == false
-          return false
+    # @param [ true | false ] with_children Flag specifies whether callbacks of embedded document should be run.
+    def run_callbacks(kind, with_children: true, &block)
+      if with_children
+        cascadable_children(kind).each do |child|
+          if child.run_callbacks(child_callback_type(kind, child), with_children: with_children) == false
+            return false
+          end
         end
       end
       if callback_executable?(kind)
-        super(kind, *args, &block)
+        super(kind, &block)
       else
         true
       end
     end
 
+    # Run the callbacks for embedded documents.
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array<Document> ] children Children to exeute callbacks on. If
+    #   nil, callbacks will be executed on all cascadable children of
+    #   the document.
+    #
+    # @api private
+    def _mongoid_run_child_callbacks(kind, children: nil, &block)
+      child, *tail = (children || cascadable_children(kind))
+      if child.nil?
+        return block&.call
+      elsif tail.empty?
+        return child.run_callbacks(child_callback_type(kind, child), &block)
+      else
+        return child.run_callbacks(child_callback_type(kind, child)) do
+          _mongoid_run_child_callbacks(kind, children: tail, &block)
+        end
+      end
+    end
+
+    # This is used to store callbacks to be executed later. A good use case for
+    # this is delaying the after_find and after_initialize callbacks until the
+    # associations are set on the document. This can also be used to delay
+    # applying the defaults on a document.
+    #
+    # @return [ Array<Symbol> ] an array of symbols that represent the pending callbacks.
+    #
+    # @api private
+    def pending_callbacks
+      @pending_callbacks ||= [].to_set
+    end
+
+    # @api private
+    def pending_callbacks=(value)
+      @pending_callbacks = value
+    end
+
+    # Run the pending callbacks. If the callback is :apply_defaults, we will apply
+    # the defaults for this document. Otherwise, the callback is passed to the
+    # run_callbacks function.
+    #
+    # @api private
+    def run_pending_callbacks
+      pending_callbacks.each do |cb|
+        if [:apply_defaults, :apply_post_processed_defaults].include?(cb)
+          send(cb)
+        else
+          self.run_callbacks(cb, with_children: false)
+        end
+      end
+      pending_callbacks.clear
+    end
+
     private
 
     # We need to hook into this for autosave, since we don't want it firing if

data/lib/mongoid/persistable/creatable.rb

@@ -102,13 +102,22 @@ module Mongoid
       def prepare_insert(options = {})
         return self if performing_validations?(options) &&
           invalid?(options[:context] || :create)
-        result = run_callbacks(:save) do
-          run_callbacks(:create) do
-            yield(self)
-            post_process_insert
+        run_callbacks(:save, with_children: false) do
+          run_callbacks(:create, with_children: false) do
+            run_callbacks(:persist_parent, with_children: false) do
+              _mongoid_run_child_callbacks(:save) do
+                _mongoid_run_child_callbacks(:create) do
+                  result = yield(self)
+                  if !result.is_a?(Document) || result.errors.empty?
+                    post_process_insert
+                    post_process_persist(result, options)
+                  end
+                end
+              end
+            end
           end
         end
-        post_process_persist(result, options) and self
+        self
       end
 
       module ClassMethods

data/lib/mongoid/persistable/updatable.rb

@@ -96,13 +96,20 @@ module Mongoid
         return false if performing_validations?(options) &&
           invalid?(options[:context] || :update)
         process_flagged_destroys
-        result = run_callbacks(:save) do
-          run_callbacks(:update) do
-            yield(self)
-            true
+        run_callbacks(:save, with_children: false) do
+          run_callbacks(:update, with_children: false) do
+            run_callbacks(:persist_parent, with_children: false) do
+              _mongoid_run_child_callbacks(:save) do
+                _mongoid_run_child_callbacks(:update) do
+                  result = yield(self)
+                  self.previously_new_record = false
+                  post_process_persist(result, options)
+                  true
+                end
+              end
+            end
           end
         end
-        post_process_persist(result, options) and result
       end
 
       # Update the document in the database.

data/lib/mongoid/persistable/upsertable.rb

@@ -18,7 +18,7 @@ module Mongoid
       # @return [ true ] True.
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).update_one(
+          collection.find(atomic_selector).replace_one(
               as_attributes, upsert: true, session: _session)
         end
       end

data/lib/mongoid/persistence_context.rb

@@ -57,7 +57,9 @@ module Mongoid
     # @return [ Mongo::Collection ] The collection for this persistence
     #   context.
     def collection(parent = nil)
-      parent ? parent.collection.with(client_options) : client[collection_name.to_sym]
+      parent ?
+        parent.collection.with(client_options.except(:database, "database")) :
+        client[collection_name.to_sym]
     end
 
     # Get the collection name for this persistence context.
@@ -122,6 +124,21 @@ module Mongoid
       options == other.options
     end
 
+    # Whether the client of the context can be reused later, and therefore should
+    # not be closed.
+    #
+    # If the persistence context is requested with :client option only, it means
+    # that the context should use a client configured in mongoid.yml.
+    # Such clients should not be closed when the context is cleared since they
+    # will be reused later.
+    #
+    # @return [ true | false ] True if client can be reused, otherwise false.
+    #
+    # @api private
+    def reusable_client?
+      @options.keys == [:client]
+    end
+
     private
 
     def set_options!(opts)
@@ -211,7 +228,7 @@ module Mongoid
       def clear(object, cluster = nil, original_context = nil)
         if context = get(object)
           unless cluster.nil? || context.cluster.equal?(cluster)
-            context.client.close
+            context.client.close unless context.reusable_client?
           end
         end
       ensure

data/lib/mongoid/query_cache.rb

@@ -4,28 +4,8 @@ module Mongoid
 
   # A cache of database queries on a per-request basis.
   module QueryCache
-    # @api private
-    LEGACY_WARNING = <<~DOC
-      You are using the legacy Mongoid query cache which has known issues.
-      Please upgrade the `mongo' gem to at least 2.14.0 to use the improved driver query cache.
-      Refer to: https://docs.mongodb.com/mongoid/current/tutorials/mongoid-queries/#the-improved-driver-query-cache
-    DOC
 
     class << self
-      # Get the cached queries.
-      #
-      # @example Get the cached queries from the current thread.
-      #   QueryCache.cache_table
-      #
-      # @return [ Hash ] The hash of cached queries.
-      # @api private
-      def cache_table
-        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.
       #
@@ -34,11 +14,7 @@ module Mongoid
       #
       # @return [ nil ] Always nil.
       def clear_cache
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.clear
-        else
-          Thread.current["[mongoid]:query_cache"] = nil
-        end
+        Mongo::QueryCache.clear
       end
 
       # Set whether the cache is enabled.
@@ -48,11 +24,7 @@ module Mongoid
       #
       # @param [ true, false ] value The enabled value.
       def enabled=(value)
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.enabled = value
-        else
-          Thread.current["[mongoid]:query_cache:enabled"] = value
-        end
+        Mongo::QueryCache.enabled = value
       end
 
       # Is the query cache enabled on the current thread?
@@ -62,11 +34,7 @@ module Mongoid
       #
       # @return [ true, false ] If the cache is enabled.
       def enabled?
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.enabled?
-        else
-          !!Thread.current["[mongoid]:query_cache:enabled"]
-        end
+        Mongo::QueryCache.enabled?
       end
 
       # Execute the block while using the query cache.
@@ -76,21 +44,7 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def cache(&block)
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.cache(&block)
-        else
-          @legacy_query_cache_warned ||= begin
-            Mongoid.logger.warn(LEGACY_WARNING)
-            true
-          end
-          enabled = QueryCache.enabled?
-          QueryCache.enabled = true
-          begin
-            yield
-          ensure
-            QueryCache.enabled = enabled
-          end
-        end
+        Mongo::QueryCache.cache(&block)
       end
 
       # Execute the block with the query cache disabled.
@@ -100,217 +54,11 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       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
-
-    if defined?(Mongo::QueryCache::Middleware)
-      Middleware = Mongo::QueryCache::Middleware
-    else
-      # The middleware to be added to a rack application in order to activate the
-      # query cache.
-      class Middleware
-
-        # Instantiate the middleware.
-        #
-        # @example Create the new middleware.
-        #   Middleware.new(app)
-        #
-        # @param [ Object ] app The rack application stack.
-        def initialize(app)
-          @app = app
-        end
-
-        # Execute the request, wrapping in a query cache.
-        #
-        # @example Execute the request.
-        #   middleware.call(env)
-        #
-        # @param [ Object ] env The environment.
-        #
-        # @return [ Object ] The result of the call.
-        def call(env)
-          QueryCache.cache do
-            @app.call(env)
-          end
-        ensure
-          QueryCache.clear_cache
-        end
-      end
-    end
-
-    # A Cursor that attempts to load documents from memory first before hitting
-    # the database if the same query has already been executed.
-    # @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
-      # cursor otherwise proceed as normal.
-      #
-      # @example Iterate over the documents.
-      #   cursor.each do |doc|
-      #     # ...
-      #   end
-      def each
-        if @cached_documents
-          @cached_documents.each do |doc|
-            yield doc
-          end
-        else
-          super
-        end
-      end
-
-      # Get a human-readable string representation of +Cursor+.
-      #
-      # @example Inspect the cursor.
-      #   cursor.inspect
-      #
-      # @return [ String ] A string representation of a +Cursor+ instance.
-      def inspect
-        "#<Mongoid::QueryCache::CachedCursor:0x#{object_id} @view=#{@view.inspect}>"
-      end
-
-      private
-
-      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
-    end
-
-    # Included to add behavior for clearing out the query cache on certain
-    # operations.
-    # @deprecated This module is only used with driver versions 2.13 and lower.
-    module Base
-
-      def alias_query_cache_clear(*method_names)
-        method_names.each do |method_name|
-          define_method("#{method_name}_with_clear_cache") do |*args|
-            QueryCache.clear_cache
-            send("#{method_name}_without_clear_cache", *args)
-          end
-
-          alias_method "#{method_name}_without_clear_cache", method_name
-          alias_method method_name, "#{method_name}_with_clear_cache"
-        end
+        Mongo::QueryCache.uncached(&block)
       end
     end
 
-    # Contains enhancements to the Mongo::Collection::View in order to get a
-    # cached cursor or a regular cursor on iteration.
-    # @deprecated This module is only used with driver versions 2.13 and lower.
-    module View
-      extend ActiveSupport::Concern
-
-      included do
-        extend QueryCache::Base
-        alias_query_cache_clear :delete_one,
-                                :delete_many,
-                                :update_one,
-                                :update_many,
-                                :replace_one,
-                                :find_one_and_delete,
-                                :find_one_and_replace,
-                                :find_one_and_update
-      end
-
-      # Override the default enumeration to handle if the cursor can be cached
-      # or not.
-      #
-      # @example Iterate over the view.
-      #   view.each do |doc|
-      #     # ...
-      #   end
-      def each
-        if system_collection? || !QueryCache.enabled? || (respond_to?(:write?, true) && write?)
-          super
-        else
-          @cursor = nil
-          unless @cursor = cached_cursor
-            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
-              @cursor.to_a[0...limit].each do |doc|
-                yield doc
-              end
-            else
-              @cursor.each do |doc|
-                yield doc
-              end
-            end
-          else
-            @cursor.to_enum
-          end
-        end
-      end
-
-      private
-
-      def cached_cursor
-        if limit
-          key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
-          cursor = QueryCache.cache_table[key]
-        end
-        cursor || QueryCache.cache_table[cache_key]
-      end
-
-      def cache_key
-        [ collection.namespace, selector, limit, skip, sort, projection, collation ]
-      end
-
-      def system_collection?
-        collection.name.start_with?('system.')
-      end
-    end
-
-    # Adds behavior to the query cache for collections.
-    # @deprecated This module is only used with driver versions 2.13 and lower.
-    module Collection
-      extend ActiveSupport::Concern
-
-      included do
-        extend QueryCache::Base
-        alias_query_cache_clear :insert_one, :insert_many
-      end
-    end
-
-    # Bypass the query cache when reloading a document.
-    module Document
-      def reload
-        QueryCache.uncached { super }
-      end
-    end
+    Middleware = Mongo::QueryCache::Middleware
   end
 end
 
-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/railties/controller_runtime.rb

@@ -62,7 +62,7 @@ module Mongoid
         def started _; end
 
         def _completed e
-          Collector.runtime += e.duration
+          Collector.runtime += e.duration * 1000
         end
         alias :succeeded :_completed
         alias :failed :_completed

data/lib/mongoid/reloadable.rb

@@ -23,11 +23,15 @@ module Mongoid
 
       reloaded = _reload
       if Mongoid.raise_not_found_error && (reloaded.nil? || reloaded.empty?)
-        raise Errors::DocumentNotFound.new(self.class, _id, _id)
+        shard_keys = atomic_selector.with_indifferent_access.slice(*shard_key_fields, :_id)
+        raise Errors::DocumentNotFound.new(self.class, _id, shard_keys)
       end
       @attributes = reloaded
-      @attributes_before_type_cast = {}
-      changed_attributes.clear
+      @attributes_before_type_cast = @attributes.dup
+      @changed_attributes = {}
+      @previous_changes = {}
+      @previous_attributes = {}
+      @previously_new_record = false
       reset_readonly
       apply_defaults
       reload_relations

data/lib/mongoid/selectable.rb

@@ -15,8 +15,7 @@ module Mongoid
     #
     # @return [ Hash ] The document's selector.
     def atomic_selector
-      @atomic_selector ||=
-        (embedded? ? embedded_atomic_selector : root_atomic_selector_in_db)
+      embedded? ? embedded_atomic_selector : root_atomic_selector_in_db
     end
 
     private