mongoid 7.2.0.rc1 → 7.3.0

data/lib/mongoid/persistable/deletable.rb

@@ -47,7 +47,7 @@ module Mongoid
       #
       # @since 4.0.0
       def atomic_deletes
-        { atomic_delete_modifier => { atomic_path => _index ? { "_id" => id } : true }}
+        { atomic_delete_modifier => { atomic_path => _index ? { "_id" => _id } : true }}
       end
 
       # Delete the embedded document.
@@ -117,7 +117,6 @@ module Mongoid
       #
       # @since 4.0.0
       def prepare_delete
-        return false unless catch(:abort) { apply_delete_dependencies! }
         yield(self)
         freeze
         self.destroyed = true

data/lib/mongoid/persistable/destroyable.rb

@@ -23,13 +23,19 @@ module Mongoid
       def destroy(options = nil)
         raise Errors::ReadonlyDocument.new(self.class) if readonly?
         self.flagged_for_destroy = true
-        result = run_callbacks(:destroy) { delete(options || {}) }
+        result = run_callbacks(:destroy) do
+          if catch(:abort) { apply_destroy_dependencies! }
+            delete(options || {})
+          else
+            false
+          end
+        end
         self.flagged_for_destroy = false
         result
       end
 
       def destroy!(options = {})
-        destroy || raise(Errors::DocumentNotDestroyed.new(id, self.class))
+        destroy || raise(Errors::DocumentNotDestroyed.new(_id, self.class))
       end
 
       module ClassMethods

data/lib/mongoid/persistable/updatable.rb

@@ -137,8 +137,33 @@ module Mongoid
             coll = collection(_root)
             selector = atomic_selector
             coll.find(selector).update_one(positionally(selector, updates), session: _session)
-            conflicts.each_pair do |key, value|
-              coll.find(selector).update_one(positionally(selector, { key => value }), session: _session)
+
+            # The following code applies updates which would cause
+            # path conflicts in MongoDB, for example when changing attributes
+            # of foo.0.bars while adding another foo. Each conflicting update
+            # is applied using its own write.
+            #
+            # TODO: MONGOID-5026: reduce the number of writes performed by
+            # more intelligently combining the writes such that there are
+            # fewer conflicts.
+            conflicts.each_pair do |modifier, changes|
+
+              # Group the changes according to their root key which is
+              # the top-level association name.
+              # This handles at least the cases described in MONGOID-4982.
+              conflicting_change_groups = changes.group_by do |key, _|
+                key.split(".", 2).first
+              end.values
+
+              # Apply changes in batches. Pop one change from each
+              # field-conflict group round-robin until all changes
+              # have been applied.
+              while batched_changes = conflicting_change_groups.map(&:pop).compact.to_h.presence
+                coll.find(selector).update_one(
+                  positionally(selector, modifier => batched_changes),
+                  session: _session,
+                )
+              end
             end
           end
         end

data/lib/mongoid/query_cache.rb

@@ -117,38 +117,44 @@ module Mongoid
       end
     end
 
-    # The middleware to be added to a rack application in order to activate the
-    # query cache.
-    #
-    # @since 4.0.0
-    class Middleware
-
-      # Instantiate the middleware.
-      #
-      # @example Create the new middleware.
-      #   Middleware.new(app)
-      #
-      # @param [ Object ] app The rack applciation stack.
+    if defined?(Mongo::QueryCache::Middleware)
+      Middleware = Mongo::QueryCache::Middleware
+    else
+      # The middleware to be added to a rack application in order to activate the
+      # query cache.
       #
       # @since 4.0.0
-      def initialize(app)
-        @app = app
-      end
+      class Middleware
 
-      # Execute the request, wrapping in a query cache.
-      #
-      # @example Execute the request.
-      #   middleware.call(env)
-      #
-      # @param [ Object ] env The environment.
-      #
-      # @return [ Object ] The result of the call.
-      #
-      # @since 4.0.0
-      def call(env)
-        QueryCache.cache { @app.call(env) }
-      ensure
-        QueryCache.clear_cache
+        # Instantiate the middleware.
+        #
+        # @example Create the new middleware.
+        #   Middleware.new(app)
+        #
+        # @param [ Object ] app The rack application stack.
+        #
+        # @since 4.0.0
+        def initialize(app)
+          @app = app
+        end
+
+        # Execute the request, wrapping in a query cache.
+        #
+        # @example Execute the request.
+        #   middleware.call(env)
+        #
+        # @param [ Object ] env The environment.
+        #
+        # @return [ Object ] The result of the call.
+        #
+        # @since 4.0.0
+        def call(env)
+          QueryCache.cache do
+            @app.call(env)
+          end
+        ensure
+          QueryCache.clear_cache
+        end
       end
     end
 

data/lib/mongoid/reloadable.rb

@@ -21,6 +21,11 @@ module Mongoid
     #
     # @since 1.0.0
     def reload
+      if @atomic_selector
+        # Clear atomic_selector cache for sharded clusters. MONGOID-5076
+        remove_instance_variable('@atomic_selector')
+      end
+
       reloaded = _reload
       if Mongoid.raise_not_found_error && reloaded.empty?
         raise Errors::DocumentNotFound.new(self.class, _id, _id)

data/lib/mongoid/selectable.rb

@@ -21,7 +21,7 @@ module Mongoid
     # @since 1.0.0
     def atomic_selector
       @atomic_selector ||=
-        (embedded? ? embedded_atomic_selector : root_atomic_selector)
+        (embedded? ? embedded_atomic_selector : root_atomic_selector_in_db)
     end
 
     private
@@ -44,18 +44,16 @@ module Mongoid
       end
     end
 
-    # Get the atomic selector for a root document.
+    # Get the atomic selector that would match the existing version of the
+    # root document.
     #
     # @api private
     #
-    # @example Get the root atomic selector.
-    #   document.root_atomic_selector
-    #
     # @return [ Hash ] The root document selector.
     #
     # @since 4.0.0
-    def root_atomic_selector
-      { "_id" => _id }.merge!(shard_key_selector)
+    def root_atomic_selector_in_db
+      { "_id" => _id }.merge!(shard_key_selector_in_db)
     end
   end
 end

data/lib/mongoid/shardable.rb

@@ -52,15 +52,31 @@ module Mongoid
       self.class.shard_key_fields
     end
 
-    # Get the document selector with the defined shard keys.
-    #
-    # @example Get the selector for the shard keys.
-    #   person.shard_key_selector
+    # Returns the selector that would match the current version of this
+    # document.
     #
     # @return [ Hash ] The shard key selector.
     #
-    # @since 2.0.0
+    # @api private
     def shard_key_selector
+      selector = {}
+      shard_key_fields.each do |field|
+        selector[field.to_s] = send(field)
+      end
+      selector
+    end
+
+    # Returns the selector that would match the existing version of this
+    # document in the database.
+    #
+    # If the document is not persisted, this method uses the current values
+    # of the shard key fields. If the document is persisted, this method
+    # uses the values retrieved from the database.
+    #
+    # @return [ Hash ] The shard key selector.
+    #
+    # @api private
+    def shard_key_selector_in_db
       selector = {}
       shard_key_fields.each do |field|
         selector[field.to_s] = new_record? ? send(field) : attribute_was(field)

data/lib/mongoid/stringified_symbol.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# A class which sends values to the database as Strings but returns them to the user as Symbols.
+module Mongoid
+  class StringifiedSymbol
+
+    class << self
+
+      # Convert the object from its mongo friendly ruby type to this type.
+      #
+      # @example Demongoize the object.
+      #   Symbol.demongoize(object)
+      #
+      # @param [ Object ] object The object to demongoize.
+      #
+      # @return [ Symbol ] The object.
+      #
+      # @api private
+      def demongoize(object)
+        if object.nil?
+          object
+        else
+          object.to_s.to_sym
+        end
+      end
+
+      # Turn the object from the ruby type we deal with to a Mongo friendly
+      # type.
+      #
+      # @example Mongoize the object.
+      #   Symbol.mongoize("123.11")
+      #
+      # @param [ Object ] object The object to mongoize.
+      #
+      # @return [ Symbol ] The object mongoized.
+      #
+      # @api private
+      def mongoize(object)
+         if object.nil?
+           object
+         else
+           object.to_s
+         end
+      end
+
+      # @api private
+      def evolve(object)
+        mongoize(object)
+      end
+    end
+  end
+end

data/lib/mongoid/touchable.rb

@@ -30,11 +30,30 @@ module Mongoid
         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)
+        # If the document being touched is embedded, touch its parents
+        # all the way through the composition hierarchy to the root object,
+        # because when an embedded document is changed the write is actually
+        # performed by the composition root. See MONGOID-3468.
+        if _parent
+          # This will persist updated_at on this document as well as parents.
+          # TODO support passing the field name to the parent's touch method;
+          # I believe it should be read out of
+          # _association.inverse_association.options but inverse_association
+          # seems to not always/ever be set here. See MONGOID-5014.
+          _parent.touch
+        else
+          # If the current document is not embedded, it is composition root
+          # and we need to persist the write here.
+          touches = touch_atomic_updates(field)
+          unless touches["$set"].blank?
+            selector = atomic_selector
+            _root.collection.find(selector).update_one(positionally(selector, touches), session: _session)
+          end
         end
+
+        # Callbacks are invoked on the composition root first and on the
+        # leaf-most embedded document last.
+        # TODO add tests, see MONGOID-5015.
         run_callbacks(:touch)
         true
       end

data/lib/mongoid/version.rb

@@ -2,5 +2,5 @@
 # encoding: utf-8
 
 module Mongoid
-  VERSION = "7.2.0.rc1"
+  VERSION = "7.3.0"
 end

data/lib/rails/generators/mongoid/config/config_generator.rb

@@ -15,7 +15,14 @@ module Mongoid
       end
 
       def app_name
-        Rails::Application.subclasses.first.parent.to_s.underscore
+        app_cls = Rails.application.class
+        parent = begin
+          # Rails 6.1+
+          app_cls.module_parent_name
+        rescue NoMethodError
+          app_cls.parent.to_s
+        end
+        parent.underscore
       end
 
       def create_config_file

data/spec/README.md

@@ -1,8 +1,17 @@
 # Running Mongoid Tests
 
-## Overview
-### Quick Start
-Spin up a MongoDB deployment against which to run the Mongoid specs. Mongoid specs support a variety of MongoDB topologies, but the simplest is a single MongoDB instance:
+## Quick Start
+
+The test suite requires shared tooling that is stored in a separate repository
+and is referenced as a submodule. After checking out the desired driver
+branch, check out the matching submodules:
+
+    git submodule init
+    git submodule update
+
+Spin up a MongoDB deployment against which to run the Mongoid specs.
+Mongoid specs support a variety of MongoDB topologies, but the simplest is
+a single MongoDB instance:
 
     # Launch mongod in one terminal
     mkdir /tmp/mdb
@@ -14,5 +23,11 @@ Run the test suite in a separate terminal:
 
 
 ## Caveats
+
 ### "Too many open files" error
-On MacOS, you may encounter a "Too many open files" error on the MongoDB server when running the tests. If this happens, stop the server, run the command `ulimit -n 10000` in the same terminal session as the server, and restart the server. This will increase the number of files that can be opened. Then, re-run the tests.
+
+On MacOS, you may encounter a "Too many open files" error on the MongoDB server
+when running the tests. If this happens, stop the server, run the command
+`ulimit -n 10000` in the same terminal session as the server, and restart
+the server. This will increase the number of files that can be opened.
+Then, re-run the tests.

data/spec/integration/app_spec.rb

@@ -13,109 +13,131 @@ describe 'Mongoid application tests' do
     end
 
     require 'fileutils'
-    require 'support/child_process_helper'
+    require 'mrss/child_process_helper'
     require 'open-uri'
 
     FileUtils.mkdir_p(TMP_BASE)
   end
 
-  context 'demo application - sinatra' do
-    it 'runs' do
-      clone_application(
-        'https://github.com/mongoid/mongoid-demo',
-        subdir: 'sinatra-minimal',
-      ) do
+  context 'demo application' do
+    context 'sinatra' do
+      it 'runs' do
+        clone_application(
+          'https://github.com/mongoid/mongoid-demo',
+          subdir: 'sinatra-minimal',
+        ) do
 
-        process = ChildProcess.build(*%w(bundle exec ruby app.rb))
-        process.environment.update(clean_env)
-        process.io.inherit!
-        process.start
-
-        begin
           # JRuby needs a long timeout
-          wait_for_port(4567, 20)
-          sleep 1
-
-          uri = URI.parse('http://localhost:4567/posts')
-          resp = JSON.parse(uri.open.read)
-        ensure
-          Process.kill('TERM', process.pid)
-          status = process.wait
-        end
+          start_app(%w(bundle exec ruby app.rb), 4567, 40) do |port|
+            uri = URI.parse('http://localhost:4567/posts')
+            resp = JSON.parse(uri.open.read)
 
-        resp.should == []
+            resp.should == []
 
-        status.should == 0
+          end
+        end
       end
     end
-  end
 
-  context 'demo application - rails-api' do
-    ['~> 6.0.0'].each do |rails_version|
-      context "with rails #{rails_version}" do
-        it 'runs' do
-          clone_application(
-            'https://github.com/mongoid/mongoid-demo',
-            subdir: 'rails-api',
-            rails_version: rails_version,
-          ) do
-
-            process = ChildProcess.build(*%w(bundle exec rails s))
-            process.environment.update(clean_env)
-            process.io.inherit!
-            process.start
-
-            begin
-              # JRuby needs a long timeout
-              wait_for_port(3000, 30)
-              sleep 1
-
-              uri = URI.parse('http://localhost:3000/posts')
-              resp = JSON.parse(uri.open.read)
-            ensure
-              Process.kill('TERM', process.pid)
-              status = process.wait
-            end
+    context 'rails-api' do
+      it 'runs' do
+        clone_application(
+          'https://github.com/mongoid/mongoid-demo',
+          subdir: 'rails-api',
+        ) do
 
-            resp.should == []
+          # JRuby needs a long timeout
+          start_app(%w(bundle exec rails s), 3000, 50) do |port|
+            uri = URI.parse('http://localhost:3000/posts')
+            resp = JSON.parse(uri.open.read)
 
-            # 143 = 128 + 15
-            [0, 15, 143].should include(status)
+            resp.should == []
           end
         end
       end
     end
   end
 
+  def start_app(cmd, port, timeout)
+    process = ChildProcess.build(*cmd)
+    process.environment.update(clean_env)
+    process.io.inherit!
+    process.start
+
+    begin
+      wait_for_port(port, timeout, process)
+      sleep 1
+
+      rv = yield port
+    ensure
+      # The process may have already died (due to an error exit) -
+      # in this case killing it will raise an exception.
+      Process.kill('TERM', process.pid) rescue nil
+      status = process.wait
+    end
+
+    # Exit should be either success or SIGTERM
+    [0, 15, 128 + 15].should include(status)
+
+    rv
+  end
+
   context 'new application - rails' do
-    ['~> 5.1.0', '~> 5.2.0', '~> 6.0.0'].each do |rails_version|
-      context "with rails #{rails_version}" do
-        it 'creates' do
-          ChildProcessHelper.check_call(%w(gem uni rails -a))
-          ChildProcessHelper.check_call(%w(gem install rails --no-document -v) + [rails_version])
-
-          Dir.chdir(TMP_BASE) do
-            FileUtils.rm_rf('mongoid-test')
-            ChildProcessHelper.check_call(%w(rails new mongoid-test --skip-spring --skip-active-record), env: clean_env)
-
-            Dir.chdir('mongoid-test') do
-              adjust_app_gemfile
-              ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
-
-              ChildProcessHelper.check_call(%w(rails g model post), env: clean_env)
-              ChildProcessHelper.check_call(%w(rails g model comment post:belongs_to), env: clean_env)
-
-              # https://jira.mongodb.org/browse/MONGOID-4885
-              comment_text = File.read('app/models/comment.rb')
-              comment_text.should =~ /belongs_to :post/
-              comment_text.should_not =~ /embedded_in :post/
-            end
-          end
+    it 'creates' do
+      install_rails
+
+      Dir.chdir(TMP_BASE) do
+        FileUtils.rm_rf('mongoid-test')
+        Mrss::ChildProcessHelper.check_call(%w(rails new mongoid-test --skip-spring --skip-active-record), env: clean_env)
+
+        Dir.chdir('mongoid-test') do
+          adjust_app_gemfile
+          Mrss::ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+
+          Mrss::ChildProcessHelper.check_call(%w(rails g model post), env: clean_env)
+          Mrss::ChildProcessHelper.check_call(%w(rails g model comment post:belongs_to), env: clean_env)
+
+          # https://jira.mongodb.org/browse/MONGOID-4885
+          comment_text = File.read('app/models/comment.rb')
+          comment_text.should =~ /belongs_to :post/
+          comment_text.should_not =~ /embedded_in :post/
+        end
+      end
+    end
+
+    it 'generates Mongoid config' do
+      install_rails
+
+      Dir.chdir(TMP_BASE) do
+        FileUtils.rm_rf('mongoid-test-config')
+        Mrss::ChildProcessHelper.check_call(%w(rails new mongoid-test-config --skip-spring --skip-active-record), env: clean_env)
+
+        Dir.chdir('mongoid-test-config') do
+          adjust_app_gemfile
+          Mrss::ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+
+          mongoid_config_file = File.join(TMP_BASE,'mongoid-test-config/config/mongoid.yml')
+
+          File.exist?(mongoid_config_file).should be false
+          Mrss::ChildProcessHelper.check_call(%w(rails g mongoid:config), env: clean_env)
+          File.exist?(mongoid_config_file).should be true
+
+          config_text = File.read(mongoid_config_file)
+          config_text.should =~ /mongoid_test_config_development/
+          config_text.should =~ /mongoid_test_config_test/
         end
       end
     end
   end
 
+  def install_rails
+    Mrss::ChildProcessHelper.check_call(%w(gem uni rails -a))
+    if (rails_version = SpecConfig.instance.rails_version) == 'master'
+    else
+      Mrss::ChildProcessHelper.check_call(%w(gem install rails --no-document -v) + [rails_version])
+    end
+  end
+
   context 'local test applications' do
     let(:client) { Mongoid.default_client }
 
@@ -136,7 +158,7 @@ describe 'Mongoid application tests' do
               before do
                 Dir.chdir(APP_PATH) do
                   remove_bundler_req
-                  ChildProcessHelper.check_call(%w(bundle install), env: env)
+                  Mrss::ChildProcessHelper.check_call(%w(bundle install), env: env)
                   write_mongoid_yml
                 end
 
@@ -150,7 +172,7 @@ describe 'Mongoid application tests' do
                 end
                 index.should be nil
 
-                ChildProcessHelper.check_call(%w(rake db:mongoid:create_indexes),
+                Mrss::ChildProcessHelper.check_call(%w(bundle exec rake db:mongoid:create_indexes),
                   cwd: APP_PATH, env: env)
 
                 index = client['posts'].indexes.detect do |index|
@@ -165,13 +187,14 @@ describe 'Mongoid application tests' do
     end
   end
 
-  def clone_application(repo_url, subdir: nil, rails_version: nil)
+  def clone_application(repo_url, subdir: nil)
     Dir.chdir(TMP_BASE) do
       FileUtils.rm_rf(File.basename(repo_url))
-      ChildProcessHelper.check_call(%w(git clone) + [repo_url])
+      Mrss::ChildProcessHelper.check_call(%w(git clone) + [repo_url])
       Dir.chdir(File.join(*[File.basename(repo_url), subdir].compact)) do
-        adjust_app_gemfile(rails_version: rails_version)
-        ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+        adjust_app_gemfile
+        adjust_rails_defaults
+        Mrss::ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
         puts `git diff`
 
         write_mongoid_yml
@@ -181,11 +204,44 @@ describe 'Mongoid application tests' do
     end
   end
 
+  def parse_mongodb_uri(uri)
+    pre, query = uri.split('?', 2)
+    if pre =~ %r,\A(mongodb(?:.*?))://([^/]+)(?:/(.*))?\z,
+      protocol = $1
+      hosts = $2
+      database = $3
+      if database == ''
+        database = nil
+      end
+    else
+      raise ArgumentError, "Invalid MongoDB URI: #{uri}"
+    end
+    if query == ''
+      query = nil
+    end
+    {
+      protocol: protocol,
+      hosts: hosts,
+      database: database,
+      query: query,
+    }
+  end
+
+  def build_mongodb_uri(parts)
+    "#{parts.fetch(:protocol)}://#{parts.fetch(:hosts)}/#{parts[:database]}?#{parts[:query]}"
+  end
+
   def write_mongoid_yml
+    # HACK: the driver does not provide a MongoDB URI parser and assembler,
+    # and the Ruby standard library URI module doesn't handle multiple hosts.
+    parts = parse_mongodb_uri(SpecConfig.instance.uri_str)
+    parts[:database] = 'mongoid_test'
+    uri = build_mongodb_uri(parts)
+    p uri
     env_config = {'clients' => {'default' => {
       # TODO massive hack, will fail if uri specifies a database name or
       # any uri options
-      'uri' => "#{SpecConfig.instance.uri_str}/mongoid_test",
+      'uri' => uri,
     }}}
     config = {'development' => env_config, 'production' => env_config}
     File.open('config/mongoid.yml', 'w') do |f|
@@ -193,7 +249,7 @@ describe 'Mongoid application tests' do
     end
   end
 
-  def adjust_app_gemfile(rails_version: nil)
+  def adjust_app_gemfile(rails_version: SpecConfig.instance.rails_version)
     remove_bundler_req
 
     gemfile_lines = IO.readlines('Gemfile')
@@ -205,13 +261,41 @@ describe 'Mongoid application tests' do
       gemfile_lines.delete_if do |line|
         line =~ /rails/
       end
-      gemfile_lines << "gem 'rails', '#{rails_version}'\n"
+      if rails_version == 'master'
+        gemfile_lines << "gem 'rails', git: 'https://github.com/rails/rails'\n"
+      else
+        gemfile_lines << "gem 'rails', '~> #{rails_version}.0'\n"
+      end
     end
     File.open('Gemfile', 'w') do |f|
       f << gemfile_lines.join
     end
   end
 
+  def adjust_rails_defaults(rails_version: SpecConfig.instance.rails_version)
+    if File.exist?('config/application.rb')
+      lines = IO.readlines('config/application.rb')
+      lines.each do |line|
+        line.gsub!(/config.load_defaults \d\.\d/, "config.load_defaults #{rails_version}")
+      end
+      File.open('config/application.rb', 'w') do |f|
+        f << lines.join
+      end
+    end
+
+    if rails_version == '5.1'
+      secrets = {
+        'development' => {
+          'secret_key_base' => 'abracadabra',
+          'my_secret_token' => 'very_secret',
+        },
+      }
+      File.open('config/secrets.yml', 'w') do |f|
+        f << YAML.dump(secrets)
+      end
+    end
+  end
+
   def remove_bundler_req
     lock_lines = IO.readlines('Gemfile.lock')
     # Get rid of the bundled with line so that whatever bundler is installed
@@ -230,14 +314,14 @@ describe 'Mongoid application tests' do
     # in `initialize': too long unix socket path (126bytes given but 108bytes max) (ArgumentError)
     # Is it trying to create unix sockets in current directory?
     # https://stackoverflow.com/questions/30302021/rails-runner-without-spring
-    ChildProcessHelper.check_call(%w(bin/spring binstub --remove --all), env: clean_env)
+    Mrss::ChildProcessHelper.check_call(%w(bin/spring binstub --remove --all), env: clean_env)
   end
 
   def clean_env
     @clean_env ||= Hash[ENV.keys.grep(/BUNDLE|RUBYOPT/).map { |k| [k, nil ] }]
   end
 
-  def wait_for_port(port, timeout)
+  def wait_for_port(port, timeout, process)
     deadline = Time.now + timeout
     loop do
       begin
@@ -245,6 +329,9 @@ describe 'Mongoid application tests' do
           return
         end
       rescue IOError, SystemCallError
+        unless process.alive?
+          raise "Process #{process} died while waiting for port #{port}"
+        end
         if Time.now > deadline
           raise
         end