es-query-builder 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01a7f2c3df52977455ef8cc73bb06caffae1b5d8
+  data.tar.gz: f9b6ddc51b5b9f64fceb830d8a9a12b5e557d362
+SHA512:
+  metadata.gz: 76e05d352511a51d07b53363273dc10da73ed421d09b8c92acf3bf7274a151f1756fd5ea68037a84efebc39f872c41590304be8df8aae1444bbed0a06aadf1b0
+  data.tar.gz: 4d19002288f950ad91db2bc5a819cd9fff51f74349a4aafa0bd9536af50cea9540c10defc4ed478e1ffb440a48517c143dad5403360b877766ba6e184af8b0c7

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+- 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in es-query-builder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yuku Takahashi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+[![Build Status](https://travis-ci.org/increments/es-query-builder.svg?branch=master)](https://travis-ci.org/increments/es-query-builder)
+
+NAME
+====
+
+`EsQueryBuilder` - A query builder for Elasticsearch in Ruby.
+
+SYNOPSIS
+========
+
+```ruby
+builder = EsQueryBuilder.new(
+  # Fields allowed searching with match query.
+  query_fields: ['field1'],
+  # Fields for filtering. Queries for these fields do not affect search score.
+  filter_fields: ['field2']
+)
+
+query = builder.build(query_string_given_by_user)
+
+body = 
+  if query.nil?
+    # Empty query
+    { size: 0 }
+  else
+    # Add other conditions, such as sort, highlight, fields and so on.
+    {
+      query: query,
+      sort: { ... }
+    }
+  end
+
+client = Elasticsearch::Client.new(host: 'http://server:9200')
+client.search({
+  index: 'index_name',
+  type: 'type_name',
+  body: body
+})
+# => #<Hash>
+```
+
+DESCRIPTION
+===========
+
+`EsQueryBuilder` converts a query string into a corresponding hash object for [elasticsearch-ruby](https://github.com/elasticsearch/elasticsearch-ruby).
+
+Elasticsearch supports [query_string query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html) dsl which is very useful to use internally, but too powerful to use as public interface. Allowing anonymous users to use the dsl may cause not only performance problems but also security risks if your index includes secret types.
+
+This gem accepts the query_string-query-dsl-like string and converts the string into a query object using other query dsls. At the same time it sanitizes fields in the query.
+
+INSTALLATION
+============
+
+```bash
+gem install es-query-builder
+```
+
+LICENSE
+=======
+
+This software is licensed under [MIT license](https://github.com/increments/es-query-builder/tree/master/LICENSE.txt).

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new("spec")
+task default: :spec

data/es-query-builder.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "es-query-builder/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "es-query-builder"
+  spec.version       = EsQueryBuilder::VERSION
+  spec.authors       = ["Yuku Takahashi"]
+  spec.email         = ["yuku@qiita.com"]
+  spec.summary       = "Build a query hash by a simple query string"
+  spec.homepage      = "https://github.com/increments/es-query-builder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/lib/es-query-builder.rb

@@ -0,0 +1,93 @@
+# Public: The class has a responsibility for converting a query string into
+# a corresponding query hash object for Elasticsearch.
+#
+# Examples
+#
+#   builder = EsQueryBuilder.new(
+#     query_fields: ['query'],
+#     filter_fields: ['filter']
+#   )
+#   # => #<EsQueryBuilder>
+#
+#   builder.build('term')
+#   # => { match: { '_all' => 'term' } }
+#
+#   builder.build('query:term')
+#   # => { match: { 'query' => 'hello' } }
+#
+#   builder.build('filter:term')
+#   # => {
+#   #      filtered: {
+#   #        query: { match_all: {} },
+#   #        filter: { term: { filter: 'hello' } }
+#   #      }
+#   #    }
+#
+#   builder.build('query\:term')
+#   # => { match: { '_all' => 'query\:term' } }
+#
+#   builder.build('unknown:term')
+#   # => { match: { '_all' => 'term' } }
+class EsQueryBuilder
+  require 'es-query-builder/token'
+  require 'es-query-builder/tokenizer'
+  require 'es-query-builder/parser'
+  require 'es-query-builder/version'
+
+  # Public: Construct the query builder object.
+  #
+  # query_fields     - An Array of Strings for specifing allowed quering
+  #                    types (default: []).
+  # filter_fields    - An Array of Strings for specifing allowed filtering
+  #                    types (default: []).
+  # all_query_fields - A String or an Array of Strings for searching usual
+  #                    query terms (default: '_all').
+  # hierarchy_fields - An Array of Strings which treats the trailing slash
+  #                    character as a hierarchy (default: []).
+  #
+  # Returns nothing.
+  def initialize(query_fields: [], filter_fields: [],
+                 all_query_fields: '_all', hierarchy_fields: [])
+    @query_fields = query_fields
+    @filter_fields = filter_fields
+    @all_query_fields = all_query_fields
+    @hierarchy_fields = hierarchy_fields
+  end
+
+  # Public: Convert the given query string into a query object.
+  #
+  # query_string - A query String for searching.
+  #
+  # Examples
+  #
+  #   build('hello world')
+  #   # => {
+  #   #      bool: {
+  #   #        must: [
+  #   #          { match: { '_all' => 'hello' } },
+  #   #          { match: { '_all' => 'world' } }
+  #   #        ]
+  #   #      }
+  #   #    }
+  #
+  # Returns a Hash for Elasticsearch client or nil.
+  def build(query_string)
+    parser.parse(tokenizer.tokenize(query_string))
+  end
+
+  private
+
+  # Internal: Tokenizer for the builder.
+  #
+  # Returns a Tokenizer.
+  def tokenizer
+    @tokenizer ||= Tokenizer.new(@query_fields, @filter_fields)
+  end
+
+  # Internal: Parser for the builder.
+  #
+  # Returns a Parser.
+  def parser
+    @parser ||= Parser.new(@all_query_fields, @hierarchy_fields)
+  end
+end

data/lib/es-query-builder/parser.rb

@@ -0,0 +1,224 @@
+class EsQueryBuilder
+  # Public: The class which has a responsibility for creatign a query.
+  #
+  # Note that the term "query" has two different meanings in the terminology of
+  # Elasticsearch. One represents how to retrieve documents from Elasticsearch
+  # and it consists of query and filter, so that is to say the other is a
+  # part of previous one. In this file, "query" and "query hash" represents the
+  # former and the latter respectively:
+  #
+  #   "query" = "query hash" + "filter hash"
+  #
+  class Parser
+    # Public: Construct the parser object.
+    #
+    # query_fields     - An Array of Strings for specifing allowed quering
+    #                    types (default: []).
+    # hierarchy_fields - An Array of Strings which treats the trailing slash
+    #                    character as a hierarchy (default: []).
+    #
+    # Returns nothing.
+    def initialize(all_query_fields = '_all', hierarchy_fields = [])
+      @all_query_fields = all_query_fields
+      @hierarchy_fields = hierarchy_fields
+    end
+
+    # Public: Parse the given tokens and build a query hash.
+    #
+    # tokens - An Array of Tokens.
+    #
+    # Returns a Hash for Elasticsearch client or nil.
+    def parse(tokens)
+      connect_queries(build_queries(tokens))
+    end
+
+    private
+
+    # Internal: Convert the given tokens into sequence of queries.
+    #
+    # tokens - An Array of Tokens.
+    #
+    # Returns an Array of Hashes. Each hash represents a query.
+    def build_queries(tokens)
+      split_by_or_token(tokens).map do |or_less_tokens|
+        query_hash = build_query_hash(or_less_tokens.select(&:query?))
+        filter_hash = build_filter_hash(or_less_tokens.select(&:filter?))
+        create_query(query_hash, filter_hash)
+      end
+    end
+
+    # Internal: Merge sequence of queries into a single query.
+    #
+    # queries - An Array of Hashes. Eash hash represents a query.
+    #
+    # Returns a Hash or nil.
+    def connect_queries(queries)
+      case queries.size
+      when 0
+        nil
+      when 1
+        queries.first
+      else
+        {
+          bool: {
+            should: queries
+          }
+        }
+      end
+    end
+
+    # Internal: Divide the given tokens array into sub arrays by 'or' token.
+    #
+    # tokens - An Array of Search::QueryBuilder::Token.
+    #
+    # Examples
+    #
+    #   split_by_or_token([<Query>, <OR>, <Query>, <Filter>])
+    #   #=> [[<Query>], [<Query>, <Filter>]]
+    #
+    # Returns an Array of Arrays of Tokens.
+    def split_by_or_token(tokens)
+      expressions = [[]]
+      tokens.each do |token|
+        if token.or?
+          expressions << []
+        else
+          expressions.last << token
+        end
+      end
+      expressions.select { |e| e.size > 0 }
+    end
+
+    # Internal: Connect given query hash and filter hash objects.
+    #
+    # query_hash  - A Hash represents a query hash.
+    # filter_hash - A Hash represents a filter hash.
+    #
+    # Returns a Hash represents a query.
+    def create_query(query_hash, filter_hash)
+      if filter_hash.size > 0
+        {
+          filtered: {
+            query: query_hash,
+            filter: filter_hash
+          }
+        }
+      else
+        query_hash
+      end
+    end
+
+    # Internal: Build a query hash by query tokens
+    #
+    # query_tokens - An Array of query Tokens.
+    #
+    # Returns a Hash represents a query hash.
+    def build_query_hash(query_tokens)
+      return { match_all: {} } if query_tokens.empty?
+      must, must_not = create_bool_queries(query_tokens)
+      if must.size == 1 && must_not.empty?
+        must.first
+      else
+        bool = {}
+        bool[:must]     = must     if must.size > 0
+        bool[:must_not] = must_not if must_not.size > 0
+        { bool: bool }
+      end
+    end
+
+    # Internal: Build a filter parameter hash by query tokens
+    #
+    # filter_tokens - An Array of filter Tokens.
+    #
+    # Returns a Hash represents a filter hash.
+    def build_filter_hash(filter_tokens)
+      return {} if filter_tokens.empty?
+      must, should, must_not = create_bool_filters(filter_tokens)
+      if must.size == 1 && should.empty? && must_not.empty?
+        # Term filter is cached by default.
+        must.first
+      else
+        bool = {}
+        bool[:must]     = must     if must.size > 0
+        bool[:should]   = should   if should.size > 0
+        bool[:must_not] = must_not if must_not.size > 0
+        # Bool filter is not cached by default.
+        { bool: bool.merge(_cache: true) }
+      end
+    end
+
+    # Internal: Create boolean query based with the given query tokens.
+    #
+    # query_tokens - An Array of query Tokens.
+    #
+    # Returns an Array consists of must and must_not query arrays.
+    def create_bool_queries(query_tokens)
+      must, must_not = [], []
+      query_tokens.each do |token|
+        # When the field is not given or invalid one, search by all fields.
+        field = token.field || @all_query_fields
+        queries = token.minus? ? must_not : must
+        if field.is_a?(String)
+          queries << {
+            match: {
+              field => token.term
+            }
+          }
+        else
+          queries << {
+            multi_match: {
+              fields: field,
+              query: token.term
+            }
+          }
+        end
+      end
+      [must, must_not]
+    end
+
+    # Internal: Create boolean filter based on the filter matches.
+    # If a field query in hierarchy fields ends with '/', it matches to all
+    # descendant terms.
+    #
+    # query_tokens - An Array of filter Tokens.
+    #
+    # Examples
+    #
+    #   # When 'tag:"foo bar"'
+    #   create_bool_filters([...])
+    #   # => [[{ term: { tag: 'foo' }}, { term: { tag: 'bar' }], [], []]
+    #
+    #   # When '-tag:foo'
+    #   create_bool_filters([...])
+    #   # => [[], [], [{ term: { tag: 'foo' } }]]
+    #
+    #   # Suppose @hierarchy_fields contains 'tag'
+    #
+    #   # When 'tag:foo/'
+    #   create_bool_filters([...])
+    #   # => [[], [{ term: { tag: 'foo' } }, { prefix: { tag: 'foo/' } }], []]
+    #
+    #   # When '-tag:foo/'
+    #   create_bool_filters([...])
+    #   # => [[], [], [{ prefix: { tag: 'foo/' } }, { term: { tag: 'foo' } }]]
+    #
+    # Returns an Array consists of must, should and must_not filters arrays.
+    def create_bool_filters(filter_tokens)
+      must, should, must_not = [], [], []
+      filter_tokens.each do |token|
+        token.term.split.each do |term|
+          if @hierarchy_fields.include?(token.field) && term.end_with?('/')
+            cond = token.minus? ? must_not : should
+            cond << { prefix: { token.field => term.downcase } }
+            # Exactly matches to the tag.
+            cond << { term: { token.field => term[0...-1].downcase } }
+          else
+            cond = token.minus? ? must_not : must
+            cond << { term: { token.field => term.downcase } }
+          end
+        end
+      end
+      [must, should, must_not]
+    end
+  end
+end

data/lib/es-query-builder/token.rb

@@ -0,0 +1,25 @@
+class EsQueryBuilder
+  class Token
+    attr_reader :full, :field, :term
+
+    TYPE_KINDS = %i(query filter or).freeze
+
+    def initialize(full: nil, minus: nil, field: nil, term: nil, type: nil)
+      @full = full
+      @minus = !!minus
+      @field = field
+      @term = term
+      @type = type
+    end
+
+    def minus?
+      @minus
+    end
+
+    TYPE_KINDS.each do |type|
+      define_method "#{type}?" do
+        @type == type
+      end
+    end
+  end
+end

data/lib/es-query-builder/tokenizer.rb

@@ -0,0 +1,69 @@
+class EsQueryBuilder
+  class Tokenizer
+    QUERY_REGEXP = /
+      (
+        (-)?                  # Minus
+        (?:(\w+):)?           # Field
+        (?:
+          (?:"(.*?)(?<!\\)")  # Quoted query
+          |
+          ([^\s]+)            # Single query
+        )
+      )
+    /x
+
+    OR_CONDITION = /^OR$/i
+
+    # Public: COnstruct the tokenizer object.
+    #
+    # filter_fields    - An Array of Strings for specifing allowed filtering
+    #                    types (default: []).
+    # all_query_fields - The String or Array of Strings for searching usual
+    #                    query terms (default: '_all').
+    #
+    # Returns nothing.
+    def initialize(query_fields = [], filter_fields = [])
+      @query_fields = query_fields
+      @filter_fields = filter_fields
+    end
+
+    # Public: Tokenize the given query string for parsing it later.
+    #
+    # query_string - The utf8 encoded String.
+    #
+    # Examples
+    #
+    #   tokenize('hello OR tag:world')
+    #   # => [<Token: @full="hello",     @type=:query,  ...>,
+    #         <Token: @full="OR",        @type=:or,     ...>,
+    #         <Token: @full="tag:world", @type=:filter, ...>]
+    #
+    # Returns an Array of Tokens.
+    def tokenize(query_string)
+      query_string.scan(QUERY_REGEXP).map do |match|
+        create_token(*match)
+      end
+    end
+
+    private
+
+    def create_token(full, minus, field, quoted, simple)
+      if @filter_fields.include?(field)
+        type = :filter
+      elsif OR_CONDITION =~ full
+        type = :or
+      else
+        field = nil unless @query_fields.include?(field)
+        type = :query
+      end
+
+      Token.new(
+        full: full,
+        minus: minus,
+        field: field,
+        term: quoted || simple,
+        type: type
+      )
+    end
+  end
+end

data/lib/es-query-builder/version.rb

@@ -0,0 +1,3 @@
+class EsQueryBuilder
+  VERSION = '0.0.1'
+end

data/spec/es_query_builder_spec.rb

@@ -0,0 +1,496 @@
+require 'spec_helper'
+
+describe EsQueryBuilder do
+  let(:query_builder) do
+    described_class.new(param)
+  end
+
+  let(:param) do
+    {}
+  end
+
+  describe '#build' do
+    subject do
+      query_builder.build(query_string)
+    end
+
+    context 'when a term query is given' do
+      let(:query_string) do
+        term
+      end
+
+      let(:term) do
+        'hello'
+      end
+
+      it 'returns a match query' do
+        should eq(
+          match: {
+            '_all' => term
+          }
+        )
+      end
+
+      context 'and the query starts with a minus character' do
+        let(:query_string) do
+          '-' + term
+        end
+
+        it 'returns a bool query with must_not condition' do
+          should eq(
+            bool: {
+              must_not: [
+                {
+                  match: {
+                    '_all' => term
+                  }
+                }
+              ]
+            }
+          )
+        end
+      end
+
+      context 'and it is constructed with all_query_fields' do
+        let(:param) do
+          { all_query_fields: all_query_fields }
+        end
+
+        let(:all_query_fields) do
+          ['field']
+        end
+
+        it 'returns a bool query for the specified query fields' do
+          should eq(
+            multi_match: {
+              fields: all_query_fields,
+              query: term
+            }
+          )
+        end
+
+        context 'and the query starts with a minus char' do
+          let(:query_string) do
+            '-' + term
+          end
+
+          it 'returns a must_not query for the specified query fields' do
+            should eq(
+              bool: {
+                must_not: [
+                  {
+                    multi_match: {
+                      fields: all_query_fields,
+                      query: term
+                    }
+                  }
+                ]
+              }
+            )
+          end
+        end
+      end
+    end
+
+    context 'when term queries are given' do
+      let(:query_string) do
+        "#{term_1} #{term_2}"
+      end
+
+      let(:term_1) do
+        'hello'
+      end
+
+      let(:term_2) do
+        'world'
+      end
+
+      it 'returns a bool query with must match queries' do
+        should eq(
+          bool: {
+            must: [
+              {
+                match: {
+                  '_all' => term_1
+                }
+              },
+              {
+                match: {
+                  '_all' => term_2
+                }
+              }
+            ]
+          }
+        )
+      end
+
+      context 'and one query starts with a minus character' do
+        let(:query_string) do
+          "#{term_1} -#{term_2}"
+        end
+
+        it 'returns a bool query with must and must_not queries' do
+          should eq(
+            bool: {
+              must: [
+                {
+                  match: {
+                    '_all' => term_1
+                  }
+                }
+              ],
+              must_not: [
+                {
+                  match: {
+                    '_all' => term_2
+                  }
+                }
+              ]
+            }
+          )
+        end
+      end
+
+      context 'and both of them start with a minus character' do
+        let(:query_string) do
+          "-#{term_1} -#{term_2}"
+        end
+
+        it 'returns a bool query with must_not queries' do
+          should eq(
+            bool: {
+              must_not: [
+                {
+                  match: {
+                    '_all' => term_1
+                  }
+                },
+                {
+                  match: {
+                    '_all' => term_2
+                  }
+                }
+              ]
+            }
+          )
+        end
+      end
+
+      context 'and one query is a filter query' do
+        let(:query_string) do
+          "#{field1}:#{term_1} #{term_2}"
+        end
+
+        let(:param) do
+          { filter_fields: [field1] }
+        end
+
+        let(:field1) do
+          'field'
+        end
+
+        it 'returns a filtered query' do
+          should eq(
+            filtered: {
+              query: {
+                match: {
+                  '_all' => term_2
+                }
+              },
+              filter: {
+                term: {
+                  field1 => term_1
+                }
+              }
+            }
+          )
+        end
+      end
+    end
+
+    context 'when a field query is given' do
+      let(:query_string) do
+        "#{field}:#{field_query}"
+      end
+
+      let(:field) do
+        'tag'
+      end
+
+      let(:field_query) do
+        'hello'
+      end
+
+      context 'and it is a part of query_fields' do
+        let(:param) do
+          { query_fields: [field] }
+        end
+
+        it 'returns a match query for the field' do
+          should eq(
+            match: {
+              field => field_query
+            }
+          )
+        end
+      end
+
+      context 'and it is a part of filter_fields' do
+        let(:param) do
+          { filter_fields: [field] }
+        end
+
+        it 'returns a filtered query object' do
+          should eq(
+            filtered: {
+              query: {
+                match_all: {}
+              },
+              filter: {
+                term: {
+                  field => field_query
+                }
+              }
+            }
+          )
+        end
+      end
+
+      context 'and the field is a part of neither query_fields nor filter_fields' do
+        let(:param) do
+          { all_query_fields: all_query_fields }
+        end
+
+        let(:all_query_fields) do
+          ["foo_#{field}", "bar_#{field}"]
+        end
+
+        it 'returns a match query for all_query_fields' do
+          should eq(
+            multi_match: {
+              fields: all_query_fields,
+              query: field_query
+            }
+          )
+        end
+      end
+    end
+
+    context 'when a quoted query is given' do
+      let(:query_string) do
+        %("#{quoted_query}")
+      end
+
+      let(:quoted_query) do
+        'hello world'
+      end
+
+      it 'returns a match query with the whole quoted query' do
+        should eq(
+          match: {
+            '_all' => quoted_query
+          }
+        )
+      end
+
+      context 'and it is constructed with all_query_fields' do
+        let(:param) do
+          { all_query_fields: all_query_fields }
+        end
+
+        let(:all_query_fields) do
+          %w(foo bar)
+        end
+
+        it 'returns a multi match query with the whole quoted query' do
+          should eq(
+            multi_match: {
+              fields: all_query_fields,
+              query: quoted_query
+            }
+          )
+        end
+      end
+    end
+
+    context 'when a quoted field query is given' do
+      let(:query_string) do
+        "#{field}:\"#{quoted_query}\""
+      end
+
+      let(:field) do
+        'field'
+      end
+
+      let(:quoted_query) do
+        "#{term_1} #{term_2}"
+      end
+
+      let(:term_1) do
+        'hello'
+      end
+
+      let(:term_2) do
+        'world'
+      end
+
+      context 'and the field is a part of query_fields' do
+        let(:param) do
+          { query_fields: [field] }
+        end
+
+        it 'returns a match query for the field' do
+          should eq(
+            match: {
+              field => quoted_query
+            }
+          )
+        end
+      end
+
+      context 'and the field is a part of filter_fields' do
+        let(:param) do
+          { filter_fields: [field] }
+        end
+
+        it 'returns a filtered query with must conditions' do
+          should eq(
+            filtered: {
+              query: {
+                match_all: {}
+              },
+              filter: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        field => term_1
+                      }
+                    },
+                    {
+                      term: {
+                        field => term_2
+                      }
+                    }
+                  ],
+                  _cache: true
+                }
+              }
+            }
+          )
+        end
+      end
+
+      context 'and the field is a part of neither query_fields nor filter_fields' do
+        it 'returns a match query for _all field' do
+          should eq(
+            match: {
+              '_all' => quoted_query
+            }
+          )
+        end
+
+        context 'and the query includes "OR"' do
+          let(:quoted_query) do
+            "#{term_1} OR #{term_2}"
+          end
+
+          it 'returns a match query inclues "OR" for _all field' do
+            should eq(
+              match: {
+                '_all' => quoted_query
+              }
+            )
+          end
+        end
+      end
+    end
+
+    context 'when an OR condition is given' do
+      context 'and that is all' do
+        let(:query_string) do
+          'OR'
+        end
+
+        it { should be_nil }
+      end
+
+      context 'and it does not connect queries' do
+        it 'does not returns a bool query' do
+          expect(query_builder.build('OR term')).not_to have_key 'bool'
+          expect(query_builder.build('term OR')).not_to have_key 'bool'
+        end
+      end
+
+      context 'and it connects queries' do
+        let(:query_string) do
+          "#{term_1} #{field_2}:#{term_2} OR #{field_3}:#{term_3}"
+        end
+
+        let(:param) do
+          {
+            query_fields: [field_2],
+            filter_fields: [field_3]
+          }
+        end
+
+        let(:term_1) do
+          'hello'
+        end
+
+        let(:field_2) do
+          'title'
+        end
+
+        let(:term_2) do
+          'world'
+        end
+
+        let(:field_3) do
+          'user'
+        end
+
+        let(:term_3) do
+          'qiitan'
+        end
+
+        it 'returns a bool query with should conditions' do
+          should eq(
+            bool: {
+              should: [
+                {
+                  bool: {
+                    must: [
+                      {
+                        match: {
+                          '_all' => term_1
+                        },
+                      },
+                      {
+                        match: {
+                          field_2 => term_2
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  filtered: {
+                    query: {
+                      match_all: {}
+                    },
+                    filter: {
+                      term: {
+                        field_3 => term_3
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'es-query-builder'
+
+RSpec.configure do |config|
+  config.color = true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: es-query-builder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuku Takahashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+description: 
+email:
+- yuku@qiita.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- es-query-builder.gemspec
+- lib/es-query-builder.rb
+- lib/es-query-builder/parser.rb
+- lib/es-query-builder/token.rb
+- lib/es-query-builder/tokenizer.rb
+- lib/es-query-builder/version.rb
+- spec/es_query_builder_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/increments/es-query-builder
+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: Build a query hash by a simple query string
+test_files:
+- spec/es_query_builder_spec.rb
+- spec/spec_helper.rb