mongoid 7.1.0 → 7.1.6

data/lib/mongoid/criteria/queryable/storable.rb

@@ -17,67 +17,49 @@ module Mongoid
       # @api private
       module Storable
 
-        # Adds an operator expression to the selector.
-        #
-        # This method takes the operator and the operator value expression
-        # separately for callers' convenience. It can be considered to
-        # handle storing the hash `{operator => op_expr}`.
-        #
-        # If the selector already has the specified operator in it (on the
-        # top level), the new condition given in op_expr is added to the
-        # existing conditions for the specified operator. This is
-        # straightforward for $and; for other logical operators, the behavior
-        # of this method is to add the new conditions to the existing operator.
-        # For example, if the selector is currently:
-        #
-        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}]}
-        #
-        # ... and operator is '$or' and op_expr is `{'test' => 123'}`,
-        # the resulting selector will be:
-        #
-        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}
+        # Adds a field expression to the query.
         #
-        # This does not implement an OR between the existing selector and the
-        # new operator expression - handling this is the job of upstream
-        # methods. This method simply stores op_expr into the selector on the
-        # assumption that the existing selector is the correct left hand side
-        # of the operation already.
+        # +field+ must be a field name, and it must be a string. The upstream
+        # code must have converted other field/key types to the simple string
+        # form by the time this method is invoked.
         #
-        # For non-logical query-level operators like $where and $text, if
-        # there already is a top-level operator with the same name, the
-        # op_expr is added to the selector via a top-level $and operator,
-        # thus producing a selector having both operator values.
+        # +value+ can be of any type, it is written into the selector unchanged.
         #
-        # This method does not simplify values (i.e. if the selector is
-        # currently empty and operator is $and, op_expr is written to the
-        # selector with $and even if the $and can in principle be elided).
+        # This method performs no processing on the provided field value.
         #
-        # This method mutates the receiver.
+        # Mutates the receiver.
         #
-        # @param [ String ] operator The operator to add.
-        # @param [ Hash ] op_expr Operator value to add.
+        # @param [ String ] field The field name.
+        # @param [ Object ] value The field value.
         #
         # @return [ Storable ] self.
-        def add_operator_expression(operator, op_expr)
-          unless operator.is_a?(String)
-            raise ArgumentError, "Operator must be a string: #{operator}"
-          end
-
-          unless operator[0] == ?$
-            raise ArgumentError, "Operator must begin with $: #{operator}"
+        def add_field_expression(field, value)
+          unless field.is_a?(String)
+            raise ArgumentError, "Field must be a string: #{field}"
           end
 
-          if %w($and $nor $or).include?(operator)
-            return add_logical_operator_expression(operator, op_expr)
+          if field[0] == ?$
+            raise ArgumentError, "Field cannot be an operator (i.e. begin with $): #{field}"
           end
 
-          # For other operators, if the operator already exists in the
-          # query, add the new condition with $and, otherwise add the
-          # new condition to the top level.
-          if selector[operator]
-            add_logical_operator_expression('$and', [{operator => op_expr}])
+          if selector[field]
+            # We already have a restriction by the field we are trying
+            # to restrict, combine the restrictions.
+            if value.is_a?(Hash) && selector[field].is_a?(Hash) &&
+              value.keys.all? { |key|
+                key_s = key.to_s
+                key_s[0] == ?$ && !selector[field].key?(key_s)
+              }
+            then
+              # Multiple operators can be combined on the same field by
+              # adding them to the existing hash.
+              new_value = selector[field].merge(value)
+              selector.store(field, new_value)
+            else
+              add_operator_expression('$and', [{field => value}])
+            end
           else
-            selector.store(operator, op_expr)
+            selector.store(field, value)
           end
 
           self
@@ -87,41 +69,40 @@ module Mongoid
         #
         # This method only handles logical operators ($and, $nor and $or).
         # It raises ArgumentError if called with another operator. Note that
-        # in MongoDB, $not is a field-level operator and not a query-level one
-        # $not is not handled by this method as a result.
+        # in MQL, $not is a field-level operator and not a query-level one,
+        # and therefore $not is not handled by this method.
         #
         # This method takes the operator and the operator value expression
         # separately for callers' convenience. It can be considered to
         # handle storing the hash `{operator => op_expr}`.
         #
-        # If the selector already has the specified operator in it (on the
-        # top level), the new condition given in op_expr is added to the
-        # existing conditions for the specified operator. This is
-        # straightforward for $and; for other logical operators, the behavior
-        # of this method is to add the new conditions to the existing operator.
+        # If the selector consists of a single condition which is the specified
+        # operator (on the top level), the new condition given in op_expr is
+        # added to the existing conditions for the specified operator.
         # For example, if the selector is currently:
         #
-        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}]}
+        #     {'$or' => [{'hello' => 'world'}]}
         #
-        # ... and operator is '$or' and op_expr is `{'test' => 123'}`,
+        # ... and operator is '$or' and op_expr is `[{'test' => 123'}]`,
         # the resulting selector will be:
         #
-        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}
+        #     {'$or' => [{'hello' => 'world'}, {'test' => 123}]}
         #
-        # This does not implement an OR between the existing selector and the
-        # new operator expression - handling this is the job of upstream
-        # methods. This method simply stores op_expr into the selector on the
-        # assumption that the existing selector is the correct left hand side
-        # of the operation already.
+        # This method always adds the new conditions as additional requirements;
+        # in other words, it does not implement the ActiveRecord or/nor behavior
+        # where the receiver becomes one of the operands. It is expected that
+        # code upstream of this method implements such behavior.
         #
         # This method does not simplify values (i.e. if the selector is
         # currently empty and operator is $and, op_expr is written to the
         # selector with $and even if the $and can in principle be elided).
+        # Such simplification is also expected to have already been performed
+        # by the upstream code.
         #
         # This method mutates the receiver.
         #
         # @param [ String ] operator The operator to add.
-        # @param [ Hash ] op_expr Operator value to add.
+        # @param [ Array<Hash> ] op_expr Operator value to add.
         #
         # @return [ Storable ] self.
         def add_logical_operator_expression(operator, op_expr)
@@ -145,56 +126,80 @@ module Mongoid
             # with whatever other conditions exist.
             selector.store(operator, op_expr)
           else
-            # Other operators need to operate explicitly on the previous
-            # conditions and the new condition.
-            new_value = [selector.to_hash.dup] + op_expr
-            selector.replace(operator => new_value)
+            # Other operators need to be added separately
+            if selector[operator]
+              add_logical_operator_expression('$and', [operator => op_expr])
+            else
+              selector.store(operator, op_expr)
+            end
           end
 
           self
         end
 
-        # Adds a field expression to the query.
+        # Adds an operator expression to the selector.
         #
-        # field must be a field name, and it must be a string. The upstream
-        # code must have converted other field/key types to the simple string
-        # form by the time this method is invoked.
+        # This method takes the operator and the operator value expression
+        # separately for callers' convenience. It can be considered to
+        # handle storing the hash `{operator => op_expr}`.
         #
-        # This method performs no processing on the provided field value.
+        # The operator value can be of any type.
         #
-        # Mutates the receiver.
+        # If the selector already has the specified operator in it (on the
+        # top level), the new condition given in op_expr is added to the
+        # existing conditions for the specified operator. This is
+        # straightforward for $and; for other logical operators, the behavior
+        # of this method is to add the new conditions to the existing operator.
+        # For example, if the selector is currently:
         #
-        # @param [ String ] field The field name.
-        # @param [ Object ] value The field value.
+        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}]}
+        #
+        # ... and operator is '$or' and op_expr is `{'test' => 123'}`,
+        # the resulting selector will be:
+        #
+        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}
+        #
+        # This does not implement an OR between the existing selector and the
+        # new operator expression - handling this is the job of upstream
+        # methods. This method simply stores op_expr into the selector on the
+        # assumption that the existing selector is the correct left hand side
+        # of the operation already.
+        #
+        # For non-logical query-level operators like $where and $text, if
+        # there already is a top-level operator with the same name, the
+        # op_expr is added to the selector via a top-level $and operator,
+        # thus producing a selector having both operator values.
+        #
+        # This method does not simplify values (i.e. if the selector is
+        # currently empty and operator is $and, op_expr is written to the
+        # selector with $and even if the $and can in principle be elided).
+        #
+        # This method mutates the receiver.
+        #
+        # @param [ String ] operator The operator to add.
+        # @param [ Object ] op_expr Operator value to add.
         #
         # @return [ Storable ] self.
-        def add_field_expression(field, value)
-          unless field.is_a?(String)
-            raise ArgumentError, "Field must be a string: #{field}"
+        def add_operator_expression(operator, op_expr)
+          unless operator.is_a?(String)
+            raise ArgumentError, "Operator must be a string: #{operator}"
           end
 
-          if field[0] == ?$
-            raise ArgumentError, "Field cannot be an operator (i.e. begin with $): #{field}"
+          unless operator[0] == ?$
+            raise ArgumentError, "Operator must begin with $: #{operator}"
           end
 
-          if selector[field]
-            # We already have a restriction by the field we are trying
-            # to restrict, combine the restrictions.
-            if value.is_a?(Hash) && selector[field].is_a?(Hash) &&
-              value.keys.all? { |key|
-                key_s = key.to_s
-                key_s[0] == ?$ && !selector[field].key?(key_s)
-              }
-            then
-              # Multiple operators can be combined on the same field by
-              # adding them to the existing hash.
-              new_value = selector[field].merge(value)
-              selector.store(field, new_value)
-            else
-              add_operator_expression('$and', [{field => value}])
-            end
+          if %w($and $nor $or).include?(operator)
+            return add_logical_operator_expression(operator, op_expr)
+          end
+
+          # For other operators, if the operator already exists in the
+          # query, add the new condition with $and, otherwise add the
+          # new condition to the top level.
+          if selector[operator]
+            add_logical_operator_expression('$and', [{operator => op_expr}])
           else
-            selector.store(field, value)
+            selector.store(operator, op_expr)
           end
 
           self

data/lib/mongoid/errors/eager_load.rb

@@ -6,6 +6,8 @@ module Mongoid
 
     # This error is raised when attempting to eager load a many to many
     # association.
+    #
+    # @deprecated No longer used by Mongoid per MONGOID-4841.
     class EagerLoad < MongoidError
 
       # Create the new eager load error.

data/lib/mongoid/errors/no_client_config.rb

@@ -11,9 +11,9 @@ module Mongoid
       # Create the new error.
       #
       # @example Create the error.
-      #   NoClientConfig.new(:secondary)
+      #   NoClientConfig.new(:analytics)
       #
-      # @param [ String, Symbol ] name The name of the client.
+      # @param [ String | Symbol ] name The name of the client.
       #
       # @since 3.0.0
       def initialize(name)

data/lib/mongoid/errors/no_default_client.rb

@@ -10,7 +10,7 @@ module Mongoid
       # Create the new error with the defined client names.
       #
       # @example Create the new error.
-      #   NoDefaultClient.new([ :secondary ])
+      #   NoDefaultClient.new([ :analytics ])
       #
       # @param [ Array<Symbol> ] keys The defined clients.
       #

data/lib/mongoid/extensions/hash.rb

@@ -48,9 +48,11 @@ module Mongoid
             value.each_pair do |_key, _value|
               value[_key] = (key == "$rename") ? _value.to_s : mongoize_for(key, klass, _key, _value)
             end
-            (consolidated[key] ||= {}).merge!(value)
+            consolidated[key] ||= {}
+            consolidated[key].update(value)
           else
-            (consolidated["$set"] ||= {}).merge!(key => mongoize_for(key, klass, key, value))
+            consolidated["$set"] ||= {}
+            consolidated["$set"].update(key => mongoize_for(key, klass, key, value))
           end
         end
         consolidated

data/lib/mongoid/extensions/regexp.rb

@@ -11,7 +11,7 @@ module Mongoid
         # type.
         #
         # @example Mongoize the object.
-        #   Regexp.mongoize(/^[abc]/)
+        #   Regexp.mongoize(/\A[abc]/)
         #
         # @param [ Regexp, String ] object The object to mongoize.
         #

data/lib/mongoid/fields.rb

@@ -500,7 +500,8 @@ module Mongoid
       def create_translations_getter(name, meth)
         generated_methods.module_eval do
           re_define_method("#{meth}_translations") do
-            (attributes[name] ||= {}).with_indifferent_access
+            attributes[name] ||= {}
+            attributes[name].with_indifferent_access
           end
           alias_method :"#{meth}_t", :"#{meth}_translations"
         end

data/lib/mongoid/fields/validators/macro.rb

@@ -113,7 +113,10 @@ module Mongoid
             end
 
             if option == :type && options[option] == Symbol
-              Mongoid.logger.warn(FIELD_TYPE_IS_SYMBOL)
+              @field_type_is_symbol_warned ||= begin
+                Mongoid.logger.warn(FIELD_TYPE_IS_SYMBOL)
+                true
+              end
             end
           end
         end

data/lib/mongoid/matchable/regexp.rb

@@ -10,8 +10,8 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher._matches?(/^Em/)
-      #   matcher._matches?(BSON::Regex::Raw.new("^Em"))
+      #   matcher._matches?(/\AEm/)
+      #   matcher._matches?(BSON::Regex::Raw.new("\\AEm"))
       #
       # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
       #

data/lib/mongoid/persistable/pushable.rb

@@ -24,7 +24,13 @@ module Mongoid
       def add_to_set(adds)
         prepare_atomic_operation do |ops|
           process_atomic_operations(adds) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || attributes[field]
+            if existing.nil?
+              attributes[field] = []
+              # Read the value out of attributes:
+              # https://jira.mongodb.org/browse/MONGOID-4874
+              existing = attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each do |val|
               existing.push(val) unless existing.include?(val)
@@ -51,7 +57,10 @@ module Mongoid
       def push(pushes)
         prepare_atomic_operation do |ops|
           process_atomic_operations(pushes) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || begin
+              attributes[field] ||= []
+              attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each{ |val| existing.push(val) }
             ops[atomic_attribute_name(field)] = { "$each" => values }

data/lib/mongoid/persistence_context.rb

@@ -122,6 +122,12 @@ module Mongoid
       end
     end
 
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
     # Determine if this persistence context is equal to another.
     #
     # @example Compare two persistence contexts.
@@ -139,12 +145,6 @@ module Mongoid
 
     private
 
-    def client_name
-      @client_name ||= options[:client] ||
-                         Threaded.client_override ||
-                         storage_options && __evaluate__(storage_options[:client])
-    end
-
     def set_options!(opts)
       @options ||= opts.each.reduce({}) do |_options, (key, value)|
                      unless VALID_OPTIONS.include?(key.to_sym)

data/lib/mongoid/query_cache.rb

@@ -163,13 +163,13 @@ module Mongoid
       private
 
       def process(result)
-        @remaining -= result.returned_count if limited?
-        @cursor_id = result.cursor_id
-        @coll_name ||= result.namespace.sub("#{database.name}.", '') if result.namespace
-        documents = result.documents
+        documents = super
+
         if @cursor_id.zero? && !@after_first_batch
-          (@cached_documents ||= []).concat(documents)
+          @cached_documents ||= []
+          @cached_documents.concat(documents)
         end
+
         @after_first_batch = true
         documents
       end
@@ -223,20 +223,40 @@ module Mongoid
       #
       # @since 5.0.0
       def each
-        if system_collection? || !QueryCache.enabled?
+        if system_collection? || !QueryCache.enabled? || (respond_to?(:write?, true) && write?)
           super
         else
-          unless cursor = cached_cursor
-            read_with_retry do
-              server = server_selector.select_server(cluster)
-              cursor = CachedCursor.new(view, send_initial_query(server), server)
-              QueryCache.cache_table[cache_key] = cursor
+          @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)
+              end
             end
           end
-          cursor.each do |doc|
-            yield doc
-          end if block_given?
-          cursor
+
+          if block_given?
+            if limit && limit != -1
+              @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
 
@@ -246,13 +266,30 @@ module Mongoid
         if limit
           key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
           cursor = QueryCache.cache_table[key]
-          if cursor
-            cursor.to_a[0...limit.abs]
-          end
         end
         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
@@ -260,6 +297,12 @@ module Mongoid
       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
+      end
     end
 
     # Adds behavior to the query cache for collections.