mongoid 6.3.0 → 6.4.5

data/lib/mongoid/document.rb

@@ -190,11 +190,11 @@ module Mongoid
     #
     # @since 5.1.0
     def as_json(options = nil)
-      if options && (options[:compact] == true)
-        super(options).reject! { |k,v| v.nil? }
-      else
-        super(options)
+      rv = super
+      if options && options[:compact]
+        rv = rv.compact
       end
+      rv
     end
 
     # Returns an instance of the specified class with the attributes,

data/lib/mongoid/errors.rb

@@ -18,6 +18,7 @@ require "mongoid/errors/invalid_path"
 require "mongoid/errors/invalid_persistence_option"
 require "mongoid/errors/invalid_relation"
 require "mongoid/errors/invalid_scope"
+require "mongoid/errors/invalid_session_use"
 require "mongoid/errors/invalid_set_polymorphic_relation"
 require "mongoid/errors/invalid_storage_options"
 require "mongoid/errors/invalid_storage_parent"

data/lib/mongoid/errors/invalid_session_use.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mongoid
+  module Errors
+
+    # This error is raised when a session is attempted to be used with a model whose client cannot use it, if
+    #   sessions are nested, or if the mongodb deployment doesn't support sessions.
+    #
+    # @since 6.4.0
+    class InvalidSessionUse < MongoidError
+
+      # Create the error.
+      #
+      # @example Create the error.
+      #   InvalidSessionUse.new(:invalid_session_use)
+      #
+      # @param [ :invalid_sesion_use, :invalid_session_nesting ] error_type The type of session misuse.
+      #
+      # @since 6.4.0
+      def initialize(error_type)
+        super(compose_message(error_type.to_s))
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/big_decimal.rb

@@ -53,7 +53,7 @@ module Mongoid
         #
         # @since 3.0.0
         def demongoize(object)
-          object && object.numeric? ? ::BigDecimal.new(object.to_s) : nil
+          object && object.numeric? ? BigDecimal(object.to_s) : nil
         end
 
         # Mongoize an object of any type to how it's stored in the db as a String.

data/lib/mongoid/extensions/regexp.rb

@@ -17,6 +17,7 @@ module Mongoid
         #
         # @since 3.0.0
         def mongoize(object)
+          return nil if object.nil?
           ::Regexp.new(object)
         end
       end

data/lib/mongoid/extensions/string.rb

@@ -82,7 +82,9 @@ module Mongoid
       #
       # @since 3.0.0
       def numeric?
-        true if Float(self) rescue (self =~ /^NaN|\-?Infinity$/)
+        !!Float(self)
+      rescue ArgumentError
+        (self =~ /\A(?:NaN|-?Infinity)\z/) == 0
       end
 
       # Get the string as a getter string.

data/lib/mongoid/indexable.rb

@@ -32,10 +32,10 @@ module Mongoid
           key, options = spec.key, spec.options
           if database = options[:database]
             with(database: database) do |klass|
-              klass.collection.indexes.create_one(key, options.except(:database))
+              klass.collection.indexes(session: _session).create_one(key, options.except(:database))
             end
           else
-            collection.indexes.create_one(key, options)
+            collection.indexes(session: _session).create_one(key, options)
           end
         end and true
       end
@@ -53,9 +53,9 @@ module Mongoid
         indexed_database_names.each do |database|
           with(database: database) do |klass|
             begin
-              klass.collection.indexes.each do |spec|
+              klass.collection.indexes(session: _session).each do |spec|
                 unless spec["name"] == "_id_"
-                  klass.collection.indexes.drop_one(spec["key"])
+                  klass.collection.indexes(session: _session).drop_one(spec["key"])
                   logger.info(
                     "MONGOID: Removed index '#{spec["name"]}' on collection " +
                     "'#{klass.collection.name}' in database '#{database}'."

data/lib/mongoid/matchable.rb

@@ -11,6 +11,7 @@ require "mongoid/matchable/lte"
 require "mongoid/matchable/ne"
 require "mongoid/matchable/nin"
 require "mongoid/matchable/or"
+require "mongoid/matchable/nor"
 require "mongoid/matchable/size"
 require "mongoid/matchable/elem_match"
 require "mongoid/matchable/regexp"
@@ -40,6 +41,7 @@ module Mongoid
       "$ne" => Ne,
       "$nin" => Nin,
       "$or" => Or,
+      "$nor" => Nor,
       "$size" => Size
     }.with_indifferent_access.freeze
 
@@ -124,6 +126,7 @@ module Mongoid
           case key.to_s
             when "$or" then Or.new(value, document)
             when "$and" then And.new(value, document)
+            when "$nor" then Nor.new(value, document)
             else Default.new(extract_attribute(document, key))
           end
         end

data/lib/mongoid/matchable/nor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Defines behavior for handling $nor expressions in embedded documents.
+    class Nor < Default
+
+      # Does the supplied query match the attribute?
+      #
+      # Note: an empty array as an argument to $nor is prohibited by
+      # MongoDB server. Mongoid does allow this and returns false in this case.
+      #
+      # @example Does this match?
+      #   matcher._matches?("$nor" => [ { field => value } ])
+      #
+      # @param [ Array ] conditions The or expression.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      #
+      # @since 6.4.2/7.0.2/7.1.0
+      def _matches?(conditions)
+        if conditions.length == 0
+          # MongoDB does not allow $nor array to be empty, but
+          # Mongoid accepts an empty array for $or which MongoDB also
+          # prohibits
+          return false
+        end
+        conditions.none? do |condition|
+          condition.all? do |key, value|
+            document._matches?(key => value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable.rb

@@ -204,7 +204,7 @@ module Mongoid
     def persist_atomic_operations(operations)
       if persisted? && operations
         selector = atomic_selector
-        _root.collection.find(selector).update_one(positionally(selector, operations))
+        _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
       end
     end
   end

data/lib/mongoid/persistable/creatable.rb

@@ -61,7 +61,9 @@ module Mongoid
           _parent.insert
         else
           selector = _parent.atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, atomic_inserts))
+          _root.collection.find(selector).update_one(
+              positionally(selector, atomic_inserts),
+              session: _session)
         end
       end
 
@@ -76,7 +78,7 @@ module Mongoid
       #
       # @since 4.0.0
       def insert_as_root
-        collection.insert_one(as_attributes)
+        collection.insert_one(as_attributes, session: _session)
       end
 
       # Post process an insert, which sets the new record attribute to false

data/lib/mongoid/persistable/deletable.rb

@@ -62,7 +62,9 @@ module Mongoid
         _parent.remove_child(self) if notifying_parent?(options)
         if _parent.persisted?
           selector = _parent.atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, atomic_deletes))
+          _root.collection.find(selector).update_one(
+              positionally(selector, atomic_deletes),
+              session: _session)
         end
         true
       end
@@ -78,7 +80,7 @@ module Mongoid
       #
       # @since 4.0.0
       def delete_as_root
-        collection.find(atomic_selector).delete_one
+        collection.find(atomic_selector).delete_one(session: _session)
         true
       end
 

data/lib/mongoid/persistable/destroyable.rb

@@ -48,11 +48,7 @@ module Mongoid
         #
         # @since 1.0.0
         def destroy_all(conditions = nil)
-          selector = conditions || {}
-          documents = where(selector)
-          destroyed = documents.count
-          documents.each { |doc| doc.destroy }
-          destroyed
+          where(conditions || {}).destroy
         end
       end
     end

data/lib/mongoid/persistable/settable.rb

@@ -25,15 +25,15 @@ module Mongoid
 
             field_and_value_hash = hasherizer(field.split('.'), value)
             field = field_and_value_hash.keys.first.to_s
+            value = field_and_value_hash[field]
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field)
+            if fields[field] && fields[field].type == Hash && attributes.key?(field) && Hash === value && !value.empty?
               merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = (attributes[field] || {}).merge(field_and_value_hash[field], &merger)
-              process_attribute(field.to_s, value)
-            else
-              process_attribute(field.to_s, field_and_value_hash[field])
+              value = (attributes[field] || {}).merge(value, &merger)
             end
 
+            process_attribute(field.to_s, value)
+
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
             end

data/lib/mongoid/persistable/updatable.rb

@@ -134,9 +134,9 @@ module Mongoid
           unless updates.empty?
             coll = collection(_root)
             selector = atomic_selector
-            coll.find(selector).update_one(positionally(selector, updates))
+            coll.find(selector).update_one(positionally(selector, updates), session: _session)
             conflicts.each_pair do |key, value|
-              coll.find(selector).update_one(positionally(selector, { key => value }))
+              coll.find(selector).update_one(positionally(selector, { key => value }), session: _session)
             end
           end
         end

data/lib/mongoid/persistable/upsertable.rb

@@ -21,7 +21,8 @@ module Mongoid
       # @since 3.0.0
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).update_one(as_attributes, upsert: true)
+          collection.find(atomic_selector).update_one(
+              as_attributes, upsert: true, session: _session)
         end
       end
 

data/lib/mongoid/persistence_context.rb

@@ -107,6 +107,10 @@ module Mongoid
     #
     # @since 6.0.0
     def client
+      client_options = send(:client_options)
+      if client_options[:read].is_a?(Symbol)
+        client_options = client_options.merge(read: {mode: client_options[:read]})
+      end
       @client ||= (client = Clients.with_name(client_name)
                     client = client.use(database_name) if database_name_option
                     client.with(client_options))

data/lib/mongoid/railtie.rb

@@ -102,6 +102,23 @@ module Rails
         puts "There is a configuration error with the current mongoid.yml."
         puts e.message
       end
+
+      # Include Controller extension that measures Mongoid runtime
+      # during request processing. The value then appears in Rails'
+      # instrumentation event `process_action.action_controller`.
+      #
+      # The measurement is made via internal Mongo monitoring subscription
+      initializer "mongoid.runtime-metric" do
+        require "mongoid/railties/controller_runtime"
+
+        ActiveSupport.on_load :action_controller do
+          include ::Mongoid::Railties::ControllerRuntime::ControllerExtension
+        end
+
+        Mongo::Monitoring::Global.subscribe Mongo::Monitoring::COMMAND,
+            ::Mongoid::Railties::ControllerRuntime::Collector.new
+      end
+
     end
   end
 end

data/lib/mongoid/railties/controller_runtime.rb

@@ -0,0 +1,86 @@
+module Mongoid
+  module Railties
+    module ControllerRuntime
+
+      # This extension mimics the Rails' internal method to
+      # measure ActiveRecord runtime during request processing.
+      # It appends MongoDB runtime value (`mongoid_runtime`) into payload
+      # of instrumentation event `process_action.action_controller`.
+      module ControllerExtension
+        extend ActiveSupport::Concern
+
+        protected
+
+        attr_internal :mongoid_runtime
+
+        # Reset the runtime before each action.
+        def process_action(action, *args)
+          Collector.reset_runtime
+          super
+        end
+
+        # Override to collect the measurements.
+        def cleanup_view_runtime
+          mongo_rt_before_render = Collector.reset_runtime
+          runtime = super
+          mongo_rt_after_render = Collector.reset_runtime
+          self.mongoid_runtime = mongo_rt_before_render + mongo_rt_after_render
+          runtime - mongo_rt_after_render
+        end
+
+        # Add the measurement to the instrumentation event payload.
+        def append_info_to_payload(payload)
+          super
+          payload[:mongoid_runtime] = (mongoid_runtime || 0) + Collector.reset_runtime
+        end
+
+        module ClassMethods
+
+          # Append MongoDB runtime information to ActionController runtime
+          # log message.
+          def log_process_action(payload)
+            messages = super
+            mongoid_runtime = payload[:mongoid_runtime]
+            messages << ("MongoDB: %.1fms" % mongoid_runtime.to_f) if mongoid_runtime
+            messages
+          end
+
+        end
+
+      end
+
+      # The Collector of MongoDB runtime metric, that subscribes to Mongo
+      # driver command monitoring. Stores the value within a thread-local
+      # variable to provide correct accounting when an application issues
+      # MongoDB operations from background threads.
+      class Collector
+
+        VARIABLE_NAME = "Mongoid.controller_runtime".freeze
+
+        def started _; end
+
+        def _completed e
+          Collector.runtime += e.duration
+        end
+        alias :succeeded :_completed
+        alias :failed :_completed
+
+        def self.runtime
+          Thread.current[VARIABLE_NAME] ||= 0
+        end
+
+        def self.runtime= value
+          Thread.current[VARIABLE_NAME] = value
+        end
+
+        def self.reset_runtime
+          to_now = runtime
+          self.runtime = 0
+          to_now
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mongoid/relations/embedded/batchable.rb

@@ -38,7 +38,8 @@ module Mongoid
           pre_process_batch_remove(docs, :delete)
           unless docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$unset" => { path => true })
+              positionally(selector, "$unset" => { path => true }),
+              session: _session
             )
             post_process_batch_remove(docs, :delete)
           end
@@ -58,7 +59,8 @@ module Mongoid
           removals = pre_process_batch_remove(docs, method)
           if !docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$pullAll" => { path => removals })
+              positionally(selector, "$pullAll" => { path => removals }),
+              session: _session
             )
             post_process_batch_remove(docs, method)
           end
@@ -133,7 +135,9 @@ module Mongoid
           inserts = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$set' => { path => inserts }))
+                positionally(selector, '$set' => { path => inserts }),
+                session: _session
+            )
             post_process_batch_insert(docs)
           end
           inserts
@@ -156,7 +160,9 @@ module Mongoid
           pushes = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$push' => { path => { '$each' => pushes } }))
+                positionally(selector, '$push' => { path => { '$each' => pushes } }),
+                session: _session
+            )
             post_process_batch_insert(docs)
           end
           pushes

data/lib/mongoid/relations/embedded/many.rb

@@ -294,6 +294,29 @@ module Mongoid
           end
         end
 
+        # Shift documents off the relation. This can be a single document or
+        # multiples, and will automatically persist the changes.
+        #
+        # @example Shift a single document.
+        #   relation.shift
+        #
+        # @example Shift multiple documents.
+        #   relation.shift(3)
+        #
+        # @param [ Integer ] count The number of documents to shift, or 1 if not
+        #   provided.
+        #
+        # @return [ Document, Array<Document> ] The shifted document(s).
+        def shift(count = nil)
+          if count
+            if target.size > 0 && docs = target[0, count]
+              docs.each { |doc| delete(doc) }
+            end
+          else
+            delete(target[0])
+          end
+        end
+
         # Substitutes the supplied target documents for the existing documents
         # in the relation.
         #