mongoid 7.1.11 → 7.2.0.rc1

data/lib/mongoid/matcher/field_operator.rb

@@ -0,0 +1,52 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module FieldOperator
+      MAP = {
+        '$all' => All,
+        '$elemMatch' => ElemMatch,
+        '$eq' => Eq,
+        '$exists' => Exists,
+        '$gt' => Gt,
+        '$gte' => Gte,
+        '$in' => In,
+        '$lt' => Lt,
+        '$lte' => Lte,
+        '$nin' => Nin,
+        '$ne' => Ne,
+        '$not' => Not,
+        '$regex' => Regex,
+        '$size' => Size,
+      }.freeze
+
+      module_function def get(op)
+        MAP.fetch(op)
+      rescue KeyError
+        raise Errors::InvalidFieldOperator.new(op)
+      end
+
+      module_function def apply_array_field_operator(exists, value, condition)
+        if Array === value
+          value.any? { |v| yield v }
+        else
+          yield value
+        end
+      end
+
+      module_function def apply_comparison_operator(operator, left, right)
+        case left
+        when Numeric
+          case right
+          when Numeric
+            left.send(operator, right)
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/gt.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Gt
+      module_function def matches?(exists, value, condition)
+        case condition
+        when Range
+          raise Errors::InvalidQuery, "$gt argument cannot be a Range: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        FieldOperator.apply_array_field_operator(exists, value, condition) do |v|
+          FieldOperator.apply_comparison_operator(:>, v, condition)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/gte.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Gte
+      module_function def matches?(exists, value, condition)
+        case condition
+        when Range
+          raise Errors::InvalidQuery, "$gte argument cannot be a Range: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        FieldOperator.apply_array_field_operator(exists, value, condition) do |v|
+          FieldOperator.apply_comparison_operator(:>=, v, condition)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/in.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module In
+      module_function def matches?(exists, value, condition)
+        unless Array === condition
+          raise Errors::InvalidQuery, "$in argument must be an array: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        if Array === value
+          if value.any? { |v|
+            condition.any? do |c|
+              EqImplWithRegexp.matches?('$in', v, c)
+            end
+          } then
+            return true
+          end
+        end
+        condition.any? do |c|
+          EqImplWithRegexp.matches?('$in', value, c)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/lt.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Lt
+      module_function def matches?(exists, value, condition)
+        case condition
+        when Range
+          raise Errors::InvalidQuery, "$lt argument cannot be a Range: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        FieldOperator.apply_array_field_operator(exists, value, condition) do |v|
+          FieldOperator.apply_comparison_operator(:<, v, condition)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/lte.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Lte
+      module_function def matches?(exists, value, condition)
+        case condition
+        when Range
+          raise Errors::InvalidQuery, "$lte argument cannot be a Range: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        FieldOperator.apply_array_field_operator(exists, value, condition) do |v|
+          FieldOperator.apply_comparison_operator(:<=, v, condition)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/ne.rb

@@ -0,0 +1,16 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Ne
+      module_function def matches?(exists, value, condition)
+        case condition
+        when ::Regexp, BSON::Regexp::Raw
+          raise Errors::InvalidQuery, "'$ne' operator does not allow Regexp arguments: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+
+        !EqImpl.matches?(exists, value, condition, '$ne')
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/nin.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Nin
+      module_function def matches?(exists, value, condition)
+        !In.matches?(exists, value, condition)
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/nor.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Nor
+      module_function def matches?(document, expr)
+        unless expr.is_a?(Array)
+          raise Errors::InvalidQuery, "$nor argument must be an array: #{Errors::InvalidQuery.truncate_expr(expr)}"
+        end
+
+        if expr.empty?
+          raise Errors::InvalidQuery, "$nor argument must be a non-empty array: #{Errors::InvalidQuery.truncate_expr(expr)}"
+        end
+
+        expr.each do |sub_expr|
+          if Expression.matches?(document, sub_expr)
+            return false
+          end
+        end
+
+        expr.any?
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/not.rb

@@ -0,0 +1,29 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Not
+      module_function def matches?(exists, value, condition)
+        case condition
+        when ::Regexp, BSON::Regexp::Raw
+          !Regex.matches?(exists, value, condition)
+        when Hash
+          if condition.empty?
+            raise Errors::InvalidQuery, "$not argument cannot be an empty hash: #{Errors::InvalidQuery.truncate_expr(condition)}"
+          end
+
+          condition.all? do |(k, cond_v)|
+            k = k.to_s
+            unless k.start_with?('$')
+              raise Errors::InvalidQuery, "$not arguments must be operators: #{Errors::InvalidQuery.truncate_expr(k)}"
+            end
+
+            !FieldOperator.get(k).matches?(exists, value, cond_v)
+          end
+        else
+          raise Errors::InvalidQuery, "$not argument must be a Hash or a regular expression: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/or.rb

@@ -0,0 +1,21 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Or
+      module_function def matches?(document, expr)
+        unless expr.is_a?(Array)
+          raise Errors::InvalidQuery, "$or argument must be an array: #{Errors::InvalidQuery.truncate_expr(expr)}"
+        end
+
+        if expr.empty?
+          raise Errors::InvalidQuery, "$or argument must be a non-empty array: #{Errors::InvalidQuery.truncate_expr(expr)}"
+        end
+
+        expr.any? do |sub_expr|
+          Expression.matches?(document, sub_expr)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/regex.rb

@@ -0,0 +1,41 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Regex
+      module_function def matches?(exists, value, condition)
+        condition = case condition
+        when Regexp
+          condition
+        when BSON::Regexp::Raw
+          condition.compile
+        else
+          # Note that strings must have been converted to a regular expression
+          # instance already (with $options taken into account, if provided).
+          raise Errors::InvalidQuery, "$regex requires a regular expression argument: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+
+        case value
+        when Array
+          value.any? do |v|
+            v =~ condition
+          end
+        when String
+          value =~ condition
+        else
+          false
+        end
+      end
+
+      module_function def matches_array_or_scalar?(value, condition)
+        if Array === value
+          value.any? do |v|
+            matches?(true, v, condition)
+          end
+        else
+          matches?(true, value, condition)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/size.rb

@@ -0,0 +1,26 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Size
+      module_function def matches?(exists, value, condition)
+        case condition
+        when Float
+          raise Errors::InvalidQuery, "$size argument must be a non-negative integer: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        when Numeric
+          if condition < 0
+            raise Errors::InvalidQuery, "$size argument must be a non-negative integer: #{Errors::InvalidQuery.truncate_expr(condition)}"
+          end
+        else
+          raise Errors::InvalidQuery, "$size argument must be a non-negative integer: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+
+        if Array === value
+          value.length == condition
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher.rb

@@ -0,0 +1,127 @@
+module Mongoid
+
+  # @api private
+  module Matcher
+
+    # Extracts field values in the document at the specified key.
+    #
+    # The document can be a Hash or a model instance.
+    #
+    # The key is a valid MongoDB dot notation key. The following use cases are
+    # supported:
+    #
+    # - Simple field traversal (`foo`) - retrieves the field `foo` in the
+    #   current document.
+    # - Hash/embedded document field traversal (`foo.bar`) - retrieves the
+    #   field `foo` in the current document, then retrieves the field `bar`
+    #   from the value of `foo`. Each path segment could descend into an
+    #   embedded document or a hash field.
+    # - Array element retrieval (`foo.N`) - retrieves the Nth array element
+    #   from the field `foo` which must be an array. N must be a non-negative
+    #   integer.
+    # - Array traversal (`foo.bar`) - if `foo` is an array field, and
+    #   the elements of `foo` are hashes or embedded documents, this returns
+    #   an array of values of the `bar` field in each of the hashes in the
+    #   `foo` array.
+    #
+    # The return value is a two-element array. The first element is the value
+    # retrieved, or an array of values. The second element is a boolean flag
+    # indicating whether an array was expanded at any point during the key
+    # traversal (because the respective document field was an array).
+    #
+    # @param [ Document | Hash ] document The document to extract from.
+    # @param [ String ] key The key path to extract.
+    #
+    # @return [ Array<true | false, Object | Array, true | false> ]
+    #   Whether the value existed in the document, the extracted value
+    #   and the array expansion flag.
+    module_function def extract_attribute(document, key)
+      if document.respond_to?(:as_attributes, true)
+        # If a document has hash fields, as_attributes would keep those fields
+        # as Hash instances which do not offer indifferent access.
+        # Convert to BSON::Document to get indifferent access on hash fields.
+        document = BSON::Document.new(document.send(:as_attributes))
+      end
+
+      src = document
+      expanded = false
+      exists = true
+
+      key.to_s.split('.').each do |field|
+        if (index = field.to_i).to_s == field
+          # Array indexing
+          if Array === src
+            exists = index < src.length
+            src = src[index]
+          else
+            # Trying to index something that is not an array
+            exists = false
+            src = nil
+          end
+        else
+          case src
+          when nil
+            exists = false
+          when Hash
+            exists = src.key?(field)
+            src = src[field]
+          when Array
+            expanded = true
+            exists = false
+            new = []
+            src.each do |doc|
+              case doc
+              when Hash
+                if doc.key?(field)
+                  v = doc[field]
+                  case v
+                  when Array
+                    new += v
+                  else
+                    new += [v]
+                  end
+                  exists = true
+                end
+              else
+                # Trying to hash index into a value that is not a hash
+              end
+            end
+            src = new
+          else
+            # Trying to descend into a field that is not a hash using
+            # dot notation.
+            exists = false
+            src = nil
+          end
+        end
+      end
+
+      [exists, src, expanded]
+    end
+  end
+end
+
+require 'mongoid/matcher/all'
+require 'mongoid/matcher/and'
+require 'mongoid/matcher/elem_match'
+require 'mongoid/matcher/elem_match_expression'
+require 'mongoid/matcher/eq'
+require 'mongoid/matcher/eq_impl'
+require 'mongoid/matcher/eq_impl_with_regexp'
+require 'mongoid/matcher/exists'
+require 'mongoid/matcher/expression'
+require 'mongoid/matcher/field_expression'
+require 'mongoid/matcher/gt'
+require 'mongoid/matcher/gte'
+require 'mongoid/matcher/in'
+require 'mongoid/matcher/lt'
+require 'mongoid/matcher/lte'
+require 'mongoid/matcher/ne'
+require 'mongoid/matcher/nin'
+require 'mongoid/matcher/nor'
+require 'mongoid/matcher/not'
+require 'mongoid/matcher/or'
+require 'mongoid/matcher/regex'
+require 'mongoid/matcher/size'
+require 'mongoid/matcher/expression_operator'
+require 'mongoid/matcher/field_operator'

data/lib/mongoid/persistable/deletable.rb

@@ -141,7 +141,7 @@ module Mongoid
         #
         # @since 1.0.0
         def delete_all(conditions = {})
-          selector = hereditary? ? conditions.merge(_type: name) : conditions
+          selector = hereditary? ? conditions.merge(discriminator_key.to_sym => discriminator_value) : conditions
           where(selector).delete
         end
       end

data/lib/mongoid/persistence_context.rb

@@ -237,9 +237,7 @@ module Mongoid
       # @since 6.0.0
       def clear(object, cluster = nil, original_context = nil)
         if context = get(object)
-          unless cluster.nil? || context.cluster.equal?(cluster)
-            context.client.close
-          end
+          context.client.close unless (context.cluster.equal?(cluster) || cluster.nil?)
         end
       ensure
         Thread.current["[mongoid][#{object.object_id}]:context"] = original_context