chewy 0.0.1 → 0.1.0

data/spec/chewy/query/criteria_spec.rb

@@ -5,28 +5,23 @@ describe Chewy::Query::Criteria do
 
   subject { described_class.new }
 
-  its(:search) { should == {} }
-  its(:query) { should == {} }
+  its(:options) { should be_a Hash }
   its(:facets) { should == {} }
+  its(:queries) { should == [] }
   its(:filters) { should == [] }
   its(:sort) { should == [] }
   its(:fields) { should == [] }
+  its(:types) { should == [] }
 
-  its(:search?) { should be_false }
-  its(:query?) { should be_false }
   its(:facets?) { should be_false }
+  its(:queries?) { should be_false }
   its(:filters?) { should be_false }
   its(:sort?) { should be_false }
   its(:fields?) { should be_false }
+  its(:types?) { should be_false }
 
-  describe '#update_search' do
-    specify { expect { subject.update_search(field: 'hello') }.to change { subject.search? }.to(true) }
-    specify { expect { subject.update_search(field: 'hello') }.to change { subject.search }.to(field: 'hello') }
-  end
-
-  describe '#update_query' do
-    specify { expect { subject.update_query(field: 'hello') }.to change { subject.query? }.to(true) }
-    specify { expect { subject.update_query(field: 'hello') }.to change { subject.query }.to(field: 'hello') }
+  describe '#update_options' do
+    specify { expect { subject.update_options(field: 'hello') }.to change { subject.options }.to(hash_including(field: 'hello')) }
   end
 
   describe '#update_facets' do
@@ -34,6 +29,15 @@ describe Chewy::Query::Criteria do
     specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets }.to(field: 'hello') }
   end
 
+  describe '#update_queries' do
+    specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries? }.to(true) }
+    specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries }.to([field: 'hello']) }
+    specify { expect { subject.update_queries(field: 'hello'); subject.update_queries(field: 'world') }
+      .to change { subject.queries }.to([{field: 'hello'}, {field: 'world'}]) }
+    specify { expect { subject.update_queries([{field: 'hello'}, {field: 'world'}, nil]) }
+      .to change { subject.queries }.to([{field: 'hello'}, {field: 'world'}]) }
+  end
+
   describe '#update_filters' do
     specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters? }.to(true) }
     specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters }.to([{field: 'hello'}]) }
@@ -70,4 +74,207 @@ describe Chewy::Query::Criteria do
     specify { expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3], purge: true) }
       .to change { subject.fields }.to(['field2', 'field3']) }
   end
+
+  describe '#update_types' do
+    specify { expect { subject.update_types(:type) }.to change { subject.types? }.to(true) }
+    specify { expect { subject.update_types(:type) }.to change { subject.types }.to(['type']) }
+    specify { expect { subject.update_types([:type, :type]) }.to change { subject.types }.to(['type']) }
+    specify { expect { subject.update_types([:type1, :type2]) }.to change { subject.types }.to(['type1', 'type2']) }
+    specify { expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3]) }
+      .to change { subject.types }.to(['type1', 'type2', 'type3']) }
+    specify { expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3], purge: true) }
+      .to change { subject.types }.to(['type2', 'type3']) }
+  end
+
+  describe '#merge' do
+    let(:criteria) { described_class.new }
+
+    specify { subject.merge(criteria).should_not be_equal subject }
+    specify { subject.merge(criteria).should_not be_equal criteria }
+
+    specify { subject.tap { |c| c.update_options(opt1: 'hello') }
+      .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
+    specify { subject.tap { |c| c.update_facets(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
+    specify { subject.tap { |c| c.update_queries(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
+    specify { subject.tap { |c| c.update_filters(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
+    specify { subject.tap { |c| c.update_sort(:field1) }
+      .merge(criteria.tap { |c| c.update_sort(:field2) }).sort.should == [:field1, :field2] }
+    specify { subject.tap { |c| c.update_fields(:field1) }
+      .merge(criteria.tap { |c| c.update_fields(:field2) }).fields.should == ['field1', 'field2'] }
+    specify { subject.tap { |c| c.update_types(:type1) }
+      .merge(criteria.tap { |c| c.update_types(:type2) }).types.should == ['type1', 'type2'] }
+  end
+
+  describe '#merge!' do
+    let(:criteria) { described_class.new }
+
+    specify { subject.merge!(criteria).should be_equal subject }
+    specify { subject.merge!(criteria).should_not be_equal criteria }
+
+    specify { subject.tap { |c| c.update_options(opt1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
+    specify { subject.tap { |c| c.update_facets(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
+    specify { subject.tap { |c| c.update_queries(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
+    specify { subject.tap { |c| c.update_filters(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
+    specify { subject.tap { |c| c.update_sort(:field1) }
+      .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort.should == [:field1, :field2] }
+    specify { subject.tap { |c| c.update_fields(:field1) }
+      .merge!(criteria.tap { |c| c.update_fields(:field2) }).fields.should == ['field1', 'field2'] }
+    specify { subject.tap { |c| c.update_types(:type1) }
+      .merge!(criteria.tap { |c| c.update_types(:type2) }).types.should == ['type1', 'type2'] }
+  end
+
+  describe '#request_body' do
+    def request_body &block
+      subject.instance_exec(&block) if block
+      subject.request_body
+    end
+
+    specify { request_body.should == {body: {}} }
+    specify { request_body { update_options(size: 10) }.should == {body: {size: 10}} }
+    specify { request_body { update_options(from: 10) }.should == {body: {from: 10}} }
+    specify { request_body { update_options(explain: true) }.should == {body: {explain: true}} }
+    specify { request_body { update_queries(:query) }.should == {body: {query: :query}} }
+    specify { request_body {
+      update_options(from: 10); update_sort(:field); update_fields(:field); update_queries(:query)
+    }.should == {body: {query: :query, from: 10, sort: [:field], fields: ['field']}} }
+  end
+
+  describe '#_request_query' do
+    def _request_query &block
+      subject.instance_exec(&block) if block
+      subject.send(:_request_query)
+    end
+
+    specify { _request_query.should be_nil }
+    specify { _request_query { update_queries(:query) }.should == {query: :query} }
+    specify { _request_query { update_queries([:query1, :query2]) }
+      .should == {query: {bool: {must: [:query1, :query2]}}} }
+    specify { _request_query { update_options(query_mode: :should); update_queries([:query1, :query2]) }
+      .should == {query: {bool: {should: [:query1, :query2]}}} }
+    specify { _request_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) }
+      .should == {query: {dis_max: {queries: [:query1, :query2]}}} }
+
+    specify { _request_query { update_filters([:filter1, :filter2]) }
+      .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}}}} }
+    specify { _request_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
+      .should == {query: {filtered: {
+        query: {bool: {must: [:query1, :query2]}},
+        filter: {and: [:filter1, :filter2]}
+      }}}
+    }
+    specify { _request_query {
+        update_options(query_mode: :should); update_options(filter_mode: :or);
+        update_filters([:filter1, :filter2]); update_queries([:query1, :query2])
+      }.should == {query: {filtered: {
+        query: {bool: {should: [:query1, :query2]}},
+        filter: {or: [:filter1, :filter2]}
+      }}}
+    }
+  end
+
+  describe '#_request_filter' do
+    def _request_filter &block
+      subject.instance_exec(&block) if block
+      subject.send(:_request_filter)
+    end
+
+    specify { _request_filter.should be_nil }
+
+    specify { _request_filter { update_types(:type) }.should == {type: {value: 'type'}} }
+    specify { _request_filter { update_types([:type1, :type2]) }
+      .should == {or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]} }
+
+    specify { _request_filter { update_filters([:filter1, :filter2]) }
+      .should == {and: [:filter1, :filter2]} }
+    specify { _request_filter { update_options(filter_mode: :or); update_filters([:filter1, :filter2]) }
+      .should == {or: [:filter1, :filter2]} }
+    specify { _request_filter { update_options(filter_mode: :must); update_filters([:filter1, :filter2]) }
+      .should == {bool: {must: [:filter1, :filter2]}} }
+    specify { _request_filter { update_options(filter_mode: :should); update_filters([:filter1, :filter2]) }
+      .should == {bool: {should: [:filter1, :filter2]}} }
+
+    specify { _request_filter { update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
+      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, :filter1, :filter2]} }
+    specify { _request_filter { update_options(filter_mode: :or); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
+      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {or: [:filter1, :filter2]}]} }
+    specify { _request_filter { update_options(filter_mode: :must); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
+      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must: [:filter1, :filter2]}}]} }
+    specify { _request_filter { update_options(filter_mode: :should); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
+      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {should: [:filter1, :filter2]}}]} }
+  end
+
+  describe '#_request_types' do
+    def _request_types &block
+      subject.instance_exec(&block) if block
+      subject.send(:_request_types)
+    end
+
+    specify { _request_types.should be_nil }
+    specify { _request_types { update_types(:type1) }.should == {type: {value: 'type1'}} }
+    specify { _request_types { update_types([:type1, :type2]) }
+      .should == {or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]} }
+  end
+
+  describe '#_queries_join' do
+    def _queries_join *args
+      subject.send(:_queries_join, *args)
+    end
+
+    let(:query) { {term: {field: 'value'}} }
+
+    specify { _queries_join([], :dis_max).should be_nil }
+    specify { _queries_join([query], :dis_max).should == query }
+    specify { _queries_join([query, query], :dis_max).should == {dis_max: {queries: [query, query]}} }
+
+    specify { _queries_join([], 0.7).should be_nil }
+    specify { _queries_join([query], 0.7).should == query }
+    specify { _queries_join([query, query], 0.7).should == {dis_max: {queries: [query, query], tie_breaker: 0.7}} }
+
+    specify { _queries_join([], :must).should be_nil }
+    specify { _queries_join([query], :must).should == query }
+    specify { _queries_join([query, query], :must).should == {bool: {must: [query, query]}} }
+
+    specify { _queries_join([], :should).should be_nil }
+    specify { _queries_join([query], :should).should == query }
+    specify { _queries_join([query, query], :should).should == {bool: {should: [query, query]}} }
+
+    specify { _queries_join([], '25%').should be_nil }
+    specify { _queries_join([query], '25%').should == query }
+    specify { _queries_join([query, query], '25%').should == {bool: {should: [query, query], minimum_should_match: '25%'}} }
+  end
+
+  describe '#_filters_join' do
+    def _filters_join *args
+      subject.send(:_filters_join, *args)
+    end
+
+    let(:filter) { {term: {field: 'value'}} }
+
+    specify { _filters_join([], :and).should be_nil }
+    specify { _filters_join([filter], :and).should == filter }
+    specify { _filters_join([filter, filter], :and).should == {and: [filter, filter]} }
+
+    specify { _filters_join([], :or).should be_nil }
+    specify { _filters_join([filter], :or).should == filter }
+    specify { _filters_join([filter, filter], :or).should == {or: [filter, filter]} }
+
+    specify { _filters_join([], :must).should be_nil }
+    specify { _filters_join([filter], :must).should == filter }
+    specify { _filters_join([filter, filter], :must).should == {bool: {must: [filter, filter]}} }
+
+    specify { _filters_join([], :should).should be_nil }
+    specify { _filters_join([filter], :should).should == filter }
+    specify { _filters_join([filter, filter], :should).should == {bool: {should: [filter, filter]}} }
+
+    specify { _filters_join([], '25%').should be_nil }
+    specify { _filters_join([filter], '25%').should == filter }
+    specify { _filters_join([filter, filter], '25%').should == {bool: {should: [filter, filter], minimum_should_match: '25%'}} }
+  end
 end

data/spec/chewy/query/loading_spec.rb

@@ -29,9 +29,11 @@ describe Chewy::Query::Loading do
       PlacesIndex.country.import(countries)
     end
 
-    specify { PlacesIndex.search.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
-    specify { PlacesIndex.search.order(:rating).limit(6).load(scopes: {city: ->(i){ where('rating < 2') }})
-      .should =~ cities.first(2) + countries.first(3) }
-    specify { PlacesIndex.search.order(:rating).limit(6).load.total_count.should == 12 }
+    specify { PlacesIndex.order(:rating).limit(6).load.total_count.should == 12 }
+    specify { PlacesIndex.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
+    specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: ->(i) { where('rating < 2') } })
+      .should =~ cities.first(2) + countries.first(3) + [nil] }
+    specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') })
+      .should =~ cities.first(2) + countries.first(3) + [nil] }
   end
 end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::And do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { name? & (email == 'email') }.should == {
+      and: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}]
+    } }
+    specify { render { ~(name? & (email == 'email')) }.should == {
+      and: {filters: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
+    } }
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Bool do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { must(name == 'name', email == 'email') }.should == {
+      bool: {must: [{term: {'name' => 'name'}}, {term: {'email' => 'email'}}]
+    } } }
+    specify { render { must(name == 'name').must_not(email == 'email') }.should == {
+      bool: {must: [{term: {'name' => 'name'}}], must_not: [{term: {'email' => 'email'}}]
+    } } }
+    specify { render { must(name == 'name').should(email == 'email') }.should == {
+      bool: {must: [{term: {'name' => 'name'}}], should: [{ term: {'email' => 'email'}}]
+    } } }
+    specify { render { ~must(name == 'name').should(email == 'email') }.should == {
+      bool: {must: [{term: {'name' => 'name'}}], should: [{ term: {'email' => 'email'}}], _cache: true
+    } } }
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Equal do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { name == 'name' }.should == {term: {'name' => 'name'}} }
+    specify { render { name != 'name' }.should == {not: {term: {'name' => 'name'}}} }
+    specify { render { name == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2']}} }
+    specify { render { name != ['name1', 'name2'] }.should == {not: {terms: {'name' => ['name1', 'name2']}}} }
+
+    specify { render { name(:bool) == 'name' }.should == {term: {'name' => 'name'}} }
+    specify { render { name(:borogoves) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2']}} }
+
+    specify { render { name(:|) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :or}} }
+    specify { render { name(:or) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :or}} }
+    specify { render { name(:&) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :and}} }
+    specify { render { name(:and) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :and}} }
+    specify { render { name(:b) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :bool}} }
+    specify { render { name(:bool) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :bool}} }
+    specify { render { name(:f) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :fielddata}} }
+    specify { render { name(:fielddata) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :fielddata}} }
+
+    specify { render { ~name == 'name' }.should == {term: {'name' => 'name', _cache: true}} }
+    specify { render { ~(name == 'name') }.should == {term: {'name' => 'name', _cache: true}} }
+    specify { render { ~name != 'name' }.should == {not: {term: {'name' => 'name', _cache: true}}} }
+    specify { render { ~name(:|) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :or, _cache: true}} }
+    specify { render { ~name != ['name1', 'name2'] }.should == {not: {terms: {'name' => ['name1', 'name2'], _cache: true}}} }
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Exists do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { name? }.should == {exists: {term: 'name'}} }
+
+    specify { render { !!name? }.should == {exists: {term: 'name'}} }
+    specify { render { !!name }.should == {exists: {term: 'name'}} }
+    specify { render { name != nil }.should == {exists: {term: 'name'}} }
+    specify { render { !(name == nil) }.should == {exists: {term: 'name'}} }
+
+    specify { render { ~name? }.should == {exists: {term: 'name'}} }
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Missing do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { !name }.should == {missing: {term: 'name', existence: true, null_value: false}} }
+    specify { render { !name? }.should == {missing: {term: 'name', existence: true, null_value: true}} }
+    specify { render { name == nil }.should == {missing: {term: 'name', existence: false, null_value: true}} }
+
+    specify { render { ~!name }.should == {missing: {term: 'name', existence: true, null_value: false}} }
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Not do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { !(email == 'email') }.should == {
+      not: {term: {'email' => 'email'}}
+    } }
+    specify { render { ~!(email == 'email') }.should == {
+      not: {filter: {term: {'email' => 'email'}}, _cache: true}
+    } }
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Or do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { name? | (email == 'email') }.should == {
+      or: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}]
+    } }
+    specify { render { ~(name? | (email == 'email')) }.should == {
+      or: {filters: [{exists: {term: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
+    } }
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Prefix do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { name =~ 'nam' }.should == {prefix: {'name' => 'nam'}} }
+    specify { render { name !~ 'nam' }.should == {not: {prefix: {'name' => 'nam'}}} }
+
+    specify { render { ~name =~ 'nam' }.should == {prefix: {'name' => 'nam', _cache: true}} }
+    specify { render { ~name !~ 'nam' }.should == {not: {prefix: {'name' => 'nam', _cache: true}}} }
+    specify { render { name(cache: false) =~ 'nam' }.should == {prefix: {'name' => 'nam', _cache: false}} }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Query do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { q(query_string: {query: 'name: hello'}) }.should == {query: {query_string: {query: 'name: hello'}}} }
+    specify { render { ~q(query_string: {query: 'name: hello'}) }.should == {fquery: {query: {query_string: {query: 'name: hello'}}, _cache: true}} }
+  end
+end