mongoid 7.0.13 → 8.0.8

data/lib/mongoid/matcher/bits_all_clear.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAllClear
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.all? do |c|
+          value & (1<<c) == 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition == 0
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_all_set.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAllSet
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.all? do |c|
+          value & (1<<c) > 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition == condition
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_any_clear.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAnyClear
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.any? do |c|
+          value & (1<<c) == 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition < condition
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_any_set.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAnySet
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.any? do |c|
+          value & (1<<c) > 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition > 0
+      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,67 @@
+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
+          # When doing a comparison with Time objects, compare using millisecond precision
+          if Mongoid.compare_time_by_ms
+            if value.kind_of?(Time) && condition.kind_of?(Time)
+              time_eq?(value, condition)
+            elsif value.is_a?(Array) && condition.kind_of?(Time)
+              value.map do |v|
+                if v.kind_of?(Time)
+                  time_rounded_to_millis(v)
+                else
+                  v
+                end
+              end.include?(time_rounded_to_millis(condition))
+            else
+              value == condition ||
+              value.is_a?(Array) && value.include?(condition)
+            end
+          else
+            value == condition ||
+            value.is_a?(Array) && value.include?(condition)
+          end
+        end
+      end
+
+      # Per https://docs.mongodb.com/ruby-driver/current/tutorials/bson-v4/#time-instances,
+      # > Times in BSON (and MongoDB) can only have millisecond precision. When Ruby Time instances
+      # are serialized to BSON or Extended JSON, the times are floored to the nearest millisecond.
+      #
+      # > Because of this flooring, applications are strongly recommended to perform all time
+      # calculations using integer math, as inexactness of floating point calculations may produce
+      # unexpected results.
+      #
+      # As such, perform a similar operation to what the bson-ruby gem does
+      module_function def time_eq?(time_a, time_b)
+        time_rounded_to_millis(time_a) == time_rounded_to_millis(time_b)
+      end
+
+      module_function def time_rounded_to_millis(time)
+        return time._bson_to_i * 1000 + time.usec.divmod(1000).first
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/eq_impl_with_regexp.rb

@@ -0,0 +1,26 @@
+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
+          if Mongoid.compare_time_by_ms &&
+            value.kind_of?(Time) && condition.kind_of?(Time)
+            EqImpl.time_eq?(value, condition)
+          else
+            value == condition
+          end
+        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,35 @@
+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 == "$comment"
+            # Nothing
+            return true
+          end
+          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,54 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module FieldOperator
+      MAP = {
+        '$all' => All,
+        '$bitsAllClear' => BitsAllClear,
+        '$bitsAllSet' => BitsAllSet,
+        '$bitsAnyClear' => BitsAnyClear,
+        '$bitsAnySet' => BitsAnySet,
+        '$elemMatch' => ElemMatch,
+        '$eq' => Eq,
+        '$exists' => Exists,
+        '$gt' => Gt,
+        '$gte' => Gte,
+        '$in' => In,
+        '$lt' => Lt,
+        '$lte' => Lte,
+        '$mod' => Mod,
+        '$nin' => Nin,
+        '$ne' => Ne,
+        '$not' => Not,
+        '$regex' => Regex,
+        '$size' => Size,
+        '$type' => Type,
+      }.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

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/mod.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Mod
+      module_function def matches?(exists, value, condition)
+        unless Array === condition
+          raise Errors::InvalidQuery, "Unknown $mod argument #{condition}"
+        end
+        if condition.length != 2
+          raise Errors::InvalidQuery, "Malformed $mod argument #{condition}, should have 2 elements"
+        end
+        condition[1] == value%condition[0]
+      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