mongoid 9.0.12 → 9.1.0

data/spec/mongoid/atomic_spec.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Atomic do
-
-  describe "#add_atomic_pull" do
-
+  describe '#add_atomic_pull' do
     let!(:person) do
       Person.create!
     end
@@ -23,17 +20,16 @@ describe Mongoid::Atomic do
       person.add_atomic_pull(address)
     end
 
-    it "adds the document to the delayed atomic pulls" do
-      expect(person.delayed_atomic_pulls["addresses"]).to eq([ address ])
+    it 'adds the document to the delayed atomic pulls' do
+      expect(person.delayed_atomic_pulls['addresses']).to eq([ address ])
     end
 
-    it "flags the document for destruction" do
+    it 'flags the document for destruction' do
       expect(address).to be_flagged_for_destroy
     end
   end
 
-  describe "#add_atomic_unset" do
-
+  describe '#add_atomic_unset' do
     let!(:person) do
       Person.new
     end
@@ -46,162 +42,148 @@ describe Mongoid::Atomic do
       person.add_atomic_unset(name)
     end
 
-    it "adds the document to the delayed atomic unsets" do
-      expect(person.delayed_atomic_unsets["name"]).to eq([ name ])
+    it 'adds the document to the delayed atomic unsets' do
+      expect(person.delayed_atomic_unsets['name']).to eq([ name ])
     end
 
-    it "flags the document for destruction" do
+    it 'flags the document for destruction' do
       expect(name).to be_flagged_for_destroy
     end
   end
 
-  describe "#atomic_updates" do
-
-    context "when the document is persisted" do
-
+  describe '#atomic_updates' do
+    context 'when the document is persisted' do
       let(:person) do
         Person.create!
       end
 
-      context "when the document is modified" do
-
+      context 'when the document is modified' do
         before do
-          person.title = "Sir"
+          person.title = 'Sir'
         end
 
-        it "returns the atomic updates" do
-          expect(person.atomic_updates).to eq({ "$set" => { "title" => "Sir" }})
+        it 'returns the atomic updates' do
+          expect(person.atomic_updates).to eq({ '$set' => { 'title' => 'Sir' } })
         end
 
-        context "when an embeds many child is added" do
-
+        context 'when an embeds many child is added' do
           let!(:address) do
-            person.addresses.build(street: "Oxford St")
+            person.addresses.build(street: 'Oxford St')
           end
 
-          it "returns a $set and $push with $each for modifications" do
+          it 'returns a $set and $push with $each for modifications' do
             expect(person.atomic_updates).to eq(
               {
-                "$set" => { "title" => "Sir" },
-                "$push" => { "addresses" => { "$each" => [
-                    { "_id" => "oxford-st", "street" => "Oxford St" }
-                  ] } }
+                '$set' => { 'title' => 'Sir' },
+                '$push' => { 'addresses' => { '$each' => [
+                  { '_id' => 'oxford-st', 'street' => 'Oxford St' }
+                ] } }
               }
             )
           end
         end
 
-        context "when an embeds one child is added" do
-
+        context 'when an embeds one child is added' do
           let!(:name) do
-            person.build_name(first_name: "Lionel")
+            person.build_name(first_name: 'Lionel')
           end
 
-          it "returns a $set for modifications" do
+          it 'returns a $set for modifications' do
             expect(person.atomic_updates).to eq(
               {
-                "$set" => {
-                  "title" => "Sir",
-                  "name" => { "_id" => "Lionel-", "first_name" => "Lionel" }
+                '$set' => {
+                  'title' => 'Sir',
+                  'name' => { '_id' => 'Lionel-', 'first_name' => 'Lionel' }
                 }
               }
             )
           end
         end
 
-        context "when an existing embeds many gets modified" do
-
+        context 'when an existing embeds many gets modified' do
           let!(:address) do
-            person.addresses.create!(street: "Oxford St")
+            person.addresses.create!(street: 'Oxford St')
           end
 
           before do
-            address.street = "Bond St"
+            address.street = 'Bond St'
           end
 
-          context "when asking for the updates from the root" do
-
-            it "returns the $set with correct position and modifications" do
+          context 'when asking for the updates from the root' do
+            it 'returns the $set with correct position and modifications' do
               expect(person.atomic_updates).to eq(
-                { "$set" => { "title" => "Sir", "addresses.0.street" => "Bond St" }}
+                { '$set' => { 'title' => 'Sir', 'addresses.0.street' => 'Bond St' } }
               )
             end
           end
 
-          context "when asking for the updates from the child" do
-
-            it "returns the $set with correct position and modifications" do
+          context 'when asking for the updates from the child' do
+            it 'returns the $set with correct position and modifications' do
               expect(address.atomic_updates).to eq(
-                { "$set" => { "addresses.0.street" => "Bond St" }}
+                { '$set' => { 'addresses.0.street' => 'Bond St' } }
               )
             end
           end
 
-          context "when an existing 2nd level embedded child gets modified" do
-
+          context 'when an existing 2nd level embedded child gets modified' do
             let!(:location) do
-              address.locations.create!(name: "Home")
+              address.locations.create!(name: 'Home')
             end
 
             before do
-              location.name = "Work"
+              location.name = 'Work'
             end
 
-            context "when asking for the updates from the root" do
-
-              it "returns the $set with correct positions and modifications" do
+            context 'when asking for the updates from the root' do
+              it 'returns the $set with correct positions and modifications' do
                 expect(person.atomic_updates).to eq(
-                  { "$set" => {
-                    "title" => "Sir",
-                    "addresses.0.street" => "Bond St",
-                    "addresses.0.locations.0.name" => "Work" }
-                  }
+                  { '$set' => {
+                    'title' => 'Sir',
+                    'addresses.0.street' => 'Bond St',
+                    'addresses.0.locations.0.name' => 'Work'
+                  } }
                 )
               end
             end
 
-            context "when asking for the updates from the 1st level child" do
-
-              it "returns the $set with correct positions and modifications" do
+            context 'when asking for the updates from the 1st level child' do
+              it 'returns the $set with correct positions and modifications' do
                 expect(address.atomic_updates).to eq(
-                  { "$set" => {
-                    "addresses.0.street" => "Bond St",
-                    "addresses.0.locations.0.name" => "Work" }
-                  }
+                  { '$set' => {
+                    'addresses.0.street' => 'Bond St',
+                    'addresses.0.locations.0.name' => 'Work'
+                  } }
                 )
               end
             end
 
-            context "when asking for the updates from the 2nd level child" do
-
-              it "returns the $set with correct positions and modifications" do
+            context 'when asking for the updates from the 2nd level child' do
+              it 'returns the $set with correct positions and modifications' do
                 expect(location.atomic_updates).to eq(
-                  { "$set" => {
-                    "addresses.0.locations.0.name" => "Work" }
-                  }
+                  { '$set' => {
+                    'addresses.0.locations.0.name' => 'Work'
+                  } }
                 )
               end
             end
           end
 
-          context "when a 2nd level embedded child gets added" do
-
+          context 'when a 2nd level embedded child gets added' do
             let!(:location) do
-              address.locations.build(name: "Home")
+              address.locations.build(name: 'Home')
             end
 
-            context "when asking for the updates from the root" do
-
-              it "returns the $set with correct positions and modifications" do
+            context 'when asking for the updates from the root' do
+              it 'returns the $set with correct positions and modifications' do
                 expect(person.atomic_updates).to eq(
                   {
-                    "$set" => {
-                      "title" => "Sir",
-                      "addresses.0.street" => "Bond St"
+                    '$set' => {
+                      'title' => 'Sir',
+                      'addresses.0.street' => 'Bond St'
                     },
                     conflicts: {
-                      "$push" => {
-                        "addresses.0.locations" => { '$each' => [{ "_id" => location.id, "name" => "Home" }] }
+                      '$push' => {
+                        'addresses.0.locations' => { '$each' => [ { '_id' => location.id, 'name' => 'Home' } ] }
                       }
                     }
                   }
@@ -209,17 +191,16 @@ describe Mongoid::Atomic do
               end
             end
 
-            context "when asking for the updates from the 1st level child" do
-
-              it "returns the $set with correct positions and modifications" do
+            context 'when asking for the updates from the 1st level child' do
+              it 'returns the $set with correct positions and modifications' do
                 expect(address.atomic_updates).to eq(
                   {
-                    "$set" => {
-                      "addresses.0.street" => "Bond St"
+                    '$set' => {
+                      'addresses.0.street' => 'Bond St'
                     },
                     conflicts: {
-                      "$push" => {
-                        "addresses.0.locations" => { '$each' => [{ "_id" => location.id, "name" => "Home" }] }
+                      '$push' => {
+                        'addresses.0.locations' => { '$each' => [ { '_id' => location.id, 'name' => 'Home' } ] }
                       }
                     }
                   }
@@ -228,8 +209,7 @@ describe Mongoid::Atomic do
             end
           end
 
-          context "when an embedded child gets unset" do
-
+          context 'when an embedded child gets unset' do
             before do
               person.attributes = { addresses: nil }
             end
@@ -238,43 +218,43 @@ describe Mongoid::Atomic do
               person.atomic_updates
             end
 
-            it "returns the $set for the first level and $unset for other." do
+            it 'returns the $set for the first level and $unset for other.' do
               expect(updates).to eq({
-                "$unset" => { "addresses" => true },
-                "$set" => { "title" => "Sir" }
-              })
+                                      '$unset' => { 'addresses' => true },
+                                      '$set' => { 'title' => 'Sir' }
+                                    })
             end
           end
 
-          context "when adding a new second level child" do
-
+          context 'when adding a new second level child' do
             let!(:new_address) do
-              person.addresses.build(street: "Another")
+              person.addresses.build(street: 'Another')
             end
 
             let!(:location) do
-              new_address.locations.build(name: "Home")
+              new_address.locations.build(name: 'Home')
             end
 
-            context "when asking for the updates from the root document" do
-
-              it "returns the $set for 1st level and other for the 2nd level" do
+            context 'when asking for the updates from the root document' do
+              it 'returns the $set for 1st level and other for the 2nd level' do
                 expect(person.atomic_updates).to eq(
                   {
-                    "$set" => {
-                      "title" => "Sir",
-                      "addresses.0.street" => "Bond St"
+                    '$set' => {
+                      'title' => 'Sir',
+                      'addresses.0.street' => 'Bond St'
                     },
                     conflicts: {
-                      "$push" => {
-                        "addresses" => { '$each' => [{
-                          "_id" => new_address.id,
-                          "street" => "Another",
-                          "locations" => [
-                            "_id" => location.id,
-                            "name" => "Home"
+                      '$push' => {
+                        'addresses' => { '$each' => [ {
+                          '_id' => new_address.id,
+                          'street' => 'Another',
+                          'locations' => [
+                            {
+                              '_id' => location.id,
+                              'name' => 'Home'
+                            }
                           ]
-                        }]}
+                        } ] }
                       }
                     }
                   }
@@ -282,24 +262,22 @@ describe Mongoid::Atomic do
               end
             end
 
-            context "when asking for the updates from the 1st level document" do
-
-              it "returns the $set for 1st level and other for the 2nd level" do
+            context 'when asking for the updates from the 1st level document' do
+              it 'returns the $set for 1st level and other for the 2nd level' do
                 expect(address.atomic_updates).to eq(
-                  { "$set" => { "addresses.0.street" => "Bond St" }}
+                  { '$set' => { 'addresses.0.street' => 'Bond St' } }
                 )
               end
             end
           end
 
-          context "when adding a new child beetween two existing and updating one of them" do
-
+          context 'when adding a new child between two existing and updating one of them' do
             let!(:new_address) do
-              person.addresses.build(street: "Ipanema")
+              person.addresses.build(street: 'Ipanema')
             end
 
             let!(:location) do
-              new_address.locations.build(name: "Home")
+              new_address.locations.build(name: 'Home')
             end
 
             before do
@@ -307,24 +285,26 @@ describe Mongoid::Atomic do
               person.addresses[1] = address
             end
 
-            it "returns the $set for 1st and 2nd level and other for the 3nd level" do
+            it 'returns the $set for 1st and 2nd level and other for the 3nd level' do
               expect(person.atomic_updates).to eq(
                 {
-                  "$set" => {
-                    "title" => "Sir"
+                  '$set' => {
+                    'title' => 'Sir'
                   },
-                  "$push" => {
-                    "addresses" => { '$each' => [{
-                      "_id" => new_address.id,
-                      "street" => "Ipanema",
-                      "locations" => [
-                        "_id" => location.id,
-                        "name" => "Home"
+                  '$push' => {
+                    'addresses' => { '$each' => [ {
+                      '_id' => new_address.id,
+                      'street' => 'Ipanema',
+                      'locations' => [
+                        {
+                          '_id' => location.id,
+                          'name' => 'Home'
+                        }
                       ]
-                    }] }
+                    } ] }
                   },
                   conflicts: {
-                    "$set" => { "addresses.0.street"=>"Bond St" }
+                    '$set' => { 'addresses.0.street' => 'Bond St' }
                   }
                 }
               )
@@ -332,31 +312,32 @@ describe Mongoid::Atomic do
           end
         end
 
-        context "when adding new embedded docs at multiple levels" do
-
+        context 'when adding new embedded docs at multiple levels' do
           let!(:address) do
-            person.addresses.build(street: "Another")
+            person.addresses.build(street: 'Another')
           end
 
           let!(:location) do
-            address.locations.build(name: "Home")
+            address.locations.build(name: 'Home')
           end
 
-          it "returns the proper $sets and $pushes for all levels" do
+          it 'returns the proper $sets and $pushes for all levels' do
             expect(person.atomic_updates).to eq(
               {
-                "$set" => {
-                  "title" => "Sir",
+                '$set' => {
+                  'title' => 'Sir'
                 },
-                "$push" => {
-                  "addresses" => { '$each' => [{
-                    "_id" => address.id,
-                    "street" => "Another",
-                    "locations" => [
-                      "_id" => location.id,
-                      "name" => "Home"
+                '$push' => {
+                  'addresses' => { '$each' => [ {
+                    '_id' => address.id,
+                    'street' => 'Another',
+                    'locations' => [
+                      {
+                        '_id' => location.id,
+                        'name' => 'Home'
+                      }
                     ]
-                  }] }
+                  } ] }
                 }
               }
             )
@@ -376,37 +357,41 @@ describe Mongoid::Atomic do
           it 'correctly distributes the operations' do
             pending 'https://jira.mongodb.org/browse/MONGOID-4982'
 
-            truck.atomic_updates.should == {
-              '$set' => {'crates.0.volume' => 2},
-              '$push' => {'crates.0.toys' => {'$each' => [crate.toys.first.attributes]}},
-              conflicts: {
-                '$push' => {'crates' => {'$each' => [truck.crates.last.attributes]}},
-              },
-            }
+            truck.atomic_updates.should eq(
+              {
+                '$set' => { 'crates.0.volume' => 2 },
+                '$push' => { 'crates.0.toys' => { '$each' => [ crate.toys.first.attributes ] } },
+                conflicts: {
+                  '$push' => { 'crates' => { '$each' => [ truck.crates.last.attributes ] } }
+                }
+              }
+            )
           end
         end
       end
     end
 
-    context "when adding embedded documents with nil ids" do
-      let(:account) { Account.create!(name: "acc") }
+    context 'when adding embedded documents with nil ids' do
+      let(:account) { Account.create!(name: 'acc') }
 
       before do
-        account.memberships.build(id: nil, name: "m1")
-        account.memberships.build(id: nil, name: "m2")
+        account.memberships.build(id: nil, name: 'm1')
+        account.memberships.build(id: nil, name: 'm2')
       end
 
-      it "has the correct updates" do
-        account.atomic_updates.should == {
-          "$push" => {
-            "memberships" => {
-              "$each" => [
-                { "_id" => nil, "name" => "m1" },
-                { "_id" => nil, "name" => "m2" }
-              ]
+      it 'has the correct updates' do
+        account.atomic_updates.should eq(
+          {
+            '$push' => {
+              'memberships' => {
+                '$each' => [
+                  { '_id' => nil, 'name' => 'm1' },
+                  { '_id' => nil, 'name' => 'm2' }
+                ]
+              }
             }
           }
-        }
+        )
       end
     end
   end

data/spec/mongoid/attributes/dynamic_spec.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Attributes::Dynamic do
   shared_examples_for 'dynamic field' do
     let(:raw_attributes) do
-      {attr_name => 'foo bar'}
+      { attr_name => 'foo bar' }
     end
 
     context 'when reading attributes' do
@@ -38,14 +37,14 @@ describe Mongoid::Attributes::Dynamic do
         context 'reading via read_attribute' do
           it 'returns nil' do
             bar = Bar.new
-            expect(bar.read_attribute(:foo)).to be nil
+            expect(bar.read_attribute(:foo)).to be_nil
           end
         end
 
         context 'reading via []' do
           it 'returns nil' do
             bar = Bar.new
-            expect(bar[:foo]).to be nil
+            expect(bar[:foo]).to be_nil
           end
         end
       end
@@ -107,7 +106,7 @@ describe Mongoid::Attributes::Dynamic do
       end
     end
 
-    context 'when writing attributes via #{attribute}=' do
+    context 'when writing attributes via <attribute>=' do
       context 'when attribute is not already set' do
         let(:bar) { Bar.new }