mongoid 7.1.0.rc0 → 7.2.0.rc1

data/lib/mongoid/criteria/modifiable.rb

@@ -74,7 +74,8 @@ module Mongoid
       # @since 5.1.0
       def create_with(attrs = {})
         tap do
-          (@create_attrs ||= {}).merge!(attrs)
+          @create_attrs ||= {}
+          @create_attrs.update(attrs)
         end
       end
 

data/lib/mongoid/criteria/queryable/extensions/numeric.rb

@@ -60,7 +60,7 @@ module Mongoid
             #
             # @since 1.0.0
             def __numeric__(object)
-              object.to_s =~ /(^[-+]?[0-9]+$)|(\.0+$)|(\.$)/ ? object.to_i : Float(object)
+              object.to_s =~ /(\A[-+]?[0-9]+\z)|(\.0+\z)|(\.\z)/ ? object.to_i : Float(object)
             end
 
             # Evolve the object to an integer.

data/lib/mongoid/criteria/queryable/extensions/regexp.rb

@@ -12,7 +12,7 @@ module Mongoid
           # Is the object a regexp?
           #
           # @example Is the object a regex?
-          #   /^[123]/.regexp?
+          #   /\A[123]/.regexp?
           #
           # @return [ true ] Always true.
           #
@@ -24,7 +24,7 @@ module Mongoid
             # Evolve the object into a regex.
             #
             # @example Evolve the object to a regex.
-            #   Regexp.evolve("^[123]")
+            #   Regexp.evolve("\A[123]")
             #
             # @param [ Regexp, String ] object The object to evolve.
             #
@@ -38,7 +38,7 @@ module Mongoid
             end
           end
 
-          module Raw
+          module Raw_
 
             # Is the object a regexp?
             #
@@ -55,7 +55,7 @@ module Mongoid
               # Evolve the object into a raw bson regex.
               #
               # @example Evolve the object to a regex.
-              #   BSON::Regexp::Raw.evolve("^[123]")
+              #   BSON::Regexp::Raw.evolve("\\A[123]")
               #
               # @param [ BSON::Regexp::Raw, String ] object The object to evolve.
               #
@@ -77,5 +77,5 @@ end
 
 ::Regexp.__send__(:include,Mongoid::Criteria::Queryable::Extensions::Regexp)
 ::Regexp.__send__(:extend, Mongoid::Criteria::Queryable::Extensions::Regexp::ClassMethods)
-BSON::Regexp::Raw.__send__(:include,Mongoid::Criteria::Queryable::Extensions::Regexp::Raw)
-BSON::Regexp::Raw.__send__(:extend, Mongoid::Criteria::Queryable::Extensions::Regexp::Raw::ClassMethods)
+BSON::Regexp::Raw.__send__(:include,Mongoid::Criteria::Queryable::Extensions::Regexp::Raw_)
+BSON::Regexp::Raw.__send__(:extend, Mongoid::Criteria::Queryable::Extensions::Regexp::Raw_::ClassMethods)

data/lib/mongoid/criteria/queryable/extensions/time_with_zone.rb

@@ -9,6 +9,18 @@ module Mongoid
         # This module contains additional time with zone behavior.
         module TimeWithZone
 
+          # Evolve the time as a date, UTC midnight.
+          #
+          # @example Evolve the time to a date query format.
+          #   time.__evolve_date__
+          #
+          # @return [ Time ] The date at midnight UTC.
+          #
+          # @since 1.0.0
+          def __evolve_date__
+            ::Time.utc(year, month, day, 0, 0, 0, 0)
+          end
+
           # Evolve the time into a utc time.
           #
           # @example Evolve the time.

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

@@ -33,7 +33,7 @@ module Mongoid
       #
       # A yet more more complex example is the following condition:
       #
-      #   Foo.geo_spacial(:boundary.intersects_point => [1, 10])
+      #   Foo.geo_spatial(:boundary.intersects_point => [1, 10])
       #
       # Processing this condition will cause a Key instance to be created as
       # follows:

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

@@ -163,7 +163,7 @@ module Mongoid
               if expr.is_a?(Selectable)
                 expr = expr.selector
               end
-              normalized = _mongoid_normalize_expr(expr)
+              normalized = _mongoid_expand_keys(expr)
               sel.store(operator, result_criteria.push(normalized))
             end
           end
@@ -190,9 +190,9 @@ module Mongoid
             sel = query.selector
             _mongoid_flatten_arrays(criteria).each do |criterion|
               if criterion.is_a?(Selectable)
-                expr = _mongoid_normalize_expr(criterion.selector)
+                expr = _mongoid_expand_keys(criterion.selector)
               else
-                expr = criterion
+                expr = _mongoid_expand_keys(criterion)
               end
               if sel.empty?
                 sel.store(operator, [expr])
@@ -212,7 +212,7 @@ module Mongoid
         # explicitly only expands Array objects and Array subclasses.
         private def _mongoid_flatten_arrays(array)
           out = []
-          pending = array
+          pending = array.dup
           until pending.empty?
             item = pending.shift
             if item.nil?
@@ -226,11 +226,78 @@ module Mongoid
           out
         end
 
-        # @api private
-        private def _mongoid_normalize_expr(expr)
-          expr.inject({}) do |hash, (field, value)|
-            hash.merge!(field.__expr_part__(value.__expand_complex__))
+        # Takes a criteria hash and expands Key objects into hashes containing
+        # MQL corresponding to said key objects.
+        #
+        # Ruby does not permit multiple symbol operators. For example,
+        # {:foo.gt => 1, :foo.gt => 2} is collapsed to {:foo.gt => 2} by the
+        # language. Therefore this method never has to deal with multiple
+        # identical operators.
+        #
+        # Similarly, this method should never need to expand a literal value
+        # and an operator at the same time.
+        #
+        # @param [ Hash ] expr Criteria including Key instances.
+        #
+        # @return [ Hash ] The expanded criteria.
+        private def _mongoid_expand_keys(expr)
+          unless expr.is_a?(Hash)
+            raise ArgumentError, 'Argument must be a Hash'
+          end
+
+          result = {}
+          expr.each do |field, value|
+            field.__expr_part__(value.__expand_complex__).each do |k, v|
+              if result[k]
+                if result[k].is_a?(Hash)
+                  # Existing value is an operator.
+                  # If new value is also an operator, ensure there are no
+                  # conflicts and add
+                  if v.is_a?(Hash)
+                    # The new value is also an operator.
+                    # If there are no conflicts, combine the hashes, otherwise
+                    # add new conditions to top level with $and.
+                    if (v.keys & result[k].keys).empty?
+                      result[k].update(v)
+                    else
+                      raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                      result['$and'] ||= []
+                      result['$and'] << {k => v}
+                    end
+                  else
+                    # The new value is a simple value.
+                    # If there isn't an $eq operator already in the query,
+                    # transform the new value into an $eq operator and add it
+                    # to the existing hash. Otherwise add the new condition
+                    # with $and to the top level.
+                    if result[k].key?('$eq')
+                      raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                      result['$and'] ||= []
+                      result['$and'] << {k => v}
+                    else
+                      result[k].update('$eq' => v)
+                    end
+                  end
+                else
+                  # Existing value is a simple value.
+                  # If we are adding an operator, and the operator is not $eq,
+                  # convert existing value into $eq and add the new operator
+                  # to the same hash. Otherwise add the new condition with $and
+                  # to the top level.
+                  if v.is_a?(Hash) && !v.key?('$eq')
+                    result[k] = {'$eq' => result[k]}.update(v)
+                  else
+                    raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                    result['$and'] ||= []
+                    result['$and'] << {k => v}
+                  end
+                end
+              else
+                result[k] = v
+              end
+            end
           end
+          result
         end
 
         # Adds the criterion to the existing selection.

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

@@ -33,7 +33,7 @@ module Mongoid
         # Add a group operation to the aggregation pipeline.
         #
         # @example Add a group operation.
-        #   pipeline.group(:count.sum => 1, :max.max => "likes")
+        #   pipeline.group(:_id => "foo", :count.sum => 1, :max.max => "likes")
         #
         # @param [ Hash ] entry The group entry.
         #
@@ -76,7 +76,8 @@ module Mongoid
         #   pipeline.unwind(:field)
         #   pipeline.unwind(document)
         #
-        # @param [ String, Symbol, Hash ] field_or_doc The name of the field or a document.
+        # @param [ String, Symbol, Hash ] field_or_doc A field name or a
+        #   document.
         #
         # @return [ Pipeline ] The pipeline.
         #

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

@@ -89,11 +89,27 @@ module Mongoid
             if new_s.is_a?(Selectable)
               new_s = new_s.selector
             end
-            normalized = _mongoid_normalize_expr(new_s)
+            normalized = _mongoid_expand_keys(new_s)
             normalized.each do |k, v|
               k = k.to_s
-              if c.selector[k] || k[0] == ?$
-                c = c.send(:__multi__, [{k => v}], '$and')
+              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
@@ -203,32 +219,44 @@ module Mongoid
         #   Source: https://docs.mongodb.com/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_spacial(:location.within_box => [[ 1, 10 ], [ 2, 10 ])
+        #   query.geo_spatial(:location.within_box => [[ 1, 10 ], [ 2, 10 ])
         #
         # @param [ Hash ] criterion The criterion.
         #
         # @return [ Selectable ] The cloned selectable.
+        def geo_spatial(criterion)
+          if criterion.nil?
+            raise Errors::CriteriaArgumentRequired, :geo_spatial
+          end
+
+          __merge__(criterion)
+        end
+
+        # Alias for +geo_spatial+.
         #
-        # @since 2.0.0
+        # @deprecated
         def geo_spacial(criterion)
+          # Duplicate method body so that we can raise this exception with
+          # geo_spacial as the indicated operator rather than geo_spatial.
           if criterion.nil?
             raise Errors::CriteriaArgumentRequired, :geo_spacial
           end
 
           __merge__(criterion)
         end
+
         key :intersects_line, :override, "$geoIntersects", "$geometry" do |value|
           { "type" => LINE_STRING, "coordinates" => value }
         end
@@ -567,17 +595,21 @@ module Mongoid
               if new_s.is_a?(Selectable)
                 new_s = new_s.selector
               end
-              new_s.each do |k, v|
+              _mongoid_expand_keys(new_s).each do |k, v|
                 k = k.to_s
                 if c.selector[k] || k[0] == ?$
                   c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
                 else
-                  if v.is_a?(Regexp)
-                    negated_operator = '$not'
+                  if v.is_a?(Hash)
+                    c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
                   else
-                    negated_operator = '$ne'
+                    if v.is_a?(Regexp)
+                      negated_operator = '$not'
+                    else
+                      negated_operator = '$ne'
+                    end
+                    c = c.send(:__override__, {k => v}, negated_operator)
                   end
-                  c = c.send(:__override__, {k => v}, negated_operator)
                 end
               end
               c
@@ -586,13 +618,34 @@ module Mongoid
         end
         key :not, :override, "$not"
 
-        # Adds $or selection to the selectable.
+        # 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<Hash | Criteria> ] criteria Multiple key/value pair
-        #   matches or Criteria objects.
+        # @example Add the $or selection where either value match is sufficient.
+        #   selectable.or({field: 1}, {field: 2})
+        #
+        # @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.
         #
@@ -600,7 +653,73 @@ module Mongoid
         def or(*criteria)
           _mongoid_add_top_level_operation('$or', criteria)
         end
-        alias :any_of :or
+
+        # 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.
+        #
+        # @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.
+        #
+        # @since 1.0.0
+        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
+            # Should be able to do:
+            #where('$or' => exprs)
+            # But since that is broken do instead:
+            clone.tap do |query|
+              if query.selector['$or']
+                query.selector.store('$or', query.selector['$or'] + exprs)
+              else
+                query.selector.store('$or', exprs)
+              end
+            end
+          end
+        end
 
         # Add a $size selection for array fields.
         #
@@ -765,6 +884,9 @@ module Mongoid
           end
 
           clone.tap do |query|
+            unless Hash === criterion
+              raise Errors::InvalidQuery, "Expression must be a Hash: #{Errors::InvalidQuery.truncate_expr(criterion)}"
+            end
             criterion.each do |field, value|
               field_s = field.to_s
               if field_s[0] == ?$