mongoid 9.0.11 → 9.1.0

data/spec/mongoid/contextual/memory_spec.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Contextual::Memory do
-
-  shared_examples "raises an error when no documents" do
-    context "when there are no matching documents" do
+  shared_examples 'raises an error when no documents' do
+    context 'when there are no matching documents' do
       let(:criteria) do
         Address.all.tap do |crit|
           crit.documents = []
         end
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect do
           context.send(method)
         end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Address./)
@@ -21,36 +19,33 @@ describe Mongoid::Contextual::Memory do
     end
   end
 
-  shared_examples "returns nil when no documents" do
-    context "when there are no matching documents" do
+  shared_examples 'returns nil when no documents' do
+    context 'when there are no matching documents' do
       let(:criteria) do
         Address.all.tap do |crit|
           crit.documents = []
         end
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(context.send(method)).to be_nil
       end
     end
   end
 
-  [ :blank?, :empty? ].each do |method|
-
+  %i[blank? empty?].each do |method|
     describe "##{method}" do
-
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: 'hobrecht')
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: 'friedel')
       end
 
-      context "when there are matching documents" do
-
+      context 'when there are matching documents' do
         let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
+          Address.where(street: 'hobrecht').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end
         end
@@ -59,15 +54,14 @@ describe Mongoid::Contextual::Memory do
           described_class.new(criteria)
         end
 
-        it "returns false" do
+        it 'returns false' do
           expect(context.send(method)).to be false
         end
       end
 
-      context "when there are no matching documents" do
-
+      context 'when there are no matching documents' do
         let(:criteria) do
-          Address.where(street: "pfluger").tap do |crit|
+          Address.where(street: 'pfluger').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end
         end
@@ -76,40 +70,38 @@ describe Mongoid::Contextual::Memory do
           described_class.new(criteria)
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(context.send(method)).to be true
         end
       end
 
       context 'when there is a collation on the criteria' do
-
         let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
+          Address.where(street: 'hobrecht').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end.collation(locale: 'en_US', strength: 2)
         end
 
-        it "raises an exception" do
-          expect {
+        it 'raises an exception' do
+          expect do
             context.send(method)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+          end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
   end
 
-  describe "#count" do
-
+  describe '#count' do
     let!(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let!(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(street: "hobrecht").tap do |crit|
+      Address.where(street: 'hobrecht').tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -118,107 +110,96 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    context "context when no arguments are provided" do
-
-      it "returns the number of matches" do
+    context 'context when no arguments are provided' do
+      it 'returns the number of matches' do
         expect(context.count).to eq(1)
       end
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
-        Address.where(street: "hobrecht").tap do |crit|
+        Address.where(street: 'hobrecht').tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.count
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
 
-    context "when provided a document" do
-
-      context "when the document matches" do
-
+    context 'when provided a document' do
+      context 'when the document matches' do
         let(:count) do
           context.count(hobrecht)
         end
 
-        it "returns 1" do
+        it 'returns 1' do
           expect(count).to eq(1)
         end
       end
 
-      context "when the document does not match" do
-
+      context 'when the document does not match' do
         let(:count) do
           context.count(friedel)
         end
 
-        it "returns 0" do
+        it 'returns 0' do
           expect(count).to eq(0)
         end
       end
     end
 
-    context "when provided a block" do
-
-      context "when the block evals 1 to true" do
-
+    context 'when provided a block' do
+      context 'when the block evals 1 to true' do
         let(:count) do
           context.count do |doc|
-            doc.street == "hobrecht"
+            doc.street == 'hobrecht'
           end
         end
 
-        it "returns 1" do
+        it 'returns 1' do
           expect(count).to eq(1)
         end
       end
 
-      context "when the block evals none to true" do
-
+      context 'when the block evals none to true' do
         let(:count) do
           context.count do |doc|
-            doc.street == "friedel"
+            doc.street == 'friedel'
           end
         end
 
-        it "returns 0" do
+        it 'returns 0' do
           expect(count).to eq(0)
         end
       end
     end
   end
 
-  [ :delete, :delete_all ].each do |method|
-
+  %i[delete delete_all].each do |method|
     let(:person) do
       Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create!(street: "hobrecht")
+      person.addresses.create!(street: 'hobrecht')
     end
 
     let(:friedel) do
-      person.addresses.create!(street: "friedel")
+      person.addresses.create!(street: 'friedel')
     end
 
     let(:pfluger) do
-      person.addresses.create!(street: "pfluger")
+      person.addresses.create!(street: 'pfluger')
     end
 
     describe "##{method}" do
-
-      context "when embedded a single level" do
-
+      context 'when embedded a single level' do
         let(:criteria) do
-          Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+          Address.any_in(street: %w[hobrecht friedel]).tap do |crit|
             crit.documents = [ hobrecht, friedel, pfluger ]
           end
         end
@@ -231,47 +212,46 @@ describe Mongoid::Contextual::Memory do
           context.send(method)
         end
 
-        it "deletes the first matching document" do
+        it 'deletes the first matching document' do
           expect(hobrecht).to be_destroyed
         end
 
-        it "deletes the last matching document" do
+        it 'deletes the last matching document' do
           expect(friedel).to be_destroyed
         end
 
-        it "does not delete non matching docs" do
-          expect(pfluger).to_not be_destroyed
+        it 'does not delete non matching docs' do
+          expect(pfluger).not_to be_destroyed
         end
 
-        it "removes the docs from the relation" do
+        it 'removes the docs from the relation' do
           expect(person.addresses).to eq([ pfluger ])
         end
 
-        it "removes the docs from the context" do
+        it 'removes the docs from the context' do
           expect(context.entries).to be_empty
         end
 
-        it "persists the changes to the database" do
+        it 'persists the changes to the database' do
           expect(person.reload.addresses).to eq([ pfluger ])
         end
 
-        it "returns the number of deleted documents" do
+        it 'returns the number of deleted documents' do
           expect(deleted).to eq(2)
         end
       end
 
-      context "when embedded multiple levels" do
-
+      context 'when embedded multiple levels' do
         let!(:home) do
-          hobrecht.locations.create!(name: "home")
+          hobrecht.locations.create!(name: 'home')
         end
 
         let!(:work) do
-          hobrecht.locations.create!(name: "work")
+          hobrecht.locations.create!(name: 'work')
         end
 
         let(:criteria) do
-          Location.where(name: "work").tap do |crit|
+          Location.where(name: 'work').tap do |crit|
             crit.documents = [ home, work ]
           end
         end
@@ -284,68 +264,66 @@ describe Mongoid::Contextual::Memory do
           context.send(method)
         end
 
-        it "deletes the first matching document" do
+        it 'deletes the first matching document' do
           expect(work).to be_destroyed
         end
 
-        it "does not delete non matching docs" do
-          expect(home).to_not be_destroyed
+        it 'does not delete non matching docs' do
+          expect(home).not_to be_destroyed
         end
 
-        it "removes the docs from the relation" do
+        it 'removes the docs from the relation' do
           expect(person.addresses.first.locations).to eq([ home ])
         end
 
-        it "removes the docs from the context" do
+        it 'removes the docs from the context' do
           expect(context.entries).to be_empty
         end
 
-        it "persists the changes to the database" do
+        it 'persists the changes to the database' do
           expect(person.reload.addresses.first.locations).to eq([ home ])
         end
 
-        it "returns the number of deleted documents" do
+        it 'returns the number of deleted documents' do
           expect(deleted).to eq(1)
         end
       end
 
       context 'when there is a collation on the criteria' do
-
         let(:criteria) do
-          Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+          Address.any_in(street: %w[hobrecht friedel]).tap do |crit|
             crit.documents = [ hobrecht, friedel, pfluger ]
           end.collation(locale: 'en_US', strength: 2)
         end
 
-        it "raises an exception" do
-          expect {
+        it 'raises an exception' do
+          expect do
             context.send(method)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+          end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
   end
 
-  [ :destroy, :destroy_all ].each do |method|
-
+  %i[destroy destroy_all].each do |method|
     let(:person) do
       Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create!(street: "hobrecht")
+      person.addresses.create!(street: 'hobrecht')
     end
 
     let(:friedel) do
-      person.addresses.create!(street: "friedel")
+      person.addresses.create!(street: 'friedel')
     end
 
     let(:pfluger) do
-      person.addresses.create!(street: "pfluger")
+      person.addresses.create!(street: 'pfluger')
     end
 
     let(:criteria) do
-      Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+      Address.any_in(street: %w[hobrecht friedel]).tap do |crit|
         crit.documents = [ hobrecht, friedel, pfluger ]
       end
     end
@@ -355,63 +333,60 @@ describe Mongoid::Contextual::Memory do
     end
 
     describe "##{method}" do
-
       context 'when there is no collation on the criteria' do
-
         let!(:destroyed) do
           context.send(method)
         end
 
-        it "deletes the first matching document" do
+        it 'deletes the first matching document' do
           expect(hobrecht).to be_destroyed
         end
 
-        it "deletes the last matching document" do
+        it 'deletes the last matching document' do
           expect(friedel).to be_destroyed
         end
 
-        it "does not delete non matching docs" do
-          expect(pfluger).to_not be_destroyed
+        it 'does not delete non matching docs' do
+          expect(pfluger).not_to be_destroyed
         end
 
-        it "removes the docs from the relation" do
+        it 'removes the docs from the relation' do
           expect(person.addresses).to eq([ pfluger ])
         end
 
-        it "removes the docs from the context" do
+        it 'removes the docs from the context' do
           expect(context.entries).to be_empty
         end
 
-        it "persists the changes to the database" do
+        it 'persists the changes to the database' do
           expect(person.reload.addresses).to eq([ pfluger ])
         end
 
-        it "returns the number of destroyed documents" do
+        it 'returns the number of destroyed documents' do
           expect(destroyed).to eq(2)
         end
       end
 
       context 'when there is a collation on the criteria' do
-
         let(:criteria) do
-          Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+          Address.any_in(street: %w[hobrecht friedel]).tap do |crit|
             crit.documents = [ hobrecht, friedel, pfluger ]
           end.collation(locale: 'en_US', strength: 2)
         end
 
-        it "raises an exception" do
-          expect {
+        it 'raises an exception' do
+          expect do
             context.send(method)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+          end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
   end
 
-  describe "#distinct" do
-    let(:depeche) { Band.create!(name: "Depeche Mode", years: 30, sales: "1E2") }
-    let(:new_order) { Band.create!(name: "New Order", years: 25, sales: "2E3") }
-    let(:maniacs) { Band.create!(name: "10,000 Maniacs", years: 20, sales: "1E2") }
+  describe '#distinct' do
+    let(:depeche) { Band.create!(name: 'Depeche Mode', years: 30, sales: '1E2') }
+    let(:new_order) { Band.create!(name: 'New Order', years: 25, sales: '2E3') }
+    let(:maniacs) { Band.create!(name: '10,000 Maniacs', years: 20, sales: '1E2') }
 
     let(:criteria) do
       Band.all.tap do |crit|
@@ -423,41 +398,37 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    context "when limiting the result set" do
-
+    context 'when limiting the result set' do
       let(:criteria) do
-        Band.where(name: "Depeche Mode").tap do |crit|
+        Band.where(name: 'Depeche Mode').tap do |crit|
           crit.documents = [ depeche ]
         end
       end
 
-      it "returns the distinct matching fields" do
-        expect(context.distinct(:name)).to eq([ "Depeche Mode" ])
+      it 'returns the distinct matching fields' do
+        expect(context.distinct(:name)).to eq([ 'Depeche Mode' ])
       end
     end
 
-    context "when not limiting the result set" do
-
-      it "returns the distinct field values" do
-        expect(context.distinct(:name).sort).to eq([ "10,000 Maniacs", "Depeche Mode", "New Order" ].sort)
+    context 'when not limiting the result set' do
+      it 'returns the distinct field values' do
+        expect(context.distinct(:name).sort).to eq([ '10,000 Maniacs', 'Depeche Mode', 'New Order' ].sort)
       end
     end
 
-    context "when providing an aliased field" do
-
-      it "returns the distinct field values" do
+    context 'when providing an aliased field' do
+      it 'returns the distinct field values' do
         expect(context.distinct(:years).sort).to eq([ 20, 25, 30 ])
       end
     end
 
-    context "when providing a demongoizable field" do
-
-      it "returns the non-demongoized distinct field values" do
-        expect(context.distinct(:sales).sort).to eq([ BigDecimal("1E2"), BigDecimal("2E3") ])
+    context 'when providing a demongoizable field' do
+      it 'returns the non-demongoized distinct field values' do
+        expect(context.distinct(:sales).sort).to eq([ BigDecimal('1E2'), BigDecimal('2E3') ])
       end
     end
 
-    context "when getting a localized field" do
+    context 'when getting a localized field' do
       with_default_i18n_configs
 
       before do
@@ -474,38 +445,36 @@ describe Mongoid::Contextual::Memory do
         end
       end
 
-      context "when getting the field without _translations" do
-        it "gets the demongoized localized field" do
+      context 'when getting the field without _translations' do
+        it 'gets the demongoized localized field' do
           expect(context.distinct(:description)).to eq([ 'deutsch-text' ])
         end
       end
 
-      context "when getting the field with _translations" do
-
-        it "gets the full hash" do
-          expect(context.distinct(:description_translations)).to eq([ { "de" => "deutsch-text", "en" => "english-text" } ])
+      context 'when getting the field with _translations' do
+        it 'gets the full hash' do
+          expect(context.distinct(:description_translations)).to eq([ { 'de' => 'deutsch-text',
+                                                                        'en' => 'english-text' } ])
         end
       end
 
       context 'when plucking a specific locale' do
-
         let(:distinct) do
           context.distinct(:'description.de')
         end
 
         it 'returns the specific translation' do
-          expect(distinct).to eq([ "deutsch-text" ])
+          expect(distinct).to eq([ 'deutsch-text' ])
         end
       end
 
       context 'when plucking a specific locale from _translations field' do
-
         let(:distinct) do
           context.distinct(:'description_translations.de')
         end
 
         it 'returns the specific translations' do
-          expect(distinct).to eq(['deutsch-text'])
+          expect(distinct).to eq([ 'deutsch-text' ])
         end
       end
 
@@ -521,62 +490,61 @@ describe Mongoid::Contextual::Memory do
           context.distinct(:description).first
         end
 
-        it "correctly uses the fallback" do
+        it 'correctly uses the fallback' do
           I18n.locale = :en
           Dictionary.create!(description: 'english-text')
           I18n.locale = :he
-          distinct.should == "english-text"
+          distinct.should eq 'english-text'
         end
       end
 
-      context "when the localized field is embedded" do
+      context 'when the localized field is embedded' do
         with_default_i18n_configs
 
         let(:person) do
           p = Passport.new
           I18n.locale = :en
-          p.name = "Neil"
+          p.name = 'Neil'
           I18n.locale = :he
-          p.name = "Nissim"
+          p.name = 'Nissim'
 
-          Person.create!(passport: p, employer_id: 12345)
+          Person.create!(passport: p, employer_id: 12_345)
         end
 
         let(:criteria) do
-          Person.where(employer_id: 12345).tap do |crit|
+          Person.where(employer_id: 12_345).tap do |crit|
             crit.documents = [ person ]
           end
         end
 
         let(:distinct) do
-          context.distinct("pass.name").first
+          context.distinct('pass.name').first
         end
 
         let(:distinct_translations) do
-          context.distinct("pass.name_translations").first
+          context.distinct('pass.name_translations').first
         end
 
         let(:distinct_translations_field) do
-          context.distinct("pass.name_translations.en").first
+          context.distinct('pass.name_translations.en').first
         end
 
-        it "returns the translation for the current locale" do
-          expect(distinct).to eq("Nissim")
+        it 'returns the translation for the current locale' do
+          expect(distinct).to eq('Nissim')
         end
 
-        it "returns the full _translation hash" do
-          expect(distinct_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
+        it 'returns the full _translation hash' do
+          expect(distinct_translations).to eq({ 'en' => 'Neil', 'he' => 'Nissim' })
         end
 
-        it "returns the translation for the requested locale" do
-          expect(distinct_translations_field).to eq("Neil")
+        it 'returns the translation for the requested locale' do
+          expect(distinct_translations_field).to eq('Neil')
         end
       end
     end
 
-    context "when getting an embedded field" do
-
-      let(:label) { Label.new(sales: "1E2") }
+    context 'when getting an embedded field' do
+      let(:label) { Label.new(sales: '1E2') }
       let!(:band) { Band.create!(label: label) }
       let(:criteria) do
         Band.where(_id: band.id).tap do |crit|
@@ -584,24 +552,23 @@ describe Mongoid::Contextual::Memory do
         end
       end
 
-      it "returns the distinct matching fields" do
-        expect(context.distinct("label.sales")).to eq([ BigDecimal("1E2") ])
+      it 'returns the distinct matching fields' do
+        expect(context.distinct('label.sales')).to eq([ BigDecimal('1E2') ])
       end
     end
   end
 
-  describe "#each" do
-
+  describe '#each' do
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(street: "hobrecht").tap do |crit|
+      Address.where(street: 'hobrecht').tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -610,65 +577,52 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    context "when skip and limit outside of range" do
-
+    context 'when skip and limit outside of range' do
       before do
         context.skip(10).limit(2)
       end
 
-      it "contains no documents" do
+      it 'contains no documents' do
         expect(context.map(&:street)).to be_empty
       end
 
-      context "when calling next on the enumerator" do
-
-        it "raises a stop iteration error" do
-          expect {
+      context 'when calling next on the enumerator' do
+        it 'raises a stop iteration error' do
+          expect do
             context.each.next
-          }.to raise_error(StopIteration)
+          end.to raise_error(StopIteration)
         end
       end
     end
 
-    context "when providing a block" do
-
-      it "yields mongoid documents to the block" do
-        context.each do |doc|
-          expect(doc).to be_a(Mongoid::Document)
-        end
+    context 'when providing a block' do
+      it 'yields mongoid documents to the block' do
+        expect(context).to all(be_a(Mongoid::Document))
       end
 
-      it "iterates over the matching documents" do
-        context.each do |doc|
-          expect(doc).to eq(hobrecht)
-        end
+      it 'iterates over the matching documents' do
+        expect(context).to all(eq(hobrecht))
       end
     end
 
-    context "when no block is provided" do
-
+    context 'when no block is provided' do
       let(:enum) do
         context.each
       end
 
-      it "returns an enumerator" do
+      it 'returns an enumerator' do
         expect(enum).to be_a(Enumerator)
       end
 
-      context "when iterating over the enumerator" do
-
-        context "when iterating with each" do
-
-          it "yields mongoid documents to the block" do
-            enum.each do |doc|
-              expect(doc).to be_a(Mongoid::Document)
-            end
+      context 'when iterating over the enumerator' do
+        context 'when iterating with each' do
+          it 'yields mongoid documents to the block' do
+            expect(enum).to all(be_a(Mongoid::Document))
           end
         end
 
-        context "when iterating with next" do
-
-          it "yields mongoid documents" do
+        context 'when iterating with next' do
+          it 'yields mongoid documents' do
             expect(enum.next).to be_a(Mongoid::Document)
           end
         end
@@ -676,54 +630,49 @@ describe Mongoid::Contextual::Memory do
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
-        Address.where(street: "hobrecht").tap do |crit|
+        Address.where(street: 'hobrecht').tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.each
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#exists?" do
-
+  describe '#exists?' do
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(street: "hobrecht").tap do |crit|
+      Address.where(street: 'hobrecht').tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
 
-    context "when not passing options" do
-
-      context "when there are matching documents" do
-
+    context 'when not passing options' do
+      context 'when there are matching documents' do
         let(:context) do
           described_class.new(criteria)
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(context).to be_exists
         end
       end
 
-      context "when there are no matching documents" do
-
+      context 'when there are no matching documents' do
         let(:criteria) do
-          Address.where(street: "pfluger").tap do |crit|
+          Address.where(street: 'pfluger').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end
         end
@@ -732,147 +681,127 @@ describe Mongoid::Contextual::Memory do
           described_class.new(criteria)
         end
 
-        it "returns false" do
-          expect(context).to_not be_exists
+        it 'returns false' do
+          expect(context).not_to be_exists
         end
       end
 
       context 'when there is a collation on the criteria' do
-
         let(:criteria) do
-          Address.where(street: "pfluger").tap do |crit|
+          Address.where(street: 'pfluger').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end.collation(locale: 'en_US', strength: 2)
         end
 
-        it "raises an exception" do
-          expect {
+        it 'raises an exception' do
+          expect do
             context
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+          end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
 
-    context "when passing an _id" do
-
-      context "when its of type BSON::ObjectId" do
-
-        context "when calling it on an empty criteria" do
-
-          it "returns true" do
+    context 'when passing an _id' do
+      context 'when its of type BSON::ObjectId' do
+        context 'when calling it on an empty criteria' do
+          it 'returns true' do
             expect(criteria.exists?(hobrecht._id)).to be true
           end
         end
 
-        context "when calling it on a criteria that includes the object" do
-
-          it "returns true" do
+        context 'when calling it on a criteria that includes the object' do
+          it 'returns true' do
             expect(criteria.where(street: hobrecht.street).exists?(hobrecht._id)).to be true
           end
         end
 
-        context "when calling it on a criteria that does not include the object" do
-
-          it "returns false" do
-            expect(criteria.where(street: "bogus").exists?(hobrecht._id)).to be false
+        context 'when calling it on a criteria that does not include the object' do
+          it 'returns false' do
+            expect(criteria.where(street: 'bogus').exists?(hobrecht._id)).to be false
           end
         end
 
-        context "when the id does not exist" do
-
-          it "returns false" do
+        context 'when the id does not exist' do
+          it 'returns false' do
             expect(criteria.exists?(BSON::ObjectId.new)).to be false
           end
         end
       end
 
-      context "when its of type String" do
-
-        context "when the id exists" do
-
-          it "returns true" do
+      context 'when its of type String' do
+        context 'when the id exists' do
+          it 'returns true' do
             expect(criteria.exists?(hobrecht._id.to_s)).to be true
           end
         end
 
-        context "when the id does not exist" do
-
-          it "returns false" do
+        context 'when the id does not exist' do
+          it 'returns false' do
             expect(criteria.exists?(BSON::ObjectId.new.to_s)).to be false
           end
         end
       end
     end
 
-    context "when passing a hash" do
-
-      context "when calling it on an empty criteria" do
-
-        it "returns true" do
+    context 'when passing a hash' do
+      context 'when calling it on an empty criteria' do
+        it 'returns true' do
           expect(criteria.exists?(street: hobrecht.street)).to be true
         end
       end
 
-      context "when calling it on a criteria that includes the object" do
-
-        it "returns true" do
+      context 'when calling it on a criteria that includes the object' do
+        it 'returns true' do
           expect(criteria.where(_id: hobrecht._id).exists?(street: hobrecht.street)).to be true
         end
       end
 
-      context "when calling it on a criteria that does not include the object" do
-
-        it "returns false" do
+      context 'when calling it on a criteria that does not include the object' do
+        it 'returns false' do
           expect(criteria.where(_id: BSON::ObjectId.new).exists?(street: hobrecht.street)).to be false
         end
       end
 
       context "when the conditions don't match" do
-
-        it "returns false" do
-          expect(criteria.exists?(street: "bogus")).to be false
+        it 'returns false' do
+          expect(criteria.exists?(street: 'bogus')).to be false
         end
       end
     end
 
-    context "when passing false" do
-
-      it "returns false" do
+    context 'when passing false' do
+      it 'returns false' do
         expect(criteria.exists?(false)).to be false
       end
     end
 
-    context "when passing nil" do
-
-      it "returns false" do
+    context 'when passing nil' do
+      it 'returns false' do
         expect(criteria.exists?(nil)).to be false
       end
     end
 
-    context "when the limit is 0" do
-
-      it "returns false" do
+    context 'when the limit is 0' do
+      it 'returns false' do
         expect(criteria.limit(0).exists?).to be false
       end
     end
   end
 
-  [ :first, :one ].each do |method|
-
+  %i[first one].each do |method|
     describe "##{method}" do
-
       let(:method) { method }
 
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: 'hobrecht')
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: 'friedel')
       end
 
       let(:criteria) do
-        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end
       end
@@ -881,51 +810,49 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "returns the first matching document" do
+      it 'returns the first matching document' do
         expect(context.send(method)).to eq(hobrecht)
       end
 
-      it "returns a list when passing a limit" do
+      it 'returns a list when passing a limit' do
         expect(context.send(method, 2)).to eq([ hobrecht, friedel ])
       end
 
-      it "returns a list when passing 1" do
+      it 'returns a list when passing 1' do
         expect(context.send(method, 1)).to eq([ hobrecht ])
       end
 
-      include_examples "returns nil when no documents"
+      include_examples 'returns nil when no documents'
 
       context 'when there is a collation on the criteria' do
-
         let(:criteria) do
-          Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+          Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end.collation(locale: 'en_US', strength: 2)
         end
 
-        it "raises an exception" do
-          expect {
+        it 'raises an exception' do
+          expect do
             context.send(method)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+          end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
   end
 
-  describe "#first!" do
-
+  describe '#first!' do
     let(:method) { :first! }
 
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+      Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -934,27 +861,26 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    it "returns the first matching document" do
+    it 'returns the first matching document' do
       expect(context.first!).to eq(hobrecht)
     end
 
-    include_examples "raises an error when no documents"
+    include_examples 'raises an error when no documents'
   end
 
-  describe "#take" do
-
+  describe '#take' do
     let(:method) { :take }
 
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+      Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -963,50 +889,48 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    it "returns the first matching document" do
+    it 'returns the first matching document' do
       expect(context.take).to eq(hobrecht)
     end
 
-    it "returns an array when passing a limit" do
+    it 'returns an array when passing a limit' do
       expect(context.take(2)).to eq([ hobrecht, friedel ])
     end
 
-    it "returns an array when passing a limit as 1" do
+    it 'returns an array when passing a limit as 1' do
       expect(context.take(1)).to eq([ hobrecht ])
     end
 
-    include_examples "returns nil when no documents"
+    include_examples 'returns nil when no documents'
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
-        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.take
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#take!" do
-
+  describe '#take!' do
     let(:method) { :take! }
 
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+      Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -1015,42 +939,39 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    it "returns the first matching document" do
+    it 'returns the first matching document' do
       expect(context.take!).to eq(hobrecht)
     end
 
-    include_examples "raises an error when no documents"
+    include_examples 'raises an error when no documents'
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
-        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.take
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#initialize" do
-
-    context "when the criteria has no options" do
-
+  describe '#initialize' do
+    context 'when the criteria has no options' do
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: 'hobrecht')
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: 'friedel')
       end
 
       let(:criteria) do
-        Address.where(street: "hobrecht").tap do |crit|
+        Address.where(street: 'hobrecht').tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end
       end
@@ -1059,27 +980,26 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "sets the criteria" do
+      it 'sets the criteria' do
         expect(context.criteria).to eq(criteria)
       end
 
-      it "sets the klass" do
+      it 'sets the klass' do
         expect(context.klass).to eq(Address)
       end
 
-      it "sets the matching documents" do
+      it 'sets the matching documents' do
         expect(context.documents).to eq([ hobrecht ])
       end
     end
 
-    context "when the criteria skips" do
-
+    context 'when the criteria skips' do
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: 'hobrecht')
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: 'friedel')
       end
 
       let(:criteria) do
@@ -1092,19 +1012,18 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "limits the matching documents" do
+      it 'limits the matching documents' do
         expect(context).to eq([ friedel ])
       end
     end
 
-    context "when the criteria limits" do
-
+    context 'when the criteria limits' do
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: 'hobrecht')
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: 'friedel')
       end
 
       let(:criteria) do
@@ -1117,41 +1036,39 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "limits the matching documents" do
+      it 'limits the matching documents' do
         expect(context).to eq([ hobrecht ])
       end
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
         Address.all.limit(1).tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#last" do
-
+  describe '#last' do
     let(:method) { :last }
 
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+      Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -1160,49 +1077,48 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    it "returns the last matching document" do
+    it 'returns the last matching document' do
       expect(context.last).to eq(friedel)
     end
 
-    it "returns a list when a limit is passed" do
+    it 'returns a list when a limit is passed' do
       expect(context.last(2)).to eq([ hobrecht, friedel ])
     end
 
-    it "returns a list when the limit is 1" do
+    it 'returns a list when the limit is 1' do
       expect(context.last(1)).to eq([ friedel ])
     end
 
-    include_examples "returns nil when no documents"
+    include_examples 'returns nil when no documents'
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
-        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.last
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#last!" do
+  describe '#last!' do
     let(:method) { :last! }
 
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:criteria) do
-      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+      Address.where(:street.in => %w[hobrecht friedel]).tap do |crit|
         crit.documents = [ hobrecht, friedel ]
       end
     end
@@ -1211,20 +1127,19 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    it "returns the last matching document" do
+    it 'returns the last matching document' do
       expect(context.last!).to eq(friedel)
     end
 
-    include_examples "raises an error when no documents"
+    include_examples 'raises an error when no documents'
   end
 
-  [ :second,
-    :third,
-    :fourth,
-    :fifth,
-    :second_to_last,
-    :third_to_last
-  ].each do |meth|
+  %i[second
+     third
+     fourth
+     fifth
+     second_to_last
+     third_to_last].each do |meth|
     describe "##{meth}" do
       let(:method) { meth }
 
@@ -1234,7 +1149,7 @@ describe Mongoid::Contextual::Memory do
           Address.new,
           Address.new,
           Address.new,
-          Address.new,
+          Address.new
         ]
       end
 
@@ -1248,11 +1163,11 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "returns the matching document" do
+      it 'returns the matching document' do
         expect(context.send(method)).to eq(addresses.send(method))
       end
 
-      include_examples "returns nil when no documents"
+      include_examples 'returns nil when no documents'
     end
 
     describe "##{meth}!" do
@@ -1264,7 +1179,7 @@ describe Mongoid::Contextual::Memory do
           Address.new,
           Address.new,
           Address.new,
-          Address.new,
+          Address.new
         ]
       end
 
@@ -1278,30 +1193,27 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "returns the matching document" do
+      it 'returns the matching document' do
         expect(context.send(method)).to eq(addresses.send(meth))
       end
 
-      include_examples "raises an error when no documents"
+      include_examples 'raises an error when no documents'
     end
   end
 
-  [ :length, :size ].each do |method|
-
+  %i[length size].each do |method|
     describe "##{method}" do
-
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: 'hobrecht')
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: 'friedel')
       end
 
-      context "when there are matching documents" do
-
+      context 'when there are matching documents' do
         let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
+          Address.where(street: 'hobrecht').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end
         end
@@ -1310,15 +1222,14 @@ describe Mongoid::Contextual::Memory do
           described_class.new(criteria)
         end
 
-        it "returns the number of matches" do
+        it 'returns the number of matches' do
           expect(context.send(method)).to eq(1)
         end
       end
 
-      context "when there are no matching documents" do
-
+      context 'when there are no matching documents' do
         let(:criteria) do
-          Address.where(street: "pfluger").tap do |crit|
+          Address.where(street: 'pfluger').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end
         end
@@ -1327,40 +1238,38 @@ describe Mongoid::Contextual::Memory do
           described_class.new(criteria)
         end
 
-        it "returns zero" do
+        it 'returns zero' do
           expect(context.send(method)).to eq(0)
         end
       end
 
       context 'when there is a collation on the criteria' do
-
         let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
+          Address.where(street: 'hobrecht').tap do |crit|
             crit.documents = [ hobrecht, friedel ]
           end.collation(locale: 'en_US', strength: 2)
         end
 
-        it "raises an exception" do
-          expect {
+        it 'raises an exception' do
+          expect do
             context.send(method)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+          end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
   end
 
-  describe "#limit" do
-
+  describe '#limit' do
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:pfluger) do
-      Address.new(street: "pfluger")
+      Address.new(street: 'pfluger')
     end
 
     let(:criteria) do
@@ -1374,31 +1283,27 @@ describe Mongoid::Contextual::Memory do
     end
 
     context 'when there is no collation on the criteria' do
-
       let!(:limit) do
         context.limit(2)
       end
 
-      it "returns the context" do
+      it 'returns the context' do
         expect(limit).to eq(context)
       end
 
-      context "when asking for all documents" do
-
-        context "when only a limit exists" do
-
-          it "only returns the limited documents" do
+      context 'when asking for all documents' do
+        context 'when only a limit exists' do
+          it 'only returns the limited documents' do
             expect(context.entries).to eq([ hobrecht, friedel ])
           end
         end
 
-        context "when a skip and limit exist" do
-
+        context 'when a skip and limit exist' do
           before do
             limit.skip(1)
           end
 
-          it "applies the skip before the limit" do
+          it 'applies the skip before the limit' do
             expect(context.entries).to eq([ friedel, pfluger ])
           end
         end
@@ -1406,41 +1311,39 @@ describe Mongoid::Contextual::Memory do
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
         Address.all.tap do |crit|
           crit.documents = [ hobrecht, friedel, pfluger ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.limit(2)
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#pluck" do
-
+  describe '#pluck' do
     let(:context) do
       described_class.new(criteria)
     end
 
     let!(:depeche) do
-      Band.create!(name: "Depeche Mode", likes: 3)
+      Band.create!(name: 'Depeche Mode', likes: 3)
     end
 
     let!(:tool) do
-      Band.create!(name: "Tool", likes: 3)
+      Band.create!(name: 'Tool', likes: 3)
     end
 
     let!(:photek) do
-      Band.create!(name: "Photek", likes: 1)
+      Band.create!(name: 'Photek', likes: 1)
     end
 
     let!(:maniacs) do
-      Band.create!(name: "10,000 Maniacs", likes: 1, sales: "1E2")
+      Band.create!(name: '10,000 Maniacs', likes: 1, sales: '1E2')
     end
 
     let(:criteria) do
@@ -1449,10 +1352,9 @@ describe Mongoid::Contextual::Memory do
       end
     end
 
-    context "when the field is aliased" do
-
+    context 'when the field is aliased' do
       let!(:expensive) do
-        Product.create!(price: 100000)
+        Product.create!(price: 100_000)
       end
 
       let!(:cheap) do
@@ -1465,39 +1367,34 @@ describe Mongoid::Contextual::Memory do
         end
       end
 
-      context "when using alias_attribute" do
-
+      context 'when using alias_attribute' do
         let(:plucked) do
           context.pluck(:price)
         end
 
-        it "uses the aliases" do
-          expect(plucked).to eq([ 100000, 1 ])
+        it 'uses the aliases' do
+          expect(plucked).to eq([ 100_000, 1 ])
         end
       end
     end
 
-    context "when the criteria matches" do
-
-      context "when there are no duplicate values" do
-
+    context 'when the criteria matches' do
+      context 'when there are no duplicate values' do
         let!(:plucked) do
           context.pluck(:name)
         end
 
-        it "returns the values" do
-          expect(plucked).to contain_exactly("10,000 Maniacs", "Depeche Mode", "Tool", "Photek")
+        it 'returns the values' do
+          expect(plucked).to contain_exactly('10,000 Maniacs', 'Depeche Mode', 'Tool', 'Photek')
         end
 
-        context "when subsequently executing the criteria without a pluck" do
-
-          it "does not limit the fields" do
+        context 'when subsequently executing the criteria without a pluck' do
+          it 'does not limit the fields' do
             expect(context.first.likes).to eq(3)
           end
         end
 
         context 'when the field is a subdocument' do
-
           context 'when a top-level field and a subdocument field are plucked' do
             let(:criteria) do
               Band.where(name: 'FKA Twigs').tap do |crit|
@@ -1514,8 +1411,8 @@ describe Mongoid::Contextual::Memory do
 
             let(:expected) do
               [
-                ["FKA Twigs", []],
-                ['FKA Twigs', ["LP1"]]
+                [ 'FKA Twigs', [] ],
+                [ 'FKA Twigs', [ 'LP1' ] ]
               ]
             end
 
@@ -1525,7 +1422,6 @@ describe Mongoid::Contextual::Memory do
           end
 
           context 'when only a subdocument field is plucked' do
-
             let(:criteria) do
               Band.where(name: 'FKA Twigs').tap do |crit|
                 crit.documents = [
@@ -1542,7 +1438,7 @@ describe Mongoid::Contextual::Memory do
             let(:expected) do
               [
                 [],
-                ["LP1"]
+                [ 'LP1' ]
               ]
             end
 
@@ -1553,72 +1449,66 @@ describe Mongoid::Contextual::Memory do
         end
       end
 
-      context "when plucking multi-fields" do
-
+      context 'when plucking multi-fields' do
         let(:plucked) do
           context.pluck(:name, :likes)
         end
 
-        it "returns the values" do
-          expect(plucked).to contain_exactly(["10,000 Maniacs", 1], ["Depeche Mode", 3], ["Tool", 3], ["Photek", 1])
+        it 'returns the values' do
+          expect(plucked).to contain_exactly([ '10,000 Maniacs', 1 ], [ 'Depeche Mode', 3 ], [ 'Tool', 3 ],
+                                             [ 'Photek', 1 ])
         end
       end
 
-      context "when there are duplicate values" do
-
+      context 'when there are duplicate values' do
         let(:plucked) do
           context.pluck(:likes)
         end
 
-        it "returns the duplicates" do
+        it 'returns the duplicates' do
           expect(plucked).to contain_exactly(1, 3, 3, 1)
         end
       end
     end
 
-    context "when plucking an aliased field" do
-
+    context 'when plucking an aliased field' do
       let(:plucked) do
         context.pluck(:id)
       end
 
-      it "returns the field values" do
+      it 'returns the field values' do
         expect(plucked).to eq([ depeche.id, tool.id, photek.id, maniacs.id ])
       end
     end
 
-    context "when plucking existent and non-existent fields" do
-
+    context 'when plucking existent and non-existent fields' do
       let(:plucked) do
         context.pluck(:id, :fooz)
       end
 
-      it "returns nil for the field that doesnt exist" do
-        expect(plucked).to eq([[depeche.id, nil], [tool.id, nil], [photek.id, nil], [maniacs.id, nil] ])
+      it 'returns nil for the field that doesnt exist' do
+        expect(plucked).to eq([ [ depeche.id, nil ], [ tool.id, nil ], [ photek.id, nil ], [ maniacs.id, nil ] ])
       end
     end
 
-    context "when plucking a field that doesnt exist" do
-
-      context "when pluck one field" do
-
+    context 'when plucking a field that doesnt exist' do
+      context 'when pluck one field' do
         let(:plucked) do
           context.pluck(:foo)
         end
 
-        it "returns an array with nil values" do
-          expect(plucked).to eq([nil, nil, nil, nil])
+        it 'returns an array with nil values' do
+          expect(plucked).to eq([ nil, nil, nil, nil ])
         end
       end
 
-      context "when pluck multiple fields" do
-
+      context 'when pluck multiple fields' do
         let(:plucked) do
           context.pluck(:foo, :bar)
         end
 
-        it "returns an array of arrays with nil values" do
-          expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil], [nil, nil]])
+        it 'returns an array of arrays with nil values' do
+          expect(plucked).to eq([ [ nil, nil ], [ nil, nil ], [ nil, nil ], [ nil, nil ] ])
         end
       end
     end
@@ -1641,7 +1531,6 @@ describe Mongoid::Contextual::Memory do
       end
 
       context 'when plucking the entire field' do
-
         let(:plucked) do
           context.pluck(:description)
         end
@@ -1659,16 +1548,16 @@ describe Mongoid::Contextual::Memory 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
           context.pluck(:'description.de')
         end
@@ -1679,7 +1568,6 @@ describe Mongoid::Contextual::Memory do
       end
 
       context 'when plucking a specific locale from _translations field' do
-
         let(:plucked) do
           context.pluck(:'description_translations.de')
         end
@@ -1701,141 +1589,140 @@ describe Mongoid::Contextual::Memory do
           context.pluck(:description).first
         end
 
-        it "correctly uses the fallback" do
+        it 'correctly uses the fallback' do
           I18n.locale = :en
           Dictionary.create!(description: 'english-text')
           I18n.locale = :he
-          plucked.should == "english-text"
+          plucked.should eq 'english-text'
         end
       end
 
-      context "when the localized field is embedded" do
+      context 'when the localized field is embedded' do
         with_default_i18n_configs
 
         before do
           p = Passport.new
           I18n.locale = :en
-          p.name = "Neil"
+          p.name = 'Neil'
           I18n.locale = :he
-          p.name = "Nissim"
+          p.name = 'Nissim'
 
-          Person.create!(passport: p, employer_id: 12345)
+          Person.create!(passport: p, employer_id: 12_345)
         end
 
         let(:plucked) do
-          Person.where(employer_id: 12345).pluck("pass.name").first
+          Person.where(employer_id: 12_345).pluck('pass.name').first
         end
 
         let(:plucked_translations) do
-          Person.where(employer_id: 12345).pluck("pass.name_translations").first
+          Person.where(employer_id: 12_345).pluck('pass.name_translations').first
         end
 
         let(:plucked_translations_field) do
-          Person.where(employer_id: 12345).pluck("pass.name_translations.en").first
+          Person.where(employer_id: 12_345).pluck('pass.name_translations.en').first
         end
 
-        it "returns the translation for the current locale" do
-          expect(plucked).to eq("Nissim")
+        it 'returns the translation for the current locale' do
+          expect(plucked).to eq('Nissim')
         end
 
-        it "returns the full _translation hash" do
-          expect(plucked_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
+        it 'returns the full _translation hash' do
+          expect(plucked_translations).to eq({ 'en' => 'Neil', 'he' => 'Nissim' })
         end
 
-        it "returns the translation for the requested locale" do
-          expect(plucked_translations_field).to eq("Neil")
+        it 'returns the translation for the requested locale' do
+          expect(plucked_translations_field).to eq('Neil')
         end
       end
     end
 
     context 'when plucking a field to be demongoized' do
-
       let(:plucked) do
         Band.where(name: maniacs.name).pluck(:sales)
       end
 
       with_config_values :map_big_decimal_to_decimal128, true, false do
-
-        it "demongoizes the field" do
+        it 'demongoizes the field' do
           expect(plucked.first).to be_a(BigDecimal)
-          expect(plucked.first).to eq(BigDecimal("1E2"))
+          expect(plucked.first).to eq(BigDecimal('1E2'))
         end
       end
     end
 
-    context "when plucking an embedded field" do
-      let(:label) { Label.new(sales: "1E2") }
+    context 'when plucking an embedded field' do
+      let(:label) { Label.new(sales: '1E2') }
       let!(:band) { Band.create!(label: label) }
 
       let(:plucked) do
         Band.where(_id: band.id).tap do |crit|
           crit.documents = [ band ]
-        end.pluck("label.sales")
+        end.pluck('label.sales')
       end
 
-      it "demongoizes the field" do
-        expect(plucked).to eq([ BigDecimal("1E2") ])
+      it 'demongoizes the field' do
+        expect(plucked).to eq([ BigDecimal('1E2') ])
       end
     end
 
-    context "when plucking an embeds_many field" do
-      let(:label) { Label.new(sales: "1E2") }
-      let!(:band) { Band.create!(labels: [label]) }
+    context 'when plucking an embeds_many field' do
+      let(:label) { Label.new(sales: '1E2') }
+      let!(:band) { Band.create!(labels: [ label ]) }
 
-      let(:plucked) { Band.where(_id: band.id).pluck("labels.sales") }
+      let(:plucked) { Band.where(_id: band.id).pluck('labels.sales') }
 
-      it "demongoizes the field" do
-        expect(plucked.first).to eq([ BigDecimal("1E2") ])
+      it 'demongoizes the field' do
+        expect(plucked.first).to eq([ BigDecimal('1E2') ])
       end
     end
 
-    context "when plucking a nonexistent embedded field" do
-      let(:label) { Label.new(sales: "1E2") }
+    context 'when plucking a nonexistent embedded field' do
+      let(:label) { Label.new(sales: '1E2') }
       let!(:band) { Band.create!(label: label) }
 
       let(:plucked) do
         Band.where(_id: band.id).tap do |crit|
           crit.documents = [ band ]
-        end.pluck("label.qwerty")
+        end.pluck('label.qwerty')
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(plucked.first).to eq(nil)
       end
     end
 
-    context "when plucking deeply nested arrays/embedded associations" do
-
+    context 'when plucking deeply nested arrays/embedded associations' do
       let(:criteria) do
         Person.all.tap do |crit|
           crit.documents = [
-            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]),
-            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]),
-            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ]),
+            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                                 { y: { z: 2 } } ]))) ]),
+            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                                 { y: { z: 2 } } ]))) ]),
+            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                                 { y: { z: 3 } } ]))) ])
           ]
         end
       end
 
       let(:plucked) do
-        context.pluck("addresses.code.deepest.array.y.z")
+        context.pluck('addresses.code.deepest.array.y.z')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(plucked).to eq([
-          [ [ 1, 2 ] ], [ [ 1, 2 ] ], [ [ 1, 3 ] ]
-        ])
+                                [ [ 1, 2 ] ], [ [ 1, 2 ] ], [ [ 1, 3 ] ]
+                              ])
       end
     end
   end
 
-  describe "#pick" do
-
+  describe '#pick' do
     let(:depeche) do
-      Band.create!(name: "Depeche Mode", likes: 3)
+      Band.create!(name: 'Depeche Mode', likes: 3)
     end
 
     let(:tool) do
-      Band.create!(name: "Tool", likes: 3)
+      Band.create!(name: 'Tool', likes: 3)
     end
 
     let(:criteria) do
@@ -1848,30 +1735,27 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    context "when picking a field" do
-
+    context 'when picking a field' do
       let(:picked) do
         context.pick(:name)
       end
 
-      it "returns one element" do
-        expect(picked).to eq("Depeche Mode")
+      it 'returns one element' do
+        expect(picked).to eq('Depeche Mode')
       end
     end
 
-    context "when picking multiple fields" do
-
+    context 'when picking multiple fields' do
       let(:picked) do
         context.pick(:name, :likes)
       end
 
-      it "returns an array" do
-        expect(picked).to eq([ "Depeche Mode", 3 ])
+      it 'returns an array' do
+        expect(picked).to eq([ 'Depeche Mode', 3 ])
       end
     end
 
-    context "when no documents to pick" do
-
+    context 'when no documents to pick' do
       let(:criteria) do
         Band.all.tap do |crit|
           crit.documents = []
@@ -1882,41 +1766,46 @@ describe Mongoid::Contextual::Memory do
         context.pick(:name)
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(picked).to be_nil
       end
     end
   end
 
-  describe "#tally" do
-    let(:fans1) { [ Fanatic.new(age:1), Fanatic.new(age:2) ] }
-    let(:fans2) { [ Fanatic.new(age:1), Fanatic.new(age:2) ] }
-    let(:fans3) { [ Fanatic.new(age:1), Fanatic.new(age:3) ] }
-
-    let(:genres1) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 3 } ]}
-    let(:genres2) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 4 } ]}
-    let(:genres3) { [ { x: 1, y: { z: 1 } }, { x: 3, y: { z: 3 } }, { y: 5 } ]}
+  describe '#tally' do
+    let(:fans1) { [ Fanatic.new(age: 1), Fanatic.new(age: 2) ] }
+    let(:fans2) { [ Fanatic.new(age: 1), Fanatic.new(age: 2) ] }
+    let(:fans3) { [ Fanatic.new(age: 1), Fanatic.new(age: 3) ] }
 
-    let(:label1) {  Label.new(name: "Atlantic") }
-    let(:label2) {  Label.new(name: "Atlantic") }
-    let(:label3) {  Label.new(name: "Columbia") }
+    let(:genres1) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 3 } ] }
+    let(:genres2) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 4 } ] }
+    let(:genres3) { [ { x: 1, y: { z: 1 } }, { x: 3, y: { z: 3 } }, { y: 5 } ] }
 
+    let(:label1) {  Label.new(name: 'Atlantic') }
+    let(:label2) {  Label.new(name: 'Atlantic') }
+    let(:label3) {  Label.new(name: 'Columbia') }
 
-    let(:band1) { Band.new(origin: "tally", name: "Depeche Mode", years: 30, sales: "1E2", label: label1, genres: genres1) }
-    let(:band2) { Band.new(origin: "tally", name: "New Order", years: 30, sales: "2E3", label: label2, genres: genres2) }
-    let(:band3) { Band.new(origin: "tally", name: "10,000 Maniacs", years: 30, sales: "1E2", label: label3, genres: genres3) }
-    let(:band4) { Band.new(origin: "tally2", fanatics: fans1, genres: [1, 2]) }
-    let(:band5) { Band.new(origin: "tally2", fanatics: fans2, genres: [1, 2]) }
-    let(:band6) { Band.new(origin: "tally2", fanatics: fans3, genres: [1, 3]) }
+    let(:band1) do
+      Band.new(origin: 'tally', name: 'Depeche Mode', years: 30, sales: '1E2', label: label1, genres: genres1)
+    end
+    let(:band2) do
+      Band.new(origin: 'tally', name: 'New Order', years: 30, sales: '2E3', label: label2, genres: genres2)
+    end
+    let(:band3) do
+      Band.new(origin: 'tally', name: '10,000 Maniacs', years: 30, sales: '1E2', label: label3, genres: genres3)
+    end
+    let(:band4) { Band.new(origin: 'tally2', fanatics: fans1, genres: [ 1, 2 ]) }
+    let(:band5) { Band.new(origin: 'tally2', fanatics: fans2, genres: [ 1, 2 ]) }
+    let(:band6) { Band.new(origin: 'tally2', fanatics: fans3, genres: [ 1, 3 ]) }
 
     let(:criteria) do
-      Band.where(origin: "tally").all.tap do |crit|
+      Band.where(origin: 'tally').all.tap do |crit|
         crit.documents = [ band1, band2, band3 ]
       end
     end
 
     let(:criteria2) do
-      Band.where(origin: "tally2").tap do |crit|
+      Band.where(origin: 'tally2').tap do |crit|
         crit.documents = [ band4, band5, band6 ]
       end
     end
@@ -1929,40 +1818,45 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria2)
     end
 
-    context "when tallying a string" do
+    context 'when tallying a string' do
       let(:tally) do
         context.tally(:name)
       end
 
-      it "returns the correct hash" do
-        expect(tally).to eq("Depeche Mode" => 1, "New Order" => 1, "10,000 Maniacs" => 1)
+      it 'returns the correct hash' do
+        expect(tally).to eq('Depeche Mode' => 1, 'New Order' => 1, '10,000 Maniacs' => 1)
       end
     end
 
-    context "using an aliased field" do
+    context 'using an aliased field' do
       let(:tally) do
         context.tally(:years)
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(30 => 3)
       end
     end
 
-    context "when tallying a demongoizable field" do
+    context 'when tallying a demongoizable field' do
       let(:tally) do
         context.tally(:sales)
       end
 
-      it "returns the correct hash" do
-        expect(tally).to eq(BigDecimal("1E2") => 2, BigDecimal("2E3") => 1)
+      it 'returns the correct hash' do
+        expect(tally).to eq(BigDecimal('1E2') => 2, BigDecimal('2E3') => 1)
       end
     end
 
-    context "when tallying a localized field" do
+    context 'when tallying a localized field' do
       with_default_i18n_configs
 
       let(:d1) { Dictionary.new(description: 'en1') }
+      let(:criteria) do
+        Dictionary.all.tap do |crit|
+          crit.documents = [ d1, d2, d3, d4 ]
+        end
+      end
       let(:d2) { Dictionary.new(description: 'en1') }
       let(:d3) { Dictionary.new(description: 'en1') }
       let(:d4) { Dictionary.new(description: 'en2') }
@@ -1981,57 +1875,56 @@ describe Mongoid::Contextual::Memory do
         I18n.locale = :en
       end
 
-      let(:criteria) do
-        Dictionary.all.tap do |crit|
-          crit.documents = [ d1, d2, d3, d4 ]
-        end
-      end
-
-      context "when getting the demongoized field" do
+      context 'when getting the demongoized field' do
         let(:tallied) do
           context.tally(:description)
         end
 
-        it "returns the translation for the current locale" do
-          expect(tallied).to eq("en1" => 3, "en2" => 1)
+        it 'returns the translation for the current locale' do
+          expect(tallied).to eq('en1' => 3, 'en2' => 1)
         end
       end
 
-      context "when getting a specific locale" do
+      context 'when getting a specific locale' do
         let(:tallied) do
-          context.tally("description.de")
+          context.tally('description.de')
         end
 
-        it "returns the translation for the the specific locale" do
-          expect(tallied).to eq("de1" => 2, "de2" => 1, "de3" => 1)
+        it 'returns the translation for the the specific locale' do
+          expect(tallied).to eq('de1' => 2, 'de2' => 1, 'de3' => 1)
         end
       end
 
-      context "when getting the full hash" do
+      context 'when getting the full hash' do
         let(:tallied) do
-          context.tally("description_translations")
+          context.tally('description_translations')
         end
 
-        it "returns the correct hash" do
+        it 'returns the correct hash' do
           expect(tallied).to eq(
-            {"de" => "de1", "en" => "en1" } => 2,
-            {"de" => "de2", "en" => "en1" } => 1,
-            {"de" => "de3", "en" => "en2" } => 1
+            { 'de' => 'de1', 'en' => 'en1' } => 2,
+            { 'de' => 'de2', 'en' => 'en1' } => 1,
+            { 'de' => 'de3', 'en' => 'en2' } => 1
           )
         end
       end
     end
 
-    context "when tallying an embedded localized field" do
+    context 'when tallying an embedded localized field' do
       with_default_i18n_configs
 
       let(:person1) { Person.create!(addresses: [ address1a, address1b ]) }
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2 ]
+        end
+      end
       let(:person2) { Person.create!(addresses: [ address2a, address2b ]) }
 
-      let(:address1a) { Address.new(name: "en1") }
-      let(:address1b) { Address.new(name: "en2") }
-      let(:address2a) { Address.new(name: "en1") }
-      let(:address2b) { Address.new(name: "en3") }
+      let(:address1a) { Address.new(name: 'en1') }
+      let(:address1b) { Address.new(name: 'en2') }
+      let(:address2a) { Address.new(name: 'en1') }
+      let(:address2b) { Address.new(name: 'en3') }
 
       before do
         I18n.locale = :en
@@ -2040,153 +1933,141 @@ describe Mongoid::Contextual::Memory do
         address2a
         address2b
         I18n.locale = :de
-        address1a.name = "de1"
-        address1b.name = "de2"
-        address2a.name = "de1"
-        address2b.name = "de3"
+        address1a.name = 'de1'
+        address1b.name = 'de2'
+        address2a.name = 'de1'
+        address2b.name = 'de3'
         person1
         person2
         I18n.locale = :en
       end
 
-      let(:criteria) do
-        Person.all.tap do |crit|
-          crit.documents = [ person1, person2 ]
-        end
-      end
-
-      context "when getting the demongoized field" do
+      context 'when getting the demongoized field' do
         let(:tallied) do
-          context.tally("addresses.name")
+          context.tally('addresses.name')
         end
 
-        it "returns the translation for the current locale" do
+        it 'returns the translation for the current locale' do
           expect(tallied).to eq(
-            [ "en1", "en2" ] => 1,
-            [ "en1", "en3" ] => 1,
+            %w[en1 en2] => 1,
+            %w[en1 en3] => 1
           )
         end
       end
 
-      context "when getting a specific locale" do
+      context 'when getting a specific locale' do
         let(:tallied) do
-          context.tally("addresses.name.de")
+          context.tally('addresses.name.de')
         end
 
-        it "returns the translation for the the specific locale" do
+        it 'returns the translation for the the specific locale' do
           expect(tallied).to eq(
-            [ "de1", "de2" ] => 1,
-            [ "de1", "de3" ] => 1,
+            %w[de1 de2] => 1,
+            %w[de1 de3] => 1
           )
         end
       end
 
-      context "when getting the full hash" do
+      context 'when getting the full hash' do
         let(:tallied) do
-          context.tally("addresses.name_translations")
+          context.tally('addresses.name_translations')
         end
 
-        it "returns the correct hash" do
+        it 'returns the correct hash' do
           expect(tallied).to eq(
-            [{ "de" => "de1", "en" => "en1" }, { "de" => "de2", "en" => "en2" }] => 1,
-            [{ "de" => "de1", "en" => "en1" }, { "de" => "de3", "en" => "en3" }] => 1,
+            [ { 'de' => 'de1', 'en' => 'en1' }, { 'de' => 'de2', 'en' => 'en2' } ] => 1,
+            [ { 'de' => 'de1', 'en' => 'en1' }, { 'de' => 'de3', 'en' => 'en3' } ] => 1
           )
         end
       end
     end
 
-    context "when tallying an embedded field" do
+    context 'when tallying an embedded field' do
       let(:tally) do
-        context.tally("label.name")
+        context.tally('label.name')
       end
 
-      it "returns the correct hash" do
-        expect(tally).to eq("Atlantic" => 2, "Columbia" => 1)
+      it 'returns the correct hash' do
+        expect(tally).to eq('Atlantic' => 2, 'Columbia' => 1)
       end
     end
 
-    context "when tallying an element in an embeds_many field" do
-
+    context 'when tallying an element in an embeds_many field' do
       let(:tally) do
-        context2.tally("fanatics.age")
+        context2.tally('fanatics.age')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1
         )
       end
     end
 
-    context "when tallying an embeds_many field" do
-
+    context 'when tallying an embeds_many field' do
       let(:tally) do
-        context2.tally("fanatics")
+        context2.tally('fanatics')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
           fans1 => 1,
           fans2 => 1,
-          fans3 => 1,
+          fans3 => 1
         )
       end
     end
 
-    context "when tallying a field of type array" do
-
+    context 'when tallying a field of type array' do
       let(:tally) do
-        context2.tally("genres")
+        context2.tally('genres')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1
         )
       end
     end
 
-    context "when tallying an element from an array of hashes" do
-
+    context 'when tallying an element from an array of hashes' do
       let(:tally) do
-        context.tally("genres.x")
+        context.tally('genres.x')
       end
 
-      it "returns the correct hash without the nil keys" do
+      it 'returns the correct hash without the nil keys' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1
         )
       end
     end
 
-    context "when tallying an element from an array of hashes; with duplicate" do
-
-      let(:band4) { Band.new(origin: "tally", genres: [ { x: 1 }, {x: 1} ] ) }
+    context 'when tallying an element from an array of hashes; with duplicate' do
+      let(:band4) { Band.new(origin: 'tally', genres: [ { x: 1 }, { x: 1 } ]) }
 
       let(:criteria) do
-        Band.where(origin: "tally").all.tap do |crit|
+        Band.where(origin: 'tally').all.tap do |crit|
           crit.documents = [ band1, band2, band3, band4 ]
         end
       end
 
       let(:tally) do
-        context.tally("genres.x")
+        context.tally('genres.x')
       end
 
-      it "returns the correct hash without the nil keys" do
+      it 'returns the correct hash without the nil keys' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1,
-          [1, 1] => 1,
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1,
+          [ 1, 1 ] => 1
         )
       end
     end
 
-    context "when tallying an aliased field of type array" do
-
+    context 'when tallying an aliased field of type array' do
       let(:person1) { Person.new(array: [ 1, 2 ]) }
       let(:person2) { Person.new(array: [ 1, 3 ]) }
 
@@ -2197,50 +2078,56 @@ describe Mongoid::Contextual::Memory do
       end
 
       let(:tally) do
-        context.tally("array")
+        context.tally('array')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          [1, 2] => 1,
-          [1, 3] => 1
+          [ 1, 2 ] => 1,
+          [ 1, 3 ] => 1
         )
       end
     end
 
-    context "when going multiple levels deep in arrays" do
-
+    context 'when going multiple levels deep in arrays' do
       let(:tally) do
-        context.tally("genres.y.z")
+        context.tally('genres.y.z')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1
         )
       end
     end
 
-    context "when going multiple levels deep in an array" do
-
+    context 'when going multiple levels deep in an array' do
       let(:tally) do
-        context.tally("genres.y.z")
+        context.tally('genres.y.z')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1
         )
       end
     end
 
-    context "when tallying deeply nested arrays/embedded associations" do
-
-      let(:person1) { Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]) }
-      let(:person2) { Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]) }
-      let(:person3) { Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ]) }
+    context 'when tallying deeply nested arrays/embedded associations' do
+      let(:person1) do
+        Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                         { y: { z: 2 } } ]))) ])
+      end
+      let(:person2) do
+        Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                         { y: { z: 2 } } ]))) ])
+      end
+      let(:person3) do
+        Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                         { y: { z: 3 } } ]))) ])
+      end
 
       let(:criteria) do
         Person.all.tap do |crit|
@@ -2249,10 +2136,10 @@ describe Mongoid::Contextual::Memory do
       end
 
       let(:tally) do
-        context.tally("addresses.code.deepest.array.y.z")
+        context.tally('addresses.code.deepest.array.y.z')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
           [ [ 1, 2 ] ] => 2,
           [ [ 1, 3 ] ] => 1
@@ -2260,21 +2147,23 @@ describe Mongoid::Contextual::Memory do
       end
     end
 
-    context "when tallying deeply nested arrays/embedded associations" do
-
+    context 'when tallying deeply nested arrays/embedded associations' do
       let(:person1) do
         Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))),
-                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+                                Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                         { y: { z: 2 } } ]))) ])
       end
 
       let(:person2) do
         Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))),
-                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+                                Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                         { y: { z: 2 } } ]))) ])
       end
 
       let(:person3) do
         Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))),
-                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ])
+                                Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } },
+                                                                                         { y: { z: 3 } } ]))) ])
       end
 
       let(:criteria) do
@@ -2284,10 +2173,10 @@ describe Mongoid::Contextual::Memory do
       end
 
       let(:tally) do
-        context.tally("addresses.code.deepest.array.y.z")
+        context.tally('addresses.code.deepest.array.y.z')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
           [ [ 1, 2 ], [ 1, 2 ] ] => 2,
           [ [ 1, 3 ], [ 1, 3 ] ] => 1
@@ -2295,12 +2184,11 @@ describe Mongoid::Contextual::Memory do
       end
     end
 
-    context "when some keys are missing" do
-
+    context 'when some keys are missing' do
       let(:criteria) do
-        Band.where(origin: "tally").all.tap do |crit|
+        Band.where(origin: 'tally').all.tap do |crit|
           crit.documents = [ band1, band2, band3 ]
-          3.times{ crit.documents << Band.new(origin: "tally") }
+          3.times { crit.documents << Band.new(origin: 'tally') }
         end
       end
 
@@ -2308,20 +2196,26 @@ describe Mongoid::Contextual::Memory do
         context.tally(:name)
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          "Depeche Mode" => 1,
-          "New Order" => 1,
-          "10,000 Maniacs" => 1,
+          'Depeche Mode' => 1,
+          'New Order' => 1,
+          '10,000 Maniacs' => 1,
           nil => 3
         )
       end
     end
 
-    context "when the first element is an embeds_one" do
-      let(:person1) { Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ])) }
-      let(:person2) { Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ])) }
-      let(:person3) { Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 3) ])) }
+    context 'when the first element is an embeds_one' do
+      let(:person1) do
+        Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ]))
+      end
+      let(:person2) do
+        Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ]))
+      end
+      let(:person3) do
+        Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 3) ]))
+      end
 
       let(:criteria) do
         Person.all.tap do |crit|
@@ -2330,20 +2224,19 @@ describe Mongoid::Contextual::Memory do
       end
 
       let(:tally) do
-        context.tally("name.translations.language")
+        context.tally('name.translations.language')
       end
 
-      it "returns the correct hash" do
+      it 'returns the correct hash' do
         expect(tally).to eq(
-          [1, 2] => 2,
-          [1, 3] => 1
+          [ 1, 2 ] => 2,
+          [ 1, 3 ] => 1
         )
       end
     end
   end
 
   describe '#inc' do
-
     let(:criteria) do
       Address.all.tap do |crit|
         crit.documents = [ Address.new(number: 1),
@@ -2357,22 +2250,21 @@ describe Mongoid::Contextual::Memory do
     end
 
     it 'increases each member' do
-      expect(context.inc(number: 10).collect(&:number)).to eql([11, 12, 13])
+      expect(context.inc(number: 10).collect(&:number)).to eql([ 11, 12, 13 ])
     end
   end
 
-  describe "#skip" do
-
+  describe '#skip' do
     let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      Address.new(street: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel")
+      Address.new(street: 'friedel')
     end
 
     let(:pfluger) do
-      Address.new(street: "pfluger")
+      Address.new(street: 'pfluger')
     end
 
     let(:criteria) do
@@ -2386,31 +2278,27 @@ describe Mongoid::Contextual::Memory do
     end
 
     context 'when there is no collation on the criteria' do
-
       let!(:skip) do
         context.skip(1)
       end
 
-      it "returns the context" do
+      it 'returns the context' do
         expect(skip).to eq(context)
       end
 
-      context "when asking for all documents" do
-
-        context "when only a skip exists" do
-
-          it "skips the correct number" do
+      context 'when asking for all documents' do
+        context 'when only a skip exists' do
+          it 'skips the correct number' do
             expect(context.entries).to eq([ friedel, pfluger ])
           end
         end
 
-        context "when a skip and limit exist" do
-
+        context 'when a skip and limit exist' do
           before do
             skip.limit(1)
           end
 
-          it "applies the skip before the limit" do
+          it 'applies the skip before the limit' do
             expect(context.entries).to eq([ friedel ])
           end
         end
@@ -2418,33 +2306,31 @@ describe Mongoid::Contextual::Memory do
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
         Address.all.tap do |crit|
           crit.documents = [ hobrecht, friedel, pfluger ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.skip(1)
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#sort" do
-
+  describe '#sort' do
     let(:hobrecht) do
-      Address.new(street: "hobrecht", number: 9, name: "hobrecht")
+      Address.new(street: 'hobrecht', number: 9, name: 'hobrecht')
     end
 
     let(:friedel) do
-      Address.new(street: "friedel", number: 1, name: "friedel")
+      Address.new(street: 'friedel', number: 1, name: 'friedel')
     end
 
     let(:pfluger) do
-      Address.new(street: "pfluger", number: 5, name: "pfluger")
+      Address.new(street: 'pfluger', number: 5, name: 'pfluger')
     end
 
     let(:criteria) do
@@ -2457,42 +2343,37 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    context "when providing a single field sort" do
-
-      context "when the sort is ascending" do
-
+    context 'when providing a single field sort' do
+      context 'when the sort is ascending' do
         let!(:sorted) do
           context.sort(street: 1)
         end
 
-        it "sorts the documents" do
+        it 'sorts the documents' do
           expect(context.entries).to eq([ friedel, hobrecht, pfluger ])
         end
 
-        it "returns the context" do
+        it 'returns the context' do
           expect(sorted).to eq(context)
         end
       end
 
-      context "when the sort is descending" do
-
-        context "when sorting on a string" do
-
+      context 'when the sort is descending' do
+        context 'when sorting on a string' do
           let!(:sorted) do
             context.sort(street: -1)
           end
 
-          it "sorts the documents" do
+          it 'sorts the documents' do
             expect(context.entries).to eq([ pfluger, hobrecht, friedel ])
           end
 
-          it "returns the context" do
+          it 'returns the context' do
             expect(sorted).to eq(context)
           end
         end
 
-        context "when sorting on a time" do
-
+        context 'when sorting on a time' do
           before do
             pfluger.move_in = 30.days.ago
             hobrecht.move_in = 25.days.ago
@@ -2502,25 +2383,24 @@ describe Mongoid::Contextual::Memory do
             context.sort(move_in: -1)
           end
 
-          it "sorts the documents" do
+          it 'sorts the documents' do
             expect(context.entries).to eq([ friedel, hobrecht, pfluger ])
           end
 
-          it "returns the context" do
+          it 'returns the context' do
             expect(sorted).to eq(context)
           end
         end
       end
     end
 
-    context "when providing multiple sort fields" do
-
+    context 'when providing multiple sort fields' do
       let(:lenau) do
-        Address.new(street: "lenau", number: 5, name: "lenau")
+        Address.new(street: 'lenau', number: 5, name: 'lenau')
       end
 
       let(:kampuchea_krom) do
-        Address.new(street: "kampuchea krom", number: 5, name: "kampuchea krom")
+        Address.new(street: 'kampuchea krom', number: 5, name: 'kampuchea krom')
       end
 
       before do
@@ -2528,101 +2408,94 @@ describe Mongoid::Contextual::Memory do
         criteria.documents.unshift(kampuchea_krom)
       end
 
-      context "when the sort is ascending" do
-
+      context 'when the sort is ascending' do
         let!(:sorted) do
           context.sort(number: 1, street: 1)
         end
 
-        it "sorts the documents" do
+        it 'sorts the documents' do
           expect(context.entries).to eq([ friedel, kampuchea_krom, lenau, pfluger, hobrecht ])
         end
 
-        it "returns the context" do
+        it 'returns the context' do
           expect(sorted).to eq(context)
         end
       end
 
-      context "when the sort is descending" do
-
+      context 'when the sort is descending' do
         let!(:sorted) do
           context.sort(number: -1, street: -1)
         end
 
-        it "sorts the documents" do
+        it 'sorts the documents' do
           expect(context.entries).to eq([ hobrecht, pfluger, lenau, kampuchea_krom, friedel ])
         end
 
-        it "returns the context" do
+        it 'returns the context' do
           expect(sorted).to eq(context)
         end
       end
     end
 
-    context "when the field is nil" do
-
+    context 'when the field is nil' do
       let!(:sorted) do
         context.sort(state: 1)
       end
 
-      it "does not sort the documents" do
+      it 'does not sort the documents' do
         expect(context.entries).to eq([ hobrecht, friedel, pfluger ])
       end
 
-      it "returns the context" do
+      it 'returns the context' do
         expect(sorted).to eq(context)
       end
     end
 
-    context "with localized field" do
-
+    context 'with localized field' do
       let!(:sorted) do
-        context.sort("name.en" => 1)
+        context.sort('name.en' => 1)
       end
 
-      it "sorts the documents" do
+      it 'sorts the documents' do
         expect(context.entries).to eq([ friedel, hobrecht, pfluger ])
       end
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
         Address.all.tap do |crit|
           crit.documents = [ hobrecht, friedel, pfluger ]
         end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.sort(state: 1)
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#update" do
-
+  describe '#update' do
     let(:person) do
       Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create!(street: "hobrecht")
+      person.addresses.create!(street: 'hobrecht')
     end
 
     let(:friedel) do
-      person.addresses.create!(street: "friedel")
+      person.addresses.create!(street: 'friedel')
     end
 
     let(:pfluger) do
-      person.addresses.create!(street: "pfluger")
+      person.addresses.create!(street: 'pfluger')
     end
 
-    context "when the documents are embedded one level" do
-
+    context 'when the documents are embedded one level' do
       let(:criteria) do
-        Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.any_in(street: %w[hobrecht friedel]).tap do |crit|
           crit.documents = [ hobrecht, friedel, pfluger ]
         end
       end
@@ -2631,60 +2504,56 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      context "when attributes are provided" do
-
+      context 'when attributes are provided' do
         before do
           context.update(number: 5)
         end
 
-        it "updates the first matching document" do
+        it 'updates the first matching document' do
           expect(hobrecht.number).to eq(5)
         end
 
-        it "does not update the last matching document" do
+        it 'does not update the last matching document' do
           expect(friedel.number).to be_nil
         end
 
-        it "does not update non matching docs" do
+        it 'does not update non matching docs' do
           expect(pfluger.number).to be_nil
         end
 
-        context "when reloading the embedded documents" do
-
-          it "updates the first matching document" do
+        context 'when reloading the embedded documents' do
+          it 'updates the first matching document' do
             expect(hobrecht.reload.number).to eq(5)
           end
 
-          it "updates the last matching document" do
+          it 'updates the last matching document' do
             expect(friedel.reload.number).to be_nil
           end
 
-          it "does not update non matching docs" do
+          it 'does not update non matching docs' do
             expect(pfluger.reload.number).to be_nil
           end
         end
       end
 
-      context "when no attributes are provided" do
-
-        it "returns false" do
+      context 'when no attributes are provided' do
+        it 'returns false' do
           expect(context.update).to be false
         end
       end
     end
 
-    context "when the documents are embedded multiple levels" do
-
+    context 'when the documents are embedded multiple levels' do
       let!(:home) do
-        hobrecht.locations.create!(name: "home")
+        hobrecht.locations.create!(name: 'home')
       end
 
       let!(:work) do
-        hobrecht.locations.create!(name: "work")
+        hobrecht.locations.create!(name: 'work')
       end
 
       let(:criteria) do
-        Location.where(name: "work").tap do |crit|
+        Location.where(name: 'work').tap do |crit|
           crit.documents = [ home, work ]
         end
       end
@@ -2693,87 +2562,80 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      context "when attributes are provided" do
-
+      context 'when attributes are provided' do
         before do
           context.update(number: 5)
         end
 
-        it "updates the first matching document" do
+        it 'updates the first matching document' do
           expect(work.number).to eq(5)
         end
 
-        it "does not update non matching docs" do
+        it 'does not update non matching docs' do
           expect(home.number).to be_nil
         end
 
-        context "when reloading the embedded documents" do
-
-          it "updates the first matching document" do
+        context 'when reloading the embedded documents' do
+          it 'updates the first matching document' do
             expect(work.reload.number).to eq(5)
           end
 
-          it "does not update non matching docs" do
+          it 'does not update non matching docs' do
             expect(home.reload.number).to be_nil
           end
         end
       end
 
-      context "when no attributes are provided" do
-
-        it "returns false" do
+      context 'when no attributes are provided' do
+        it 'returns false' do
           expect(context.update).to be false
         end
       end
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
         Address.all.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.update
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#update_all" do
-
+  describe '#update_all' do
     let(:person) do
       Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create!(street: "hobrecht")
+      person.addresses.create!(street: 'hobrecht')
     end
 
     let(:friedel) do
-      person.addresses.create!(street: "friedel")
+      person.addresses.create!(street: 'friedel')
     end
 
     let(:pfluger) do
-      person.addresses.create!(street: "pfluger")
+      person.addresses.create!(street: 'pfluger')
     end
 
     context 'when there is a collation on the criteria' do
-
       let(:criteria) do
         Address.all.collation(locale: 'en_US', strength: 2)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           context.update_all({})
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
 
-    context "when the documents are empty" do
-
+    context 'when the documents are empty' do
       let(:person_two) do
         Person.create!
       end
@@ -2786,15 +2648,14 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(context.update_all({})).to be false
       end
     end
 
-    context "when the documents are embedded one level" do
-
+    context 'when the documents are embedded one level' do
       let(:criteria) do
-        Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.any_in(street: %w[hobrecht friedel]).tap do |crit|
           crit.documents = [ hobrecht, friedel, pfluger ]
         end
       end
@@ -2803,90 +2664,84 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      context "when providing aliased fields" do
-
+      context 'when providing aliased fields' do
         before do
-          context.update_all(suite: "10B")
+          context.update_all(suite: '10B')
         end
 
-        it "updates the first matching document" do
-          expect(hobrecht.suite).to eq("10B")
+        it 'updates the first matching document' do
+          expect(hobrecht.suite).to eq('10B')
         end
 
-        it "updates the last matching document" do
-          expect(friedel.suite).to eq("10B")
+        it 'updates the last matching document' do
+          expect(friedel.suite).to eq('10B')
         end
 
-        it "does not update non matching docs" do
+        it 'does not update non matching docs' do
           expect(pfluger.suite).to be_nil
         end
       end
 
-      context "when attributes are provided" do
-
+      context 'when attributes are provided' do
         before do
           context.update_all(number: 5)
         end
 
-        it "updates the first matching document" do
+        it 'updates the first matching document' do
           expect(hobrecht.number).to eq(5)
         end
 
-        it "updates the last matching document" do
+        it 'updates the last matching document' do
           expect(friedel.number).to eq(5)
         end
 
-        it "does not update non matching docs" do
+        it 'does not update non matching docs' do
           expect(pfluger.number).to be_nil
         end
 
-        context "when reloading the embedded documents" do
-
-          it "updates the first matching document" do
+        context 'when reloading the embedded documents' do
+          it 'updates the first matching document' do
             expect(hobrecht.reload.number).to eq(5)
           end
 
-          it "updates the last matching document" do
+          it 'updates the last matching document' do
             expect(friedel.reload.number).to eq(5)
           end
 
-          it "does not update non matching docs" do
+          it 'does not update non matching docs' do
             expect(pfluger.reload.number).to be_nil
           end
         end
 
-        context "when updating the documents a second time" do
-
+        context 'when updating the documents a second time' do
           before do
             context.update_all(number: 5)
           end
 
-          it "does not error on the update" do
+          it 'does not error on the update' do
             expect(hobrecht.number).to eq(5)
           end
         end
       end
 
-      context "when no attributes are provided" do
-
-        it "returns false" do
+      context 'when no attributes are provided' do
+        it 'returns false' do
           expect(context.update_all).to be false
         end
       end
     end
 
-    context "when the documents are embedded multiple levels" do
-
+    context 'when the documents are embedded multiple levels' do
       let!(:home) do
-        hobrecht.locations.create!(name: "home")
+        hobrecht.locations.create!(name: 'home')
       end
 
       let!(:work) do
-        hobrecht.locations.create!(name: "work")
+        hobrecht.locations.create!(name: 'work')
       end
 
       let(:criteria) do
-        Location.where(name: "work").tap do |crit|
+        Location.where(name: 'work').tap do |crit|
           crit.documents = [ home, work ]
         end
       end
@@ -2895,35 +2750,32 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      context "when attributes are provided" do
-
+      context 'when attributes are provided' do
         before do
           context.update_all(number: 5)
         end
 
-        it "updates the first matching document" do
+        it 'updates the first matching document' do
           expect(work.number).to eq(5)
         end
 
-        it "does not update non matching docs" do
+        it 'does not update non matching docs' do
           expect(home.number).to be_nil
         end
 
-        context "when reloading the embedded documents" do
-
-          it "updates the first matching document" do
+        context 'when reloading the embedded documents' do
+          it 'updates the first matching document' do
             expect(work.reload.number).to eq(5)
           end
 
-          it "does not update non matching docs" do
+          it 'does not update non matching docs' do
             expect(home.reload.number).to be_nil
           end
         end
       end
 
-      context "when no attributes are provided" do
-
-        it "returns false" do
+      context 'when no attributes are provided' do
+        it 'returns false' do
           expect(context.update_all).to be false
         end
       end