mongoid 9.0.11 → 9.1.0

data/spec/mongoid/changeable_spec.rb

@@ -1,105 +1,94 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Changeable do
-
-  describe "#attribute_change" do
-
-    context "when the attribute has changed from the persisted value" do
-
-      context "when using the setter" do
-
+  describe '#attribute_change' do
+    context 'when the attribute has changed from the persisted value' do
+      context 'when using the setter' do
         let(:person) do
-          Person.new(title: "Grand Poobah").tap(&:move_changes)
+          Person.new(title: 'Grand Poobah').tap(&:move_changes)
         end
 
         before do
-          person.title = "Captain Obvious"
+          person.title = 'Captain Obvious'
         end
 
-        it "returns an array of the old value and new value" do
-          expect(person.send(:attribute_change, "title")).to eq(
-            [ "Grand Poobah", "Captain Obvious" ]
+        it 'returns an array of the old value and new value' do
+          expect(person.send(:attribute_change, 'title')).to eq(
+            [ 'Grand Poobah', 'Captain Obvious' ]
           )
         end
 
-        it "allows access via (attribute)_change" do
+        it 'allows access via (attribute)_change' do
           expect(person.title_change).to eq(
-            [ "Grand Poobah", "Captain Obvious" ]
+            [ 'Grand Poobah', 'Captain Obvious' ]
           )
         end
 
-        context "when the field is aliased" do
-
+        context 'when the field is aliased' do
           let(:person) do
-            Person.new(test: "Aliased 1").tap(&:move_changes)
+            Person.new(test: 'Aliased 1').tap(&:move_changes)
           end
 
           before do
-            person.test = "Aliased 2"
+            person.test = 'Aliased 2'
           end
 
-          it "returns an array of the old value and new value" do
-            expect(person.send(:attribute_change, "test")).to eq(
-              [ "Aliased 1", "Aliased 2" ]
+          it 'returns an array of the old value and new value' do
+            expect(person.send(:attribute_change, 'test')).to eq(
+              [ 'Aliased 1', 'Aliased 2' ]
             )
           end
 
-          it "allows access via (attribute)_change" do
+          it 'allows access via (attribute)_change' do
             expect(person.test_change).to eq(
-              [ "Aliased 1", "Aliased 2" ]
+              [ 'Aliased 1', 'Aliased 2' ]
             )
           end
         end
       end
 
-      context "when using [] methods" do
-
+      context 'when using [] methods' do
         let(:person) do
-          Person.new(title: "Grand Poobah").tap(&:move_changes)
+          Person.new(title: 'Grand Poobah').tap(&:move_changes)
         end
 
         before do
-          person[:title] = "Captain Obvious"
+          person[:title] = 'Captain Obvious'
         end
 
-        it "returns an array of the old value and new value" do
-          expect(person.send(:attribute_change, "title")).to eq(
-            [ "Grand Poobah", "Captain Obvious" ]
+        it 'returns an array of the old value and new value' do
+          expect(person.send(:attribute_change, 'title')).to eq(
+            [ 'Grand Poobah', 'Captain Obvious' ]
           )
         end
 
-        it "allows access via (attribute)_change" do
+        it 'allows access via (attribute)_change' do
           expect(person.title_change).to eq(
-            [ "Grand Poobah", "Captain Obvious" ]
+            [ 'Grand Poobah', 'Captain Obvious' ]
           )
         end
       end
     end
 
-    context "when the attribute has changed from the default value" do
-
-      context "when using the setter" do
-
+    context 'when the attribute has changed from the default value' do
+      context 'when using the setter' do
         let(:person) do
           Person.new(pets: true)
         end
 
-        it "returns an array of nil and new value" do
-          expect(person.send(:attribute_change, "pets")).to eq([ nil, true ])
+        it 'returns an array of nil and new value' do
+          expect(person.send(:attribute_change, 'pets')).to eq([ nil, true ])
         end
 
-        it "allows access via (attribute)_change" do
+        it 'allows access via (attribute)_change' do
           expect(person.pets_change).to eq([ nil, true ])
         end
       end
 
-      context "when using [] methods" do
-
-        context "when the field is defined" do
-
+      context 'when using [] methods' do
+        context 'when the field is defined' do
           let(:person) do
             Person.new
           end
@@ -108,136 +97,128 @@ describe Mongoid::Changeable do
             person[:pets] = true
           end
 
-          it "returns an array of nil and new value" do
-            expect(person.send(:attribute_change, "pets")).to eq([ nil, true ])
+          it 'returns an array of nil and new value' do
+            expect(person.send(:attribute_change, 'pets')).to eq([ nil, true ])
           end
 
-          it "allows access via (attribute)_change" do
+          it 'allows access via (attribute)_change' do
             expect(person.pets_change).to eq([ nil, true ])
           end
         end
 
-        context "when the field is not defined" do
-
+        context 'when the field is not defined' do
           let(:person) do
             Person.new
           end
 
           before do
-            person[:t] = "test"
+            person[:t] = 'test'
           end
 
-          it "returns an array of nil and new value" do
-            expect(person.send(:attribute_change, "t")).to eq([ nil, "test" ])
+          it 'returns an array of nil and new value' do
+            expect(person.send(:attribute_change, 't')).to eq([ nil, 'test' ])
           end
         end
       end
     end
 
-    context "when the attribute changes multiple times" do
-
+    context 'when the attribute changes multiple times' do
       let(:person) do
-        Person.new(title: "Grand Poobah").tap(&:move_changes)
+        Person.new(title: 'Grand Poobah').tap(&:move_changes)
       end
 
       before do
-        person.title = "Captain Obvious"
-        person.title = "Dark Helmet"
+        person.title = 'Captain Obvious'
+        person.title = 'Dark Helmet'
       end
 
-      it "returns an array of the original value and new value" do
-        expect(person.send(:attribute_change, "title")).to eq(
-          [ "Grand Poobah", "Dark Helmet" ]
+      it 'returns an array of the original value and new value' do
+        expect(person.send(:attribute_change, 'title')).to eq(
+          [ 'Grand Poobah', 'Dark Helmet' ]
         )
       end
 
-      it "allows access via (attribute)_change" do
+      it 'allows access via (attribute)_change' do
         expect(person.title_change).to eq(
-          [ "Grand Poobah", "Dark Helmet" ]
+          [ 'Grand Poobah', 'Dark Helmet' ]
         )
       end
     end
 
-    context "when the attribute is modified in place" do
-
-      context "when the attribute is an array" do
-
+    context 'when the attribute is modified in place' do
+      context 'when the attribute is an array' do
         let(:person) do
-          Person.new(aliases: [ "Grand Poobah" ]).tap(&:move_changes)
+          Person.new(aliases: [ 'Grand Poobah' ]).tap(&:move_changes)
         end
 
         before do
-          person.aliases[0] = "Dark Helmet"
+          person.aliases[0] = 'Dark Helmet'
         end
 
-        it "returns an array of the original value and new value" do
-          expect(person.send(:attribute_change, "aliases")).to eq(
-            [[ "Grand Poobah" ],  [ "Dark Helmet" ]]
+        it 'returns an array of the original value and new value' do
+          expect(person.send(:attribute_change, 'aliases')).to eq(
+            [ [ 'Grand Poobah' ],  [ 'Dark Helmet' ] ]
           )
         end
 
-        it "allows access via (attribute)_change" do
+        it 'allows access via (attribute)_change' do
           expect(person.aliases_change).to eq(
-            [[ "Grand Poobah" ],  [ "Dark Helmet" ]]
+            [ [ 'Grand Poobah' ],  [ 'Dark Helmet' ] ]
           )
         end
 
-        context "when the attribute changes multiple times" do
-
+        context 'when the attribute changes multiple times' do
           before do
-            person.aliases << "Colonel Sanders"
+            person.aliases << 'Colonel Sanders'
           end
 
-          it "returns an array of the original value and new value" do
-            expect(person.send(:attribute_change, "aliases")).to eq(
-              [[ "Grand Poobah" ], [ "Dark Helmet", "Colonel Sanders" ]]
+          it 'returns an array of the original value and new value' do
+            expect(person.send(:attribute_change, 'aliases')).to eq(
+              [ [ 'Grand Poobah' ], [ 'Dark Helmet', 'Colonel Sanders' ] ]
             )
           end
         end
       end
 
-      context "when the attribute is a hash" do
-
+      context 'when the attribute is a hash' do
         let(:person) do
-          Person.new(map: { location: "Home" }).tap(&:move_changes)
+          Person.new(map: { location: 'Home' }).tap(&:move_changes)
         end
 
         before do
-          person.map[:location] = "Work"
+          person.map[:location] = 'Work'
         end
 
-        it "returns an array of the original value and new value" do
-          expect(person.send(:attribute_change, "map")).to eq(
-            [{ "location" => "Home" }, { "location" => "Work" }]
+        it 'returns an array of the original value and new value' do
+          expect(person.send(:attribute_change, 'map')).to eq(
+            [ { 'location' => 'Home' }, { 'location' => 'Work' } ]
           )
         end
 
-        it "allows access via (attribute)_change" do
+        it 'allows access via (attribute)_change' do
           expect(person.map_change).to eq(
-            [{ "location" => "Home" }, { "location" => "Work" }]
+            [ { 'location' => 'Home' }, { 'location' => 'Work' } ]
           )
         end
 
-        context "when the attribute changes multiple times" do
-
+        context 'when the attribute changes multiple times' do
           before do
             person.map[:lat] = 20.0
           end
 
-          it "returns an array of the original value and new value" do
-            expect(person.send(:attribute_change, "map")).to eq(
-              [{ "location" => "Home" }, { "location" => "Work", "lat" => 20.0 }]
+          it 'returns an array of the original value and new value' do
+            expect(person.send(:attribute_change, 'map')).to eq(
+              [ { 'location' => 'Home' }, { 'location' => 'Work', 'lat' => 20.0 } ]
             )
           end
         end
 
-        context "when the values are arrays" do
-
+        context 'when the values are arrays' do
           let(:map) do
             {
-              "stack1" => [ 1, 2, 3, 4 ],
-              "stack2" => [ 1, 2, 3, 4 ],
-              "stack3" => [ 1, 2, 3, 4 ]
+              'stack1' => [ 1, 2, 3, 4 ],
+              'stack2' => [ 1, 2, 3, 4 ],
+              'stack3' => [ 1, 2, 3, 4 ]
             }
           end
 
@@ -246,25 +227,24 @@ describe Mongoid::Changeable do
             person.move_changes
           end
 
-          context "when reordering the arrays inline" do
-
+          context 'when reordering the arrays inline' do
             before do
-              person.map["stack1"].reverse!
+              person.map['stack1'].reverse!
             end
 
-            it "flags the attribute as changed" do
-              expect(person.send(:attribute_change, "map")).to eq(
+            it 'flags the attribute as changed' do
+              expect(person.send(:attribute_change, 'map')).to eq(
                 [
                   {
-                    "stack1" => [ 1, 2, 3, 4 ],
-                    "stack2" => [ 1, 2, 3, 4 ],
-                    "stack3" => [ 1, 2, 3, 4 ]
+                    'stack1' => [ 1, 2, 3, 4 ],
+                    'stack2' => [ 1, 2, 3, 4 ],
+                    'stack3' => [ 1, 2, 3, 4 ]
                   },
                   {
-                    "stack1" => [ 4, 3, 2, 1 ],
-                    "stack2" => [ 1, 2, 3, 4 ],
-                    "stack3" => [ 1, 2, 3, 4 ]
-                  },
+                    'stack1' => [ 4, 3, 2, 1 ],
+                    'stack2' => [ 1, 2, 3, 4 ],
+                    'stack3' => [ 1, 2, 3, 4 ]
+                  }
                 ]
               )
             end
@@ -273,117 +253,107 @@ describe Mongoid::Changeable do
       end
     end
 
-    context "when the attribute has not changed from the persisted value" do
-
+    context 'when the attribute has not changed from the persisted value' do
       let(:person) do
         Person.new(title: nil)
       end
 
-      it "returns nil" do
-        expect(person.send(:attribute_change, "title")).to be_nil
+      it 'returns nil' do
+        expect(person.send(:attribute_change, 'title')).to be_nil
       end
     end
 
-    context "when the attribute has not changed from the default value" do
-
-      context "when the attribute differs from the persisted value" do
-
+    context 'when the attribute has not changed from the default value' do
+      context 'when the attribute differs from the persisted value' do
         let(:person) do
           Person.new
         end
 
-        it "returns the change" do
-          expect(person.send(:attribute_change, "pets")).to eq([ nil, false ])
+        it 'returns the change' do
+          expect(person.send(:attribute_change, 'pets')).to eq([ nil, false ])
         end
       end
 
-      context "when the attribute does not differ from the persisted value" do
-
+      context 'when the attribute does not differ from the persisted value' do
         let(:person) do
-          Person.instantiate("pets" => false)
+          Person.instantiate('pets' => false)
         end
 
-        it "returns nil" do
-          expect(person.send(:attribute_change, "pets")).to be_nil
+        it 'returns nil' do
+          expect(person.send(:attribute_change, 'pets')).to be_nil
         end
       end
     end
 
-    context "when the attribute has been set with the same value" do
-
+    context 'when the attribute has been set with the same value' do
       let(:person) do
-        Person.new(title: "Grand Poobah").tap(&:move_changes)
+        Person.new(title: 'Grand Poobah').tap(&:move_changes)
       end
 
       before do
-        person.title = "Grand Poobah"
+        person.title = 'Grand Poobah'
       end
 
-      it "returns an empty array" do
-        expect(person.send(:attribute_change, "title")).to be_nil
+      it 'returns an empty array' do
+        expect(person.send(:attribute_change, 'title')).to be_nil
       end
     end
 
-    context "when the attribute is removed" do
-
+    context 'when the attribute is removed' do
       let(:person) do
-        Person.new(title: "Grand Poobah").tap(&:move_changes)
+        Person.new(title: 'Grand Poobah').tap(&:move_changes)
       end
 
       before do
         person.remove_attribute(:title)
       end
 
-      it "returns an empty array" do
-        expect(person.send(:attribute_change, "title")).to eq(
-          [ "Grand Poobah", nil ]
+      it 'returns an empty array' do
+        expect(person.send(:attribute_change, 'title')).to eq(
+          [ 'Grand Poobah', nil ]
         )
       end
     end
   end
 
-  describe "#attribute_changed?" do
-
-    context "when the attribute has changed from the persisted value" do
-
+  describe '#attribute_changed?' do
+    context 'when the attribute has changed from the persisted value' do
       let(:person) do
-        Person.new(title: "Grand Poobah")
+        Person.new(title: 'Grand Poobah')
       end
 
       before do
-        person.title = "Captain Obvious"
+        person.title = 'Captain Obvious'
       end
 
-      it "returns true" do
-        expect(person.send(:attribute_changed?, "title")).to be true
+      it 'returns true' do
+        expect(person.send(:attribute_changed?, 'title')).to be true
       end
 
-      it "allows access via (attribute)_changed?" do
+      it 'allows access via (attribute)_changed?' do
         expect(person.title_changed?).to be true
       end
 
-      context "when the field is aliased" do
-
+      context 'when the field is aliased' do
         let(:person) do
-          Person.new(test: "Aliased 1")
+          Person.new(test: 'Aliased 1')
         end
 
         before do
-          person.test = "Aliased 2"
+          person.test = 'Aliased 2'
         end
 
-        it "returns true" do
-          expect(person.send(:attribute_changed?, "test")).to be true
+        it 'returns true' do
+          expect(person.send(:attribute_changed?, 'test')).to be true
         end
 
-        it "allows access via (attribute)_changed?" do
+        it 'allows access via (attribute)_changed?' do
           expect(person.test_changed?).to be true
         end
       end
     end
 
-    context "when the attribute has changed from the default value" do
-
+    context 'when the attribute has changed from the default value' do
       let(:person) do
         Person.new
       end
@@ -392,355 +362,341 @@ describe Mongoid::Changeable do
         person.pets = true
       end
 
-      it "returns true" do
-        expect(person.send(:attribute_changed?, "pets")).to be true
+      it 'returns true' do
+        expect(person.send(:attribute_changed?, 'pets')).to be true
       end
 
-      it "allows access via (attribute)_changed?" do
+      it 'allows access via (attribute)_changed?' do
         expect(person.pets_changed?).to be true
       end
     end
 
-    context "when the attribute has not changed the persisted value" do
-
+    context 'when the attribute has not changed the persisted value' do
       let!(:person) do
-        Person.new(title: "Grand Poobah").tap(&:move_changes)
+        Person.new(title: 'Grand Poobah').tap(&:move_changes)
       end
 
-      it "returns false" do
-        expect(person.send(:attribute_changed?, "title")).to be false
+      it 'returns false' do
+        expect(person.send(:attribute_changed?, 'title')).to be false
       end
     end
 
-    context "when the attribute has not changed from the default value" do
-
-      context "when the attribute is not enumerable" do
-
-        context "when the attribute differs from the persisted value" do
-
+    context 'when the attribute has not changed from the default value' do
+      context 'when the attribute is not enumerable' do
+        context 'when the attribute differs from the persisted value' do
           let!(:person) do
             Person.new
           end
 
-          it "returns true" do
-            expect(person.send(:attribute_changed?, "pets")).to be true
+          it 'returns true' do
+            expect(person.send(:attribute_changed?, 'pets')).to be true
           end
         end
 
-        context "when the attribute does not differ from the persisted value" do
-
+        context 'when the attribute does not differ from the persisted value' do
           let!(:person) do
-            Person.instantiate("pets" => false)
+            Person.instantiate('pets' => false)
           end
 
-          it "returns false" do
-            expect(person.send(:attribute_changed?, "pets")).to be false
+          it 'returns false' do
+            expect(person.send(:attribute_changed?, 'pets')).to be false
           end
         end
       end
 
-      context "when the attribute is an array" do
-
+      context 'when the attribute is an array' do
         let!(:person) do
-          Person.new(aliases: [ "Bond" ])
+          Person.new(aliases: [ 'Bond' ])
         end
 
-        context "when the array is only accessed" do
-
+        context 'when the array is only accessed' do
           before do
             person.move_changes
             person.aliases
           end
 
-          it "returns false" do
-            expect(person).to_not be_aliases_changed
+          it 'returns false' do
+            expect(person).not_to be_aliases_changed
           end
         end
       end
 
-      context "when the attribute is a hash" do
-
+      context 'when the attribute is a hash' do
         let!(:person) do
-          Person.new(map: { key: "value" })
+          Person.new(map: { key: 'value' })
         end
 
-        context "when the hash is only accessed" do
-
+        context 'when the hash is only accessed' do
           before do
             person.move_changes
             person.map
           end
 
-          it "returns false" do
-            expect(person).to_not be_map_changed
+          it 'returns false' do
+            expect(person).not_to be_map_changed
           end
         end
       end
     end
 
-    context "when including key word args" do
-
+    context 'when including key word args' do
       let(:person) { Person.new }
 
-      context "when only including from" do
-
-        context "when the object has not changed" do
-
-          it "returns false" do
+      context 'when only including from' do
+        context 'when the object has not changed' do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, from: nil)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(from: nil)).to be false
           end
         end
 
-        context "when the object has changed from the wrong item" do
-
+        context 'when the object has changed from the wrong item' do
           before do
             person.score = 2
           end
 
-          it "returns false" do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, from: 1)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(from: 1)).to be false
           end
         end
 
-        context "when the object has changed from the correct item" do
-
+        context 'when the object has changed from the correct item' do
           before do
             person.score = 2
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(person.send(:attribute_changed?, :score, from: nil)).to be true
           end
 
-          it "returns true using (attribute)_changed?" do
+          it 'returns true using (attribute)_changed?' do
             expect(person.score_changed?(from: nil)).to be true
           end
         end
       end
 
-      context "when only including to" do
-
-        context "when the object has not changed" do
-
-          it "returns false" do
+      context 'when only including to' do
+        context 'when the object has not changed' do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, to: nil)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(to: nil)).to be false
           end
         end
 
-        context "when the object has changed to the wrong item" do
-
+        context 'when the object has changed to the wrong item' do
           before do
             person.score = 2
           end
 
-          it "returns false" do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, to: 1)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(to: 1)).to be false
           end
         end
 
-        context "when the object has changed to the correct item" do
-
+        context 'when the object has changed to the correct item' do
           before do
             person.score = 2
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(person.send(:attribute_changed?, :score, to: 2)).to be true
           end
 
-          it "returns true using (attribute)_changed?" do
+          it 'returns true using (attribute)_changed?' do
             expect(person.score_changed?(to: 2)).to be true
           end
         end
       end
 
-      context "when including from and to" do
-
-        context "when the object has not changed" do
-
-          it "returns false" do
+      context 'when including from and to' do
+        context 'when the object has not changed' do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, from: nil, to: nil)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(from: nil, to: nil)).to be false
           end
         end
 
-        context "when only the from is correct" do
-
+        context 'when only the from is correct' do
           before do
             person.score = 2
           end
 
-          it "returns false" do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, from: nil, to: 3)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(from: nil, to: 3)).to be false
           end
         end
 
-        context "when only the to is correct" do
-
+        context 'when only the to is correct' do
           before do
             person.score = 2
           end
 
-          it "returns false" do
+          it 'returns false' do
             expect(person.send(:attribute_changed?, :score, from: 1, to: 2)).to be false
           end
 
-          it "returns false using (attribute)_changed?" do
+          it 'returns false using (attribute)_changed?' do
             expect(person.score_changed?(from: 1, to: 2)).to be false
           end
         end
 
-        context "when the from and to are correct" do
-
+        context 'when the from and to are correct' do
           before do
             person.score = 2
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(person.send(:attribute_changed?, :score, from: nil, to: 2)).to be true
           end
 
-          it "returns true using (attribute)_changed?" do
+          it 'returns true using (attribute)_changed?' do
             expect(person.score_changed?(from: nil, to: 2)).to be true
           end
         end
 
-        context "when value is mongoized" do
-
+        context 'when value is mongoized' do
           before do
-            person.score = "2"
+            person.score = '2'
           end
 
-          it "returns true with mongoized value" do
+          it 'returns true with mongoized value' do
             expect(person.send(:attribute_changed?, :score, from: nil, to: 2)).to be true
           end
 
-          it "returns true with mongoized value using (attribute)_changed?" do
+          it 'returns true with mongoized value using (attribute)_changed?' do
             expect(person.score_changed?(from: nil, to: 2)).to be true
           end
         end
 
-        context "when value is mongoized" do
-
+        context 'when value is mongoized' do
           before do
-            person.score = "2"
+            person.score = '2'
           end
 
-          it "returns false with unmongoized value" do
-            expect(person.send(:attribute_changed?, :score, from: nil, to: "2")).to be false
+          it 'returns false with unmongoized value' do
+            expect(person.send(:attribute_changed?, :score, from: nil, to: '2')).to be false
           end
 
-          it "returns false with unmongoized value using (attribute)_changed?" do
-            expect(person.score_changed?(from: nil, to: "2")).to be false
+          it 'returns false with unmongoized value using (attribute)_changed?' do
+            expect(person.score_changed?(from: nil, to: '2')).to be false
           end
         end
       end
     end
   end
 
-  describe "#attribute_changed_from_default?" do
-
-    context "when the attribute differs from the default value" do
-
+  describe '#attribute_changed_from_default?' do
+    context 'when the attribute differs from the default value' do
       let(:person) do
         Person.new(age: 33)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person).to be_age_changed_from_default
       end
     end
 
-    context "when the attribute is the same as the default" do
-
+    context 'when the attribute is the same as the default' do
       let(:person) do
         Person.new
       end
 
-      it "returns false" do
-        expect(person).to_not be_age_changed_from_default
+      it 'returns false' do
+        expect(person).not_to be_age_changed_from_default
       end
     end
   end
 
-  describe "#attribute_was" do
-
-    context "when the attribute has changed from the persisted value" do
-
+  describe '#attribute_was' do
+    context 'when the attribute has changed from the persisted value' do
       let(:person) do
-        Person.new(title: "Grand Poobah").tap(&:move_changes)
+        Person.new(title: 'Grand Poobah').tap(&:move_changes)
       end
 
       before do
-        person.title = "Captain Obvious"
+        person.title = 'Captain Obvious'
       end
 
-      it "returns the old value" do
-        expect(person.send(:attribute_was, "title")).to eq("Grand Poobah")
+      it 'returns the old value' do
+        expect(person.send(:attribute_was, 'title')).to eq('Grand Poobah')
       end
 
-      it "allows access via (attribute)_was" do
-        expect(person.title_was).to eq("Grand Poobah")
+      it 'allows access via (attribute)_was' do
+        expect(person.title_was).to eq('Grand Poobah')
       end
 
-      context "when the field is aliased" do
-
+      context 'when the field is aliased' do
         let(:person) do
-          Person.new(test: "Aliased 1").tap(&:move_changes)
+          Person.new(test: 'Aliased 1').tap(&:move_changes)
         end
 
         before do
-          person.test = "Aliased 2"
+          person.test = 'Aliased 2'
         end
 
-        it "returns the old value" do
-          expect(person.send(:attribute_was, "test")).to eq("Aliased 1")
+        it 'returns the old value' do
+          expect(person.send(:attribute_was, 'test')).to eq('Aliased 1')
         end
 
-        it "allows access via (attribute)_was" do
-          expect(person.test_was).to eq("Aliased 1")
+        it 'allows access via (attribute)_was' do
+          expect(person.test_was).to eq('Aliased 1')
         end
       end
     end
 
-    context "when the attribute has not changed from the persisted value" do
-
+    context 'when the attribute has not changed from the persisted value' do
       let!(:person) do
-        Person.new(title: "Grand Poobah").tap(&:move_changes)
+        Person.new(title: 'Grand Poobah').tap(&:move_changes)
       end
 
-      it "returns the original value" do
-        expect(person.send(:attribute_was, "title")).to eq("Grand Poobah")
+      it 'returns the original value' do
+        expect(person.send(:attribute_was, 'title')).to eq('Grand Poobah')
+      end
+    end
+
+    context 'when the attribute is a Hash field stored as a BSON::Document' do
+      let(:person) do
+        Person.new(map: BSON::Document.new('foo' => true)).tap(&:move_changes)
+      end
+
+      before do
+        person.map['bar'] = true
+      end
+
+      it 'returns a BSON::Document, consistent with the field getter' do
+        expect(person.map_was).to be_a(BSON::Document)
+      end
+
+      it 'returns the correct previous value' do
+        expect(person.map_was).to eq('foo' => true)
       end
     end
   end
 
   describe '#attribute_previously_was' do
     let(:previous_title) do
-      "Grand Poobah"
+      'Grand Poobah'
     end
 
     let(:age) do
@@ -752,7 +708,7 @@ describe Mongoid::Changeable do
     end
 
     let(:updated_title) do
-      "Captain Obvious"
+      'Captain Obvious'
     end
 
     before do
@@ -761,21 +717,21 @@ describe Mongoid::Changeable do
     end
 
     context 'when attribute changed' do
-      it "returns the old value" do
-        expect(person.send(:attribute_previously_was, "title")).to eq(previous_title)
+      it 'returns the old value' do
+        expect(person.send(:attribute_previously_was, 'title')).to eq(previous_title)
       end
 
-      it "allows access via (attribute)_was" do
+      it 'allows access via (attribute)_was' do
         expect(person.title_previously_was).to eq(previous_title)
       end
     end
 
     context 'when attribute did not change' do
-      it "returns the same value" do
-        expect(person.send(:attribute_previously_was, "age")).to eq(age)
+      it 'returns the same value' do
+        expect(person.send(:attribute_previously_was, 'age')).to eq(age)
       end
 
-      it "allows access via (attribute)_was" do
+      it 'allows access via (attribute)_was' do
         expect(person.age_previously_was).to eq(age)
       end
     end
@@ -785,25 +741,22 @@ describe Mongoid::Changeable do
       expect(person.title_previously_was).to be_nil
       expect(person.age_previously_was).to be_nil
     end
-
   end
 
-  describe "#attribute_will_change!" do
-
+  describe '#attribute_will_change!' do
     let(:aliases) do
-      [ "007" ]
+      [ '007' ]
     end
 
     let(:person) do
-      Person.new(aliases: aliases, test: "Aliased 1")
+      Person.new(aliases: aliases, test: 'Aliased 1')
     end
 
     before do
       person.changed_attributes.clear
     end
 
-    context "when the value has not changed" do
-
+    context 'when the value has not changed' do
       before do
         person.aliases_will_change!
       end
@@ -812,35 +765,32 @@ describe Mongoid::Changeable do
         person.changes
       end
 
-      it "does not return the value in the changes" do
+      it 'does not return the value in the changes' do
         expect(changes).to be_empty
       end
 
-      it "is not flagged as changed" do
-        expect(person).to_not be_changed
+      it 'is not flagged as changed' do
+        expect(person).not_to be_changed
       end
     end
 
-    context "when the value has changed" do
-
+    context 'when the value has changed' do
       before do
         person.aliases_will_change!
-        person.aliases << "008"
+        person.aliases << '008'
       end
 
       let(:changes) do
         person.changes
       end
 
-      it "returns the value in the changes" do
-        expect(changes).to eq({ "aliases" => [[ "007" ], [ "007", "008" ]] })
+      it 'returns the value in the changes' do
+        expect(changes).to eq({ 'aliases' => [ [ '007' ], %w[007 008] ] })
       end
     end
 
-    context "when the value is duplicable" do
-
-      context "when the attribute has not been cloned" do
-
+    context 'when the value is duplicable' do
+      context 'when the attribute has not been cloned' do
         before do
           person.aliases_will_change!
         end
@@ -849,20 +799,19 @@ describe Mongoid::Changeable do
           person.changed_attributes
         end
 
-        it "clones the value" do
-          expect(changed["aliases"]).to_not equal(aliases)
+        it 'clones the value' do
+          expect(changed['aliases']).not_to equal(aliases)
         end
 
-        it "puts the old value in the changes" do
-          expect(changed["aliases"]).to eq(aliases)
+        it 'puts the old value in the changes' do
+          expect(changed['aliases']).to eq(aliases)
         end
       end
 
-      context "when the attribute has been flagged" do
-
+      context 'when the attribute has been flagged' do
         before do
-          person.changed_attributes["aliases"] = aliases
-          expect(aliases).to receive(:clone).never
+          person.changed_attributes['aliases'] = aliases
+          expect(aliases).not_to receive(:clone)
           person.aliases_will_change!
         end
 
@@ -870,321 +819,295 @@ describe Mongoid::Changeable do
           person.changed_attributes
         end
 
-        it "does not clone the value" do
-          expect(changed["aliases"]).to equal(aliases)
+        it 'does not clone the value' do
+          expect(changed['aliases']).to equal(aliases)
         end
 
-        it "retains the first value in the changes" do
-          expect(changed["aliases"]).to eq(aliases)
+        it 'retains the first value in the changes' do
+          expect(changed['aliases']).to eq(aliases)
         end
       end
     end
   end
 
-  describe "#changed" do
-
-    context "when the document has changed" do
-
+  describe '#changed' do
+    context 'when the document has changed' do
       let(:person) do
-        Person.instantiate(title: "Grand Poobah")
+        Person.instantiate(title: 'Grand Poobah')
       end
 
       before do
-        person.title = "Captain Obvious"
+        person.title = 'Captain Obvious'
       end
 
-      it "returns an array of changed field names" do
-        expect(person.changed).to include("title")
+      it 'returns an array of changed field names' do
+        expect(person.changed).to include('title')
       end
-
     end
 
-    context "When the document has changed but changed back to the original" do
-
+    context 'When the document has changed but changed back to the original' do
       let(:person) do
-        Person.instantiate(title: "Grand Poobah")
+        Person.instantiate(title: 'Grand Poobah')
       end
 
       before do
-        person.title = "Captain Obvious"
+        person.title = 'Captain Obvious'
         person.title = nil
       end
 
-      it "returns an array of changed field names" do
-        expect(person.changed).not_to include("title")
+      it 'returns an array of changed field names' do
+        expect(person.changed).not_to include('title')
       end
-
     end
 
-    context "when the document has not changed" do
-
+    context 'when the document has not changed' do
       let(:person) do
         Person.instantiate({})
       end
 
-      it "does not include non changed fields" do
-        expect(person.changed).to_not include("title")
+      it 'does not include non changed fields' do
+        expect(person.changed).not_to include('title')
       end
     end
 
-    context "when the document is embedded" do
-
+    context 'when the document is embedded' do
       let(:person) do
         Person.create!
       end
 
       let!(:name) do
-        person.create_name(first_name: "Layne", last_name: "Staley")
+        person.create_name(first_name: 'Layne', last_name: 'Staley')
       end
 
-      context "when changing attributes via []" do
-
+      context 'when changing attributes via []' do
         before do
-          person.name["a"] = "testing"
+          person.name['a'] = 'testing'
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person.name).to be_changed
         end
       end
     end
   end
 
-  describe "#changed?" do
-
-    context "when the document has changed" do
-
+  describe '#changed?' do
+    context 'when the document has changed' do
       let(:person) do
-        Person.new(title: "Grand Poobah")
+        Person.new(title: 'Grand Poobah')
       end
 
       before do
-        person.title = "Captain Obvious"
+        person.title = 'Captain Obvious'
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person).to be_changed
       end
     end
 
-    context "when a hash field has been accessed" do
-
-      context "when the field has not changed" do
-
+    context 'when a hash field has been accessed' do
+      context 'when the field has not changed' do
         let(:person) do
-          Person.create!(map: { name: "value" })
+          Person.create!(map: { name: 'value' })
         end
 
         before do
           person.map
         end
 
-        it "returns false" do
-          expect(person).to_not be_changed
+        it 'returns false' do
+          expect(person).not_to be_changed
         end
       end
 
-      context "when the field is changed" do
-
+      context 'when the field is changed' do
         let(:person) do
-          Person.create!(map: { name: "value" })
+          Person.create!(map: { name: 'value' })
         end
 
         before do
-          person.map = { name: "another" }
+          person.map = { name: 'another' }
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to be_changed
         end
       end
 
-      context "when a dynamic field is changed in place" do
-
+      context 'when a dynamic field is changed in place' do
         let(:person) do
-          Person.create!(other_name: { full: {first: 'first', last: 'last'} })
+          Person.create!(other_name: { full: { first: 'first', last: 'last' } })
         end
 
         before do
           person.other_name[:full][:first] = 'Name'
         end
 
-        it "returns true" do
-          expect(person.changes).to_not be_empty
+        it 'returns true' do
+          expect(person.changes).not_to be_empty
           expect(person).to be_changed
         end
       end
     end
 
-    context "when the document has not changed" do
-
+    context 'when the document has not changed' do
       let(:acolyte) do
-        Acolyte.instantiate("_id" => BSON::ObjectId.new)
+        Acolyte.instantiate('_id' => BSON::ObjectId.new)
       end
 
-      it "returns false" do
-        expect(acolyte).to_not be_changed
+      it 'returns false' do
+        expect(acolyte).not_to be_changed
       end
     end
 
-    context "when a child has changed" do
-
+    context 'when a child has changed' do
       let(:person) do
         Person.create!
       end
 
       let!(:address) do
-        person.addresses.create!(street: "hobrecht")
+        person.addresses.create!(street: 'hobrecht')
       end
 
       before do
         address.number = 10
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person).to be_changed
       end
     end
 
-    context "when changed? has been called before child elements size change" do
-
+    context 'when changed? has been called before child elements size change' do
       let(:person) do
         Person.create!
       end
 
       let(:address) do
-        person.addresses.create!(street: "hobrecht")
+        person.addresses.create!(street: 'hobrecht')
       end
 
       let!(:location) do
-        address.locations.create!(name: "home")
+        address.locations.create!(name: 'home')
       end
 
       before do
         person.changed?
       end
 
-      context "when adding via new" do
-
+      context 'when adding via new' do
         before do
           address.locations.new
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to be_changed
         end
       end
 
-      context "when adding via build" do
-
+      context 'when adding via build' do
         before do
           address.locations.build
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to be_changed
         end
       end
 
-      context "when adding via create" do
-
+      context 'when adding via create' do
         before do
           address.locations.create!
         end
 
-        it "returns false" do
-          expect(person).to_not be_changed
+        it 'returns false' do
+          expect(person).not_to be_changed
         end
       end
     end
 
-    context "when a deeply embedded child has changed" do
-
+    context 'when a deeply embedded child has changed' do
       let(:person) do
         Person.create!
       end
 
       let(:address) do
-        person.addresses.create!(street: "hobrecht")
+        person.addresses.create!(street: 'hobrecht')
       end
 
       let!(:location) do
-        address.locations.create!(name: "home")
+        address.locations.create!(name: 'home')
       end
 
       before do
-        location.name = "work"
+        location.name = 'work'
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person).to be_changed
       end
     end
 
-    context "when a child is new" do
-
+    context 'when a child is new' do
       let(:person) do
         Person.create!
       end
 
       let!(:address) do
-        person.addresses.build(street: "hobrecht")
+        person.addresses.build(street: 'hobrecht')
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person).to be_changed
       end
     end
 
-    context "when a deeply embedded child is new" do
-
+    context 'when a deeply embedded child is new' do
       let(:person) do
         Person.create!
       end
 
       let(:address) do
-        person.addresses.create!(street: "hobrecht")
+        person.addresses.create!(street: 'hobrecht')
       end
 
       let!(:location) do
-        address.locations.build(name: "home")
+        address.locations.build(name: 'home')
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person).to be_changed
       end
     end
   end
 
-  describe "#changes" do
-
-    context "when the document has changed" do
-
+  describe '#changes' do
+    context 'when the document has changed' do
       let(:person) do
-        Person.instantiate(title: "Grand Poobah")
+        Person.instantiate(title: 'Grand Poobah')
       end
 
       before do
-        person.title = "Captain Obvious"
+        person.title = 'Captain Obvious'
       end
 
-      it "returns a hash of changes" do
-        expect(person.changes["title"]).to eq(
-          [ nil, "Captain Obvious" ]
+      it 'returns a hash of changes' do
+        expect(person.changes['title']).to eq(
+          [ nil, 'Captain Obvious' ]
         )
       end
 
-      it "returns a hash with indifferent access" do
+      it 'returns a hash with indifferent access' do
         expect(person.changes[:title]).to eq(
-          [ nil, "Captain Obvious" ]
+          [ nil, 'Captain Obvious' ]
         )
       end
     end
 
     context 'when habtm association changes' do
-
       let(:person) do
-        Person.create!(title: "Grand Poobah")
+        Person.create!(title: 'Grand Poobah')
       end
 
       let(:user_account) do
@@ -1195,16 +1118,15 @@ describe Mongoid::Changeable do
         person.user_accounts << user_account
       end
 
-      it 'should not add to the changes or changed_attributes hash' do
-        person.changes.should == {}
-        person.changed_attributes.should == {}
+      it 'does not add to the changes or changed_attributes hash' do
+        person.changes.should eq({})
+        person.changed_attributes.should eq({})
       end
     end
 
     context 'when habtm association _ids changes' do
-
       let(:person) do
-        Person.create!(title: "Grand Poobah")
+        Person.create!(title: 'Grand Poobah')
       end
 
       let(:user_account) do
@@ -1215,16 +1137,15 @@ describe Mongoid::Changeable do
         person.user_account_ids << user_account._id
       end
 
-      it 'should add to the changes or changed_attributes hash' do
-        person.changes.should == { "user_account_ids" => [ nil, [ user_account._id ] ] }
-        person.changed_attributes.should == { "user_account_ids" => nil }
+      it 'adds to the changes or changed_attributes hash' do
+        person.changes.should eq({ 'user_account_ids' => [ nil, [ user_account._id ] ] })
+        person.changed_attributes.should eq({ 'user_account_ids' => nil })
       end
     end
 
     context 'when assigning empty list to habtm association' do
-
       let(:person) do
-        Person.create!(title: "Grand Poobah", user_accounts: [user_account])
+        Person.create!(title: 'Grand Poobah', user_accounts: [ user_account ])
       end
 
       let(:user_account) do
@@ -1235,16 +1156,15 @@ describe Mongoid::Changeable do
         person.user_accounts = []
       end
 
-      it 'should not add to the changes or changed_attributes hash' do
-        person.changes.should == {}
-        person.changed_attributes.should == {}
+      it 'does not add to the changes or changed_attributes hash' do
+        person.changes.should eq({})
+        person.changed_attributes.should eq({})
       end
     end
 
     context 'when assigning empty list to habtm association _ids' do
-
       let(:person) do
-        Person.create!(title: "Grand Poobah", user_accounts: [user_account])
+        Person.create!(title: 'Grand Poobah', user_accounts: [ user_account ])
       end
 
       let(:user_account) do
@@ -1255,266 +1175,246 @@ describe Mongoid::Changeable do
         person.user_account_ids = []
       end
 
-      it 'should not add to the changes or changed_attributes hash' do
-        person.changes.should == { "user_account_ids" => [ [ user_account._id ], [] ] }
-        person.changed_attributes.should ==  { "user_account_ids" => [ user_account._id ] }
+      it 'does not add to the changes or changed_attributes hash' do
+        person.changes.should eq({ 'user_account_ids' => [ [ user_account._id ], [] ] })
+        person.changed_attributes.should eq({ 'user_account_ids' => [ user_account._id ] })
       end
     end
 
-    context "when the document has not changed" do
-
+    context 'when the document has not changed' do
       let(:acolyte) do
-        Acolyte.instantiate("_id" => BSON::ObjectId.new)
+        Acolyte.instantiate('_id' => BSON::ObjectId.new)
       end
 
-      it "returns an empty hash" do
+      it 'returns an empty hash' do
         expect(acolyte.changes).to be_empty
       end
     end
   end
 
-  describe "#setters" do
-
-    context "when the document has changed" do
-
+  describe '#setters' do
+    context 'when the document has changed' do
       let(:person) do
-        Person.new(aliases: [ "007" ]).tap do |p|
+        Person.new(aliases: [ '007' ]).tap do |p|
           p.new_record = false
           p.move_changes
         end
       end
 
-      context "when an array field has changed" do
-
-        context "when the array has values removed" do
-
+      context 'when an array field has changed' do
+        context 'when the array has values removed' do
           before do
-            person.aliases.delete_one("007")
+            person.aliases.delete_one('007')
           end
 
           let!(:setters) do
             person.setters
           end
 
-          it "contains array changes in the setters" do
-            expect(setters).to eq({ "aliases" => [] })
+          it 'contains array changes in the setters' do
+            expect(setters).to eq({ 'aliases' => [] })
           end
         end
 
-        context "when the array has values added" do
-
+        context 'when the array has values added' do
           before do
-            person.aliases << "008"
+            person.aliases << '008'
           end
 
           let!(:setters) do
             person.setters
           end
 
-          it "contains array changes in the setters" do
-            expect(setters).to eq({ "aliases" => [ "007", "008" ] })
+          it 'contains array changes in the setters' do
+            expect(setters).to eq({ 'aliases' => %w[007 008] })
           end
         end
 
-        context "when the array has changed completely" do
-
+        context 'when the array has changed completely' do
           before do
-            person.aliases << "008"
-            person.aliases.delete_one("007")
+            person.aliases << '008'
+            person.aliases.delete_one('007')
           end
 
           let!(:setters) do
             person.setters
           end
 
-          it "does not contain array changes in the setters" do
-            expect(setters).to eq({ "aliases" => [ "008" ]})
+          it 'does not contain array changes in the setters' do
+            expect(setters).to eq({ 'aliases' => [ '008' ] })
           end
         end
       end
 
-      context "when the document is a root document" do
-
+      context 'when the document is a root document' do
         let(:person) do
-          Person.instantiate(title: "Grand Poobah")
+          Person.instantiate(title: 'Grand Poobah')
         end
 
         before do
-          person.title = "Captain Obvious"
+          person.title = 'Captain Obvious'
         end
 
-        it "returns a hash of field names and new values" do
-          expect(person.setters["title"]).to eq("Captain Obvious")
+        it 'returns a hash of field names and new values' do
+          expect(person.setters['title']).to eq('Captain Obvious')
         end
       end
 
-      context "when the document is embedded" do
-
-        let(:person) { Person.create(title: "Grand Poobah") }
-        let(:address) { person.addresses.create(street: "Oxford St") }
+      context 'when the document is embedded' do
+        let(:person) { Person.create(title: 'Grand Poobah') }
+        let(:address) { person.addresses.create(street: 'Oxford St') }
 
-        before { address.street = "Bond St" }
+        before { address.street = 'Bond St' }
 
-        it "returns a hash of field names and new values" do
+        it 'returns a hash of field names and new values' do
           expect(address.setters).to eq(
-            { "addresses.0.street" => "Bond St" }
+            { 'addresses.0.street' => 'Bond St' }
           )
         end
 
-        context "when the document is embedded multiple levels" do
-          let(:location) { address.locations.create(name: "Home") }
-          before { location.name = "Work" }
-          
-          it "returns the proper hash with locations" do
+        context 'when the document is embedded multiple levels' do
+          let(:location) { address.locations.create(name: 'Home') }
+
+          before { location.name = 'Work' }
+
+          it 'returns the proper hash with locations' do
             expect(location.setters).to eq(
-              { "addresses.0.locations.0.name" => "Work" }
+              { 'addresses.0.locations.0.name' => 'Work' }
             )
           end
         end
       end
     end
 
-    context "when the document has not changed" do
-
+    context 'when the document has not changed' do
       let(:acolyte) do
-        Acolyte.instantiate("_id" => BSON::ObjectId.new)
+        Acolyte.instantiate('_id' => BSON::ObjectId.new)
       end
 
-      it "returns an empty hash" do
+      it 'returns an empty hash' do
         expect(acolyte.setters).to be_empty
       end
     end
   end
 
-  describe "#previous_changes" do
-
+  describe '#previous_changes' do
     let(:person) do
-      Person.new(title: "Grand Poobah")
+      Person.new(title: 'Grand Poobah')
     end
 
     before do
-      person.title = "Captain Obvious"
+      person.title = 'Captain Obvious'
     end
 
-    context "when the document has been saved" do
-
+    context 'when the document has been saved' do
       before do
         person.save!
       end
 
-      it "returns the changes before the save" do
-        expect(person.previous_changes["title"]).to eq(
-          [ nil, "Captain Obvious" ]
+      it 'returns the changes before the save' do
+        expect(person.previous_changes['title']).to eq(
+          [ nil, 'Captain Obvious' ]
         )
       end
     end
 
-    context "when the document has not been saved" do
-
-      it "returns an empty hash" do
+    context 'when the document has not been saved' do
+      it 'returns an empty hash' do
         expect(person.previous_changes).to be_empty
       end
     end
   end
 
-  describe "#move_changes" do
-
+  describe '#move_changes' do
     let(:person) do
-      Person.new(title: "Sir")
+      Person.new(title: 'Sir')
     end
 
     before do
-      person.atomic_pulls["addresses"] = Address.new
+      person.atomic_pulls['addresses'] = Address.new
       person.atomic_unsets << Address.new
-      person.delayed_atomic_sets["addresses"] = Address.new
+      person.delayed_atomic_sets['addresses'] = Address.new
       person.move_changes
     end
 
-    it "clears the atomic pulls" do
+    it 'clears the atomic pulls' do
       expect(person.atomic_pulls).to be_empty
     end
 
-    it "clears the atomic unsets" do
+    it 'clears the atomic unsets' do
       expect(person.atomic_unsets).to be_empty
     end
 
-    it "clears the delayed atomic sets" do
+    it 'clears the delayed atomic sets' do
       expect(person.delayed_atomic_sets).to be_empty
     end
 
-    it "clears the changed attributes" do
+    it 'clears the changed attributes' do
       expect(person.changed_attributes).to be_empty
     end
   end
 
-  describe "#reset_attribute!" do
-
-    context "when the attribute has changed" do
-
+  describe '#reset_attribute!' do
+    context 'when the attribute has changed' do
       let(:person) do
-        Person.instantiate(title: "Grand Poobah")
+        Person.instantiate(title: 'Grand Poobah')
       end
 
       before do
-        person.title = "Captain Obvious"
-        person.send(:reset_attribute!, "title")
+        person.title = 'Captain Obvious'
+        person.send(:reset_attribute!, 'title')
       end
 
-      it "resets the value to the original" do
+      it 'resets the value to the original' do
         expect(person.title).to be_nil
       end
 
-      it "allows access via reset_(attribute)!" do
+      it 'allows access via reset_(attribute)!' do
         expect(person.title).to be_nil
       end
 
-      it "removes the field from the changes" do
-        expect(person.changed).to_not include("title")
+      it 'removes the field from the changes' do
+        expect(person.changed).not_to include('title')
       end
 
-      context "when the field is aliased" do
-
+      context 'when the field is aliased' do
         let(:person) do
-          Person.instantiate(test: "Aliased 1")
+          Person.instantiate(test: 'Aliased 1')
         end
 
         before do
-          person.test = "Aliased 2"
-          person.send(:reset_attribute!, "test")
+          person.test = 'Aliased 2'
+          person.send(:reset_attribute!, 'test')
         end
 
-        it "resets the value to the original" do
+        it 'resets the value to the original' do
           expect(person.test).to be_nil
         end
 
-        it "removes the field from the changes" do
-          expect(person.changed).to_not include("test")
+        it 'removes the field from the changes' do
+          expect(person.changed).not_to include('test')
         end
       end
     end
 
-    context "when the attribute has not changed" do
-
+    context 'when the attribute has not changed' do
       let(:person) do
-        Person.instantiate(title: "Grand Poobah")
+        Person.instantiate(title: 'Grand Poobah')
       end
 
       before do
-        person.send(:reset_attribute!, "title")
+        person.send(:reset_attribute!, 'title')
       end
 
-      it "does nothing" do
+      it 'does nothing' do
         expect(person.title).to be_nil
       end
     end
   end
 
-  describe "#reset_attribute_to_default!" do
-
-    context "when a default is defined" do
-
-      context "when the document is new" do
-
+  describe '#reset_attribute_to_default!' do
+    context 'when a default is defined' do
+      context 'when the document is new' do
         let(:person) do
           Person.new(pets: true)
         end
@@ -1523,13 +1423,12 @@ describe Mongoid::Changeable do
           person.reset_pets_to_default!
         end
 
-        it "resets to the default value" do
+        it 'resets to the default value' do
           expect(person.pets).to eq(false)
         end
       end
 
-      context "when the document is persisted" do
-
+      context 'when the document is persisted' do
         let(:person) do
           Person.create!(pets: true)
         end
@@ -1538,48 +1437,45 @@ describe Mongoid::Changeable do
           person.reset_pets_to_default!
         end
 
-        it "resets to the default value" do
+        it 'resets to the default value' do
           expect(person.pets).to eq(false)
         end
 
-        it "flags the document dirty" do
+        it 'flags the document dirty' do
           expect(person).to be_pets_changed
         end
       end
     end
 
-    context "when a default is not defined" do
-
-      context "when the document is new" do
-
+    context 'when a default is not defined' do
+      context 'when the document is new' do
         let(:person) do
-          Person.new(title: "test")
+          Person.new(title: 'test')
         end
 
         before do
           person.reset_title_to_default!
         end
 
-        it "resets to nil" do
+        it 'resets to nil' do
           expect(person.title).to be_nil
         end
       end
 
-      context "when the document is persisted" do
-
+      context 'when the document is persisted' do
         let(:person) do
-          Person.create!(title: "test")
+          Person.create!(title: 'test')
         end
 
         before do
           person.reset_title_to_default!
         end
 
-        it "resets to nil" do
+        it 'resets to nil' do
           expect(person.title).to be_nil
         end
 
-        it "flags the document dirty" do
+        it 'flags the document dirty' do
           expect(person).to be_title_changed
         end
       end
@@ -1587,58 +1483,52 @@ describe Mongoid::Changeable do
   end
 
   describe '#previously_changed?' do
-
     let(:person) do
-      Person.new(title: "Grand Poobah")
+      Person.new(title: 'Grand Poobah')
     end
 
     before do
-      person.title = "Captain Obvious"
+      person.title = 'Captain Obvious'
     end
 
-    context "when the document has been saved" do
-
+    context 'when the document has been saved' do
       before do
         person.save!
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person.title_previously_changed?).to be(true)
       end
     end
 
-    context "when the document has not been saved" do
-
-      it "returns false" do
+    context 'when the document has not been saved' do
+      it 'returns false' do
         expect(person.title_previously_changed?).to be(false)
       end
     end
   end
 
   describe '#previous_change' do
-
     let(:person) do
-      Person.new(title: "Grand Poobah")
+      Person.new(title: 'Grand Poobah')
     end
 
     before do
-      person.title = "Captain Obvious"
+      person.title = 'Captain Obvious'
     end
 
-    context "when the document has been saved" do
-
+    context 'when the document has been saved' do
       before do
         person.save!
       end
 
-      it "returns the changes" do
-        expect(person.title_previous_change).to eq([ nil, "Captain Obvious" ])
+      it 'returns the changes' do
+        expect(person.title_previous_change).to eq([ nil, 'Captain Obvious' ])
       end
     end
 
-    context "when the document has not been saved" do
-
-      it "returns no changes" do
+    context 'when the document has not been saved' do
+      it 'returns no changes' do
         expect(person.title_previous_change).to eq(nil)
       end
     end
@@ -1646,26 +1536,26 @@ describe Mongoid::Changeable do
 
   describe '#attribute_before_last_save' do
     let(:person) do
-      Person.create!(title: "Grand Poobah")
+      Person.create!(title: 'Grand Poobah')
     end
 
     before do
-      person.title = "Captain Obvious"
+      person.title = 'Captain Obvious'
     end
 
-    context "when the document has been saved" do
+    context 'when the document has been saved' do
       before do
         person.save!
       end
 
-      it "returns the changes" do
-        expect(person.attribute_before_last_save(:title)).to eq("Grand Poobah")
-        expect(person.title_before_last_save).to eq("Grand Poobah")
+      it 'returns the changes' do
+        expect(person.attribute_before_last_save(:title)).to eq('Grand Poobah')
+        expect(person.title_before_last_save).to eq('Grand Poobah')
       end
     end
 
-    context "when the document has not been saved" do
-      it "returns no changes" do
+    context 'when the document has not been saved' do
+      it 'returns no changes' do
         expect(person.attribute_before_last_save(:title)).to be_nil
         expect(person.title_before_last_save).to be_nil
       end
@@ -1674,63 +1564,60 @@ describe Mongoid::Changeable do
 
   describe '#saved_change_to_attribute' do
     let(:person) do
-      Person.create!(title: "Grand Poobah")
+      Person.create!(title: 'Grand Poobah')
     end
 
     before do
-      person.title = "Captain Obvious"
+      person.title = 'Captain Obvious'
     end
 
-    context "when the document has been saved" do
+    context 'when the document has been saved' do
       before do
         person.save!
       end
 
-      it "returns the changes" do
-        expect(person.saved_change_to_attribute(:title)).to eq(["Grand Poobah", "Captain Obvious"])
-        expect(person.saved_change_to_title).to eq(["Grand Poobah", "Captain Obvious"])
+      it 'returns the changes' do
+        expect(person.saved_change_to_attribute(:title)).to eq([ 'Grand Poobah', 'Captain Obvious' ])
+        expect(person.saved_change_to_title).to eq([ 'Grand Poobah', 'Captain Obvious' ])
       end
     end
 
-    context "when the document has not been saved" do
-      it "returns changes for the previous save" do
-        expect(person.saved_change_to_attribute(:title)).to eq([nil, "Grand Poobah"])
-        expect(person.saved_change_to_title).to eq([nil, "Grand Poobah"])
+    context 'when the document has not been saved' do
+      it 'returns changes for the previous save' do
+        expect(person.saved_change_to_attribute(:title)).to eq([ nil, 'Grand Poobah' ])
+        expect(person.saved_change_to_title).to eq([ nil, 'Grand Poobah' ])
       end
     end
   end
 
   describe '#saved_change_to_attribute?' do
-    context "when the document has been saved" do
+    context 'when the document has been saved' do
       let(:person) do
-        Person.create!(title: "Grand Poobah")
-      end
-
-      before do
-        person.title = "Captain Obvious"
+        Person.create!(title: 'Grand Poobah')
       end
 
       before do
+        person.title = 'Captain Obvious'
         person.save!
       end
 
-      it "detects the changes" do
+      it 'detects the changes' do
         expect(person.saved_change_to_attribute?(:title)).to be_truthy
-        expect(person.saved_change_to_attribute?(:title, from: "Grand Poobah")).to be_truthy
-        expect(person.saved_change_to_attribute?(:title, to: "Captain Obvious")).to be_truthy
-        expect(person.saved_change_to_attribute?(:title, from: "Grand Poobah", to: "Captain Obvious")).to be_truthy
-        expect(person.saved_change_to_title?(from: "Grand Poobah", to: "Captain Obvious")).to be_truthy
+        expect(person.saved_change_to_attribute?(:title, from: 'Grand Poobah')).to be_truthy
+        expect(person.saved_change_to_attribute?(:title, to: 'Captain Obvious')).to be_truthy
+        expect(person.saved_change_to_attribute?(:title, from: 'Grand Poobah', to: 'Captain Obvious')).to be_truthy
+        expect(person.saved_change_to_title?(from: 'Grand Poobah', to: 'Captain Obvious')).to be_truthy
         expect(person.saved_change_to_attribute?(:age)).to be_falsey
         expect(person.saved_change_to_age?).to be_falsey
       end
     end
 
-    context "when the document has not been saved" do
+    context 'when the document has not been saved' do
       let(:person) do
-        Person.new(title: "Grand Poobah")
+        Person.new(title: 'Grand Poobah')
       end
 
-      it "returns changes for the previous save" do
+      it 'returns changes for the previous save' do
         expect(person.saved_change_to_attribute?(:title)).to be_falsey
         expect(person.saved_change_to_title?).to be_falsey
       end
@@ -1739,11 +1626,11 @@ describe Mongoid::Changeable do
 
   describe '#will_save_change_to_attribute?' do
     let(:person) do
-      Person.create!(title: "Grand Poobah")
+      Person.create!(title: 'Grand Poobah')
     end
 
     before do
-      person.title = "Captain Obvious"
+      person.title = 'Captain Obvious'
     end
 
     it 'correctly detects changes' do
@@ -1752,155 +1639,141 @@ describe Mongoid::Changeable do
       expect(person.will_save_change_to_attribute?(:score)).to eq(false)
       expect(person.will_save_change_to_score?).to eq(false)
     end
-
   end
 
-  context "when fields have been defined pre-dirty inclusion" do
-
+  context 'when fields have been defined pre-dirty inclusion' do
     let(:document) do
       Dokument.new
     end
 
-    it "defines a _change method" do
+    it 'defines a _change method' do
       expect(document.updated_at_change).to be_nil
     end
 
-    it "defines a _changed? method" do
+    it 'defines a _changed? method' do
       expect(document.updated_at_changed?).to be false
     end
 
-    it "defines a _changes method" do
+    it 'defines a _changes method' do
       expect(document.updated_at_was).to be_nil
     end
   end
 
-  context "when only embedded documents change" do
-
+  context 'when only embedded documents change' do
     let!(:person) do
       Person.create!
     end
 
-    context "when the child is an embeds one" do
-
-      context "when the child is new" do
-
+    context 'when the child is an embeds one' do
+      context 'when the child is new' do
         let!(:name) do
-          person.build_name(first_name: "Gordon", last_name: "Ramsay")
+          person.build_name(first_name: 'Gordon', last_name: 'Ramsay')
         end
 
-        it "flags the parent as changed" do
+        it 'flags the parent as changed' do
           expect(person).to be_changed
         end
       end
 
-      context "when the child is modified" do
-
+      context 'when the child is modified' do
         let!(:name) do
-          person.create_name(first_name: "Gordon", last_name: "Ramsay")
+          person.create_name(first_name: 'Gordon', last_name: 'Ramsay')
         end
 
         before do
-          name.first_name = "G"
+          name.first_name = 'G'
         end
 
-        it "flags the parent as changed" do
+        it 'flags the parent as changed' do
           expect(person).to be_changed
         end
       end
 
-      context "when the child is not modified" do
-
+      context 'when the child is not modified' do
         let!(:name) do
-          person.create_name(first_name: "Gordon", last_name: "Ramsay")
+          person.create_name(first_name: 'Gordon', last_name: 'Ramsay')
         end
 
-        it "does not flag the parent as changed" do
-          expect(person).to_not be_changed
+        it 'does not flag the parent as changed' do
+          expect(person).not_to be_changed
         end
       end
     end
 
-    context "when the child is an embeds many" do
-
-      context "when a child is new" do
-
+    context 'when the child is an embeds many' do
+      context 'when a child is new' do
         let!(:address) do
-          person.addresses.build(street: "jakobstr.")
+          person.addresses.build(street: 'jakobstr.')
         end
 
-        it "flags the parent as changed" do
+        it 'flags the parent as changed' do
           expect(person).to be_changed
         end
       end
 
-      context "when a child is modified" do
-
+      context 'when a child is modified' do
         let!(:address) do
-          person.addresses.create!(street: "jakobstr.")
+          person.addresses.create!(street: 'jakobstr.')
         end
 
         before do
-          address.city = "Berlin"
+          address.city = 'Berlin'
         end
 
-        it "flags the parent as changed" do
+        it 'flags the parent as changed' do
           expect(person).to be_changed
         end
       end
 
-      context "when no child is modified" do
-
+      context 'when no child is modified' do
         let!(:address) do
-          person.addresses.create!(street: "skalitzerstr.")
+          person.addresses.create!(street: 'skalitzerstr.')
         end
 
-        it "does not flag the parent as changed" do
-          expect(person).to_not be_changed
+        it 'does not flag the parent as changed' do
+          expect(person).not_to be_changed
         end
       end
     end
   end
 
-  context "when changing a hash of hashes" do
-
+  context 'when changing a hash of hashes' do
     let!(:person) do
-      Person.create!(map: { "test" => {}})
+      Person.create!(map: { 'test' => {} })
     end
 
     before do
-      person.map["test"]["value"] = 10
+      person.map['test']['value'] = 10
     end
 
-    it "records the changes" do
+    it 'records the changes' do
       expect(person.changes).to eq(
-        { "map" => [{ "test" => {}}, { "test" => { "value" => 10 }}]}
+        { 'map' => [ { 'test' => {} }, { 'test' => { 'value' => 10 } } ] }
       )
     end
   end
 
-  context "when modifying a many to many key" do
-
+  context 'when modifying a many to many key' do
     let!(:person) do
       Person.create!
     end
 
     let!(:preference) do
-      Preference.create!(name: "dirty")
+      Preference.create!(name: 'dirty')
     end
 
     before do
       person.update_attributes!(preference_ids: [ preference.id ])
     end
 
-    it "records the foreign key dirty changes" do
-      expect(person.previous_changes["preference_ids"]).to eq(
-        [nil, [ preference.id ]]
+    it 'records the foreign key dirty changes' do
+      expect(person.previous_changes['preference_ids']).to eq(
+        [ nil, [ preference.id ] ]
       )
     end
   end
 
-  context "when accessing an array field" do
-
+  context 'when accessing an array field' do
     let!(:person) do
       Person.create!
     end
@@ -1909,24 +1782,22 @@ describe Mongoid::Changeable do
       Person.find(person.id)
     end
 
-    context "when the field is not changed" do
-
+    context 'when the field is not changed' do
       before do
         from_db.preference_ids
       end
 
-      it "flags the change" do
-        expect(from_db.changes["preference_ids"]).to eq([ nil, []])
+      it 'flags the change' do
+        expect(from_db.changes['preference_ids']).to eq([ nil, [] ])
       end
 
-      it "does not include the changes in the setters" do
+      it 'does not include the changes in the setters' do
         expect(from_db.setters).to be_empty
       end
     end
   end
 
-  context "when reloading an unchanged document" do
-
+  context 'when reloading an unchanged document' do
     let!(:person) do
       Person.create!
     end
@@ -1939,95 +1810,90 @@ describe Mongoid::Changeable do
       from_db.reload
     end
 
-    it "clears the changed attributes" do
+    it 'clears the changed attributes' do
       expect(from_db.changed_attributes).to be_empty
     end
   end
 
-  context "when fields are getting changed" do
-
+  context 'when fields are getting changed' do
     let(:person) do
       Person.create!(
-        title: "MC",
+        title: 'MC',
         some_dynamic_field: 'blah'
       )
     end
 
     before do
-      person.title = "DJ"
-      person.write_attribute(:ssn, "222-22-2222")
+      person.title = 'DJ'
+      person.write_attribute(:ssn, '222-22-2222')
       person.some_dynamic_field = 'bloop'
     end
 
-    it "marks the document as changed" do
+    it 'marks the document as changed' do
       expect(person).to be_changed
     end
 
-    it "marks field changes" do
+    it 'marks field changes' do
       expect(person.changes).to eq({
-        "title" => [ "MC", "DJ" ],
-        "ssn" => [ nil, "222-22-2222" ],
-        "some_dynamic_field" => [ "blah", "bloop" ]
-      })
+                                     'title' => %w[MC DJ],
+                                     'ssn' => [ nil, '222-22-2222' ],
+                                     'some_dynamic_field' => %w[blah bloop]
+                                   })
     end
 
-    it "marks changed fields" do
-      expect(person.changed).to eq([ "title", "ssn", "some_dynamic_field" ])
+    it 'marks changed fields' do
+      expect(person.changed).to eq(%w[title ssn some_dynamic_field])
     end
 
-    it "marks the field as changed" do
+    it 'marks the field as changed' do
       expect(person.title_changed?).to be true
     end
 
-    it "stores previous field values" do
-      expect(person.title_was).to eq("MC")
+    it 'stores previous field values' do
+      expect(person.title_was).to eq('MC')
     end
 
-    it "marks field changes" do
-      expect(person.title_change).to eq([ "MC", "DJ" ])
+    it 'marks field changes' do
+      expect(person.title_change).to eq(%w[MC DJ])
     end
 
-    it "allows reset of field changes" do
+    it 'allows reset of field changes' do
       person.reset_title!
-      expect(person.title).to eq("MC")
-      expect(person.changed).to eq([ "ssn", "some_dynamic_field" ])
+      expect(person.title).to eq('MC')
+      expect(person.changed).to eq(%w[ssn some_dynamic_field])
     end
 
-    context "after a save" do
-
+    context 'after a save' do
       before do
         person.save!
       end
 
-      it "clears changes" do
-        expect(person).to_not be_changed
+      it 'clears changes' do
+        expect(person).not_to be_changed
       end
 
-      it "stores previous changes" do
-        expect(person.previous_changes["title"]).to eq([ "MC", "DJ" ])
-        expect(person.previous_changes["ssn"]).to eq([ nil, "222-22-2222" ])
+      it 'stores previous changes' do
+        expect(person.previous_changes['title']).to eq(%w[MC DJ])
+        expect(person.previous_changes['ssn']).to eq([ nil, '222-22-2222' ])
       end
     end
 
-    context "when the previous value is nil" do
-
+    context 'when the previous value is nil' do
       before do
         person.score = 100
         person.reset_score!
       end
 
-      it "removes the attribute from the document" do
+      it 'removes the attribute from the document' do
         expect(person.score).to be_nil
       end
     end
   end
 
-  context "when accessing dirty attributes in callbacks" do
-
-    context "when the document is persisted" do
-
+  context 'when accessing dirty attributes in callbacks' do
+    context 'when the document is persisted' do
       let!(:acolyte) do
-        Acolyte.create!(name: "callback-test")
+        Acolyte.create!(name: 'callback-test')
       end
 
       before do
@@ -2042,23 +1908,22 @@ describe Mongoid::Changeable do
 
       after do
         Acolyte._save_callbacks.select do |callback|
-          [:before, :after].include?(callback.kind)
+          %i[before after].include?(callback.kind)
         end.each do |callback|
           Acolyte._save_callbacks.delete(callback)
         end
       end
 
-      it "does not retain the changes until after all callbacks" do
-        acolyte.update_attribute(:status, "testing")
-        expect(acolyte.changed_in_before_callback).to eq({"status"=>[nil, "testing"]})
-        expect(acolyte.changed_in_after_callback).to eq({  })
+      it 'does not retain the changes until after all callbacks' do
+        acolyte.update_attribute(:status, 'testing')
+        expect(acolyte.changed_in_before_callback).to eq({ 'status' => [ nil, 'testing' ] })
+        expect(acolyte.changed_in_after_callback).to eq({})
       end
     end
 
-    context "when the document is new" do
-
+    context 'when the document is new' do
       let!(:acolyte) do
-        Acolyte.new(name: "callback-test")
+        Acolyte.new(name: 'callback-test')
       end
 
       before do
@@ -2073,22 +1938,21 @@ describe Mongoid::Changeable do
 
       after do
         Acolyte._save_callbacks.select do |callback|
-          [:before, :after].include?(callback.kind)
+          %i[before after].include?(callback.kind)
         end.each do |callback|
           Acolyte._save_callbacks.delete(callback)
         end
       end
 
-      it "does not retain the changes until after all callbacks" do
+      it 'does not retain the changes until after all callbacks' do
         acolyte.save!
-        expect(acolyte.changed_before_in_callback["name"]).to eq([ nil, "callback-test" ])
-        expect(acolyte.changed_after_in_callback["name"]).to be_nil
+        expect(acolyte.changed_before_in_callback['name']).to eq([ nil, 'callback-test' ])
+        expect(acolyte.changed_after_in_callback['name']).to be_nil
       end
     end
   end
 
-  context "when associations are getting changed" do
-
+  context 'when associations are getting changed' do
     let(:person) do
       Person.create!(addresses: [ Address.new ])
     end
@@ -2097,25 +1961,22 @@ describe Mongoid::Changeable do
       person.addresses = [ Address.new ]
     end
 
-    it "does not set the association to nil when hitting the database" do
-      expect(person.setters).to_not eq({ "addresses" => nil })
+    it 'does not set the association to nil when hitting the database' do
+      expect(person.setters).not_to eq({ 'addresses' => nil })
     end
   end
 
   context 'when nesting deeply embedded documents' do
-
     context 'when persisting the root document' do
-
       let!(:person) do
         Person.create!
       end
 
       it 'is not marked as changed' do
-        expect(person).to_not be_changed
+        expect(person).not_to be_changed
       end
 
       context 'when creating a new first level embedded document' do
-
         let!(:address) do
           person.addresses.new(street: 'goltzstr.')
         end
@@ -2129,7 +1990,6 @@ describe Mongoid::Changeable do
         end
 
         context 'when building the lowest level document' do
-
           before do
             person.save!
           end
@@ -2151,7 +2011,6 @@ describe Mongoid::Changeable do
           end
 
           context 'when saving the hierarchy' do
-
             before do
               person.save!
             end
@@ -2169,7 +2028,6 @@ describe Mongoid::Changeable do
             end
 
             context 'when embedding further' do
-
               let!(:deepest) do
                 reloaded.addresses.first.code.build_deepest
               end