mongoid 6.4.4 → 7.3.2

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional datetime behaviour.
+        # This module contains additional datetime behavior.
         module DateTime
 
           # Evolve the date time into a mongo friendly UTC time.
@@ -17,11 +19,8 @@ module Mongoid
           # @since 1.0.0
           def __evolve_time__
             usec = strftime("%6N").to_f
-            if utc?
-              ::Time.utc(year, month, day, hour, min, sec, usec)
-            else
-              ::Time.local(year, month, day, hour, min, sec, usec).utc
-            end
+            u = utc
+            ::Time.utc(u.year, u.month, u.day, u.hour, u.min, u.sec, usec)
           end
 
           module ClassMethods

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional hash behaviour.
+        # This module contains additional hash behavior.
         module Hash
 
           # Add an object to a hash using the merge strategies.

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional nil behaviour.
+        # This module contains additional nil behavior.
         module NilClass
 
           # Add this object to nil.

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional numeric behaviour.
+        # This module contains additional numeric behavior.
         module Numeric
 
           # Evolve the numeric value into a mongo friendly date, aka UTC time at
@@ -58,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/object.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional object behaviour.
+        # This module contains additional object behavior.
         module Object
 
           # Combine the two objects using the add strategy.

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional range behaviour.
+        # This module contains additional range behavior.
         module Range
 
           # Get the range as an array.

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

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional regex behaviour.
+        # This module contains additional regex behavior.
         module Regexp
 
           # Is the object a regexp?
           #
           # @example Is the object a regex?
-          #   /^[123]/.regexp?
+          #   /\A[123]/.regexp?
           #
           # @return [ true ] Always true.
           #
@@ -22,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.
             #
@@ -36,7 +38,7 @@ module Mongoid
             end
           end
 
-          module Raw
+          module Raw_
 
             # Is the object a regexp?
             #
@@ -53,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.
               #
@@ -75,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/set.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 require "set"
 
 module Mongoid
@@ -6,7 +8,7 @@ module Mongoid
     module Queryable
       module Extensions
 
-        # This module contains additional object behaviour.
+        # This module contains additional object behavior.
         module Set
           module ClassMethods
 

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional object behaviour.
+        # This module contains additional object behavior.
         module String
 
           # Evolve the string into a mongodb friendly date.
@@ -29,7 +31,7 @@ module Mongoid
           #
           # @since 1.0.0
           def __evolve_time__
-            ::Time.parse(self).utc
+            __mongoize_time__.utc
           end
 
           # Get the string as a mongo expression, adding $ to the front.

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional symbol behaviour.
+        # This module contains additional symbol behavior.
         module Symbol
 
           # Get the symbol as a specification.

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional time behaviour.
+        # This module contains additional time behavior.
         module Time
 
           # Evolve the time as a date, UTC midnight.
@@ -28,7 +30,7 @@ module Mongoid
           #
           # @since 1.0.0
           def __evolve_time__
-            utc
+            getutc
           end
 
           module ClassMethods

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

@@ -1,12 +1,26 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
       module Extensions
 
-        # This module contains additional time with zone behaviour.
+        # 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/extensions.rb

@@ -1,7 +1,5 @@
+# frozen_string_literal: true
 # encoding: utf-8
-unless defined?(Boolean)
-  class Boolean; end
-end
 
 if defined?(ActiveSupport)
   unless defined?(ActiveSupport::TimeWithZone)

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

@@ -1,18 +1,79 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
 
-      # The key is a representation of a field in a queryable, that can be
-      # expanded to special MongoDB selectors.
+      # Key objects represent specifications for building query expressions
+      # utilizing MongoDB selectors.
+      #
+      # Simple key-value conditions are translated directly into expression
+      # hashes by Mongoid without utilizing Key objects. For example, the
+      # following condition:
+      #
+      #   Foo.where(price: 1)
+      #
+      # ... is translated to the following simple expression:
+      #
+      #   {price: 1}
+      #
+      # More complex conditions would start involving Key objects. For example:
+      #
+      #   Foo.where(:price.gt => 1)
+      #
+      # ... causes a Key instance to be created thusly:
+      #
+      #   Key.new(:price, :__override__, '$gt')
+      #
+      # This Key instance utilizes +operator+ but not +expanded+ nor +block+.
+      # The corresponding MongoDB query expression is:
+      #
+      #    {price: {'$gt' => 1}}
+      #
+      # A yet more more complex example is the following condition:
+      #
+      #   Foo.geo_spatial(:boundary.intersects_point => [1, 10])
+      #
+      # Processing this condition will cause a Key instance to be created as
+      # follows:
+      #
+      #   Key.new(:location, :__override__, '$geoIntersects', '$geometry') do |value|
+      #     { "type" => POINT, "coordinates" => value }
+      #   end
+      #
+      # ... eventually producing the following MongoDB query expression:
+      #
+      # {
+      #   boundary: {
+      #     '$geoIntersects' => {
+      #       '$geometry' => {
+      #         type: "Point" ,
+      #         coordinates: [ 1, 10 ]
+      #       }
+      #     }
+      #   }
+      # }
+      #
+      # Key instances can be thought of as procs that map a value to the
+      # MongoDB query expression required to obtain the key's condition,
+      # given the value.
       class Key
 
-        # @attribute [r] name The name of the field.
-        # @attribute [r] block The optional block to transform values.
-        # @attribute [r] operator The MongoDB query operator.
-        # @attribute [r] expanded The MongoDB expanded query operator.
-        # @attribute [r] strategy The name of the merge strategy.
-        attr_reader :block, :name, :operator, :expanded, :strategy
+        # @return [ String | Symbol ] The name of the field.
+        attr_reader :name
+
+        # @return [ String ] The MongoDB query operator.
+        attr_reader :operator
+
+        # @return [ String ] The MongoDB expanded query operator.
+        attr_reader :expanded
+
+        # @return [ Symbol ] The name of the merge strategy.
+        attr_reader :strategy
+
+        # @return [ Proc ] The optional block to transform values.
+        attr_reader :block
 
         # Does the key equal another object?
         #
@@ -42,16 +103,24 @@ module Mongoid
 
         # Instantiate the new key.
         #
-        # @example Instantiate the key.
-        #   Key.new("age", "$gt")
+        # @example Instantiate a key.
+        #   Key.new("age", :__override__, "$gt")
+        #
+        # @example Instantiate a key for sorting.
+        #   Key.new(:field, :__override__, 1)
         #
         # @param [ String, Symbol ] name The field name.
         # @param [ Symbol ] strategy The name of the merge strategy.
-        # @param [ String ] operator The Mongo operator.
+        # @param [ String | Integer ] operator The MongoDB operator,
+        #   or sort direction (1 or -1).
         # @param [ String ] expanded The Mongo expanded operator.
         #
         # @since 1.0.0
         def initialize(name, strategy, operator, expanded = nil, &block)
+          unless operator.is_a?(String) || operator.is_a?(Integer)
+            raise ArgumentError, "Operator must be a string or an integer: #{operator.inspect}"
+          end
+
           @name, @strategy, @operator, @expanded, @block =
             name, strategy, operator, expanded, block
         end
@@ -68,9 +137,27 @@ module Mongoid
         #
         # @since 1.0.0
         def __expr_part__(object, negating = false)
-          value = block ? block[object] : object
-          expression = { operator => expanded ? { expanded => value } : value }
-          { name.to_s => (negating && operator != "$not") ? { "$not" => expression } : expression }
+          { name.to_s => transform_value(object, negating) }
+        end
+
+        def transform_value(value, negating = false)
+          if block
+            expr = block[value]
+          else
+            expr = value
+          end
+
+          if expanded
+            expr = {expanded => expr}
+          end
+
+          expr = {operator => expr}
+
+          if negating && operator != '$not'
+            expr = {'$not' => expr}
+          end
+
+          expr
         end
 
         # Get the key as raw Mongo sorting options.

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
 
-      # Adds macro behaviour for adding symbol methods.
+      # Adds macro behavior for adding symbol methods.
       module Macroable
 
         # Adds a method on Symbol for convenience in where queries for the

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
 
-      # Contains behaviour for merging existing selection with new selection.
+      # Contains behavior for merging existing selection with new selection.
       module Mergeable
 
         # @attribute [rw] strategy The name of the current strategy.
@@ -45,16 +47,18 @@ module Mongoid
           use(:__union__)
         end
 
-        # Reset the stratgies to nil, used after cloning.
+        # Clear the current strategy and negating flag, used after cloning.
         #
         # @example Reset the strategies.
         #   mergeable.reset_strategies!
         #
-        # @return [ nil ] nil.
+        # @return [ Criteria ] self.
         #
         # @since 1.0.0
         def reset_strategies!
-          self.strategy, self.negating = nil, nil
+          self.strategy = nil
+          self.negating = nil
+          self
         end
 
         private
@@ -132,32 +136,194 @@ module Mongoid
           with_strategy(:__intersect__, criterion, operator)
         end
 
-        # Adds the criterion to the existing selection.
+        # Adds $and/$or/$nor criteria to a copy of this selection.
+        #
+        # Each of the criteria can be a Hash of key/value pairs or MongoDB
+        # operators (keys beginning with $), or a Selectable object
+        # (which typically will be a Criteria instance).
         #
         # @api private
         #
         # @example Add the criterion.
         #   mergeable.__multi__([ 1, 2 ], "$in")
         #
-        # @param [ Hash ] criterion The criteria.
+        # @param [ Array<Hash | Criteria> ] criteria Multiple key/value pair
+        #   matches or Criteria objects.
         # @param [ String ] operator The MongoDB operator.
         #
         # @return [ Mergeable ] The new mergeable.
         #
         # @since 1.0.0
-        def __multi__(criterion, operator)
+        def __multi__(criteria, operator)
           clone.tap do |query|
             sel = query.selector
-            criterion.flatten.each do |expr|
+            criteria.flatten.each do |expr|
               next unless expr
-              criteria = sel[operator] || []
-              normalized = expr.inject({}) do |hash, (field, value)|
-                hash.merge!(field.__expr_part__(value.__expand_complex__))
-                hash
+              result_criteria = sel[operator] || []
+              if expr.is_a?(Selectable)
+                expr = expr.selector
+              end
+              normalized = _mongoid_expand_keys(expr)
+              sel.store(operator, result_criteria.push(normalized))
+            end
+          end
+        end
+
+        # Combines criteria into a MongoDB selector.
+        #
+        # Criteria is an array of criterions which will be flattened.
+        #
+        # Each criterion can be:
+        # - A hash
+        # - A Criteria instance
+        # - nil, in which case it is ignored
+        #
+        # @api private
+        private def _mongoid_add_top_level_operation(operator, criteria)
+          # Flatten the criteria. The idea is that predicates in MongoDB
+          # are always hashes and are never arrays. This method additionally
+          # allows Criteria instances as predicates.
+          # The flattening is existing Mongoid behavior but we could possibly
+          # get rid of it as applications can splat their predicates, or
+          # flatten if needed.
+          clone.tap do |query|
+            sel = query.selector
+            _mongoid_flatten_arrays(criteria).each do |criterion|
+              if criterion.is_a?(Selectable)
+                expr = _mongoid_expand_keys(criterion.selector)
+              else
+                expr = _mongoid_expand_keys(criterion)
               end
-              sel.store(operator, criteria.push(normalized))
+              if sel.empty?
+                sel.store(operator, [expr])
+              elsif sel.keys == [operator]
+                sel.store(operator, sel[operator] + [expr])
+              else
+                operands = [sel.dup] + [expr]
+                sel.clear
+                sel.store(operator, operands)
+              end
+            end
+          end
+        end
+
+        # Calling .flatten on an array which includes a Criteria instance
+        # evaluates the criteria, which we do not want. Hence this method
+        # explicitly only expands Array objects and Array subclasses.
+        private def _mongoid_flatten_arrays(array)
+          out = []
+          pending = array.dup
+          until pending.empty?
+            item = pending.shift
+            if item.nil?
+              # skip
+            elsif item.is_a?(Array)
+              pending += item
+            else
+              out << item
             end
           end
+          out
+        end
+
+        # Takes a criteria hash and expands Key objects into hashes containing
+        # MQL corresponding to said key objects. Also converts the input to
+        # BSON::Document to permit indifferent access.
+        #
+        # The argument must be a hash containing key-value pairs of the
+        # following forms:
+        # - {field_name: value}
+        # - {'field_name' => value}
+        # - {key_instance: value}
+        # - {:$operator => operator_value_expression}
+        # - {'$operator' => operator_value_expression}
+        #
+        # 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.
+        #
+        # This method effectively converts symbol keys to string keys in
+        # the input +expr+, such that the downstream code can assume that
+        # conditions always contain string keys.
+        #
+        # @param [ Hash ] expr Criteria including Key instances.
+        #
+        # @return [ BSON::Document ] The expanded criteria.
+        private def _mongoid_expand_keys(expr)
+          unless expr.is_a?(Hash)
+            raise ArgumentError, 'Argument must be a Hash'
+          end
+
+          result = BSON::Document.new
+          expr.each do |field, value|
+            field.__expr_part__(value.__expand_complex__, negating?).each do |k, v|
+              if existing = result[k]
+                if existing.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 & existing.keys).empty?
+                      existing.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.
+                    # Transform the implicit equality to either $eq or $regexp
+                    # depending on the type of the argument. See
+                    # https://docs.mongodb.com/manual/reference/operator/query/eq/#std-label-eq-usage-examples
+                    # for the description of relevant server behavior.
+                    op = case v
+                    when Regexp, BSON::Regexp::Raw
+                      '$regex'
+                    else
+                      '$eq'
+                    end
+                    # If there isn't an $eq/$regex operator already in the
+                    # query, transform the new value into an operator
+                    # expression and add it to the existing hash. Otherwise
+                    # add the new condition with $and to the top level.
+                    if existing.key?(op)
+                      raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                      result['$and'] ||= []
+                      result['$and'] << {k => v}
+                    else
+                      existing.update(op => v)
+                    end
+                  end
+                else
+                  # Existing value is a simple value.
+                  # See the notes above about transformations to $eq/$regex.
+                  op = case existing
+                  when Regexp, BSON::Regexp::Raw
+                    '$regex'
+                  else
+                    '$eq'
+                  end
+                  if v.is_a?(Hash) && !v.key?(op)
+                    result[k] = {op => existing}.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.
@@ -167,13 +333,16 @@ module Mongoid
         # @example Add the criterion.
         #   mergeable.__override__([ 1, 2 ], "$in")
         #
-        # @param [ Hash ] criterion The criteria.
+        # @param [ Hash | Criteria ] criterion The criteria.
         # @param [ String ] operator The MongoDB operator.
         #
         # @return [ Mergeable ] The new mergeable.
         #
         # @since 1.0.0
         def __override__(criterion, operator)
+          if criterion.is_a?(Selectable)
+            criterion = criterion.selector
+          end
           selection(criterion) do |selector, field, value|
             expression = prepare(field, operator, value)
             existing = selector[field]
@@ -225,7 +394,7 @@ module Mongoid
         # @api private
         #
         # @example Add criterion with a strategy.
-        #   mergeable.with_strategy(:__union__, [ 1, 2, 3 ], "$in")
+        #   mergeable.with_strategy(:__union__, {field_name: [ 1, 2, 3 ]}, "$in")
         #
         # @param [ Symbol ] strategy The name of the strategy method.
         # @param [ Object ] criterion The criterion to add.