mongoid 9.0.11 → 9.1.0

data/spec/mongoid/criteria/queryable/selectable_logical_spec.rb

@@ -1,36 +1,30 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Queryable::Selectable do
-
   let(:query) do
-    Mongoid::Query.new("id" => "_id")
+    Mongoid::Query.new('id' => '_id')
   end
 
   shared_examples_for 'returns a cloned query' do
-
-    it "returns a cloned query" do
-      expect(selection).to_not equal(query)
+    it 'returns a cloned query' do
+      expect(selection).not_to equal(query)
     end
   end
 
   # Hoisting means the operator can be elided, for example
   # Foo.and(a: 1) produces simply {'a' => 1}.
   shared_examples_for 'a hoisting logical operation' do
-
     let(:query) do
       Mongoid::Query.new
     end
 
-    context "when provided a single criterion" do
-
+    context 'when provided a single criterion' do
       shared_examples_for 'adds the conditions to top level' do
-
-        it "adds the conditions to top level" do
+        it 'adds the conditions to top level' do
           expect(selection.selector).to eq(
-            "field" => [ 1, 2 ]
+            'field' => [ 1, 2 ]
           )
         end
 
@@ -45,7 +39,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when the criterion is wrapped in an array' do
         let(:selection) do
-          query.send(tested_method, [{field: [ 1, 2 ] }])
+          query.send(tested_method, [ { field: [ 1, 2 ] } ])
         end
 
         it_behaves_like 'adds the conditions to top level'
@@ -53,7 +47,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when the criterion is wrapped in a deep array with nil elements' do
         let(:selection) do
-          query.send(tested_method, [[[{field: [ 1, 2 ] }]], [nil]])
+          query.send(tested_method, [ [ [ { field: [ 1, 2 ] } ] ], [ nil ] ])
         end
 
         it_behaves_like 'adds the conditions to top level'
@@ -74,19 +68,15 @@ describe Mongoid::Criteria::Queryable::Selectable do
       it 'combines' do
         expect(result.selector).to eq(
           'hello' => 'world',
-          'foo' => 'bar',
+          'foo' => 'bar'
         )
       end
     end
 
-    context "when provided a single criterion that is handled via Key" do
-
+    context 'when provided a single criterion that is handled via Key' do
       shared_examples_for 'adds the conditions to top level' do
-
-        it "adds the conditions to top level" do
-          expect(selection.selector).to eq({
-            "field" => {'$gt' => 3},
-          })
+        it 'adds the conditions to top level' do
+          expect(selection.selector).to eq({ 'field' => { '$gt' => 3 } })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -100,7 +90,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when the criterion is wrapped in an array' do
         let(:selection) do
-          query.send(tested_method, [{ :field.gt => 3 }])
+          query.send(tested_method, [ { :field.gt => 3 } ])
         end
 
         it_behaves_like 'adds the conditions to top level'
@@ -108,7 +98,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when the criterion is wrapped in a deep array with nil elements' do
         let(:selection) do
-          query.send(tested_method, [[[{ :field.gt => 3 }]], [nil]])
+          query.send(tested_method, [ [ [ { :field.gt => 3 } ] ], [ nil ] ])
         end
 
         it_behaves_like 'adds the conditions to top level'
@@ -120,9 +110,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'adds the conditions' do
-          expect(selection.selector).to eq({
-            "field" => {'$gte' => Time.new(2020, 1, 1)},
-          })
+          expect(selection.selector).to eq({ 'field' => { '$gte' => Time.new(2020, 1, 1) } })
         end
 
         it 'keeps argument type' do
@@ -136,9 +124,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'adds the conditions' do
-          expect(selection.selector).to eq({
-            "field" => {'$gte' => Time.utc(2020, 1, 1)},
-          })
+          expect(selection.selector).to eq({ 'field' => { '$gte' => Time.utc(2020, 1, 1) } })
         end
 
         it 'converts argument to a time' do
@@ -152,9 +138,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'adds the conditions' do
-          expect(selection.selector).to eq({
-            "field" => {'$gte' => Time.utc(2020, 1, 1)},
-          })
+          expect(selection.selector).to eq({ 'field' => { '$gte' => Time.utc(2020, 1, 1) } })
         end
 
         it 'converts argument to a time' do
@@ -163,52 +147,38 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
 
-    context "when provided a nested criterion" do
-
+    context 'when provided a nested criterion' do
       let(:selection) do
         query.send(tested_method, :test.elem_match => { :field.in => [ 1, 2 ] })
       end
 
-      it "builds the correct selector" do
-        expect(selection.selector).to eq({
-          "test" => { "$elemMatch" => { "field" => { "$in" => [ 1, 2 ] }}}
-        })
+      it 'builds the correct selector' do
+        expect(selection.selector).to eq({ 'test' => { '$elemMatch' => { 'field' => { '$in' => [ 1, 2 ] } } } })
       end
 
       it_behaves_like 'returns a cloned query'
     end
 
-    context "when chaining the criteria" do
-
-      context "when the criteria are for different fields" do
-
+    context 'when chaining the criteria' do
+      context 'when the criteria are for different fields' do
         let(:selection) do
           query.and(first: [ 1, 2 ]).send(tested_method, second: [ 3, 4 ])
         end
 
-        it "adds the conditions to top level" do
-          expect(selection.selector).to eq({
-            "first" => [ 1, 2 ],
-            "second" => [ 3, 4 ],
-          })
+        it 'adds the conditions to top level' do
+          expect(selection.selector).to eq({ 'first' => [ 1, 2 ], 'second' => [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when the criteria are on the same field" do
-
+      context 'when the criteria are on the same field' do
         let(:selection) do
           query.and(first: [ 1, 2 ]).send(tested_method, first: [ 3, 4 ])
         end
 
-        it "combines via $and operator" do
-          expect(selection.selector).to eq({
-            "first" => [ 1, 2 ],
-            "$and" => [
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+        it 'combines via $and operator' do
+          expect(selection.selector).to eq({ 'first' => [ 1, 2 ], '$and' => [ { 'first' => [ 3, 4 ] } ] })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -219,24 +189,23 @@ describe Mongoid::Criteria::Queryable::Selectable do
   # Non-hoisting means the operator is always present, for example
   # Foo.or(a: 1) produces {'$or' => [{'a' => 1}]}.
   shared_examples_for 'a non-hoisting logical operation' do
-
     context 'when there is a single predicate' do
       let(:query) do
         Mongoid::Query.new.send(tested_method, hello: 'world')
       end
 
       it 'adds the predicate' do
-        expect(query.selector).to eq(expected_operator => [{'hello' => 'world'}])
+        expect(query.selector).to eq(expected_operator => [ { 'hello' => 'world' } ])
       end
     end
 
     context 'when the single predicate is wrapped in an array' do
       let(:query) do
-        Mongoid::Query.new.send(tested_method, [{hello: 'world'}])
+        Mongoid::Query.new.send(tested_method, [ { hello: 'world' } ])
       end
 
       it 'adds the predicate' do
-        expect(query.selector).to eq(expected_operator => [{'hello' => 'world'}])
+        expect(query.selector).to eq(expected_operator => [ { 'hello' => 'world' } ])
       end
     end
 
@@ -254,7 +223,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       it 'combines' do
         # This is used for $or / $nor, the two conditions should remain
         # as separate hashes
-        expect(result.selector).to eq(expected_operator => [{'hello' => 'world'}, {'foo' => 'bar'}])
+        expect(result.selector).to eq(expected_operator => [ { 'hello' => 'world' }, { 'foo' => 'bar' } ])
       end
     end
 
@@ -268,7 +237,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:other2) do
-        {bar: 42}
+        { bar: 42 }
       end
 
       let(:other3) do
@@ -279,72 +248,67 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       it 'combines' do
         expect(result.selector).to eq(expected_operator => [
-          {'hello' => 'world'},
-          {'foo' => 'bar'},
-          {'bar' => 42},
-          {'a' => 2},
-        ])
+                                        { 'hello' => 'world' },
+                                        { 'foo' => 'bar' },
+                                        { 'bar' => 42 },
+                                        { 'a' => 2 }
+                                      ])
       end
     end
   end
 
-  describe "#and" do
-
+  describe '#and' do
     let(:tested_method) { :and }
     let(:expected_operator) { '$and' }
 
     it_behaves_like 'a hoisting logical operation'
 
-    context "when provided no criterion" do
-
+    context 'when provided no criterion' do
       let(:selection) do
         query.and
       end
 
-      it "does not add any criterion" do
+      it 'does not add any criterion' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
 
       it_behaves_like 'returns a cloned query'
     end
 
-    context "when provided nil" do
-
+    context 'when provided nil' do
       let(:selection) do
         query.and(nil)
       end
 
-      it "does not add any criterion" do
+      it 'does not add any criterion' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
 
       it_behaves_like 'returns a cloned query'
     end
 
-    context "when provided multiple criteria" do
-
-      context "when the criterion is already included" do
-
+    context 'when provided multiple criteria' do
+      context 'when the criterion is already included' do
         context 'simple criterion' do
           let(:selection) do
             query.and({ first: [ 1, 2 ] }).and({ first: [ 1, 2 ] })
           end
 
-          it "adds all conditions" do
+          it 'adds all conditions' do
             expect(selection.selector).to eq({
-              'first' => [1, 2],
-              "$and" => [
-                { "first" => [ 1, 2 ] }
-              ]
-            })
+                                               'first' => [ 1, 2 ],
+                                               '$and' => [
+                                                 { 'first' => [ 1, 2 ] }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -355,13 +319,13 @@ describe Mongoid::Criteria::Queryable::Selectable do
             query.and({ first: [ 1, 2 ] }).and(:first.gt => 3)
           end
 
-          it "adds all conditions" do
+          it 'adds all conditions' do
             expect(selection.selector).to eq({
-              'first' => [1, 2],
-              "$and" => [
-                { "first" => {'$gt' => 3} }
-              ]
-            })
+                                               'first' => [ 1, 2 ],
+                                               '$and' => [
+                                                 { 'first' => { '$gt' => 3 } }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -372,46 +336,44 @@ describe Mongoid::Criteria::Queryable::Selectable do
             query.and(:first.lt => 5).and(:first.gt => 3)
           end
 
-          it "adds all conditions" do
+          it 'adds all conditions' do
             expect(selection.selector).to eq({
-              'first' => {'$lt' => 5, '$gt' => 3},
-            })
+                                               'first' => { '$lt' => 5, '$gt' => 3 }
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
         end
       end
 
-      context "when the new criteria are for different fields" do
-
+      context 'when the new criteria are for different fields' do
         let(:selection) do
           query.and({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
         end
 
-        it "adds all conditions to top level" do
+        it 'adds all conditions to top level' do
           expect(selection.selector).to eq({
-            "first" => [ 1, 2 ],
-            "second" => [ 3, 4 ],
-          })
+                                             'first' => [ 1, 2 ],
+                                             'second' => [ 3, 4 ]
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when the new criteria are for the same field" do
-
+      context 'when the new criteria are for the same field' do
         context 'when criteria are simple' do
           let(:selection) do
             query.and({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
           end
 
-          it "combines via $and operator" do
+          it 'combines via $and operator' do
             expect(selection.selector).to eq({
-              "first" => [ 1, 2 ],
-              "$and" => [
-                { "first" => [ 3, 4 ] }
-              ]
-            })
+                                               'first' => [ 1, 2 ],
+                                               '$and' => [
+                                                 { 'first' => [ 3, 4 ] }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -421,26 +383,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
           shared_examples 'behave correctly' do
             let(:selection) do
               query.and(
-                { field: {first_operator => [ 1, 2 ] }},
-                { field: {second_operator => [ 3, 4 ] }},
+                { field: { first_operator => [ 1, 2 ] } },
+                { field: { second_operator => [ 3, 4 ] } }
               )
             end
 
-            it "combines via $and operator and stringifies all keys" do
+            it 'combines via $and operator and stringifies all keys' do
               expect(selection.selector).to eq({
-                "field" => {'$in' => [ 1, 2 ]},
-                "$and" => [
-                  { "field" => {'$in' => [ 3, 4 ] }}
-                ]
-              })
+                                                 'field' => { '$in' => [ 1, 2 ] },
+                                                 '$and' => [
+                                                   { 'field' => { '$in' => [ 3, 4 ] } }
+                                                 ]
+                                               })
             end
           end
 
           [
-            ['$in', '$in'],
-            [:$in, '$in'],
-            ['$in', :$in],
-            [:$in, :$in],
+            [ '$in', '$in' ],
+            [ :$in, '$in' ],
+            [ '$in', :$in ],
+            %i[$in $in]
           ].each do |first_operator, second_operator|
             context "when first operator is #{first_operator.inspect} and second operator is #{second_operator.inspect}" do
               let(:first_operator) { first_operator }
@@ -453,11 +415,10 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'when criteria are handled via Key' do
           shared_examples_for 'adds the conditions to top level' do
-
-            it "adds the conditions to top level" do
+            it 'adds the conditions to top level' do
               expect(selection.selector).to eq({
-                "field" => {'$gt' => 3, '$lt' => 5},
-              })
+                                                 'field' => { '$gt' => 3, '$lt' => 5 }
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
@@ -473,7 +434,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           context 'criteria are provided in separate hashes' do
             let(:selection) do
-              query.send(tested_method, {:field.gt => 3}, {:field.lt => 5})
+              query.send(tested_method, { :field.gt => 3 }, { :field.lt => 5 })
             end
 
             it_behaves_like 'adds the conditions to top level'
@@ -481,7 +442,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           context 'when the criterion is wrapped in an array' do
             let(:selection) do
-              query.send(tested_method, [:field.gt => 3], [:field.lt => 5])
+              query.send(tested_method, [ { :field.gt => 3 } ], [ { :field.lt => 5 } ])
             end
 
             it_behaves_like 'adds the conditions to top level'
@@ -490,34 +451,31 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'when criteria are simple and handled via Key' do
           shared_examples_for 'combines conditions with $and' do
-
-            it "combines conditions with $and" do
+            it 'combines conditions with $and' do
               expect(selection.selector).to eq({
-                "field" => 3,
-                '$and' => ['field' => {'$lt' => 5}],
-              })
+                                                 'field' => 3,
+                                                 '$and' => [ { 'field' => { '$lt' => 5 } } ]
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
           end
 
           shared_examples_for 'combines conditions with $eq' do
-
-            it "combines conditions with $eq" do
+            it 'combines conditions with $eq' do
               expect(selection.selector).to eq({
-                "field" => {'$eq' => 3, '$lt' => 5},
-              })
+                                                 'field' => { '$eq' => 3, '$lt' => 5 }
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
           end
 
           shared_examples_for 'combines conditions with $regex' do
-
-            it "combines conditions with $regex" do
+            it 'combines conditions with $regex' do
               expect(selection.selector).to eq({
-                "field" => {'$regex' => /t/, '$lt' => 5},
-              })
+                                                 'field' => { '$regex' => /t/, '$lt' => 5 }
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
@@ -543,7 +501,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           context 'criteria are provided in separate hashes' do
             let(:selection) do
-              query.send(tested_method, {:field => 3}, {:field.lt => 5})
+              query.send(tested_method, { field: 3 }, { :field.lt => 5 })
             end
 
             it_behaves_like 'combines conditions with $and'
@@ -551,7 +509,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           context 'when the criterion is wrapped in an array' do
             let(:selection) do
-              query.send(tested_method, [:field => 3], [:field.lt => 5])
+              query.send(tested_method, [ { field: 3 } ], [ { :field.lt => 5 } ])
             end
 
             it_behaves_like 'combines conditions with $and'
@@ -560,34 +518,31 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'when criteria are handled via Key and simple' do
           shared_examples_for 'combines conditions with $and' do
-
-            it "combines conditions with $and" do
+            it 'combines conditions with $and' do
               expect(selection.selector).to eq({
-                "field" => {'$gt' => 3},
-                '$and' => ['field' => 5],
-              })
+                                                 'field' => { '$gt' => 3 },
+                                                 '$and' => [ { 'field' => 5 } ]
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
           end
 
           shared_examples_for 'combines conditions with $eq' do
-
-            it "combines conditions with $eq" do
+            it 'combines conditions with $eq' do
               expect(selection.selector).to eq({
-                "field" => {'$gt' => 3, '$eq' => 5},
-              })
+                                                 'field' => { '$gt' => 3, '$eq' => 5 }
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
           end
 
           shared_examples_for 'combines conditions with $regex' do
-
-            it "combines conditions with $regex" do
+            it 'combines conditions with $regex' do
               expect(selection.selector).to eq({
-                "field" => {'$gt' => 3, '$regex' => /t/},
-              })
+                                                 'field' => { '$gt' => 3, '$regex' => /t/ }
+                                               })
             end
 
             it_behaves_like 'returns a cloned query'
@@ -613,7 +568,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           context 'criteria are provided in separate hashes' do
             let(:selection) do
-              query.send(tested_method, {:field.gt => 3}, {:field => 5})
+              query.send(tested_method, { :field.gt => 3 }, { field: 5 })
             end
 
             it_behaves_like 'combines conditions with $and'
@@ -621,7 +576,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           context 'when the criterion is wrapped in an array' do
             let(:selection) do
-              query.send(tested_method, [:field.gt => 3], [:field => 5])
+              query.send(tested_method, [ { :field.gt => 3 } ], [ { field: 5 } ])
             end
 
             it_behaves_like 'combines conditions with $and'
@@ -638,7 +593,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
       let(:result) { query.and(other) }
 
       context 'different fields' do
-
         let(:other) do
           Mongoid::Query.new.where(foo: 'bar')
         end
@@ -649,13 +603,12 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       context 'same field' do
-
         let(:other) do
           Mongoid::Query.new.where(hello: /bar/)
         end
 
         it 'combines fields with $and' do
-          expect(result.selector).to eq('hello' => 'world', '$and' => [{'hello' => /bar/}])
+          expect(result.selector).to eq('hello' => 'world', '$and' => [ { 'hello' => /bar/ } ])
         end
       end
     end
@@ -670,7 +623,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:other2) do
-        {bar: 42}
+        { bar: 42 }
       end
 
       let(:other3) do
@@ -681,10 +634,9 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       it 'combines' do
         expect(result.selector).to eq('hello' => 'world',
-          'foo' => 'bar',
-          'bar' => 42,
-          'a' => 2,
-        )
+                                      'foo' => 'bar',
+                                      'bar' => 42,
+                                      'a' => 2)
       end
     end
 
@@ -696,7 +648,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:expected) do
-        {'created_at' => {'$gt' => time.utc}}
+        { 'created_at' => { '$gt' => time.utc } }
       end
 
       it 'combines and evolves' do
@@ -709,7 +661,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         let(:selector) { scope.selector }
 
         it 'adds most recent criterion as $and' do
-          expect(selector).to eq('foo' => 1, '$and' => [{'foo' => 2}])
+          expect(selector).to eq('foo' => 1, '$and' => [ { 'foo' => 2 } ])
         end
       end
 
@@ -765,10 +717,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'adds new conditions to top level' do
-          selection.selector.should == {
-            'foo' => 'bar',
-            'hello' => 'world',
-          }
+          selection.selector.should eq({ 'foo' => 'bar', 'hello' => 'world' })
         end
       end
 
@@ -778,128 +727,117 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'adds new conditions to top level' do
-          selection.selector.should == {
-            'foo' => 'bar',
-            'hello' => 'world',
-          }
+          selection.selector.should eq({ 'foo' => 'bar', 'hello' => 'world' })
         end
       end
 
       context 'when complex criteria conditions are given' do
         let(:selection) do
-          base_selection.and(query.or([one: 'one'], [two: 'two']))
+          base_selection.and(query.or([ { one: 'one' } ], [ { two: 'two' } ]))
         end
 
         it 'adds new conditions to top level' do
-          selection.selector.should == {
-            'foo' => 'bar',
-            '$or' => [
-              {'one' => 'one'},
-              {'two' => 'two'},
-            ],
-          }
+          selection.selector.should eq(
+            { 'foo' => 'bar',
+              '$or' => [
+                { 'one' => 'one' },
+                { 'two' => 'two' }
+              ] }
+          )
         end
       end
     end
   end
 
   shared_examples '$or/$nor' do
-
     it_behaves_like 'a non-hoisting logical operation'
 
-    context "when provided no arguments" do
-
+    context 'when provided no arguments' do
       let(:selection) do
         query.send(tested_method)
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "does not add any criteria" do
+      it 'does not add any criteria' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
     end
 
-    context "when provided nil" do
-
+    context 'when provided nil' do
       let(:selection) do
         query.send(tested_method, nil)
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "does not add any criteria" do
+      it 'does not add any criteria' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
     end
 
-    context "when provided a single criterion" do
-
+    context 'when provided a single criterion' do
       let(:selection) do
         query.send(tested_method, field: [ 1, 2 ])
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "adds the $or/$nor selector" do
+      it 'adds the $or/$nor selector' do
         expect(selection.selector).to eq({
-          expected_operator => [{ "field" => [ 1, 2 ] }]
-        })
+                                           expected_operator => [ { 'field' => [ 1, 2 ] } ]
+                                         })
       end
 
       context 'when the criterion is wrapped in array' do
-
         let(:selection) do
-          query.send(tested_method, [{ field: [ 1, 2 ] }])
+          query.send(tested_method, [ { field: [ 1, 2 ] } ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or/$nor selector" do
+        it 'adds the $or/$nor selector' do
           expect(selection.selector).to eq({
-            expected_operator => [{ "field" => [ 1, 2 ] }]
-          })
+                                             expected_operator => [ { 'field' => [ 1, 2 ] } ]
+                                           })
         end
 
         context 'when the array has nil as one of the elements' do
-
           let(:selection) do
-            query.send(tested_method, [{ field: [ 1, 2 ] }, nil])
+            query.send(tested_method, [ { field: [ 1, 2 ] }, nil ])
           end
 
           it_behaves_like 'returns a cloned query'
 
-          it "adds the $or/$nor selector ignoring the nil element" do
+          it 'adds the $or/$nor selector ignoring the nil element' do
             expect(selection.selector).to eq({
-              expected_operator => [{ "field" => [ 1, 2 ] }]
-            })
+                                               expected_operator => [ { 'field' => [ 1, 2 ] } ]
+                                             })
           end
         end
       end
 
       context 'when query already has a condition on another field' do
-
         let(:selection) do
           query.where(foo: 'bar').send(tested_method, field: [ 1, 2 ])
         end
 
         it 'moves original conditions under $or/$nor' do
           expect(selection.selector).to eq({
-            expected_operator => [{'foo' => 'bar'}, { "field" => [ 1, 2 ] }]
-          })
+                                             expected_operator => [ { 'foo' => 'bar' }, { 'field' => [ 1, 2 ] } ]
+                                           })
         end
       end
 
       context 'when query already has an $or/$nor condition and another condition' do
-
         let(:selection) do
           query.send(tested_method, field: [ 1, 2 ]).where(foo: 'bar').send(tested_method, test: 1)
         end
@@ -908,49 +846,46 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection.selector).to eq(
             expected_operator => [
               {
-                expected_operator => [{ "field" => [ 1, 2 ] }],
-                'foo' => 'bar',
+                expected_operator => [ { 'field' => [ 1, 2 ] } ],
+                'foo' => 'bar'
               },
-              {'test' => 1},
+              { 'test' => 1 }
             ]
           )
         end
       end
     end
 
-    context "when provided multiple criteria" do
-
-      context "when the criteria are for different fields" do
-
+    context 'when provided multiple criteria' do
+      context 'when the criteria are for different fields' do
         let(:selection) do
           query.send(tested_method, { first: [ 1, 2 ] }, { second: [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or/$nor selector" do
+        it 'adds the $or/$nor selector' do
           expect(selection.selector).to eq({
-            expected_operator => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
+                                             expected_operator => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criteria uses a Key instance" do
-
+      context 'when the criteria uses a Key instance' do
         let(:selection) do
           query.send(tested_method, { first: [ 1, 2 ] }, { :second.gt => 3 })
         end
 
-        it "adds the $or/$nor selector" do
+        it 'adds the $or/$nor selector' do
           expect(selection.selector).to eq({
-            expected_operator => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
-          })
+                                             expected_operator => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => { '$gt' => 3 } }
+                                             ]
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -962,8 +897,8 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           it 'adds the conditions' do
             expect(selection.selector).to eq(expected_operator => [
-              "field" => {'$gte' => Time.new(2020, 1, 1)},
-            ])
+                                               { 'field' => { '$gte' => Time.new(2020, 1, 1) } }
+                                             ])
           end
 
           it 'keeps the type' do
@@ -978,8 +913,8 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           it 'adds the conditions' do
             expect(selection.selector).to eq(expected_operator => [
-              "field" => {'$gte' => Time.utc(2020, 1, 1)},
-            ])
+                                               { 'field' => { '$gte' => Time.utc(2020, 1, 1) } }
+                                             ])
           end
 
           it 'converts argument to a time' do
@@ -994,8 +929,8 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           it 'adds the conditions' do
             expect(selection.selector).to eq(expected_operator => [
-              "field" => {'$gte' => Time.utc(2020, 1, 1)},
-            ])
+                                               { 'field' => { '$gte' => Time.utc(2020, 1, 1) } }
+                                             ])
           end
 
           it 'converts argument to a time' do
@@ -1004,41 +939,38 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
-      context "when a criterion has an aliased field" do
-
+      context 'when a criterion has an aliased field' do
         let(:selection) do
           query.send(tested_method, { id: 1 })
         end
 
-        it "adds the $or/$nor selector and aliases the field" do
+        it 'adds the $or/$nor selector and aliases the field' do
           expect(selection.selector).to eq({
-            expected_operator => [ { "_id" => 1 } ]
-          })
+                                             expected_operator => [ { '_id' => 1 } ]
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when a criterion is wrapped in an array" do
-
+      context 'when a criterion is wrapped in an array' do
         let(:selection) do
-          query.send(tested_method, [{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+          query.send(tested_method, [ { first: [ 1, 2 ] }, { :second.gt => 3 } ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or/$nor selector" do
+        it 'adds the $or/$nor selector' do
           expect(selection.selector).to eq({
-            expected_operator => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
-          })
+                                             expected_operator => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => { '$gt' => 3 } }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criteria are on the same field" do
-
+      context 'when the criteria are on the same field' do
         context 'simple criteria' do
           let(:selection) do
             query.send(tested_method, { first: [ 1, 2 ] }, { first: [ 3, 4 ] })
@@ -1046,13 +978,13 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           it_behaves_like 'returns a cloned query'
 
-          it "appends both $or/$nor expressions" do
+          it 'appends both $or/$nor expressions' do
             expect(selection.selector).to eq({
-              expected_operator => [
-                { "first" => [ 1, 2 ] },
-                { "first" => [ 3, 4 ] }
-              ]
-            })
+                                               expected_operator => [
+                                                 { 'first' => [ 1, 2 ] },
+                                                 { 'first' => [ 3, 4 ] }
+                                               ]
+                                             })
           end
         end
 
@@ -1063,86 +995,82 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
           it_behaves_like 'returns a cloned query'
 
-          it "adds all criteria" do
+          it 'adds all criteria' do
             expect(selection.selector).to eq({
-              expected_operator => [
-                { "first" => {'$gt' => 3, '$lt' => 5} },
-              ]
-            })
+                                               expected_operator => [
+                                                 { 'first' => { '$gt' => 3, '$lt' => 5 } }
+                                               ]
+                                             })
           end
         end
 
         context 'Key criteria as multiple arguments' do
           let(:selection) do
-            query.send(tested_method, {:first.gt => 3}, {:first.lt => 5})
+            query.send(tested_method, { :first.gt => 3 }, { :first.lt => 5 })
           end
 
           it_behaves_like 'returns a cloned query'
 
-          it "adds all criteria" do
+          it 'adds all criteria' do
             expect(selection.selector).to eq({
-              expected_operator => [
-                { "first" => {'$gt' => 3} },
-                { "first" => {'$lt' => 5} },
-              ]
-            })
+                                               expected_operator => [
+                                                 { 'first' => { '$gt' => 3 } },
+                                                 { 'first' => { '$lt' => 5 } }
+                                               ]
+                                             })
           end
         end
       end
     end
 
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
+    context 'when chaining the criterion' do
+      context 'when the criterion are for different fields' do
         let(:selection) do
           query.send(tested_method, first: [ 1, 2 ]).send(tested_method, second: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or/$nor selectors" do
+        it 'adds the $or/$nor selectors' do
           expect(selection.selector).to eq({
-            expected_operator => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
+                                             expected_operator => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criterion are on the same field" do
-
+      context 'when the criterion are on the same field' do
         let(:selection) do
           query.send(tested_method, first: [ 1, 2 ]).send(tested_method, first: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "appends both $or/$nor expressions" do
+        it 'appends both $or/$nor expressions' do
           expect(selection.selector).to eq({
-            expected_operator => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+                                             expected_operator => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'first' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
     end
 
     context 'when giving multiple conditions in one call on the same key with symbol operator' do
-
       context 'non-regexp argument' do
         let(:selection) do
           query.send(tested_method, field: 1, :field.gt => 0)
         end
 
         it 'combines conditions with $eq' do
-          selection.selector.should == {
-            expected_operator => [
-              'field' => {'$eq' => 1, '$gt' => 0},
-            ]
-          }
+          selection.selector.should eq(
+            { expected_operator => [
+              { 'field' => { '$eq' => 1, '$gt' => 0 } }
+            ] }
+          )
         end
       end
 
@@ -1152,35 +1080,31 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'combines conditions with $regex' do
-          selection.selector.should == {
-            expected_operator => [
-              'field' => {'$regex' => /t/, '$gt' => 0},
-            ]
-          }
+          selection.selector.should eq(
+            { expected_operator => [
+              { 'field' => { '$regex' => /t/, '$gt' => 0 } }
+            ] }
+          )
         end
       end
-
     end
   end
 
-  describe "#or" do
-
+  describe '#or' do
     let(:tested_method) { :or }
     let(:expected_operator) { '$or' }
 
     it_behaves_like '$or/$nor'
   end
 
-  describe "#nor" do
-
+  describe '#nor' do
     let(:tested_method) { :nor }
     let(:expected_operator) { '$nor' }
 
     it_behaves_like '$or/$nor'
   end
 
-  describe "#any_of" do
-
+  describe '#any_of' do
     let(:tested_method) { :any_of }
     let(:expected_operator) { '$or' }
 
@@ -1198,7 +1122,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:other2) do
-        {bar: 42}
+        { bar: 42 }
       end
 
       let(:other3) do
@@ -1211,96 +1135,89 @@ describe Mongoid::Criteria::Queryable::Selectable do
         expect(result.selector).to eq(
           'hello' => 'world',
           expected_operator => [
-            {'foo' => 'bar'},
-            {'bar' => 42},
-            {'a' => 2},
-          ],
+            { 'foo' => 'bar' },
+            { 'bar' => 42 },
+            { 'a' => 2 }
+          ]
         )
       end
     end
 
-    context "when provided no arguments" do
-
+    context 'when provided no arguments' do
       let(:selection) do
         query.any_of
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "does not add any criteria" do
+      it 'does not add any criteria' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
     end
 
-    context "when provided nil" do
-
+    context 'when provided nil' do
       let(:selection) do
         query.any_of(nil)
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "does not add any criteria" do
+      it 'does not add any criteria' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
     end
 
-    context "when provided a single criterion" do
-
+    context 'when provided a single criterion' do
       let(:selection) do
         query.any_of(field: [ 1, 2 ])
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "adds the $or selector" do
+      it 'adds the $or selector' do
         expect(selection.selector).to eq(
-          "field" => [ 1, 2 ],
+          'field' => [ 1, 2 ]
         )
       end
 
       context 'when the criterion is wrapped in array' do
-
         let(:selection) do
-          query.any_of([{ field: [ 1, 2 ] }])
+          query.any_of([ { field: [ 1, 2 ] } ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the condition" do
+        it 'adds the condition' do
           expect(selection.selector).to eq(
-            "field" => [ 1, 2 ],
+            'field' => [ 1, 2 ]
           )
         end
 
         context 'when the array has nil as one of the elements' do
-
           let(:selection) do
-            query.any_of([{ field: [ 1, 2 ] }, nil])
+            query.any_of([ { field: [ 1, 2 ] }, nil ])
           end
 
           it_behaves_like 'returns a cloned query'
 
-          it "adds the $or selector ignoring the nil element" do
+          it 'adds the $or selector ignoring the nil element' do
             expect(selection.selector).to eq(
-              "field" => [ 1, 2 ],
+              'field' => [ 1, 2 ]
             )
           end
         end
       end
 
       context 'when query already has a condition on another field' do
-
         context 'when there is one argument' do
-
           let(:selection) do
             query.where(foo: 'bar').any_of(field: [ 1, 2 ])
           end
@@ -1308,106 +1225,100 @@ describe Mongoid::Criteria::Queryable::Selectable do
           it 'adds the new condition' do
             expect(selection.selector).to eq(
               'foo' => 'bar',
-              'field' => [1, 2],
+              'field' => [ 1, 2 ]
             )
           end
         end
 
         context 'when there are multiple arguments' do
-
           let(:selection) do
-            query.where(foo: 'bar').any_of({field: [ 1, 2 ]}, {hello: 'world'})
+            query.where(foo: 'bar').any_of({ field: [ 1, 2 ] }, { hello: 'world' })
           end
 
           it 'adds the new condition' do
             expect(selection.selector).to eq(
               'foo' => 'bar',
               '$or' => [
-                {'field' => [1, 2]},
-                {'hello' => 'world'},
-              ],
+                { 'field' => [ 1, 2 ] },
+                { 'hello' => 'world' }
+              ]
             )
           end
         end
       end
 
       context 'when query already has an $or condition and another condition' do
-
         let(:selection) do
           query.or(field: [ 1, 2 ]).where(foo: 'bar').any_of(test: 1)
         end
 
         it 'adds the new condition' do
           expect(selection.selector).to eq(
-            '$or' => [{'field' => [1, 2]}],
+            '$or' => [ { 'field' => [ 1, 2 ] } ],
             'foo' => 'bar',
-            'test' => 1,
+            'test' => 1
           )
         end
       end
 
       context 'when any_of has multiple arguments' do
-
         let(:selection) do
-          query.or(field: [ 1, 2 ]).where(foo: 'bar').any_of({a: 1}, {b: 2})
+          query.or(field: [ 1, 2 ]).where(foo: 'bar').any_of({ a: 1 }, { b: 2 })
         end
 
         it 'adds the new condition to top level' do
           expect(selection.selector).to eq(
-            '$or' => [{'field' => [1, 2]}],
+            '$or' => [ { 'field' => [ 1, 2 ] } ],
             'foo' => 'bar',
-            '$and' => [{'$or' => [{'a' => 1}, {'b' => 2}]}],
+            '$and' => [ { '$or' => [ { 'a' => 1 }, { 'b' => 2 } ] } ]
           )
         end
 
         context 'when query already has a top-level $and' do
           let(:selection) do
-            query.or(field: [ 1, 2 ]).where('$and' => [foo: 'bar']).any_of({a: 1}, {b: 2})
+            query.or(field: [ 1, 2 ]).where('$and' => [ { foo: 'bar' } ]).any_of({ a: 1 }, { b: 2 })
           end
 
           it 'adds the new condition to top level $and' do
             expect(selection.selector).to eq(
-              '$or' => [{'field' => [1, 2]}],
-              '$and' => [{'foo' => 'bar'}, {'$or' => [{'a' => 1}, {'b' => 2}]}],
+              '$or' => [ { 'field' => [ 1, 2 ] } ],
+              '$and' => [ { 'foo' => 'bar' }, { '$or' => [ { 'a' => 1 }, { 'b' => 2 } ] } ]
             )
           end
         end
       end
     end
 
-    context "when provided multiple criteria" do
-
-      context "when the criteria are for different fields" do
-
+    context 'when provided multiple criteria' do
+      context 'when the criteria are for different fields' do
         let(:selection) do
           query.any_of({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selector" do
+        it 'adds the $or selector' do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
+                                             '$or' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criteria uses a Key instance" do
-
+      context 'when the criteria uses a Key instance' do
         let(:selection) do
           query.any_of({ first: [ 1, 2 ] }, { :second.gt => 3 })
         end
 
-        it "adds the $or selector" do
+        it 'adds the $or selector' do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
-          })
+                                             '$or' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => { '$gt' => 3 } }
+                                             ]
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -1415,42 +1326,39 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when criteria are simple and handled via Key' do
         shared_examples_for 'adds conditions with $or' do
-
-          it "adds conditions with $or" do
+          it 'adds conditions with $or' do
             expect(selection.selector).to eq({
-              '$or' => [
-                {'field' => 3},
-                {'field' => {'$lt' => 5}},
-              ],
-            })
+                                               '$or' => [
+                                                 { 'field' => 3 },
+                                                 { 'field' => { '$lt' => 5 } }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
         end
 
         shared_examples_for 'combines conditions with $eq' do
-
-          it "combines conditions with $eq" do
+          it 'combines conditions with $eq' do
             expect(selection.selector).to eq({
-              'field' => {
-                '$eq' => 3,
-                '$lt' => 5,
-              },
-            })
+                                               'field' => {
+                                                 '$eq' => 3,
+                                                 '$lt' => 5
+                                               }
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
         end
 
         shared_examples_for 'combines conditions with $regex' do
-
-          it "combines conditions with $regex" do
+          it 'combines conditions with $regex' do
             expect(selection.selector).to eq({
-              'field' => {
-                '$regex' => /t/,
-                '$lt' => 5,
-              },
-            })
+                                               'field' => {
+                                                 '$regex' => /t/,
+                                                 '$lt' => 5
+                                               }
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -1476,7 +1384,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'criteria are provided in separate hashes' do
           let(:selection) do
-            query.send(tested_method, {:field => 3}, {:field.lt => 5})
+            query.send(tested_method, { field: 3 }, { :field.lt => 5 })
           end
 
           it_behaves_like 'adds conditions with $or'
@@ -1484,7 +1392,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'when the criterion is wrapped in an array' do
           let(:selection) do
-            query.send(tested_method, [:field => 3], [:field.lt => 5])
+            query.send(tested_method, [ { field: 3 } ], [ { :field.lt => 5 } ])
           end
 
           it_behaves_like 'adds conditions with $or'
@@ -1493,24 +1401,22 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when criteria are handled via Key and simple' do
         shared_examples_for 'adds conditions with $or' do
-
-          it "adds conditions with $or" do
+          it 'adds conditions with $or' do
             expect(selection.selector).to eq({
-              '$or' => [
-                {'field' => {'$gt' => 3}},
-                {'field' => 5},
-              ],
-            })
+                                               '$or' => [
+                                                 { 'field' => { '$gt' => 3 } },
+                                                 { 'field' => 5 }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
         end
 
         shared_examples_for 'combines conditions with $eq' do
-
-          it "combines conditions with $eq" do
+          it 'combines conditions with $eq' do
             expect(selection.selector).to eq(
-              'field' => {'$gt' => 3, '$eq' => 5},
+              'field' => { '$gt' => 3, '$eq' => 5 }
             )
           end
 
@@ -1518,10 +1424,9 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         shared_examples_for 'combines conditions with $regex' do
-
-          it "combines conditions with $regex" do
+          it 'combines conditions with $regex' do
             expect(selection.selector).to eq(
-              'field' => {'$gt' => 3, '$regex' => /t/},
+              'field' => { '$gt' => 3, '$regex' => /t/ }
             )
           end
 
@@ -1548,7 +1453,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'criteria are provided in separate hashes' do
           let(:selection) do
-            query.send(tested_method, {:field.gt => 3}, {:field => 5})
+            query.send(tested_method, { :field.gt => 3 }, { field: 5 })
           end
 
           it_behaves_like 'adds conditions with $or'
@@ -1556,95 +1461,89 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context 'when the criterion is wrapped in an array' do
           let(:selection) do
-            query.send(tested_method, [:field.gt => 3], [:field => 5])
+            query.send(tested_method, [ { :field.gt => 3 } ], [ { field: 5 } ])
           end
 
           it_behaves_like 'adds conditions with $or'
         end
       end
 
-      context "when a criterion has an aliased field" do
-
+      context 'when a criterion has an aliased field' do
         let(:selection) do
           query.any_of({ id: 1 })
         end
 
-        it "adds the $or selector and aliases the field" do
+        it 'adds the $or selector and aliases the field' do
           expect(selection.selector).to eq(
-            "_id" => 1,
+            '_id' => 1
           )
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when a criterion is wrapped in an array" do
-
+      context 'when a criterion is wrapped in an array' do
         let(:selection) do
-          query.any_of([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+          query.any_of([ { first: [ 1, 2 ] }, { :second.gt => 3 } ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selector" do
+        it 'adds the $or selector' do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
-          })
+                                             '$or' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => { '$gt' => 3 } }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criteria are on the same field" do
-
+      context 'when the criteria are on the same field' do
         let(:selection) do
           query.any_of({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "appends both $or expressions" do
+        it 'appends both $or expressions' do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+                                             '$or' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'first' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
     end
 
-    context "when chaining the criteria" do
-
-      context "when the criteria are for different fields" do
-
+    context 'when chaining the criteria' do
+      context 'when the criteria are for different fields' do
         let(:selection) do
           query.any_of(first: [ 1, 2 ]).any_of(second: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the conditions separately" do
+        it 'adds the conditions separately' do
           expect(selection.selector).to eq(
-            "first" => [ 1, 2 ],
-            "second" => [ 3, 4 ],
+            'first' => [ 1, 2 ],
+            'second' => [ 3, 4 ]
           )
         end
       end
 
-      context "when the criteria are on the same field" do
-
+      context 'when the criteria are on the same field' do
         let(:selection) do
           query.any_of(first: [ 1, 2 ]).any_of(first: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the conditions separately" do
+        it 'adds the conditions separately' do
           expect(selection.selector).to eq(
-            "first" => [ 1, 2 ],
-            '$and' => [{"first" => [ 3, 4 ]}],
+            'first' => [ 1, 2 ],
+            '$and' => [ { 'first' => [ 3, 4 ] } ]
           )
         end
       end
@@ -1652,66 +1551,66 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
     context 'when using multiple criteria and symbol operators' do
       context 'when using fields that meaningfully evolve values' do
-
         let(:query) do
-          Dictionary.any_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+          Dictionary.any_of({ a: 1 }, :published.gt => Date.new(2020, 2, 3))
         end
 
         it 'generates the expected query' do
-          query.selector.should == {'$or' => [
-            {'a' => 1},
-            # Date instance is converted to a Time instance in local time,
-            # because we are querying on a Time field and dates are interpreted
-            # in local time when assigning to Time fields
-            {'published' => {'$gt' => Time.zone.local(2020, 2, 3)}},
-          ]}
+          query.selector.should eq(
+            { '$or' => [
+              { 'a' => 1 },
+              # Date instance is converted to a Time instance in local time,
+              # because we are querying on a Time field and dates are interpreted
+              # in local time when assigning to Time fields
+              { 'published' => { '$gt' => Time.zone.local(2020, 2, 3) } }
+            ] }
+          )
         end
       end
 
       context 'when using fields that do not meaningfully evolve values' do
-
         let(:query) do
-          Dictionary.any_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+          Dictionary.any_of({ a: 1 }, :submitted_on.gt => Date.new(2020, 2, 3))
         end
 
         it 'generates the expected query' do
-          query.selector.should == {'$or' => [
-            {'a' => 1},
-            # Date instance is converted to a Time instance in UTC,
-            # because we are querying on a Date field and dates are interpreted
-            # in UTC when persisted as dates by Mongoid
-            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
-          ]}
+          query.selector.should eq(
+            { '$or' => [
+              { 'a' => 1 },
+              # Date instance is converted to a Time instance in UTC,
+              # because we are querying on a Date field and dates are interpreted
+              # in UTC when persisted as dates by Mongoid
+              { 'submitted_on' => { '$gt' => Time.utc(2020, 2, 3) } }
+            ] }
+          )
         end
       end
     end
   end
 
-  describe "#not" do
-
-    context "when provided no criterion" do
-
+  describe '#not' do
+    context 'when provided no criterion' do
       let(:selection) do
         query.not
       end
 
-      it "does not add any criterion" do
+      it 'does not add any criterion' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
 
-      it "returns a cloned query" do
+      it 'returns a cloned query' do
         expect(selection).not_to equal(query)
       end
 
       it 'does not mutate receiver' do
-        expect(query.negating).to be nil
+        expect(query.negating).to be_nil
 
         selection
-        expect(query.negating).to be nil
+        expect(query.negating).to be_nil
       end
 
       shared_examples_for 'negates the next condition' do
@@ -1719,267 +1618,252 @@ describe Mongoid::Criteria::Queryable::Selectable do
           query.not.send(query_method, field: [ 1, 2 ])
         end
 
-        it "negates the next condition" do
+        it 'negates the next condition' do
           expect(selection.selector).to eq(
-            { "field" => { "$not" => { operator => [ 1, 2 ] }}}
+            { 'field' => { '$not' => { operator => [ 1, 2 ] } } }
           )
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
+        it 'removes the negation on the clone' do
+          expect(selection).not_to be_negating
         end
       end
 
-      context "when the next condition is #all" do
+      context 'when the next condition is #all' do
         let(:query_method) { :all }
         let(:operator) { '$all' }
 
         it_behaves_like 'negates the next condition'
       end
 
-      context "when the next condition is #in" do
+      context 'when the next condition is #in' do
         let(:query_method) { :in }
         let(:operator) { '$in' }
 
         it_behaves_like 'negates the next condition'
       end
 
-      context "when the next condition is #nin" do
+      context 'when the next condition is #nin' do
         let(:query_method) { :nin }
         let(:operator) { '$nin' }
 
         it_behaves_like 'negates the next condition'
       end
 
-      context "when the following criteria is a gt method" do
-
+      context 'when the following criteria is a gt method' do
         let(:selection) do
           query.not.gt(age: 50)
         end
 
-        it "negates the gt selection" do
+        it 'negates the gt selection' do
           expect(selection.selector).to eq(
-            { "age" => { "$not" => { "$gt" => 50 }}}
+            { 'age' => { '$not' => { '$gt' => 50 } } }
           )
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
+        it 'removes the negation on the clone' do
+          expect(selection).not_to be_negating
         end
       end
 
-      context "when the criteria uses Key" do
-
+      context 'when the criteria uses Key' do
         let(:selection) do
           query.not(:age.gt => 50)
         end
 
-        it "negates the gt selection" do
+        it 'negates the gt selection' do
           expect(selection.selector).to eq(
-            '$and' => ['$nor' => ['age' => {'$gt' => 50}]]
+            '$and' => [ { '$nor' => [ { 'age' => { '$gt' => 50 } } ] } ]
           )
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
+        it 'removes the negation on the clone' do
+          expect(selection).not_to be_negating
         end
       end
 
-      context "when the following criteria is a where" do
-
+      context 'when the following criteria is a where' do
         let(:selection) do
           query.not.where(field: 1, :other.in => [ 1, 2 ])
         end
 
-        it "negates the selection with an operator" do
+        it 'negates the selection with an operator' do
           expect(selection.selector).to eq(
-            { "field" => { "$ne" => 1 }, "other" => { "$not" => { "$in" => [ 1, 2 ] }}}
+            { 'field' => { '$ne' => 1 }, 'other' => { '$not' => { '$in' => [ 1, 2 ] } } }
           )
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
+        it 'removes the negation on the clone' do
+          expect(selection).not_to be_negating
         end
       end
 
-      context "when the following criteria is a where with a regexp" do
-
+      context 'when the following criteria is a where with a regexp' do
         let(:selection) do
           query.not.where(field: 1, other: /test/)
         end
 
-        it "negates the selection with an operator" do
+        it 'negates the selection with an operator' do
           expect(selection.selector).to eq(
-            { "field" => { "$ne" => 1 }, "other" => { "$not" => /test/ } }
+            { 'field' => { '$ne' => 1 }, 'other' => { '$not' => /test/ } }
           )
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
+        it 'removes the negation on the clone' do
+          expect(selection).not_to be_negating
         end
       end
 
       context 'when the following criteria uses string were form' do
-
         let(:selection) do
           query.not.where('hello world')
         end
 
-        it "negates the selection with an operator" do
+        it 'negates the selection with an operator' do
           expect(selection.selector).to eq(
-            '$and' => [{'$nor' => [{'$where' => 'hello world'}]}]
+            '$and' => [ { '$nor' => [ { '$where' => 'hello world' } ] } ]
           )
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
+        it 'removes the negation on the clone' do
+          expect(selection).not_to be_negating
         end
-
       end
     end
 
-    context "when provided nil" do
-
+    context 'when provided nil' do
       let(:selection) do
         query.not(nil)
       end
 
-      it "does not add any criterion" do
+      it 'does not add any criterion' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
 
       it_behaves_like 'returns a cloned query'
     end
 
-    context "when provided a single criterion" do
-
+    context 'when provided a single criterion' do
       let(:selection) do
         query.not(field: /test/)
       end
 
-      it "adds the $not selector" do
+      it 'adds the $not selector' do
         expect(selection.selector).to eq({
-          "field" => { "$not" => /test/ }
-        })
+                                           'field' => { '$not' => /test/ }
+                                         })
       end
 
       it_behaves_like 'returns a cloned query'
     end
 
-    context "when negating a field in the original selector" do
+    context 'when negating a field in the original selector' do
       let(:query) do
-        Mongoid::Query.new("id" => "_id").where(field: 'foo')
+        Mongoid::Query.new('id' => '_id').where(field: 'foo')
       end
 
       let(:selection) do
         query.not(field: 'bar')
       end
 
-      it "combines the conditions" do
+      it 'combines the conditions' do
         expect(selection.selector).to eq({
-          "field" => 'foo',
-          '$and' => [{'$nor' => [{ "field" => 'bar' }]}],
-        })
+                                           'field' => 'foo',
+                                           '$and' => [ { '$nor' => [ { 'field' => 'bar' } ] } ]
+                                         })
       end
 
       it_behaves_like 'returns a cloned query'
     end
 
-    context "when provided multiple criteria" do
-
-      context "when the criteria are for different fields" do
-
+    context 'when provided multiple criteria' do
+      context 'when the criteria are for different fields' do
         let(:selection) do
           query.not(first: /1/, second: /2/)
         end
 
-        it "adds the $not selectors" do
+        it 'adds the $not selectors' do
           expect(selection.selector).to eq({
-            "first" => { "$not" => /1/ },
-            "second" => { "$not" => /2/ }
-          })
+                                             'first' => { '$not' => /1/ },
+                                             'second' => { '$not' => /2/ }
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when the criteria are given in separate arguments" do
-
+      context 'when the criteria are given in separate arguments' do
         let(:selection) do
-          query.not({first: /1/}, {second: /2/})
+          query.not({ first: /1/ }, { second: /2/ })
         end
 
-        it "adds the $not selectors" do
+        it 'adds the $not selectors' do
           expect(selection.selector).to eq({
-            "first" => { "$not" => /1/ },
-            "second" => { "$not" => /2/ }
-          })
+                                             'first' => { '$not' => /1/ },
+                                             'second' => { '$not' => /2/ }
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
       end
     end
 
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
+    context 'when chaining the criterion' do
+      context 'when the criterion are for different fields' do
         let(:selection) do
           query.not(first: /1/).not(second: /2/)
         end
 
-        it "adds the $not selectors" do
+        it 'adds the $not selectors' do
           expect(selection.selector).to eq({
-            "first" => { "$not" => /1/ },
-            "second" => { "$not" => /2/ }
-          })
+                                             'first' => { '$not' => /1/ },
+                                             'second' => { '$not' => /2/ }
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when the criterion are on the same field" do
-
+      context 'when the criterion are on the same field' do
         let(:selection) do
           query.not(first: /1/).not(first: /2/)
         end
 
-        it "combines conditions" do
+        it 'combines conditions' do
           expect(selection.selector).to eq(
-            "first" =>  { "$not" => /1/ },
-            '$and' => [{'$nor' => [{'first' => /2/}]}],
+            'first' => { '$not' => /1/ },
+            '$and' => [ { '$nor' => [ { 'first' => /2/ } ] } ]
           )
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when the criterion are a double negative" do
-
+      context 'when the criterion are a double negative' do
         let(:selection) do
           query.not.where(:first.not => /1/)
         end
 
-        it "does not double the $not selector" do
+        it 'does not double the $not selector' do
           expect(selection.selector).to eq({
-            "first" =>  { "$not" => /1/ }
-          })
+                                             'first' => { '$not' => /1/ }
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -1998,7 +1882,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       let(:result) { query.not(other) }
 
       it 'combines' do
-        expect(result.selector).to eq('hello' => 'world', 'foo' => {'$ne' => 'bar'})
+        expect(result.selector).to eq('hello' => 'world', 'foo' => { '$ne' => 'bar' })
       end
     end
 
@@ -2015,7 +1899,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       it 'combines fields into top level criteria' do
         expect(result.selector).to eq('hello' => 'world',
-          'a' => {'$ne' => 1}, 'b' => {'$ne' => 2})
+                                      'a' => { '$ne' => 1 }, 'b' => { '$ne' => 2 })
       end
     end
 
@@ -2025,14 +1909,15 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:other) do
-        Mongoid::Query.new.where('$nor' => [{a: 1, b: 2}])
+        Mongoid::Query.new.where('$nor' => [ { a: 1, b: 2 } ])
       end
 
       let(:result) { query.not(other) }
 
       it 'combines with $and of $nor' do
-        expect(result.selector).to eq('hello' => 'world', '$and' => [{'$nor' => [{
-          '$nor' => [{'a' => 1, 'b' => 2}]}]}])
+        expect(result.selector).to eq('hello' => 'world', '$and' => [ { '$nor' => [ {
+                                        '$nor' => [ { 'a' => 1, 'b' => 2 } ]
+                                      } ] } ])
       end
     end
 
@@ -2046,7 +1931,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:other2) do
-        {bar: 42}
+        { bar: 42 }
       end
 
       let(:other3) do
@@ -2057,26 +1942,24 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       it 'combines' do
         expect(result.selector).to eq('hello' => 'world',
-          'foo' => {'$ne' => 'bar'},
-          'bar' => {'$ne' => 42},
-          'a' => {'$ne' => 2},
-        )
+                                      'foo' => { '$ne' => 'bar' },
+                                      'bar' => { '$ne' => 42 },
+                                      'a' => { '$ne' => 2 })
       end
     end
 
     context 'when giving multiple conditions in one call on the same key with symbol operator' do
-
       context 'non-regexp argument' do
         let(:selection) do
           query.not(field: 1, :field.gt => 0)
         end
 
         it 'combines conditions with $eq' do
-          selection.selector.should == {
-            '$and' => ['$nor' => [
-              'field' => {'$eq' => 1, '$gt' => 0},
-            ]]
-          }
+          selection.selector.should eq(
+            '$and' => [ { '$nor' => [
+              { 'field' => { '$eq' => 1, '$gt' => 0 } }
+            ] } ]
+          )
         end
       end
 
@@ -2086,39 +1969,40 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it 'combines conditions with $regex' do
-          selection.selector.should == {
-            '$and' => ['$nor' => [
-              'field' => {'$regex' => /t/, '$gt' => 0},
-            ]]
-          }
+          selection.selector.should eq(
+            '$and' => [ { '$nor' => [
+              { 'field' => { '$regex' => /t/, '$gt' => 0 } }
+            ] } ]
+          )
         end
       end
     end
 
     # This test confirms that MONGOID-5097 has been repaired.
-    context "when using exists on a field of type Time" do
+    context 'when using exists on a field of type Time' do
       let(:criteria) do
-        Dictionary.any_of({:published.exists => true}, published: nil)
+        Dictionary.any_of({ :published.exists => true }, published: nil)
       end
 
       it "doesn't raise an error" do
         expect do
           criteria
-        end.to_not raise_error
+        end.not_to raise_error
       end
 
-      it "generates the correct selector" do
+      it 'generates the correct selector' do
         expect(criteria.selector).to eq({
-          "$or" => [ {
-            "published" => { "$exists" => true }
-          }, {
-            "published" => nil
-          } ] } )
+                                          '$or' => [ {
+                                            'published' => { '$exists' => true }
+                                          }, {
+                                            'published' => nil
+                                          } ]
+                                        })
       end
     end
   end
 
-  describe "#none_of" do
+  describe '#none_of' do
     context 'when argument is a mix of Criteria and hashes' do
       let(:query) { Mongoid::Query.new.where(hello: 'world') }
       let(:other1) { Mongoid::Query.new.where(foo: 'bar') }
@@ -2131,72 +2015,72 @@ describe Mongoid::Criteria::Queryable::Selectable do
         expect(result.selector).to eq(
           'hello' => 'world',
           '$nor' => [
-            {'foo' => 'bar'},
-            {'bar' => 42},
-            {'a' => 2},
-          ],
+            { 'foo' => 'bar' },
+            { 'bar' => 42 },
+            { 'a' => 2 }
+          ]
         )
       end
     end
 
-    context "when provided no arguments" do
+    context 'when provided no arguments' do
       let(:selection) { query.none_of }
 
       it_behaves_like 'returns a cloned query'
 
-      it "does not add any criteria" do
+      it 'does not add any criteria' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
     end
 
-    context "when provided nil" do
+    context 'when provided nil' do
       let(:selection) { query.none_of(nil) }
 
       it_behaves_like 'returns a cloned query'
 
-      it "does not add any criteria" do
+      it 'does not add any criteria' do
         expect(selection.selector).to eq({})
       end
 
-      it "returns the query" do
+      it 'returns the query' do
         expect(selection).to eq(query)
       end
     end
 
-    context "when provided a single criterion" do
+    context 'when provided a single criterion' do
       let(:selection) { query.none_of(field: [ 1, 2 ]) }
 
       it_behaves_like 'returns a cloned query'
 
       it 'adds the $nor selector' do
         expect(selection.selector).to eq(
-          '$nor' => [ { 'field' => [ 1, 2 ] } ],
+          '$nor' => [ { 'field' => [ 1, 2 ] } ]
         )
       end
 
       context 'when the criterion is wrapped in array' do
-        let(:selection) { query.none_of([{ field: [ 1, 2 ] }]) }
+        let(:selection) { query.none_of([ { field: [ 1, 2 ] } ]) }
 
         it_behaves_like 'returns a cloned query'
 
         it 'adds the condition' do
           expect(selection.selector).to eq(
-            '$nor' => [ { 'field' => [ 1, 2 ] } ],
+            '$nor' => [ { 'field' => [ 1, 2 ] } ]
           )
         end
 
         context 'when the array has nil as one of the elements' do
-          let(:selection) { query.none_of([{ field: [ 1, 2 ] }, nil]) }
+          let(:selection) { query.none_of([ { field: [ 1, 2 ] }, nil ]) }
 
           it_behaves_like 'returns a cloned query'
 
           it 'adds the $nor selector ignoring the nil element' do
             expect(selection.selector).to eq(
-              '$nor' => [ { 'field' => [ 1, 2 ] } ],
+              '$nor' => [ { 'field' => [ 1, 2 ] } ]
             )
           end
         end
@@ -2209,7 +2093,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
           it 'adds the new condition' do
             expect(selection.selector).to eq(
               'foo' => 'bar',
-              '$nor' => [ { 'field' => [1, 2] } ],
+              '$nor' => [ { 'field' => [ 1, 2 ] } ]
             )
           end
         end
@@ -2223,9 +2107,9 @@ describe Mongoid::Criteria::Queryable::Selectable do
             expect(selection.selector).to eq(
               'foo' => 'bar',
               '$nor' => [
-                { 'field' => [1, 2] },
-                { 'hello' => 'world' },
-              ],
+                { 'field' => [ 1, 2 ] },
+                { 'hello' => 'world' }
+              ]
             )
           end
         end
@@ -2238,7 +2122,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         it 'adds the new condition' do
           expect(selection.selector).to eq(
-            '$nor' => [ { 'field' => [1, 2] } ],
+            '$nor' => [ { 'field' => [ 1, 2 ] } ],
             'foo' => 'bar',
             '$and' => [ { '$nor' => [ { 'test' => 1 } ] } ]
           )
@@ -2247,65 +2131,65 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when none_of has multiple arguments' do
         let(:selection) do
-          query.nor(field: [ 1, 2 ]).where(foo: 'bar').none_of({a: 1}, {b: 2})
+          query.nor(field: [ 1, 2 ]).where(foo: 'bar').none_of({ a: 1 }, { b: 2 })
         end
 
         it 'adds the new condition to top level' do
           expect(selection.selector).to eq(
             'foo' => 'bar',
-            '$nor' => [ { 'field' => [1, 2] } ],
+            '$nor' => [ { 'field' => [ 1, 2 ] } ],
             '$and' => [ { '$nor' => [ { 'a' => 1 }, { 'b' => 2 } ] } ]
           )
         end
 
         context 'when query already has a top-level $and' do
           let(:selection) do
-            query.nor(field: [ 1, 2 ]).where('$and' => [foo: 'bar']).none_of({a: 1}, {b: 2})
+            query.nor(field: [ 1, 2 ]).where('$and' => [ { foo: 'bar' } ]).none_of({ a: 1 }, { b: 2 })
           end
 
           it 'adds the new condition to top level $and' do
             expect(selection.selector).to eq(
-              '$nor' => [ { 'field' => [1, 2] } ],
+              '$nor' => [ { 'field' => [ 1, 2 ] } ],
               '$and' => [
                 { 'foo' => 'bar' },
                 { '$nor' => [ { 'a' => 1 }, { 'b' => 2 } ] }
-              ],
+              ]
             )
           end
         end
       end
     end
 
-    context "when provided multiple criteria" do
-      context "when the criteria are for different fields" do
+    context 'when provided multiple criteria' do
+      context 'when the criteria are for different fields' do
         let(:selection) do
           query.none_of({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $nor selector" do
+        it 'adds the $nor selector' do
           expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
+                                             '$nor' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criteria uses a Key instance" do
+      context 'when the criteria uses a Key instance' do
         let(:selection) do
           query.none_of({ first: [ 1, 2 ] }, { :second.gt => 3 })
         end
 
-        it "adds the $nor selector" do
+        it 'adds the $nor selector' do
           expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
-          })
+                                             '$nor' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => { '$gt' => 3 } }
+                                             ]
+                                           })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -2313,23 +2197,23 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when criteria are simple and handled via Key' do
         shared_examples_for 'adds conditions with $nor' do
-          it "adds conditions with $nor" do
+          it 'adds conditions with $nor' do
             expect(selection.selector).to eq({
-              '$nor' => [
-                {'field' => 3},
-                {'field' => {'$lt' => 5}},
-              ],
-            })
+                                               '$nor' => [
+                                                 { 'field' => 3 },
+                                                 { 'field' => { '$lt' => 5 } }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
         end
 
         shared_examples_for 'combines conditions with $eq' do
-          it "combines conditions with $eq" do
+          it 'combines conditions with $eq' do
             expect(selection.selector).to eq({
-              '$nor' => [ { 'field' => { '$eq' => 3, '$lt' => 5 } } ]
-            })
+                                               '$nor' => [ { 'field' => { '$eq' => 3, '$lt' => 5 } } ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -2338,8 +2222,8 @@ describe Mongoid::Criteria::Queryable::Selectable do
         shared_examples_for 'combines conditions with $regex' do
           it 'combines conditions with $regex' do
             expect(selection.selector).to eq({
-              '$nor' => [ { 'field' => { '$regex' => /t/, '$lt' => 5 } } ]
-            })
+                                               '$nor' => [ { 'field' => { '$regex' => /t/, '$lt' => 5 } } ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -2348,22 +2232,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
         context 'criteria are provided in the same hash' do
           context 'non-regexp argument' do
             let(:selection) { query.none_of(:field => 3, :field.lt => 5) }
+
             it_behaves_like 'combines conditions with $eq'
           end
 
           context 'regexp argument' do
             let(:selection) { query.none_of(:field => /t/, :field.lt => 5) }
+
             it_behaves_like 'combines conditions with $regex'
           end
         end
 
         context 'criteria are provided in separate hashes' do
-          let(:selection) { query.none_of({:field => 3}, {:field.lt => 5}) }
+          let(:selection) { query.none_of({ field: 3 }, { :field.lt => 5 }) }
+
           it_behaves_like 'adds conditions with $nor'
         end
 
         context 'when the criterion is wrapped in an array' do
-          let(:selection) { query.none_of([:field => 3], [:field.lt => 5]) }
+          let(:selection) { query.none_of([ { field: 3 } ], [ { :field.lt => 5 } ]) }
+
           it_behaves_like 'adds conditions with $nor'
         end
       end
@@ -2372,11 +2260,11 @@ describe Mongoid::Criteria::Queryable::Selectable do
         shared_examples_for 'adds conditions with $nor' do
           it 'adds conditions with $nor' do
             expect(selection.selector).to eq({
-              '$nor' => [
-                { 'field' => { '$gt' => 3 } },
-                { 'field' => 5 },
-              ],
-            })
+                                               '$nor' => [
+                                                 { 'field' => { '$gt' => 3 } },
+                                                 { 'field' => 5 }
+                                               ]
+                                             })
           end
 
           it_behaves_like 'returns a cloned query'
@@ -2385,7 +2273,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         shared_examples_for 'combines conditions with $eq' do
           it 'combines conditions with $eq' do
             expect(selection.selector).to eq(
-              '$nor' => [ { 'field' => {'$gt' => 3, '$eq' => 5} } ],
+              '$nor' => [ { 'field' => { '$gt' => 3, '$eq' => 5 } } ]
             )
           end
 
@@ -2395,7 +2283,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         shared_examples_for 'combines conditions with $regex' do
           it 'combines conditions with $regex' do
             expect(selection.selector).to eq(
-              '$nor' => [ { 'field' => {'$gt' => 3, '$regex' => /t/} } ],
+              '$nor' => [ { 'field' => { '$gt' => 3, '$regex' => /t/ } } ]
             )
           end
 
@@ -2405,22 +2293,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
         context 'criteria are provided in the same hash' do
           context 'non-regexp argument' do
             let(:selection) { query.none_of(:field.gt => 3, :field => 5) }
+
             it_behaves_like 'combines conditions with $eq'
           end
 
           context 'regexp argument' do
             let(:selection) { query.none_of(:field.gt => 3, :field => /t/) }
+
             it_behaves_like 'combines conditions with $regex'
           end
         end
 
         context 'criteria are provided in separate hashes' do
-          let(:selection) { query.none_of({:field.gt => 3}, {:field => 5}) }
+          let(:selection) { query.none_of({ :field.gt => 3 }, { field: 5 }) }
+
           it_behaves_like 'adds conditions with $nor'
         end
 
         context 'when the criterion is wrapped in an array' do
-          let(:selection) { query.none_of([:field.gt => 3], [:field => 5]) }
+          let(:selection) { query.none_of([ { :field.gt => 3 } ], [ { field: 5 } ]) }
+
           it_behaves_like 'adds conditions with $nor'
         end
       end
@@ -2429,7 +2321,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         let(:selection) { query.none_of({ id: 1 }) }
 
         it 'adds the $nor selector and aliases the field' do
-          expect(selection.selector).to eq('$nor' => [{ '_id' => 1 }])
+          expect(selection.selector).to eq('$nor' => [ { '_id' => 1 } ])
         end
 
         it_behaves_like 'returns a cloned query'
@@ -2437,22 +2329,22 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when a criterion is wrapped in an array' do
         let(:selection) do
-          query.none_of([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+          query.none_of([ { first: [ 1, 2 ] }, { :second.gt => 3 } ])
         end
 
         it_behaves_like 'returns a cloned query'
 
         it 'adds the $ nor selector' do
           expect(selection.selector).to eq({
-            '$nor' => [
-              { 'first' => [ 1, 2 ] },
-              { 'second' => { '$gt' => 3 }}
-            ]
-          })
+                                             '$nor' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'second' => { '$gt' => 3 } }
+                                             ]
+                                           })
         end
       end
 
-      context "when the criteria are on the same field" do
+      context 'when the criteria are on the same field' do
         let(:selection) do
           query.none_of({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
         end
@@ -2461,11 +2353,11 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         it 'appends both $nor expressions' do
           expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+                                             '$nor' => [
+                                               { 'first' => [ 1, 2 ] },
+                                               { 'first' => [ 3, 4 ] }
+                                             ]
+                                           })
         end
       end
     end
@@ -2481,12 +2373,12 @@ describe Mongoid::Criteria::Queryable::Selectable do
         it 'adds the conditions separately' do
           expect(selection.selector).to eq(
             '$nor' => [ { 'first' => [ 1, 2 ] } ],
-            '$and' => [ { '$nor' => [ { 'second' => [ 3, 4 ] } ] } ],
+            '$and' => [ { '$nor' => [ { 'second' => [ 3, 4 ] } ] } ]
           )
         end
       end
 
-      context "when the criteria are on the same field" do
+      context 'when the criteria are on the same field' do
         let(:selection) do
           query.none_of(first: [ 1, 2 ]).none_of(first: [ 3, 4 ])
         end
@@ -2505,33 +2397,37 @@ describe Mongoid::Criteria::Queryable::Selectable do
     context 'when using multiple criteria and symbol operators' do
       context 'when using fields that meaningfully evolve values' do
         let(:query) do
-          Dictionary.none_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+          Dictionary.none_of({ a: 1 }, :published.gt => Date.new(2020, 2, 3))
         end
 
         it 'generates the expected query' do
-          query.selector.should == {'$nor' => [
-            {'a' => 1},
-            # Date instance is converted to a Time instance in local time,
-            # because we are querying on a Time field and dates are interpreted
-            # in local time when assigning to Time fields
-            {'published' => {'$gt' => Time.zone.local(2020, 2, 3) } },
-          ] }
+          query.selector.should eq(
+            { '$nor' => [
+              { 'a' => 1 },
+              # Date instance is converted to a Time instance in local time,
+              # because we are querying on a Time field and dates are interpreted
+              # in local time when assigning to Time fields
+              { 'published' => { '$gt' => Time.zone.local(2020, 2, 3) } }
+            ] }
+          )
         end
       end
 
       context 'when using fields that do not meaningfully evolve values' do
         let(:query) do
-          Dictionary.none_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+          Dictionary.none_of({ a: 1 }, :submitted_on.gt => Date.new(2020, 2, 3))
         end
 
         it 'generates the expected query' do
-          query.selector.should == {'$nor' => [
-            {'a' => 1},
-            # Date instance is converted to a Time instance in UTC,
-            # because we are querying on a Date field and dates are interpreted
-            # in UTC when persisted as dates by Mongoid
-            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
-          ]}
+          query.selector.should eq(
+            { '$nor' => [
+              { 'a' => 1 },
+              # Date instance is converted to a Time instance in UTC,
+              # because we are querying on a Date field and dates are interpreted
+              # in UTC when persisted as dates by Mongoid
+              { 'submitted_on' => { '$gt' => Time.utc(2020, 2, 3) } }
+            ] }
+          )
         end
       end
     end