mongoid 7.1.2 → 7.2.0

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/tasks/database.rb

@@ -132,8 +132,32 @@ module Mongoid
             next
           end
 
-          # Database must exist in order to run collStats
-          model.collection.create
+          # Database of the collection must exist in order to run collStats.
+          # Depending on server version, the collection itself must also
+          # exist.
+          # MongoDB does not have a command to create the database; the best
+          # approximation of it is to create the collection we want.
+          # On older servers, creating a collection that already exists is
+          # an error.
+          # Additionally, 3.6 and potentially older servers do not provide
+          # the error code when they are asked to collStats a non-existent
+          # collection (https://jira.mongodb.org/browse/SERVER-50070).
+          begin
+            stats = model.collection.database.command(collStats: model.collection.name).first
+          rescue Mongo::Error::OperationFailure => exc
+            # Code 26 is database does not exist.
+            # Code 8 is collection does not exist, as of 4.0.
+            # On 3.6 and earlier match the text of exception message.
+            if exc.code == 26 || exc.code == 8 ||
+              exc.code.nil? && exc.message =~ /not found/
+            then
+              model.collection.create
+
+              stats = model.collection.database.command(collStats: model.collection.name).first
+            else
+              raise
+            end
+          end
 
           stats = model.collection.database.command(collStats: model.collection.name).first
           if stats[:sharded]
@@ -142,7 +166,18 @@ module Mongoid
           end
 
           admin_db = model.collection.client.use(:admin).database
-          admin_db.command(enableSharding: model.collection.database.name)
+
+          begin
+            admin_db.command(enableSharding: model.collection.database.name)
+          rescue Mongo::Error::OperationFailure => exc
+            # Server 2.6 fails if sharding is already enabled
+            if exc.code == 23 || exc.code.nil? && exc.message =~ /already enabled/
+              # Nothing
+            else
+              raise
+            end
+          end
+
           begin
             admin_db.command(shardCollection: model.collection.namespace, **model.shard_config)
           rescue Mongo::Error::OperationFailure => e

data/lib/mongoid/traversable.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
+require "mongoid/fields/validators/macro"
+
 module Mongoid
 
   # Provides behavior around traversing the document graph.
@@ -17,6 +19,105 @@ module Mongoid
       @__parent = p
     end
 
+    # Module used for prepending to the various discriminator_*= methods
+    #
+    # @api private
+    module DiscriminatorAssignment
+      def discriminator_key=(value)
+        if hereditary?
+          raise Errors::InvalidDiscriminatorKeyTarget.new(self, self.superclass)
+        end
+
+        _mongoid_clear_types
+
+        if value
+          Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
+          value = value.to_s
+          super
+        else
+          # When discriminator key is set to nil, replace the class's definition
+          # of the discriminator key reader (provided by class_attribute earlier)
+          # and re-delegate to Mongoid.
+          class << self
+            delegate :discriminator_key, to: ::Mongoid
+          end
+        end
+
+        # This condition checks if the new discriminator key would overwrite
+        # an existing field.
+        # This condition also checks if the class has any descendants, because
+        # if it doesn't then it doesn't need a discriminator key.
+        if !fields.has_key?(self.discriminator_key) && !descendants.empty?
+          default_proc = lambda { self.class.discriminator_value }
+          field(self.discriminator_key, default: default_proc, type: String)
+        end
+      end
+
+      def discriminator_value=(value)
+        value ||= self.name
+        _mongoid_clear_types
+        add_discriminator_mapping(value)
+        @discriminator_value = value
+      end
+    end
+
+    # Module used for prepending the discriminator_value method.
+    #
+    # A separate module was needed because the subclasses of this class
+    # need to be manually prepended with the discriminator_value and can't
+    # rely on being a class_attribute because the .discriminator_value
+    # method is overriden by every subclass in the inherited method.
+    #
+    # @api private
+    module DiscriminatorRetrieval
+
+      # Get the name on the reading side if the discriminator_value is nil
+      def discriminator_value
+        @discriminator_value || self.name
+      end
+    end
+
+    included do
+      class_attribute :discriminator_key, instance_accessor: false
+
+      class << self
+        delegate :discriminator_key, to: ::Mongoid
+        prepend DiscriminatorAssignment
+        include DiscriminatorRetrieval
+
+        # @api private
+        #
+        # @return [ Hash<String, Class> ] The current mapping of discriminator_values to classes
+        attr_accessor :discriminator_mapping
+      end
+
+      # Add a discriminator mapping to the parent class. This mapping is used when
+      # receiving a document to identify its class.
+      #
+      # @param [ String ] value The discriminator_value that was just set
+      # @param [ Class ] The class the discriminator_value was set on
+      #
+      # @api private
+      def self.add_discriminator_mapping(value, klass=self)
+        self.discriminator_mapping ||= {}
+        self.discriminator_mapping[value] = klass
+        superclass.add_discriminator_mapping(value, klass) if hereditary?
+      end
+
+      # Get the discriminator mapping from the parent class. This method returns nil if there
+      # is no mapping for the given value.
+      #
+      # @param [ String ] value The discriminator_value to retrieve
+      #
+      # @return [ Class | nil ] klass The class corresponding to the given discriminator_value. If
+      #                               the value is not in the mapping, this method returns nil.
+      #
+      # @api private
+      def self.get_discriminator_mapping(value)
+        self.discriminator_mapping[value] if self.discriminator_mapping
+      end
+    end
+
     # Get all child +Documents+ to this +Document+, going n levels deep if
     # necessary. This is used when calling update persistence operations from
     # the root document, where changes in the entire tree need to be
@@ -201,14 +302,20 @@ module Mongoid
         subclass.pre_processed_defaults = pre_processed_defaults.dup
         subclass.post_processed_defaults = post_processed_defaults.dup
         subclass._declared_scopes = Hash.new { |hash,key| self._declared_scopes[key] }
+        subclass.discriminator_value = subclass.name
+
+        # We need to do this here because the discriminator_value method is
+        # overriden in the subclass above.
+        class << subclass
+          include DiscriminatorRetrieval
+        end
 
         # We only need the _type field if inheritance is in play, but need to
         # add to the root class as well for backwards compatibility.
-        unless fields.has_key?("_type")
-          field(:_type, default: self.name, type: String)
+        unless fields.has_key?(self.discriminator_key)
+          default_proc = lambda { self.class.discriminator_value }
+          field(self.discriminator_key, default: default_proc, type: String)
         end
-        subclass_default = subclass.name || ->{ self.class.name }
-        subclass.field(:_type, default: subclass_default, type: String, overwrite: true)
       end
     end
   end

data/lib/mongoid/version.rb

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

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,7 +13,7 @@ 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)
@@ -91,19 +91,19 @@ describe 'Mongoid application tests' 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])
+          Mrss::ChildProcessHelper.check_call(%w(gem uni rails -a))
+          Mrss::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), env: clean_env)
+            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
-              ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+              Mrss::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)
+              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')
@@ -116,35 +116,85 @@ describe 'Mongoid application tests' do
     end
   end
 
+  context 'local test applications' do
+    let(:client) { Mongoid.default_client }
+
+    describe 'create_indexes rake task' do
+
+      APP_PATH = File.join(File.dirname(__FILE__), '../../test-apps/rails-api')
+
+      %w(development production).each do |rails_env|
+        context "in #{rails_env}" do
+
+          %w(classic zeitwerk).each do |autoloader|
+            context "with #{autoloader} autoloader" do
+
+              let(:env) do
+                clean_env.merge(RAILS_ENV: rails_env, AUTOLOADER: autoloader)
+              end
+
+              before do
+                Dir.chdir(APP_PATH) do
+                  remove_bundler_req
+                  Mrss::ChildProcessHelper.check_call(%w(bundle install), env: env)
+                  write_mongoid_yml
+                end
+
+                client['posts'].drop
+                client['posts'].create
+              end
+
+              it 'creates an index' do
+                index = client['posts'].indexes.detect do |index|
+                  index['key'] == {'subject' => 1}
+                end
+                index.should be nil
+
+                Mrss::ChildProcessHelper.check_call(%w(rake db:mongoid:create_indexes),
+                  cwd: APP_PATH, env: env)
+
+                index = client['posts'].indexes.detect do |index|
+                  index['key'] == {'subject' => 1}
+                end
+                index.should be_a(Hash)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
   def clone_application(repo_url, subdir: nil, rails_version: 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)
+        Mrss::ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
         puts `git diff`
 
-        config = {'development' => {'clients' => {'default' => {'uri' => SpecConfig.instance.uri_str}}}}
-        File.open('config/mongoid.yml', 'w') do |f|
-          f << YAML.dump(config)
-        end
+        write_mongoid_yml
 
         yield
       end
     end
   end
 
-  def adjust_app_gemfile(rails_version: nil)
-    lock_lines = IO.readlines('Gemfile.lock')
-    # Get rid of the bundled with line so that whatever bundler is installed
-    # on the system is usable with the application.
-    if i = lock_lines.index("BUNDLED WITH\n")
-      lock_lines.slice!(i, 2)
-      File.open('Gemfile.lock', 'w') do |f|
-        f << lock_lines.join
-      end
+  def write_mongoid_yml
+    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",
+    }}}
+    config = {'development' => env_config, 'production' => env_config}
+    File.open('config/mongoid.yml', 'w') do |f|
+      f << YAML.dump(config)
     end
+  end
+
+  def adjust_app_gemfile(rails_version: nil)
+    remove_bundler_req
 
     gemfile_lines = IO.readlines('Gemfile')
     gemfile_lines.delete_if do |line|
@@ -162,13 +212,25 @@ describe 'Mongoid application tests' do
     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
+    # on the system is usable with the application.
+    if i = lock_lines.index("BUNDLED WITH\n")
+      lock_lines.slice!(i, 2)
+      File.open('Gemfile.lock', 'w') do |f|
+        f << lock_lines.join
+      end
+    end
+  end
+
   def remove_spring
     # Spring produces this error in Evergreen:
     # /data/mci/280eb2ecf4fd69208e2106cd3af526f1/src/rubies/ruby-2.7.0/lib/ruby/gems/2.7.0/gems/spring-2.1.0/lib/spring/client/run.rb:26:
     # 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