mongoid 7.1.0.rc0 → 7.2.0.rc1

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

@@ -84,16 +84,16 @@ module Mongoid
         # Evolves a multi-list selection, like an $and or $or criterion, and
         # performs the necessary serialization.
         #
-        # @api private
-        #
         # @example Evolve the multi-selection.
         #   selector.evolve_multi([{ field: "value" }])
         #
-        # @param [ Array<Hash> ] value The multi-selection.
+        # @param [ Array<Hash> ] specs The multi-selection.
         #
         # @return [ Array<Hash> ] The serialized values.
         #
         # @since 1.0.0
+        #
+        # @api private
         def evolve_multi(specs)
           unless specs.is_a?(Array)
             raise ArgumentError, "specs is not an array: #{specs.inspect}"

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}`.
+        # 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)
@@ -134,7 +115,7 @@ module Mongoid
           end
 
           unless op_expr.is_a?(Array)
-            raise ArgumentError, "Operator value expression must be an array: #{op_expr}"
+            raise Errors::InvalidQuery, "#{operator} argument must be an array: #{Errors::InvalidQuery.truncate_expr(op_expr)}"
           end
 
           if selector.length == 1 && selector.keys.first == operator
@@ -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/document.rb

@@ -233,8 +233,8 @@ module Mongoid
       became.errors.instance_variable_set(:@messages, errors.instance_variable_get(:@messages))
       became.instance_variable_set(:@new_record, new_record?)
       became.instance_variable_set(:@destroyed, destroyed?)
-      became.changed_attributes["_type"] = self.class.to_s
-      became._type = klass.to_s
+      became.changed_attributes[klass.discriminator_key] = self.class.discriminator_value
+      became[klass.discriminator_key] = klass.discriminator_value
 
       # mark embedded docs as persisted
       embedded_relations.each_pair do |name, meta|
@@ -353,7 +353,19 @@ module Mongoid
       #
       # @since 1.0.0
       def _types
-        @_type ||= (descendants + [ self ]).uniq.map(&:to_s)
+        @_type ||= (descendants + [ self ]).uniq.map(&:discriminator_value)
+      end
+
+      # Clear the @_type cache. This is generally called when changing the discriminator
+      # key/value on a class.
+      #
+      # @example Get the types.
+      #   document._mongoid_clear_types
+      #
+      # @api private
+      def _mongoid_clear_types
+        @_type = nil
+        superclass._mongoid_clear_types if hereditary?
       end
 
       # Set the i18n scope to overwrite ActiveModel.

data/lib/mongoid/errors.rb

@@ -20,6 +20,13 @@ require "mongoid/errors/invalid_index"
 require "mongoid/errors/invalid_options"
 require "mongoid/errors/invalid_path"
 require "mongoid/errors/invalid_persistence_option"
+require "mongoid/errors/invalid_query"
+# Must be after invalid_query.
+require "mongoid/errors/invalid_discriminator_key_target"
+require "mongoid/errors/invalid_elem_match_operator"
+require "mongoid/errors/invalid_estimated_count_criteria"
+require "mongoid/errors/invalid_expression_operator"
+require "mongoid/errors/invalid_field_operator"
 require "mongoid/errors/invalid_relation"
 require "mongoid/errors/invalid_relation_option"
 require "mongoid/errors/invalid_scope"

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/invalid_discriminator_key_target.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Errors
+
+    # Creates the exception raised when trying to set or get the 
+    # discriminator key on a child class.
+    #
+    # @param [ String ] class_name The class name.
+    # @param [ String ] operator The class' superclass.
+    #
+    # @api private
+    class InvalidDiscriminatorKeyTarget < MongoidError
+      def initialize(class_name, superclass)
+        super(
+          compose_message(
+            "invalid_discriminator_key_target",
+            { class_name: class_name, superclass: superclass }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_elem_match_operator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Errors
+
+    # Raised when invalid field-level operator is passed to the $elemMatch
+    # embedded matcher.
+    class InvalidElemMatchOperator < InvalidQuery
+
+      # @api private
+      VALID_OPERATORS = %w(
+        and all eq exists gt gte in lt lte ne nin nor not or regex size
+      ).freeze
+
+      # Creates the exception.
+      #
+      # @param [ String ] operator The operator that was used.
+      #
+      # @api private
+      def initialize(operator)
+        @operator = operator
+        super(compose_message("invalid_elem_match_operator",
+          operator: operator,
+          valid_operators: VALID_OPERATORS.map { |op| "'$#{op}'" }.join(', '),
+        ))
+      end
+
+      # @return [ String ] The operator that was used.
+      attr_reader :operator
+    end
+  end
+end

data/lib/mongoid/errors/invalid_estimated_count_criteria.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Errors
+
+    class InvalidEstimatedCountCriteria < MongoidError
+
+      # Creates the exception raised when trying to call estimated_count
+      # on a filtered criteria.
+      #
+      # @param [ String ] class_name The klass of the criteria used to call
+      #                              estimated count.
+      #
+      # @api private
+      def initialize(class_name)
+        super(
+          compose_message(
+            "invalid_estimated_count_criteria",
+            { class_name: class_name }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_expression_operator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Errors
+
+    # Raised when invalid expression-level operator is passed to an
+    # embedded matcher.
+    class InvalidExpressionOperator < InvalidQuery
+
+      # Creates the exception.
+      #
+      # @param [ String ] operator The operator that was used.
+      #
+      # @api private
+      def initialize(operator)
+        @operator = operator
+        super(compose_message("invalid_expression_operator",
+          operator: operator,
+          valid_operators: "'$and', '$nor', '$or'",
+        ))
+      end
+
+      # @return [ String ] The operator that was used.
+      attr_reader :operator
+    end
+  end
+end