mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/referenced/has_many/enumerable_spec.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Referenced::HasMany::Enumerable do
-
-  describe "#==" do
-
-    context "when comparing with an enumerable" do
-
+  describe '#==' do
+    context 'when comparing with an enumerable' do
       let(:person) do
         Person.create!
       end
@@ -17,8 +13,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         Post.create!(person_id: person.id)
       end
 
-      context "when only a criteria target exists" do
-
+      context 'when only a criteria target exists' do
         let(:criteria) do
           Post.where(person_id: person.id)
         end
@@ -27,24 +22,22 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           described_class.new(criteria)
         end
 
-        it "returns the equality check" do
+        it 'returns the equality check' do
           expect(enumerable).to eq([ post ])
         end
       end
 
-      context "when only an array target exists" do
-
+      context 'when only an array target exists' do
         let!(:enumerable) do
           described_class.new([ post ])
         end
 
-        it "returns the equality check" do
+        it 'returns the equality check' do
           expect(enumerable._loaded.values).to eq([ post ])
         end
       end
 
-      context "when a criteria and added exist" do
-
+      context 'when a criteria and added exist' do
         let(:criteria) do
           Post.where(person_id: person.id)
         end
@@ -57,42 +50,38 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           Post.new
         end
 
-        context "when the added does not contain unloaded docs" do
-
+        context 'when the added does not contain unloaded docs' do
           before do
             enumerable << post_two
           end
 
-          it "returns the equality check" do
+          it 'returns the equality check' do
             expect(enumerable).to eq([ post, post_two ])
           end
         end
 
-        context "when the added contains unloaded docs" do
-
+        context 'when the added contains unloaded docs' do
           before do
             enumerable << post
           end
 
-          it "returns the equality check" do
+          it 'returns the equality check' do
             expect(enumerable).to eq([ post ])
           end
         end
 
-        context "when the enumerable is loaded" do
-
+        context 'when the enumerable is loaded' do
           before do
             enumerable.instance_variable_set(:@executed, true)
           end
 
-          context "when the loaded has no docs and added is persisted" do
-
+          context 'when the loaded has no docs and added is persisted' do
             before do
               post.save!
               enumerable._added[post.id] = post
             end
 
-            it "returns the equality check" do
+            it 'returns the equality check' do
               expect(enumerable).to eq([ post ])
             end
           end
@@ -100,79 +89,70 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
     end
 
-    context "when comparing with a non enumerable" do
-
+    context 'when comparing with a non enumerable' do
       let(:enumerable) do
         described_class.new([])
       end
 
-      it "returns false" do
-        expect(enumerable).to_not eq("person")
+      it 'returns false' do
+        expect(enumerable).not_to eq('person')
       end
     end
   end
 
-  describe "#===" do
-
+  describe '#===' do
     let(:data) { [] }
 
     shared_examples 'standard library-compatible enumerable' do
-      context "when compared to an array class" do
-
-        it "returns false" do
+      context 'when compared to an array class' do
+        it 'returns false' do
           expect(enumerable === Array).to be false
         end
       end
 
-      context "when compared to an enumerable class" do
-
-        it "returns false" do
+      context 'when compared to an enumerable class' do
+        it 'returns false' do
           expect(enumerable === described_class).to be false
         end
       end
 
-      context "when compared to a different class" do
-
-        it "returns false" do
+      context 'when compared to a different class' do
+        it 'returns false' do
           expect(enumerable === Mongoid::Document).to be false
         end
       end
 
-      context "when compared to an array instance" do
-
-        context "when the entries are equal" do
-
+      context 'when compared to an array instance' do
+        context 'when the entries are equal' do
           let(:data) do
-            [Post.new(id: 2)]
+            [ Post.new(id: 2) ]
           end
 
           let(:other) do
-            described_class.new([Post.new(id: 2)])
+            described_class.new([ Post.new(id: 2) ])
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(enumerable === other).to be true
           end
         end
 
-        context "when the entries are both empty" do
-
+        context 'when the entries are both empty' do
           let(:other) do
             described_class.new([])
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(enumerable === other).to be true
           end
         end
 
-        context "when the entries are not equal" do
-
+        context 'when the entries are not equal' do
           let(:other) do
             described_class.new([ Band.new ])
           end
 
-          it "returns false" do
+          it 'returns false' do
             expect(enumerable === other).to be false
           end
         end
@@ -196,8 +176,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#<<" do
-
+  describe '#<<' do
     let(:person) do
       Person.create!
     end
@@ -210,21 +189,20 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       described_class.new([])
     end
 
-    context "when the association is empty" do
-
+    context 'when the association is empty' do
       let!(:added) do
         enumerable << post
       end
 
-      it "adds the document to the added target" do
+      it 'adds the document to the added target' do
         expect(enumerable._added).to eq({ post.id => post })
       end
 
-      it "returns the added documents" do
+      it 'returns the added documents' do
         expect(added).to eq([ post ])
       end
 
-      it "sets the base on the new document" do
+      it 'sets the base on the new document' do
         expect_query(0) do
           added.collect(&:person)
         end
@@ -232,8 +210,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#empty?" do
-
+  describe '#empty?' do
     let(:person) do
       Person.create!
     end
@@ -246,8 +223,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       Post.create!(person_id: person.id)
     end
 
-    context "when only a criteria target exists" do
-
+    context 'when only a criteria target exists' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -260,40 +236,38 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.empty?
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(empty).to be false
       end
 
       context 'when #empty? is called' do
-
         before { empty }
 
-        it "retains the correct length" do
+        it 'retains the correct length' do
           expect(enumerable.length).to eq(2)
         end
 
-        it "retains the correct length when calling to_a" do
+        it 'retains the correct length when calling to_a' do
           expect(enumerable.to_a.length).to eq(2)
         end
 
-        context "when iterating over the association a second time" do
-
+        context 'when iterating over the association a second time' do
           before do
             enumerable.each { |post| post }
           end
 
-          it "retains the correct length" do
+          it 'retains the correct length' do
             expect(enumerable.length).to eq(2)
           end
 
-          it "retains the correct length when calling to_a" do
+          it 'retains the correct length when calling to_a' do
             expect(enumerable.to_a.length).to eq(2)
           end
         end
       end
     end
 
-    context "when the documents have been loaded" do
+    context 'when the documents have been loaded' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -306,18 +280,17 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.load_all!
       end
 
-      it "is _loaded" do
+      it 'is _loaded' do
         expect(enumerable._loaded?).to be true
       end
 
-      it "it does not call #exists? on the unloaded scope" do
-        expect(enumerable._unloaded).to_not receive(:exists?)
+      it 'does not call #exists? on the unloaded scope' do
+        expect(enumerable._unloaded).not_to receive(:exists?)
         expect(enumerable.empty?).to be false
       end
     end
 
-    context "when the documents are not loaded" do
-
+    context 'when the documents are not loaded' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -326,35 +299,33 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new(criteria)
       end
 
-      it "is not _loaded" do
+      it 'is not _loaded' do
         expect(enumerable._loaded?).to be false
       end
 
-      it "it calls #exists? on the unloaded scope" do
+      it 'calls #exists? on the unloaded scope' do
         expect(enumerable._unloaded).to receive(:exists?)
         expect(enumerable.empty?).to be true
       end
 
-      context "when documents are added" do
-
+      context 'when documents are added' do
         before do
           enumerable << post_one
         end
 
-        it "is not _loaded" do
+        it 'is not _loaded' do
           expect(enumerable._loaded?).to be false
         end
 
-        it "it does not call #exists? on the unloaded scope" do
-          expect(enumerable._unloaded).to_not receive(:exists?)
+        it 'does not call #exists? on the unloaded scope' do
+          expect(enumerable._unloaded).not_to receive(:exists?)
           expect(enumerable.empty?).to be false
         end
       end
     end
   end
 
-  describe "#any?" do
-
+  describe '#any?' do
     let(:person) do
       Person.create!
     end
@@ -367,8 +338,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       Post.create!(person_id: person.id)
     end
 
-    context "when only a criteria target exists" do
-
+    context 'when only a criteria target exists' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -381,40 +351,38 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.any?
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(any).to be true
       end
 
       context 'when #any? is called' do
-
         before { any }
 
-        it "retains the correct length" do
+        it 'retains the correct length' do
           expect(enumerable.length).to eq(2)
         end
 
-        it "retains the correct length when calling to_a" do
+        it 'retains the correct length when calling to_a' do
           expect(enumerable.to_a.length).to eq(2)
         end
 
-        context "when iterating over the association a second time" do
-
+        context 'when iterating over the association a second time' do
           before do
             enumerable.each { |post| post }
           end
 
-          it "retains the correct length" do
+          it 'retains the correct length' do
             expect(enumerable.length).to eq(2)
           end
 
-          it "retains the correct length when calling to_a" do
+          it 'retains the correct length when calling to_a' do
             expect(enumerable.to_a.length).to eq(2)
           end
         end
       end
     end
 
-    context "when the documents have been loaded" do
+    context 'when the documents have been loaded' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -427,52 +395,49 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.load_all!
       end
 
-      it "is _loaded" do
+      it 'is _loaded' do
         expect(enumerable._loaded?).to be true
       end
 
-      it "it does not call #exists? on the unloaded scope" do
-        expect(enumerable._unloaded).to_not receive(:exists?)
+      it 'does not call #exists? on the unloaded scope' do
+        expect(enumerable._unloaded).not_to receive(:exists?)
         expect(enumerable.any?).to be true
       end
 
-      context "when a block is given" do
-        it "returns true when the predicate is true" do
+      context 'when a block is given' do
+        it 'returns true when the predicate is true' do
           expect(
-            enumerable.any? { |doc| true }
+            enumerable.any? { |_doc| true }
           ).to be true
         end
 
-        it "returns false when the predicate is false" do
+        it 'returns false when the predicate is false' do
           expect(
-            enumerable.any? { |doc| false }
+            enumerable.any? { |_doc| false }
           ).to be false
         end
       end
 
-      context "when an argument is given" do
-
-        it "returns true when the argument is true" do
+      context 'when an argument is given' do
+        it 'returns true when the argument is true' do
           expect(enumerable.any?(Post)).to be true
         end
 
-        it "returns false when the argument is false" do
+        it 'returns false when the argument is false' do
           expect(enumerable.any?(Sandwich)).to be false
         end
       end
 
-      context "when both an argument and a block are given" do
-
-        it "gives precedence to the pattern" do
+      context 'when both an argument and a block are given' do
+        it 'gives precedence to the pattern' do
           expect(
-            enumerable.any?(Post) { |doc| false }
+            enumerable.any?(Post) { |_doc| false }
           ).to be true
         end
       end
     end
 
-    context "when the documents are not loaded" do
-
+    context 'when the documents are not loaded' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -481,125 +446,115 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new(criteria)
       end
 
-      it "is not _loaded" do
+      it 'is not _loaded' do
         expect(enumerable._loaded?).to be false
       end
 
-      it "it calls #exists? on the unloaded scope" do
+      it 'calls #exists? on the unloaded scope' do
         expect(enumerable._unloaded).to receive(:exists?)
         expect(enumerable.any?).to be false
       end
 
-      context "when documents are added" do
-
+      context 'when documents are added' do
         before do
           enumerable << post_one
         end
 
-        it "is not _loaded" do
+        it 'is not _loaded' do
           expect(enumerable._loaded?).to be false
         end
 
-        it "it does not call #exists? on the unloaded scope" do
-          expect(enumerable._unloaded).to_not receive(:exists?)
+        it 'does not call #exists? on the unloaded scope' do
+          expect(enumerable._unloaded).not_to receive(:exists?)
           expect(enumerable.any?).to be true
         end
       end
 
-      context "when a block is given" do
-        it "returns true when the predicate is true" do
+      context 'when a block is given' do
+        it 'returns true when the predicate is true' do
           expect(
-            enumerable.any? { |doc| true }
+            enumerable.any? { |_doc| true }
           ).to be true
         end
 
-        it "returns false when the predicate is false" do
+        it 'returns false when the predicate is false' do
           expect(
-            enumerable.any? { |doc| false }
+            enumerable.any? { |_doc| false }
           ).to be false
         end
       end
 
-      context "when an argument is given" do
-
-        it "returns true when the argument is true" do
+      context 'when an argument is given' do
+        it 'returns true when the argument is true' do
           expect(enumerable.any?(Post)).to be true
         end
 
-        it "returns false when the argument is false" do
+        it 'returns false when the argument is false' do
           expect(enumerable.any?(Sandwich)).to be false
         end
       end
 
-      context "when both an argument and a block are given" do
-
-        it "gives precedence to the pattern" do
+      context 'when both an argument and a block are given' do
+        it 'gives precedence to the pattern' do
           expect(
-            enumerable.any?(Post) { |doc| false }
+            enumerable.any?(Post) { |_doc| false }
           ).to be true
         end
       end
     end
   end
 
-  describe "#clear" do
+  describe '#clear' do
+    let(:person) { Person.create! }
+    let(:post) { Post.create!(person_id: person.id) }
+    let(:post_two) { Post.create!(person_id: person.id) }
+    let(:criteria) { Post.where(person_id: person.id) }
+    let(:enumerable) { described_class.new(criteria) }
 
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:post) do
-      Post.create!(person_id: person.id)
-    end
-
-    let!(:post_two) do
-      Post.create!(person_id: person.id)
-    end
-
-    let(:criteria) do
-      Post.where(person_id: person.id)
-    end
-
-    let(:enumerable) do
-      described_class.new(criteria)
+    let(:clear) do
+      enumerable.clear do |doc|
+        expect(doc).to be_a(Post)
+      end
     end
 
     before do
+      post
+      post_two
+
       enumerable._loaded[post.id] = post
       enumerable << post
-    end
 
-    let!(:clear) do
-      enumerable.clear do |doc|
-        expect(doc).to be_a(Post)
-      end
+      clear
     end
 
-    it "clears out the loaded docs" do
+    it 'clears out the loaded docs' do
       expect(enumerable._loaded).to be_empty
     end
 
-    it "clears out the added docs" do
+    it 'clears out the added docs' do
       expect(enumerable._added).to be_empty
     end
 
-    it "retains its loaded state" do
-      expect(enumerable).to_not be__loaded
+    it 'retains its loaded state' do
+      expect(enumerable).not_to be__loaded
     end
   end
 
-  describe "#clone" do
-
+  describe '#clone' do
     let(:person) do
       Person.create!
     end
 
+    let(:cloned) do
+      enumerable.clone
+    end
+
     let!(:post) do
-      Post.create!(title: "one", person_id: person.id)
+      Post.create!(title: 'one', person_id: person.id)
     end
 
     let!(:post_two) do
-      Post.create!(title: "two", person_id: person.id)
+      Post.create!(title: 'two', person_id: person.id)
     end
 
     let(:criteria) do
@@ -615,27 +570,21 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       enumerable << post_two
     end
 
-    let(:cloned) do
-      enumerable.clone
-    end
-
-    it "does not retain the first id" do
-      expect(cloned.first).to_not eq(post)
+    it 'does not retain the first id' do
+      expect(cloned.first).not_to eq(post)
     end
 
-    it "does not retain the last id" do
-      expect(cloned.last).to_not eq(post_two)
+    it 'does not retain the last id' do
+      expect(cloned.last).not_to eq(post_two)
     end
   end
 
-  describe "#delete" do
-
+  describe '#delete' do
     let(:person) do
       Person.create!
     end
 
-    context "when the document is loaded" do
-
+    context 'when the document is loaded' do
       let!(:post) do
         Post.create!(person_id: person.id)
       end
@@ -648,75 +597,57 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.delete(post)
       end
 
-      it "deletes the document from the enumerable" do
+      it 'deletes the document from the enumerable' do
         expect(enumerable._loaded).to be_empty
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(deleted).to eq(post)
       end
     end
 
-    context "when the document is added" do
-
-      let!(:post) do
-        Post.new
-      end
-
-      let(:criteria) do
-        Person.where(person_id: person.id)
-      end
-
-      let!(:enumerable) do
-        described_class.new(criteria)
-      end
+    context 'when the document is added' do
+      let(:post) { Post.new }
+      let(:deleted) { enumerable.delete(post) }
+      let(:criteria) { Person.where(person_id: person.id) }
+      let(:enumerable) { described_class.new(criteria) }
 
       before do
         enumerable << post
+        deleted
       end
 
-      let!(:deleted) do
-        enumerable.delete(post)
-      end
-
-      it "removes the document from the added docs" do
+      it 'removes the document from the added docs' do
         expect(enumerable._added).to be_empty
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(deleted).to eq(post)
       end
     end
 
-    context "when the document is unloaded" do
-
-      let!(:post) do
-        Post.create!(person_id: person.id)
-      end
-
-      let(:criteria) do
-        Post.where(person_id: person.id)
-      end
+    context 'when the document is unloaded' do
+      let(:post) { Post.create!(person_id: person.id) }
+      let(:criteria) { Post.where(person_id: person.id) }
+      let(:enumerable) { described_class.new(criteria) }
+      let(:deleted) { enumerable.delete(post) }
 
-      let!(:enumerable) do
-        described_class.new(criteria)
-      end
-
-      let!(:deleted) do
-        enumerable.delete(post)
+      before do
+        enumerable
+        post
+        deleted
       end
 
-      it "does not load the document" do
+      it 'does not load the document' do
         expect(enumerable._loaded).to be_empty
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(deleted).to eq(post)
       end
     end
 
-    context "when the document is not found" do
-
+    context 'when the document is not found' do
       let!(:post) do
         Post.create!(person_id: person.id)
       end
@@ -735,20 +666,18 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         end
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(deleted).to be_nil
       end
     end
   end
 
-  describe "#delete_if" do
-
+  describe '#delete_if' do
     let(:person) do
       Person.create!
     end
 
-    context "when the document is loaded" do
-
+    context 'when the document is loaded' do
       let!(:post) do
         Post.create!(person_id: person.id)
       end
@@ -761,48 +690,36 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.delete_if { |doc| doc == post }
       end
 
-      it "deletes the document from the enumerable" do
+      it 'deletes the document from the enumerable' do
         expect(enumerable._loaded).to be_empty
       end
 
-      it "returns the remaining docs" do
+      it 'returns the remaining docs' do
         expect(deleted).to be_empty
       end
     end
 
-    context "when the document is added" do
-
-      let!(:post) do
-        Post.new
-      end
-
-      let(:criteria) do
-        Person.where(person_id: person.id)
-      end
-
-      let!(:enumerable) do
-        described_class.new(criteria)
-      end
+    context 'when the document is added' do
+      let(:post) { Post.new }
+      let(:deleted) { enumerable.delete_if { |doc| doc == post } }
+      let(:criteria) { Person.where(person_id: person.id) }
+      let(:enumerable) { described_class.new(criteria) }
 
       before do
         enumerable << post
+        deleted
       end
 
-      let!(:deleted) do
-        enumerable.delete_if { |doc| doc == post }
-      end
-
-      it "removes the document from the added docs" do
+      it 'removes the document from the added docs' do
         expect(enumerable._added).to be_empty
       end
 
-      it "returns the remaining docs" do
+      it 'returns the remaining docs' do
         expect(deleted).to be_empty
       end
     end
 
-    context "when the document is unloaded" do
-
+    context 'when the document is unloaded' do
       let!(:post) do
         Post.create!(person_id: person.id)
       end
@@ -819,17 +736,16 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.delete_if { |doc| doc == post }
       end
 
-      it "does not load the document" do
+      it 'does not load the document' do
         expect(enumerable._loaded).to be_empty
       end
 
-      it "returns the remaining docs" do
+      it 'returns the remaining docs' do
         expect(deleted).to be_empty
       end
     end
 
     context "when the block doesn't match" do
-
       let!(:post) do
         Post.create!(person_id: person.id)
       end
@@ -846,20 +762,19 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.delete_if { |doc| doc == Post.new }
       end
 
-      it "returns the remaining docs" do
+      it 'returns the remaining docs' do
         expect(deleted).to eq([ post ])
       end
     end
   end
 
-  describe "#detect" do
-
+  describe '#detect' do
     let(:person) do
       Person.create!
     end
 
     let!(:post) do
-      Post.create!(person: person, title: "test")
+      Post.create!(person: person, title: 'test')
     end
 
     let(:criteria) do
@@ -870,20 +785,18 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       described_class.new(criteria)
     end
 
-    context "when setting a value on the matching document" do
-
+    context 'when setting a value on the matching document' do
       before do
-        enumerable.detect{ |post| post.title = "test" }.rating = 10
+        enumerable.detect { |post| post.title = 'test' }.rating = 10
       end
 
-      it "sets the value on the instance" do
-        expect(enumerable.detect{ |post| post.title = "test" }.rating).to eq(10)
+      it 'sets the value on the instance' do
+        expect(enumerable.detect { |post| post.title = 'test' }.rating).to eq(10)
       end
     end
   end
 
-  describe "#each" do
-
+  describe '#each' do
     let(:person) do
       Person.create!
     end
@@ -892,8 +805,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       Post.create!(person_id: person.id)
     end
 
-    context "when only a criteria target exists" do
-
+    context 'when only a criteria target exists' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -903,21 +815,18 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       let!(:iterated) do
-        enumerable.each do |doc|
-          expect(doc).to be_a(Post)
-        end
+        expect(enumerable).to all(be_a(Post))
       end
 
-      it "loads each document" do
+      it 'loads each document' do
         expect(enumerable._loaded).to eq({ post.id => post })
       end
 
-      it "becomes loaded" do
+      it 'becomes loaded' do
         expect(enumerable).to be__loaded
       end
 
       context 'when the base association is accessed from each document' do
-
         let(:persons) do
           described_class.new(criteria).collect(&:person)
         end
@@ -933,29 +842,25 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
     end
 
-    context "when only an array target exists" do
-
+    context 'when only an array target exists' do
       let!(:enumerable) do
         described_class.new([ post ])
       end
 
       let!(:iterated) do
-        enumerable.each do |doc|
-          expect(doc).to be_a(Post)
-        end
+        expect(enumerable).to all(be_a(Post))
       end
 
-      it "does not alter the loaded docs" do
+      it 'does not alter the loaded docs' do
         expect(enumerable._loaded).to eq({ post.id => post })
       end
 
-      it "stays loaded" do
+      it 'stays loaded' do
         expect(enumerable).to be__loaded
       end
     end
 
-    context "when a criteria and added exist" do
-
+    context 'when a criteria and added exist' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -968,55 +873,48 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         Post.new
       end
 
-      context "when the added does not contain unloaded docs" do
-
+      context 'when the added does not contain unloaded docs' do
         before do
           enumerable << post_two
         end
 
         let!(:iterated) do
-          enumerable.each do |doc|
-            expect(doc).to be_a(Post)
-          end
+          expect(enumerable).to all(be_a(Post))
         end
 
-        it "adds the unloaded to the loaded docs" do
+        it 'adds the unloaded to the loaded docs' do
           expect(enumerable._loaded).to eq({ post.id => post })
         end
 
-        it "keeps the appended in the added docs" do
+        it 'keeps the appended in the added docs' do
           expect(enumerable._added).to eq({ post_two.id => post_two })
         end
 
-        it "stays loaded" do
+        it 'stays loaded' do
           expect(enumerable).to be__loaded
         end
       end
 
-      context "when the added contains unloaded docs" do
-
+      context 'when the added contains unloaded docs' do
         before do
           enumerable << post
         end
 
         let!(:iterated) do
-          enumerable.each do |doc|
-            expect(doc).to be_a(Post)
-          end
+          expect(enumerable).to all(be_a(Post))
         end
 
-        it "adds the persisted added doc to the loaded" do
+        it 'adds the persisted added doc to the loaded' do
           expect(enumerable._loaded).to eq({ post.id => post })
         end
 
-        it "stays loaded" do
+        it 'stays loaded' do
           expect(enumerable).to be__loaded
         end
       end
     end
 
-    context "when no block is passed" do
-
+    context 'when no block is passed' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -1025,15 +923,13 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new(criteria)
       end
 
-      it "returns an enumerator" do
+      it 'returns an enumerator' do
         expect(enumerable.each.class.include?(Enumerable)).to be true
       end
-
     end
   end
 
-  describe "#entries" do
-
+  describe '#entries' do
     let(:person) do
       Person.create!
     end
@@ -1046,34 +942,31 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       described_class.new(criteria)
     end
 
-    context "when the added contains a persisted document" do
-
+    context 'when the added contains a persisted document' do
       let!(:post) do
         Post.create!(person_id: person.id)
       end
 
-      before do
-        enumerable << post
-      end
-
       let(:entries) do
         enumerable.entries
       end
 
-      it "yields to the in memory documents first" do
+      before do
+        enumerable << post
+      end
+
+      it 'yields to the in memory documents first' do
         expect(entries.first).to equal(post)
       end
     end
   end
 
-  describe "#first" do
-
+  describe '#first' do
     let(:person) do
       Person.create!
     end
 
-    context "when the enumerable is not loaded" do
-
+    context 'when the enumerable is not loaded' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -1082,10 +975,8 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new(criteria)
       end
 
-      context "when unloaded is not empty" do
-
-        context "when added is empty" do
-
+      context 'when unloaded is not empty' do
+        context 'when added is empty' do
           let!(:post) do
             Post.create!(person_id: person.id)
           end
@@ -1094,26 +985,29 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
             enumerable.first
           end
 
-          it "returns the first unloaded doc" do
+          it 'returns the first unloaded doc' do
             expect(first).to eq(post)
           end
 
-          it "does not load the enumerable" do
-            expect(enumerable).to_not be__loaded
+          it 'does not load the enumerable' do
+            expect(enumerable).not_to be__loaded
           end
 
-          it "receives query only once" do
+          it 'receives query only once' do
             expect(criteria).to receive(:first).once
             first
           end
         end
 
-        context "when added is not empty" do
-
+        context 'when added is not empty' do
           let!(:post) do
             Post.create!(person_id: person.id)
           end
 
+          let(:first) do
+            enumerable.first
+          end
+
           let(:post_two) do
             Post.new(person_id: person.id)
           end
@@ -1122,66 +1016,57 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
             enumerable << post_two
           end
 
-          let(:first) do
-            enumerable.first
-          end
-
-          context "when a perviously persisted unloaded doc exists" do
-
-            it "returns the first added doc" do
+          context 'when a previously persisted unloaded doc exists' do
+            it 'returns the first added doc' do
               expect(first).to eq(post)
             end
 
-            it "does not load the enumerable" do
-              expect(enumerable).to_not be__loaded
+            it 'does not load the enumerable' do
+              expect(enumerable).not_to be__loaded
             end
           end
         end
       end
 
-      context "when unloaded is empty" do
-
+      context 'when unloaded is empty' do
         let!(:post) do
           Post.new(person_id: person.id)
         end
 
-        before do
-          enumerable << post
-        end
-
         let(:first) do
           enumerable.first
         end
 
-        it "returns the first loaded doc" do
+        before do
+          enumerable << post
+        end
+
+        it 'returns the first loaded doc' do
           expect(first).to eq(post)
         end
 
-        it "does not load the enumerable" do
-          expect(enumerable).to_not be__loaded
+        it 'does not load the enumerable' do
+          expect(enumerable).not_to be__loaded
         end
       end
 
-      context "when unloaded and added are empty" do
-
+      context 'when unloaded and added are empty' do
         let(:first) do
           enumerable.first
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(first).to be_nil
         end
 
-        it "does not load the enumerable" do
-          expect(enumerable).to_not be__loaded
+        it 'does not load the enumerable' do
+          expect(enumerable).not_to be__loaded
         end
       end
     end
 
-    context "when the enumerable is loaded" do
-
-      context "when loaded is not empty" do
-
+    context 'when the enumerable is loaded' do
+      context 'when loaded is not empty' do
         let!(:post) do
           Post.create!(person_id: person.id)
         end
@@ -1194,17 +1079,20 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.first
         end
 
-        it "returns the first loaded doc" do
+        it 'returns the first loaded doc' do
           expect(first).to eq(post)
         end
       end
 
-      context "when loaded is empty" do
-
+      context 'when loaded is empty' do
         let!(:post) do
           Post.create!(person_id: person.id)
         end
 
+        let(:first) do
+          enumerable.first
+        end
+
         let(:enumerable) do
           described_class.new([])
         end
@@ -1213,17 +1101,12 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable << post
         end
 
-        let(:first) do
-          enumerable.first
-        end
-
-        it "returns the first added doc" do
+        it 'returns the first added doc' do
           expect(first).to eq(post)
         end
       end
 
-      context "when loaded and added are empty" do
-
+      context 'when loaded and added are empty' do
         let(:enumerable) do
           described_class.new([])
         end
@@ -1232,14 +1115,13 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.first
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(first).to be_nil
         end
       end
     end
 
     context 'when including a limit' do
-
       let(:person) do
         Person.create!
       end
@@ -1253,20 +1135,19 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       let!(:first_post) do
-        person.posts.create!(title: "One")
+        person.posts.create!(title: 'One')
       end
 
       let!(:second_post) do
-        person.posts.create!(title: "Two")
+        person.posts.create!(title: 'Two')
       end
 
       it 'returns the matching document' do
-        expect(enumerable.first(1)).to eq([first_post])
+        expect(enumerable.first(1)).to eq([ first_post ])
       end
     end
 
     context 'when no parameters are provided' do
-
       let(:person) do
         Person.create!
       end
@@ -1280,11 +1161,11 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       let!(:first_post) do
-        person.posts.create!(title: "One")
+        person.posts.create!(title: 'One')
       end
 
       let!(:second_post) do
-        person.posts.create!(title: "Two")
+        person.posts.create!(title: 'Two')
       end
 
       it 'uses the sort on id' do
@@ -1293,8 +1174,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#include?" do
-
+  describe '#include?' do
     let(:person) do
       Person.create!
     end
@@ -1307,10 +1187,8 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       Post.create!(person_id: person.id)
     end
 
-    context "when no criteria exists" do
-
-      context "when the enumerable is loaded" do
-
+    context 'when no criteria exists' do
+      context 'when the enumerable is loaded' do
         let!(:enumerable) do
           described_class.new([ post_one, post_two ])
         end
@@ -1319,45 +1197,34 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.include?(post_two)
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(included).to be true
         end
 
-        it "retains the correct length" do
+        it 'retains the correct length' do
           expect(enumerable.length).to eq(2)
         end
 
-        it "retains the correct length when calling to_a" do
+        it 'retains the correct length when calling to_a' do
           expect(enumerable.to_a.length).to eq(2)
         end
       end
 
-      context "when the enumerable contains an added document" do
-
-        let!(:enumerable) do
-          described_class.new([])
-        end
-
-        let(:post_three) do
-          Post.new(person_id: person)
-        end
+      context 'when the enumerable contains an added document' do
+        let(:enumerable) { described_class.new([]) }
+        let(:post_three) { Post.new(person_id: person) }
 
         before do
           enumerable.push(post_three)
         end
 
-        let!(:included) do
-          enumerable.include?(post_three)
-        end
-
-        it "returns true" do
-          expect(included).to be true
+        it 'returns true' do
+          expect(enumerable.include?(post_three)).to be true
         end
       end
     end
 
-    context "when the document is present and not the first" do
-
+    context 'when the document is present and not the first' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -1370,43 +1237,40 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable.include?(post_two)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(included).to be true
       end
 
-      it "retains the correct length" do
+      it 'retains the correct length' do
         expect(enumerable.length).to eq(2)
       end
 
-      it "retains the correct length when calling to_a" do
+      it 'retains the correct length when calling to_a' do
         expect(enumerable.to_a.length).to eq(2)
       end
 
-      context "when iterating over the association a second time" do
-
+      context 'when iterating over the association a second time' do
         before do
           enumerable.each { |post| post }
         end
 
-        it "retains the correct length" do
+        it 'retains the correct length' do
           expect(enumerable.length).to eq(2)
         end
 
-        it "retains the correct length when calling to_a" do
+        it 'retains the correct length when calling to_a' do
           expect(enumerable.to_a.length).to eq(2)
         end
       end
     end
   end
 
-  describe "#initialize" do
-
+  describe '#initialize' do
     let(:person) do
       Person.new
     end
 
-    context "when provided with a criteria" do
-
+    context 'when provided with a criteria' do
       let(:criteria) do
         Post.where(person_id: person.id)
       end
@@ -1415,17 +1279,16 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new(criteria)
       end
 
-      it "sets the criteria" do
+      it 'sets the criteria' do
         expect(enumerable._unloaded).to eq(criteria)
       end
 
-      it "is not loaded" do
-        expect(enumerable).to_not be__loaded
+      it 'is not loaded' do
+        expect(enumerable).not_to be__loaded
       end
     end
 
-    context "when provided an array" do
-
+    context 'when provided an array' do
       let(:post) do
         Post.new
       end
@@ -1434,28 +1297,30 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new([ post ])
       end
 
-      it "does not set a criteria" do
+      it 'does not set a criteria' do
         expect(enumerable._unloaded).to be_nil
       end
 
-      it "is loaded" do
+      it 'is loaded' do
         expect(enumerable).to be__loaded
       end
     end
   end
 
-  describe "#in_memory" do
-
+  describe '#in_memory' do
     let(:person) do
       Person.new
     end
 
-    context "when the enumerable is loaded" do
-
+    context 'when the enumerable is loaded' do
       let(:post) do
         Post.new
       end
 
+      let(:in_memory) do
+        enumerable.in_memory
+      end
+
       let(:enumerable) do
         described_class.new([ post ])
       end
@@ -1468,21 +1333,20 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable << post_two
       end
 
-      let(:in_memory) do
-        enumerable.in_memory
-      end
-
-      it "returns the loaded and added docs" do
+      it 'returns the loaded and added docs' do
         expect(in_memory).to eq([ post, post_two ])
       end
     end
 
-    context "when the enumerable is not loaded" do
-
+    context 'when the enumerable is not loaded' do
       let(:post) do
         Post.new(person_id: person.id)
       end
 
+      let(:in_memory) do
+        enumerable.in_memory
+      end
+
       let(:enumerable) do
         described_class.new(Post.where(person_id: person.id))
       end
@@ -1495,17 +1359,12 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable << post_two
       end
 
-      let(:in_memory) do
-        enumerable.in_memory
-      end
-
-      it "returns the added docs" do
+      it 'returns the added docs' do
         expect(in_memory).to eq([ post_two ])
       end
     end
 
-    context "when passed a block" do
-
+    context 'when passed a block' do
       let(:enumerable) do
         described_class.new(Post.where(person_id: person.id))
       end
@@ -1518,7 +1377,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable << post_two
       end
 
-      it "yields to each in memory document" do
+      it 'yields to each in memory document' do
         enumerable.in_memory do |doc|
           expect(doc).to eq(post_two)
         end
@@ -1526,35 +1385,30 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#is_a?" do
-
+  describe '#is_a?' do
     let(:enumerable) do
       described_class.new(Post.all)
     end
 
-    context "when checking against enumerable" do
-
-      it "returns true" do
-        expect(enumerable.is_a?(::Enumerable)).to be true
+    context 'when checking against enumerable' do
+      it 'returns true' do
+        expect(enumerable.is_a?(Enumerable)).to be true
       end
     end
 
-    context "when checking against array" do
-
-      it "returns true" do
+    context 'when checking against array' do
+      it 'returns true' do
         expect(enumerable.is_a?(Array)).to be true
       end
     end
   end
 
-  describe "#last" do
-
+  describe '#last' do
     let(:person) do
       Person.create!
     end
 
-    context "when the enumerable is not loaded" do
-
+    context 'when the enumerable is not loaded' do
       let(:criteria) do
         Post.asc(:_id).where(person_id: person.id)
       end
@@ -1563,8 +1417,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         described_class.new(criteria)
       end
 
-      context "when unloaded is not empty" do
-
+      context 'when unloaded is not empty' do
         let!(:post) do
           Post.create!(person_id: person.id)
         end
@@ -1573,60 +1426,57 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.last
         end
 
-        it "returns the last unloaded doc" do
+        it 'returns the last unloaded doc' do
           expect(last).to eq(post)
         end
 
-        it "does not load the enumerable" do
-          expect(enumerable).to_not be__loaded
+        it 'does not load the enumerable' do
+          expect(enumerable).not_to be__loaded
         end
 
-        it "receives query only once" do
+        it 'receives query only once' do
           expect(criteria).to receive(:last).once
           last
         end
       end
 
-      context "when unloaded is empty" do
-
+      context 'when unloaded is empty' do
         let!(:post) do
           Post.new(person_id: person.id)
         end
 
-        before do
-          enumerable << post
-        end
-
         let(:last) do
           enumerable.last
         end
 
-        it "returns the last unloaded doc" do
+        before do
+          enumerable << post
+        end
+
+        it 'returns the last unloaded doc' do
           expect(last).to eq(post)
         end
 
-        it "does not load the enumerable" do
-          expect(enumerable).to_not be__loaded
+        it 'does not load the enumerable' do
+          expect(enumerable).not_to be__loaded
         end
       end
 
-      context "when unloaded and added are empty" do
-
+      context 'when unloaded and added are empty' do
         let(:last) do
           enumerable.last
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(last).to be_nil
         end
 
-        it "does not load the enumerable" do
-          expect(enumerable).to_not be__loaded
+        it 'does not load the enumerable' do
+          expect(enumerable).not_to be__loaded
         end
       end
 
-      context "when added is not empty" do
-
+      context 'when added is not empty' do
         let!(:post_one) do
           person.posts.create!
         end
@@ -1639,19 +1489,16 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.last
         end
 
-        context "when accessing from a reloaded child" do
-
-          it "returns the last document" do
+        context 'when accessing from a reloaded child' do
+          it 'returns the last document' do
             expect(post_one.reload.person.posts.asc(:_id).last).to eq(post_two)
           end
         end
       end
     end
 
-    context "when the enumerable is loaded" do
-
-      context "when loaded is not empty" do
-
+    context 'when the enumerable is loaded' do
+      context 'when loaded is not empty' do
         let!(:post) do
           Post.create!(person_id: person.id)
         end
@@ -1664,17 +1511,20 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.last
         end
 
-        it "returns the last loaded doc" do
+        it 'returns the last loaded doc' do
           expect(last).to eq(post)
         end
       end
 
-      context "when loaded is empty" do
-
+      context 'when loaded is empty' do
         let!(:post) do
           Post.create!(person_id: person.id)
         end
 
+        let(:last) do
+          enumerable.last
+        end
+
         let(:enumerable) do
           described_class.new([])
         end
@@ -1683,17 +1533,12 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable << post
         end
 
-        let(:last) do
-          enumerable.last
-        end
-
-        it "returns the last added doc" do
+        it 'returns the last added doc' do
           expect(last).to eq(post)
         end
       end
 
-      context "when loaded and added are empty" do
-
+      context 'when loaded and added are empty' do
         let(:enumerable) do
           described_class.new([])
         end
@@ -1702,14 +1547,13 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable.last
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(last).to be_nil
         end
       end
     end
 
     context 'when including a limit' do
-
       let(:person) do
         Person.create!
       end
@@ -1723,20 +1567,19 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       let!(:first_post) do
-        person.posts.create!(title: "One")
+        person.posts.create!(title: 'One')
       end
 
       let!(:second_post) do
-        person.posts.create!(title: "Two")
+        person.posts.create!(title: 'Two')
       end
 
       it 'returns the matching document' do
-        expect(enumerable.last(1)).to eq([second_post])
+        expect(enumerable.last(1)).to eq([ second_post ])
       end
     end
 
     context 'when no parameters are provided' do
-
       let(:person) do
         Person.create!
       end
@@ -1750,11 +1593,11 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       let!(:first_post) do
-        person.posts.create!(title: "One")
+        person.posts.create!(title: 'One')
       end
 
       let!(:second_post) do
-        person.posts.create!(title: "Two")
+        person.posts.create!(title: 'Two')
       end
 
       it 'uses the sort on id' do
@@ -1763,29 +1606,25 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#kind_of?" do
-
+  describe '#kind_of?' do
     let(:enumerable) do
       described_class.new(Post.all)
     end
 
-    context "when checking against enumerable" do
-
-      it "returns true" do
-        expect(enumerable.kind_of?(::Enumerable)).to be true
+    context 'when checking against enumerable' do
+      it 'returns true' do
+        expect(enumerable.is_a?(Enumerable)).to be true
       end
     end
 
-    context "when checking against array" do
-
-      it "returns true" do
-        expect(enumerable.kind_of?(Array)).to be true
+    context 'when checking against array' do
+      it 'returns true' do
+        expect(enumerable.is_a?(Array)).to be true
       end
     end
   end
 
-  describe "#load_all!" do
-
+  describe '#load_all!' do
     let(:person) do
       Person.create!
     end
@@ -1806,15 +1645,15 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       enumerable.load_all!
     end
 
-    it "loads all the unloaded documents" do
+    it 'loads all the unloaded documents' do
       expect(enumerable._loaded).to eq({ post.id => post })
     end
 
-    it "returns the object" do
-      expect(loaded).to eq([post])
+    it 'returns the object' do
+      expect(loaded).to eq([ post ])
     end
 
-    it "sets loaded to true" do
+    it 'sets loaded to true' do
       expect(enumerable).to be__loaded
     end
   end
@@ -1843,7 +1682,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       context 'when the criteria is present' do
         it 'delegates to the criteria pluck method' do
           result = enumerable.pluck(:title)
-          expect(result).to eq(['Test Title'])
+          expect(result).to eq([ 'Test Title' ])
         end
 
         context 'when added docs are present' do
@@ -1851,9 +1690,9 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
             added_post = Post.new(title: 'Added Title', person_id: person.id)
             enumerable << added_post
 
-            expect(criteria).to receive(:pluck).with(:title).and_return(['Test Title'])
+            expect(criteria).to receive(:pluck).with(:title).and_return([ 'Test Title' ])
             result = enumerable.pluck(:title)
-            expect(result).to eq(['Test Title', 'Added Title'])
+            expect(result).to eq([ 'Test Title', 'Added Title' ])
           end
         end
       end
@@ -1872,18 +1711,18 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
             enumerable << added_post
 
             result = enumerable.pluck(:title)
-            expect(result).to eq(['Added Title'])
+            expect(result).to eq([ 'Added Title' ])
           end
         end
       end
     end
 
     context 'when the enumerable is loaded' do
-      let(:enumerable) { described_class.new([post], base, association) }
+      let(:enumerable) { described_class.new([ post ], base, association) }
 
       it 'returns the values from the loaded documents' do
         result = enumerable.pluck(:title)
-        expect(result).to eq(['Test Title'])
+        expect(result).to eq([ 'Test Title' ])
       end
 
       context 'when added docs are present' do
@@ -1892,7 +1731,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           enumerable << added_post
 
           result = enumerable.pluck(:title)
-          expect(result).to eq(['Test Title', 'Added Title'])
+          expect(result).to eq([ 'Test Title', 'Added Title' ])
         end
       end
     end
@@ -1905,7 +1744,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
 
     context 'when the field is aliased' do
       let!(:expensive) do
-        parent.products.create!(price: 100000)
+        parent.products.create!(price: 100_000)
       end
 
       let!(:cheap) do
@@ -1913,13 +1752,12 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       context 'when using alias_attribute' do
-
         let(:plucked) do
           parent.products.pluck(:price)
         end
 
         it 'uses the aliases' do
-          expect(plucked).to eq([ 100000, 1 ])
+          expect(plucked).to eq([ 100_000, 1 ])
         end
       end
     end
@@ -1953,16 +1791,16 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         end
 
         it 'returns the full translations hash to _translations' do
-          expect(plucked_translations.first).to eq({'de'=>'deutsch-text', 'en'=>'english-text'})
+          expect(plucked_translations.first).to eq({ 'de' => 'deutsch-text', 'en' => 'english-text' })
         end
 
         it 'returns both' do
-          expect(plucked_translations_both.first).to eq([{'de'=>'deutsch-text', 'en'=>'english-text'}, 'deutsch-text'])
+          expect(plucked_translations_both.first).to eq([ { 'de' => 'deutsch-text', 'en' => 'english-text' },
+                                                          'deutsch-text' ])
         end
       end
 
       context 'when plucking a specific locale' do
-
         let(:plucked) do
           parent.products.all.pluck(:'name.de')
         end
@@ -1973,7 +1811,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       end
 
       context 'when plucking a specific locale from _translations field' do
-
         let(:plucked) do
           parent.products.all.pluck(:'name_translations.de')
         end
@@ -2042,12 +1879,12 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           end
 
           it 'returns both' do
-            expect(plucked_translations_both.first).to eq([{ 'de' => 'deutsch-text', 'en' => 'english-text' }, 'deutsch-text'])
+            expect(plucked_translations_both.first).to eq([ { 'de' => 'deutsch-text', 'en' => 'english-text' },
+                                                            'deutsch-text' ])
           end
         end
 
         context 'when plucking a specific locale' do
-
           let(:plucked) do
             parent.products.all.pluck(:'tagline.de')
           end
@@ -2058,7 +1895,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         end
 
         context 'when plucking a specific locale from _translations field' do
-
           let(:plucked) do
             parent.products.all.pluck(:'tagline_translations.de')
           end
@@ -2072,7 +1908,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
           require_fallbacks
 
           before do
-            I18n.fallbacks[:he] = [:en]
+            I18n.fallbacks[:he] = [ :en ]
           end
 
           let(:plucked) do
@@ -2192,7 +2028,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
 
     context 'when plucking an embeds_many field' do
       let(:label) { Label.new(sales: '1E2') }
-      let!(:band) { Band.create!(labels: [label]) }
+      let!(:band) { Band.create!(labels: [ label ]) }
 
       let(:plucked) { Band.where(_id: band.id).pluck('labels.sales') }
 
@@ -2213,55 +2049,37 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#reset" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let(:post) do
-      Post.create!(person_id: person.id)
-    end
-
-    let(:post_two) do
-      Post.create!(person_id: person.id)
-    end
-
-    let(:enumerable) do
-      described_class.new([ post ])
-    end
+  describe '#reset' do
+    let(:person) { Person.create! }
+    let(:post) { Post.create!(person_id: person.id) }
+    let(:post_two) { Post.create!(person_id: person.id) }
+    let(:enumerable) { described_class.new([ post ]) }
 
     before do
       enumerable << post_two
-    end
-
-    let!(:reset) do
       enumerable.reset
     end
 
-    it "is not loaded" do
-      expect(enumerable).to_not be__loaded
+    it 'is not loaded' do
+      expect(enumerable).not_to be__loaded
     end
 
-    it "clears out the loaded docs" do
+    it 'clears out the loaded docs' do
       expect(enumerable._loaded).to be_empty
     end
 
-    it "clears out the added docs" do
+    it 'clears out the added docs' do
       expect(enumerable._added).to be_empty
     end
   end
 
-  describe "#respond_to?" do
-
+  describe '#respond_to?' do
     let(:enumerable) do
       described_class.new([])
     end
 
-    context "when checking against array methods" do
-
+    context 'when checking against array methods' do
       [].methods.each do |method|
-
         it "returns true for #{method}" do
           expect(enumerable).to respond_to(method)
         end
@@ -2269,8 +2087,7 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
   end
 
-  describe "#size" do
-
+  describe '#size' do
     let(:person) do
       Person.create!
     end
@@ -2279,37 +2096,37 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
       Post.create!(person_id: person.id)
     end
 
-    context "when the base is new" do
-
+    context 'when the base is new' do
       let!(:person) do
         Person.new
       end
 
-      context "when the added contains a persisted document" do
-
+      context 'when the added contains a persisted document' do
         let!(:post) do
           Post.create!(person_id: person.id)
         end
 
-        context "when the enumerable is not loaded" do
-
+        context 'when the enumerable is not loaded' do
           let(:enumerable) do
             described_class.new(Post.where(person_id: person.id))
           end
 
-          it "includes the number of all added documents" do
+          it 'includes the number of all added documents' do
             expect(enumerable.size).to eq(1)
           end
         end
       end
     end
 
-    context "when the enumerable is loaded" do
-
+    context 'when the enumerable is loaded' do
       let(:enumerable) do
         described_class.new([ post ])
       end
 
+      let(:size) do
+        enumerable.size
+      end
+
       let(:post_two) do
         Post.new(person_id: person.id)
       end
@@ -2318,104 +2135,81 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
         enumerable << post_two
       end
 
-      let(:size) do
-        enumerable.size
-      end
-
-      it "returns the loaded size plus added size" do
+      it 'returns the loaded size plus added size' do
         expect(size).to eq(2)
       end
 
-      it "matches the size of the loaded enumerable" do
+      it 'matches the size of the loaded enumerable' do
         expect(size).to eq(enumerable.to_a.size)
       end
     end
 
-    context "when the enumerable is not loaded" do
-
+    context 'when the enumerable is not loaded' do
       let(:enumerable) do
         described_class.new(Post.where(person_id: person.id))
       end
 
-      context "when the added contains new documents" do
-
+      context 'when the added contains new documents' do
         let(:post_two) do
           Post.new(person_id: person.id)
         end
 
-        before do
-          enumerable << post_two
-        end
-
         let(:size) do
           enumerable.size
         end
 
-        it "returns the unloaded count plus added new size" do
+        before do
+          enumerable << post_two
+        end
+
+        it 'returns the unloaded count plus added new size' do
           expect(size).to eq(2)
         end
       end
 
-      context "when the added contains persisted documents" do
-
+      context 'when the added contains persisted documents' do
         let(:post_two) do
           Post.create!(person_id: person.id)
         end
 
-        before do
-          enumerable << post_two
-        end
-
         let(:size) do
           enumerable.size
         end
 
-        it "returns the unloaded count plus added new size" do
+        before do
+          enumerable << post_two
+        end
+
+        it 'returns the unloaded count plus added new size' do
           expect(size).to eq(2)
         end
       end
     end
   end
 
-  describe "#to_json" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:post) do
-      Post.create!(title: "test", person_id: person.id)
-    end
-
-    let(:criteria) do
-      Post.where(person_id: person.id)
-    end
-
-    let!(:enumerable) do
-      described_class.new(criteria)
-    end
+  describe '#to_json' do
+    let(:person) { Person.create! }
+    let(:json) { enumerable.to_json }
+    let(:post) { Post.create!(title: 'test', person_id: person.id) }
+    let(:criteria) { Post.where(person_id: person.id) }
+    let(:enumerable) { described_class.new(criteria) }
 
     before do
       enumerable << post
     end
 
-    let!(:json) do
-      enumerable.to_json
-    end
-
-    it "serializes the enumerable" do
+    it 'serializes the enumerable' do
       expect(json).to include(post.title)
     end
   end
 
-  describe "#to_json(parameters)" do
-
+  describe '#to_json(parameters)' do
     let(:person) do
       Person.create!
     end
 
     let!(:post) do
-      Post.create!(title: "test", person_id: person.id)
+      Post.create!(title: 'test', person_id: person.id)
     end
 
     let(:criteria) do
@@ -2423,54 +2217,38 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     let!(:json) do
-      person.posts.to_json({except: 'title'})
+      person.posts.to_json({ except: 'title' })
     end
 
-    it "serializes the enumerable" do
-      expect(json).to_not include(post.title)
+    it 'serializes the enumerable' do
+      expect(json).not_to include(post.title)
     end
   end
 
-  describe "#as_json" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:post) do
-      Post.create!(title: "test", person_id: person.id)
-    end
-
-    let(:criteria) do
-      Post.where(person_id: person.id)
-    end
-
-    let!(:enumerable) do
-      described_class.new(criteria)
-    end
+  describe '#as_json' do
+    let(:person) { Person.create! }
+    let(:json) { enumerable.as_json }
+    let(:post) { Post.create!(title: 'test', person_id: person.id) }
+    let(:criteria) { Post.where(person_id: person.id) }
+    let(:enumerable) { described_class.new(criteria) }
 
     before do
       enumerable << post
     end
 
-    let!(:json) do
-      enumerable.as_json
-    end
-
-    it "serializes the enumerable" do
+    it 'serializes the enumerable' do
       expect(json.size).to eq(1)
       expect(json[0]['title']).to eq(post.title)
     end
   end
 
-  describe "#as_json(parameters)" do
-
+  describe '#as_json(parameters)' do
     let(:person) do
       Person.create!
     end
 
     let!(:post) do
-      Post.create!(title: "test", person_id: person.id)
+      Post.create!(title: 'test', person_id: person.id)
     end
 
     let(:criteria) do
@@ -2478,62 +2256,45 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     let!(:json) do
-      person.posts.as_json({except: "title"})
+      person.posts.as_json({ except: 'title' })
     end
 
-    it "serializes the enumerable" do
+    it 'serializes the enumerable' do
       expect(json.size).to eq(1)
     end
 
-    it "includes the proper fields" do
-      expect(json[0].keys).to_not include("title")
+    it 'includes the proper fields' do
+      expect(json[0].keys).not_to include('title')
     end
   end
 
-  describe "#uniq" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:post) do
-      Post.create!(person_id: person.id)
-    end
-
-    let(:criteria) do
-      Post.where(person_id: person.id)
-    end
-
-    let!(:enumerable) do
-      described_class.new(criteria)
-    end
+  describe '#uniq' do
+    let(:person) { Person.create! }
+    let(:post) { Post.create!(person_id: person.id) }
+    let(:criteria) { Post.where(person_id: person.id) }
+    let!(:enumerable) { described_class.new(criteria) }
 
     before do
       enumerable << post
       enumerable._loaded[post.id] = post
     end
 
-    let!(:uniq) do
-      enumerable.uniq
-    end
-
-    it "returns the unique documents" do
-      expect(uniq).to eq([ post ])
+    it 'returns the unique documents' do
+      expect(enumerable.uniq).to eq([ post ])
     end
 
-    it "sets loaded to true" do
+    it 'sets loaded to true' do
+      enumerable.uniq
       expect(enumerable).to be__loaded
     end
   end
 
   describe 'setting the same parent object on enumerated children objects' do
-
     let(:person) do
       Person.create!
     end
 
     context 'when a single child is fetched' do
-
       let!(:post) do
         person.posts << Post.new
         person.posts.first
@@ -2547,7 +2308,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     context 'when a single child is fetched with a scope' do
-
       let!(:post) do
         person.posts << Post.new(title: 'open')
         person.posts.open.first
@@ -2561,7 +2321,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     context 'when multiple children are fetched' do
-
       let!(:posts) do
         person.posts << Post.new
         person.posts << Post.new
@@ -2577,7 +2336,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     context 'when multiple children are fetched with query criteria' do
-
       let!(:posts) do
         person.posts << Post.new(title: 'open')
         person.posts << Post.new(title: 'open')
@@ -2593,7 +2351,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     context 'when multiple children are fetched with a scope' do
-
       let!(:posts) do
         person.posts << Post.new(title: 'open')
         person.posts << Post.new(title: 'open')
@@ -2609,7 +2366,6 @@ describe Mongoid::Association::Referenced::HasMany::Enumerable do
     end
 
     context 'when the parent is updated in memory' do
-
       let!(:posts) do
         person.posts << Post.new
         person.posts << Post.new