mongoid 7.1.7 → 7.2.0.rc1

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

@@ -80,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/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.7"
+  VERSION = "7.2.0.rc1"
 end

data/spec/integration/app_spec.rb

@@ -150,7 +150,7 @@ describe 'Mongoid application tests' do
                 end
                 index.should be nil
 
-                ChildProcessHelper.check_call(%w(bundle exec rake db:mongoid:create_indexes),
+                ChildProcessHelper.check_call(%w(rake db:mongoid:create_indexes),
                   cwd: APP_PATH, env: env)
 
                 index = client['posts'].indexes.detect do |index|
@@ -181,44 +181,11 @@ 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' => uri,
+      'uri' => "#{SpecConfig.instance.uri_str}/mongoid_test",
     }}}
     config = {'development' => env_config, 'production' => env_config}
     File.open('config/mongoid.yml', 'w') do |f|

data/spec/integration/associations/embedded_spec.rb

@@ -172,4 +172,98 @@ describe 'embedded associations' do
       end
     end
   end
+
+  describe 'updated_at on parent' do
+    context 'when child is added' do
+      context 'embeds_one' do
+        let(:parent) { EomParent.create! }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.child = EomChild.new
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+
+      context 'embeds_many' do
+        let(:parent) { EmmCongress.create! }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.legislators << EmmLegislator.new
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+    end
+
+    context 'when child is updated' do
+      context 'embeds_one' do
+        let(:parent) { EomParent.create!(child: EomChild.new) }
+
+        it 'updates' do
+          first_updated_at = parent.updated_at
+
+          parent.child.a = 42
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+
+      context 'embeds_many' do
+        let(:parent) { EmmCongress.create!(legislators: [EmmLegislator.new]) }
+
+        it 'updates' do
+          first_updated_at = parent.updated_at
+
+          parent.legislators.first.a = 42
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+    end
+
+    context 'when child is removed' do
+      context 'embeds_one' do
+        let(:parent) { EomParent.create!(child: EomChild.new) }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.child = nil
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+
+      context 'embeds_many' do
+        let(:parent) { EmmCongress.create!(legislators: [EmmLegislator.new]) }
+
+        it 'updates' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-3252'
+
+          first_updated_at = parent.updated_at
+
+          parent.legislators.clear
+          parent.save!
+
+          parent.updated_at.should > first_updated_at
+        end
+      end
+    end
+  end
 end

data/spec/integration/associations/has_many_spec.rb

@@ -2,74 +2,67 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'mongoid/association/referenced/has_many_models'
 
 describe 'has_many associations' do
   context 'destroying parent in transaction with dependent child' do
     require_transaction_support
 
-    let(:artist) { Artist.create! }
-    let(:album) { Album.create!(artist: artist) }
+    let(:company) { HmmCompany.create! }
+    let(:address) { HmmAddress.create!(company: company) }
 
     before do
-      Artist.delete_all
-      Album.delete_all
-
-      album
+      Company.delete_all
+      Address.delete_all
     end
 
-    it 'works' do
-      Artist.count.should == 1
-      Album.count.should == 1
-
-      artist.with_session do |session|
-        session.with_transaction do
-          artist.destroy
+    context 'dependent: :destroy' do
+      before do
+        HmmCompany.class_eval do
+          has_one :address, class_name: 'HmmAddress', dependent: :destroy
         end
       end
 
-      Artist.count.should == 0
-      Album.count.should == 0
-    end
-  end
+      it 'destroys' do
+        address
 
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:wiki_page) do
-        WikiPage.create!
-      end
+        HmmCompany.count.should == 1
+        HmmAddress.count.should == 1
 
-      let!(:comment) do
-        Comment.create!(wiki_page: wiki_page, title: 'hi') do
-          wiki_page.reload
+        company.with_session do |session|
+          session.with_transaction do
+            company.destroy!
+          end
         end
-      end
 
-      it 'does not destroy the dependent object' do
-        wiki_page.comments.should == [comment]
-        wiki_page.comments = [comment]
-        wiki_page.save!
-        wiki_page.reload
-        wiki_page.comments.should == [comment]
+        HmmCompany.count.should == 0
+        HmmAddress.count.should == 0
       end
     end
 
-    context 'without dependent: destroy' do
-      let(:series) do
-        Series.create!
-      end
-
-      let!(:book) do
-        Book.create!(series: series).tap do
-          series.reload
+    context 'dependent: :restrict_with_error' do
+      before do
+        HmmCompany.class_eval do
+          has_one :address, class_name: 'HmmAddress', dependent: :restrict_with_error
         end
       end
 
-      it 'does not destroy the dependent object' do
-        series.books.should == [book]
-        series.books = [book]
-        series.save!
-        series.reload
-        series.books.should == [book]
+      it 'destroys' do
+        address
+
+        HmmCompany.count.should == 1
+        HmmAddress.count.should == 1
+
+        lambda do
+          company.with_session do |session|
+            session.with_transaction do
+              company.destroy!
+            end
+          end
+        end.should raise_error(Mongoid::Errors::DocumentNotDestroyed)
+
+        HmmCompany.count.should == 1
+        HmmAddress.count.should == 1
       end
     end
   end

data/spec/integration/associations/has_one_spec.rb

@@ -2,74 +2,67 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'mongoid/association/referenced/has_one_models'
 
 describe 'has_one associations' do
   context 'destroying parent in transaction with dependent child' do
     require_transaction_support
 
-    let(:person) { Person.create! }
-    let(:game) { Game.create!(person: person) }
+    let(:college) { HomCollege.create! }
+    let(:address) { HomAddress.create!(college: college) }
 
     before do
-      Person.delete_all
-      Game.delete_all
-
-      game
+      HomCollege.delete_all
+      HomAddress.delete_all
     end
 
-    it 'works' do
-      Person.count.should == 1
-      Game.count.should == 1
-
-      Person.with_session do |session|
-        session.with_transaction do
-          person.destroy
+    context 'dependent: :destroy' do
+      before do
+        HomCollege.class_eval do
+          has_one :address, class_name: 'HomAddress', dependent: :destroy
         end
       end
 
-      Person.count.should == 0
-      Game.count.should == 0
-    end
-  end
+      it 'destroys' do
+        address
 
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:person) do
-        Person.create!
-      end
+        HomCollege.count.should == 1
+        HomAddress.count.should == 1
 
-      let!(:game) do
-        Game.create!(person: person) do
-          person.reload
+        HomCollege.with_session do |session|
+          session.with_transaction do
+            college.destroy!
+          end
         end
-      end
 
-      it 'does not destroy the dependent object' do
-        person.game.should == game
-        person.game = person.game
-        person.save!
-        person.reload
-        person.game.should == game
+        HomCollege.count.should == 0
+        HomAddress.count.should == 0
       end
     end
 
-    context 'without dependent: destroy' do
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:account) do
-        Account.create!(person: person, name: 'foo').tap do
-          person.reload
+    context 'dependent: :restrict_with_error' do
+      before do
+        HomCollege.class_eval do
+          has_one :address, class_name: 'HomAddress', dependent: :restrict_with_error
         end
       end
 
-      it 'does not destroy the dependent object' do
-        person.account.should == account
-        person.account = person.account
-        person.save!
-        person.reload
-        person.account.should == account
+      it 'does not destroy' do
+        address
+
+        HomCollege.count.should == 1
+        HomAddress.count.should == 1
+
+        lambda do
+          HomCollege.with_session do |session|
+            session.with_transaction do
+              college.destroy!
+            end
+          end
+        end.should raise_error(Mongoid::Errors::DocumentNotDestroyed)
+
+        HomCollege.count.should == 1
+        HomAddress.count.should == 1
       end
     end
   end