mongoid 7.1.8 → 7.2.3

data/lib/mongoid/matcher.rb

@@ -0,0 +1,103 @@
+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
+
+      current = [document]
+
+      key.to_s.split('.').each do |field|
+        new = []
+        current.each do |doc|
+          case doc
+          when Hash
+            if doc.key?(field)
+              new << doc[field]
+            end
+          when Array
+            if (index = field.to_i).to_s == field
+              if doc.length > index
+                new << doc[index]
+              end
+            end
+            doc.each do |subdoc|
+              if Hash === subdoc
+                if subdoc.key?(field)
+                  new << subdoc[field]
+                end
+              end
+            end
+          end
+        end
+        current = new
+        break if current.empty?
+      end
+
+      current
+    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/matcher/all.rb

@@ -0,0 +1,22 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module All
+      module_function def matches?(exists, value, condition)
+        unless Array === condition
+          raise Errors::InvalidQuery, "$all argument must be an array: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+
+        !condition.empty? && condition.all? do |c|
+          case c
+          when ::Regexp, BSON::Regexp::Raw
+            Regex.matches_array_or_scalar?(value, c)
+          else
+            EqImpl.matches?(true, value, c, '$all')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/and.rb

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

data/lib/mongoid/matcher/elem_match.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module ElemMatch
+      module_function def matches?(exists, value, condition)
+        unless Hash === condition
+          raise Errors::InvalidQuery, "$elemMatch requires a Hash operand: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        if Array === value && !value.empty?
+          value.any? do |v|
+            ElemMatchExpression.matches?(v, condition)
+          end
+        else
+          # Validate the condition is valid, even though we will never attempt
+          # matching it.
+          condition.each do |k, v|
+            k = k.to_s
+            if k.start_with?('$')
+              begin
+                ExpressionOperator.get(k)
+              rescue Mongoid::Errors::InvalidExpressionOperator
+                begin
+                  FieldOperator.get(k)
+                rescue Mongoid::Errors::InvalidFieldOperator => exc
+                  raise Mongoid::Errors::InvalidElemMatchOperator.new(exc.operator)
+                end
+              end
+            end
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/elem_match_expression.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # $elemMatch argument can be a top-level expression and some specific
+    # operator combinations like $not with a regular expression.
+    #
+    # @api private
+    module ElemMatchExpression
+      module_function def matches?(document, expr)
+        Expression.matches?(document, expr)
+      rescue Mongoid::Errors::InvalidExpressionOperator
+        begin
+          FieldExpression.matches?(true, document, expr)
+        rescue Mongoid::Errors::InvalidFieldOperator => exc
+          raise Mongoid::Errors::InvalidElemMatchOperator.new(exc.operator)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/eq.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Eq
+      module_function def matches?(exists, value, condition)
+        EqImpl.matches?(exists, value, condition, '$eq')
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/eq_impl.rb

@@ -0,0 +1,32 @@
+module Mongoid
+  module Matcher
+
+    # This module is used by $eq and other operators that need to perform
+    # the matching that $eq performs (for example, $ne which negates the result
+    # of $eq). Unlike $eq this module takes an original operator as an
+    # additional argument to +matches?+ to provide the correct exception
+    # messages reflecting the operator that was first invoked.
+    #
+    # @api private
+    module EqImpl
+      module_function def matches?(exists, value, condition, original_operator)
+        case condition
+        when Range
+          # Since $ne invokes $eq, the exception message needs to handle
+          # both operators.
+          raise Errors::InvalidQuery, "Range is not supported as an argument to '#{original_operator}'"
+=begin
+          if value.is_a?(Array)
+            value.any? { |elt| condition.include?(elt) }
+          else
+            condition.include?(value)
+          end
+=end
+        else
+          value == condition ||
+          value.is_a?(Array) && value.include?(condition)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/eq_impl_with_regexp.rb

@@ -0,0 +1,21 @@
+module Mongoid
+  module Matcher
+
+    # This is an internal equality implementation that performs exact
+    # comparisons and regular expression matches.
+    #
+    # @api private
+    module EqImplWithRegexp
+      module_function def matches?(original_operator, value, condition)
+        case condition
+        when Regexp
+          value =~ condition
+        when ::BSON::Regexp::Raw
+          value =~ condition.compile
+        else
+          value == condition
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/exists.rb

@@ -0,0 +1,15 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Exists
+      module_function def matches?(exists, value, condition)
+        case condition
+        when Range
+          raise Errors::InvalidQuery, "$exists argument cannot be a Range: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        exists == (condition || false)
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/expression.rb

@@ -0,0 +1,31 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Expression
+      module_function def matches?(document, expr)
+        if expr.nil?
+          raise Errors::InvalidQuery, "Nil condition in expression context"
+        end
+        unless Hash === expr
+          raise Errors::InvalidQuery, "MQL query must be provided as a Hash"
+        end
+        expr.all? do |k, expr_v|
+          k = k.to_s
+          if k.start_with?('$')
+            ExpressionOperator.get(k).matches?(document, expr_v)
+          else
+            values = Matcher.extract_attribute(document, k)
+            if values.length > 0
+              values.any? do |v|
+                FieldExpression.matches?(true, v, expr_v)
+              end
+            else
+              FieldExpression.matches?(false, nil, expr_v)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/expression_operator.rb

@@ -0,0 +1,19 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module ExpressionOperator
+      MAP = {
+        '$and' => And,
+        '$nor' => Nor,
+        '$or' => Or,
+      }.freeze
+
+      module_function def get(op)
+        MAP.fetch(op)
+      rescue KeyError
+        raise Errors::InvalidExpressionOperator.new(op)
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/field_expression.rb

@@ -0,0 +1,62 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module FieldExpression
+      module_function def matches?(exists, value, condition)
+        if condition.is_a?(Hash)
+          condition.all? do |k, cond_v|
+            k = k.to_s
+            if k.start_with?('$')
+              if %w($regex $options).include?(k)
+                unless condition.key?('$regex')
+                  raise Errors::InvalidQuery, "$regex is required if $options is given: #{Errors::InvalidQuery.truncate_expr(condition)}"
+                end
+
+                if k == '$regex'
+                  if options = condition['$options']
+                    cond_v = case cond_v
+                    when Regexp
+                      BSON::Regexp::Raw.new(cond_v.source, options)
+                    when BSON::Regexp::Raw
+                      BSON::Regexp::Raw.new(cond_v.pattern, options)
+                    else
+                      BSON::Regexp::Raw.new(cond_v, options)
+                    end
+                  elsif String === cond_v
+                    cond_v = BSON::Regexp::Raw.new(cond_v)
+                  end
+
+                  FieldOperator.get(k).matches?(exists, value, cond_v)
+                else
+                  # $options are matched as part of $regex
+                  true
+                end
+              else
+                FieldOperator.get(k).matches?(exists, value, cond_v)
+              end
+            elsif Hash === value
+              sub_values = Matcher.extract_attribute(value, k)
+              if sub_values.length > 0
+                sub_values.any? do |sub_v|
+                  Eq.matches?(true, sub_v, cond_v)
+                end
+              else
+                Eq.matches?(false, nil, cond_v)
+              end
+            else
+              false
+            end
+          end
+        else
+          case condition
+          when ::Regexp, BSON::Regexp::Raw
+            Regex.matches_array_or_scalar?(value, condition)
+          else
+            Eq.matches?(exists, value, condition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/field_operator.rb

@@ -0,0 +1,48 @@
+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)
+        left.send(operator, right)
+      rescue ArgumentError, NoMethodError, TypeError
+        # We silence bogus comparison attempts, e.g. number to string
+        # comparisons.
+        # Several different exceptions may be produced depending on the types
+        # involved.
+        false
+      end
+    end
+  end
+end