mongoid 7.1.0.rc0 → 7.2.0.rc1

data/lib/mongoid/railties/database.rake

@@ -60,13 +60,20 @@ namespace :db do
   end
 
   unless Rake::Task.task_defined?("db:create_indexes")
+    desc "Create indexes specified in Mongoid models"
     task :create_indexes => "mongoid:create_indexes"
   end
 
   unless Rake::Task.task_defined?("db:remove_indexes")
+    desc "Remove indexes specified in Mongoid models"
     task :remove_indexes => "mongoid:remove_indexes"
   end
 
+  unless Rake::Task.task_defined?("db:shard_collections")
+    desc "Shard collections with shard keys specified in Mongoid models"
+    task :shard_collections => "mongoid:shard_collections"
+  end
+
   namespace :mongoid do
     task :load_models do
       ::Rails.application.eager_load! if defined?(::Rails)

data/lib/mongoid/reloadable.rb

@@ -60,7 +60,7 @@ module Mongoid
     #
     # @since 2.3.2
     def reload_root_document
-      {}.merge(collection.find({ _id: _id }, session: _session).read(mode: :primary).first || {})
+      {}.merge(collection.find(atomic_selector, session: _session).read(mode: :primary).first || {})
     end
 
     # Reload the embedded document.
@@ -73,7 +73,7 @@ module Mongoid
     # @since 2.3.2
     def reload_embedded_document
       extract_embedded_attributes({}.merge(
-        collection(_root).find(_id: _root._id).read(mode: :primary).first
+        collection(_root).find(_root.atomic_selector).read(mode: :primary).first
       ))
     end
 

data/lib/mongoid/serializable.rb

@@ -13,8 +13,16 @@ module Mongoid
     # We need to redefine where the JSON configuration is getting defined,
     # similar to +ActiveRecord+.
     included do
-      undef_method :include_root_in_json
-      delegate :include_root_in_json, to: ::Mongoid
+
+      class << self
+        # Note that this intentionally only delegates :include_root_in_json
+        # and not :include_root_in_json? - delegating the latter produces
+        # wrong behavior.
+        # Also note that this intentionally uses the ActiveSupport delegation
+        # functionality and not the Ruby standard library one.
+        # See https://jira.mongodb.org/browse/MONGOID-4849.
+        delegate :include_root_in_json, to: ::Mongoid
+      end
     end
 
     # Gets the document as a serializable hash, used by ActiveModel's JSON
@@ -72,7 +80,7 @@ module Mongoid
 
       only = Array.wrap(options[:only]).map(&:to_s)
       except = Array.wrap(options[:except]).map(&:to_s)
-      except |= ['_type'] unless Mongoid.include_type_for_serialization
+      except |= [self.class.discriminator_key] unless Mongoid.include_type_for_serialization
 
       if !only.empty?
         names &= only

data/lib/mongoid/shardable.rb

@@ -10,8 +10,32 @@ module Mongoid
     extend ActiveSupport::Concern
 
     included do
+      # Returns the list of shard key fields, if shard key was declared on
+      # this model. If no shard key was declared, returns an empty array.
+      #
+      # @return [ Array<Symbol> ] List of shard key fields.
+      # @api public
       cattr_accessor :shard_key_fields
       self.shard_key_fields = []
+
+      # Returns the shard configuration, which is a hash with the following
+      # (symbol) keys:
+      #
+      # - keys: A hash mapping (symbol) field names to values, defining the
+      #   shard key. Values can be either the integer 1 for ranged sharding
+      #   or the string "hashed" for hashed sharding.
+      # - options: A hash containing options for shardCollections command.
+      #
+      # If shard key was not declared via the +shard_key+ macro, +shard_config+
+      # attribute is nil.
+      #
+      # @example Get the shard configuration.
+      #   Model.shard_config
+      #   # => {key: {foo: 1, bar: 1}, options: {unique: true}}
+      #
+      # @return [ Hash | nil ] Shard configuration.
+      # @api public
+      cattr_accessor :shard_config
     end
 
     # Get the shard key fields.
@@ -55,14 +79,42 @@ module Mongoid
       #     field :first_name, :type => String
       #     field :last_name, :type => String
       #
-      #     shard_key :first_name, :last_name
+      #     shard_key first_name: 1, last_name: 1
       #   end
       #
       # @since 2.0.0
-      def shard_key(*names)
-        names.each do |name|
-          self.shard_key_fields << self.database_field_name(name).to_sym
+      def shard_key(*args)
+        unless args.first.is_a?(Hash)
+          # Shorthand syntax
+          if args.last.is_a?(Hash)
+            raise ArgumentError, 'Shorthand shard_key syntax does not permit options'
+          end
+
+          spec = Hash[args.map do |name|
+            [name, 1]
+          end]
+
+          return shard_key(spec)
+        end
+
+        if args.length > 2
+          raise ArgumentError, 'Full shard_key syntax requires 1 or 2 arguments'
         end
+
+        spec, options = args
+
+        spec = Hash[spec.map do |name, value|
+          if value.is_a?(Symbol)
+            value = value.to_s
+          end
+          [database_field_name(name).to_sym, value]
+        end]
+
+        self.shard_key_fields = spec.keys
+        self.shard_config = {
+          key: spec.freeze,
+          options: (options || {}).dup.freeze,
+        }.freeze
       end
     end
   end

data/lib/mongoid/tasks/database.rake

@@ -5,27 +5,32 @@ namespace :db do
     task :load_models do
     end
 
-    desc "Create the indexes defined on your mongoid models"
+    desc "Create indexes specified in Mongoid models"
     task :create_indexes => [:environment, :load_models] do
       ::Mongoid::Tasks::Database.create_indexes
     end
 
-    desc "Remove indexes that exist in the database but aren't specified on the models"
+    desc "Remove indexes that exist in the database but are not specified in Mongoid models"
     task :remove_undefined_indexes => [:environment, :load_models] do
       ::Mongoid::Tasks::Database.remove_undefined_indexes
     end
 
-    desc "Remove the indexes defined on your mongoid models without questions!"
+    desc "Remove indexes specified in Mongoid models"
     task :remove_indexes => [:environment, :load_models] do
       ::Mongoid::Tasks::Database.remove_indexes
     end
 
-    desc "Drops the default client database"
+    desc "Shard collections with shard keys specified in Mongoid models"
+    task :shard_collections => [:environment, :load_models] do
+      ::Mongoid::Tasks::Database.shard_collections
+    end
+
+    desc "Drop the database of the default Mongoid client"
     task :drop => :environment do
       ::Mongoid::Clients.default.database.drop
     end
 
-    desc "Drop all collections except the system collections"
+    desc "Drop all non-system collections"
     task :purge => :environment do
       ::Mongoid.purge!
     end

data/lib/mongoid/tasks/database.rb

@@ -108,6 +108,89 @@ module Mongoid
         end.compact
       end
 
+      # Shard collections for models that declare shard keys.
+      #
+      # Returns the model classes that have had their collections sharded,
+      # including model classes whose collections had already been sharded
+      # prior to the invocation of this method.
+      #
+      # @example Shard all collections
+      #   Mongoid::Tasks::Database.shard_collections
+      #
+      # @return [ Array<Class> ] The sharded models
+      def shard_collections(models = ::Mongoid.models)
+        models.map do |model|
+          next if model.shard_config.nil?
+
+          if model.embedded? && !model.cyclic?
+            logger.warn("MONGOID: #{model} has shard config but is emdedded")
+            next
+          end
+
+          unless model.collection.cluster.sharded?
+            logger.warn("MONGOID: #{model} has shard config but is not persisted in a sharded cluster: #{model.collection.cluster.summary}")
+            next
+          end
+
+          # 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]
+            logger.info("MONGOID: #{model.collection.namespace} is already sharded for #{model}")
+            next model
+          end
+
+          admin_db = model.collection.client.use(:admin).database
+
+          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
+            logger.error("MONGOID: Failed to shard collection #{model.collection.namespace} for #{model}: #{e.class}: #{e}")
+            next
+          end
+
+          logger.info("MONGOID: Sharded collection #{model.collection.namespace} for #{model}")
+
+          model
+        end.compact
+      end
+
       private
 
       def logger

data/lib/mongoid/timestamps/timeless.rb

@@ -44,11 +44,13 @@ module Mongoid
       end
 
       class << self
+        extend Forwardable
 
         def timeless_table
           Thread.current['[mongoid]:timeless'] ||= Hash.new
         end
-        delegate :[]=, :[], to: :timeless_table
+
+        def_delegators :timeless_table, :[]=, :[]
       end
 
       private

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/validatable/uniqueness.rb

@@ -150,7 +150,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.

data/lib/mongoid/version.rb

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