elasticquery 0.1.0

data/lib/elasticquery/filters/search.rb

@@ -0,0 +1,53 @@
+require_relative 'base'
+
+module Elasticquery
+  module Filters
+    class Search < Base
+      OPERATORS = %w(and or)
+      TYPES = %w(best_fields most_fields cross_fields phrase pharse_prefix)
+
+      # Create new search subquery
+      #
+      # @params [String] query keyword
+      # @params [Array<String>] fields to search with. Default to "_all"
+      # @params [String] operator search option
+      # @params [String] type search option
+      def initialize(query, fields: "_all", operator: "and", type: "best_fields")
+        @fields = fields
+        @operator = operator
+        @type = type
+        @query = query
+      end
+
+      # Is current query valid to exec
+      #
+      # @return [Boolean]
+      #
+      # @example
+      #   filter = Elasticquery::Filters::Search.new 'hello'
+      #   filter.valid? #=> true
+      def valid?
+        OPERATORS.include?(@operator) &&
+          TYPES.include?(@type) &&
+          ( Array === @fields || @fields == "_all" )
+      end
+      
+      # Hash presentation of query.
+      #
+      # @return [Hash] presentation of filter.
+      #
+      # @example
+      #   r = Elasticquery::Filters::Search.new { fields: ['name', 'country'], query: 'belarus' }
+      #   r.to_hash #=> {query: {filtered: {query: {multi_match: {fields: ['name', 'country'], query: 'belarus'}}}}}
+      def to_hash
+        valid? ? {query: {filtered: {query: {multi_match: subquery}}}} : {}
+      end
+
+      private
+
+      def subquery
+        {fields: @fields, operator: @operator, type: @type, query: @query}
+      end
+    end
+  end
+end

data/lib/elasticquery/filters/term.rb

@@ -0,0 +1,41 @@
+require_relative 'base'
+
+module Elasticquery
+  module Filters
+    class Term < Base
+
+      # Create filtered -> filter 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
+      end
+
+      # Is passed condition valid. Passed condition must have
+      # one key
+      # 
+      # @return [Boolean] is condition have at least one key
+      #
+      # @example
+      #   rule = Elasticquery::Rules::Term.new
+      #   rule.valid? #=> false
+      def valid?
+        @condition.keys.any?
+      end
+
+      # Hash presentation of query.
+      #
+      # @return [Hash] presentation of filter.
+      #
+      # @example
+      #   r = Elasticquery::filters::Term.new { name: "John" }
+      #   r.to_hash #=> {query: {filtered: {filter: {and: {name: 'John'}}}}}
+      def to_hash
+        valid? ? {query: {filtered: {filter: {and: {term: @condition}}}}} : {}
+      end
+    end
+  end
+end

data/lib/elasticquery/queries/all.rb

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

data/lib/elasticquery/query.rb

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/hash/deep_merge'
+
+module Elasticquery
+  class Query
+
+    attr_reader :filters
+
+    DEFAULT = {query: {filtered: {query: {match_all:{}}}}}
+
+    # Create new query from hash.
+    #
+    # @param [Hash] query passed as hash. When it not passed use default es 'match_all' query
+    #
+    # @example
+    #   Elasticsearch::Query.new.to_hash #=> {query: {filtered: {query: {match_all:{}}}}}
+    def initialize(query = DEFAULT)
+      @query = query
+      @filters = []
+    end
+
+    # Convery query object ot hash
+    #
+    # @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
+    end
+
+    # Merge filter to query. If current query is `matche_all`ed
+    # then clear it and use new value. Populate #filters array
+    # with given classes
+    #
+    # @param [Elasticquery::filter::Base] filter passed
+    #
+    # @see #match_all?
+    def <<(filter)
+      @query = {} if match_all?
+      merge filter
+      @filters << filter
+    end
+
+    # Ckeck current object to default elasticsearch param
+    #
+    # @return [Boolean] is passed query undefined
+    def match_all?
+      @query == DEFAULT
+    end
+
+    private
+
+    def merge(filter)
+      hash = filter.to_hash
+      subquery = hash.respond_to?(:call) ? instance_exec(&hash) : hash
+      @query.deep_merge! subquery
+    end
+
+    def _filters
+      @query[:query] &&
+        @query[:query][:filtered] &&
+        @query[:query][:filtered][:filter] &&
+        @query[:query][:filtered][:filter][:and]
+    end
+  end
+end

data/lib/elasticquery/version.rb

@@ -0,0 +1,4 @@
+module Elasticquery
+  # current gem version
+  VERSION = "0.1.0"
+end

data/test/base_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'elasticquery/base'
+
+class TestBase < MiniTest::Test
+
+  def setup
+    @klass = Class.new(Elasticquery::Base)
+    @klass.filtered { 1 + 1 }
+
+    @query = @klass.new
+  end
+
+  def test_queries_with_filters_are_filterable
+    assert @query.filterable?
+  end
+
+  def test_queries_without_filters_are_not_filtrable
+    klass = Class.new(Elasticquery::Base)
+    refute klass.new.filterable?
+  end
+
+  def test_filters_is_empty_by_default
+    query = Elasticquery::Base.new
+    assert_empty query.filters
+  end
+
+  def test_extract_params
+    query = @klass.new a: 1
+    assert_equal 1, query.params[:a]
+  end
+
+  def test_default_params_as_empty
+    assert_empty @query.params
+  end
+
+  def test_filters_proc
+    assert_equal 2, @query.filters.first.call
+  end
+
+  def test_should_have_term_rule_included
+    assert_respond_to @query, :term
+  end
+
+  def test_filters_as_array
+    klass = Class.new(Elasticquery::Base)
+    klass.filtered { 1 + 1 }
+    klass.filtered { 2 + 2 }
+
+    query = klass.new
+    assert_equal 2, query.filters.count
+  end
+
+  def test_should_execute_code_in_instance_context
+    klass = Class.new(Elasticquery::Base)
+    klass.send(:define_method, :_error_) { raise StandardError, 'from instance context'}
+    klass.filtered { _error_ }
+
+    assert_raises(StandardError) { klass.new.build }
+  end
+
+  def test_build_should_build_on_instance
+    @klass.stub :build, {query: 1} do
+      assert_equal @klass.build({a: 1}), query: 1
+    end
+  end
+end

data/test/filters/not_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+require 'elasticquery/filters/not'
+
+class NotFilter < MiniTest::Test
+  attr_reader :filters
+
+  def setup
+    @filter = Elasticquery::Filters::Not.new a: 1
+  end
+
+  def test_always_valid
+    filter = Elasticquery::Filters::Not.new
+    assert filter.valid?
+  end
+
+  def test_to_hash_return_proc
+    assert_instance_of Proc, @filter.to_hash
+  end
+
+  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}}}}}}
+    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}}}}}}}
+
+    assert filter_class.verify
+    assert previous_filter.verify
+  end
+
+  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}}}}}}}
+    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}}}}}}}}
+
+    assert filter_class.verify
+    assert previous_filter.verify
+  end
+
+  def test_based_new_raise_exception
+    assert_raises StandardError do
+      @filter.dup_with a: 1
+    end
+  end
+end

data/test/filters/range_test.rb

@@ -0,0 +1,44 @@
+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
+  end
+
+  def test_filter_valid_if_has_at_least_lte_or_gte_option
+    filter = Elasticquery::Filters::Range.new 'year', lte: 1
+    assert filter.valid?
+    filter = Elasticquery::Filters::Range.new 'year', gte: 0
+    assert filter.valid?
+  end
+
+  def test_filter_invalid_if_has_no_options
+    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)
+  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)
+  end
+
+  def test_to_hash_is_empty_if_invalid
+    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
+    assert_kind_of Elasticquery::Filters::Range, new_filter
+  end
+end

data/test/filters/search_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+require 'elasticquery/filters/search'
+
+class TestSearchFilter < MiniTest::Test
+
+  def test_default_values_of_filter
+    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
+
+  def test_passed_parameters
+    assert_raises ArgumentError do
+      Elasticquery::Filters::Search.new
+    end
+  end
+
+  def test_default_query_should_be_valid
+    filter = Elasticquery::Filters::Search.new 'hi'
+    assert filter.valid?
+  end
+
+  def test_query_fields_validation
+    filter = Elasticquery::Filters::Search.new 'hi', fields: 42
+    refute filter.valid?
+    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'
+    refute filter.valid?
+    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
+      assert filter.valid?
+    end
+    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
+    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'
+    assert_kind_of Elasticquery::Filters::Search, new_filter
+  end
+end

data/test/filters/term_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+require 'elasticquery/filters/term'
+
+class TestTermfilter < MiniTest::Test
+
+  def test_valid_filter_should_have_one_key
+    filter = Elasticquery::Filters::Term.new a: 1
+    assert filter.valid?
+  end
+
+  def test_invalid_filter_should_have_no_keys
+    filter = Elasticquery::Filters::Term.new
+    refute filter.valid?
+  end
+
+  def test_valid_filter_should_have_2_and_more_keys
+    filter = Elasticquery::Filters::Term.new  a: 1, b: 2
+    assert filter.valid?
+  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)
+  end
+
+  def test_to_hash_is_empty_if_invalid
+    filter = Elasticquery::Filters::Term.new
+    refute filter.valid?
+    assert_equal filter.to_hash, {}
+  end
+
+  def test_dup_with_return_new_term_filter
+    filter = Elasticquery::Filters::Term.new a: 1
+    new_filter = filter.dup_with b: 2
+    assert_kind_of Elasticquery::Filters::Term, new_filter
+  end
+end