mongoid 6.4.8 → 7.0.13

data/lib/mongoid/errors/invalid_relation_option.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Mongoid
+  module Errors
+
+    # Raised when an option provided for a relation is invalid.
+    class InvalidRelationOption < MongoidError
+
+      # Create the new error.
+      #
+      # @example Create the new error.
+      #   InvalidRelationOption.new(Person, invalid_option: 'make_me_a_sandwich')
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String, Symbol ] name The relation name.
+      # @param [ Symbol ] option The invalid option.
+      # @param [ Array<Symbol> ] valid_options The valid option.
+      #
+      # @since 3.0.0
+      def initialize(klass, name, option, valid_options)
+        super(
+            compose_message(
+                "invalid_relation_option",
+                { klass: klass, name: name, option: option, valid_options: valid_options }
+            )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/unknown_model.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid
+  module Errors
+
+    # This error is raised when trying to instantiate a model object from the value in
+    # the '_type' field of a document and the class doesn't exist.
+    class UnknownModel < MongoidError
+
+      # Create the new error.
+      #
+      # @example Instantiate the error.
+      #   UnknownModel.new('InvalidClass', "invalid_class")
+      #
+      # @param [ String ] klass The model class.
+      # @param [ String ] value The value used to determine the (invalid) class.
+      #
+      # @since 7.0.0
+      def initialize(klass, value)
+        super(
+            compose_message("unknown_model", { klass: klass, value: value })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors.rb

@@ -8,6 +8,7 @@ require "mongoid/errors/eager_load"
 require "mongoid/errors/in_memory_collation_not_supported"
 require "mongoid/errors/invalid_collection"
 require "mongoid/errors/invalid_config_option"
+require "mongoid/errors/invalid_dependent_strategy"
 require "mongoid/errors/invalid_field"
 require "mongoid/errors/invalid_field_option"
 require "mongoid/errors/invalid_find"
@@ -17,6 +18,7 @@ require "mongoid/errors/invalid_options"
 require "mongoid/errors/invalid_path"
 require "mongoid/errors/invalid_persistence_option"
 require "mongoid/errors/invalid_relation"
+require "mongoid/errors/invalid_relation_option"
 require "mongoid/errors/invalid_scope"
 require "mongoid/errors/invalid_session_use"
 require "mongoid/errors/invalid_set_polymorphic_relation"
@@ -42,6 +44,7 @@ require "mongoid/errors/readonly_document"
 require "mongoid/errors/scope_overwrite"
 require "mongoid/errors/too_many_nested_attribute_records"
 require "mongoid/errors/unknown_attribute"
+require "mongoid/errors/unknown_model"
 require "mongoid/errors/unsaved_document"
 require "mongoid/errors/unsupported_javascript"
 require "mongoid/errors/validations"

data/lib/mongoid/extensions/array.rb

@@ -122,22 +122,22 @@ module Mongoid
 
       module ClassMethods
 
-        # Convert the provided object to a propery array of foreign keys.
+        # Convert the provided object to a proper array of foreign keys.
         #
         # @example Mongoize the object.
         #   Array.__mongoize_fk__(constraint, object)
         #
-        # @param [ Constraint ] constraint The metadata constraint.
+        # @param [ Association ] association The association metadata.
         # @param [ Object ] object The object to convert.
         #
         # @return [ Array ] The array of ids.
         #
         # @since 3.0.0
-        def __mongoize_fk__(constraint, object)
+        def __mongoize_fk__(association, object)
           if object.resizable?
-            object.blank? ? object : constraint.convert(object)
+            object.blank? ? object : association.convert_to_foreign_key(object)
           else
-            object.blank? ? [] : constraint.convert(Array(object))
+            object.blank? ? [] : association.convert_to_foreign_key(Array(object))
           end
         end
 

data/lib/mongoid/extensions/hash.rb

@@ -46,9 +46,11 @@ module Mongoid
             value.each_pair do |_key, _value|
               value[_key] = (key == "$rename") ? _value.to_s : mongoize_for(key, klass, _key, _value)
             end
-            (consolidated[key] ||= {}).merge!(value)
+            consolidated[key] ||= {}
+            consolidated[key].update(value)
           else
-            (consolidated["$set"] ||= {}).merge!(key => mongoize_for(key, klass, key, value))
+            consolidated["$set"] ||= {}
+            consolidated["$set"].update(key => mongoize_for(key, klass, key, value))
           end
         end
         consolidated
@@ -106,8 +108,11 @@ module Mongoid
         value = self
         keys.each do |key|
           return nil if value.nil?
-          nested = value[key] || value[key.to_i]
-          value = nested
+          value_for_key = value[key]
+          if value_for_key.nil? && key.to_i.to_s == key
+            value_for_key = value[key.to_i]
+          end
+          value = value_for_key
         end
         value
       end

data/lib/mongoid/extensions/object.rb

@@ -225,17 +225,17 @@ module Mongoid
         # contstraint.
         #
         # @example Convert the object to a fk.
-        #   Object.__mongoize_fk__(constraint, object)
+        #   Object.__mongoize_fk__(association, object)
         #
-        # @param [ Constraint ] constraint The constraint.
+        # @param [ Association ] association The association metadata.
         # @param [ Object ] object The object to convert.
         #
         # @return [ Object ] The converted object.
         #
         # @since 3.0.0
-        def __mongoize_fk__(constraint, object)
+        def __mongoize_fk__(association, object)
           return nil if !object || object == ""
-          constraint.convert(object)
+          association.convert_to_foreign_key(object)
         end
 
         # Convert the object from its mongo friendly ruby type to this type.

data/lib/mongoid/extensions/range.rb

@@ -70,6 +70,7 @@ module Mongoid
         def mongoize(object)
           return nil if object.nil?
           return object if object.is_a?(::Hash)
+          return object if object.is_a?(String)
           hash = { "min" => object.first, "max" => object.last }
           if object.respond_to?(:exclude_end?) && object.exclude_end?
             hash.merge!("exclude_end" => true)

data/lib/mongoid/extensions/regexp.rb

@@ -9,7 +9,7 @@ module Mongoid
         # type.
         #
         # @example Mongoize the object.
-        #   Regexp.mongoize(/^[abc]/)
+        #   Regexp.mongoize(/\A[abc]/)
         #
         # @param [ Regexp, String ] object The object to mongoize.
         #

data/lib/mongoid/extensions/string.rb

@@ -69,7 +69,7 @@ module Mongoid
       #
       # @since 2.3.1
       def mongoid_id?
-        self =~ /\A(|_)id$/
+        self =~ /\A(|_)id\z/
       end
 
       # Is the string a number? The literals "NaN", "Infinity", and "-Infinity"
@@ -96,7 +96,7 @@ module Mongoid
       #
       # @since 1.0.0
       def reader
-        delete("=").sub(/\_before\_type\_cast$/, '')
+        delete("=").sub(/\_before\_type\_cast\z/, '')
       end
 
       # Is this string a writer?

data/lib/mongoid/extensions.rb

@@ -5,10 +5,6 @@ class BSON::ObjectId
   end
 end
 
-class Symbol
-  remove_method :size if instance_methods.include? :size # temporal fix for ruby 1.9
-end
-
 class BSON::Document
   # We need to override this as ActiveSupport creates a new Object, instead of a new Hash
   # see https://github.com/rails/rails/commit/f1bad130d0c9bd77c94e43b696adca56c46a66aa

data/lib/mongoid/factory.rb

@@ -38,12 +38,22 @@ module Mongoid
     #   #only we give the document a list of the selected fields.
     #
     # @return [ Document ] The instantiated document.
-    def from_db(klass, attributes = nil, selected_fields = nil)
+    def from_db(klass, attributes = nil, criteria = nil)
+      selected_fields = criteria.options[:fields] if criteria
       type = (attributes || {})[TYPE]
       if type.blank?
-        klass.instantiate(attributes, selected_fields)
+        obj = klass.instantiate(attributes, selected_fields)
+        if criteria && criteria.association && criteria.parent_document
+          obj.set_relation(criteria.association.inverse, criteria.parent_document)
+        end
+        obj
       else
-        type.camelize.constantize.instantiate(attributes, selected_fields)
+        camelized = type.camelize
+        begin
+          camelized.constantize.instantiate(attributes, selected_fields)
+        rescue NameError
+          raise Errors::UnknownModel.new(camelized, type)
+        end
       end
     end
   end

data/lib/mongoid/fields/foreign_key.rb

@@ -63,8 +63,8 @@ module Mongoid
       # @since 3.0.0
       def evolve(object)
         if object_id_field? || object.is_a?(Document)
-          if metadata.polymorphic? && constraint
-            constraint.convert(object)
+          if association.polymorphic?
+            association.convert_to_foreign_key(object)
           else
             object.__evolve_object_id__
           end
@@ -97,7 +97,7 @@ module Mongoid
       # @since 3.0.0
       def mongoize(object)
         if type.resizable? || object_id_field?
-          type.__mongoize_fk__(constraint, object)
+          type.__mongoize_fk__(association, object)
         else
           related_id_field.mongoize(object)
         end
@@ -113,7 +113,7 @@ module Mongoid
       # @since 2.2.0
       def object_id_field?
         @object_id_field ||=
-          metadata.polymorphic? ? true : metadata.klass.using_object_ids?
+            association.polymorphic? ? true : association.klass.using_object_ids?
       end
 
       # Returns true if an array, false if not.
@@ -156,7 +156,7 @@ module Mongoid
       #
       # @since 3.0.0
       def related_id_field
-        @related_id_field ||= metadata.klass.fields["_id"]
+        @related_id_field ||= association.klass.fields["_id"]
       end
 
       # This is used when default values need to be serialized. Most of the

data/lib/mongoid/fields/standard.rb

@@ -26,18 +26,6 @@ module Mongoid
         mods[key] = new
       end
 
-      # Get the constraint from the metadata once.
-      #
-      # @example Get the constraint.
-      #   field.constraint
-      #
-      # @return [ Constraint ] The relation's contraint.
-      #
-      # @since 2.1.0
-      def constraint
-        @constraint ||= metadata.constraint
-      end
-
       # Evaluate the default value and return it. Will handle the
       # serialization, proc calls, and duplication if necessary.
       #
@@ -127,8 +115,8 @@ module Mongoid
       # @return [ Metadata ] The relation metadata.
       #
       # @since 2.2.0
-      def metadata
-        @metadata ||= options[:metadata]
+      def association
+        @association ||= options[:association]
       end
 
       # Is the field a BSON::ObjectId?

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

@@ -14,7 +14,7 @@ module Mongoid
           :label,
           :localize,
           :fallbacks,
-          :metadata,
+          :association,
           :pre_processed,
           :subtype,
           :type,

data/lib/mongoid/fields.rb

@@ -411,7 +411,7 @@ module Mongoid
       def create_field_getter(name, meth, field)
         generated_methods.module_eval do
           re_define_method(meth) do
-            raw = read_attribute(name)
+            raw = read_raw_attribute(name)
             if lazy_settable?(field, raw)
               write_attribute(name, field.eval_default(self))
             else
@@ -461,7 +461,7 @@ module Mongoid
           re_define_method("#{meth}=") do |value|
             val = write_attribute(name, value)
             if field.foreign_key?
-              remove_ivar(field.metadata.name)
+              remove_ivar(field.association.name)
             end
             val
           end
@@ -480,7 +480,7 @@ module Mongoid
       def create_field_check(name, meth)
         generated_methods.module_eval do
           re_define_method("#{meth}?") do
-            value = read_attribute(name)
+            value = read_raw_attribute(name)
             lookup_attribute_presence(name, value)
           end
         end
@@ -498,7 +498,8 @@ module Mongoid
       def create_translations_getter(name, meth)
         generated_methods.module_eval do
           re_define_method("#{meth}_translations") do
-            (attributes[name] ||= {}).with_indifferent_access
+            attributes[name] ||= {}
+            attributes[name].with_indifferent_access
           end
           alias_method :"#{meth}_t", :"#{meth}_translations"
         end

data/lib/mongoid/indexable.rb

@@ -28,8 +28,11 @@ module Mongoid
       # @since 1.0.0
       def create_indexes
         return unless index_specifications
+
+        default_options = {background: Config.background_indexing}
+
         index_specifications.each do |spec|
-          key, options = spec.key, spec.options
+          key, options = spec.key, default_options.merge(spec.options)
           if database = options[:database]
             with(database: database) do |klass|
               klass.collection.indexes(session: _session).create_one(key, options.except(:database))

data/lib/mongoid/interceptable.rb

@@ -160,8 +160,8 @@ module Mongoid
     #
     # @since 2.3.0
     def cascadable_children(kind, children = Set.new)
-      embedded_relations.each_pair do |name, metadata|
-        next unless metadata.cascading_callbacks?
+      embedded_relations.each_pair do |name, association|
+        next unless association.cascading_callbacks?
         without_autobuild do
           delayed_pulls = delayed_atomic_pulls[name]
           delayed_unsets = delayed_atomic_unsets[name]
@@ -170,7 +170,7 @@ module Mongoid
           relation = send(name)
           Array.wrap(relation).each do |child|
             next if children.include?(child)
-            children.add(child) if cascadable_child?(kind, child, metadata)
+            children.add(child) if cascadable_child?(kind, child, association)
             child.send(:cascadable_children, kind, children)
           end
         end
@@ -189,9 +189,9 @@ module Mongoid
     # @return [ true, false ] If the child should fire the callback.
     #
     # @since 2.3.0
-    def cascadable_child?(kind, child, metadata)
+    def cascadable_child?(kind, child, association)
       return false if kind == :initialize || kind == :find || kind == :touch
-      return false if kind == :validate && metadata.validate?
+      return false if kind == :validate && association.validate?
       child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
     end
 
@@ -228,9 +228,11 @@ 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)
+    def halted_callback_hook(filter, name = nil)
       @before_callback_halted = true
     end
 

data/lib/mongoid/matchable/all.rb

@@ -10,11 +10,12 @@ module Mongoid
       # @example Do the values match?
       #   matcher._matches?({ :key => 10 })
       #
-      # @param [ Hash ] value The values to check.
+      # @param [ Hash ] condition The condition to evaluate. This must be
+      #   a one-element hash like {'$gt' => 1}.
       #
       # @return [ true, false ] If the values match.
-      def _matches?(value)
-        first = first(value)
+      def _matches?(condition)
+        first = condition_value(condition)
         return false if first.is_a?(Array) && first.empty?
 
         attribute_array = Array.wrap(@attribute)

data/lib/mongoid/matchable/and.rb

@@ -2,7 +2,7 @@
 module Mongoid
   module Matchable
 
-    # Defines behavior for handling $or expressions in embedded documents.
+    # Defines behavior for handling $and expressions in embedded documents.
     class And < Default
 
       # Does the supplied query match the attribute?

data/lib/mongoid/matchable/default.rb

@@ -20,52 +20,99 @@ module Mongoid
         @attribute, @document = attribute, document
       end
 
-      # Return true if the attribute and value are equal, or if it is an array
-      # if the value is included.
+      # Checks whether the attribute matches the value, using the default
+      # MongoDB matching logic (i.e., when no operator is specified in the
+      # criteria).
       #
-      # @example Does this value match?
-      #   default._matches?("value")
+      # If attribute and value are both of basic types like string or number,
+      # this method returns true if and only if the attribute equals the value.
       #
-      # @param [ Object ] value The value to check if it matches.
+      # Value can also be of a type like Regexp or Range which defines
+      # more complex matching/inclusion behavior via the === operator.
+      # If so, and attribute is still of a basic type like string or number,
+      # this method returns true if and only if the value's === operator
+      # returns true for the attribute. For example, this method returns true
+      # if attribute is a string and value is a Regexp and attribute matches
+      # the value, of if attribute is a number and value is a Range and
+      # the value includes the attribute.
       #
-      # @return [ true, false ] True if matches, false if not.
+      # If attribute is an array and value is not an array, the checks just
+      # described (i.e. the === operator invocation) are performed on each item
+      # of the attribute array. If any of the items in the attribute match
+      # the value according to the value type's === operator, this method
+      # returns true.
+      #
+      # If attribute and value are both arrays, this method returns true if and
+      # only if the arrays are equal (including the order of the elements).
+      #
+      # @param [ Object ] value The value to check.
+      #
+      # @return [ true, false ] True if attribute matches the value, false if not.
       #
       # @since 1.0.0
       def _matches?(value)
-        attribute.is_a?(Array) && !value.is_a?(Array) ? attribute.any? { |_attribute| value === _attribute } : value === attribute
+        if attribute.is_a?(Array) && !value.is_a?(Array)
+          attribute.any? { |_attribute| value === _attribute }
+        else
+          value === attribute
+        end
       end
 
       protected
 
-      # Convenience method for getting the first value in a hash.
+      # Given a condition, which is a one-element hash consisting of an
+      # operator and a value like {'$gt' => 1}, return the value.
       #
-      # @example Get the first value.
-      #   matcher.first(:test => "value")
+      # @example Get the condition value.
+      #   matcher.condition_value({'$gt' => 1})
+      #   # => 1
       #
-      # @param [ Hash ] hash The has to pull from.
+      # @param [ Hash ] condition The condition.
       #
-      # @return [ Object ] The first value.
+      # @return [ Object ] The value of the condition.
       #
       # @since 1.0.0
-      def first(hash)
-        hash.values.first
+      def condition_value(condition)
+        unless condition.is_a?(Hash)
+          raise ArgumentError, 'Condition must be a hash'
+        end
+
+        unless condition.length == 1
+          raise ArgumentError, 'Condition must have one element'
+        end
+
+        condition.values.first
       end
 
-      # If object exists then compare the two, otherwise return false
+      # Determines whether the attribute value stored in this matcher
+      # satisfies the provided condition using the provided operator.
+      #
+      # For example, given an instance of Gt matcher with the @attribute of
+      # 2, the matcher is set up to answer whether the attribute is
+      # greater than some input value. This input value is provided in
+      # the condition, which could be {"$gt" => 1}, and the operator is
+      # provided (somewhat in a duplicate fashion) in the operator argument,
+      # in this case :>.
       #
-      # @example Determine if we can compare.
-      #   matcher.determine("test", "$in")
+      # @example
+      #   matcher = Matchable::Gt.new(2)
+      #   matcher.determine({'$gt' => 1}, :>)
+      #   # => true
       #
-      # @param [ Object ] value The value to compare with.
-      # @param [ Symbol, String ] operator The comparison operation.
+      # @param [ Hash ] condition The condition to evaluate. This must be
+      #   a one-element hash; the key is ignored, and the value is passed
+      #   as the argument to the operator.
+      # @param [ Symbol, String ] operator The comparison operator or method.
+      #   The operator is invoked on the attribute stored in the matcher
+      #   instance.
       #
-      # @return [ true, false ] The comparison or false.
+      # @return [ true, false ] Result of condition evaluation.
       #
       # @since 1.0.0
-      def determine(value, operator)
-        attribute.__array__.any? {|attr|
-          attr ? attr.send(operator, first(value)) : false
-        }
+      def determine(condition, operator)
+        attribute.__array__.any? do |attr|
+          attr && attr.send(operator, condition_value(condition))
+        end
       end
     end
   end

data/lib/mongoid/matchable/elem_match.rb

@@ -13,13 +13,19 @@ module Mongoid
       #
       # @return [ true, false ] If the values match.
       def _matches?(value)
-        if !@attribute.is_a?(Array) || !value.kind_of?(Hash) || !value["$elemMatch"].kind_of?(Hash)
+        elem_match = value["$elemMatch"] || value[:$elemMatch]
+
+        if !@attribute.is_a?(Array) || !value.kind_of?(Hash) || !elem_match.kind_of?(Hash)
           return false
         end
 
         return @attribute.any? do |sub_document|
-          value["$elemMatch"].all? do |k, v|
-            Matchable.matcher(sub_document, k, v)._matches?(v)
+          elem_match.all? do |k, v|
+            if v.try(:first).try(:[],0) == "$not".freeze || v.try(:first).try(:[],0) == :$not
+              !Matchable.matcher(sub_document, k, v.first[1])._matches?(v.first[1])
+            else
+              Matchable.matcher(sub_document, k, v)._matches?(v)
+            end
           end
         end
       end

data/lib/mongoid/matchable/eq.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs equivalency checks.
+    class Eq < Default
+
+      # Return true if the attribute and first value are equal.
+      #
+      # @example Do the values match?
+      #   matcher._matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      def _matches?(value)
+        super(value.values.first)
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/ne.rb

@@ -12,7 +12,7 @@ module Mongoid
       #
       # @param [ Hash ] value The values to check.
       #
-      # @return [ true, false ] If a value exists.
+      # @return [ true, false ] True if matches, false if not.
       def _matches?(value)
         !super(value.values.first)
       end

data/lib/mongoid/matchable/regexp.rb

@@ -7,8 +7,8 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher._matches?(/^Em/)
-      #   matcher._matches?(BSON::Regex::Raw.new("^Em"))
+      #   matcher._matches?(/\AEm/)
+      #   matcher._matches?(BSON::Regex::Raw.new("\\AEm"))
       #
       # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
       #