chewy_query 0.0.1

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::MatchAll do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::Filters.new(&block).__render__
+    end
+
+    specify{ expect(render{ match_all }).to eq(match_all: {}) }
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::Prefix do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::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', _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/builder/nodes/query_spec.rb

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

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

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

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::Raw do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::Filters.new(&block).__render__
+    end
+
+    specify{ expect(render{ r(term: { name: 'name' }) }).to eq(term: { name: 'name' }) }
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder::Nodes::Script do
+  describe '#__render__' do
+    def render(&block)
+      ChewyQuery::Builder::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', _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/builder_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe ChewyQuery::Builder do
+  subject{ ChewyQuery::Builder.new(:products, types: :product) }
+
+  describe '#==' do
+    specify{ expect(subject.query(match: 'hello') == subject.query(match: 'hello')).to be_truthy }
+    specify{ expect(subject.query(match: 'hello') == subject.query(match: 'world')).to be_falsy }
+    specify{ expect(subject.limit(10) == subject.limit(10)).to be_truthy }
+    specify{ expect(subject.limit(10) == subject.limit(11)).to be_falsy }
+    specify{ expect(subject.limit(2).limit(10) == subject.limit(10)).to be_truthy }
+  end
+
+  describe '#query_mode' do
+    specify{ expect(subject.query_mode(:should)).to be_a(described_class) }
+    specify{ expect(subject.query_mode(:should)).not_to eq(subject) }
+    specify{ expect(subject.query_mode(:should).criteria.options).to include(query_mode: :should) }
+    specify{ expect{ subject.query_mode(:should) }.not_to change{ subject.criteria.options } }
+  end
+
+  describe '#filter_mode' do
+    specify{ expect(subject.filter_mode(:or)).to be_a(described_class) }
+    specify{ expect(subject.filter_mode(:or)).not_to eq(subject) }
+    specify{ expect(subject.filter_mode(:or).criteria.options).to include(filter_mode: :or) }
+    specify{ expect{ subject.filter_mode(:or) }.not_to change{ subject.criteria.options } }
+  end
+
+  describe '#post_filter_mode' do
+    specify{ expect(subject.post_filter_mode(:or)).to be_a(described_class) }
+    specify{ expect(subject.post_filter_mode(:or)).not_to eq(subject) }
+    specify{ expect(subject.post_filter_mode(:or).criteria.options).to include(post_filter_mode: :or) }
+    specify{ expect{ subject.post_filter_mode(:or) }.not_to change{ subject.criteria.options } }
+  end
+
+  describe '#limit' do
+    specify{ expect(subject.limit(10)).to be_a(described_class) }
+    specify{ expect(subject.limit(10)).not_to eq(subject) }
+    specify{ expect(subject.limit(10).criteria.request_options).to include(size: 10) }
+    specify{ expect{ subject.limit(10) }.not_to change{ subject.criteria.request_options } }
+  end
+
+  describe '#offset' do
+    specify{ expect(subject.offset(10)).to be_a(described_class) }
+    specify{ expect(subject.offset(10)).not_to eq(subject) }
+    specify{ expect(subject.offset(10).criteria.request_options).to include(from: 10) }
+    specify{ expect{ subject.offset(10) }.not_to change{ subject.criteria.request_options } }
+  end
+
+  describe '#facets' do
+    specify{ expect(subject.facets(term: { field: 'hello' })).to be_a(described_class) }
+    specify{ expect(subject.facets(term: { field: 'hello' })).not_to eq(subject) }
+    specify{ expect(subject.facets(term: { field: 'hello' }).criteria.facets).to include(term: { field: 'hello' }) }
+    specify{ expect{ subject.facets(term: { field: 'hello' }) }.not_to change{ subject.criteria.facets } }
+  end
+
+  describe '#aggregations' do
+    specify{ expect(subject.aggregations(agg1: { field: 'hello' })).to be_a(described_class) }
+    specify{ expect(subject.aggregations(agg1: { field: 'hello' })).not_to eq(subject) }
+    specify{
+      expect(subject.aggregations(agg1: { field: 'hello' }).criteria.aggregations).to include(agg1: { field: 'hello' })
+    }
+    specify{ expect{ subject.aggregations(agg1: { field: 'hello' }) }.not_to change { subject.criteria.aggregations } }
+  end
+
+  describe '#suggest' do
+    specify{ expect(subject.suggest(name1: { text: 'hello' })).to be_a(described_class) }
+    specify{ expect(subject.suggest(name1: { text: 'hello' })).not_to eq(subject) }
+    specify{ expect(subject.suggest(name1: { text: 'hello' }).criteria.suggest).to include(name1: { text: 'hello' }) }
+    specify{ expect{ subject.suggest(name1: { text: 'hello' }) }.not_to change{ subject.criteria.suggest } }
+  end
+
+  describe '#strategy' do
+    specify{ expect(subject.strategy('query_first')).to be_a(described_class) }
+    specify{ expect(subject.strategy('query_first')).not_to eq(subject) }
+    specify{ expect(subject.strategy('query_first').criteria.options).to include(strategy: 'query_first') }
+    specify{ expect{ subject.strategy('query_first') }.not_to change{ subject.criteria.options } }
+  end
+
+  describe '#query' do
+    specify{ expect(subject.query(match: 'hello')).to be_a(described_class) }
+    specify{ expect(subject.query(match: 'hello')).not_to eq(subject) }
+    specify{ expect(subject.query(match: 'hello').criteria.queries).to include(match: 'hello') }
+    specify{ expect{ subject.query(match: 'hello') }.not_to change{ subject.criteria.queries } }
+  end
+
+  describe '#filter' do
+    specify{ expect(subject.filter(term: { field: 'hello' })).to be_a(described_class) }
+    specify{ expect(subject.filter(term: { field: 'hello' })).not_to eq(subject) }
+    specify{ expect{ subject.filter(term: { field: 'hello' }) }.not_to change{ subject.criteria.filters } }
+    specify{
+      expect(subject.filter(
+        [{ term: { field: 'hello' } }, { term: { field: 'world' } }]
+      ).criteria.filters).to eq([{ term: { field: 'hello' } }, { term: { field: 'world' } }])
+    }
+
+    specify{ expect{ subject.filter{ name == 'John' } }.not_to change{ subject.criteria.filters } }
+    specify{ expect(subject.filter{ name == 'John' }.criteria.filters).to eq([{ term: { 'name' => 'John' } }]) }
+  end
+
+  describe '#post_filter' do
+    specify{ expect(subject.post_filter(term: { field: 'hello' })).to be_a(described_class) }
+    specify{ expect(subject.post_filter(term: { field: 'hello' })).not_to eq(subject) }
+    specify{ expect{ subject.post_filter(term: { field: 'hello' }) }.not_to change{ subject.criteria.post_filters } }
+    specify{
+      expect(subject.post_filter(
+        [{ term: { field: 'hello' } }, { term: { field: 'world' } }]
+      ).criteria.post_filters).to eq([{ term: { field: 'hello' } }, { term: { field: 'world' } }])
+    }
+
+    specify{ expect{ subject.post_filter{ name == 'John' } }.not_to change{ subject.criteria.post_filters } }
+    specify{
+      expect(subject.post_filter{ name == 'John' }.criteria.post_filters).to eq([{ term: { 'name' => 'John' } }])
+    }
+  end
+
+  describe '#order' do
+    specify{ expect(subject.order(field: 'hello')).to be_a(described_class) }
+    specify{ expect(subject.order(field: 'hello')).not_to eq(subject) }
+    specify{ expect{ subject.order(field: 'hello') }.not_to change{ subject.criteria.sort } }
+
+    specify{ expect(subject.order(:field).criteria.sort).to eq([:field]) }
+    specify{ expect(subject.order([:field1, :field2]).criteria.sort).to eq([:field1, :field2]) }
+    specify{ expect(subject.order(field: :asc).criteria.sort).to eq([{ field: :asc }]) }
+    specify{ expect(
+      subject.order(field1: { order: :asc }, field2: :desc).order([:field3], :field4).criteria.sort
+    ).to eq([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
+  end
+
+  describe '#reorder' do
+    specify{ expect(subject.reorder(field: 'hello')).to be_a(described_class) }
+    specify{ expect(subject.reorder(field: 'hello')).not_to eq(subject) }
+    specify{ expect{ subject.reorder(field: 'hello') }.not_to change{ subject.criteria.sort } }
+
+    specify{ expect(subject.order(:field1).reorder(:field2).criteria.sort).to eq([:field2]) }
+    specify{ expect(subject.order(:field1).reorder(:field2).order(:field3).criteria.sort).to eq([:field2, :field3]) }
+    specify{ expect(subject.order(:field1).reorder(:field2).reorder(:field3).criteria.sort).to eq([:field3]) }
+  end
+
+  describe '#only' do
+    specify{ expect(subject.only(:field)).to be_a described_class }
+    specify{ expect(subject.only(:field)).not_to eq(subject) }
+    specify{ expect{ subject.only(:field) }.not_to change{ subject.criteria.fields } }
+
+    specify{ expect(subject.only(:field1, :field2).criteria.fields).to match_array(['field1', 'field2']) }
+    specify{ expect(
+      subject.only([:field1, :field2]).only(:field3).criteria.fields
+    ).to match_array(['field1', 'field2', 'field3']) }
+  end
+
+  describe '#only!' do
+    specify{ expect(subject.only!(:field)).to be_a(described_class) }
+    specify{ expect(subject.only!(:field)).not_to eq(subject) }
+    specify{ expect{ subject.only!(:field) }.not_to change{ subject.criteria.fields } }
+
+    specify{ expect(subject.only!(:field1, :field2).criteria.fields).to match_array(['field1', 'field2']) }
+    specify{ expect(subject.only!([:field1, :field2]).only!(:field3).criteria.fields).to eq(['field3']) }
+    specify{ expect(subject.only([:field1, :field2]).only!(:field3).criteria.fields).to eq(['field3']) }
+  end
+
+  describe '#types' do
+    specify{ expect(subject.types(:product)).to be_a(described_class) }
+    specify{ expect(subject.types(:product)).not_to eq(subject) }
+    specify{ expect{ subject.types(:product) }.not_to change{ subject.criteria.types } }
+
+    specify{ expect(subject.types(:user).criteria.types).to eq(['user']) }
+    specify{ expect(subject.types(:product, :city).criteria.types).to match_array(['product', 'city']) }
+    specify{ expect(
+      subject.types([:product, :city]).types(:country).criteria.types
+    ).to match_array(['product', 'city', 'country']) }
+  end
+
+  describe '#types!' do
+    specify{ expect(subject.types!(:product)).to be_a(described_class) }
+    specify{ expect(subject.types!(:product)).not_to eq(subject) }
+    specify{ expect{ subject.types!(:product) }.not_to change{ subject.criteria.types } }
+
+    specify{ expect(subject.types!(:user).criteria.types).to eq(['user']) }
+    specify{ expect(subject.types!(:product, :city).criteria.types).to match_array(['product', 'city']) }
+    specify{ expect(subject.types!([:product, :city]).types!(:country).criteria.types).to eq(['country']) }
+    specify{ expect(subject.types([:product, :city]).types!(:country).criteria.types).to eq(['country']) }
+  end
+
+  describe '#none' do
+    specify{ expect(subject.none).to be_a(described_class) }
+    specify{ expect(subject.none).not_to eq(subject) }
+    specify{ expect(subject.none.criteria).to be_none }
+  end
+
+  describe '#merge' do
+    let(:query){ ChewyQuery::Builder.new(:products) }
+
+    specify{ expect(
+      subject.filter{ name == 'name' }.merge(query.filter{ age == 42 }).criteria.filters
+    ).to eq([{ term: { 'name' => 'name' } }, { term: { 'age' => 42 } }]) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'its'
+require 'chewy_query'
+
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: chewy_query
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- pyromaniac
+- undr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The query builder for ElasticSearch which was extracted from Chewy.
+email:
+- kinwizard@gmail.com
+- undr@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- chewy_query.gemspec
+- lib/chewy_query.rb
+- lib/chewy_query/builder.rb
+- lib/chewy_query/builder/compose.rb
+- lib/chewy_query/builder/criteria.rb
+- lib/chewy_query/builder/filters.rb
+- lib/chewy_query/builder/nodes/and.rb
+- lib/chewy_query/builder/nodes/base.rb
+- lib/chewy_query/builder/nodes/bool.rb
+- lib/chewy_query/builder/nodes/equal.rb
+- lib/chewy_query/builder/nodes/exists.rb
+- lib/chewy_query/builder/nodes/expr.rb
+- lib/chewy_query/builder/nodes/field.rb
+- lib/chewy_query/builder/nodes/has_child.rb
+- lib/chewy_query/builder/nodes/has_parent.rb
+- lib/chewy_query/builder/nodes/has_relation.rb
+- lib/chewy_query/builder/nodes/match_all.rb
+- lib/chewy_query/builder/nodes/missing.rb
+- lib/chewy_query/builder/nodes/not.rb
+- lib/chewy_query/builder/nodes/or.rb
+- lib/chewy_query/builder/nodes/prefix.rb
+- lib/chewy_query/builder/nodes/query.rb
+- lib/chewy_query/builder/nodes/range.rb
+- lib/chewy_query/builder/nodes/raw.rb
+- lib/chewy_query/builder/nodes/regexp.rb
+- lib/chewy_query/builder/nodes/script.rb
+- lib/chewy_query/version.rb
+- spec/chewy_query/builder/context_spec.rb
+- spec/chewy_query/builder/filters_spec.rb
+- spec/chewy_query/builder/nodes/and_spec.rb
+- spec/chewy_query/builder/nodes/bool_spec.rb
+- spec/chewy_query/builder/nodes/equal_spec.rb
+- spec/chewy_query/builder/nodes/exists_spec.rb
+- spec/chewy_query/builder/nodes/has_child_spec.rb
+- spec/chewy_query/builder/nodes/has_parent_spec.rb
+- spec/chewy_query/builder/nodes/match_all_spec.rb
+- spec/chewy_query/builder/nodes/missing_spec.rb
+- spec/chewy_query/builder/nodes/not_spec.rb
+- spec/chewy_query/builder/nodes/or_spec.rb
+- spec/chewy_query/builder/nodes/prefix_spec.rb
+- spec/chewy_query/builder/nodes/query_spec.rb
+- spec/chewy_query/builder/nodes/range_spec.rb
+- spec/chewy_query/builder/nodes/raw_spec.rb
+- spec/chewy_query/builder/nodes/regexp_spec.rb
+- spec/chewy_query/builder/nodes/script_spec.rb
+- spec/chewy_query/builder_spec.rb
+- spec/chewy_query_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: The query builder for ElasticSearch which was extracted from Chewy.
+test_files:
+- spec/chewy_query/builder/context_spec.rb
+- spec/chewy_query/builder/filters_spec.rb
+- spec/chewy_query/builder/nodes/and_spec.rb
+- spec/chewy_query/builder/nodes/bool_spec.rb
+- spec/chewy_query/builder/nodes/equal_spec.rb
+- spec/chewy_query/builder/nodes/exists_spec.rb
+- spec/chewy_query/builder/nodes/has_child_spec.rb
+- spec/chewy_query/builder/nodes/has_parent_spec.rb
+- spec/chewy_query/builder/nodes/match_all_spec.rb
+- spec/chewy_query/builder/nodes/missing_spec.rb
+- spec/chewy_query/builder/nodes/not_spec.rb
+- spec/chewy_query/builder/nodes/or_spec.rb
+- spec/chewy_query/builder/nodes/prefix_spec.rb
+- spec/chewy_query/builder/nodes/query_spec.rb
+- spec/chewy_query/builder/nodes/range_spec.rb
+- spec/chewy_query/builder/nodes/raw_spec.rb
+- spec/chewy_query/builder/nodes/regexp_spec.rb
+- spec/chewy_query/builder/nodes/script_spec.rb
+- spec/chewy_query/builder_spec.rb
+- spec/chewy_query_spec.rb
+- spec/spec_helper.rb