mongoid 7.1.5 → 7.2.1

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

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

@@ -17,8 +17,13 @@ module Mongoid
       # @return [ Hash ] The hash of cached queries.
       #
       # @since 4.0.0
+      # @api private
       def cache_table
-        Thread.current["[mongoid]:query_cache"] ||= {}
+        if defined?(Mongo::QueryCache)
+          raise NotImplementedError, "Mongoid does not expose driver's query cache table"
+        else
+          Thread.current["[mongoid]:query_cache"] ||= {}
+        end
       end
 
       # Clear the query cache.
@@ -30,7 +35,11 @@ module Mongoid
       #
       # @since 4.0.0
       def clear_cache
-        Thread.current["[mongoid]:query_cache"] = nil
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.clear
+        else
+          Thread.current["[mongoid]:query_cache"] = nil
+        end
       end
 
       # Set whether the cache is enabled.
@@ -42,7 +51,11 @@ module Mongoid
       #
       # @since 4.0.0
       def enabled=(value)
-        Thread.current["[mongoid]:query_cache:enabled"] = value
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.enabled = value
+        else
+          Thread.current["[mongoid]:query_cache:enabled"] = value
+        end
       end
 
       # Is the query cache enabled on the current thread?
@@ -54,7 +67,11 @@ module Mongoid
       #
       # @since 4.0.0
       def enabled?
-        !!Thread.current["[mongoid]:query_cache:enabled"]
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.enabled?
+        else
+          !!Thread.current["[mongoid]:query_cache:enabled"]
+        end
       end
 
       # Execute the block while using the query cache.
@@ -65,12 +82,18 @@ module Mongoid
       # @return [ Object ] The result of the block.
       #
       # @since 4.0.0
-      def cache
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = true
-        yield
-      ensure
-        QueryCache.enabled = enabled
+      def cache(&block)
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.cache(&block)
+        else
+          enabled = QueryCache.enabled?
+          QueryCache.enabled = true
+          begin
+            yield
+          ensure
+            QueryCache.enabled = enabled
+          end
+        end
       end
 
       # Execute the block with the query cache disabled.
@@ -79,12 +102,18 @@ module Mongoid
       #   QueryCache.uncached { collection.find }
       #
       # @return [ Object ] The result of the block.
-      def uncached
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = false
-        yield
-      ensure
-        QueryCache.enabled = enabled
+      def uncached(&block)
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.uncached(&block)
+        else
+          enabled = QueryCache.enabled?
+          QueryCache.enabled = false
+          begin
+            yield
+          ensure
+            QueryCache.enabled = enabled
+          end
+        end
       end
     end
 
@@ -127,6 +156,7 @@ module Mongoid
     # the database if the same query has already been executed.
     #
     # @since 5.0.0
+    # @deprecated This class is only used with driver versions 2.13 and lower.
     class CachedCursor < Mongo::Cursor
 
       # We iterate over the cached documents if they exist already in the
@@ -164,12 +194,10 @@ module Mongoid
 
       def process(result)
         documents = super
-
         if @cursor_id.zero? && !@after_first_batch
           @cached_documents ||= []
           @cached_documents.concat(documents)
         end
-
         @after_first_batch = true
         documents
       end
@@ -179,6 +207,7 @@ module Mongoid
     # operations.
     #
     # @since 4.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module Base
 
       def alias_query_cache_clear(*method_names)
@@ -198,6 +227,7 @@ module Mongoid
     # cached cursor or a regular cursor on iteration.
     #
     # @since 5.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module View
       extend ActiveSupport::Concern
 
@@ -228,24 +258,19 @@ module Mongoid
         else
           @cursor = nil
           unless @cursor = cached_cursor
-
-            if driver_supports_cursor_sessions?
-              session = client.send(:get_session, @options)
-              read_with_retry(session, server_selector) do |server|
-                result = send_initial_query(server, session)
-                @cursor = get_cursor(result, server, session)
-              end
-            else
-              read_with_retry do
-                server = server_selector.select_server(cluster)
-                result = send_initial_query(server)
-                @cursor = get_cursor(result, server)
+            session = client.send(:get_session, @options)
+            read_with_retry(session, server_selector) do |server|
+              result = send_initial_query(server, session)
+              if result.cursor_id == 0 || result.cursor_id.nil?
+                @cursor = CachedCursor.new(view, result, server, session: session)
+                QueryCache.cache_table[cache_key] = @cursor
+              else
+                @cursor = Mongo::Cursor.new(view, result, server, session: session)
               end
             end
           end
-
           if block_given?
-            if limit && limit != -1
+            if limit
               @cursor.to_a[0...limit].each do |doc|
                 yield doc
               end
@@ -270,44 +295,19 @@ module Mongoid
         cursor || QueryCache.cache_table[cache_key]
       end
 
-      def get_cursor(result, server, session = nil)
-        if result.cursor_id == 0 || result.cursor_id.nil?
-          cursor = if session
-            CachedCursor.new(view, result, server, session: session)
-          else
-            CachedCursor.new(view, result, server)
-          end
-
-          QueryCache.cache_table[cache_key] = cursor
-        else
-          cursor = if session
-            Mongo::Cursor.new(view, result, server, session: session)
-          else
-            Mongo::Cursor.new(view, result, server)
-          end
-        end
-
-        cursor
-      end
-
       def cache_key
         [ collection.namespace, selector, limit, skip, sort, projection, collation ]
       end
 
       def system_collection?
-        collection.namespace =~ /\Asystem./
-      end
-
-      def driver_supports_cursor_sessions?
-        # Driver versions 2.9 and newer support passing in a session to the
-        # cursor object.
-        (Mongo::VERSION.split('.').map(&:to_i) <=> [2, 9, 0]) > 0
+        collection.name.start_with?('system.')
       end
     end
 
     # Adds behavior to the query cache for collections.
     #
     # @since 5.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module Collection
       extend ActiveSupport::Concern
 
@@ -326,6 +326,8 @@ module Mongoid
   end
 end
 
-Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
-Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
-Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
+unless defined?(Mongo::QueryCache)
+  Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
+  Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
+  Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
+end