elasticquery 0.1.1 → 0.1.2

data/test/integration/not_case_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'elasticquery'
+require "test_helper"
+require "elasticquery"
 
 class TestNotCase < MiniTest::Test
   class PostQuery < Elasticquery::Base
@@ -8,6 +8,13 @@ class TestNotCase < MiniTest::Test
     end
   end
 
+  class PostRangeQuery < Elasticquery::Base
+    filtered do |param|
+      term published: true
+      range.not :age, lte: params[:year]
+    end
+  end
+
   class InvalidQuery < Elasticquery::Base
     filtered do |param|
       term.not
@@ -16,7 +23,7 @@ class TestNotCase < MiniTest::Test
 
   def test_invalid_previous_filter
     query = InvalidQuery.new({}).build
-    assert_equal query, {}
+    assert_equal Elasticquery::Query::DEFAULT, query
   end
 
   def test_term_case
@@ -25,4 +32,11 @@ class TestNotCase < MiniTest::Test
     expected = [{not: {filter: {term: {id: 1}}}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
+
+  def test_range_case
+    params = {year: 2015}
+    actual = PostRangeQuery.new(params).build
+    expected = [{term: {published: true}}, {not: {filter: {range: {age: {lte: 2015}}}}}]
+    assert_equal expected, actual[:query][:filtered][:filter][:and]
+  end
 end

data/test/integration/queries_inheritence_test.rb

@@ -1,37 +1,31 @@
-require 'test_helper'
-require 'elasticquery'
+require "test_helper"
+require "elasticquery"
 
 class TestQueriesInheritence < MiniTest::Test
   class MultipleFilteredQuery < Elasticquery::Base
     filtered do |params|
-      term :'category.id' => params[:category_id]
+      term :"category.id" => params[:category_id]
     end
 
     filtered do |params|
-      term :'author.name' => params[:author_name]
+      term :"author.name" => params[:author_name]
     end
   end
 
   class ParentPostQuery < Elasticquery::Base
     filtered do |params|
-      term :'category.id' => params[:category_id]
+      term :"category.id" => params[:category_id]
     end
   end
 
   class ChildPostQuery < ParentPostQuery
     filtered do |params|
-      term :'author.name' => params[:author_name]
-    end
-  end
-
-  class ChildOverrideQuery < ParentPostQuery
-    filtered do |params|
-      term :'category.id' => params[:category_id_new]
+      term :"author.name" => params[:author_name]
     end
   end
 
   def setup
-    @params = {category_id: 1, author_name: 'Sergey'}
+    @params = {category_id: 1, author_name: "Sergey"}
   end
 
   def test_parent_subqueries_builder
@@ -44,21 +38,13 @@ class TestQueriesInheritence < MiniTest::Test
   def test_child_query_builder
     query = ChildPostQuery.new @params
     actual = query.build
-    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => 'Sergey'}}]
+    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => "Sergey"}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
 
   def test_concatenate_all_filters
     actual = MultipleFilteredQuery.new(@params).build
-    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => 'Sergey'}}]
-    assert_equal expected, actual[:query][:filtered][:filter][:and]
-  end
-
-  def test_override_same_keys
-    params = { category_id: 1, author_name: 'Sergey', category_id_new: 14 }
-    query = ChildOverrideQuery.new params
-    actual = query.build
-    expected = [{term: {:"category.id" => 14}}]
+    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => "Sergey"}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
 end

data/test/integration/range_case_test.rb

@@ -1,10 +1,10 @@
-require 'test_helper'
-require 'elasticquery'
+require "test_helper"
+require "elasticquery"
 
 class TestRangeCase < MiniTest::Test
   class HumanQuery < Elasticquery::Base
     filtered do |params|
-      range :year, lte: params[:max_year], gte: params[:min_year]
+      range :year, lte: params[:max_year], gte: params[:min_year], execution: "fielddata"
       range :revenue, lte: params[:max_revenue], gte: params[:min_revenue]
     end
   end
@@ -12,14 +12,27 @@ class TestRangeCase < MiniTest::Test
   def test_simple_range
     params = { min_year: 1960, max_year: 2015 }
     actual = HumanQuery.new(params).build
-    expected = [{range: {year:{ lte: 2015, gte: 1960}}}]
+    expected = [{range: {year:{ lte: 2015, gte: 1960, execution: "fielddata"}}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
 
+  def test_range_blank_values_should_be_ignored
+    params = { min_year: 1960, max_year: 2015, max_revenue: "", min_revenue: "  " }
+    actual = HumanQuery.new(params).build
+    expected = [{range: {year:{ lte: 2015, gte: 1960, execution: "fielddata"}}}]
+    assert_equal expected, actual[:query][:filtered][:filter][:and]
+  end
+
+  def test_empty_range
+    params = {}
+    actual = HumanQuery.new(params).build
+    assert_equal Elasticquery::Query::DEFAULT, actual
+  end
+
   def test_multiple_ranges
     params = { min_year: 1960, max_year: 2015, min_revenue: 100 }
     actual = HumanQuery.new(params).build
-    expected = [{range: {year:{ lte: 2015, gte: 1960}}}, {range: {revenue: {gte: 100}}}]
+    expected = [{range: {year:{ lte: 2015, gte: 1960, execution: "fielddata"}}}, {range: {revenue: {gte: 100}}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
 end

data/test/integration/search_case_test.rb

@@ -1,10 +1,10 @@
-require 'test_helper'
-require 'elasticquery'
+require "test_helper"
+require "elasticquery"
 
 class TestSearchQueryCase < MiniTest::Test
   class PostQuery < Elasticquery::Base
     filtered do |params|
-      term :'category' => params[:category]
+      term :"category" => params[:category]
       search params[:search]
     end
   end
@@ -25,23 +25,29 @@ class TestSearchQueryCase < MiniTest::Test
   end
 
   def test_search_with_other_query
-    params = {category: 'zoo', search: 'hello'}
+    params = {category: "zoo", search: "hello"}
     actual = PostQuery.new(params).build
-    expected_term = [{term: {category: 'zoo'}}]
+    expected_term = [{term: {category: "zoo"}}]
     assert_equal expected_term, actual[:query][:filtered][:filter][:and]
-    expected_search = { query: 'hello', fields: "_all", operator: 'and', type: 'best_fields'}
+    expected_search = { query: "hello", fields: "_all", operator: "and", type: "best_fields"}
     assert_equal expected_search, actual[:query][:filtered][:query][:multi_match]
   end
 
+  def test_empty_search
+    params = {search: "" , fields: %w(title body), operator: "or"}
+    actual = PostOptionsQuery.new(params).build
+    assert_equal Elasticquery::Query::DEFAULT, actual
+  end
+
   def test_all_options_to_configure
-    params = {search: 'hello', fields: %w(title body), operator: 'or'}
+    params = {search: "hello", fields: %w(title body), operator: "or"}
     actual = PostOptionsQuery.new(params).build
-    expected = {fields: %w(title body), operator: "or", type: "phrase", query: 'hello'}
+    expected = {fields: %w(title body), operator: "or", type: "phrase", query: "hello"}
     assert_equal expected, actual[:query][:filtered][:query][:multi_match]
   end
 
   def test_multiple_search_use_last_search_declaration
-    params = {search: 'hello'}
+    params = {search: "hello"}
     actual = MultipleSearch.new(params).build
     assert_equal "look for", actual[:query][:filtered][:query][:multi_match][:query]
   end

data/test/integration/term_case_test.rb

@@ -1,24 +1,38 @@
-require 'test_helper'
-require 'elasticquery'
+require "test_helper"
+require "elasticquery"
 
 class TestTermCase < MiniTest::Test
   class PostQuery < Elasticquery::Base
     filtered do |params|
-      term :'category.id' => params[:category_id], :"author.name" => params[:author_name]
+      term :"category.id" => params[:category_id]
+      term :"author.name" => params[:author_name], _cache: false
     end
   end
 
   def test_multiple_valid_terms
-    params = {category_id: 1, author_name: 'Sergey'}
+    params = {category_id: 1, author_name: "Sergey"}
     actual = PostQuery.new(params).build
-    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => 'Sergey'}}]
+    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => "Sergey", _cache: false}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
 
   def test_extra_params
-    params = { category_id: 1, author_name: 'Sergey', a: 1 }
+    params = {category_id: 1, author_name: "Sergey", a: 1}
     actual = PostQuery.new(params).build
-    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => 'Sergey'}}]
+    expected = [{term: {:"category.id" => 1}}, {term: {:"author.name" => "Sergey", _cache: false}}]
     assert_equal expected, actual[:query][:filtered][:filter][:and]
   end
+
+  def test_blank_values_should_be_ignored
+    params = {category_id: 1, author_name: ""}
+    actual = PostQuery.new(params).build
+    expected = [{term: {:"category.id" => 1}}]
+    assert_equal expected, actual[:query][:filtered][:filter][:and]
+  end
+
+  def test_empty_params
+    params = {}
+    actual = PostQuery.new(params).build
+    assert_equal Elasticquery::Query::DEFAULT, actual
+  end
 end

data/test/query_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'elasticquery/query'
+require "test_helper"
+require "elasticquery/query"
 
 class TestQuery < MiniTest::Test
 
@@ -46,13 +46,22 @@ class TestQuery < MiniTest::Test
   end
 
   def test_should_group_filters_in_array
-    @rule.expect :to_hash, query: {filtered: {filter: {and: {term: {a: 1, b: 2}}}}}
+    @rule.expect :to_hash, query: {filtered: {filter: {and: [{term: {a: 1, _cache: true}}]}}}
     @query << @rule
-    @rule.expect :to_hash, query: {filtered: {filter: {and: {term: {c: 3}}}}}
+    @rule.expect :to_hash, query: {filtered: {filter: {and: [{term: {c: 3}}]}}}
     @query << @rule
-    @rule.expect :to_hash, query: {filtered: {filter: {and: {range: {x: 3}}}}}
+    @rule.expect :to_hash, query: {filtered: {filter: {and: [{range: {x: 3}}]}}}
     @query << @rule
-    expected = {query: {filtered: {filter: {and: [{term: {a: 1}}, {term: {b: 2}}, {term: {c: 3}}, {range: {x: 3}}]}}}}
+    expected = {query: {filtered: {filter: {and: [{term: {a: 1, _cache: true}}, {term: {c: 3}}, {range: {x: 3}}]}}}}
+    assert_equal(expected, @query.to_hash)
+  end
+
+  def test_should_group_multiple_terms_conditions
+    @rule.expect :to_hash, query: {filtered: {filter: {and: [{terms: {a: %w(a b c)}}]}}}
+    @query << @rule
+    @rule.expect :to_hash, query: {filtered: {filter: {and: [{terms: {c: %w(x y z), execution: "bool"}}]}}}
+    @query << @rule
+    expected = {query: {filtered: {filter: {and: [{terms: {a: %w(a b c)}}, {terms: {c: %w(x y z), execution: "bool"}}]}}}}
     assert_equal(expected, @query.to_hash)
   end
 

data/test/test_helper.rb

@@ -1,5 +1,5 @@
-require 'minitest/test'
-require 'minitest/autorun'
+require "minitest/test"
+require "minitest/autorun"
 
 require "minitest/reporters"
 Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(:color => true)]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticquery
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Sergey Kuchmistov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-02 00:00:00.000000000 Z
+date: 2015-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -116,23 +130,26 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-style.yml"
 - ".travis.yml"
 - Gemfile
+- History.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - elasticquery.gemspec
 - lib/elasticquery.rb
 - lib/elasticquery/base.rb
+- lib/elasticquery/builder.rb
 - lib/elasticquery/filters/base.rb
 - lib/elasticquery/filters/not.rb
 - lib/elasticquery/filters/range.rb
 - lib/elasticquery/filters/search.rb
 - lib/elasticquery/filters/term.rb
-- lib/elasticquery/queries/all.rb
 - lib/elasticquery/query.rb
 - lib/elasticquery/version.rb
 - test/base_test.rb
+- test/builder_test.rb
 - test/filters/not_test.rb
 - test/filters/range_test.rb
 - test/filters/search_test.rb
@@ -143,7 +160,6 @@ files:
 - test/integration/range_case_test.rb
 - test/integration/search_case_test.rb
 - test/integration/term_case_test.rb
-- test/queries/all_test.rb
 - test/query_test.rb
 - test/test_helper.rb
 homepage: https://github.com/caulfield/elasticquery
@@ -166,12 +182,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Elasticsearch query builder.
 test_files:
 - test/base_test.rb
+- test/builder_test.rb
 - test/filters/not_test.rb
 - test/filters/range_test.rb
 - test/filters/search_test.rb
@@ -182,7 +199,6 @@ test_files:
 - test/integration/range_case_test.rb
 - test/integration/search_case_test.rb
 - test/integration/term_case_test.rb
-- test/queries/all_test.rb
 - test/query_test.rb
 - test/test_helper.rb
 has_rdoc: 

data/lib/elasticquery/queries/all.rb

@@ -1,34 +0,0 @@
-require 'elasticquery/filters/term'
-require 'elasticquery/filters/search'
-require 'elasticquery/filters/not'
-require 'elasticquery/filters/range'
-
-require 'active_support/concern'
-require 'active_support/core_ext/string/inflections'
-
-module Elasticquery
-  module Queries
-    module All
-      extend ActiveSupport::Concern
-
-      filters = [
-        Filters::Term,
-        Filters::Search,
-        Filters::Not,
-        Filters::Range
-      ]
-
-      included do
-        filters.each do |filter_class|
-          filter_name = filter_class.to_s.split("::").last.underscore
-
-          define_method filter_name do |*args|
-            filter = filter_class.new *args
-            query << filter
-            self
-          end
-        end
-      end
-    end
-  end
-end