chewy_query 0.0.1

data/spec/chewy_query/builder/filters_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Filters do
+  def Bool(options)
+    ChewyQuery::Builder::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?
+      bool.should(*options[:should]) if options[:should].present?
+    end
+  end
+
+  %w(field group and or not raw exists missing prefix regexp range equal query script).each do |method|
+    define_method method.camelize do |*args|
+      "ChewyQuery::Builder::Nodes::#{method.camelize}".constantize.new *args
+    end
+  end
+
+  def query(&block)
+    ChewyQuery::Builder::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') }
+  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{ 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')) }
+  end
+
+  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)) }
+  end
+
+  context 'bool' do
+    specify{ expect(query{ must(email == 'email') }).to be_eql(Bool(must: [Equal(:email, 'email')])) }
+    specify{ expect(query{ must_not(email == 'email') }).to be_eql(Bool(must_not: [Equal(:email, 'email')])) }
+    specify{ expect(query{ should(email == 'email') }).to be_eql(Bool(should: [Equal(:email, 'email')])) }
+    specify{ expect(query{
+      must(email == 'email').should(address != 'address', age == 42).must_not(sex == 'm').must(name == 'name')
+    }).to be_eql(Bool(
+      must: [Equal(:email, 'email'), Equal(:name, 'name')],
+      must_not: [Equal(:sex, 'm')],
+      should: [Not(Equal(:address, 'address')), Equal(:age, 42)]
+    )) }
+  end
+
+  context 'exists' do
+    specify{ expect(query{ email? }).to be_eql(Exists(:email)) }
+    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')) }
+  end
+
+  context 'missing' do
+    specify{ expect(query{ !email }).to be_eql(Missing(:email)) }
+    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)
+    ) }
+  end
+
+  context 'range' do
+    specify{ expect(query{ age > 42 }).to be_eql(Range(:age, gt: 42)) }
+    specify{ expect(query{ age >= 42 }).to be_eql(Range(:age, gt: 42, left_closed: true)) }
+    specify{ expect(query{ age < 42 }).to be_eql(Range(:age, lt: 42)) }
+    specify{ expect(query{ age <= 42 }).to be_eql(Range(:age, lt: 42, right_closed: true)) }
+    specify{ expect(query{ age == (30..42) }).to be_eql(Range(:age, gt: 30, lt: 42)) }
+    specify{ expect(query{ age == [30..42] }).to be_eql(
+      Range(:age, gt: 30, lt: 42, left_closed: true, right_closed: true)
+    ) }
+
+    specify{ expect(query{ (age > 30) & (age < 42) }).to be_eql(Range(:age, gt: 30, lt: 42)) }
+    specify{ expect(query{ (age > 30) & (age <= 42) }).to be_eql(Range(:age, gt: 30, lt: 42, right_closed: true)) }
+    specify{ expect(query{ (age >= 30) & (age < 42) }).to be_eql(Range(:age, gt: 30, lt: 42, left_closed: true)) }
+    specify{ expect(query{ (age >= 30) & (age <= 42) }).to be_eql(
+      Range(:age, gt: 30, lt: 42, right_closed: true, left_closed: true)
+    ) }
+
+    specify{ expect(query{ (age > 30) | (age < 42) }).to be_eql(Or(Range(:age, gt: 30), Range(:age, lt: 42))) }
+  end
+
+  context 'prefix' do
+    specify{ expect(query{ name =~ 'nam' }).to be_eql(Prefix(:name, 'nam')) }
+    specify{ expect(query{ name !~ 'nam' }).to be_eql(Not(Prefix(:name, 'nam'))) }
+  end
+
+  context 'regexp' do
+    specify{ expect(query{ name =~ /name/ }).to be_eql(Regexp(:name, 'name')) }
+    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))
+    ) }
+  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')) }
+  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' })) }
+  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(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(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'))))
+    ) }
+
+    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
+end

data/spec/chewy_query/builder/nodes/and_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::And do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::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}
+    ) }
+  end
+end

data/spec/chewy_query/builder/nodes/bool_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::Bool do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::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
+    } ) }
+  end
+end

data/spec/chewy_query/builder/nodes/equal_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::Equal do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::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(:bool) == 'name' }).to eq(term: { 'name' => 'name' }) }
+    specify{ expect(render{ name(:borogoves) == ['name1', 'name2'] }).to eq(terms: { 'name' => ['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 == '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 } }
+    ) }
+  end
+end

data/spec/chewy_query/builder/nodes/exists_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::Exists do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::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 != 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' }) }
+  end
+end

data/spec/chewy_query/builder/nodes/has_child_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::HasChild do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::Filters.new(&block).__render__
+    end
+
+    specify{ expect(render{ has_child('child') }).to eq(has_child: { type: 'child' }) }
+    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{ 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 } }] }
+          }
+        }
+      }
+    ) }
+
+    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' } } }
+      ) }
+    end
+  end
+end

data/spec/chewy_query/builder/nodes/has_parent_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::HasParent do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::Filters.new(&block).__render__
+    end
+
+    specify{ expect(render{ has_parent('child') }).to eq(has_parent: { type: 'child' }) }
+    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{ 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 } }] }
+          }
+        }
+      }
+    ) }
+
+    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' } } }
+      ) }
+    end
+  end
+end