chewy 0.8.4 → 5.1.0

data/spec/chewy/query/filters_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Query::Filters do
-  def Bool options
+  def Bool(options) # rubocop:disable Naming/MethodName
     Chewy::Query::Nodes::Bool.new.tap do |bool|
       bool.must(*options[:must]) if options[:must].present?
       bool.must_not(*options[:must_not]) if options[:must_not].present?
@@ -9,27 +9,27 @@ 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
+      "Chewy::Query::Nodes::#{method.camelize}".constantize.new(*args)
     end
   end
 
-  def query &block
+  def query(&block)
     Chewy::Query::Filters.new(&block).__result__
   end
 
   context 'outer scope' do
     let(:email) { 'email' }
     specify { expect(query { email }).to be_eql Field(:email) }
-    specify { expect(query { o{email} }).to eq('email') }
+    specify { expect(query { o { email } }).to eq('email') }
   end
 
   context 'field' do
     let(:email) { 'email' }
     specify { expect(query { f(:email) }).to be_eql Field(:email) }
-    specify { expect(query { f{ :email } }).to be_eql Field(:email) }
-    specify { expect(query { f{ email } }).to be_eql Field(:email) }
+    specify { expect(query { f { :email } }).to be_eql Field(:email) }
+    specify { expect(query { f { email } }).to be_eql Field(:email) }
     specify { expect(query { email }).to be_eql Field(:email) }
     specify { expect(query { emails.first }).to be_eql Field('emails.first') }
     specify { expect(query { emails.first.second }).to be_eql Field('emails.first.second') }
@@ -38,28 +38,36 @@ 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 == ['email1', 'email2'] }).to be_eql Equal(:email, ['email1', 'email2']) }
-    specify { expect(query { email != ['email1', 'email2'] }).to be_eql Not(Equal(:email, ['email1', 'email2'])) }
-    specify { expect(query { email(execution: :bool) == ['email1', 'email2'] })
-      .to be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
-    specify { expect(query { email(:bool) == ['email1', 'email2'] })
-      .to be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
-    specify { expect(query { email(:b) == ['email1', 'email2'] })
-      .to be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+    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)
+    end
+    specify do
+      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)
+    end
   end
 
   context 'bool' do
     specify { query { must(email == 'email') }.should be_eql Bool(must: [Equal(:email, 'email')]) }
     specify { query { must_not(email == 'email') }.should be_eql Bool(must_not: [Equal(:email, 'email')]) }
     specify { query { should(email == 'email') }.should be_eql Bool(should: [Equal(:email, 'email')]) }
-    specify { query {
-      must(email == 'email').should(address != 'address', age == 42)
-      .must_not(sex == 'm').must(name == 'name')
-    }.should be_eql Bool(
-      must: [Equal(:email, 'email'), Equal(:name, 'name')],
-      must_not: [Equal(:sex, 'm')],
-      should: [Not(Equal(:address, 'address')), Equal(:age, 42)]
-    ) }
+    specify do
+      query do
+        must(email == 'email').should(address != 'address', age == 42)
+          .must_not(sex == 'm').must(name == 'name')
+      end.should be_eql Bool(
+        must: [Equal(:email, 'email'), Equal(:name, 'name')],
+        must_not: [Equal(:sex, 'm')],
+        should: [Not(Equal(:address, 'address')), Equal(:age, 42)]
+      )
+    end
   end
 
   context 'exists' do
@@ -67,8 +75,10 @@ describe Chewy::Query::Filters do
     specify { expect(query { !!email? }).to be_eql Exists(:email) }
     specify { expect(query { emails.first? }).to be_eql Exists('emails.first') }
     specify { expect(query { !!emails.first? }).to be_eql Exists('emails.first') }
-    specify { expect(query { emails != nil }).to be_eql Exists('emails') }
-    specify { expect(query { !(emails == nil) }).to be_eql Exists('emails') }
+    specify { expect(query { emails != nil }).to be_eql Exists('emails') } # rubocop:disable Style/NonNilCheck
+    specify { expect(query { emails.first != nil }).to be_eql Exists('emails.first') } # rubocop:disable Style/NonNilCheck
+    specify { expect(query { !emails.nil? }).to be_eql Exists('emails') }
+    specify { expect(query { !emails.first.nil? }).to be_eql Exists('emails.first') }
   end
 
   context 'missing' do
@@ -76,8 +86,10 @@ describe Chewy::Query::Filters do
     specify { expect(query { !email? }).to be_eql Missing(:email, null_value: true) }
     specify { expect(query { !emails.first }).to be_eql Missing('emails.first') }
     specify { expect(query { !emails.first? }).to be_eql Missing('emails.first', null_value: true) }
-    specify { expect(query { emails == nil }).to be_eql Missing('emails', existence: false, null_value: true) }
-    specify { expect(query { emails.first == nil }).to be_eql Missing('emails.first', existence: false, null_value: true) }
+    specify { expect(query { emails == nil }).to be_eql Missing('emails', existence: false, null_value: true) } # rubocop:disable Style/NilComparison
+    specify { expect(query { emails.first == nil }).to be_eql Missing('emails.first', existence: false, null_value: true) } # rubocop:disable Style/NilComparison
+    specify { expect(query { emails.nil? }).to be_eql Missing('emails', existence: false, null_value: true) }
+    specify { expect(query { emails.first.nil? }).to be_eql Missing('emails.first', existence: false, null_value: true) }
   end
 
   context 'range' do
@@ -105,69 +117,85 @@ 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
     let(:some_query) { 'some query' }
     specify { expect(query { q('some query') }).to be_eql Query('some query') }
-    specify { expect(query { q{'some query'} }).to be_eql Query('some query') }
-    specify { expect(query { q{ some_query } }).to be_eql Query('some query') }
+    specify { expect(query { q { 'some query' } }).to be_eql Query('some query') }
+    specify { expect(query { q { some_query } }).to be_eql Query('some query') }
   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'}) }
+    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
     let(:some_script) { 'some script' }
     specify { expect(query { s('some script') }).to be_eql Script('some script') }
     specify { expect(query { s('some script', param1: 42) }).to be_eql Script('some script', param1: 42) }
-    specify { expect(query { s{'some script'} }).to be_eql Script('some script') }
+    specify { expect(query { s { 'some script' } }).to be_eql Script('some script') }
     specify { expect(query { s(param1: 42) { some_script } }).to be_eql Script('some script', param1: 42) }
   end
 
   context 'and or not' do
-    specify { expect(query { (email == 'email') & (name == 'name') })
-      .to be_eql And(Equal(:email, 'email'), Equal(:name, 'name')) }
-    specify { expect(query { (email == 'email') | (name == 'name') })
-      .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
-    specify { expect(query { !(email == 'email') }).to be_eql Not(Equal(:email, 'email')) }
-
-    specify { expect(query { (email == 'email') & (name == 'name') | (address != 'address') })
-      .to be_eql Or(
-        And(
+    specify do
+      expect(query { (email == 'email') & (name == 'name') })
+        .to be_eql And(Equal(:email, 'email'), Equal(:name, 'name'))
+    end
+    specify 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 do
+      expect(query { (email == 'email') & (name == 'name') | (address != 'address') })
+        .to be_eql Or(
+          And(
+            Equal(:email, 'email'),
+            Equal(:name, 'name')
+          ),
+          Not(Equal(:address, 'address'))
+        )
+    end
+    specify do
+      expect(query { (email == 'email') & ((name == 'name') | (address != 'address')) })
+        .to be_eql And(
+          Equal(:email, 'email'),
+          Or(
+            Equal(:name, 'name'),
+            Not(Equal(:address, 'address'))
+          )
+        )
+    end
+    specify do
+      expect(query { (email == 'email') & ((name == 'name') & (address != 'address')) })
+        .to be_eql And(
           Equal(:email, 'email'),
-          Equal(:name, 'name')
-        ),
-        Not(Equal(:address, 'address'))
-      ) }
-    specify { expect(query { (email == 'email') & ((name == 'name') | (address != 'address')) })
-      .to be_eql And(
-        Equal(:email, 'email'),
-        Or(
           Equal(:name, 'name'),
-          Not(Equal(:address, 'address')),
+          Not(Equal(:address, 'address'))
         )
-      ) }
-    specify { expect(query { (email == 'email') & ((name == 'name') & (address != 'address')) })
-      .to be_eql And(
-        Equal(:email, 'email'),
-        Equal(:name, 'name'),
-        Not(Equal(:address, 'address')),
-      ) }
-    specify { expect(query { ((email == 'email') | (name == 'name')) | (address != 'address') })
-      .to be_eql Or(
-        Equal(:email, 'email'),
-        Equal(:name, 'name'),
-        Not(Equal(:address, 'address')),
-      ) }
-    specify { expect(query { !((email == 'email') | (name == 'name')) })
-      .to be_eql Not(Or(Equal(:email, 'email'), Equal(:name, 'name'))) }
-    specify { expect(query { !!((email == 'email') | (name == 'name')) })
-      .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
+    end
+    specify do
+      expect(query { ((email == 'email') | (name == 'name')) | (address != 'address') })
+        .to be_eql Or(
+          Equal(:email, 'email'),
+          Equal(:name, 'name'),
+          Not(Equal(:address, 'address'))
+        )
+    end
+    specify do
+      expect(query { !((email == 'email') | (name == 'name')) })
+        .to be_eql Not(Or(Equal(:email, 'email'), Equal(:name, 'name')))
+    end
+    specify do
+      expect(query { !!((email == 'email') | (name == 'name')) })
+        .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name'))
+    end
   end
 end

data/spec/chewy/query/loading_spec.rb

@@ -9,77 +9,115 @@ describe Chewy::Query::Loading, :orm do
   end
 
   context 'multiple types' do
-    let(:cities) { 6.times.map { |i| City.create!(rating: i) } }
-    let(:countries) { 6.times.map { |i| Country.create!(rating: i) } }
+    let(:cities) { Array.new(6) { |i| City.create!(rating: i) } }
+    let(:countries) { Array.new(6) { |i| Country.create!(rating: i) } }
 
     before do
       stub_index(:places) do
         define_type City do
-          field :rating, type: 'integer', value: ->(o){ o.rating }
+          field :rating, type: 'integer', value: ->(o) { o.rating }
         end
 
         define_type Country do
-          field :rating, type: 'integer', value: ->(o){ o.rating }
+          field :rating, type: 'integer', value: ->(o) { o.rating }
         end
       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 { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where(:rating.lt => 2) } }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.limit(6).load(city: { scope: ->{ where(:rating.lt => 2) } }).order(:rating))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(scope: ->{ where(:rating.lt => 2) }))
-          .to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where(:rating.lt => 2) }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+        specify do
+          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(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(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(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 { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.limit(6).load(city: { scope: ->{ where('rating < 2') } }).order(:rating))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') }))
-          .to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') }))
-          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+        specify do
+          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(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(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(subject.order(:rating).limit(6).load(city: {scope: City.where('rating < 2')}))
+            .to match_array(cities.first(2) + countries.first(3) + [nil])
+        end
       end
     end
 
     describe '#preload' do
       context 'mongoid', :mongoid do
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.limit(6).preload(scope: ->{ where(:rating.lt => 2) }).order(:rating)
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+        specify do
+          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(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 { expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where(:rating.lt => 2) })
-          .map(&:_object)).to match_array([nil] * 6) }
+        specify do
+          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(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(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 { expect(PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
-        specify { expect(PlacesIndex.limit(6).preload(scope: ->{ where('rating < 2') }).order(:rating)
-          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+        specify do
+          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(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 { expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4) }
-        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where('rating < 2') })
-          .map(&:_object)).to match_array([nil] * 6) }
+        specify do
+          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(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(subject.order(:rating).limit(6).preload(only: [:city], except: :city, scope: -> { where('rating < 2') })
+          .map(&:_object)).to match_array([nil] * 6)
+        end
       end
     end
   end

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

@@ -2,15 +2,11 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::And do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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

@@ -2,21 +2,13 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Bool do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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

@@ -2,31 +2,31 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Equal do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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 == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2']}}) }
-    specify { expect(render { name != ['name1', 'name2'] }).to eq({not: {terms: {'name' => ['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) == ['name1', 'name2'] }).to eq({terms: {'name' => ['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(:|) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or}}) }
-    specify { expect(render { name(:or) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or}}) }
-    specify { expect(render { name(:&) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :and}}) }
-    specify { expect(render { name(:and) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :and}}) }
-    specify { expect(render { name(:b) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :bool}}) }
-    specify { expect(render { name(:bool) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :bool}}) }
-    specify { expect(render { name(:f) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :fielddata}}) }
-    specify { expect(render { name(:fielddata) == ['name1', 'name2'] }).to eq({terms: {'name' => ['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(:|) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or, _cache: true}}) }
-    specify { expect(render { ~name != ['name1', 'name2'] }).to eq({not: {terms: {'name' => ['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

@@ -2,17 +2,17 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Exists do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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'}}) }
-    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