chewy 0.9.0 → 5.2.0

data/spec/chewy/journal_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Journal do
-  context 'journaling', orm: true do
+  context 'journaling', :orm do
     ['', 'namespace/'].each do |namespace|
       context namespace.present? ? 'with namespace' : 'without namespace' do
         before do
@@ -22,11 +22,6 @@ describe Chewy::Journal do
           end
 
           Chewy.massacre
-          begin
-            Chewy.client.indices.delete(index: Chewy::Journal.index_name)
-          rescue Elasticsearch::Transport::Transport::Errors::NotFound
-            nil
-          end
           Chewy.settings[:prefix] = 'some_prefix'
           Timecop.freeze(time)
         end
@@ -56,115 +51,215 @@ describe Chewy::Journal do
 
             places_index.import
 
-            expect(Chewy.client.indices.exists?(index: Chewy::Journal.index_name)).to eq true
+            expect(Chewy::Stash::Journal.exists?).to eq true
 
             Timecop.freeze(update_time)
-            cities.first.update_attributes!(name: 'Supername')
+            cities.first.update!(name: 'Supername')
 
             Timecop.freeze(destroy_time)
             countries.last.destroy
 
-            journal_records = Chewy.client.search(index: Chewy::Journal.index_name, type: Chewy::Journal.type_name, sort: 'created_at')['hits']['hits'].map { |r| r['_source'] }
-
+            journal_entries = Chewy::Stash::Journal.order(:created_at).hits.map { |r| r['_source'] }
             expected_journal = [
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [1],
-                'created_at' => time.to_i
+                'references' => ['1'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [2],
-                'created_at' => time.to_i
+                'references' => ['2'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [1],
-                'created_at' => time.to_i
+                'references' => ['1'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [2],
-                'created_at' => time.to_i
+                'references' => ['2'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [3],
-                'created_at' => time.to_i
+                'references' => ['3'].map(&Base64.method(:encode64)),
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [1, 2],
-                'created_at' => import_time.to_i
+                'references' => %w[1 2].map(&Base64.method(:encode64)),
+                'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [1, 2, 3],
-                'created_at' => import_time.to_i
+                'references' => %w[1 2 3].map(&Base64.method(:encode64)),
+                'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [1],
-                'created_at' => update_time.to_i
+                'references' => ['1'].map(&Base64.method(:encode64)),
+                'created_at' => update_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'delete',
-                'object_ids' => [2],
-                'created_at' => destroy_time.to_i
+                'references' => ['2'].map(&Base64.method(:encode64)),
+                'created_at' => destroy_time.utc.as_json
               }
             ]
 
-            expect(Chewy.client.count(index: Chewy::Journal.index_name)['count']).to eq 9
-            expect(journal_records).to eq expected_journal
-
-            journal_entries = Chewy::Journal::Entry.since(import_time)
-            expect(journal_entries.length).to eq 4
-            # we have only 2 types, so we can group all journal entries(4) into 2
-            expect(Chewy::Journal::Entry.group(journal_entries)).to eq [
-              Chewy::Journal::Entry.new('index_name' => "#{namespace}places",
-                                        'type_name' => 'city',
-                                        'action' => nil,
-                                        'object_ids' => [1, 2],
-                                        'created_at' => nil),
-              Chewy::Journal::Entry.new('index_name' => "#{namespace}places",
-                                        'type_name' => 'country',
-                                        'action' => 'delete',
-                                        'object_ids' => [1, 2, 3],
-                                        'created_at' => destroy_time.to_i)
-            ]
+            expect(Chewy::Stash::Journal.count).to eq 9
+            expect(journal_entries).to eq expected_journal
+
+            journal_entries = Chewy::Stash::Journal.entries(import_time - 1)
+            expect(journal_entries.size).to eq 4
 
             # simulate lost data
             Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_places", type: 'city', id: 1, refresh: true)
-            expect(places_index::City.all.to_a.length).to eq 1
+            expect(places_index::City.count).to eq 1
+
+            described_class.new.apply(time)
+            expect(places_index::City.count).to eq 2
+
+            clean_response = described_class.new.clean(import_time)
+            expect(clean_response['deleted'] || clean_response['_indices']['_all']['deleted']).to eq 7
+            Chewy.client.indices.refresh
+            expect(Chewy::Stash::Journal.count).to eq 2
+
+            Timecop.return
+          end
+        end
+      end
+    end
+  end
+
+  context do
+    before { Chewy.massacre }
+    before do
+      stub_model(:city) do
+        update_index 'cities', :self
+      end
+      stub_model(:country) do
+        update_index 'countries', :self
+      end
 
-            Chewy::Journal::Apply.since(time)
-            expect(places_index::City.all.to_a.length).to eq 2
+      stub_index(:cities) do
+        define_type City do
+          default_import_options journal: true
+        end
+      end
+      stub_index(:countries) do
+        define_type Country do
+          default_import_options journal: true
+        end
+      end
+    end
 
-            expect(Chewy::Journal::Clean.until(import_time)).to eq 7
-            expect(Chewy.client.count(index: Chewy::Journal.index_name)['count']).to eq 2
+    describe '#apply' do
+      specify { expect(described_class.new(CitiesIndex).apply(2.minutes.ago)).to eq(0) }
+
+      context 'with an index filter' do
+        let(:time) { Time.now }
+
+        before { Timecop.freeze(time) }
+        after { Timecop.return }
+
+        specify do
+          Chewy.strategy(:urgent) do
+            Array.new(2) { |i| City.create!(id: i + 1) }
+            Array.new(2) { |i| Country.create!(id: i + 1) }
 
-            expect(Chewy::Journal.delete!).to be_truthy
-            expect { Chewy::Journal.delete! }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
-            expect(Chewy::Journal.delete).to eq false
-            expect(Chewy::Journal.exists?).to eq false
+            # simulate lost data
+            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: 'countries', type: 'country', id: 1, refresh: true)
+            expect(CitiesIndex.all.to_a.length).to eq 1
+            expect(CountriesIndex.all.to_a.length).to eq 1
+
+            # Replay on specific index
+            expect(described_class.new(CitiesIndex).apply(time)).to eq(2)
+            expect(CitiesIndex.all.to_a.length).to eq 2
+            expect(CountriesIndex.all.to_a.length).to eq 1
+
+            # Replay on both
+            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            expect(CitiesIndex.all.to_a.length).to eq 1
+            expect(described_class.new(CitiesIndex, CountriesIndex).apply(time)).to eq(4)
+            expect(CitiesIndex.all.to_a.length).to eq 2
+            expect(CountriesIndex.all.to_a.length).to eq 2
+          end
+        end
+      end
+
+      context 'retries' do
+        let(:time) { Time.now.to_i }
+        before do
+          Timecop.freeze
+          Chewy.strategy(:urgent)
+          City.create!(id: 1)
+        end
+
+        after do
+          Chewy.strategy.pop
+          Timecop.return
+        end
+
+        specify 'journal was cleaned after the first call' do
+          expect(Chewy::Stash::Journal).to receive(:entries).exactly(2).and_call_original
+          expect(described_class.new.apply(time)).to eq(1)
+        end
+
+        context 'endless journal' do
+          let(:count_of_checks) { 10 } # default
+          let!(:journal_entries) do
+            record = Chewy::Stash::Journal.entries(time).first
+            Array.new(count_of_checks) do |i|
+              Chewy::Stash::Journal::Journal.new(
+                record.attributes.merge(
+                  'created_at' => time.to_i + i,
+                  'references' => [i.to_s]
+                )
+              )
+            end
+          end
+
+          specify '10 retries by default' do
+            expect(Chewy::Stash::Journal)
+              .to receive(:entries).exactly(count_of_checks) { [journal_entries.shift].compact }
+            expect(described_class.new.apply(time)).to eq(10)
+          end
+
+          specify 'with :once parameter set' do
+            expect(Chewy::Stash::Journal)
+              .to receive(:entries).exactly(1) { [journal_entries.shift].compact }
+            expect(described_class.new.apply(time, retries: 1)).to eq(1)
+          end
+
+          context 'with retries parameter set' do
+            let(:retries) { 5 }
+
+            specify do
+              expect(Chewy::Stash::Journal)
+                .to receive(:entries).exactly(retries) { [journal_entries.shift].compact }
+              expect(described_class.new.apply(time, retries: retries)).to eq(5)
+            end
           end
         end
       end

data/spec/chewy/minitest/helpers_spec.rb

@@ -28,7 +28,7 @@ describe :minitest_helper do
     specify 'doesn\'t fail when index updates correctly' do
       expect do
         assert_indexes DummiesIndex::Dummy do
-          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
         end
       end.to_not raise_error
     end
@@ -42,7 +42,7 @@ describe :minitest_helper do
 
     specify 'SearchIndexReceiver catches the indexes' do
       receiver = assert_indexes DummiesIndex::Dummy do
-        DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
 
       expect(receiver).to be_a(SearchIndexReceiver)
@@ -57,7 +57,7 @@ describe :minitest_helper do
       expect(DummiesIndex::Dummy).not_to receive(:bulk)
 
       assert_indexes DummiesIndex::Dummy do
-        DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
     end
 
@@ -65,7 +65,7 @@ describe :minitest_helper do
       expect(DummiesIndex::Dummy).to receive(:bulk)
 
       assert_indexes DummiesIndex::Dummy, bypass_actual_index: false do
-        DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
     end
   end

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -5,7 +5,7 @@ describe :search_index_receiver do
   def search_request(item_count = 2, verb: :index)
     items = Array.new(item_count) do |i|
       {
-        verb => { _id: i + 1, data: {} }
+        verb => {_id: i + 1, data: {}}
       }
     end
 

data/spec/chewy/query/criteria_spec.rb

@@ -46,10 +46,10 @@ describe Chewy::Query::Criteria do
   describe '#update_scores' do
     specify { expect { subject.update_scores(:score) }.to change { subject.scores? }.to(true) }
     specify { expect { subject.update_scores(:score) }.to change { subject.scores }.to([:score]) }
-    specify { expect { subject.update_scores([:score, :score2]) }.to change { subject.scores }.to([:score, :score2]) }
+    specify { expect { subject.update_scores(%i[score score2]) }.to change { subject.scores }.to(%i[score score2]) }
     specify do
-      expect { subject.tap { |s| s.update_scores(:score1) }.update_scores([:score2, :score3]) }
-        .to change { subject.scores }.to([:score1, :score2, :score3])
+      expect { subject.tap { |s| s.update_scores(:score1) }.update_scores(%i[score2 score3]) }
+        .to change { subject.scores }.to(%i[score1 score2 score3])
     end
   end
 
@@ -60,12 +60,12 @@ describe Chewy::Query::Criteria do
 
   describe '#update_script_fields' do
     specify do
-      expect { subject.update_script_fields(distance: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }) }
+      expect { subject.update_script_fields(distance: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
         .to change { subject.script_fields? }.to(true)
     end
     specify do
-      expect { subject.update_script_fields(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" }) }
-        .to change { subject.script_fields }.to(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" })
+      expect { subject.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }
+        .to change { subject.script_fields }.to(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"})
     end
   end
 
@@ -83,43 +83,43 @@ describe Chewy::Query::Criteria do
         subject.update_queries(field: 'hello')
         subject.update_queries(field: 'world')
       end
-        .to change { subject.queries }.to([{ field: 'hello' }, { field: 'world' }])
+        .to change { subject.queries }.to([{field: 'hello'}, {field: 'world'}])
     end
     specify do
-      expect { subject.update_queries([{ field: 'hello' }, { field: 'world' }, nil]) }
-        .to change { subject.queries }.to([{ field: 'hello' }, { field: 'world' }])
+      expect { subject.update_queries([{field: 'hello'}, {field: 'world'}, nil]) }
+        .to change { subject.queries }.to([{field: 'hello'}, {field: 'world'}])
     end
   end
 
   describe '#update_filters' do
     specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters? }.to(true) }
-    specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters }.to([{ field: 'hello' }]) }
+    specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters }.to([{field: 'hello'}]) }
     specify do
       expect do
         subject.update_filters(field: 'hello')
         subject.update_filters(field: 'world')
       end
-        .to change { subject.filters }.to([{ field: 'hello' }, { field: 'world' }])
+        .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}])
     end
     specify do
-      expect { subject.update_filters([{ field: 'hello' }, { field: 'world' }, nil]) }
-        .to change { subject.filters }.to([{ field: 'hello' }, { field: 'world' }])
+      expect { subject.update_filters([{field: 'hello'}, {field: 'world'}, nil]) }
+        .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}])
     end
   end
 
   describe '#update_post_filters' do
     specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters? }.to(true) }
-    specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters }.to([{ field: 'hello' }]) }
+    specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters }.to([{field: 'hello'}]) }
     specify do
       expect do
         subject.update_post_filters(field: 'hello')
         subject.update_post_filters(field: 'world')
       end
-        .to change { subject.post_filters }.to([{ field: 'hello' }, { field: 'world' }])
+        .to change { subject.post_filters }.to([{field: 'hello'}, {field: 'world'}])
     end
     specify do
-      expect { subject.update_post_filters([{ field: 'hello' }, { field: 'world' }, nil]) }
-        .to change { subject.post_filters }.to([{ field: 'hello' }, { field: 'world' }])
+      expect { subject.update_post_filters([{field: 'hello'}, {field: 'world'}, nil]) }
+        .to change { subject.post_filters }.to([{field: 'hello'}, {field: 'world'}])
     end
   end
 
@@ -134,78 +134,78 @@ describe Chewy::Query::Criteria do
         .to change { subject.sort }.to([:field])
     end
     specify do
-      expect { subject.update_sort([:field1, :field2]) }
-        .to change { subject.sort }.to([:field1, :field2])
+      expect { subject.update_sort(%i[field1 field2]) }
+        .to change { subject.sort }.to(%i[field1 field2])
     end
     specify do
-      expect { subject.update_sort([{ field: :asc }]) }
-        .to change { subject.sort }.to([{ field: :asc }])
+      expect { subject.update_sort([{field: :asc}]) }
+        .to change { subject.sort }.to([{field: :asc}])
     end
     specify do
-      expect { subject.update_sort([:field1, field2: { order: :asc }]) }
-        .to change { subject.sort }.to([:field1, { field2: { order: :asc } }])
+      expect { subject.update_sort([:field1, field2: {order: :asc}]) }
+        .to change { subject.sort }.to([:field1, {field2: {order: :asc}}])
     end
     specify do
-      expect { subject.update_sort([{ field1: { order: :asc } }, :field2]) }
-        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2])
+      expect { subject.update_sort([{field1: {order: :asc}}, :field2]) }
+        .to change { subject.sort }.to([{field1: {order: :asc}}, :field2])
     end
     specify do
-      expect { subject.update_sort([field1: :asc, field2: { order: :asc }]) }
-        .to change { subject.sort }.to([{ field1: :asc }, { field2: { order: :asc } }])
+      expect { subject.update_sort([field1: :asc, field2: {order: :asc}]) }
+        .to change { subject.sort }.to([{field1: :asc}, {field2: {order: :asc}}])
     end
     specify do
-      expect { subject.update_sort([{ field1: { order: :asc } }, :field2, :field3]) }
-        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2, :field3])
+      expect { subject.update_sort([{field1: {order: :asc}}, :field2, :field3]) }
+        .to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3])
     end
     specify do
-      expect { subject.update_sort([{ field1: { order: :asc } }, [:field2, :field3]]) }
-        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2, :field3])
+      expect { subject.update_sort([{field1: {order: :asc}}, %i[field2 field3]]) }
+        .to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3])
     end
     specify do
-      expect { subject.update_sort([{ field1: { order: :asc } }, [:field2], :field3]) }
-        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2, :field3])
+      expect { subject.update_sort([{field1: {order: :asc}}, [:field2], :field3]) }
+        .to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3])
     end
     specify do
-      expect { subject.update_sort([{ field1: { order: :asc }, field2: :desc }, [:field3], :field4]) }
-        .to change { subject.sort }.to([{ field1: { order: :asc } }, { field2: :desc }, :field3, :field4])
+      expect { subject.update_sort([{field1: {order: :asc}, field2: :desc}, [:field3], :field4]) }
+        .to change { subject.sort }.to([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4])
     end
     specify do
-      expect { subject.tap { |s| s.update_sort([field1: { order: :asc }, field2: :desc]) }.update_sort([[:field3], :field4]) }
-        .to change { subject.sort }.to([{ field1: { order: :asc } }, { field2: :desc }, :field3, :field4])
+      expect { subject.tap { |s| s.update_sort([field1: {order: :asc}, field2: :desc]) }.update_sort([[:field3], :field4]) }
+        .to change { subject.sort }.to([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4])
     end
     specify do
-      expect { subject.tap { |s| s.update_sort([field1: { order: :asc }, field2: :desc]) }.update_sort([[:field3], :field4], purge: true) }
-        .to change { subject.sort }.to([:field3, :field4])
+      expect { subject.tap { |s| s.update_sort([field1: {order: :asc}, field2: :desc]) }.update_sort([[:field3], :field4], purge: true) }
+        .to change { subject.sort }.to(%i[field3 field4])
     end
   end
 
   describe '#update_fields' do
     specify { expect { subject.update_fields(:field) }.to change { subject.fields? }.to(true) }
     specify { expect { subject.update_fields(:field) }.to change { subject.fields }.to(['field']) }
-    specify { expect { subject.update_fields([:field, :field]) }.to change { subject.fields }.to(['field']) }
-    specify { expect { subject.update_fields([:field1, :field2]) }.to change { subject.fields }.to(%w(field1 field2)) }
+    specify { expect { subject.update_fields(%i[field field]) }.to change { subject.fields }.to(['field']) }
+    specify { expect { subject.update_fields(%i[field1 field2]) }.to change { subject.fields }.to(%w[field1 field2]) }
     specify do
-      expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3]) }
-        .to change { subject.fields }.to(%w(field1 field2 field3))
+      expect { subject.tap { |s| s.update_fields(:field1) }.update_fields(%i[field2 field3]) }
+        .to change { subject.fields }.to(%w[field1 field2 field3])
     end
     specify do
-      expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3], purge: true) }
-        .to change { subject.fields }.to(%w(field2 field3))
+      expect { subject.tap { |s| s.update_fields(:field1) }.update_fields(%i[field2 field3], purge: true) }
+        .to change { subject.fields }.to(%w[field2 field3])
     end
   end
 
   describe '#update_types' do
     specify { expect { subject.update_types(:type) }.to change { subject.types? }.to(true) }
     specify { expect { subject.update_types(:type) }.to change { subject.types }.to(['type']) }
-    specify { expect { subject.update_types([:type, :type]) }.to change { subject.types }.to(['type']) }
-    specify { expect { subject.update_types([:type1, :type2]) }.to change { subject.types }.to(%w(type1 type2)) }
+    specify { expect { subject.update_types(%i[type type]) }.to change { subject.types }.to(['type']) }
+    specify { expect { subject.update_types(%i[type1 type2]) }.to change { subject.types }.to(%w[type1 type2]) }
     specify do
-      expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3]) }
-        .to change { subject.types }.to(%w(type1 type2 type3))
+      expect { subject.tap { |s| s.update_types(:type1) }.update_types(%i[type2 type3]) }
+        .to change { subject.types }.to(%w[type1 type2 type3])
     end
     specify do
-      expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3], purge: true) }
-        .to change { subject.types }.to(%w(type2 type3))
+      expect { subject.tap { |s| s.update_types(:type1) }.update_types(%i[type2 type3], purge: true) }
+        .to change { subject.types }.to(%w[type2 type3])
     end
   end
 
@@ -231,14 +231,14 @@ describe Chewy::Query::Criteria do
         .to eq(field1: 'hello')
     end
     specify do
-      expect(subject.tap { |c| c.update_script_fields(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }) }
-        .merge(criteria.tap { |c| c.update_script_fields(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" }) }).script_fields)
-        .to eq(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }, distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" })
+      expect(subject.tap { |c| c.update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
+        .merge(criteria.tap { |c| c.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }).script_fields)
+        .to eq(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}, distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"})
     end
     specify do
       expect(subject.tap { |c| c.update_scores(script: 'hello') }
         .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores)
-        .to eq([{ script: 'hello' }, { script: 'foobar' }])
+        .to eq([{script: 'hello'}, {script: 'foobar'}])
     end
     specify do
       expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
@@ -248,29 +248,29 @@ describe Chewy::Query::Criteria do
     specify do
       expect(subject.tap { |c| c.update_queries(field1: 'hello') }
         .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries)
-        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+        .to eq([{field1: 'hello'}, {field2: 'hello'}])
     end
     specify do
       expect(subject.tap { |c| c.update_filters(field1: 'hello') }
         .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters)
-        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+        .to eq([{field1: 'hello'}, {field2: 'hello'}])
     end
     specify do
       expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
         .merge(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters)
-        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+        .to eq([{field1: 'hello'}, {field2: 'hello'}])
     end
     specify do
       expect(subject.tap { |c| c.update_sort(:field1) }
-        .merge(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq([:field1, :field2])
+        .merge(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq(%i[field1 field2])
     end
     specify do
       expect(subject.tap { |c| c.update_fields(:field1) }
-        .merge(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(%w(field1 field2))
+        .merge(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(%w[field1 field2])
     end
     specify do
       expect(subject.tap { |c| c.update_types(:type1) }
-        .merge(criteria.tap { |c| c.update_types(:type2) }).types).to eq(%w(type1 type2))
+        .merge(criteria.tap { |c| c.update_types(:type2) }).types).to eq(%w[type1 type2])
     end
   end
 
@@ -296,9 +296,9 @@ describe Chewy::Query::Criteria do
         .to eq(field1: 'hello')
     end
     specify do
-      expect(subject.tap { |c| c.update_script_fields(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }) }
-        .merge(criteria.tap { |c| c.update_script_fields(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" }) }).script_fields)
-        .to eq(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }, distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" })
+      expect(subject.tap { |c| c.update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
+        .merge(criteria.tap { |c| c.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }).script_fields)
+        .to eq(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}, distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"})
     end
     specify do
       expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
@@ -308,32 +308,32 @@ describe Chewy::Query::Criteria do
     specify do
       expect(subject.tap { |c| c.update_queries(field1: 'hello') }
         .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries)
-        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+        .to eq([{field1: 'hello'}, {field2: 'hello'}])
     end
     specify do
       expect(subject.tap { |c| c.update_filters(field1: 'hello') }
         .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters)
-        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+        .to eq([{field1: 'hello'}, {field2: 'hello'}])
     end
     specify do
       expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
         .merge!(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters)
-        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+        .to eq([{field1: 'hello'}, {field2: 'hello'}])
     end
     specify do
       expect(subject.tap { |c| c.update_sort(:field1) }
         .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort)
-        .to eq([:field1, :field2])
+        .to eq(%i[field1 field2])
     end
     specify do
       expect(subject.tap { |c| c.update_fields(:field1) }
         .merge!(criteria.tap { |c| c.update_fields(:field2) }).fields)
-        .to eq(%w(field1 field2))
+        .to eq(%w[field1 field2])
     end
     specify do
       expect(subject.tap { |c| c.update_types(:type1) }
         .merge!(criteria.tap { |c| c.update_types(:type2) }).types)
-        .to eq(%w(type1 type2))
+        .to eq(%w[type1 type2])
     end
   end
 
@@ -344,30 +344,30 @@ describe Chewy::Query::Criteria do
     end
 
     specify { expect(request_body).to eq(body: {}) }
-    specify { expect(request_body { update_request_options(size: 10) }).to eq(body: { size: 10 }) }
-    specify { expect(request_body { update_request_options(from: 10) }).to eq(body: { from: 10 }) }
-    specify { expect(request_body { update_request_options(explain: true) }).to eq(body: { explain: true }) }
-    specify { expect(request_body { update_queries(:query) }).to eq(body: { query: :query }) }
+    specify { expect(request_body { update_request_options(size: 10) }).to eq(body: {size: 10}) }
+    specify { expect(request_body { update_request_options(from: 10) }).to eq(body: {from: 10}) }
+    specify { expect(request_body { update_request_options(explain: true) }).to eq(body: {explain: true}) }
+    specify { expect(request_body { update_queries(:query) }).to eq(body: {query: :query}) }
     specify do
       expect(request_body do
-               update_scores(script_score: { script: '_score' })
-             end).to eq(body: { query: { function_score: { functions: [{ script_score: { script: '_score' } }] } } }) end
+               update_scores(script_score: {script: '_score'})
+             end).to eq(body: {query: {function_score: {functions: [{script_score: {script: '_score'}}]}}}) end
     specify do
       expect(request_body do
-               update_scores(script_score: { script: 'boost_me' })
+               update_scores(script_score: {script: 'boost_me'})
                update_queries(:query)
                update_options(boost_mode: :add)
                update_options(score_mode: :avg)
-             end).to eq(body: { query: {
-                          function_score: {
-                            functions: [{
-                              script_score: { script: 'boost_me' }
-                            }],
-                            query: :query,
-                            boost_mode: :add,
-                            score_mode: :avg
-                          }
-                        } })
+             end).to eq(body: {query: {
+               function_score: {
+                 functions: [{
+                   script_score: {script: 'boost_me'}
+                 }],
+                 query: :query,
+                 boost_mode: :add,
+                 score_mode: :avg
+               }
+             }})
     end
     specify do
       expect(request_body do
@@ -375,22 +375,22 @@ describe Chewy::Query::Criteria do
                update_sort(:field)
                update_fields(:field)
                update_queries(:query)
-             end).to eq(body: { query: :query, from: 10, sort: [:field], _source: ['field'] }) end
+             end).to eq(body: {query: :query, from: 10, sort: [:field], _source: ['field']}) end
 
     specify do
       expect(request_body do
                update_queries(:query)
                update_filters(:filters)
-             end).to eq(body: { query: { filtered: { query: :query, filter: :filters } } }) end
+             end).to eq(body: {query: {filtered: {query: :query, filter: :filters}}}) end
     specify do
       expect(request_body do
                update_queries(:query)
                update_post_filters(:post_filter)
-             end).to eq(body: { query: :query, post_filter: :post_filter }) end
+             end).to eq(body: {query: :query, post_filter: :post_filter}) end
     specify do
       expect(request_body do
-               update_script_fields(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" })
-             end).to eq(body: { script_fields: { distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" } } }) end
+               update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"})
+             end).to eq(body: {script_fields: {distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}}}) end
   end
 
   describe '#_filtered_query' do
@@ -403,64 +403,64 @@ describe Chewy::Query::Criteria do
     specify { expect(_filtered_query { update_queries(:query) }).to eq(query: :query) }
     specify { expect(_filtered_query(strategy: 'query_first') { update_queries(:query) }).to eq(query: :query) }
     specify do
-      expect(_filtered_query { update_queries([:query1, :query2]) })
-        .to eq(query: { bool: { must: [:query1, :query2] } })
+      expect(_filtered_query { update_queries(%i[query1 query2]) })
+        .to eq(query: {bool: {must: %i[query1 query2]}})
     end
     specify do
       expect(_filtered_query do
         update_options(query_mode: :should)
-        update_queries([:query1, :query2])
+        update_queries(%i[query1 query2])
       end)
-        .to eq(query: { bool: { should: [:query1, :query2] } })
+        .to eq(query: {bool: {should: %i[query1 query2]}})
     end
     specify do
       expect(_filtered_query do
         update_options(query_mode: :dis_max)
-        update_queries([:query1, :query2])
+        update_queries(%i[query1 query2])
       end)
-        .to eq(query: { dis_max: { queries: [:query1, :query2] } })
+        .to eq(query: {dis_max: {queries: %i[query1 query2]}})
     end
 
     specify do
-      expect(_filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]) })
-        .to eq(query: { filtered: { query: { match_all: {} }, filter: { and: [:filter1, :filter2] }, strategy: 'query_first' } })
+      expect(_filtered_query(strategy: 'query_first') { update_filters(%i[filter1 filter2]) })
+        .to eq(query: {filtered: {query: {match_all: {}}, filter: {and: %i[filter1 filter2]}, strategy: 'query_first'}})
     end
     specify do
-      expect(_filtered_query { update_filters([:filter1, :filter2]) })
-        .to eq(query: { filtered: { query: { match_all: {} }, filter: { and: [:filter1, :filter2] } } })
+      expect(_filtered_query { update_filters(%i[filter1 filter2]) })
+        .to eq(query: {filtered: {query: {match_all: {}}, filter: {and: %i[filter1 filter2]}}})
     end
 
     specify do
       expect(_filtered_query do
-        update_filters([:filter1, :filter2])
-        update_queries([:query1, :query2])
+        update_filters(%i[filter1 filter2])
+        update_queries(%i[query1 query2])
       end)
-        .to eq(query: { filtered: {
-                 query: { bool: { must: [:query1, :query2] } },
-                 filter: { and: [:filter1, :filter2] }
-               } })
+        .to eq(query: {filtered: {
+          query: {bool: {must: %i[query1 query2]}},
+          filter: {and: %i[filter1 filter2]}
+        }})
     end
     specify do
       expect(_filtered_query(strategy: 'query_first') do
-        update_filters([:filter1, :filter2])
-        update_queries([:query1, :query2])
+        update_filters(%i[filter1 filter2])
+        update_queries(%i[query1 query2])
       end)
-        .to eq(query: { filtered: {
-                 query: { bool: { must: [:query1, :query2] } },
-                 filter: { and: [:filter1, :filter2] },
-                 strategy: 'query_first'
-               } })
+        .to eq(query: {filtered: {
+          query: {bool: {must: %i[query1 query2]}},
+          filter: {and: %i[filter1 filter2]},
+          strategy: 'query_first'
+        }})
     end
     specify do
       expect(_filtered_query do
                update_options(query_mode: :should)
                update_options(filter_mode: :or)
-               update_filters([:filter1, :filter2])
-               update_queries([:query1, :query2])
-             end).to eq(query: { filtered: {
-                          query: { bool: { should: [:query1, :query2] } },
-                          filter: { or: [:filter1, :filter2] }
-                        } })
+               update_filters(%i[filter1 filter2])
+               update_queries(%i[query1 query2])
+             end).to eq(query: {filtered: {
+               query: {bool: {should: %i[query1 query2]}},
+               filter: {or: %i[filter1 filter2]}
+             }})
     end
   end
 
@@ -472,19 +472,19 @@ describe Chewy::Query::Criteria do
     specify do
       subject.update_scores(boost_factor: 5)
       expect(subject.send(:_boost_query, query: :query))
-        .to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query } })
+        .to eq(query: {function_score: {functions: [{boost_factor: 5}], query: :query}})
     end
     specify do
       subject.update_scores(boost_factor: 5)
       subject.update_options(boost_mode: :multiply)
       subject.update_options(score_mode: :add)
       expect(subject.send(:_boost_query, query: :query))
-        .to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query, boost_mode: :multiply, score_mode: :add } })
+        .to eq(query: {function_score: {functions: [{boost_factor: 5}], query: :query, boost_mode: :multiply, score_mode: :add}})
     end
     specify do
       subject.update_scores(boost_factor: 5)
       expect(subject.send(:_boost_query, query: :query, filter: :filter))
-        .to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: { filtered: { query: :query, filter: :filter } } } })
+        .to eq(query: {function_score: {functions: [{boost_factor: 5}], query: {filtered: {query: :query, filter: :filter}}}})
     end
   end
 
@@ -496,83 +496,83 @@ describe Chewy::Query::Criteria do
 
     specify { expect(_request_filter).to be_nil }
 
-    specify { expect(_request_filter { update_types(:type) }).to eq(type: { value: 'type' }) }
+    specify { expect(_request_filter { update_types(:type) }).to eq(type: {value: 'type'}) }
     specify do
-      expect(_request_filter { update_types([:type1, :type2]) })
-        .to eq(or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }])
+      expect(_request_filter { update_types(%i[type1 type2]) })
+        .to eq(or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}])
     end
 
     specify do
-      expect(_request_filter { update_filters([:filter1, :filter2]) })
-        .to eq(and: [:filter1, :filter2])
+      expect(_request_filter { update_filters(%i[filter1 filter2]) })
+        .to eq(and: %i[filter1 filter2])
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :or)
-        update_filters([:filter1, :filter2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(or: [:filter1, :filter2])
+        .to eq(or: %i[filter1 filter2])
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :must)
-        update_filters([:filter1, :filter2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(bool: { must: [:filter1, :filter2] })
+        .to eq(bool: {must: %i[filter1 filter2]})
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :should)
-        update_filters([:filter1, :filter2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(bool: { should: [:filter1, :filter2] })
+        .to eq(bool: {should: %i[filter1 filter2]})
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :must_not)
-        update_filters([:filter1, :filter2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(bool: { must_not: [:filter1, :filter2] })
+        .to eq(bool: {must_not: %i[filter1 filter2]})
     end
 
     specify do
       expect(_request_filter do
-        update_types([:type1, :type2])
-        update_filters([:filter1, :filter2])
+        update_types(%i[type1 type2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, :filter1, :filter2])
+        .to eq(and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, :filter1, :filter2])
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :or)
-        update_types([:type1, :type2])
-        update_filters([:filter1, :filter2])
+        update_types(%i[type1 type2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { or: [:filter1, :filter2] }])
+        .to eq(and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {or: %i[filter1 filter2]}])
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :must)
-        update_types([:type1, :type2])
-        update_filters([:filter1, :filter2])
+        update_types(%i[type1 type2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { bool: { must: [:filter1, :filter2] } }])
+        .to eq(and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must: %i[filter1 filter2]}}])
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :should)
-        update_types([:type1, :type2])
-        update_filters([:filter1, :filter2])
+        update_types(%i[type1 type2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { bool: { should: [:filter1, :filter2] } }])
+        .to eq(and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {should: %i[filter1 filter2]}}])
     end
     specify do
       expect(_request_filter do
         update_options(filter_mode: :must_not)
-        update_types([:type1, :type2])
-        update_filters([:filter1, :filter2])
+        update_types(%i[type1 type2])
+        update_filters(%i[filter1 filter2])
       end)
-        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { bool: { must_not: [:filter1, :filter2] } }])
+        .to eq(and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must_not: %i[filter1 filter2]}}])
     end
   end
 
@@ -585,37 +585,37 @@ describe Chewy::Query::Criteria do
     specify { expect(_request_post_filter).to be_nil }
 
     specify do
-      expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
-        .to eq(and: [:post_filter1, :post_filter2])
+      expect(_request_post_filter { update_post_filters(%i[post_filter1 post_filter2]) })
+        .to eq(and: %i[post_filter1 post_filter2])
     end
     specify do
       expect(_request_post_filter do
         update_options(post_filter_mode: :or)
-        update_post_filters([:post_filter1, :post_filter2])
+        update_post_filters(%i[post_filter1 post_filter2])
       end)
-        .to eq(or: [:post_filter1, :post_filter2])
+        .to eq(or: %i[post_filter1 post_filter2])
     end
     specify do
       expect(_request_post_filter do
         update_options(post_filter_mode: :must)
-        update_post_filters([:post_filter1, :post_filter2])
+        update_post_filters(%i[post_filter1 post_filter2])
       end)
-        .to eq(bool: { must: [:post_filter1, :post_filter2] })
+        .to eq(bool: {must: %i[post_filter1 post_filter2]})
     end
     specify do
       expect(_request_post_filter do
         update_options(post_filter_mode: :should)
-        update_post_filters([:post_filter1, :post_filter2])
+        update_post_filters(%i[post_filter1 post_filter2])
       end)
-        .to eq(bool: { should: [:post_filter1, :post_filter2] })
+        .to eq(bool: {should: %i[post_filter1 post_filter2]})
     end
 
     context do
       before { allow(Chewy).to receive_messages(filter_mode: :or) }
 
       specify do
-        expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
-          .to eq(or: [:post_filter1, :post_filter2])
+        expect(_request_post_filter { update_post_filters(%i[post_filter1 post_filter2]) })
+          .to eq(or: %i[post_filter1 post_filter2])
       end
     end
   end
@@ -627,10 +627,10 @@ describe Chewy::Query::Criteria do
     end
 
     specify { expect(_request_types).to be_nil }
-    specify { expect(_request_types { update_types(:type1) }).to eq(type: { value: 'type1' }) }
+    specify { expect(_request_types { update_types(:type1) }).to eq(type: {value: 'type1'}) }
     specify do
-      expect(_request_types { update_types([:type1, :type2]) })
-        .to eq(or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }])
+      expect(_request_types { update_types(%i[type1 type2]) })
+        .to eq(or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}])
     end
   end
 
@@ -639,31 +639,31 @@ describe Chewy::Query::Criteria do
       subject.send(:_queries_join, *args)
     end
 
-    let(:query) { { term: { field: 'value' } } }
+    let(:query) { {term: {field: 'value'}} }
 
     specify { expect(_queries_join([], :dis_max)).to be_nil }
     specify { expect(_queries_join([query], :dis_max)).to eq(query) }
-    specify { expect(_queries_join([query, query], :dis_max)).to eq(dis_max: { queries: [query, query] }) }
+    specify { expect(_queries_join([query, query], :dis_max)).to eq(dis_max: {queries: [query, query]}) }
 
     specify { expect(_queries_join([], 0.7)).to be_nil }
     specify { expect(_queries_join([query], 0.7)).to eq(query) }
-    specify { expect(_queries_join([query, query], 0.7)).to eq(dis_max: { queries: [query, query], tie_breaker: 0.7 }) }
+    specify { expect(_queries_join([query, query], 0.7)).to eq(dis_max: {queries: [query, query], tie_breaker: 0.7}) }
 
     specify { expect(_queries_join([], :must)).to be_nil }
     specify { expect(_queries_join([query], :must)).to eq(query) }
-    specify { expect(_queries_join([query, query], :must)).to eq(bool: { must: [query, query] }) }
+    specify { expect(_queries_join([query, query], :must)).to eq(bool: {must: [query, query]}) }
 
     specify { expect(_queries_join([], :should)).to be_nil }
     specify { expect(_queries_join([query], :should)).to eq(query) }
-    specify { expect(_queries_join([query, query], :should)).to eq(bool: { should: [query, query] }) }
+    specify { expect(_queries_join([query, query], :should)).to eq(bool: {should: [query, query]}) }
 
     specify { expect(_queries_join([], :must_not)).to be_nil }
-    specify { expect(_queries_join([query], :must_not)).to eq(bool: { must_not: [query] }) }
-    specify { expect(_queries_join([query, query], :must_not)).to eq(bool: { must_not: [query, query] }) }
+    specify { expect(_queries_join([query], :must_not)).to eq(bool: {must_not: [query]}) }
+    specify { expect(_queries_join([query, query], :must_not)).to eq(bool: {must_not: [query, query]}) }
 
     specify { expect(_queries_join([], '25%')).to be_nil }
     specify { expect(_queries_join([query], '25%')).to eq(query) }
-    specify { expect(_queries_join([query, query], '25%')).to eq(bool: { should: [query, query], minimum_should_match: '25%' }) }
+    specify { expect(_queries_join([query, query], '25%')).to eq(bool: {should: [query, query], minimum_should_match: '25%'}) }
   end
 
   describe '#_filters_join' do
@@ -671,7 +671,7 @@ describe Chewy::Query::Criteria do
       subject.send(:_filters_join, *args)
     end
 
-    let(:filter) { { term: { field: 'value' } } }
+    let(:filter) { {term: {field: 'value'}} }
 
     specify { expect(_filters_join([], :and)).to be_nil }
     specify { expect(_filters_join([filter], :and)).to eq(filter) }
@@ -683,18 +683,18 @@ describe Chewy::Query::Criteria do
 
     specify { expect(_filters_join([], :must)).to be_nil }
     specify { expect(_filters_join([filter], :must)).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], :must)).to eq(bool: { must: [filter, filter] }) }
+    specify { expect(_filters_join([filter, filter], :must)).to eq(bool: {must: [filter, filter]}) }
 
     specify { expect(_filters_join([], :should)).to be_nil }
     specify { expect(_filters_join([filter], :should)).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], :should)).to eq(bool: { should: [filter, filter] }) }
+    specify { expect(_filters_join([filter, filter], :should)).to eq(bool: {should: [filter, filter]}) }
 
     specify { expect(_filters_join([], :must_not)).to be_nil }
-    specify { expect(_filters_join([filter], :must_not)).to eq(bool: { must_not: [filter] }) }
-    specify { expect(_filters_join([filter, filter], :must_not)).to eq(bool: { must_not: [filter, filter] }) }
+    specify { expect(_filters_join([filter], :must_not)).to eq(bool: {must_not: [filter]}) }
+    specify { expect(_filters_join([filter, filter], :must_not)).to eq(bool: {must_not: [filter, filter]}) }
 
     specify { expect(_filters_join([], '25%')).to be_nil }
     specify { expect(_filters_join([filter], '25%')).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], '25%')).to eq(bool: { should: [filter, filter], minimum_should_match: '25%' }) }
+    specify { expect(_filters_join([filter, filter], '25%')).to eq(bool: {should: [filter, filter], minimum_should_match: '25%'}) }
   end
 end