mongoid 9.0.11 → 9.1.0

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

@@ -1,198 +1,181 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Queryable::Selector do
-
-  describe "merge!" do
-
+  describe 'merge!' do
     let(:selector) do
       described_class.new
     end
 
-    context "when selector is nested" do
-
+    context 'when selector is nested' do
       before do
         selector[:field] = selection
         selector.merge!(other)
       end
 
       let(:selection) do
-        { "$lt" => 50 }
+        { '$lt' => 50 }
       end
 
-      context "when other contains same key with a hash" do
-
+      context 'when other contains same key with a hash' do
         let(:other) do
-          { "field" => { "$gt" => 20 } }
+          { 'field' => { '$gt' => 20 } }
         end
 
-        it "deep merges" do
-          expect(selector['field']).to eq({"$lt"=>50, "$gt" => 20})
+        it 'deep merges' do
+          expect(selector['field']).to eq({ '$lt' => 50, '$gt' => 20 })
         end
       end
 
-      context "when other contains same key without hash" do
-
+      context 'when other contains same key without hash' do
         let(:other) do
-          { "field" => 10 }
+          { 'field' => 10 }
         end
 
-        it "merges" do
+        it 'merges' do
           expect(selector['field']).to eq(10)
         end
       end
     end
 
-    context "when selector contains a $nin string" do
-
+    context 'when selector contains a $nin string' do
       let(:initial) do
-        { "$nin" => ["foo"] }
+        { '$nin' => [ 'foo' ] }
       end
 
       before do
-        selector["field"] = initial
+        selector['field'] = initial
       end
 
-      context "when merging in a new $nin" do
-
+      context 'when merging in a new $nin' do
         let(:other) do
-          { "field" => { "$nin" => ["bar"] } }
+          { 'field' => { '$nin' => [ 'bar' ] } }
         end
 
         before do
           selector.merge!(other)
         end
 
-        it "combines the two $nin queries into one" do
+        it 'combines the two $nin queries into one' do
           expect(selector).to eq({
-            "field" => { "$nin" => ["foo", "bar"] }
-          })
+                                   'field' => { '$nin' => %w[foo bar] }
+                                 })
         end
       end
     end
 
-    context "when selector contains a $nin symbol" do
-
+    context 'when selector contains a $nin symbol' do
       let(:initial) do
-        { :$nin => ["foo"] }
+        { :$nin => [ 'foo' ] }
       end
 
       before do
-        selector["field"] = initial
+        selector['field'] = initial
       end
 
-      context "when merging in a new $nin" do
-
+      context 'when merging in a new $nin' do
         let(:other) do
-          { "field" => { :$nin => ["bar"] } }
+          { 'field' => { :$nin => [ 'bar' ] } }
         end
 
         before do
           selector.merge!(other)
         end
 
-        it "combines the two $nin queries into one" do
+        it 'combines the two $nin queries into one' do
           expect(selector).to eq({
-            "field" => { :$nin => ["foo", "bar"] }
-          })
+                                   'field' => { :$nin => %w[foo bar] }
+                                 })
         end
       end
     end
 
-    context "when selector contains a $in string" do
-
+    context 'when selector contains a $in string' do
       let(:initial) do
-        { "$in" => [1, 2] }
+        { '$in' => [ 1, 2 ] }
       end
 
       before do
-        selector["field"] = initial
+        selector['field'] = initial
       end
 
-      context "when merging in a new $in with an intersecting value" do
-
+      context 'when merging in a new $in with an intersecting value' do
         let(:other) do
-          { "field" => { "$in" => [1] } }
+          { 'field' => { '$in' => [ 1 ] } }
         end
 
         before do
           selector.merge!(other)
         end
 
-        it "intersects the $in values" do
+        it 'intersects the $in values' do
           expect(selector).to eq({
-                                     "field" => { "$in" => [1] }
+                                   'field' => { '$in' => [ 1 ] }
                                  })
         end
       end
 
-      context "when merging in a new $in with no intersecting values" do
-
+      context 'when merging in a new $in with no intersecting values' do
         let(:other) do
-          { "field" => { "$in" => [3] } }
+          { 'field' => { '$in' => [ 3 ] } }
         end
 
         before do
           selector.merge!(other)
         end
 
-        it "intersects the $in values" do
+        it 'intersects the $in values' do
           expect(selector).to eq({
-                                     "field" => { "$in" => [] }
+                                   'field' => { '$in' => [] }
                                  })
         end
       end
     end
 
-    context "when selector contains a $in symbol" do
-
+    context 'when selector contains a $in symbol' do
       let(:initial) do
-        { :$in => [1, 2] }
+        { :$in => [ 1, 2 ] }
       end
 
       before do
-        selector["field"] = initial
+        selector['field'] = initial
       end
 
-      context "when merging in a new $in with an intersecting value" do
-
+      context 'when merging in a new $in with an intersecting value' do
         let(:other) do
-          { "field" => { :$in => [1] } }
+          { 'field' => { :$in => [ 1 ] } }
         end
 
         before do
           selector.merge!(other)
         end
 
-        it "intersects the $in values" do
+        it 'intersects the $in values' do
           expect(selector).to eq({
-                                     "field" => { :$in => [1] }
+                                   'field' => { :$in => [ 1 ] }
                                  })
         end
       end
 
-      context "when merging in a new $in with no intersecting values" do
-
+      context 'when merging in a new $in with no intersecting values' do
         let(:other) do
-          { "field" => { :$in => [3] } }
+          { 'field' => { :$in => [ 3 ] } }
         end
 
         before do
           selector.merge!(other)
         end
 
-        it "intersects the $in values" do
+        it 'intersects the $in values' do
           expect(selector).to eq({
-                                     "field" => { :$in => [] }
+                                   'field' => { :$in => [] }
                                  })
         end
       end
     end
 
-    context "when selector is not nested" do
-
+    context 'when selector is not nested' do
       before do
         selector[:field] = selection
         selector.merge!(other)
@@ -203,16 +186,15 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
 
       let(:other) do
-        { "field" => { "$gt" => 20 } }
+        { 'field' => { '$gt' => 20 } }
       end
 
-      it "merges" do
-        expect(selector['field']).to eq({ "$gt" => 20 })
+      it 'merges' do
+        expect(selector['field']).to eq({ '$gt' => 20 })
       end
     end
 
     context 'when an object does not support the | operator' do
-
       before do
         selector['start'] = selection
         selector.merge!(other)
@@ -223,108 +205,104 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
 
       let(:other) do
-        { 'start' => selection, 'name' => 'test',  }
+        { 'start' => selection, 'name' => 'test' }
       end
 
-      it "merges" do
+      it 'merges' do
         expect(selector['name']).to eq('test')
         expect(selector['start']).to eq(selection)
       end
     end
 
-    context "when the selector contains an $or" do
-
+    context 'when the selector contains an $or' do
       let(:initial) do
-        [{ "value" => 1 }]
+        [ { 'value' => 1 } ]
       end
 
       before do
-        selector["$or"] = initial
+        selector['$or'] = initial
       end
 
-      context "when merging in a new $or" do
-
+      context 'when merging in a new $or' do
         let(:other) do
-          [{ "value" => 2 }]
+          [ { 'value' => 2 } ]
         end
 
         before do
-          selector.merge!({ "$or" => other })
+          selector.merge!({ '$or' => other })
         end
 
-        it "combines the two $or queries into one" do
+        it 'combines the two $or queries into one' do
           expect(selector).to eq({
-            "$or" => [{ "value" => 1 }, { "value" => 2 }]
-          })
+                                   '$or' => [ { 'value' => 1 }, { 'value' => 2 } ]
+                                 })
         end
       end
     end
 
-    context "when the selector contains an $and" do
-
+    context 'when the selector contains an $and' do
       let(:initial) do
-        [{ "value" => 1 }]
+        [ { 'value' => 1 } ]
       end
 
       before do
-        selector["$and"] = initial
+        selector['$and'] = initial
       end
 
-      context "when merging in a new $and" do
-
+      context 'when merging in a new $and' do
         let(:other) do
-          [{ "value" => 2 }]
+          [ { 'value' => 2 } ]
         end
 
         before do
-          selector.merge!({ "$and" => other })
+          selector.merge!({ '$and' => other })
         end
 
-        it "combines the two $and queries into one" do
+        it 'combines the two $and queries into one' do
           expect(selector).to eq({
-            "$and" => [{ "value" => 1 }, { "value" => 2 }]
-          })
+                                   '$and' => [ { 'value' => 1 }, { 'value' => 2 } ]
+                                 })
         end
       end
     end
 
-    context "when the selector contains a $nor" do
-
+    context 'when the selector contains a $nor' do
       let(:initial) do
-        [{ "value" => 1 }]
+        [ { 'value' => 1 } ]
       end
 
       before do
-        selector["$nor"] = initial
+        selector['$nor'] = initial
       end
 
-      context "when merging in a new $nor" do
-
+      context 'when merging in a new $nor' do
         let(:other) do
-          [{ "value" => 2 }]
+          [ { 'value' => 2 } ]
         end
 
         before do
-          selector.merge!({ "$nor" => other })
+          selector.merge!({ '$nor' => other })
         end
 
-        it "combines the two $nor queries into one" do
+        it 'combines the two $nor queries into one' do
           expect(selector).to eq({
-            "$nor" => initial + other
-          })
+                                   '$nor' => initial + other
+                                 })
         end
       end
     end
   end
 
-  describe "#__deep_copy__" do
-
+  describe '#__deep_copy__' do
     let(:value) do
       [ 1, 2, 3 ]
     end
+    let(:cloned) do
+      selector.__deep_copy__
+    end
 
     let(:selection) do
-      { "$in" => value }
+      { '$in' => value }
     end
 
     let(:selector) do
@@ -335,46 +313,37 @@ describe Mongoid::Criteria::Queryable::Selector do
       selector[:field] = selection
     end
 
-    let(:cloned) do
-      selector.__deep_copy__
-    end
-
-    it "returns an equal copy" do
+    it 'returns an equal copy' do
       expect(cloned).to eq(selector)
     end
 
-    it "performs a deep copy" do
-      expect(cloned["field"]).to_not equal(selection)
+    it 'performs a deep copy' do
+      expect(cloned['field']).not_to equal(selection)
     end
 
-    it "clones n levels deep" do
-      expect(cloned["field"]["$in"]).to_not equal(value)
+    it 'clones n levels deep' do
+      expect(cloned['field']['$in']).not_to equal(value)
     end
   end
 
-  [ :store, :[]= ].each do |method|
-
+  %i[store []=].each do |method|
     describe "##{method}" do
-
-      context "when aliases are provided" do
-
-        context "when the alias has no serializer" do
-
+      context 'when aliases are provided' do
+        context 'when the alias has no serializer' do
           let(:selector) do
-            described_class.new({ "id" => "_id" })
+            described_class.new({ 'id' => '_id' })
           end
 
           before do
-            selector.send(method, "id", 1)
+            selector.send(method, 'id', 1)
           end
 
-          it "stores the field in the selector by database name" do
-            expect(selector["_id"]).to eq(1)
+          it 'stores the field in the selector by database name' do
+            expect(selector['_id']).to eq(1)
           end
         end
 
-        context "when the alias has a serializer" do
-
+        context 'when the alias has a serializer' do
           before(:all) do
             class Field
               def evolve(object)
@@ -393,64 +362,58 @@ describe Mongoid::Criteria::Queryable::Selector do
 
           let(:selector) do
             described_class.new(
-              { "id" => "_id" }, { "_id" => Field.new }
+              { 'id' => '_id' }, { '_id' => Field.new }
             )
           end
 
-          it "stores the serialized field in the selector by database name" do
-            selector.send(method, "id", "1")
-            expect(selector["_id"]).to eq(1)
+          it 'stores the serialized field in the selector by database name' do
+            selector.send(method, 'id', '1')
+            expect(selector['_id']).to eq(1)
           end
 
-          it "stores the serialized field when selector is deeply nested" do
-            selector.send(method, "$or", [{'$and' => [{'_id' => '5'}]}])
+          it 'stores the serialized field when selector is deeply nested' do
+            selector.send(method, '$or', [ { '$and' => [ { '_id' => '5' } ] } ])
             expect(selector['$or'][0]['$and'][0]['_id']).to eq(5)
           end
         end
       end
 
-      context "when no serializers are provided" do
-
+      context 'when no serializers are provided' do
         let(:selector) do
           described_class.new
         end
 
-        context "when provided a standard object" do
-
-          context "when the keys are strings" do
-
-            it "does not serialize values" do
-              expect(selector.send(method, "key", "5")).to eq("5")
+        context 'when provided a standard object' do
+          context 'when the keys are strings' do
+            it 'does not serialize values' do
+              expect(selector.send(method, 'key', '5')).to eq('5')
             end
           end
 
-          context "when the keys are symbols" do
-
-            it "does not serialize values" do
-              expect(selector.send(method, :key, "5")).to eq("5")
+          context 'when the keys are symbols' do
+            it 'does not serialize values' do
+              expect(selector.send(method, :key, '5')).to eq('5')
             end
           end
         end
 
-        context "when provided a range" do
-
+        context 'when provided a range' do
           before do
-            selector.send(method, "key", 1..3)
+            selector.send(method, 'key', 1..3)
           end
 
-          it "serializes the range" do
-            expect(selector["key"]).to eq({ "$gte" => 1, "$lte" => 3 })
+          it 'serializes the range' do
+            expect(selector['key']).to eq({ '$gte' => 1, '$lte' => 3 })
           end
         end
 
-        context "when providing an array" do
-
+        context 'when providing an array' do
           let(:big_one) do
-            BigDecimal("1.2321")
+            BigDecimal('1.2321')
           end
 
           let(:big_two) do
-            BigDecimal("4.2222")
+            BigDecimal('4.2222')
           end
 
           let(:array) do
@@ -458,68 +421,64 @@ describe Mongoid::Criteria::Queryable::Selector do
           end
 
           before do
-            selector.send(method, "key", array)
+            selector.send(method, 'key', array)
           end
 
           context 'when serializing bigdecimal to string' do
             config_override :map_big_decimal_to_decimal128, false
 
-            it "serializes each element in the array" do
-              expect(selector["key"]).to eq([ big_one.to_s, big_two.to_s ])
+            it 'serializes each element in the array' do
+              expect(selector['key']).to eq([ big_one.to_s, big_two.to_s ])
             end
           end
 
           context 'when serializing bigdecimal to decimal128' do
             config_override :map_big_decimal_to_decimal128, true
 
-            it "serializes each element in the array" do
-              expect(selector["key"]).to eq([ BSON::Decimal128.new(big_one), BSON::Decimal128.new(big_two)])
+            it 'serializes each element in the array' do
+              expect(selector['key']).to eq([ BSON::Decimal128.new(big_one), BSON::Decimal128.new(big_two) ])
             end
           end
         end
 
-        context "when providing a Mongoid::RawValue" do
-
-          context "and raw_value is a string" do
-
+        context 'when providing a Mongoid::RawValue' do
+          context 'and raw_value is a string' do
             before do
-              selector.send(method, "key", Mongoid::RawValue("Foo"))
+              selector.send(method, 'key', Mongoid::RawValue('Foo'))
             end
 
-            it "returns the raw_value" do
-              expect(selector["key"]).to eq("Foo")
+            it 'returns the raw_value' do
+              expect(selector['key']).to eq('Foo')
             end
           end
 
-          context "and raw_value cannot be converted by bson-ruby" do
-
+          context 'and raw_value cannot be converted by bson-ruby' do
             before do
-              selector.send(method, "key", Mongoid::RawValue(4..5))
+              selector.send(method, 'key', Mongoid::RawValue(4..5))
             end
 
-            it "returns the raw_value without conversion" do
-              expect(selector["key"]).to eq(4..5)
+            it 'returns the raw_value without conversion' do
+              expect(selector['key']).to eq(4..5)
             end
           end
 
-          context "and raw_value is a complex type" do
+          context 'and raw_value is a complex type' do
             config_override :map_big_decimal_to_decimal128, true
 
             before do
-              selector.send(method, "key", Mongoid::RawValue([{ foo: 1, "Bar" => [/baz/, BigDecimal('2'), 4..5] }, 3]))
+              selector.send(method, 'key',
+                            Mongoid::RawValue([ { foo: 1, 'Bar' => [ /baz/, BigDecimal('2'), 4..5 ] }, 3 ]))
             end
 
-            it "returns the raw_value" do
-              expect(selector["key"]).to eq([{ foo: 1, "Bar" => [/baz/, BigDecimal('2'), 4..5] }, 3])
+            it 'returns the raw_value' do
+              expect(selector['key']).to eq([ { foo: 1, 'Bar' => [ /baz/, BigDecimal('2'), 4..5 ] }, 3 ])
             end
           end
         end
       end
 
-      context "when serializers are provided" do
-
-        context "when the serializer is not localized" do
-
+      context 'when serializers are provided' do
+        context 'when the serializer is not localized' do
           before(:all) do
             class Field
               def evolve(object)
@@ -537,176 +496,153 @@ describe Mongoid::Criteria::Queryable::Selector do
           end
 
           let(:selector) do
-            described_class.new({}, { "key" => Field.new })
+            described_class.new({}, { 'key' => Field.new })
           end
 
-          context "when the criterion is simple" do
-
-            context "when the key is a string" do
-
+          context 'when the criterion is simple' do
+            context 'when the key is a string' do
               before do
-                selector.send(method, "key", "5")
+                selector.send(method, 'key', '5')
               end
 
-              it "serializes the value" do
-                expect(selector["key"]).to eq(5)
+              it 'serializes the value' do
+                expect(selector['key']).to eq(5)
               end
             end
 
-            context "when the key is a symbol" do
-
+            context 'when the key is a symbol' do
               before do
-                selector.send(method, :key, "5")
+                selector.send(method, :key, '5')
               end
 
-              it "serializes the value" do
-                expect(selector["key"]).to eq(5)
+              it 'serializes the value' do
+                expect(selector['key']).to eq(5)
               end
             end
           end
 
-          context "when the criterion is complex" do
-
-            context "when the field name is the key" do
-
-              context "when the criterion is an array" do
-
-                context "when the key is a string" do
-
+          context 'when the criterion is complex' do
+            context 'when the field name is the key' do
+              context 'when the criterion is an array' do
+                context 'when the key is a string' do
                   before do
-                    selector.send(method, "key", [ "1", "2" ])
+                    selector.send(method, 'key', %w[1 2])
                   end
 
-                  it "serializes the value" do
-                    expect(selector["key"]).to eq([ 1, 2 ])
+                  it 'serializes the value' do
+                    expect(selector['key']).to eq([ 1, 2 ])
                   end
                 end
 
-                context "when the key is a symbol" do
-
+                context 'when the key is a symbol' do
                   before do
-                    selector.send(method, :key, [ "1", "2" ])
+                    selector.send(method, :key, %w[1 2])
                   end
 
-                  it "serializes the value" do
-                    expect(selector["key"]).to eq([ 1, 2 ])
+                  it 'serializes the value' do
+                    expect(selector['key']).to eq([ 1, 2 ])
                   end
                 end
               end
 
-              context "when the criterion is a hash" do
-
-                context "when the value is non enumerable" do
-
-                  context "when the key is a string" do
-
+              context 'when the criterion is a hash' do
+                context 'when the value is non enumerable' do
+                  context 'when the key is a string' do
                     before do
-                      selector.send(method, "key", { "$gt" => "5" })
+                      selector.send(method, 'key', { '$gt' => '5' })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key"]).to eq({ "$gt" => 5 })
+                    it 'serializes the value' do
+                      expect(selector['key']).to eq({ '$gt' => 5 })
                     end
                   end
 
-                  context "when the key is a symbol" do
-
+                  context 'when the key is a symbol' do
                     before do
-                      selector.send(method, :key, { "$gt" => "5" })
+                      selector.send(method, :key, { '$gt' => '5' })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key"]).to eq({ "$gt" => 5 })
+                    it 'serializes the value' do
+                      expect(selector['key']).to eq({ '$gt' => 5 })
                     end
                   end
                 end
 
-                context "when the value is enumerable" do
-
-                  context "when the key is a string" do
-
+                context 'when the value is enumerable' do
+                  context 'when the key is a string' do
                     before do
-                      selector.send(method, "key", { "$in" => [ "1", "2" ] })
+                      selector.send(method, 'key', { '$in' => %w[1 2] })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key"]).to eq({ "$in" => [ 1, 2 ] })
+                    it 'serializes the value' do
+                      expect(selector['key']).to eq({ '$in' => [ 1, 2 ] })
                     end
                   end
 
-                  context "when the key is a symbol" do
-
+                  context 'when the key is a symbol' do
                     before do
-                      selector.send(method, :key, { "$in" => [ "1", "2" ] })
+                      selector.send(method, :key, { '$in' => %w[1 2] })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key"]).to eq({ "$in" => [ 1, 2 ] })
+                    it 'serializes the value' do
+                      expect(selector['key']).to eq({ '$in' => [ 1, 2 ] })
                     end
                   end
                 end
 
-                [ "$and", "$or" ].each do |operator|
-
+                [ '$and', '$or' ].each do |operator|
                   context "when the criterion is a #{operator}" do
-
-                    context "when the individual criteria are simple" do
-
-                      context "when the keys are strings" do
-
+                    context 'when the individual criteria are simple' do
+                      context 'when the keys are strings' do
                         before do
-                          selector.send(method, operator, [{ "key" => "1" }])
+                          selector.send(method, operator, [ { 'key' => '1' } ])
                         end
 
-                        it "serializes the values" do
-                          expect(selector[operator]).to eq([{ "key" => 1 }])
+                        it 'serializes the values' do
+                          expect(selector[operator]).to eq([ { 'key' => 1 } ])
                         end
                       end
 
-                      context "when the keys are symbols" do
-
+                      context 'when the keys are symbols' do
                         before do
-                          selector.send(method, operator, [{ key: "1" }])
+                          selector.send(method, operator, [ { key: '1' } ])
                         end
 
-                        it "serializes the values" do
-                          expect(selector[operator]).to eq([{ "key" => 1 }])
+                        it 'serializes the values' do
+                          expect(selector[operator]).to eq([ { 'key' => 1 } ])
                         end
                       end
                     end
 
-                    context "when the individual criteria are complex" do
-
-                      context "when the keys are strings" do
-
+                    context 'when the individual criteria are complex' do
+                      context 'when the keys are strings' do
                         before do
                           selector.send(
                             method,
                             operator,
-                            [{ "field" => "1" }, { "key" => { "$gt" => "2" }}]
+                            [ { 'field' => '1' }, { 'key' => { '$gt' => '2' } } ]
                           )
                         end
 
-                        it "serializes the values" do
+                        it 'serializes the values' do
                           expect(selector[operator]).to eq(
-                            [{ "field" => "1" }, { "key" => { "$gt" => 2 }}]
+                            [ { 'field' => '1' }, { 'key' => { '$gt' => 2 } } ]
                           )
                         end
                       end
 
-                      context "when the keys are symbols" do
-
+                      context 'when the keys are symbols' do
                         before do
                           selector.send(
                             method,
                             operator,
-                            [{ field: "1" }, { key: { "$gt" => "2" }}]
+                            [ { field: '1' }, { key: { '$gt' => '2' } } ]
                           )
                         end
 
-                        it "serializes the values" do
+                        it 'serializes the values' do
                           expect(selector[operator]).to eq(
-                            [{ "field" => "1" }, { "key" => { "$gt" => 2 }}]
+                            [ { 'field' => '1' }, { 'key' => { '$gt' => 2 } } ]
                           )
                         end
                       end
@@ -715,60 +651,55 @@ describe Mongoid::Criteria::Queryable::Selector do
                 end
               end
 
-              context "when the criterion is a Mongoid::RawValue" do
-
-                context "and raw_value is a serializable string" do
-
+              context 'when the criterion is a Mongoid::RawValue' do
+                context 'and raw_value is a serializable string' do
                   before do
-                    selector.send(method, "key", Mongoid::RawValue("1"))
+                    selector.send(method, 'key', Mongoid::RawValue('1'))
                   end
 
-                  it "returns the raw_value" do
-                    expect(selector["key"]).to eq("1")
+                  it 'returns the raw_value' do
+                    expect(selector['key']).to eq('1')
                   end
                 end
 
-                context "and raw_value is a serializable type" do
-
+                context 'and raw_value is a serializable type' do
                   before do
-                    selector.send(method, "key", Mongoid::RawValue(BigDecimal('2')))
+                    selector.send(method, 'key', Mongoid::RawValue(BigDecimal('2')))
                   end
 
-                  it "returns the raw_value" do
-                    expect(selector["key"]).to eq(BigDecimal('2'))
+                  it 'returns the raw_value' do
+                    expect(selector['key']).to eq(BigDecimal('2'))
                   end
                 end
 
-                context "and raw_value is a non-serializable string" do
-
+                context 'and raw_value is a non-serializable string' do
                   before do
-                    selector.send(method, "key", Mongoid::RawValue("Foo"))
+                    selector.send(method, 'key', Mongoid::RawValue('Foo'))
                   end
 
-                  it "returns the raw_value" do
-                    expect(selector["key"]).to eq("Foo")
+                  it 'returns the raw_value' do
+                    expect(selector['key']).to eq('Foo')
                   end
                 end
 
-                context "and raw_value cannot be converted by bson-ruby" do
-
+                context 'and raw_value cannot be converted by bson-ruby' do
                   before do
-                    selector.send(method, "key", Mongoid::RawValue(4..5))
+                    selector.send(method, 'key', Mongoid::RawValue(4..5))
                   end
 
-                  it "returns the raw_value without conversion" do
-                    expect(selector["key"]).to eq(4..5)
+                  it 'returns the raw_value without conversion' do
+                    expect(selector['key']).to eq(4..5)
                   end
                 end
 
-                context "and raw_value is a complex type" do
-
+                context 'and raw_value is a complex type' do
                   before do
-                    selector.send(method, "key", Mongoid::RawValue([{ foo: "1", "Bar" => [/baz/, BigDecimal('2'), 4..5] }, 3]))
+                    selector.send(method, 'key',
+                                  Mongoid::RawValue([ { foo: '1', 'Bar' => [ /baz/, BigDecimal('2'), 4..5 ] }, 3 ]))
                   end
 
-                  it "returns the raw_value" do
-                    expect(selector["key"]).to eq([{ foo: "1", "Bar" => [/baz/, BigDecimal('2'), 4..5] }, 3])
+                  it 'returns the raw_value' do
+                    expect(selector['key']).to eq([ { foo: '1', 'Bar' => [ /baz/, BigDecimal('2'), 4..5 ] }, 3 ])
                   end
                 end
               end
@@ -776,7 +707,7 @@ describe Mongoid::Criteria::Queryable::Selector do
           end
         end
 
-        context "when the serializer is localized" do
+        context 'when the serializer is localized' do
           with_default_i18n_configs
 
           before(:all) do
@@ -796,188 +727,165 @@ describe Mongoid::Criteria::Queryable::Selector do
           end
 
           let(:selector) do
-            described_class.new({}, { "key" => Field.new })
+            described_class.new({}, { 'key' => Field.new })
           end
 
           before do
-            ::I18n.locale = :de
+            I18n.locale = :de
           end
 
-          context "when the criterion is simple" do
-
-            context "when the key is a string" do
-
+          context 'when the criterion is simple' do
+            context 'when the key is a string' do
               before do
-                selector.send(method, "key", "5")
+                selector.send(method, 'key', '5')
               end
 
-              it "serializes the value" do
-                expect(selector["key.de"]).to eq(5)
+              it 'serializes the value' do
+                expect(selector['key.de']).to eq(5)
               end
             end
 
-            context "when the key is a symbol" do
-
+            context 'when the key is a symbol' do
               before do
-                selector.send(method, :key, "5")
+                selector.send(method, :key, '5')
               end
 
-              it "serializes the value" do
-                expect(selector["key.de"]).to eq(5)
+              it 'serializes the value' do
+                expect(selector['key.de']).to eq(5)
               end
             end
           end
 
-          context "when the criterion is complex" do
-
-            context "when the field name is the key" do
-
-              context "when the criterion is an array" do
-
-                context "when the key is a string" do
-
+          context 'when the criterion is complex' do
+            context 'when the field name is the key' do
+              context 'when the criterion is an array' do
+                context 'when the key is a string' do
                   before do
-                    selector.send(method, "key", [ "1", "2" ])
+                    selector.send(method, 'key', %w[1 2])
                   end
 
-                  it "serializes the value" do
-                    expect(selector["key.de"]).to eq([ 1, 2 ])
+                  it 'serializes the value' do
+                    expect(selector['key.de']).to eq([ 1, 2 ])
                   end
                 end
 
-                context "when the key is a symbol" do
-
+                context 'when the key is a symbol' do
                   before do
-                    selector.send(method, :key, [ "1", "2" ])
+                    selector.send(method, :key, %w[1 2])
                   end
 
-                  it "serializes the value" do
-                    expect(selector["key.de"]).to eq([ 1, 2 ])
+                  it 'serializes the value' do
+                    expect(selector['key.de']).to eq([ 1, 2 ])
                   end
                 end
               end
 
-              context "when the criterion is a hash" do
-
-                context "when the value is non enumerable" do
-
-                  context "when the key is a string" do
-
+              context 'when the criterion is a hash' do
+                context 'when the value is non enumerable' do
+                  context 'when the key is a string' do
                     let(:hash) do
-                      { "$gt" => "5" }
+                      { '$gt' => '5' }
                     end
 
                     before do
-                      selector.send(method, "key", hash)
+                      selector.send(method, 'key', hash)
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key.de"]).to eq({ "$gt" => 5 })
+                    it 'serializes the value' do
+                      expect(selector['key.de']).to eq({ '$gt' => 5 })
                     end
 
-                    it "sets the same hash instance" do
-                      expect(selector["key.de"]).to equal(hash)
+                    it 'sets the same hash instance' do
+                      expect(selector['key.de']).to equal(hash)
                     end
                   end
 
-                  context "when the key is a symbol" do
-
+                  context 'when the key is a symbol' do
                     before do
-                      selector.send(method, :key, { "$gt" => "5" })
+                      selector.send(method, :key, { '$gt' => '5' })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key.de"]).to eq({ "$gt" => 5 })
+                    it 'serializes the value' do
+                      expect(selector['key.de']).to eq({ '$gt' => 5 })
                     end
                   end
                 end
 
-                context "when the value is enumerable" do
-
-                  context "when the key is a string" do
-
+                context 'when the value is enumerable' do
+                  context 'when the key is a string' do
                     before do
-                      selector.send(method, "key", { "$in" => [ "1", "2" ] })
+                      selector.send(method, 'key', { '$in' => %w[1 2] })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key.de"]).to eq({ "$in" => [ 1, 2 ] })
+                    it 'serializes the value' do
+                      expect(selector['key.de']).to eq({ '$in' => [ 1, 2 ] })
                     end
                   end
 
-                  context "when the key is a symbol" do
-
+                  context 'when the key is a symbol' do
                     before do
-                      selector.send(method, :key, { "$in" => [ "1", "2" ] })
+                      selector.send(method, :key, { '$in' => %w[1 2] })
                     end
 
-                    it "serializes the value" do
-                      expect(selector["key.de"]).to eq({ "$in" => [ 1, 2 ] })
+                    it 'serializes the value' do
+                      expect(selector['key.de']).to eq({ '$in' => [ 1, 2 ] })
                     end
                   end
                 end
 
-                [ "$and", "$or" ].each do |operator|
-
+                [ '$and', '$or' ].each do |operator|
                   context "when the criterion is a #{operator}" do
-
-                    context "when the individual criteria are simple" do
-
-                      context "when the keys are strings" do
-
+                    context 'when the individual criteria are simple' do
+                      context 'when the keys are strings' do
                         before do
-                          selector.send(method, operator, [{ "key" => "1" }])
+                          selector.send(method, operator, [ { 'key' => '1' } ])
                         end
 
-                        it "serializes the values" do
-                          expect(selector[operator]).to eq([{ "key.de" => 1 }])
+                        it 'serializes the values' do
+                          expect(selector[operator]).to eq([ { 'key.de' => 1 } ])
                         end
                       end
 
-                      context "when the keys are symbols" do
-
+                      context 'when the keys are symbols' do
                         before do
-                          selector.send(method, operator, [{ key: "1" }])
+                          selector.send(method, operator, [ { key: '1' } ])
                         end
 
-                        it "serializes the values" do
-                          expect(selector[operator]).to eq([{ "key.de" => 1 }])
+                        it 'serializes the values' do
+                          expect(selector[operator]).to eq([ { 'key.de' => 1 } ])
                         end
                       end
                     end
 
-                    context "when the individual criteria are complex" do
-
-                      context "when the keys are strings" do
-
+                    context 'when the individual criteria are complex' do
+                      context 'when the keys are strings' do
                         before do
                           selector.send(
                             method,
                             operator,
-                            [{ "field" => "1" }, { "key" => { "$gt" => "2" }}]
+                            [ { 'field' => '1' }, { 'key' => { '$gt' => '2' } } ]
                           )
                         end
 
-                        it "serializes the values" do
+                        it 'serializes the values' do
                           expect(selector[operator]).to eq(
-                            [{ "field" => "1" }, { "key.de" => { "$gt" => 2 }}]
+                            [ { 'field' => '1' }, { 'key.de' => { '$gt' => 2 } } ]
                           )
                         end
                       end
 
-                      context "when the keys are symbols" do
-
+                      context 'when the keys are symbols' do
                         before do
                           selector.send(
                             method,
                             operator,
-                            [{ field: "1" }, { key: { "$gt" => "2" }}]
+                            [ { field: '1' }, { key: { '$gt' => '2' } } ]
                           )
                         end
 
-                        it "serializes the values" do
+                        it 'serializes the values' do
                           expect(selector[operator]).to eq(
-                            [{ "field" => "1" }, { "key.de" => { "$gt" => 2 }}]
+                            [ { 'field' => '1' }, { 'key.de' => { '$gt' => 2 } } ]
                           )
                         end
                       end
@@ -992,41 +900,37 @@ describe Mongoid::Criteria::Queryable::Selector do
     end
   end
 
-  describe "#to_pipeline" do
-
+  describe '#to_pipeline' do
     let(:selector) do
       described_class.new
     end
 
-    context "when the selector is empty" do
-
+    context 'when the selector is empty' do
       let(:pipeline) do
         selector.to_pipeline
       end
 
-      it "returns an empty array" do
+      it 'returns an empty array' do
         expect(pipeline).to be_empty
       end
     end
 
-    context "when the selector is not empty" do
-
+    context 'when the selector is not empty' do
       before do
-        selector["name"] = "test"
+        selector['name'] = 'test'
       end
 
       let(:pipeline) do
         selector.to_pipeline
       end
 
-      it "returns the selector in a $match entry" do
-        expect(pipeline).to eq([{ "$match" => { "name" => "test" }}])
+      it 'returns the selector in a $match entry' do
+        expect(pipeline).to eq([ { '$match' => { 'name' => 'test' } } ])
       end
     end
   end
 
   describe '#multi_selection?' do
-
     let(:selector) do
       described_class.new
     end