chewy 0.9.0 → 0.10.0

data/spec/chewy/query/filters_spec.rb

@@ -9,7 +9,7 @@ describe Chewy::Query::Filters do
     end
   end
 
-  %w(field group and or not raw exists missing prefix regexp range equal query script).each do |method|
+  %w[field group and or not raw exists missing prefix regexp range equal query script].each do |method|
     define_method method.camelize do |*args|
       "Chewy::Query::Nodes::#{method.camelize}".constantize.new(*args)
     end
@@ -38,19 +38,19 @@ describe Chewy::Query::Filters do
   context 'term' do
     specify { expect(query { email == 'email' }).to be_eql Equal(:email, 'email') }
     specify { expect(query { name != 'name' }).to be_eql Not(Equal(:name, 'name')) }
-    specify { expect(query { email == %w(email1 email2) }).to be_eql Equal(:email, %w(email1 email2)) }
-    specify { expect(query { email != %w(email1 email2) }).to be_eql Not(Equal(:email, %w(email1 email2))) }
+    specify { expect(query { email == %w[email1 email2] }).to be_eql Equal(:email, %w[email1 email2]) }
+    specify { expect(query { email != %w[email1 email2] }).to be_eql Not(Equal(:email, %w[email1 email2])) }
     specify do
-      expect(query { email(execution: :bool) == %w(email1 email2) })
-        .to be_eql Equal(:email, %w(email1 email2), execution: :bool)
+      expect(query { email(execution: :bool) == %w[email1 email2] })
+        .to be_eql Equal(:email, %w[email1 email2], execution: :bool)
     end
     specify do
-      expect(query { email(:bool) == %w(email1 email2) })
-        .to be_eql Equal(:email, %w(email1 email2), execution: :bool)
+      expect(query { email(:bool) == %w[email1 email2] })
+        .to be_eql Equal(:email, %w[email1 email2], execution: :bool)
     end
     specify do
-      expect(query { email(:b) == %w(email1 email2) })
-        .to be_eql Equal(:email, %w(email1 email2), execution: :bool)
+      expect(query { email(:b) == %w[email1 email2] })
+        .to be_eql Equal(:email, %w[email1 email2], execution: :bool)
     end
   end
 
@@ -117,7 +117,7 @@ describe Chewy::Query::Filters do
     specify { expect(query { name == /name/ }).to be_eql Regexp(:name, 'name') }
     specify { expect(query { name !~ /name/ }).to be_eql Not(Regexp(:name, 'name')) }
     specify { expect(query { name != /name/ }).to be_eql Not(Regexp(:name, 'name')) }
-    specify { expect(query { name(:anystring, :intersection) =~ /name/ }).to be_eql Regexp(:name, 'name', flags: %w(anystring intersection)) }
+    specify { expect(query { name(:anystring, :intersection) =~ /name/ }).to be_eql Regexp(:name, 'name', flags: %w[anystring intersection]) }
   end
 
   context 'query' do
@@ -128,10 +128,10 @@ describe Chewy::Query::Filters do
   end
 
   context 'raw' do
-    let(:raw_query) { { term: { name: 'name' } } }
-    specify { expect(query { r(term: { name: 'name' }) }).to be_eql Raw(term: { name: 'name' }) }
-    specify { expect(query { r { { term: { name: 'name' } } } }).to be_eql Raw(term: { name: 'name' }) }
-    specify { expect(query { r { raw_query } }).to be_eql Raw(term: { name: 'name' }) }
+    let(:raw_query) { {term: {name: 'name'}} }
+    specify { expect(query { r(term: {name: 'name'}) }).to be_eql Raw(term: {name: 'name'}) }
+    specify { expect(query { r { {term: {name: 'name'}} } }).to be_eql Raw(term: {name: 'name'}) }
+    specify { expect(query { r { raw_query } }).to be_eql Raw(term: {name: 'name'}) }
   end
 
   context 'script' do
@@ -151,7 +151,7 @@ describe Chewy::Query::Filters do
       expect(query { (email == 'email') | (name == 'name') })
         .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name'))
     end
-    specify { expect(query { !(email == 'email') }).to be_eql Not(Equal(:email, 'email')) }
+    specify { expect(query { email != 'email' }).to be_eql Not(Equal(:email, 'email')) }
 
     specify do
       expect(query { (email == 'email') & (name == 'name') | (address != 'address') })

data/spec/chewy/query/loading_spec.rb

@@ -24,46 +24,48 @@ describe Chewy::Query::Loading, :orm do
       end
     end
 
+    let(:subject) { Chewy::Query.new(PlacesIndex) }
+
     before { PlacesIndex.import!(cities: cities, countries: countries) }
 
     describe '#load' do
-      specify { expect(PlacesIndex.order(:rating).limit(6).load.total_count).to eq(12) }
-      specify { expect(PlacesIndex.order(:rating).limit(6).load).to match_array(cities.first(3) + countries.first(3)) }
+      specify { expect(subject.order(:rating).limit(6).load.total_count).to eq(12) }
+      specify { expect(subject.order(:rating).limit(6).load).to match_array(cities.first(3) + countries.first(3)) }
 
       context 'mongoid', :mongoid do
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: -> { where(:rating.lt => 2) } }))
+          expect(subject.order(:rating).limit(6).load(city: {scope: -> { where(:rating.lt => 2) }}))
             .to match_array(cities.first(2) + countries.first(3) + [nil])
         end
         specify do
-          expect(PlacesIndex.limit(6).load(city: { scope: -> { where(:rating.lt => 2) } }).order(:rating))
+          expect(subject.limit(6).load(city: {scope: -> { where(:rating.lt => 2) }}).order(:rating))
             .to match_array(cities.first(2) + countries.first(3) + [nil])
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).load(scope: -> { where(:rating.lt => 2) }))
+          expect(subject.order(:rating).limit(6).load(scope: -> { where(:rating.lt => 2) }))
             .to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where(:rating.lt => 2) }))
+          expect(subject.order(:rating).limit(6).load(city: {scope: City.where(:rating.lt => 2)}))
             .to match_array(cities.first(2) + countries.first(3) + [nil])
         end
       end
 
       context 'active record', :active_record do
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: -> { where('rating < 2') } }))
+          expect(subject.order(:rating).limit(6).load(city: {scope: -> { where('rating < 2') }}))
             .to match_array(cities.first(2) + countries.first(3) + [nil])
         end
         specify do
-          expect(PlacesIndex.limit(6).load(city: { scope: -> { where('rating < 2') } }).order(:rating))
+          expect(subject.limit(6).load(city: {scope: -> { where('rating < 2') }}).order(:rating))
             .to match_array(cities.first(2) + countries.first(3) + [nil])
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).load(scope: -> { where('rating < 2') }))
+          expect(subject.order(:rating).limit(6).load(scope: -> { where('rating < 2') }))
             .to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') }))
+          expect(subject.order(:rating).limit(6).load(city: {scope: City.where('rating < 2')}))
             .to match_array(cities.first(2) + countries.first(3) + [nil])
         end
       end
@@ -72,48 +74,48 @@ describe Chewy::Query::Loading, :orm do
     describe '#preload' do
       context 'mongoid', :mongoid do
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(scope: -> { where(:rating.lt => 2) })
+          expect(subject.order(:rating).limit(6).preload(scope: -> { where(:rating.lt => 2) })
           .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
         end
         specify do
-          expect(PlacesIndex.limit(6).preload(scope: -> { where(:rating.lt => 2) }).order(:rating)
+          expect(subject.limit(6).preload(scope: -> { where(:rating.lt => 2) }).order(:rating)
           .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
         end
 
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: -> { where(:rating.lt => 2) })
+          expect(subject.order(:rating).limit(6).preload(only: :city, scope: -> { where(:rating.lt => 2) })
           .map(&:_object)).to match_array(cities.first(2) + [nil] * 4)
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: -> { where(:rating.lt => 2) })
+          expect(subject.order(:rating).limit(6).preload(except: [:city], scope: -> { where(:rating.lt => 2) })
           .map(&:_object)).to match_array(countries.first(2) + [nil] * 4)
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where(:rating.lt => 2) })
+          expect(subject.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where(:rating.lt => 2) })
           .map(&:_object)).to match_array([nil] * 6)
         end
       end
 
       context 'active record', :active_record do
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(scope: -> { where('rating < 2') })
+          expect(subject.order(:rating).limit(6).preload(scope: -> { where('rating < 2') })
           .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
         end
         specify do
-          expect(PlacesIndex.limit(6).preload(scope: -> { where('rating < 2') }).order(:rating)
+          expect(subject.limit(6).preload(scope: -> { where('rating < 2') }).order(:rating)
           .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2)
         end
 
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: -> { where('rating < 2') })
+          expect(subject.order(:rating).limit(6).preload(only: :city, scope: -> { where('rating < 2') })
           .map(&:_object)).to match_array(cities.first(2) + [nil] * 4)
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: -> { where('rating < 2') })
+          expect(subject.order(:rating).limit(6).preload(except: [:city], scope: -> { where('rating < 2') })
           .map(&:_object)).to match_array(countries.first(2) + [nil] * 4)
         end
         specify do
-          expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where('rating < 2') })
+          expect(subject.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where('rating < 2') })
           .map(&:_object)).to match_array([nil] * 6)
         end
       end

data/spec/chewy/query/nodes/and_spec.rb

@@ -6,7 +6,7 @@ describe Chewy::Query::Nodes::And do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { name? & (email == 'email') }).to eq(and: [{ exists: { field: 'name' } }, { term: { 'email' => 'email' } }]) }
-    specify { expect(render { ~(name? & (email == 'email')) }).to eq(and: { filters: [{ exists: { field: 'name' } }, { term: { 'email' => 'email' } }], _cache: true }) }
+    specify { expect(render { name? & (email == 'email') }).to eq(and: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]) }
+    specify { expect(render { ~(name? & (email == 'email')) }).to eq(and: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}) }
   end
 end

data/spec/chewy/query/nodes/bool_spec.rb

@@ -6,9 +6,9 @@ describe Chewy::Query::Nodes::Bool do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { must(name == 'name', email == 'email') }).to eq(bool: { must: [{ term: { 'name' => 'name' } }, { term: { 'email' => 'email' } }] }) }
-    specify { expect(render { must(name == 'name').must_not(email == 'email') }).to eq(bool: { must: [{ term: { 'name' => 'name' } }], must_not: [{ term: { 'email' => 'email' } }] }) }
-    specify { expect(render { must(name == 'name').should(email == 'email') }).to eq(bool: { must: [{ term: { 'name' => 'name' } }], should: [{ term: { 'email' => 'email' } }] }) }
-    specify { expect(render { ~must(name == 'name').should(email == 'email') }).to eq(bool: { must: [{ term: { 'name' => 'name' } }], should: [{ term: { 'email' => 'email' } }], _cache: true }) }
+    specify { expect(render { must(name == 'name', email == 'email') }).to eq(bool: {must: [{term: {'name' => 'name'}}, {term: {'email' => 'email'}}]}) }
+    specify { expect(render { must(name == 'name').must_not(email == 'email') }).to eq(bool: {must: [{term: {'name' => 'name'}}], must_not: [{term: {'email' => 'email'}}]}) }
+    specify { expect(render { must(name == 'name').should(email == 'email') }).to eq(bool: {must: [{term: {'name' => 'name'}}], should: [{term: {'email' => 'email'}}]}) }
+    specify { expect(render { ~must(name == 'name').should(email == 'email') }).to eq(bool: {must: [{term: {'name' => 'name'}}], should: [{term: {'email' => 'email'}}], _cache: true}) }
   end
 end

data/spec/chewy/query/nodes/equal_spec.rb

@@ -6,27 +6,27 @@ describe Chewy::Query::Nodes::Equal do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { name == 'name' }).to eq(term: { 'name' => 'name' }) }
-    specify { expect(render { name != 'name' }).to eq(not: { term: { 'name' => 'name' } }) }
-    specify { expect(render { name == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2) }) }
-    specify { expect(render { name != %w(name1 name2) }).to eq(not: { terms: { 'name' => %w(name1 name2) } }) }
+    specify { expect(render { name == 'name' }).to eq(term: {'name' => 'name'}) }
+    specify { expect(render { name != 'name' }).to eq(not: {term: {'name' => 'name'}}) }
+    specify { expect(render { name == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2]}) }
+    specify { expect(render { name != %w[name1 name2] }).to eq(not: {terms: {'name' => %w[name1 name2]}}) }
 
-    specify { expect(render { name(:bool) == 'name' }).to eq(term: { 'name' => 'name' }) }
-    specify { expect(render { name(:borogoves) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2) }) }
+    specify { expect(render { name(:bool) == 'name' }).to eq(term: {'name' => 'name'}) }
+    specify { expect(render { name(:borogoves) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2]}) }
 
-    specify { expect(render { name(:|) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :or }) }
-    specify { expect(render { name(:or) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :or }) }
-    specify { expect(render { name(:&) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :and }) }
-    specify { expect(render { name(:and) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :and }) }
-    specify { expect(render { name(:b) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :bool }) }
-    specify { expect(render { name(:bool) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :bool }) }
-    specify { expect(render { name(:f) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :fielddata }) }
-    specify { expect(render { name(:fielddata) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :fielddata }) }
+    specify { expect(render { name(:|) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :or}) }
+    specify { expect(render { name(:or) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :or}) }
+    specify { expect(render { name(:&) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :and}) }
+    specify { expect(render { name(:and) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :and}) }
+    specify { expect(render { name(:b) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :bool}) }
+    specify { expect(render { name(:bool) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :bool}) }
+    specify { expect(render { name(:f) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :fielddata}) }
+    specify { expect(render { name(:fielddata) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :fielddata}) }
 
-    specify { expect(render { ~name == 'name' }).to eq(term: { 'name' => 'name', _cache: true }) }
-    specify { expect(render { ~(name == 'name') }).to eq(term: { 'name' => 'name', _cache: true }) }
-    specify { expect(render { ~name != 'name' }).to eq(not: { term: { 'name' => 'name', _cache: true } }) }
-    specify { expect(render { ~name(:|) == %w(name1 name2) }).to eq(terms: { 'name' => %w(name1 name2), execution: :or, _cache: true }) }
-    specify { expect(render { ~name != %w(name1 name2) }).to eq(not: { terms: { 'name' => %w(name1 name2), _cache: true } }) }
+    specify { expect(render { ~name == 'name' }).to eq(term: {'name' => 'name', _cache: true}) }
+    specify { expect(render { ~(name == 'name') }).to eq(term: {'name' => 'name', _cache: true}) }
+    specify { expect(render { ~name != 'name' }).to eq(not: {term: {'name' => 'name', _cache: true}}) }
+    specify { expect(render { ~name(:|) == %w[name1 name2] }).to eq(terms: {'name' => %w[name1 name2], execution: :or, _cache: true}) }
+    specify { expect(render { ~name != %w[name1 name2] }).to eq(not: {terms: {'name' => %w[name1 name2], _cache: true}}) }
   end
 end

data/spec/chewy/query/nodes/exists_spec.rb

@@ -6,13 +6,13 @@ describe Chewy::Query::Nodes::Exists do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { name? }).to eq(exists: { field: 'name' }) }
+    specify { expect(render { name? }).to eq(exists: {field: 'name'}) }
 
-    specify { expect(render { !!name? }).to eq(exists: { field: 'name' }) }
-    specify { expect(render { !!name }).to eq(exists: { field: 'name' }) }
-    specify { expect(render { name != nil }).to eq(exists: { field: 'name' }) } # rubocop:disable Style/NonNilCheck
-    specify { expect(render { !name.nil? }).to eq(exists: { field: 'name' }) }
+    specify { expect(render { !!name? }).to eq(exists: {field: 'name'}) }
+    specify { expect(render { !!name }).to eq(exists: {field: 'name'}) }
+    specify { expect(render { name != nil }).to eq(exists: {field: 'name'}) } # rubocop:disable Style/NonNilCheck
+    specify { expect(render { !name.nil? }).to eq(exists: {field: 'name'}) }
 
-    specify { expect(render { ~name? }).to eq(exists: { field: 'name' }) }
+    specify { expect(render { ~name? }).to eq(exists: {field: 'name'}) }
   end
 end

data/spec/chewy/query/nodes/has_child_spec.rb

@@ -6,45 +6,45 @@ describe Chewy::Query::Nodes::HasChild do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { has_child('child') }).to eq(has_child: { type: 'child' }) }
+    specify { expect(render { has_child('child') }).to eq(has_child: {type: 'child'}) }
 
     specify do
-      expect(render { has_child('child').filter(term: { name: 'name' }) })
-        .to eq(has_child: { type: 'child', filter: { term: { name: 'name' } } })
+      expect(render { has_child('child').filter(term: {name: 'name'}) })
+        .to eq(has_child: {type: 'child', filter: {term: {name: 'name'}}})
     end
     specify do
       expect(render { has_child('child').filter { name == 'name' } })
-        .to eq(has_child: { type: 'child', filter: { term: { 'name' => 'name' } } })
+        .to eq(has_child: {type: 'child', filter: {term: {'name' => 'name'}}})
     end
     specify do
-      expect(render { has_child('child').filter(term: { name: 'name' }).filter { age < 42 } })
-        .to eq(has_child: { type: 'child', filter: { and: [{ term: { name: 'name' } }, range: { 'age' => { lt: 42 } }] } })
+      expect(render { has_child('child').filter(term: {name: 'name'}).filter { age < 42 } })
+        .to eq(has_child: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}})
     end
     specify do
-      expect(render { has_child('child').filter(term: { name: 'name' }).filter { age < 42 }.filter_mode(:or) })
-        .to eq(has_child: { type: 'child', filter: { or: [{ term: { name: 'name' } }, range: { 'age' => { lt: 42 } }] } })
+      expect(render { has_child('child').filter(term: {name: 'name'}).filter { age < 42 }.filter_mode(:or) })
+        .to eq(has_child: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}})
     end
 
     specify do
-      expect(render { has_child('child').query(match: { name: 'name' }) })
-        .to eq(has_child: { type: 'child', query: { match: { name: 'name' } } })
+      expect(render { has_child('child').query(match: {name: 'name'}) })
+        .to eq(has_child: {type: 'child', query: {match: {name: 'name'}}})
     end
     specify do
-      expect(render { has_child('child').query(match: { name: 'name' }).query(match: { surname: 'surname' }) })
-        .to eq(has_child: { type: 'child', query: { bool: { must: [{ match: { name: 'name' } }, { match: { surname: 'surname' } }] } } })
+      expect(render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) })
+        .to eq(has_child: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}})
     end
     specify do
-      expect(render { has_child('child').query(match: { name: 'name' }).query(match: { surname: 'surname' }).query_mode(:should) })
-        .to eq(has_child: { type: 'child', query: { bool: { should: [{ match: { name: 'name' } }, { match: { surname: 'surname' } }] } } })
+      expect(render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) })
+        .to eq(has_child: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}})
     end
 
     specify do
-      expect(render { has_child('child').filter { name == 'name' }.query(match: { name: 'name' }) })
-        .to eq(has_child: { type: 'child', query: { filtered: { query: { match: { name: 'name' } }, filter: { term: { 'name' => 'name' } } } } })
+      expect(render { has_child('child').filter { name == 'name' }.query(match: {name: 'name'}) })
+        .to eq(has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}})
     end
     specify do
-      expect(render { has_child('child').filter { name == 'name' }.query(match: { name: 'name' }).filter { age < 42 } })
-        .to eq(has_child: { type: 'child', query: { filtered: { query: { match: { name: 'name' } }, filter: { and: [{ term: { 'name' => 'name' } }, range: { 'age' => { lt: 42 } }] } } } })
+      expect(render { has_child('child').filter { name == 'name' }.query(match: {name: 'name'}).filter { age < 42 } })
+        .to eq(has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}})
     end
 
     context do
@@ -52,7 +52,7 @@ describe Chewy::Query::Nodes::HasChild do
 
       specify do
         expect(render { has_child('child').filter { name == o { name } } })
-          .to eq(has_child: { type: 'child', filter: { term: { 'name' => 'Name' } } })
+          .to eq(has_child: {type: 'child', filter: {term: {'name' => 'Name'}}})
       end
     end
   end

data/spec/chewy/query/nodes/has_parent_spec.rb

@@ -6,45 +6,45 @@ describe Chewy::Query::Nodes::HasParent do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { has_parent('child') }).to eq(has_parent: { type: 'child' }) }
+    specify { expect(render { has_parent('child') }).to eq(has_parent: {type: 'child'}) }
 
     specify do
-      expect(render { has_parent('child').filter(term: { name: 'name' }) })
-        .to eq(has_parent: { type: 'child', filter: { term: { name: 'name' } } })
+      expect(render { has_parent('child').filter(term: {name: 'name'}) })
+        .to eq(has_parent: {type: 'child', filter: {term: {name: 'name'}}})
     end
     specify do
       expect(render { has_parent('child').filter { name == 'name' } })
-        .to eq(has_parent: { type: 'child', filter: { term: { 'name' => 'name' } } })
+        .to eq(has_parent: {type: 'child', filter: {term: {'name' => 'name'}}})
     end
     specify do
-      expect(render { has_parent('child').filter(term: { name: 'name' }).filter { age < 42 } })
-        .to eq(has_parent: { type: 'child', filter: { and: [{ term: { name: 'name' } }, range: { 'age' => { lt: 42 } }] } })
+      expect(render { has_parent('child').filter(term: {name: 'name'}).filter { age < 42 } })
+        .to eq(has_parent: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}})
     end
     specify do
-      expect(render { has_parent('child').filter(term: { name: 'name' }).filter { age < 42 }.filter_mode(:or) })
-        .to eq(has_parent: { type: 'child', filter: { or: [{ term: { name: 'name' } }, range: { 'age' => { lt: 42 } }] } })
+      expect(render { has_parent('child').filter(term: {name: 'name'}).filter { age < 42 }.filter_mode(:or) })
+        .to eq(has_parent: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}})
     end
 
     specify do
-      expect(render { has_parent('child').query(match: { name: 'name' }) })
-        .to eq(has_parent: { type: 'child', query: { match: { name: 'name' } } })
+      expect(render { has_parent('child').query(match: {name: 'name'}) })
+        .to eq(has_parent: {type: 'child', query: {match: {name: 'name'}}})
     end
     specify do
-      expect(render { has_parent('child').query(match: { name: 'name' }).query(match: { surname: 'surname' }) })
-        .to eq(has_parent: { type: 'child', query: { bool: { must: [{ match: { name: 'name' } }, { match: { surname: 'surname' } }] } } })
+      expect(render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) })
+        .to eq(has_parent: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}})
     end
     specify do
-      expect(render { has_parent('child').query(match: { name: 'name' }).query(match: { surname: 'surname' }).query_mode(:should) })
-        .to eq(has_parent: { type: 'child', query: { bool: { should: [{ match: { name: 'name' } }, { match: { surname: 'surname' } }] } } })
+      expect(render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) })
+        .to eq(has_parent: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}})
     end
 
     specify do
-      expect(render { has_parent('child').filter { name == 'name' }.query(match: { name: 'name' }) })
-        .to eq(has_parent: { type: 'child', query: { filtered: { query: { match: { name: 'name' } }, filter: { term: { 'name' => 'name' } } } } })
+      expect(render { has_parent('child').filter { name == 'name' }.query(match: {name: 'name'}) })
+        .to eq(has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}})
     end
     specify do
-      expect(render { has_parent('child').filter { name == 'name' }.query(match: { name: 'name' }).filter { age < 42 } })
-        .to eq(has_parent: { type: 'child', query: { filtered: { query: { match: { name: 'name' } }, filter: { and: [{ term: { 'name' => 'name' } }, range: { 'age' => { lt: 42 } }] } } } })
+      expect(render { has_parent('child').filter { name == 'name' }.query(match: {name: 'name'}).filter { age < 42 } })
+        .to eq(has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}})
     end
 
     context do
@@ -52,7 +52,7 @@ describe Chewy::Query::Nodes::HasParent do
 
       specify do
         expect(render { has_parent('child').filter { name == o { name } } })
-          .to eq(has_parent: { type: 'child', filter: { term: { 'name' => 'Name' } } })
+          .to eq(has_parent: {type: 'child', filter: {term: {'name' => 'Name'}}})
       end
     end
   end

data/spec/chewy/query/nodes/missing_spec.rb

@@ -6,11 +6,11 @@ describe Chewy::Query::Nodes::Missing do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { !name }).to eq(missing: { field: 'name', existence: true, null_value: false }) }
-    specify { expect(render { !name? }).to eq(missing: { field: 'name', existence: true, null_value: true }) }
-    specify { expect(render { name == nil }).to eq(missing: { field: 'name', existence: false, null_value: true }) } # rubocop:disable Style/NilComparison
-    specify { expect(render { name.nil? }).to eq(missing: { field: 'name', existence: false, null_value: true }) }
+    specify { expect(render { !name }).to eq(missing: {field: 'name', existence: true, null_value: false}) }
+    specify { expect(render { !name? }).to eq(missing: {field: 'name', existence: true, null_value: true}) }
+    specify { expect(render { name == nil }).to eq(missing: {field: 'name', existence: false, null_value: true}) } # rubocop:disable Style/NilComparison
+    specify { expect(render { name.nil? }).to eq(missing: {field: 'name', existence: false, null_value: true}) }
 
-    specify { expect(render { ~!name }).to eq(missing: { field: 'name', existence: true, null_value: false }) }
+    specify { expect(render { ~!name }).to eq(missing: {field: 'name', existence: true, null_value: false}) }
   end
 end

data/spec/chewy/query/nodes/not_spec.rb

@@ -6,7 +6,8 @@ describe Chewy::Query::Nodes::Not do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { !(email == 'email') }).to eq(not: { term: { 'email' => 'email' } }) }
-    specify { expect(render { ~!(email == 'email') }).to eq(not: { filter: { term: { 'email' => 'email' } }, _cache: true }) }
+    # rubocop:disable Style/InverseMethods
+    specify { expect(render { !(email == 'email') }).to eq(not: {term: {'email' => 'email'}}) }
+    specify { expect(render { ~!(email == 'email') }).to eq(not: {filter: {term: {'email' => 'email'}}, _cache: true}) }
   end
 end