mongoid 7.0.1 → 7.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24a3c4aba84097db1be0810c29d175dfa6e69f6346efa857ac124aeb77bec1b1
-  data.tar.gz: b181a4840f966322895bf4dfe0b64cb136513412d8a3ca89b9aa28a342d27054
+  metadata.gz: 0e3c2f9aa40e2f20c7620a2ae7684da4ebfc1699e32357dd4aa663d93b7ade33
+  data.tar.gz: 9f0d2145026c3db222638b7d00d842a690294cc6101a582a14a75607c44474a1
 SHA512:
-  metadata.gz: 12979183bf4d077b673beb7a57632fc73b7f1672be666401c68969ae675164b0d0641881cdcb8fb43bec283c4b4ca4d946f63a0c988bb58ac4065e677a5278c6
-  data.tar.gz: 3ae9210672c5c5dc3f8536983e814840fc823668373c9594d9a7cb834b533e945eca850c5840dbf0f90e7f707318c0a16823c0a54599d29b5f3a6308f5bf2dd1
+  metadata.gz: 0f9b11ae060df18208b48b911ee39c2954a7855ac7ffc19b073aa21a707e51805bb465b73b7634abb425d983b3d57fbbab044a202853e532c0fc8331141b9734
+  data.tar.gz: 24d37b3c3b77d110d45ec6df6209e8cf4a7821fb787c4d369cd87f01bcf66db0292e101928f8ab2a102f5020c6bb4d7b4b19b13fc2c7765096f5f409251825ff

data/lib/mongoid/association.rb

@@ -3,7 +3,6 @@ require 'mongoid/association/builders'
 require 'mongoid/association/bindable'
 require 'mongoid/association/depending'
 require 'mongoid/association/proxy'
-require 'mongoid/association/touchable'
 
 require 'mongoid/association/many'
 require 'mongoid/association/one'

data/lib/mongoid/association/depending.rb

@@ -8,7 +8,23 @@ module Mongoid
 
       included do
         class_attribute :dependents
+
+        # @api private
+        class_attribute :dependents_owner
+
         self.dependents = []
+        self.dependents_owner = self
+      end
+
+      class_methods do
+        # @api private
+        def _all_dependents
+          superclass_dependents = superclass.respond_to?(:_all_dependents) ? superclass._all_dependents : []
+          dependents + superclass_dependents.reject do |new_dep|
+            dependents.any? do |old_dep| old_dep.name == new_dep.name
+            end
+          end
+        end
       end
 
       # The valid dependent strategies.
@@ -41,6 +57,11 @@ module Mongoid
       def self.define_dependency!(association)
         validate!(association)
         association.inverse_class.tap do |klass|
+          if klass.dependents_owner != klass
+            klass.dependents = []
+            klass.dependents_owner = klass
+          end
+
           if association.dependent && !klass.dependents.include?(association)
             klass.dependents.push(association)
           end
@@ -63,7 +84,7 @@ module Mongoid
       #
       # @since 2.0.0.rc.1
       def apply_delete_dependencies!
-        dependents.each do |association|
+        self.class._all_dependents.each do |association|
           if association.try(:dependent)
             send("_dependent_#{association.dependent}!", association)
           end

data/lib/mongoid/association/embedded/embeds_one/proxy.rb

@@ -52,9 +52,9 @@ module Mongoid
               if _assigning?
                 _base.add_atomic_unset(_target) unless replacement
               else
-                # The associated object will be replaced by the below update, so only
-                # run the callbacks and state-changing code by passing persist: false.
-                _target.destroy(persist: false) if persistable?
+                # The associated object will be replaced by the below update if non-nil, so only
+                # run the callbacks and state-changing code by passing persist: false in that case.
+                _target.destroy(persist: !replacement) if persistable?
               end
               unbind_one
               return nil unless replacement

data/lib/mongoid/association/referenced/has_many/proxy.rb

@@ -459,7 +459,7 @@ module Mongoid
               collection.insert_many(inserts, session: _session)
               docs.each do |doc|
                 doc.new_record = false
-                doc.run_after_callbacks(:create, :save)
+                doc.run_after_callbacks(:create, :save) unless _association.autosave?
                 doc.post_persist
               end
             end

data/lib/mongoid/association/relatable.rb

@@ -57,6 +57,10 @@ module Mongoid
         @name = name
         @options = opts
         @extension = nil
+
+        @module_path = _class.name ? _class.name.split('::')[0..-2].join('::') : ''
+        @module_path << '::' unless @module_path.empty?
+
         create_extension!(&block)
         validate!
       end
@@ -147,7 +151,7 @@ module Mongoid
       #
       # @since 7.0
       def relation_class_name
-        @class_name ||= @options[:class_name] || ActiveSupport::Inflector.classify(name)
+        @class_name ||= @options[:class_name] || ActiveSupport::Inflector.classify(name_with_module)
       end
       alias :class_name :relation_class_name
 
@@ -321,13 +325,23 @@ module Mongoid
 
       private
 
+      def name_with_module
+        @module_path + name.to_s.capitalize
+      end
+
+      # Gets the model classes with inverse associations of this model. This is used to determine
+      # the classes on the other end of polymorphic relations with models.
+      def inverse_association_classes
+        Mongoid::Config.models.map { |m| inverse_association(m) }.compact.map(&:inverse_class)
+      end
+
       def setup_index!
         @owner_class.index(index_spec, background: true) if indexed?
       end
 
       def define_touchable!
         if touchable?
-          Association::Touchable.define_touchable!(self)
+          Touchable.define_touchable!(self)
         end
       end
 

data/lib/mongoid/attributes/nested.rb

@@ -42,15 +42,21 @@ module Mongoid
         #   to a class method to reject documents with.
         # @option *args [ Integer ] :limit The max number to create.
         # @option *args [ true, false ] :update_only Only update existing docs.
+        # @options *args [ true, false ] :autosave Whether autosave should be enabled on the
+        #   association. Note that since the default is true, setting autosave to nil will still
+        #   enable it.
         def accepts_nested_attributes_for(*args)
-          options = args.extract_options!
+          options = args.extract_options!.dup
+          options[:autosave] = true if options[:autosave].nil?
+
           options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
           args.each do |name|
             meth = "#{name}_attributes="
             self.nested_attributes["#{name}_attributes"] = meth
             association = relations[name.to_s]
             raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless association
-            autosave_nested_attributes(association)
+            autosave_nested_attributes(association) if options[:autosave]
+
             re_define_method(meth) do |attrs|
               _assigning do
                 if association.polymorphic? and association.inverse_type
@@ -75,7 +81,12 @@ module Mongoid
         #
         # @since 3.1.4
         def autosave_nested_attributes(association)
-          if association.autosave?
+          # In order for the autosave functionality to work properly, the association needs to be
+          # marked as autosave despite the fact that the option isn't present. Because the method
+          # Association#autosave? is implemented by checking the autosave option, this is the most
+          # straightforward way to mark it.
+          if association.autosave? || (association.options[:autosave].nil? && !association.embedded?)
+            association.options[:autosave] = true
             Association::Referenced::AutoSave.define_autosave!(association)
           end
         end

data/lib/mongoid/contextual/map_reduce.rb

@@ -165,7 +165,7 @@ module Mongoid
       def raw
         validate_out!
         cmd = command
-        opts = { read: cmd.delete(:read).options } if cmd[:read]
+        opts = { read: cmd.delete(:read) } if cmd[:read]
         @map_reduce.database.command(cmd, (opts || {}).merge(session: _session)).first
       end
       alias :results :raw

data/lib/mongoid/copyable.rb

@@ -73,8 +73,9 @@ module Mongoid
         next unless attrs.present? && attrs[association.key].present?
 
         if association.is_a?(Association::Embedded::EmbedsMany)
-          attrs[association.name.to_s].each_with_index do |attr, index|
-            process_localized_attributes(send(association.name)[index].class, attr)
+          attrs[association.name.to_s].each do |attr|
+            embedded_klass = attr.fetch('_type', association.class_name).constantize
+            process_localized_attributes(embedded_klass, attr)
           end
         else
           process_localized_attributes(association.klass, attrs[association.key])

data/lib/mongoid/document.rb

@@ -15,6 +15,7 @@ require "mongoid/fields"
 require "mongoid/timestamps"
 require "mongoid/association"
 require "mongoid/composable"
+require "mongoid/touchable"
 
 module Mongoid
 
@@ -23,6 +24,7 @@ module Mongoid
   module Document
     extend ActiveSupport::Concern
     include Composable
+    include Mongoid::Touchable::InstanceMethods
 
     attr_accessor :__selected_fields
     attr_reader :new_record

data/lib/mongoid/matchable.rb

@@ -11,6 +11,7 @@ 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/regexp"
@@ -40,6 +41,7 @@ module Mongoid
       "$ne" => Ne,
       "$nin" => Nin,
       "$or" => Or,
+      "$nor" => Nor,
       "$size" => Size
     }.with_indifferent_access.freeze
 
@@ -124,6 +126,7 @@ module Mongoid
           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

data/lib/mongoid/matchable/nor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Defines behavior for handling $nor expressions in embedded documents.
+    class Nor < Default
+
+      # Does the supplied query match the attribute?
+      #
+      # Note: an empty array as an argument to $nor is prohibited by
+      # MongoDB server. Mongoid does allow this and returns false in this case.
+      #
+      # @example Does this match?
+      #   matcher._matches?("$nor" => [ { field => value } ])
+      #
+      # @param [ Array ] conditions The or expression.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      #
+      # @since 6.4.2/7.0.2/7.1.0
+      def _matches?(conditions)
+        if conditions.length == 0
+          # MongoDB does not allow $nor array to be empty, but
+          # Mongoid accepts an empty array for $or which MongoDB also
+          # prohibits
+          return false
+        end
+        conditions.none? do |condition|
+          condition.all? do |key, value|
+            document._matches?(key => value)
+          end
+        end
+      end
+    end
+  end
+end

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,17 +51,39 @@ 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
+            field_seq = field.to_s.split('.')
+            field = field_seq.shift
+            if field_seq.length > 0
+              # nested hash path
+              old_value = attributes[field]
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field)
-              merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = (attributes[field] || {}).merge(field_and_value_hash[field], &merger)
-              process_attribute(field.to_s, value)
-            else
-              process_attribute(field.to_s, field_and_value_hash[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
+
+              # 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, value)
+
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
             end
@@ -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/persistence_context.rb

@@ -107,6 +107,10 @@ module Mongoid
     #
     # @since 6.0.0
     def client
+      client_options = send(:client_options)
+      if client_options[:read].is_a?(Symbol)
+        client_options = client_options.merge(read: {mode: client_options[:read]})
+      end
       @client ||= (client = Clients.with_name(client_name)
                     client = client.use(database_name) if database_name_option
                     client.with(client_options))
@@ -208,7 +212,7 @@ module Mongoid
         if context = get(object)
           context.client.close unless (context.cluster.equal?(cluster) || cluster.nil?)
         end
-      ensure  
+      ensure
         Thread.current["[mongoid][#{object.object_id}]:context"] = nil
       end
     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