mongoid 7.0.2 → 8.1.1

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

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   class Criteria
     module Queryable
@@ -10,21 +11,15 @@ module Mongoid
         extend Macroable
 
         # Constant for a LineString $geometry.
-        #
-        # @since 2.0.0
         LINE_STRING = "LineString"
 
         # Constant for a Point $geometry.
-        #
-        # @since 2.0.0
         POINT = "Point"
 
         # Constant for a Polygon $geometry.
-        #
-        # @since 2.0.0
         POLYGON = "Polygon"
 
-        # @attribute [rw] negating If the next spression is negated.
+        # @attribute [rw] negating If the next expression is negated.
         # @attribute [rw] selector The query selector.
         attr_accessor :negating, :selector
 
@@ -36,13 +31,35 @@ module Mongoid
         # @example Execute an $all in a where query.
         #   selectable.where(:field.all => [ 1, 2 ])
         #
-        # @param [ Hash ] criterion The key value pairs for $all matching.
+        # @param [ Hash... ] *criteria The key value pair(s) for $all matching.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def all(criterion = nil)
-          send(strategy || :__union__, with_array_values(criterion), "$all")
+        def all(*criteria)
+          if criteria.empty?
+            return clone.tap do |query|
+              query.reset_strategies!
+            end
+          end
+
+          criteria.inject(clone) do |query, condition|
+            if condition.nil?
+              raise Errors::CriteriaArgumentRequired, :all
+            end
+
+            condition = expand_condition_to_array_values(condition)
+
+            if strategy
+              send(strategy, condition, "$all")
+            else
+              condition.inject(query) do |_query, (field, value)|
+                v = {'$all' => value}
+                if negating?
+                  v = {'$not' => v}
+                end
+                _query.add_field_expression(field.to_s, v)
+              end
+            end
+          end.reset_strategies!
         end
         alias :all_in :all
         key :all, :union, "$all"
@@ -52,14 +69,43 @@ module Mongoid
         # @example Add the criterion.
         #   selectable.and({ field: value }, { other: value })
         #
-        # @param [ Array<Hash> ] criterion Multiple key/value pair matches that
-        #   all must match to return results.
-        #
-        # @return [ Selectable ] The cloned selectable.
+        # @param [ [ Hash | Criteria | Array<Hash | Criteria> ]... ] *criteria
+        #   Multiple key/value pair matches or Criteria objects that all must
+        #   match to return results.
         #
-        # @since 1.0.0
-        def and(*criterion)
-          __multi__(criterion, "$and")
+        # @return [ Selectable ] The new selectable.
+        def and(*criteria)
+          _mongoid_flatten_arrays(criteria).inject(self.clone) do |c, new_s|
+            if new_s.is_a?(Selectable)
+              new_s = new_s.selector
+            end
+            normalized = _mongoid_expand_keys(new_s)
+            normalized.each do |k, v|
+              k = k.to_s
+              if c.selector[k]
+                # There is already a condition on k.
+                # If v is an operator, and all existing conditions are
+                # also operators, and v isn't present in existing conditions,
+                # we can add to existing conditions.
+                # Otherwise use $and.
+                if v.is_a?(Hash) &&
+                  v.length == 1 &&
+                  (new_k = v.keys.first).start_with?('$') &&
+                  (existing_kv = c.selector[k]).is_a?(Hash) &&
+                  !existing_kv.key?(new_k) &&
+                  existing_kv.keys.all? { |sub_k| sub_k.start_with?('$') }
+                then
+                  merged_v = c.selector[k].merge(v)
+                  c.selector.store(k, merged_v)
+                else
+                  c = c.send(:__multi__, [k => v], '$and')
+                end
+              else
+                c.selector.store(k, v)
+              end
+            end
+            c
+          end
         end
         alias :all_of :and
 
@@ -74,9 +120,11 @@ module Mongoid
         # @param [ Hash ] criterion Multiple key/range pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def between(criterion = nil)
+        def between(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :between
+          end
+
           selection(criterion) do |selector, field, value|
             selector.store(
               field,
@@ -102,10 +150,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/match pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def elem_match(criterion = nil)
-          __override__(criterion, "$elemMatch")
+        def elem_match(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :elem_match
+          end
+
+          and_or_override(criterion, "$elemMatch")
         end
         key :elem_match, :override, "$elemMatch"
 
@@ -123,45 +173,61 @@ module Mongoid
         # @param [ Hash ] criterion The field/boolean existence checks.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def exists(criterion = nil)
+        def exists(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :exists
+          end
+
           typed_override(criterion, "$exists") do |value|
-            ::Boolean.evolve(value)
+            Mongoid::Boolean.evolve(value)
           end
         end
         key :exists, :override, "$exists" do |value|
-          ::Boolean.evolve(value)
+          Mongoid::Boolean.evolve(value)
         end
 
-        # Add a $geoIntersects or $geoWithin selection. Symbol operators must be used as shown in
-        # the examples to expand the criteria.
+        # Add a $geoIntersects or $geoWithin selection. Symbol operators must
+        # be used as shown in the examples to expand the criteria.
         #
         # @note The only valid geometry shapes for a $geoIntersects are:
         #   :intersects_line, :intersects_point, and :intersects_polygon.
         #
-        # @note The only valid geometry shape for a $geoWithin is :within_polygon
+        # @note The only valid options for a $geoWithin query are the geometry
+        #   shape :within_polygon and the operator :within_box.
+        #
+        # @note The :within_box operator for the $geoWithin query expects the
+        #   lower left (south west) coordinate pair as the first argument and
+        #   the upper right (north east) as the second argument.
+        #   Important: When latitude and longitude are passed, longitude is
+        #   expected as the first element of the coordinate pair.
+        #   Source: https://www.mongodb.com/docs/manual/reference/operator/query/box/
         #
         # @example Add a geo intersect criterion for a line.
-        #   query.geo_spacial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
+        #   query.geo_spatial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
         #
         # @example Add a geo intersect criterion for a point.
-        #   query.geo_spacial(:location.intersects_point => [[ 1, 10 ]])
+        #   query.geo_spatial(:location.intersects_point => [[ 1, 10 ]])
         #
         # @example Add a geo intersect criterion for a polygon.
-        #   query.geo_spacial(:location.intersects_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])
+        #   query.geo_spatial(:location.intersects_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])
         #
         # @example Add a geo within criterion for a polygon.
-        #   query.geo_spacial(:location.within_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])
+        #   query.geo_spatial(:location.within_polygon => [[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]])
+        #
+        # @example Add a geo within criterion for a box.
+        #   query.geo_spatial(:location.within_box => [[ 1, 10 ], [ 2, 10 ])
         #
         # @param [ Hash ] criterion The criterion.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 2.0.0
-        def geo_spacial(criterion = nil)
+        def geo_spatial(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :geo_spatial
+          end
+
           __merge__(criterion)
         end
+
         key :intersects_line, :override, "$geoIntersects", "$geometry" do |value|
           { "type" => LINE_STRING, "coordinates" => value }
         end
@@ -174,6 +240,27 @@ module Mongoid
         key :within_polygon, :override, "$geoWithin", "$geometry" do |value|
           { "type" => POLYGON, "coordinates" => value }
         end
+        key :within_box, :override, "$geoWithin", "$box"
+
+        # Add the $eq criterion to the selector.
+        #
+        # @example Add the $eq criterion.
+        #   selectable.eq(age: 60)
+        #
+        # @example Execute an $eq in a where query.
+        #   selectable.where(:field.eq => 10)
+        #
+        # @param [ Hash ] criterion The field/value pairs to check.
+        #
+        # @return [ Selectable ] The cloned selectable.
+        def eq(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :eq
+          end
+
+          and_or_override(criterion, "$eq")
+        end
+        key :eq, :override, "$eq"
 
         # Add the $gt criterion to the selector.
         #
@@ -186,10 +273,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/value pairs to check.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def gt(criterion = nil)
-          __override__(criterion, "$gt")
+        def gt(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :gt
+          end
+
+          and_or_override(criterion, "$gt")
         end
         key :gt, :override, "$gt"
 
@@ -204,10 +293,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/value pairs to check.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def gte(criterion = nil)
-          __override__(criterion, "$gte")
+        def gte(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :gte
+          end
+
+          and_or_override(criterion, "$gte")
         end
         key :gte, :override, "$gte"
 
@@ -222,13 +313,27 @@ module Mongoid
         # @example Execute an $in in a where query.
         #   selectable.where(:field.in => [ 1, 2, 3 ])
         #
-        # @param [ Hash ] criterion The field/value criterion pairs.
+        # @param [ Hash ] condition The field/value criterion pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def in(criterion = nil)
-          send(strategy || :__intersect__, with_array_values(criterion), "$in")
+        def in(condition)
+          if condition.nil?
+            raise Errors::CriteriaArgumentRequired, :in
+          end
+
+          condition = expand_condition_to_array_values(condition)
+
+          if strategy
+            send(strategy, condition, "$in")
+          else
+            condition.inject(clone) do |query, (field, value)|
+              v = {'$in' => value}
+              if negating?
+                v = {'$not' => v}
+              end
+              query.add_field_expression(field.to_s, v)
+            end.reset_strategies!
+          end
         end
         alias :any_in :in
         key :in, :intersect, "$in"
@@ -244,10 +349,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/value pairs to check.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def lt(criterion = nil)
-          __override__(criterion, "$lt")
+        def lt(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :lt
+          end
+
+          and_or_override(criterion, "$lt")
         end
         key :lt, :override, "$lt"
 
@@ -262,10 +369,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/value pairs to check.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def lte(criterion = nil)
-          __override__(criterion, "$lte")
+        def lte(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :lte
+          end
+
+          and_or_override(criterion, "$lte")
         end
         key :lte, :override, "$lte"
 
@@ -277,9 +386,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/distance pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def max_distance(criterion = nil)
+        def max_distance(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :max_distance
+          end
+
+          # $maxDistance must be given together with $near
           __add__(criterion, "$maxDistance")
         end
 
@@ -294,10 +406,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/mod selections.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def mod(criterion = nil)
-          __override__(criterion, "$mod")
+        def mod(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :mod
+          end
+
+          and_or_override(criterion, "$mod")
         end
         key :mod, :override, "$mod"
 
@@ -312,10 +426,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/ne selections.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def ne(criterion = nil)
-          __override__(criterion, "$ne")
+        def ne(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :ne
+          end
+
+          and_or_override(criterion, "$ne")
         end
         alias :excludes :ne
         key :ne, :override, "$ne"
@@ -331,10 +447,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/location pair.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def near(criterion = nil)
-          __override__(criterion, "$near")
+        def near(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :near
+          end
+
+          and_or_override(criterion, "$near")
         end
         key :near, :override, "$near"
 
@@ -349,10 +467,12 @@ module Mongoid
         # @param [ Hash ] criterion The field/location pair.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def near_sphere(criterion = nil)
-          __override__(criterion, "$nearSphere")
+        def near_sphere(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :near_sphere
+          end
+
+          and_or_override(criterion, "$nearSphere")
         end
         key :near_sphere, :override, "$nearSphere"
 
@@ -367,13 +487,27 @@ module Mongoid
         # @example Execute an $nin in a where query.
         #   selectable.where(:field.nin => [ 1, 2, 3 ])
         #
-        # @param [ Hash ] criterion The field/value criterion pairs.
+        # @param [ Hash ] condition The field/value criterion pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def nin(criterion = nil)
-          send(strategy || :__intersect__, with_array_values(criterion), "$nin")
+        def nin(condition)
+          if condition.nil?
+            raise Errors::CriteriaArgumentRequired, :nin
+          end
+
+          condition = expand_condition_to_array_values(condition)
+
+          if strategy
+            send(strategy, condition, "$nin")
+          else
+            condition.inject(clone) do |query, (field, value)|
+              v = {'$nin' => value}
+              if negating?
+                v = {'$not' => v}
+              end
+              query.add_field_expression(field.to_s, v)
+            end.reset_strategies!
+          end
         end
         alias :not_in :nin
         key :nin, :intersect, "$nin"
@@ -383,13 +517,12 @@ module Mongoid
         # @example Add the $nor selection.
         #   selectable.nor(field: 1, field: 2)
         #
-        # @param [ Array ] criterion An array of hash criterion.
+        # @param [ [ Hash | Criteria | Array<Hash | Criteria> ]... ] *criteria
+        #   Multiple key/value pair matches or Criteria objects.
         #
-        # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def nor(*criterion)
-          __multi__(criterion, "$nor")
+        # @return [ Selectable ] The new selectable.
+        def nor(*criteria)
+          _mongoid_add_top_level_operation('$nor', criteria)
         end
 
         # Is the current selectable negating the next selection?
@@ -397,16 +530,14 @@ module Mongoid
         # @example Is the selectable negating?
         #   selectable.negating?
         #
-        # @return [ true, false ] If the selectable is negating.
-        #
-        # @since 1.0.0
+        # @return [ true | false ] If the selectable is negating.
         def negating?
           !!negating
         end
 
-        # Negate the next selection.
+        # Negate the arguments, or the next selection if no arguments are given.
         #
-        # @example Negate the selection.
+        # @example Negate the next selection.
         #   selectable.not.in(field: [ 1, 2 ])
         #
         # @example Add the $not criterion.
@@ -415,34 +546,159 @@ module Mongoid
         # @example Execute a $not in a where query.
         #   selectable.where(:field.not => /Bob/)
         #
-        # @param [ Hash ] criterion The field/value pairs to negate.
+        # @param [ [ Hash | Criteria ]... ] *criteria The key/value pair
+        #   matches or Criteria objects to negate.
         #
-        # @return [ Selectable ] The negated selectable.
-        #
-        # @since 1.0.0
-        def not(*criterion)
-          if criterion.empty?
-            tap { |query| query.negating = true }
+        # @return [ Selectable ] The new selectable.
+        def not(*criteria)
+          if criteria.empty?
+            dup.tap { |query| query.negating = true }
           else
-            __override__(criterion.first, "$not")
+            criteria.compact.inject(self.clone) do |c, new_s|
+              if new_s.is_a?(Selectable)
+                new_s = new_s.selector
+              end
+              _mongoid_expand_keys(new_s).each do |k, v|
+                k = k.to_s
+                if c.selector[k] || k.start_with?('$')
+                  c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
+                else
+                  if v.is_a?(Hash)
+                    c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
+                  else
+                    if v.is_a?(Regexp)
+                      negated_operator = '$not'
+                    else
+                      negated_operator = '$ne'
+                    end
+                    c = c.send(:__override__, {k => v}, negated_operator)
+                  end
+                end
+              end
+              c
+            end
           end
         end
         key :not, :override, "$not"
 
-        # Adds $or selection to the selectable.
+        # Negate the arguments, constraining the query to only those documents
+        # that do NOT match the arguments.
+        #
+        # @example Exclude a single criterion.
+        #   selectable.none_of(name: /Bob/)
+        #
+        # @example Exclude multiple criteria.
+        #   selectable.none_of(name: /Bob/, country: "USA")
+        #
+        # @example Exclude multiple criteria as an array.
+        #   selectable.none_of([{ name: /Bob/ }, { country: "USA" }])
+        #
+        # @param [ [ Hash | Criteria ]... ] *criteria The key/value pair
+        #   matches or Criteria objects to negate.
+        #
+        # @return [ Selectable ] The new selectable.
+        def none_of(*criteria)
+          criteria = _mongoid_flatten_arrays(criteria)
+          return dup if criteria.empty?
+
+          exprs = criteria.map do |criterion|
+            _mongoid_expand_keys(
+                criterion.is_a?(Selectable) ?
+                  criterion.selector : criterion)
+          end
+
+          self.and('$nor' => exprs)
+        end
+
+        # Creates a disjunction using $or from the existing criteria in the
+        # receiver and the provided arguments.
+        #
+        # This behavior (receiver becoming one of the disjunction operands)
+        # matches ActiveRecord's +or+ behavior.
         #
-        # @example Add the $or selection.
+        # Use +any_of+ to add a disjunction of the arguments as an additional
+        # constraint to the criteria already existing in the receiver.
+        #
+        # Each argument can be a Hash, a Criteria object, an array of
+        # Hash or Criteria objects, or a nested array. Nested arrays will be
+        # flattened and can be of any depth. Passing arrays is deprecated.
+        #
+        # @example Add the $or selection where both fields must have the specified values.
         #   selectable.or(field: 1, field: 2)
         #
-        # @param [ Array ] criterion An array of hash criterion.
+        # @example Add the $or selection where either value match is sufficient.
+        #   selectable.or({field: 1}, {field: 2})
         #
-        # @return [ Selectable ] The cloned selectable.
+        # @example Same as previous example but using the deprecated array wrap.
+        #   selectable.or([{field: 1}, {field: 2}])
+        #
+        # @example Same as previous example, also deprecated.
+        #   selectable.or([{field: 1}], [{field: 2}])
+        #
+        # @param [ [ Hash | Criteria | Array<Hash | Criteria> ]... ] *criteria
+        #   Multiple key/value pair matches or Criteria objects, or arrays
+        #   thereof. Passing arrays is deprecated.
+        #
+        # @return [ Selectable ] The new selectable.
+        def or(*criteria)
+          _mongoid_add_top_level_operation('$or', criteria)
+        end
+
+        # Adds a disjunction of the arguments as an additional constraint
+        # to the criteria already existing in the receiver.
+        #
+        # Use +or+ to make the receiver one of the disjunction operands.
+        #
+        # Each argument can be a Hash, a Criteria object, an array of
+        # Hash or Criteria objects, or a nested array. Nested arrays will be
+        # flattened and can be of any depth. Passing arrays is deprecated.
         #
-        # @since 1.0.0
-        def or(*criterion)
-          __multi__(criterion, "$or")
+        # @example Add the $or selection where both fields must have the specified values.
+        #   selectable.any_of(field: 1, field: 2)
+        #
+        # @example Add the $or selection where either value match is sufficient.
+        #   selectable.any_of({field: 1}, {field: 2})
+        #
+        # @example Same as previous example but using the deprecated array wrap.
+        #   selectable.any_of([{field: 1}, {field: 2}])
+        #
+        # @example Same as previous example, also deprecated.
+        #   selectable.any_of([{field: 1}], [{field: 2}])
+        #
+        # @param [ [ Hash | Criteria | Array<Hash | Criteria> ]... ] *criteria
+        #   Multiple key/value pair matches or Criteria objects, or arrays
+        #   thereof. Passing arrays is deprecated.
+        #
+        # @return [ Selectable ] The new selectable.
+        def any_of(*criteria)
+          criteria = _mongoid_flatten_arrays(criteria)
+          case criteria.length
+          when 0
+            clone
+          when 1
+            # When we have a single criteria, any_of behaves like and.
+            # Note: criteria can be a Query object, which #where method does
+            # not support.
+            self.and(*criteria)
+          else
+            # When we have multiple criteria, combine them all with $or
+            # and add the result to self.
+            exprs = criteria.map do |criterion|
+              if criterion.is_a?(Selectable)
+                _mongoid_expand_keys(criterion.selector)
+              else
+                Hash[criterion.map do |k, v|
+                  if k.is_a?(Symbol)
+                    [k.to_s, v]
+                  else
+                    [k, v]
+                  end
+                end]
+              end
+            end
+            self.and('$or' => exprs)
+          end
         end
-        alias :any_of :or
 
         # Add a $size selection for array fields.
         #
@@ -458,9 +714,11 @@ module Mongoid
         # @param [ Hash ] criterion The field/size pairs criterion.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def with_size(criterion = nil)
+        def with_size(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :with_size
+          end
+
           typed_override(criterion, "$size") do |value|
             ::Integer.evolve(value)
           end
@@ -482,9 +740,11 @@ module Mongoid
         # @param [ Hash ] criterion The field/type pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def with_type(criterion = nil)
+        def with_type(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :with_type
+          end
+
           typed_override(criterion, "$type") do |value|
             ::Integer.evolve(value)
           end
@@ -501,20 +761,35 @@ module Mongoid
         # @example Construct a text search selector with options.
         #   selectable.text_search("testing", :$language => "fr")
         #
-        # @param [ String, Symbol ] terms A string of terms that MongoDB parses
+        # @note Per https://www.mongodb.com/docs/manual/reference/operator/query/text/
+        #   it is not currently possible to supply multiple text search
+        #   conditions in a query. Mongoid will build such a query but the
+        #   server will return an error when trying to execute it.
+        #
+        # @param [ String | Symbol ] terms A string of terms that MongoDB parses
         #   and uses to query the text index.
         # @param [ Hash ] opts Text search options. See MongoDB documentation
         #   for options.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 2.2.0
         def text_search(terms, opts = nil)
+          if terms.nil?
+            raise Errors::CriteriaArgumentRequired, :terms
+          end
+
           clone.tap do |query|
-            if terms
-              criterion = { :$text => { :$search => terms } }
-              criterion[:$text].merge!(opts) if opts
-              query.selector = criterion
+            criterion = {'$text' => { '$search' => terms }}
+            criterion['$text'].merge!(opts) if opts
+            if query.selector['$text']
+              # Per https://www.mongodb.com/docs/manual/reference/operator/query/text/
+              # multiple $text expressions are not currently supported by
+              # MongoDB server, but build the query correctly instead of
+              # overwriting previous text search condition with the currently
+              # given one.
+              Mongoid.logger.warn('Multiple $text expressions per query are not currently supported by the server')
+              query.selector = {'$and' => [query.selector]}.merge(criterion)
+            else
+              query.selector = query.selector.merge(criterion)
             end
           end
         end
@@ -529,23 +804,42 @@ module Mongoid
         # @example Add a javascript selection.
         #   selectable.where("this.name == 'syd'")
         #
-        # @param [ String, Hash ] criterion The javascript or standard selection.
+        # @param [ [ Hash | String ]... ] *criterion The standard selection
+        #   or javascript string.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
-        def where(criterion = nil)
-          # We need to save the criterion in an instance variable so Modifiable methods
-          # know how to create a polymorphic object.
-          @criterion = criterion
-          criterion.is_a?(String) ? js_query(criterion) : expr_query(criterion)
+        def where(*criteria)
+          criteria.inject(clone) do |query, criterion|
+            if criterion.nil?
+              raise Errors::CriteriaArgumentRequired, :where
+            end
+
+            # We need to save the criterion in an instance variable so
+            # Modifiable methods know how to create a polymorphic object.
+            # Note that this method in principle accepts multiple criteria,
+            # but only the first one will be stored in @criterion. This
+            # works out to be fine because first_or_create etc. methods
+            # only ever specify one criterion to #where.
+            @criterion = criterion
+            if criterion.is_a?(String)
+              js_query(criterion)
+            else
+              expr_query(criterion)
+            end
+          end.reset_strategies!
         end
 
         private
 
-        # Create the standard expression query.
+        # Adds the specified expression to the query.
         #
-        # @api private
+        # Criterion must be a hash in one of the following forms:
+        # - {field_name: value}
+        # - {'field_name' => value}
+        # - {key_instance: value}
+        # - {'$operator' => operator_value_expression}
+        #
+        # Field name and operator may be given as either strings or symbols.
         #
         # @example Create the selection.
         #   selectable.expr_query(age: 50)
@@ -553,11 +847,27 @@ module Mongoid
         # @param [ Hash ] criterion The field/value pairs.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
+        # @api private
         def expr_query(criterion)
-          selection(criterion) do |selector, field, value|
-            selector.merge!(field.__expr_part__(value.__expand_complex__, negating?))
+          if criterion.nil?
+            raise ArgumentError, 'Criterion cannot be nil here'
+          end
+          unless Hash === criterion
+            raise Errors::InvalidQuery, "Expression must be a Hash: #{Errors::InvalidQuery.truncate_expr(criterion)}"
+          end
+
+          normalized = _mongoid_expand_keys(criterion)
+          clone.tap do |query|
+            normalized.each do |field, value|
+              field_s = field.to_s
+              if field_s.start_with?('$')
+                # Query expression-level operator, like $and or $where
+                query.add_operator_expression(field_s, value)
+              else
+                query.add_field_expression(field, value)
+              end
+            end
+            query.reset_strategies!
           end
         end
 
@@ -571,11 +881,9 @@ module Mongoid
         #   end
         #
         # @param [ Hash ] criterion The criterion.
-        #
-        # @since 1.0.0
         def typed_override(criterion, operator)
           if criterion
-            criterion.update_values do |value|
+            criterion.transform_values! do |value|
               yield(value)
             end
           end
@@ -592,27 +900,28 @@ module Mongoid
         # @param [ String ] criterion The javascript as a string.
         #
         # @return [ Selectable ] The cloned selectable
-        #
-        # @since 1.0.0
         def js_query(criterion)
           clone.tap do |query|
-            query.selector.merge!("$where" => criterion)
+            if negating?
+              query.add_operator_expression('$and',
+                [{'$nor' => [{'$where' => criterion}]}])
+            else
+              query.add_operator_expression('$where', criterion)
+            end
+            query.reset_strategies!
           end
         end
 
         # Take the provided criterion and store it as a selection in the query
         # selector.
         #
-        # @api private
-        #
         # @example Store the selection.
         #   selectable.selection({ field: "value" })
         #
         # @param [ Hash ] criterion The selection to store.
         #
         # @return [ Selectable ] The cloned selectable.
-        #
-        # @since 1.0.0
+        # @api private
         def selection(criterion = nil)
           clone.tap do |query|
             if criterion
@@ -624,23 +933,19 @@ module Mongoid
           end
         end
 
-        # Convert the criterion values to $in friendly values. This means you,
-        # array.
-        #
-        # @api private
+        # Combine operator expessions onto a Criteria using either
+        # an override or ands depending on the status of the
+        # Mongoid.overwrite_chained_operators feature flag.
         #
-        # @example Convert all the values to arrays.
-        #   selectable.with_array_values({ key: 1...4 })
+        # @param [ Hash ] The criterion to add to the criteria.
+        # @param [ String ] operator The MongoDB operator.
         #
-        # @param [ Hash ] criterion The criterion.
-        #
-        # @return [ Hash ] The $in friendly criterion (array values).
-        #
-        # @since 1.0.0
-        def with_array_values(criterion)
-          return nil unless criterion
-          criterion.each_pair do |key, value|
-            criterion[key] = value.__array__
+        # @return [ Criteria ] The resulting criteria.
+        def and_or_override(criterion, operator)
+          if Mongoid.overwrite_chained_operators
+            __override__(criterion, operator)
+          else
+            and_with_operator(criterion, operator)
           end
         end
 
@@ -652,8 +957,6 @@ module Mongoid
           #   Selectable.forwardables
           #
           # @return [ Array<Symbol> ] The names of the forwardable methods.
-          #
-          # @since 1.0.0
           def forwardables
             public_instance_methods(false) -
               [ :negating, :negating=, :negating?, :selector, :selector= ]