elasticquery 0.1.1 → 0.1.2

data/History.md

@@ -0,0 +1,22 @@
+## Elasticquery (master)
+
+## Elasticquery 0.1.2 (16 June 2015)
+
+* Fix `range.not`. Exception was raised
+
+* Skip blank values in filtering
+`term name: "  "`, `range :age, lte: ""`, and `search nil` return all records
+
+* Create `history.md` file
+
+* Add options support for `range` and `term`.
+`term` supports `_cache` option. `range` supports both `_cache` and `execution`
+
+## Elasticquery 0.1.1 (02 Mar 2015)
+
+* Fix typo in gem description
+* Add rubygems bange
+
+## Elasticquery 0.1.0 (02 Mar 2015)
+
+* Initial version. Supported filters: `term`, `range`, `term.not`, `range.not`. Support multi match query. Simple inheritence support. Chain calls.

data/README.md

@@ -23,7 +23,7 @@ gem install elasticquery
 ## Getting Started
 ### First instruction
 
-Elasticsearch was designed to be customized as you need to. Providing simple methods it allows you to build power and flexible form objects. For example:
+Elasticquery was designed to be customized as you need to. Providing simple methods it allows you to build power and flexible form objects. Simplicity - is the main goal. For example:
 
 ```ruby
 class MyQuery < Elasticquery::Base
@@ -48,8 +48,6 @@ Article.search query.build # => be happy
 2. [MultiMatch][es_search] filter. [Usage][search_examples]
 3. [Range][es_range] filter. [Usage][range_examples]  
 
-#### Note! After first releases of elasticuqery it has scarce support of options and methods. Pull requests and issues with your ideas are welcome!
-
 ### Extended instruction
 There are multiple ways to organize your query, using chaining calls, or custom filters. Better custom filters support in progress now.
 
@@ -102,15 +100,6 @@ end
 
 ChildQuery.build({user_id: 1, category_id: 14}) => # the same as in previous example
 ```
-- Custom filter methods
-```ruby
-in progress...
-```
-
-- Custom filter classes
-```ruby
-in progress...
-```
 
 ### Usage
 #### term
@@ -124,6 +113,9 @@ term category: 'Soul', user: 'Aaron'
 
 # Term exclusion
 term.not category: 'Rap'
+
+# Blank values are skipped. This query returns all records
+term name: " "
 ```
 
 #### search (multimatch)
@@ -136,6 +128,9 @@ search 'developers', fields: "_all", operator: "and", type: "best_fields"
 
 # Configure fields
 search 'Jordan', fields: ['first_name', 'last_name'], operator: "or"
+
+# Blank values are skipped. This query returns all records
+search ''
 ```
 
 #### range
@@ -148,12 +143,13 @@ range :volume, gte: 1, lte: 100
 
 # Range exclusion
 range.not :size, gte: 32, lte: 128
-```
-
-## Contributing
-1. I'm happy to see any method you can be part of this.
 
+# Blank values are skipped. This query returns all records
+range.not :age, lte: ' ', gte: nil
 
+# _cache and execution options support
+range :volume, gte: 1, lte: 100, _cache: true, execution: "fielddata"
+```
 [elasticsearch_rails]: https://github.com/elasticsearch/elasticsearch-rails
 [demo]: http://elasticquery-demo.herokuapp.com
 [bundler]: http://bundler.io/

data/elasticquery.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport"
+  spec.add_dependency "deep_merge"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "yard"

data/lib/elasticquery/base.rb

@@ -1,11 +1,11 @@
-require 'active_support/core_ext/class/attribute'
-require 'elasticquery/query'
-require 'elasticquery/queries/all'
+require "active_support/core_ext/class/attribute"
+require "elasticquery/query"
+require "elasticquery/builder"
 
 # Base class for query builder. Superclass of your all builders
 module Elasticquery
   class Base
-    include Elasticquery::Queries::All
+    include Elasticquery::Builder
 
     class_attribute :filters
     attr_reader :params, :query

data/lib/elasticquery/builder.rb

@@ -0,0 +1,32 @@
+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 Builder
+    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

data/lib/elasticquery/filters/base.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module Elasticquery
   module Filters
     class Base

data/lib/elasticquery/filters/not.rb

@@ -1,25 +1,25 @@
-require_relative 'base'
+require_relative "base"
 
 module Elasticquery
   module Filters
     class Not < Base
 
-      def initialize(condition = {})
-        @condition = condition
+      def initialize(*args)
+        @args = args
       end
 
       def dup_with(*args)
-        raise StandardError, 'Cannot use Filters::Not twice'
+        raise StandardError, "Cannot use Filters::Not twice"
       end
 
       def to_hash
-        condition = @condition
+        args = @args
         -> do
-          filter = filters.last.dup_with condition
+          filter = filters.last.dup_with *args
           if filter.valid?
             subquery = filter.to_hash
-            q = subquery[:query][:filtered][:filter][:and]
-            {query: {filtered: {filter: {and: {not: {filter: q}}}}}}
+            q = subquery[:query][:filtered][:filter][:and][0]
+            {query: {filtered: {filter: {and: [{not: {filter: q}}]}}}}
           else
             {}
           end

data/lib/elasticquery/filters/range.rb

@@ -1,25 +1,31 @@
-require_relative 'base'
+require_relative "base"
 
 module Elasticquery
   module Filters
     class Range < Base
+      OPTIONS = %i(_cache execution)
 
-      def initialize(field, gte: nil, lte: nil)
+      def initialize(field=nil, gte: nil, lte: nil, **options)
+        @options = options.extract! *OPTIONS
         @field, @gte, @lte = field, gte, lte
       end
 
       def valid?
-        @gte || @lte
+        @gte.present? || @lte.present?
       end
 
       def to_hash
-        valid? ? {query: {filtered: {filter: {and: {range: range}}}}} : {}
+        if valid?
+          {query: {filtered: {filter: {and: [{range: range_with_options}]}}}}
+        else
+          {}
+        end
       end
 
       private
       
-      def range
-        {@field => {}}.tap do |r|
+      def range_with_options
+        {@field => @options}.tap do |r|
           r[@field][:lte] = @lte unless @lte.nil?
           r[@field][:gte] = @gte unless @gte.nil?
         end

data/lib/elasticquery/filters/search.rb

@@ -1,4 +1,4 @@
-require_relative 'base'
+require_relative "base"
 
 module Elasticquery
   module Filters
@@ -29,6 +29,7 @@ module Elasticquery
       def valid?
         OPERATORS.include?(@operator) &&
           TYPES.include?(@type) &&
+          @query.present? &&
           ( Array === @fields || @fields == "_all" )
       end
       

data/lib/elasticquery/filters/term.rb

@@ -1,21 +1,22 @@
-require_relative 'base'
+require_relative "base"
 
 module Elasticquery
   module Filters
     class Term < Base
+      OPTIONS = %i(_cache)
 
-      # Create filtered -> filter filter for elasticsearch
-      # builder
+      # Create term filter for elasticsearch builder
       #
       # @param [Hash] condition passed to define
       #
       # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-filtered-query.html#_filtering_without_a_query
-      def initialize(condition={})
-        @condition = condition
+      def initialize(data={})
+        @options = data.extract! *OPTIONS
+        @condition = data
       end
 
       # Is passed condition valid. Passed condition must have
-      # one key
+      # one key and present value
       # 
       # @return [Boolean] is condition have at least one key
       #
@@ -23,7 +24,7 @@ module Elasticquery
       #   rule = Elasticquery::Rules::Term.new
       #   rule.valid? #=> false
       def valid?
-        @condition.keys.any?
+        @condition.keys.size == 1 && @condition.values[0].present?
       end
 
       # Hash presentation of query.
@@ -31,10 +32,14 @@ module Elasticquery
       # @return [Hash] presentation of filter.
       #
       # @example
-      #   r = Elasticquery::filters::Term.new { name: "John" }
-      #   r.to_hash #=> {query: {filtered: {filter: {and: {name: 'John'}}}}}
+      #   valid = Elasticquery::Filters::Term.new {name: "John"}
+      #   valid.to_hash #=> {query: {filtered: {filter: {and: [{term: {name: 'John'}}]}}}
       def to_hash
-        valid? ? {query: {filtered: {filter: {and: {term: @condition}}}}} : {}
+        if valid?
+          {query: {filtered: {filter: {and: [{term: @condition.merge(@options)}]}}}}
+        else
+          {}
+        end
       end
     end
   end

data/lib/elasticquery/query.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/hash/deep_merge'
+require "deep_merge/rails_compat"
 
 module Elasticquery
   class Query
@@ -22,16 +22,8 @@ module Elasticquery
     #
     # @return [Hash] hash presentation of query
     def to_hash
-      q = @query.dup
-      if Enumerable === _filters
-        flatted_filters = _filters.flat_map do |type, filters|
-          filters.flat_map do |key, value|
-            {type => {key => value}}
-          end
-        end
-        q[:query][:filtered][:filter][:and] = flatted_filters
-      end
-      q
+      return DEFAULT if @query == {}
+      @query
     end
 
     # Merge filter to query. If current query is `matche_all`ed
@@ -59,7 +51,7 @@ module Elasticquery
     def merge(filter)
       hash = filter.to_hash
       subquery = hash.respond_to?(:call) ? instance_exec(&hash) : hash
-      @query.deep_merge! subquery
+      @query.deeper_merge! subquery
     end
 
     def _filters

data/lib/elasticquery/version.rb

@@ -1,4 +1,4 @@
 module Elasticquery
-  # current gem version
-  VERSION = "0.1.1"
+  # Current gem version
+  VERSION = "0.1.2"
 end

data/lib/elasticquery.rb

@@ -2,5 +2,5 @@ require "elasticquery/version"
 
 # Base gem module
 module Elasticquery
-  autoload :Base, 'elasticquery/base'
+  autoload :Base, "elasticquery/base"
 end

data/test/base_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'elasticquery/base'
+require "test_helper"
+require "elasticquery/base"
 
 class TestBase < MiniTest::Test
 
@@ -52,7 +52,7 @@ class TestBase < MiniTest::Test
 
   def test_should_execute_code_in_instance_context
     klass = Class.new(Elasticquery::Base)
-    klass.send(:define_method, :_error_) { raise StandardError, 'from instance context'}
+    klass.send(:define_method, :_error_) { raise StandardError, "from instance context"}
     klass.filtered { _error_ }
 
     assert_raises(StandardError) { klass.new.build }

data/test/{queries/all_test.rb → builder_test.rb}

@@ -1,8 +1,8 @@
-require 'test_helper'
-require 'elasticquery/queries/all'
+require "test_helper"
+require "elasticquery/builder"
 
 class TestAllBaseQueries < MiniTest::Test
-  include Elasticquery::Queries::All
+  include Elasticquery::Builder
 
   attr_accessor :query
 

data/test/filters/not_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'elasticquery/filters/not'
+require "test_helper"
+require "elasticquery/filters/not"
 
 class NotFilter < MiniTest::Test
   attr_reader :filters
@@ -20,13 +20,15 @@ class NotFilter < MiniTest::Test
   def test_to_hash_change_last_term_filter_value
     filter_class = MiniTest::Mock.new
     filter_class.expect :valid?, true
-    filter_class.expect :to_hash, {query: {filtered: {filter: {and: {term: {a: 1, b: 2}}}}}}
+    expected = {query: {filtered: {filter: {and: [{term: {a: 1, b: 2}}]}}}}
+    filter_class.expect :to_hash, expected
     previous_filter = MiniTest::Mock.new
     previous_filter.expect :dup_with, filter_class, [{a: 1}]
 
     @filters = [previous_filter]
     result = instance_exec &@filter.to_hash
-    assert_equal result, query: {filtered: {filter: {and: {not: {filter: {term: {a: 1, b: 2}}}}}}}
+    expected = {query: {filtered: {filter: {and: [{not: {filter: {term: {a: 1, b: 2}}}}]}}}}
+    assert_equal result, expected
 
     assert filter_class.verify
     assert previous_filter.verify
@@ -35,13 +37,15 @@ class NotFilter < MiniTest::Test
   def test_to_hash_change_last_range_filter_value
     filter_class = MiniTest::Mock.new
     filter_class.expect :valid?, true
-    filter_class.expect :to_hash, {query: {filtered: {filter: {and: {range: {a: {lte: 1}}}}}}}
+    expected = {query: {filtered: {filter: {and: [{range: {a: {lte: 1}}}]}}}}
+    filter_class.expect :to_hash, expected
     previous_filter = MiniTest::Mock.new
     previous_filter.expect :dup_with, filter_class, [{a: 1}]
 
     @filters = [previous_filter]
     result = instance_exec &@filter.to_hash
-    assert_equal result, query: {filtered: {filter: {and: {not: {filter: {range: {a: {lte: 1}}}}}}}}
+    expected = {query: {filtered: {filter: {and: [{not: {filter: {range: {a: {lte: 1}}}}}]}}}}
+    assert_equal result, expected
 
     assert filter_class.verify
     assert previous_filter.verify

data/test/filters/range_test.rb

@@ -1,44 +1,66 @@
-require 'test_helper'
-require 'elasticquery/filters/range'
+require "test_helper"
+require "elasticquery/filters/range"
 
 class RangeFilter < MiniTest::Test
   def setup
-    @filter = Elasticquery::Filters::Range.new 'year', lte: 2015, gte: 1990
-    @lte_filter = Elasticquery::Filters::Range.new 'age', lte: 58
-    @gte_filter = Elasticquery::Filters::Range.new 'age', gte: 18
+    @filter = Elasticquery::Filters::Range.new "year", lte: 2015, gte: 1990
+    @lte_filter = Elasticquery::Filters::Range.new "age", lte: 58
+    @gte_filter = Elasticquery::Filters::Range.new "age", gte: 18
   end
 
   def test_filter_valid_if_has_at_least_lte_or_gte_option
-    filter = Elasticquery::Filters::Range.new 'year', lte: 1
+    filter = Elasticquery::Filters::Range.new "year", lte: 1
     assert filter.valid?
-    filter = Elasticquery::Filters::Range.new 'year', gte: 0
+    filter = Elasticquery::Filters::Range.new "year", gte: 0
     assert filter.valid?
   end
 
+  def empty_values_is_invalid
+    filter = Elasticquery::Filters::Range.new "year", lte: "  "
+    assert filter.invalid?
+    filter = Elasticquery::Filters::Range.new "year", gte: nil, lte: ""
+    assert filte.invalid?
+  end
+
   def test_filter_invalid_if_has_no_options
-    filter = Elasticquery::Filters::Range.new 'year'
+    filter = Elasticquery::Filters::Range.new "year"
     refute filter.valid?
   end
 
   def test_to_hash_should_return_query
     filter = Elasticquery::Filters::Range.new :year, lte: 1, gte: 0
-    assert_equal({query: {filtered: {filter: {and: {range: {year: {lte: 1, gte: 0}}}}}}}, filter.to_hash)
+    assert_equal({query: {filtered: {filter: {and: [{range: {year: {lte: 1, gte: 0}}}]}}}}, filter.to_hash)
   end
 
   def test_to_hash_with_one_param
     filter = Elasticquery::Filters::Range.new :year, lte: 1
-    assert_equal({query: {filtered: {filter: {and: {range: {year: {lte: 1}}}}}}}, filter.to_hash)
+    assert_equal({query: {filtered: {filter: {and: [{range: {year: {lte: 1}}}]}}}}, filter.to_hash)
+  end
+
+  def test_to_hash_support_cache_option
+    filter = Elasticquery::Filters::Range.new :year, lte: 1, _cache: true
+    assert_equal({query: {filtered: {filter: {and: [{range: {year: {_cache: true, lte: 1}}}]}}}}, filter.to_hash)
+  end
+
+  def test_to_hash_support_execution_option
+    filter = Elasticquery::Filters::Range.new :year, lte: 1, gte: 0, execution: "fielddata"
+    assert_equal({query: {filtered: {filter: {and: [{range: {year: {lte: 1, gte: 0, execution: "fielddata"}}}]}}}}, filter.to_hash)
+  end
+
+  def test_to_hash_skip_unnesessary_options
+    filter = Elasticquery::Filters::Range.new :year, lte: 1, _cache: true, extra: false
+    assert_equal({query: {filtered: {filter: {and: [{range: {year: { _cache: true, lte: 1}}}]}}}}, filter.to_hash)
   end
 
   def test_to_hash_is_empty_if_invalid
-    filter = Elasticquery::Filters::Range.new 'year'
+    filter = Elasticquery::Filters::Range.new "year"
     refute filter.valid?
     assert_equal filter.to_hash, {}
   end
 
   def test_dup_with_return_new_range_filter
-    filter = Elasticquery::Filters::Range.new 'year'
-    new_filter = filter.dup_with 'month', gte: 12
+    filter = Elasticquery::Filters::Range.new "year"
+    new_filter = filter.dup_with "month", gte: 12
     assert_kind_of Elasticquery::Filters::Range, new_filter
   end
 end

data/test/filters/search_test.rb

@@ -1,10 +1,10 @@
-require 'test_helper'
-require 'elasticquery/filters/search'
+require "test_helper"
+require "elasticquery/filters/search"
 
 class TestSearchFilter < MiniTest::Test
 
   def test_default_values_of_filter
-    filter = Elasticquery::Filters::Search.new 'hi'
+    filter = Elasticquery::Filters::Search.new "hi"
     actual = filter.to_hash[:query][:filtered][:query][:multi_match]
     assert_equal actual, {fields: "_all", operator: "and", type: "best_fields", query: "hi"}
   end
@@ -15,43 +15,48 @@ class TestSearchFilter < MiniTest::Test
     end
   end
 
+  def test_empty_query_is_invalid
+    filter = Elasticquery::Filters::Search.new "  "
+    assert filter.invalid?
+  end
+
   def test_default_query_should_be_valid
-    filter = Elasticquery::Filters::Search.new 'hi'
+    filter = Elasticquery::Filters::Search.new "hi"
     assert filter.valid?
   end
 
   def test_query_fields_validation
-    filter = Elasticquery::Filters::Search.new 'hi', fields: 42
+    filter = Elasticquery::Filters::Search.new "hi", fields: 42
     refute filter.valid?
-    filter = Elasticquery::Filters::Search.new 'hi', fields: %w(name body)
+    filter = Elasticquery::Filters::Search.new "hi", fields: %w(name body)
     assert filter.valid?
   end
 
   def test_operator_validation
-    filter = Elasticquery::Filters::Search.new 'hi', operator: 'without'
+    filter = Elasticquery::Filters::Search.new "hi", operator: "without"
     refute filter.valid?
-    filter = Elasticquery::Filters::Search.new 'hi', operator: 'or'
+    filter = Elasticquery::Filters::Search.new "hi", operator: "or"
     assert filter.valid?
   end
 
   def test_types_validation
     %w(most_fields cross_fields phrase pharse_prefix).each do |type|
-      filter = Elasticquery::Filters::Search.new 'hi', type: type
+      filter = Elasticquery::Filters::Search.new "hi", type: type
       assert filter.valid?
     end
-    filter = Elasticquery::Filters::Search.new 'hi', type: 'random'
+    filter = Elasticquery::Filters::Search.new "hi", type: "random"
     refute filter.valid?
   end
 
   def test_to_hash_is_empty_if_invalid
-    filter = Elasticquery::Filters::Search.new 'hi', fields: 42
+    filter = Elasticquery::Filters::Search.new "hi", fields: 42
     refute filter.valid?
     assert_equal filter.to_hash, {}
   end
 
   def test_dup_with_return_new_search_query
-    filter = Elasticquery::Filters::Search.new 'hi', fields: 42
-    new_filter = filter.dup_with 'who'
+    filter = Elasticquery::Filters::Search.new "hi", fields: 42
+    new_filter = filter.dup_with "who"
     assert_kind_of Elasticquery::Filters::Search, new_filter
   end
 end

data/test/filters/term_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'elasticquery/filters/term'
+require "test_helper"
+require "elasticquery/filters/term"
 
 class TestTermfilter < MiniTest::Test
 
@@ -13,14 +13,29 @@ class TestTermfilter < MiniTest::Test
     refute filter.valid?
   end
 
-  def test_valid_filter_should_have_2_and_more_keys
+  def test_invalid_filter_should_have_2_and_more_keys
     filter = Elasticquery::Filters::Term.new  a: 1, b: 2
+    refute filter.valid?
+  end
+
+  def test_empty_condition_is_invalid
+    filter = Elasticquery::Filters::Term.new a: ""
+    refute filter.valid?
+  end
+
+  def test_valid_filter_could_have_cache_option
+    filter = Elasticquery::Filters::Term.new  a: 1, _cache: false
     assert filter.valid?
   end
 
+  def test_to_hash_should_pass__cache_options
+    filter = Elasticquery::Filters::Term.new a: 1, _cache: true
+    assert_equal({query: {filtered: {filter: {and: [{term: {a: 1, _cache: true}}]}}}}, filter.to_hash)
+  end
+
   def test_to_hash_should_return_es_query
-    filter = Elasticquery::Filters::Term.new a: 1, b: 2
-    assert_equal({query: {filtered: {filter: {and: {term: {a: 1, b: 2}}}}}}, filter.to_hash)
+    filter = Elasticquery::Filters::Term.new a: 1
+    assert_equal({query: {filtered: {filter: {and: [{term: {a: 1}}]}}}}, filter.to_hash)
   end
 
   def test_to_hash_is_empty_if_invalid

data/test/integration/chainable_call_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'elasticquery'
+require "test_helper"
+require "elasticquery"
 
 class TestChainableCalls < MiniTest::Test
 
@@ -12,17 +12,17 @@ class TestChainableCalls < MiniTest::Test
   end
 
   def test_apply_query
-    query = @query.term(a: 1).term(a: 3)
-    assert_equal query.build, query: {filtered: {filter: {and: [{term: {a: 3}}]}}}
+    query = @query.term(a: 1).term(b: 3)
+    assert_equal query.build, query: {filtered: {filter: {and: [{term: {a: 1}}, {term: {b: 3}}]}}}
   end
 
   def test_with_not_filter
-    query = @query.search('hi').term.not(a: 1)
-    assert_equal query.build, {query: {filtered: {query: {multi_match: {fields: "_all", operator: "and", type: "best_fields", query: "hi"}}, filter: {and: [{not: {filter: {term: {a: 1}}}}]}}}}
+    query = @query.search("hi").term.not(a: 1, _cache: true)
+    assert_equal query.build, {query: {filtered: {query: {multi_match: {fields: "_all", operator: "and", type: "best_fields", query: "hi"}}, filter: {and: [{not: {filter: {term: {a: 1, _cache: true}}}}]}}}}
   end
 
   def test_apply_kinds_of_query
-    query = @query.term(a: 1).search('hello', operator: 'or').build
+    query = @query.term(a: 1).search("hello", operator: "or").build
     terms = query[:query][:filtered][:filter][:and]
     search = query[:query][:filtered][:query][:multi_match]
     assert_equal terms, [{term: {a: 1}}]