mongoid 6.4.8 → 7.0.13

data/lib/mongoid/matchable.rb

@@ -2,6 +2,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"
@@ -10,15 +12,14 @@ require "mongoid/matchable/lt"
 require "mongoid/matchable/lte"
 require "mongoid/matchable/ne"
 require "mongoid/matchable/nin"
-require "mongoid/matchable/or"
 require "mongoid/matchable/nor"
-require "mongoid/matchable/size"
-require "mongoid/matchable/elem_match"
+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
+  # This module contains all the behavior for Ruby implementations of MongoDB
   # selectors.
   #
   # @since 4.0.0
@@ -30,8 +31,9 @@ module Mongoid
     # @since 1.0.0
     MATCHERS = {
       "$all" => All,
-      "$elemMatch" => ElemMatch,
       "$and" => And,
+      "$elemMatch" => ElemMatch,
+      "$eq" => Eq,
       "$exists" => Exists,
       "$gt" => Gt,
       "$gte" => Gte,
@@ -40,9 +42,9 @@ module Mongoid
       "$lte" => Lte,
       "$ne" => Ne,
       "$nin" => Nin,
-      "$or" => Or,
       "$nor" => Nor,
-      "$size" => Size
+      "$or" => Or,
+      "$size" => Size,
     }.with_indifferent_access.freeze
 
     # Determines if this document has the attributes to match the supplied
@@ -62,13 +64,13 @@ module Mongoid
           value.each do |item|
             if item[0].to_s == "$not".freeze
               item = item[1]
-              return false if matcher(self, key, item)._matches?(item)
+              return false if matcher(key, item)._matches?(item)
             else
-              return false unless matcher(self, key, Hash[*item])._matches?(Hash[*item])
+              return false unless matcher(key, Hash[*item])._matches?(Hash[*item])
             end
           end
         else
-          return false unless matcher(self, key, value)._matches?(value)
+          return false unless matcher(key, value)._matches?(value)
         end
       end
       true
@@ -79,20 +81,18 @@ module Mongoid
     # Get the matcher for the supplied key and value. Will determine the class
     # name from the key.
     #
-    # @api private
-    #
     # @example Get the matcher.
     #   document.matcher(: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)
-      Matchable.matcher(document, key, value)
+    # @api private
+    def matcher(key, value)
+      Matchable.matcher(self, key, value)
     end
 
     class << self
@@ -103,7 +103,7 @@ module Mongoid
       # @api private
       #
       # @example Get the matcher.
-      #   document.matcher(:title, { "$in" => [ "test" ] })
+      #   Matchable.matcher(document, :title, { "$in" => [ "test" ] })
       #
       # @param [ Document ] document The document to check.
       # @param [ Symbol, String ] key The field name.
@@ -147,6 +147,7 @@ module Mongoid
       # @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|

data/lib/mongoid/persistable/deletable.rb

@@ -21,10 +21,12 @@ module Mongoid
       def delete(options = {})
         raise Errors::ReadonlyDocument.new(self.class) if readonly?
         prepare_delete do
-          if embedded?
-            delete_as_embedded(options)
-          else
-            delete_as_root
+          unless options[:persist] == false
+            if embedded?
+              delete_as_embedded(options)
+            else
+              delete_as_root
+            end
           end
         end
       end
@@ -113,11 +115,10 @@ module Mongoid
       #
       # @since 4.0.0
       def prepare_delete
-        cascade!
+        return false unless catch(:abort) { apply_delete_dependencies! }
         yield(self)
         freeze
         self.destroyed = true
-        true
       end
 
       module ClassMethods

data/lib/mongoid/persistable/incrementable.rb

@@ -28,7 +28,7 @@ module Mongoid
             attributes[field] = (current || 0) + increment
             ops[atomic_attribute_name(field)] = increment
           end
-          { "$inc" => ops }
+          { "$inc" => ops } unless ops.empty?
         end
       end
     end

data/lib/mongoid/persistable/logical.rb

@@ -30,7 +30,7 @@ module Mongoid
             attributes[field] = value
             ops[atomic_attribute_name(field)] = values
           end
-          { "$bit" => ops }
+          { "$bit" => ops } unless ops.empty?
         end
       end
     end

data/lib/mongoid/persistable/pushable.rb

@@ -22,7 +22,13 @@ module Mongoid
       def add_to_set(adds)
         prepare_atomic_operation do |ops|
           process_atomic_operations(adds) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || attributes[field]
+            if existing.nil?
+              attributes[field] = []
+              # Read the value out of attributes:
+              # https://jira.mongodb.org/browse/MONGOID-4874
+              existing = attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each do |val|
               existing.push(val) unless existing.include?(val)
@@ -49,7 +55,10 @@ module Mongoid
       def push(pushes)
         prepare_atomic_operation do |ops|
           process_atomic_operations(pushes) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || begin
+              attributes[field] ||= []
+              attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each{ |val| existing.push(val) }
             ops[atomic_attribute_name(field)] = { "$each" => values }

data/lib/mongoid/persistable/settable.rb

@@ -14,6 +14,34 @@ module Mongoid
       # @example Set the values.
       #   document.set(title: "sir", dob: Date.new(1970, 1, 1))
       #
+      # The key can be a dotted sequence of keys, in which case the
+      # top level field is treated as a nested hash and any missing keys
+      # are created automatically:
+      #
+      # @example Set the values using nested hash semantics.
+      #   document.set('author.title' => 'Sir')
+      #   # => document.author == {'title' => 'Sir'}
+      #
+      # Performing a nested set like this merges values of intermediate keys:
+      #
+      # @example Nested hash value merging.
+      #   document.set('author.title' => 'Sir')
+      #   document.set('author.name' => 'Linus Torvalds')
+      #   # => document.author == {'title' => 'Sir', 'name' => 'Linus Torvalds'}
+      #
+      # If the top level field was not a hash, its original value is discarded
+      # and the field is replaced with a hash.
+      #
+      # @example Nested hash overwriting a non-hash value.
+      #   document.set('author' => 'John Doe')
+      #   document.set('author.title' => 'Sir')
+      #   # => document.author == {'title' => 'Sir'}
+      #
+      # Note that unlike MongoDB's $set, Mongoid's set writes out the entire
+      # field even when setting a subset of the field via the nested hash
+      # semantics. This means performing a $set with nested hash semantics
+      # can overwrite other hash keys within the top level field in the database.
+      #
       # @param [ Hash ] setters The field/value pairs to set.
       #
       # @return [ Document ] The document.
@@ -23,16 +51,38 @@ module Mongoid
         prepare_atomic_operation do |ops|
           process_atomic_operations(setters) do |field, value|
 
-            field_and_value_hash = hasherizer(field.split('.'), value)
-            field = field_and_value_hash.keys.first.to_s
-            value = field_and_value_hash[field]
+            field_seq = field.to_s.split('.')
+            field = field_seq.shift
+            if field_seq.length > 0
+              # nested hash path
+              old_value = attributes[field]
+
+              # if the old value is not a hash, clobber it
+              unless Hash === old_value
+                old_value = {}
+              end
+
+              # descend into the hash, creating intermediate keys as needed
+              cur_value = old_value
+              while field_seq.length > 1
+                cur_key = field_seq.shift
+                # clobber on each level if type is not a hash
+                unless Hash === cur_value[cur_key]
+                  cur_value[cur_key] = {}
+                end
+                cur_value = cur_value[cur_key]
+              end
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field) && Hash === value && !value.empty?
-              merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = (attributes[field] || {}).merge(value, &merger)
+              # now we are on the leaf level, perform the set
+              # and overwrite whatever was on this level before
+              cur_value[field_seq.shift] = value
+
+              # and set value to the value of the top level field
+              # because this is what we pass to $set
+              value = old_value
             end
 
-            process_attribute(field.to_s, value)
+            process_attribute(field, value)
 
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
@@ -42,10 +92,5 @@ module Mongoid
         end
       end
     end
-
-    def hasherizer(keys, value)
-      return value if keys.empty?
-      {}.tap { |hash| hash[keys.shift] = hasherizer(keys, value) }
-    end
   end
 end

data/lib/mongoid/persistable.rb

@@ -162,10 +162,9 @@ module Mongoid
     # @since 4.0.0
     def process_atomic_operations(operations)
       operations.each do |field, value|
-        as_writable_attribute!(field, value) do |access|
-          yield(access, value)
-          remove_change(access)
-        end
+        access = database_field_name(field)
+        yield(access, value)
+        remove_change(access)
       end
     end
 
@@ -202,7 +201,7 @@ module Mongoid
     #
     # @since 4.0.0
     def persist_atomic_operations(operations)
-      if persisted? && operations
+      if persisted? && operations && !operations.empty?
         selector = atomic_selector
         _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
       end

data/lib/mongoid/persistence_context.rb

@@ -116,6 +116,12 @@ module Mongoid
                     client.with(client_options))
     end
 
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
     # Determine if this persistence context is equal to another.
     #
     # @example Compare two persistence contexts.
@@ -133,12 +139,6 @@ module Mongoid
 
     private
 
-    def client_name
-      @client_name ||= options[:client] ||
-                         Threaded.client_override ||
-                         storage_options && __evaluate__(storage_options[:client])
-    end
-
     def set_options!(opts)
       @options ||= opts.each.reduce({}) do |_options, (key, value)|
                      unless VALID_OPTIONS.include?(key.to_sym)
@@ -169,6 +169,9 @@ module Mongoid
 
       # Set the persistence context for a particular class or model instance.
       #
+      # If there already is a persistence context set, options in the existing
+      # context are combined with options given to the set call.
+      #
       # @example Set the persistence context for a class or model instance.
       #  PersistenceContext.set(model)
       #
@@ -180,9 +183,19 @@ module Mongoid
       #
       # @since 6.0.0
       def set(object, options_or_context)
-        context = PersistenceContext.new(object, options_or_context.is_a?(PersistenceContext) ?
-                                                   options_or_context.options : options_or_context)
-        Thread.current["[mongoid][#{object.object_id}]:context"] = context
+        key = "[mongoid][#{object.object_id}]:context"
+        existing_context = Thread.current[key]
+        existing_options = if existing_context
+          existing_context.options
+        else
+          {}
+        end
+        if options_or_context.is_a?(PersistenceContext)
+          options_or_context = options_or_context.options
+        end
+        new_options = existing_options.merge(options_or_context)
+        context = PersistenceContext.new(object, new_options)
+        Thread.current[key] = context
       end
 
       # Get the persistence context for a particular class or model instance.
@@ -206,14 +219,16 @@ module Mongoid
       #
       # @param [ Class, Object ] object The class or model instance.
       # @param [ Mongo::Cluster ] cluster The original cluster before this context was used.
+      # @param [ Mongoid::PersistenceContext ] original_context The original persistence
+      #   context that was set before this context was used.
       #
       # @since 6.0.0
-      def clear(object, cluster = nil)
+      def clear(object, cluster = nil, original_context = nil)
         if context = get(object)
           context.client.close unless (context.cluster.equal?(cluster) || cluster.nil?)
         end
       ensure
-        Thread.current["[mongoid][#{object.object_id}]:context"] = nil
+        Thread.current["[mongoid][#{object.object_id}]:context"] = original_context
       end
     end
   end

data/lib/mongoid/positional.rb

@@ -64,7 +64,7 @@ module Mongoid
       matches = position.scan(/\.\d+\./)
       if matches.size == 1
         keys.each do |kk|
-          if position =~ /^#{kk}\.\d+\.(.*)/
+          if position =~ /\A#{kk}\.\d+\.(.*)\z/
             return "#{kk}.$.#{$1}"
           end
         end

data/lib/mongoid/query_cache.rb

@@ -138,7 +138,9 @@ module Mongoid
       # @since 5.0.0
       def each
         if @cached_documents
-          @cached_documents.each{ |doc| yield doc }
+          @cached_documents.each do |doc|
+            yield doc
+          end
         else
           super
         end
@@ -293,7 +295,7 @@ module Mongoid
       end
 
       def system_collection?
-        collection.namespace =~ /^system./
+        collection.namespace =~ /\Asystem./
       end
 
       def driver_supports_cursor_sessions?

data/lib/mongoid/serializable.rb

@@ -101,7 +101,7 @@ module Mongoid
         value = send(name)
         attrs[name] = value ? value.serializable_hash(options) : nil
       elsif names.include?(name) && !fields.key?(name)
-        attrs[name] = read_attribute(name)
+        attrs[name] = read_raw_attribute(name)
       elsif !attribute_missing?(name)
         attrs[name] = send(name)
       end
@@ -124,9 +124,9 @@ module Mongoid
     def serialize_relations(attributes = {}, options = {})
       inclusions = options[:include]
       relation_names(inclusions).each do |name|
-        metadata = relations[name.to_s]
-        if metadata && relation = send(metadata.name)
-          attributes[metadata.name.to_s] =
+        association = relations[name.to_s]
+        if association && relation = send(association.name)
+          attributes[association.name.to_s] =
             relation.serializable_hash(relation_options(inclusions, options, name))
         end
       end

data/lib/mongoid/shardable.rb

@@ -37,7 +37,7 @@ module Mongoid
     def shard_key_selector
       selector = {}
       shard_key_fields.each do |field|
-        selector[field.to_s] = send(field)
+        selector[field.to_s] = new_record? ? send(field) : attribute_was(field)
       end
       selector
     end

data/lib/mongoid/touchable.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+# encoding: utf-8
+module Mongoid
+  module Touchable
+
+    module InstanceMethods
+
+      # Touch the document, in effect updating its updated_at timestamp and
+      # optionally the provided field to the current time. If any belongs_to
+      # relations exist with a touch option, they will be updated as well.
+      #
+      # @example Update the updated_at timestamp.
+      #   document.touch
+      #
+      # @example Update the updated_at and provided timestamps.
+      #   document.touch(:audited)
+      #
+      # @note This will not autobuild relations if those options are set.
+      #
+      # @param [ Symbol ] field The name of an additional field to update.
+      #
+      # @return [ true/false ] false if record is new_record otherwise true.
+      #
+      # @since 3.0.0
+      def touch(field = nil)
+        return false if _root.new_record?
+        current = Time.now
+        field = database_field_name(field)
+        write_attribute(:updated_at, current) if respond_to?("updated_at=")
+        write_attribute(field, current) if field
+
+        touches = touch_atomic_updates(field)
+        unless touches["$set"].blank?
+          selector = atomic_selector
+          _root.collection.find(selector).update_one(positionally(selector, touches), session: _session)
+        end
+        run_callbacks(:touch)
+        true
+      end
+    end
+
+    extend self
+
+    # Add the association to the touchable relations if the touch option was
+    # provided.
+    #
+    # @example Add the touchable.
+    #   Model.define_touchable!(assoc)
+    #
+    # @param [ Association ] association The association metadata.
+    #
+    # @return [ Class ] The model class.
+    #
+    # @since 3.0.0
+    def define_touchable!(association)
+      name = association.name
+      method_name = define_relation_touch_method(name, association)
+      association.inverse_class.tap do |klass|
+        klass.after_save method_name
+        klass.after_destroy method_name
+        klass.after_touch method_name
+      end
+    end
+
+    private
+
+    # Define the method that will get called for touching belongs_to
+    # relations.
+    #
+    # @api private
+    #
+    # @example Define the touch relation.
+    #   Model.define_relation_touch_method(:band)
+    #   Model.define_relation_touch_method(:band, :band_updated_at)
+    #
+    # @param [ Symbol ] name The name of the relation.
+    # @param [ Association ] association The association metadata.
+    #
+    # @since 3.1.0
+    #
+    # @return [ Symbol ] The method name.
+    def define_relation_touch_method(name, association)
+      relation_classes = if association.polymorphic?
+                           association.send(:inverse_association_classes)
+                         else
+                           [ association.relation_class ]
+                         end
+
+      relation_classes.each { |c| c.send(:include, InstanceMethods) }
+      method_name = "touch_#{name}_after_create_or_destroy"
+      association.inverse_class.class_eval <<-TOUCH, __FILE__, __LINE__ + 1
+          def #{method_name}
+            without_autobuild do
+              relation = __send__(:#{name})
+              relation.touch #{":#{association.touch_field}" if association.touch_field} if relation
+            end
+          end
+      TOUCH
+      method_name.to_sym
+    end
+  end
+end

data/lib/mongoid/traversable.rb

@@ -8,7 +8,7 @@ module Mongoid
     extend ActiveSupport::Concern
 
     def _parent
-      @__parent
+      @__parent ||= nil
     end
 
     def _parent=(p)
@@ -40,7 +40,7 @@ module Mongoid
     # @since 2.4.0
     def collect_children
       children = []
-      embedded_relations.each_pair do |name, metadata|
+      embedded_relations.each_pair do |name, association|
         without_autobuild do
           child = send(name)
           Array.wrap(child).each do |doc|
@@ -101,7 +101,7 @@ module Mongoid
     #
     # @since 2.0.0.beta.1
     def remove_child(child)
-      name = child.metadata_name
+      name = child.association_name
       if child.embedded_one?
         remove_ivar(name)
       else

data/lib/mongoid/validatable/macros.rb

@@ -48,7 +48,7 @@ module Mongoid
       #     include Mongoid::Document
       #     field :title
       #
-      #     validates_format_of :title, with: /^[a-z0-9 \-_]*$/i
+      #     validates_format_of :title, with: /\A[a-z0-9 \-_]*\z/i
       #   end
       #
       # @param [ Array ] args The names of the fields to validate.

data/lib/mongoid/validatable/presence.rb

@@ -62,8 +62,8 @@ module Mongoid
       # @since 3.0.0
       def relation_or_fk_missing?(doc, attr, value)
         return true if value.blank? && doc.send(attr).blank?
-        metadata = doc.relations[attr.to_s]
-        metadata.stores_foreign_key? && doc.send(metadata.foreign_key).blank?
+        association = doc.relations[attr.to_s]
+        association.stores_foreign_key? && doc.send(association.foreign_key).blank?
       end
 
       # For guarding against false values.

data/lib/mongoid/validatable/uniqueness.rb

@@ -148,7 +148,7 @@ module Mongoid
       #
       # @since 2.3.0
       def filter(value)
-        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}$/i : value
+        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}\z/i : value
       end
 
       # Scope the criteria to the scope options provided.
@@ -224,9 +224,9 @@ module Mongoid
       #
       # @since 2.4.4
       def to_validate(document, attribute, value)
-        metadata = document.relations[attribute.to_s]
-        if metadata && metadata.stores_foreign_key?
-          [ metadata.foreign_key, value && value._id ]
+        association = document.relations[attribute.to_s]
+        if association && association.stores_foreign_key?
+          [ association.foreign_key, value && value._id ]
         else
           [ attribute, value ]
         end
@@ -246,7 +246,7 @@ module Mongoid
       # @since 2.4.10
       def validate_embedded(document, attribute, value)
         return if skip_validation?(document)
-        relation = document._parent.send(document.metadata_name)
+        relation = document._parent.send(document.association_name)
         criteria = create_criteria(relation, document, attribute, value)
         criteria = criteria.merge(options[:conditions].call) if options[:conditions]
         add_error(document, attribute, value) if criteria.count > 1

data/lib/mongoid/validatable.rb

@@ -127,14 +127,14 @@ module Mongoid
       # was not provided or set to true.
       #
       # @example Set up validation.
-      #   Person.validates_relation(metadata)
+      #   Person.validates_relation(association)
       #
-      # @param [ Metadata ] metadata The relation metadata.
+      # @param [ Association ] association The association metadata.
       #
       # @since 2.0.0.rc.1
-      def validates_relation(metadata)
-        if metadata.validate?
-          validates_associated(metadata.name)
+      def validates_relation(association)
+        if association.validate?
+          validates_associated(association.name)
         end
       end
 
@@ -154,9 +154,9 @@ module Mongoid
       def validates_with(*args, &block)
         if args.first == PresenceValidator
           args.last[:attributes].each do |name|
-            metadata = relations[name.to_s]
-            if metadata && metadata[:autosave] != false
-              autosave(metadata.merge!(autosave: true))
+            association = relations[name.to_s]
+            if association && association.autosave?
+              Association::Referenced::AutoSave.define_autosave!(association)
             end
           end
         end

data/lib/mongoid/version.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 module Mongoid
-  VERSION = "6.4.8"
+  VERSION = "7.0.13"
 end

data/lib/mongoid.rb

@@ -13,6 +13,7 @@ require "active_support/time_with_zone"
 require "active_model"
 
 require "mongo"
+require 'mongo/active_support'
 
 require "mongoid/version"
 require "mongoid/config"