chewy 0.8.4 → 5.1.0

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

@@ -2,39 +2,58 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::HasChild do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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'}}})
+    end
+    specify do
+      expect(render { has_child('child').filter { 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}}]}})
+    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}}]}})
+    end
 
-    specify { expect(render { has_child('child').filter(term: {name: 'name'}) })
-      .to eq({has_child: {type: 'child', filter: {term: {name: 'name'}}}}) }
-    specify { expect(render { has_child('child').filter{ name == 'name' } })
-      .to eq({has_child: {type: 'child', filter: {term: {'name' => 'name'}}}}) }
-    specify { 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}}]}}}) }
-    specify { 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}}]}}}) }
-
-    specify { expect(render { has_child('child').query(match: {name: 'name'}) })
-      .to eq({has_child: {type: 'child', query: {match: {name: 'name'}}}}) }
-    specify { 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'}}]}}}}) }
-    specify { 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'}}]}}}}) }
+    specify do
+      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'}}]}}})
+    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'}}]}}})
+    end
 
-    specify { 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'}}}}}}) }
-    specify { 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}}]}}}}}) }
+    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'}}}}})
+    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}}]}}}})
+    end
 
     context do
       let(:name) { 'Name' }
 
-      specify { expect(render { has_child('child').filter{ name == o{name} } })
-       .to eq({has_child: {type: 'child', filter: {term: {'name' => 'Name'}}}}) }
+      specify do
+        expect(render { has_child('child').filter { name == o { name } } })
+          .to eq(has_child: {type: 'child', filter: {term: {'name' => 'Name'}}})
+      end
     end
   end
 end

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

@@ -2,39 +2,58 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::HasParent do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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'}}})
+    end
+    specify do
+      expect(render { has_parent('child').filter { 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}}]}})
+    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}}]}})
+    end
 
-    specify { expect(render { has_parent('child').filter(term: {name: 'name'}) })
-      .to eq({has_parent: {type: 'child', filter: {term: {name: 'name'}}}}) }
-    specify { expect(render { has_parent('child').filter{ name == 'name' } })
-      .to eq({has_parent: {type: 'child', filter: {term: {'name' => 'name'}}}}) }
-    specify { 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}}]}}}) }
-    specify { 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}}]}}}) }
-
-    specify { expect(render { has_parent('child').query(match: {name: 'name'}) })
-      .to eq({has_parent: {type: 'child', query: {match: {name: 'name'}}}}) }
-    specify { 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'}}]}}}}) }
-    specify { 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'}}]}}}}) }
+    specify do
+      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'}}]}}})
+    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'}}]}}})
+    end
 
-    specify { 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'}}}}}}) }
-    specify { 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}}]}}}}}) }
+    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'}}}}})
+    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}}]}}}})
+    end
 
     context do
       let(:name) { 'Name' }
 
-      specify { expect(render { has_parent('child').filter{ name == o{name} } })
-       .to eq({has_parent: {type: 'child', filter: {term: {'name' => 'Name'}}}}) }
+      specify do
+        expect(render { has_parent('child').filter { name == o { name } } })
+          .to eq(has_parent: {type: 'child', filter: {term: {'name' => 'Name'}}})
+      end
     end
   end
 end

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

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::MatchAll do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { match_all }).to eq({match_all: {}}) }
+    specify { expect(render { match_all }).to eq(match_all: {}) }
   end
 end

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

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

@@ -2,15 +2,13 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Not do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       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}) }
+    # rubocop:enable Style/InverseMethods
   end
 end

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

@@ -2,15 +2,11 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Or 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({
-      or: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
-    }) }
-    specify { expect(render { ~(name? | (email == 'email')) }).to eq({
-      or: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
-    }) }
+    specify { expect(render { name? | (email == 'email') }).to eq(or: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]) }
+    specify { expect(render { ~(name? | (email == 'email')) }).to eq(or: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}) }
   end
 end

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

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Prefix do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { name =~ 'nam' }).to eq({prefix: {'name' => 'nam'}}) }
-    specify { expect(render { name !~ 'nam' }).to eq({not: {prefix: {'name' => 'nam'}}}) }
+    specify { expect(render { name =~ 'nam' }).to eq(prefix: {'name' => 'nam'}) }
+    specify { expect(render { name !~ 'nam' }).to eq(not: {prefix: {'name' => 'nam'}}) }
 
-    specify { expect(render { ~name =~ 'nam' }).to eq({prefix: {'name' => 'nam', _cache: true}}) }
-    specify { expect(render { ~name !~ 'nam' }).to eq({not: {prefix: {'name' => 'nam', _cache: true}}}) }
-    specify { expect(render { name(cache: false) =~ 'nam' }).to eq({prefix: {'name' => 'nam', _cache: false}}) }
+    specify { expect(render { ~name =~ 'nam' }).to eq(prefix: {'name' => 'nam', _cache: true}) }
+    specify { expect(render { ~name !~ 'nam' }).to eq(not: {prefix: {'name' => 'nam', _cache: true}}) }
+    specify { expect(render { name(cache: false) =~ 'nam' }).to eq(prefix: {'name' => 'nam', _cache: false}) }
   end
 end

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

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Query do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { q(query_string: {query: 'name: hello'}) }).to eq({query: {query_string: {query: 'name: hello'}}}) }
-    specify { expect(render { ~q(query_string: {query: 'name: hello'}) }).to eq({fquery: {query: {query_string: {query: 'name: hello'}}, _cache: true}}) }
+    specify { expect(render { q(query_string: {query: 'name: hello'}) }).to eq(query: {query_string: {query: 'name: hello'}}) }
+    specify { expect(render { ~q(query_string: {query: 'name: hello'}) }).to eq(fquery: {query: {query_string: {query: 'name: hello'}}, _cache: true}) }
   end
 end

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

@@ -2,31 +2,31 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Range do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { age > nil }).to eq({range: {'age' => {gt: nil}}}) }
-    specify { expect(render { age == (nil..nil) }).to eq({range: {'age' => {gt: nil, lt: nil}}}) }
+    specify { expect(render { age > nil }).to eq(range: {'age' => {gt: nil}}) }
+    specify { expect(render { age == (nil..nil) }).to eq(range: {'age' => {gt: nil, lt: nil}}) }
 
-    specify { expect(render { age > 42 }).to eq({range: {'age' => {gt: 42}}}) }
-    specify { expect(render { age == (42..45) }).to eq({range: {'age' => {gt: 42, lt: 45}}}) }
-    specify { expect(render { age == [42..45] }).to eq({range: {'age' => {gte: 42, lte: 45}}}) }
-    specify { expect(render { (age > 42) & (age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}}}) }
+    specify { expect(render { age > 42 }).to eq(range: {'age' => {gt: 42}}) }
+    specify { expect(render { age == (42..45) }).to eq(range: {'age' => {gt: 42, lt: 45}}) }
+    specify { expect(render { age == [42..45] }).to eq(range: {'age' => {gte: 42, lte: 45}}) }
+    specify { expect(render { (age > 42) & (age <= 45) }).to eq(range: {'age' => {gt: 42, lte: 45}}) }
 
-    specify { expect(render { ~age > 42 }).to eq({range: {'age' => {gt: 42}, _cache: true}}) }
-    specify { expect(render { ~age == (42..45) }).to eq({range: {'age' => {gt: 42, lt: 45}, _cache: true}}) }
-    specify { expect(render { ~age == [42..45] }).to eq({range: {'age' => {gte: 42, lte: 45}, _cache: true}}) }
-    specify { expect(render { (age > 42) & ~(age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, _cache: true}}) }
-    specify { expect(render { (~age > 42) & (age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, _cache: true}}) }
+    specify { expect(render { ~age > 42 }).to eq(range: {'age' => {gt: 42}, _cache: true}) }
+    specify { expect(render { ~age == (42..45) }).to eq(range: {'age' => {gt: 42, lt: 45}, _cache: true}) }
+    specify { expect(render { ~age == [42..45] }).to eq(range: {'age' => {gte: 42, lte: 45}, _cache: true}) }
+    specify { expect(render { (age > 42) & ~(age <= 45) }).to eq(range: {'age' => {gt: 42, lte: 45}, _cache: true}) }
+    specify { expect(render { (~age > 42) & (age <= 45) }).to eq(range: {'age' => {gt: 42, lte: 45}, _cache: true}) }
 
-    specify { expect(render { age(:i) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :index}}) }
-    specify { expect(render { age(:index) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :index}}) }
-    specify { expect(render { age(:f) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :fielddata}}) }
-    specify { expect(render { age(:fielddata) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :fielddata}}) }
-    specify { expect(render { (age(:f) > 42) & (age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, execution: :fielddata}}) }
+    specify { expect(render { age(:i) > 42 }).to eq(range: {'age' => {gt: 42}, execution: :index}) }
+    specify { expect(render { age(:index) > 42 }).to eq(range: {'age' => {gt: 42}, execution: :index}) }
+    specify { expect(render { age(:f) > 42 }).to eq(range: {'age' => {gt: 42}, execution: :fielddata}) }
+    specify { expect(render { age(:fielddata) > 42 }).to eq(range: {'age' => {gt: 42}, execution: :fielddata}) }
+    specify { expect(render { (age(:f) > 42) & (age <= 45) }).to eq(range: {'age' => {gt: 42, lte: 45}, execution: :fielddata}) }
 
-    specify { expect(render { ~age(:f) > 42 }).to eq({range: {'age' => {gt: 42}, execution: :fielddata, _cache: true}}) }
-    specify { expect(render { (age(:f) > 42) & (~age <= 45) }).to eq({range: {'age' => {gt: 42, lte: 45}, execution: :fielddata, _cache: true}}) }
+    specify { expect(render { ~age(:f) > 42 }).to eq(range: {'age' => {gt: 42}, execution: :fielddata, _cache: true}) }
+    specify { expect(render { (age(:f) > 42) & (~age <= 45) }).to eq(range: {'age' => {gt: 42, lte: 45}, execution: :fielddata, _cache: true}) }
   end
 end

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

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Raw do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { r(term: {name: 'name'}) }).to eq({term: {name: 'name'}}) }
+    specify { expect(render { r(term: {name: 'name'}) }).to eq(term: {name: 'name'}) }
   end
 end

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

@@ -2,30 +2,42 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Regexp do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { names.first == /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*'}}) }
-    specify { expect(render { names.first =~ /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*'}}) }
-    specify { expect(render { name != /nam.*/ }).to eq({not: {regexp: {'name' => 'nam.*'}}}) }
-    specify { expect(render { name !~ /nam.*/ }).to eq({not: {regexp: {'name' => 'nam.*'}}}) }
+    specify { expect(render { names.first == /nam.*/ }).to eq(regexp: {'names.first' => 'nam.*'}) }
+    specify { expect(render { names.first =~ /nam.*/ }).to eq(regexp: {'names.first' => 'nam.*'}) }
+    specify { expect(render { name != /nam.*/ }).to eq(not: {regexp: {'name' => 'nam.*'}}) }
+    specify { expect(render { name !~ /nam.*/ }).to eq(not: {regexp: {'name' => 'nam.*'}}) }
 
-    specify { expect(render { names.first(flags: [:anystring, :intersection, :borogoves]) == /nam.*/ })
-      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
-    specify { expect(render { names.first(:anystring, :intersection, :borogoves) == /nam.*/ })
-      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
+    specify do
+      expect(render { names.first(flags: %i[anystring intersection borogoves]) == /nam.*/ })
+        .to eq(regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}})
+    end
+    specify do
+      expect(render { names.first(:anystring, :intersection, :borogoves) == /nam.*/ })
+        .to eq(regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}})
+    end
 
-    specify { expect(render { names.first(flags: [:anystring, :intersection, :borogoves]) =~ /nam.*/ })
-      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
-    specify { expect(render { names.first(:anystring, :intersection, :borogoves) =~ /nam.*/ })
-      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}}) }
+    specify do
+      expect(render { names.first(flags: %i[anystring intersection borogoves]) =~ /nam.*/ })
+        .to eq(regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}})
+    end
+    specify do
+      expect(render { names.first(:anystring, :intersection, :borogoves) =~ /nam.*/ })
+        .to eq(regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}})
+    end
 
-    specify { expect(render { ~names.first == /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'nam.*'}}) }
-    specify { expect(render { names.first(cache: 'name') == /nam.*/ }).to eq({regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'name'}}) }
-    specify { expect(render { ~names.first(:anystring) =~ /nam.*/ })
-      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'nam.*'}}) }
-    specify { expect(render { names.first(:anystring, cache: 'name') =~ /nam.*/ })
-      .to eq({regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'name'}}) }
+    specify { expect(render { ~names.first == /nam.*/ }).to eq(regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'nam.*'}) }
+    specify { expect(render { names.first(cache: 'name') == /nam.*/ }).to eq(regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'name'}) }
+    specify do
+      expect(render { ~names.first(:anystring) =~ /nam.*/ })
+        .to eq(regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'nam.*'})
+    end
+    specify do
+      expect(render { names.first(:anystring, cache: 'name') =~ /nam.*/ })
+        .to eq(regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'name'})
+    end
   end
 end

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

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe Chewy::Query::Nodes::Script do
   describe '#__render__' do
-    def render &block
+    def render(&block)
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { expect(render { s('var = val') }).to eq({script: {script: 'var = val'}}) }
-    specify { expect(render { s('var = val', val: 42) }).to eq({script: {script: 'var = val', params: {val: 42}}}) }
+    specify { expect(render { s('var = val') }).to eq(script: {script: 'var = val'}) }
+    specify { expect(render { s('var = val', val: 42) }).to eq(script: {script: 'var = val', params: {val: 42}}) }
 
-    specify { expect(render { ~s('var = val') }).to eq({script: {script: 'var = val', _cache: true}}) }
-    specify { expect(render { ~s('var = val', val: 42) }).to eq({script: {script: 'var = val', params: {val: 42}, _cache: true}}) }
+    specify { expect(render { ~s('var = val') }).to eq(script: {script: 'var = val', _cache: true}) }
+    specify { expect(render { ~s('var = val', val: 42) }).to eq(script: {script: 'var = val', params: {val: 42}, _cache: true}) }
   end
 end

data/spec/chewy/query/pagination/kaminari_spec.rb

@@ -1,57 +1,5 @@
-require 'spec_helper'
+require 'chewy/search/pagination/kaminari_examples'
 
-if defined?(::Kaminari)
-  describe Chewy::Query::Pagination::Kaminari do
-    before { Chewy.massacre }
-
-    before do
-      stub_index(:products) do
-        define_type(:product) do
-          field :name
-          field :age, type: 'integer'
-        end
-      end
-    end
-
-    let(:search) { ProductsIndex.order(:age) }
-
-    specify { expect(search.total_pages).to eq(0) }
-
-    context do
-      let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-
-      before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-      before { allow(::Kaminari.config).to receive_messages(default_per_page: 3) }
-
-      describe '#per, #page' do
-        specify { expect(search.map { |e| e.attributes.except('_score', '_explanation') }).to match_array(data) }
-        specify { expect(search.page(1).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..2]) }
-        specify { expect(search.page(2).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[3..5]) }
-        specify { expect(search.page(2).per(4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..7]) }
-        specify { expect(search.per(2).page(3).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..5]) }
-        specify { expect(search.per(5).page.map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..4]) }
-        specify { expect(search.page.per(4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..3]) }
-      end
-
-      describe '#total_pages' do
-        specify { expect(search.total_pages).to eq(4) }
-        specify { expect(search.per(5).page(2).total_pages).to eq(2) }
-        specify { expect(search.per(2).page(3).total_pages).to eq(5) }
-      end
-
-      describe '#total_count' do
-        specify { expect(search.per(4).page(1).total_count).to eq(10) }
-        specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
-      end
-
-      describe '#load' do
-        specify { expect(search.per(2).page(1).load.first.age).to eq(10) }
-        specify { expect(search.per(2).page(3).load.first.age).to eq(50) }
-        specify { expect(search.per(2).page(3).load.page(2).load.first.age).to eq(30) }
-
-        specify { expect(search.per(4).page(1).load.total_count).to eq(10) }
-        specify { expect(search.per(2).page(3).load.total_pages).to eq(5) }
-      end
-    end
-  end
+describe Chewy::Search::Pagination::Kaminari do
+  it_behaves_like :kaminari, Chewy::Query
 end

data/spec/chewy/query/pagination/will_paginate_spec.rb

@@ -0,0 +1,5 @@
+require 'chewy/search/pagination/will_paginate_examples'
+
+describe Chewy::Search::Pagination::WillPaginate do
+  it_behaves_like :will_paginate, Chewy::Query
+end

data/spec/chewy/query/pagination_spec.rb

@@ -1,36 +1,39 @@
 require 'spec_helper'
 
 describe Chewy::Query::Pagination do
-  before { Chewy.massacre }
-
-  before do
-    stub_index(:products) do
-      define_type(:product) do
-        field :name
-        field :age, type: 'integer'
+  if Chewy::Runtime.version < '5.0'
+    before { Chewy.massacre }
+
+    before do
+      stub_index(:products) do
+        define_type(:product) do
+          field :name
+          field :age, type: 'integer'
+        end
       end
     end
-  end
 
-  let(:search) { ProductsIndex.order(:age) }
+    let(:search) { Chewy::Query.new(ProductsIndex).order(:age) }
 
-  specify { expect(search.total_count).to eq(0) }
+    specify { expect(search.total_count).to eq(0) }
 
-  context do
-    let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    context do
+      let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
 
-    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
+      before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
 
-    describe '#total_count' do
-      specify { expect(search.total_count).to eq(10) }
-      specify { expect(search.limit(5).total_count).to eq(10) }
-      specify { expect(search.filter(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
-    end
+      describe '#total_count' do
+        specify { expect(search.total_count).to eq(10) }
+        specify { expect(search.limit(5).total_count).to eq(10) }
+        specify { expect(search.filter(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+      end
 
-    describe '#load' do
-      specify { expect(search.load.total_count).to eq(10) }
-      specify { expect(search.limit(5).load.total_count).to eq(10) }
+      describe '#load' do
+        specify { expect(search.load.total_count).to eq(10) }
+        specify { expect(search.limit(5).load.total_count).to eq(10) }
+      end
     end
+  else
+    xspecify 'Skip Chewy::Query specs for 5.0'
   end
-
 end