mongoid 6.4.8 → 7.0.0.beta

data/lib/mongoid/validatable/presence.rb

@@ -62,8 +62,8 @@ module Mongoid
       # @since 3.0.0
       def relation_or_fk_missing?(doc, attr, value)
         return true if value.blank? && doc.send(attr).blank?
-        metadata = doc.relations[attr.to_s]
-        metadata.stores_foreign_key? && doc.send(metadata.foreign_key).blank?
+        association = doc.relations[attr.to_s]
+        association.stores_foreign_key? && doc.send(association.foreign_key).blank?
       end
 
       # For guarding against false values.

data/lib/mongoid/validatable/uniqueness.rb

@@ -224,9 +224,9 @@ module Mongoid
       #
       # @since 2.4.4
       def to_validate(document, attribute, value)
-        metadata = document.relations[attribute.to_s]
-        if metadata && metadata.stores_foreign_key?
-          [ metadata.foreign_key, value && value._id ]
+        association = document.relations[attribute.to_s]
+        if association && association.stores_foreign_key?
+          [ association.foreign_key, value && value._id ]
         else
           [ attribute, value ]
         end
@@ -246,7 +246,7 @@ module Mongoid
       # @since 2.4.10
       def validate_embedded(document, attribute, value)
         return if skip_validation?(document)
-        relation = document._parent.send(document.metadata_name)
+        relation = document._parent.send(document.association_name)
         criteria = create_criteria(relation, document, attribute, value)
         criteria = criteria.merge(options[:conditions].call) if options[:conditions]
         add_error(document, attribute, value) if criteria.count > 1

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "6.4.8"
+  VERSION = "7.0.0.beta"
 end

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -11,10 +11,6 @@ development:
       hosts:
         - localhost:27017
       options:
-        # Note that all options listed below are Ruby driver client options (the mongo gem).
-        # Please refer to the driver documentation of the version of the mongo gem you are using
-        # for the most up-to-date list of options.
-        #
         # Change the default write concern. (default = { w: 1 })
         # write:
         #   w: 1
@@ -149,6 +145,9 @@ development:
     # Application name that is printed to the mongodb logs upon establishing a
     # connection in server versions >= 3.4. Note that the name cannot exceed 128 bytes.
     # app_name: MyApplicationName
+
+    # Use background indexes by default if `background` option not specified. (default: false)
+    # background_indexing: false
 test:
   clients:
     default:

data/spec/app/models/animal.rb

@@ -9,7 +9,8 @@ class Animal
   field :tags, type: Array
 
   embedded_in :person
-  embedded_in :circus
+  embedded_in :circus, class_name: 'Circus' # class_name is necessary because ActiveRecord think the singular of Circus
+                                            # is Circu
 
   validates_format_of :name, without: /\$\$\$/
 

data/spec/app/models/band.rb

@@ -20,7 +20,6 @@ class Band
 
   embeds_many :records, cascade_callbacks: true
   embeds_many :notes, as: :noteable, cascade_callbacks: true, validate: false
-  embeds_many :labels
   embeds_one :label, cascade_callbacks: true
 
   has_many :same_name, class_name: 'Agent', inverse_of: :same_name

data/spec/app/models/bomb.rb

@@ -1,4 +1,4 @@
 class Bomb
   include Mongoid::Document
-  has_one :explosion, dependent: :delete, autobuild: true
+  has_one :explosion, dependent: :delete_all, autobuild: true
 end

data/spec/app/models/message.rb

@@ -5,7 +5,7 @@ class Message
   field :priority, type: Integer
 
   embedded_in :person
-  has_and_belongs_to_many :receviers, class_name: "Person", inverse_of: nil
+  has_and_belongs_to_many :receivers, class_name: "Person", inverse_of: nil
 
   has_one :post, as: :posteable
 end

data/spec/app/models/person.rb

@@ -85,7 +85,7 @@ class Person
 
   has_many \
     :posts,
-    dependent: :delete,
+    dependent: :delete_all,
     validate: false do
     def extension
       "Testing"
@@ -105,7 +105,7 @@ class Person
   has_one :account, validate: false
   has_one :cat, dependent: :nullify, validate: false, primary_key: :username
   has_one :book, autobuild: true, validate: false
-  has_one :home, dependent: :delete, validate: false
+  has_one :home, dependent: :delete_all, validate: false
 
   has_and_belongs_to_many \
     :administrated_events,
@@ -114,6 +114,9 @@ class Person
     dependent:  :nullify,
     validate: false
 
+  belongs_to :mother, class_name: 'Person'
+  has_many :children, class_name: 'Person'
+
   accepts_nested_attributes_for :addresses
   accepts_nested_attributes_for :name, update_only: true
   accepts_nested_attributes_for :pet, allow_destroy: true

data/spec/app/models/vertex.rb

@@ -0,0 +1,6 @@
+class Vertex
+  include Mongoid::Document
+
+  has_and_belongs_to_many :parents, inverse_of: :children, class_name: 'Vertex'
+  has_and_belongs_to_many :children, inverse_of: :parents, class_name: 'Vertex'
+end

data/spec/app/models/wiki_page.rb

@@ -9,6 +9,6 @@ class WikiPage
 
   embeds_many :edits, validate: false
   has_many :comments, dependent: :destroy, validate: false
-  has_many :child_pages, class_name: "WikiPage", dependent: :delete, inverse_of: :parent_pages
+  has_many :child_pages, class_name: "WikiPage", dependent: :delete_all, inverse_of: :parent_pages
   belongs_to :parent_pages, class_name: "WikiPage", inverse_of: :child_pages
 end

data/spec/config/mongoid.yml

@@ -32,6 +32,7 @@ test:
     log_level: :warn
     belongs_to_required_by_default: false
     app_name: 'testing'
+    background_indexing: false
 test_with_max_staleness:
   clients:
     default:

data/spec/mongoid/{relations → association}/accessors_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Accessors do
+describe Mongoid::Association::Accessors do
 
   describe "\#{getter}?" do
 

data/spec/mongoid/{relations → association}/auto_save_spec.rb

@@ -1,11 +1,12 @@
 require "spec_helper"
 
-describe Mongoid::Relations::AutoSave do
+describe Mongoid::Association::Referenced::AutoSave do
 
   describe ".auto_save" do
 
     before(:all) do
-      Person.autosave(Person.relations["account"].merge!(autosave: true))
+      Person.has_many :drugs, validate: false, autosave: true
+      Person.has_one :account, validate: false, autosave: true
     end
 
     after(:all) do
@@ -42,13 +43,8 @@ describe Mongoid::Relations::AutoSave do
 
       context "when the relation has already had the autosave callback added" do
 
-        let(:metadata) do
-          Person.relations["drugs"].merge!(autosave: true)
-        end
-
         before do
-          Person.autosave(metadata)
-          Person.autosave(metadata)
+          Person.has_many :drugs, validate: false, autosave: true
         end
 
         let(:drug) do
@@ -71,6 +67,11 @@ describe Mongoid::Relations::AutoSave do
         context "when saving a new parent document" do
 
           context 'when persistence options are not set on the parent' do
+
+            before do
+              Person.has_many :drugs, validate: false, autosave: true
+            end
+
             before do
               person.drugs << drug
               person.save
@@ -254,10 +255,6 @@ describe Mongoid::Relations::AutoSave do
 
       context "when it has two relations with autosaves" do
 
-        before do
-          Person.autosave(Person.relations["drugs"].merge!(autosave: true))
-        end
-
         let!(:person) do
           Person.create(drugs: [percocet], account: account)
         end
@@ -309,6 +306,57 @@ describe Mongoid::Relations::AutoSave do
           end
         end
       end
+
+      context 'when the autosave should be cascaded' do
+
+        before do
+          class King
+            include Mongoid::Document
+            has_one :peasant, autosave: true
+          end
+
+          class Peasant
+            include Mongoid::Document
+            belongs_to :king
+            has_one :harvest, autosave: true
+          end
+
+          class Harvest
+            include Mongoid::Document
+            field :season, type: String
+            belongs_to :peasant
+          end
+        end
+
+        after do
+          Object.send(:remove_const, :King)
+          Object.send(:remove_const, :Peasant)
+          Object.send(:remove_const, :Harvest)
+        end
+
+        let(:king) do
+          King.create
+        end
+
+        let(:peasant) do
+          Peasant.create
+        end
+
+        let(:harvest) do
+          Harvest.create(season: 'Summer')
+        end
+
+        before do
+          peasant.harvest = harvest
+          king.peasant = peasant
+          harvest.season = 'Fall'
+          king.save
+        end
+
+        it 'cascades the save' do
+          expect(harvest.reload.season).to eq('Fall')
+        end
+      end
     end
   end
 end

data/spec/mongoid/{relations → association}/builders_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Builders do
+describe Mongoid::Association::Builders do
 
   describe "#build_#\{name}" do
 

data/spec/mongoid/association/constrainable_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+
+describe Mongoid::Association::Constrainable do
+
+  describe "#convert_to_foreign_key" do
+
+    context "when the id's class stores object ids" do
+
+      before(:all) do
+        Person.field(
+          :_id,
+          type: BSON::ObjectId,
+          pre_processed: true,
+          default: ->{ BSON::ObjectId.new },
+          overwrite: true
+        )
+      end
+
+      let(:constrainable) do
+        Post.belongs_to :person
+      end
+
+      context "when provided an object id" do
+
+        let(:object) do
+          BSON::ObjectId.new
+        end
+
+        it "returns the object id" do
+          expect(constrainable.convert_to_foreign_key(object)).to eq(object)
+        end
+      end
+
+      context "when provided a string" do
+
+        let(:object) do
+          BSON::ObjectId.new
+        end
+
+        it "returns an object id from the string" do
+          expect(constrainable.convert_to_foreign_key(object.to_s)).to eq(object)
+        end
+      end
+    end
+
+    context "when the id's class does not store object ids" do
+
+      let(:constrainable) do
+        Alert.belongs_to :account
+      end
+
+      it "returns the object" do
+        expect(constrainable.convert_to_foreign_key("testing")).to eq("testing")
+      end
+    end
+
+    context 'when the association is polymorphic' do
+
+      let(:constrainable) do
+        Post.relations['posteable']
+      end
+
+      let(:result) do
+        constrainable.convert_to_foreign_key(object)
+      end
+
+      context 'when a BSON::ObjectId is passed' do
+
+        let(:object) do
+          BSON::ObjectId.new
+        end
+
+        it 'returns the object id' do
+          expect(result).to eq(object)
+        end
+      end
+
+      context 'when a string is passed' do
+
+        context 'when the string represents an ObjectId' do
+
+          let(:object) do
+            BSON::ObjectId.new.to_s
+          end
+
+          it 'returns the object id' do
+            expect(result).to eq(BSON::ObjectId.from_string(object))
+          end
+        end
+
+        context 'when the string does not represent an ObjectId' do
+
+          let(:object) do
+            'some-other-string'
+          end
+
+          it 'returns the object' do
+            expect(result).to eq(object)
+          end
+        end
+      end
+
+      context 'when a model object is passed' do
+
+        let(:object) do
+          Post.new
+        end
+
+        it 'returns the id' do
+          expect(result).to eq(object.id)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/{relations → association}/counter_cache_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Relations::CounterCache do
+describe Mongoid::Association::Referenced::CounterCache do
 
   describe "#reset_counters" do
 

data/spec/mongoid/association/depending_spec.rb

@@ -0,0 +1,613 @@
+require "spec_helper"
+
+describe Mongoid::Association::Depending do
+
+  around(:each) do |example|
+    relations_before = Person.relations
+    example.run
+    Person.relations = relations_before
+  end
+
+  describe "#apply_delete_dependencies!" do
+
+    let(:band) do
+      Band.new
+    end
+
+    context "when the association exists in the list of dependencies" do
+
+      context "when the association has no dependent strategy" do
+
+        before do
+          band.dependents.push(Band.relations["records"])
+        end
+
+        after do
+          band.dependents.delete(Band.relations["records"])
+        end
+
+        it "ignores the dependency" do
+          expect(band.apply_delete_dependencies!).to eq([Band.relations["records"]])
+        end
+      end
+    end
+  end
+
+  describe ".define_dependency!" do
+
+    let(:klass) do
+      Class.new.tap { |c| c.send(:include, Mongoid::Document) }
+    end
+
+    context "when the association metadata doesnt exist" do
+
+      before do
+        klass.dependents.push("nothing")
+      end
+
+      it "does not raise an error" do
+        expect {
+          klass.new.apply_delete_dependencies!
+        }.not_to raise_error
+      end
+    end
+
+    context "when a dependent option is provided" do
+
+      let!(:association) do
+        klass.has_many :posts, dependent: :destroy
+      end
+
+      after do
+        klass.relations.delete(association.name.to_s)
+      end
+
+      it "adds the relation to the dependents" do
+        expect(klass.dependents).to include(klass.relations["posts"])
+      end
+    end
+
+    context "when no dependent option is provided" do
+
+      let!(:association) do
+        klass.has_many :posts
+      end
+
+      after do
+        klass.relations.delete(association.name.to_s)
+      end
+
+      it "does not add a relation to the dependents" do
+        expect(klass.dependents).to_not include(association)
+      end
+    end
+
+    context 'when the class is defined more than once' do
+
+      let!(:association) do
+        klass.has_many :posts, dependent: :destroy
+        klass.has_many :posts, dependent: :destroy
+      end
+
+      it 'only creates the dependency once' do
+        expect(klass.dependents.size).to eq(1)
+      end
+    end
+  end
+
+  [:delete, :destroy].each do |method|
+
+    describe "##{method}" do
+
+      context "when cascading removals" do
+
+        context "when strategy is delete" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:post) do
+            person.posts.create(title: "Testing")
+          end
+
+          before do
+            person.send(method)
+          end
+
+          it "deletes the associated documents" do
+            expect {
+              Post.find(post.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context "when strategy is destroy" do
+
+          let(:person) do
+            Person.create
+          end
+
+          let!(:game) do
+            person.create_game(name: "Pong")
+          end
+
+          before do
+            person.send(method)
+          end
+
+          it "destroys the associated documents" do
+            expect {
+              Game.find(game.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context "when strategy is nullify" do
+
+          context "when nullifying a references many" do
+
+            let(:movie) do
+              Movie.create(title: "Bladerunner")
+            end
+
+            let!(:rating) do
+              movie.ratings.create(value: 10)
+            end
+
+            let(:from_db) do
+              Rating.find(rating.id)
+            end
+
+            before do
+              movie.send(method)
+            end
+
+            it "removes the references to the removed document" do
+              expect(from_db.ratable_id).to be_nil
+            end
+          end
+
+          context "when nullifying a references one" do
+
+            context "when the relation exists" do
+
+              let(:book) do
+                Book.create(title: "Neuromancer")
+              end
+
+              let!(:rating) do
+                book.create_rating(value: 10)
+              end
+
+              let(:from_db) do
+                Rating.find(rating.id)
+              end
+
+              before do
+                book.send(method)
+              end
+
+              it "removes the references to the removed document" do
+                expect(from_db.ratable_id).to be_nil
+              end
+            end
+
+            context "when the relation is nil" do
+
+              let(:book) do
+                Book.create(title: "Neuromancer")
+              end
+
+              it "returns nil" do
+                expect(book.send(method)).to be true
+              end
+            end
+          end
+
+          context "when nullifying a many to many" do
+
+            let(:person) do
+              Person.create
+            end
+
+            let!(:preference) do
+              person.preferences.create(name: "Setting")
+            end
+
+            let(:from_db) do
+              Preference.find(preference.id)
+            end
+
+            before do
+              person.send(method)
+            end
+
+            it "removes the references from the removed document" do
+              expect(person.preference_ids).to_not include(preference.id)
+            end
+
+            it "removes the references to the removed document" do
+              expect(from_db.person_ids).to_not include(person.id)
+            end
+          end
+        end
+
+        context "when dependent is restrict_with_error" do
+
+          context "when restricting a references many" do
+
+            let!(:association) do
+              Person.has_many :drugs, dependent: :restrict_with_exception
+            end
+
+            after do
+              Person.dependents.delete(association)
+              Person.has_many :drugs, validate: false
+            end
+
+            context "when the relation is empty" do
+
+              let(:person) do
+                Person.new drugs: []
+              end
+
+              it "raises no error" do
+                expect { person.send(method) }.to_not raise_error
+              end
+
+              it "deletes the parent" do
+                person.send(method)
+                expect(person).to be_destroyed
+              end
+            end
+
+            context "when the relation is not empty" do
+
+              let(:person) do
+                Person.new drugs: [Drug.new]
+              end
+
+              it "raises DeleteRestriction error" do
+                expect { person.send(method) }.to raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+            end
+          end
+
+          context "when restricting a references one" do
+
+            let!(:association) do
+              Person.has_one :account, dependent: :restrict_with_exception
+            end
+
+            after do
+              Person.dependents.delete(association)
+              Person.has_one :account, validate: false
+            end
+
+            context "when the relation is empty" do
+
+              let(:person) do
+                Person.new account: nil
+              end
+
+              it "raises no error" do
+                expect { person.send(method) }.to_not raise_error
+              end
+
+              it "deletes the parent" do
+                person.send(method)
+                expect(person).to be_destroyed
+              end
+            end
+
+            context "when the relation is not empty" do
+
+              let(:person) do
+                Person.new account: Account.new(name: 'test')
+              end
+
+              it "raises DeleteRestriction error" do
+                expect { person.send(method) }.to raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+            end
+          end
+
+          context "when restricting a many to many" do
+
+            let!(:association) do
+              Person.has_and_belongs_to_many :houses, dependent: :restrict_with_exception
+            end
+
+            after do
+              Person.dependents.delete(association)
+              Person.has_and_belongs_to_many :houses, validate: false
+            end
+
+            context "when the relation is empty" do
+
+              let(:person) do
+                Person.new houses: []
+              end
+
+              it "raises no error" do
+                expect { person.send(method) }.to_not raise_error
+              end
+
+              it "deletes the parent" do
+                person.send(method)
+                expect(person).to be_destroyed
+              end
+            end
+
+            context "when the relation is not empty" do
+
+              let(:person) do
+                Person.new houses: [House.new]
+              end
+
+              it "raises DeleteRestriction error" do
+                expect { person.send(method) }.to raise_error(Mongoid::Errors::DeleteRestriction)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'when the strategy is :delete_all' do
+
+    let(:person) do
+      Person.create
+    end
+
+    context "when cascading a has one" do
+
+      context "when the relation exists" do
+
+        let!(:home) do
+          person.create_home
+        end
+
+        before do
+          person.delete
+        end
+
+        it "deletes the relation" do
+          expect(home).to be_destroyed
+        end
+
+        it "persists the deletion" do
+          expect {
+            home.reload
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+
+      context "when the relation does not exist" do
+
+        before do
+          person.delete
+        end
+
+        it "deletes the base document" do
+          expect(person).to be_destroyed
+        end
+      end
+    end
+
+    context "when cascading a has many" do
+
+      context "when the relation has documents" do
+
+        let!(:post_one) do
+          person.posts.create(title: "one")
+        end
+
+        let!(:post_two) do
+          person.posts.create(title: "two")
+        end
+
+        context "when the documents are in memory" do
+
+          before do
+            expect(post_one).to receive(:delete).never
+            expect(post_two).to receive(:delete).never
+            person.delete
+          end
+
+          it "deletes the first document" do
+            expect(post_one).to be_destroyed
+          end
+
+          it "deletes the second document" do
+            expect(post_two).to be_destroyed
+          end
+
+          it "unbinds the first document" do
+            expect(post_one.person).to be_nil
+          end
+
+          it "unbinds the second document" do
+            expect(post_two.person).to be_nil
+          end
+
+          it "removes the documents from the relation" do
+            expect(person.posts).to be_empty
+          end
+
+          it "persists the first deletion" do
+            expect {
+              post_one.reload
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+
+          it "persists the second deletion" do
+            expect {
+              post_two.reload
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+      end
+    end
+  end
+
+  context 'when the strategy is :destroy' do
+
+    let!(:association) do
+      Person.has_many :destroyable_posts, class_name: "Post", dependent: :destroy
+    end
+
+    after do
+      Person.dependents.delete(association)
+    end
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:post) do
+      Post.new
+    end
+
+    context "when the documents exist" do
+
+      before do
+        expect(post).to receive(:destroy)
+        person.destroyable_posts << post
+      end
+
+      it "destroys all documents in the relation" do
+        person.delete
+      end
+    end
+
+    context "when no documents exist" do
+
+      before do
+        expect(post).to receive(:destroy).never
+      end
+
+      it "it does not destroy the relation" do
+        person.delete
+      end
+    end
+  end
+
+  context 'when the strategy is :nullify' do
+
+    let!(:association) do
+      Person.has_many :nullifyable_posts, class_name: "Post", dependent: :nullify
+    end
+
+    after do
+      Person.dependents.delete(association)
+    end
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:posts_relation) do
+      person.posts
+    end
+
+    before do
+      allow(person).to receive(:nullifyable_posts).and_return(posts_relation)
+      expect(posts_relation).to receive(:nullify)
+    end
+
+    it "nullifies the relation" do
+      person.delete
+    end
+  end
+
+  context 'when the strategy is :restrict_with_exception' do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:post) do
+      Post.new
+    end
+
+    let!(:association) do
+      Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_exception
+    end
+
+    after do
+      Person.dependents.delete(association)
+    end
+
+    context 'when there are related objects' do
+
+      before do
+        person.restrictable_posts << post
+        expect(post).to receive(:delete).never
+        expect(post).to receive(:destroy).never
+      end
+
+      it 'raises an exception and leaves the related one intact' do
+        expect { person.delete }.to raise_exception(Mongoid::Errors::DeleteRestriction)
+      end
+    end
+
+    context 'when there are no related objects' do
+
+      before do
+        expect(post).to receive(:delete).never
+        expect(post).to receive(:destroy).never
+      end
+
+      it 'deletes the object and leaves the other one intact' do
+        expect(person.delete).to be(true)
+      end
+    end
+  end
+
+  context 'when the strategy is :restrict_with_error' do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:post) do
+      Post.new
+    end
+
+    let!(:association) do
+      Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_error
+    end
+
+    after do
+      Person.dependents.delete(association)
+    end
+
+    context 'when there are related objects' do
+
+      before do
+        person.restrictable_posts << post
+      end
+
+      it 'adds an error to the parent object' do
+        expect(person.delete).to be(false)
+        expect(person.errors[:restrictable_posts].first).to be(
+          Mongoid::Association::Depending::RESTRICT_ERROR_MSG)
+      end
+    end
+
+    context 'when there are no related objects' do
+
+      before do
+        expect(post).to receive(:delete).never
+        expect(post).to receive(:destroy).never
+      end
+
+      it 'deletes the object and leaves the other one intact' do
+        expect(person.delete).to be(true)
+      end
+    end
+  end
+end