mongoid 7.1.11 → 7.2.0.rc1

data/lib/mongoid/fields/validators/macro.rb

@@ -39,7 +39,8 @@ module Mongoid
         #
         # @since 3.0.0
         def validate(klass, name, options)
-          validate_name(klass, name, options)
+          validate_field_name(klass, name)
+          validate_name_uniqueness(klass, name, options)
           validate_options(klass, name, options)
         end
 
@@ -61,28 +62,40 @@ module Mongoid
           end
         end
 
-        private
-
-        # Determine if the field name is allowed, if not raise an error.
-        #
-        # @api private
+        # Determine if the field name is valid, if not raise an error.
         #
         # @example Check the field name.
-        #   Macro.validate_name(Model, :name)
+        #   Macro.validate_field_name(Model, :name)
         #
         # @param [ Class ] klass The model class.
         # @param [ Symbol ] name The field name.
         #
         # @raise [ Errors::InvalidField ] If the name is not allowed.
         #
-        # @since 3.0.0
-        def validate_name(klass, name, options)
+        # @api private
+        def validate_field_name(klass, name)
           [name, "#{name}?".to_sym, "#{name}=".to_sym].each do |n|
             if Mongoid.destructive_fields.include?(n)
               raise Errors::InvalidField.new(klass, n)
             end
           end
+        end
 
+        private
+
+        # Determine if the field name is unique, if not raise an error.
+        #
+        # @example Check the field name.
+        #   Macro.validate_name_uniqueness(Model, :name, {})
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        # @param [ Hash ] options The provided options.
+        #
+        # @raise [ Errors::InvalidField ] If the name is not allowed.
+        #
+        # @api private
+        def validate_name_uniqueness(klass, name, options)
           if !options[:overwrite] && klass.fields.keys.include?(name.to_s)
             if Mongoid.duplicate_fields_exception
               raise Errors::InvalidField.new(klass, name)

data/lib/mongoid/findable.rb

@@ -60,6 +60,16 @@ module Mongoid
       with_default_scope.count
     end
 
+    # Returns an estimated count of records in the database.
+    #
+    # @example Get the count of matching documents.
+    #   Person.estimated_count
+    #
+    # @return [ Integer ] The number of matching documents.
+    def estimated_count
+      with_default_scope.estimated_count
+    end
+
     # Returns true if count is zero
     #
     # @example Are there no saved documents for this model?
@@ -81,20 +91,46 @@ module Mongoid
       with_default_scope.exists?
     end
 
-    # Find a +Document+ in several different ways.
-    #
-    # If a +String+ is provided, it will be assumed that it is a
-    # representation of a Mongo::ObjectID and will attempt to find a single
-    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
-    # it will attempt to find either a single +Document+ or multiples based
-    # on the conditions provided and the first parameter.
-    #
-    # @example Find a single document by an id.
-    #   Person.find(BSON::ObjectId)
-    #
-    # @param [ Array ] args An assortment of finder options.
-    #
-    # @return [ Document, nil, Criteria ] A document or matching documents.
+    # Finds a +Document+ or multiple documents by their _id values.
+    #
+    # If a single non-Array argument is given, this argument is interpreted
+    # as the _id value of a document to find. If there is a matching document
+    # in the database, this document is returned; otherwise, if the
+    # +raise_not_found_error+ Mongoid configuration option is truthy
+    # (which is the default), +Errors::DocumentNotFound+ is raised, and if
+    # +raise_not_found_error+ is falsy, +find+ returns +nil+.
+    #
+    # If multiple arguments are given, or an Array argument is given, the
+    # array is flattened and each array element is interpreted as the _id
+    # value of the document to find. Mongoid then attempts to retrieve all
+    # documents with the provided _id values. The return value is an array
+    # of found documents. Each document appears one time in the returned array,
+    # even if its _id is given multiple times in the argument to +find+.
+    # If the +raise_not_found_error+ Mongoid configuration option is truthy,
+    # +Errors::DocumentNotFound+ exception is raised if any of the specified
+    # _ids were not found in the database. If the ++raise_not_found_error+
+    # Mongoid configuration option is falsy, only those documents which are
+    # found are returned; if no documents are found, the return value is an
+    # empty array.
+    #
+    # Note that MongoDB does not allow the _id field to be an array.
+    #
+    # The argument undergoes customary Mongoid type conversions based on
+    # the type declared for the _id field. By default the _id field is a
+    # +BSON::ObjectId+; this allows strings to be passed to +find+ and the
+    # strings will be transparently converted to +BSON::ObjectId+ instances
+    # during query construction.
+    #
+    # The +find+ method takes into account the default scope defined on the
+    # model class, if any.
+    #
+    # @param [ Object | Array<Object> ] args The _id values to find or an
+    #   array thereof.
+    #
+    # @return [ Document | Array<Document> | nil ] A document or matching documents.
+    #
+    # @raise Errors::DocumentNotFound If not all documents are found and
+    #   the +raise_not_found_error+ Mongoid configuration option is truthy.
     def find(*args)
       with_default_scope.find(*args)
     end

data/lib/mongoid/indexable.rb

@@ -82,8 +82,8 @@ module Mongoid
       #
       # @since 1.0.0
       def add_indexes
-        if hereditary? && !index_keys.include?(_type: 1)
-          index({ _type: 1 }, unique: false, background: true)
+        if hereditary? && !index_keys.include?(self.discriminator_key.to_sym => 1)
+          index({ self.discriminator_key.to_sym => 1 }, unique: false, background: true)
         end
         true
       end

data/lib/mongoid/interceptable.rb

@@ -125,7 +125,7 @@ module Mongoid
     # @return [ Document ] The document
     #
     # @since 2.3.0
-    ruby2_keywords def run_callbacks(kind, *args, &block)
+    def run_callbacks(kind, *args, &block)
       cascadable_children(kind).each do |child|
         if child.run_callbacks(child_callback_type(kind, child), *args) == false
           return false
@@ -234,11 +234,9 @@ module Mongoid
     #   document.halted_callback_hook(filter)
     #
     # @param [ Symbol ] filter The callback that halted.
-    # @param [ Symbol ] name The name of the callback that was halted
-    #   (requires Rails 6.1+)
     #
     # @since 3.0.3
-    def halted_callback_hook(filter, name = nil)
+    def halted_callback_hook(filter)
       @before_callback_halted = true
     end
 

data/lib/mongoid/matchable.rb

@@ -1,24 +1,6 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-require "mongoid/matchable/default"
-require "mongoid/matchable/all"
-require "mongoid/matchable/and"
-require "mongoid/matchable/elem_match"
-require "mongoid/matchable/eq"
-require "mongoid/matchable/exists"
-require "mongoid/matchable/gt"
-require "mongoid/matchable/gte"
-require "mongoid/matchable/in"
-require "mongoid/matchable/lt"
-require "mongoid/matchable/lte"
-require "mongoid/matchable/ne"
-require "mongoid/matchable/nin"
-require "mongoid/matchable/nor"
-require "mongoid/matchable/or"
-require "mongoid/matchable/regexp"
-require "mongoid/matchable/size"
-
 module Mongoid
 
   # This module contains all the behavior for Ruby implementations of MongoDB
@@ -28,27 +10,6 @@ module Mongoid
   module Matchable
     extend ActiveSupport::Concern
 
-    # Hash lookup for the matcher for a specific operation.
-    #
-    # @since 1.0.0
-    MATCHERS = {
-      "$all" => All,
-      "$and" => And,
-      "$elemMatch" => ElemMatch,
-      "$eq" => Eq,
-      "$exists" => Exists,
-      "$gt" => Gt,
-      "$gte" => Gte,
-      "$in" => In,
-      "$lt" => Lt,
-      "$lte" => Lte,
-      "$ne" => Ne,
-      "$nin" => Nin,
-      "$nor" => Nor,
-      "$or" => Or,
-      "$size" => Size,
-    }.with_indifferent_access.freeze
-
     # Determines if this document has the attributes to match the supplied
     # MongoDB selector. Used for matching on embedded associations.
     #
@@ -61,116 +22,7 @@ module Mongoid
     #
     # @since 1.0.0
     def _matches?(selector)
-      selector.each_pair do |key, value|
-        if value.is_a?(Hash)
-          value.each do |item|
-            if item[0].to_s == "$not".freeze
-              item = item[1]
-              return false if matcher(key, item)._matches?(item)
-            else
-              return false unless matcher(key, Hash[*item])._matches?(Hash[*item])
-            end
-          end
-        else
-          return false unless matcher(key, value)._matches?(value)
-        end
-      end
-      true
-    end
-
-    private
-
-    # Get the matcher for the supplied key and value. Will determine the class
-    # name from the key.
-    #
-    # @example Get the matcher.
-    #   document.matcher(:title, { "$in" => [ "test" ] })
-    #
-    # @param [ Symbol, String ] key The field name.
-    # @param [ Object, Hash ] value The value or selector.
-    #
-    # @return [ Matcher ] The matcher.
-    #
-    # @since 2.0.0.rc.7
-    # @api private
-    def matcher(key, value)
-      Matchable.matcher(self, key, value)
-    end
-
-    class << self
-
-      # Get the matcher for the supplied key and value. Will determine the class
-      # name from the key.
-      #
-      # @api private
-      #
-      # @example Get the matcher.
-      #   Matchable.matcher(document, :title, { "$in" => [ "test" ] })
-      #
-      # @param [ Document ] document The document to check.
-      # @param [ Symbol, String ] key The field name.
-      # @param [ Object, Hash ] value The value or selector.
-      #
-      # @return [ Matcher ] The matcher.
-      #
-      # @since 2.0.0.rc.7
-      def matcher(document, key, value)
-        if value.is_a?(Hash)
-          matcher = MATCHERS[value.keys.first]
-          if matcher
-            matcher.new(extract_attribute(document, key))
-          else
-            Default.new(extract_attribute(document, key))
-          end
-        elsif value.regexp?
-          Regexp.new(extract_attribute(document, key))
-        else
-          case key.to_s
-            when "$or" then Or.new(value, document)
-            when "$and" then And.new(value, document)
-            when "$nor" then Nor.new(value, document)
-            else Default.new(extract_attribute(document, key))
-          end
-        end
-      end
-
-      private
-
-      # Extract the attribute from the key, being smarter about dot notation.
-      #
-      # @api private
-      #
-      # @example Extract the attribute.
-      #   strategy.extract_attribute(doc, "info.field")
-      #
-      # @param [ Document ] document The document.
-      # @param [ String ] key The key.
-      #
-      # @return [ Object ] The value of the attribute.
-      #
-      # @since 2.2.1
-      # @api private
-      def extract_attribute(document, key)
-        if (key_string = key.to_s) =~ /.+\..+/
-          key_string.split('.').inject(document.send(:as_attributes)) do |_attribs, _key|
-            if _attribs.is_a?(::Array)
-              if _key =~ /\A\d+\z/ && _attribs.none? {|doc| doc.is_a?(Hash)}
-                _attribs.try(:[], _key.to_i)
-              else
-                _attribs.map { |doc| doc.try(:[], _key) }
-              end
-            else
-              _attribs.try(:[], _key)
-            end
-          end
-        else
-          if document.is_a?(Hash)
-            document[key_string]
-          else
-            document.attributes[key_string]
-          end
-        end
-      end
+      Matcher::Expression.matches?(self, selector)
     end
   end
 end

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