mongoid 7.1.6 → 7.2.0.rc1

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,35 @@
+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|
+            if k.to_s.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,40 @@
+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
+            exists, value, expanded = Matcher.extract_attribute(document, k)
+            # The value may have been expanded into an array, but then
+            # array may have been shrunk back to a scalar (or hash) when
+            # path contained a numeric position.
+            # Do not treat a hash as an array here (both are iterable).
+            if expanded && Array === value
+              if value == []
+                # Empty array is technically equivalent to exists: false.
+                FieldExpression.matches?(false, nil, expr_v)
+              else
+                value.any? do |v|
+                  FieldExpression.matches?(true, v, expr_v)
+                end
+              end
+            else
+              FieldExpression.matches?(exists, value, 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,63 @@
+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_exists, sub_value, expanded =
+                Matcher.extract_attribute(value, k)
+              if expanded
+                sub_value.any? do |sub_v|
+                  Eq.matches?(true, sub_v, cond_v)
+                end
+              else
+                Eq.matches?(sub_exists, sub_value, 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,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