qiita-elasticsearch 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aaa3120e317dceee23661a755b4a9eb2f38f2694
-  data.tar.gz: db119b903847b6287106d7205a945aa6218c7816
+  metadata.gz: cc0094615455695aa7148b67052af7b154c5e31e
+  data.tar.gz: 64562e5f4139f14eb727062d7caf39cf706f92eb
 SHA512:
-  metadata.gz: 5f3454a506c3c3fae11b682c23acd2a4d0b197cd8409f67b98078e6cead69c8e92a9949119d556675c6333439204a0dc25bae5c819cc843968267c593083de9e
-  data.tar.gz: 54baba6c1bd52bba643b8961c5038ce86f8d3de46afd6682f706b0a139995c16dc0685667e9af16f0bfb9bdcfbd7fb12643ed90fba344367ccde0b639672b8ad
+  metadata.gz: 183fabc234d8480455a5804eb80a8ccca40cc0b0e39fc5f6ee2f75800958875170203063f76303c88ea68e45388f347aa000f14c13d204eb6f2f8317c213b5d7
+  data.tar.gz: 857a39fb54f660ed9a3edf6c74b45212589ba558586bd0966f2b388454099ce5aad322a7b77949d1a4129b10ae6e755eacf377b8c2eecf3e6a0f43a042637ba6

data/.rubocop.yml

@@ -11,11 +11,14 @@ Metrics/CyclomaticComplexity:
   Enabled: false
 
 Metrics/LineLength:
-  Max: 120
+  Enabled: false
 
 Metrics/MethodLength:
   Enabled: false
 
+Metrics/ParameterLists:
+  Enabled: false
+
 Metrics/PerceivedComplexity:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.3.0
+- Add downcased_fields options and update case rule
+
 ## 0.2.2
 - Support range fields
 

data/README.md

@@ -6,7 +6,6 @@ Elasticsearch client helper for Qiita.
 
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new
-#=> #<Qiita::Elasticsearch::QueryBuilder:0x007ff81e67c4d8 @filterable_fields=nil, @hierarchal_fields=nil, @matchable_fields=nil>
 
 query_builder.build("a")
 #=> {"match"=>{"_all"=>"a"}}
@@ -29,7 +28,6 @@ Pass `:matchable_fields` option to tell matchable field names (default: `_all`).
 
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new(matchable_fields: ["body", "title"])
-#=> #<Qiita::Elasticsearch::QueryBuilder:0x007ff81fa59168 @filterable_fields=nil, @hierarchal_fields=nil, @matchable_fields=["body", "title"], @range_fields=nil>
 
 query_builder.build("a")
 #=> {"multi_match"=>{"fields"=>["body", "title"], "query"=>"a"}}
@@ -40,7 +38,6 @@ Pass `:filterable_fields` option to enable filtered queries like `tag:Ruby`.
 
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new(filterable_fields: ["tag", "title"])
-#=> #<Qiita::Elasticsearch::QueryBuilder:0x007ff81e2de1f0 @filterable_fields=["tag", "title"], @hierarchal_fields=nil, @matchable_fields=nil, @range_fields=nil>
 
 query_builder.build("tag:a")
 #=> {"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}}}
@@ -53,25 +50,34 @@ query_builder.build("user:a b")
 ```
 
 ### hierarchal_fields
-Pass `:hierarchal_fields` options with `:filterable_fields` to enable prefixed filtered queries.
+Pass `:hierarchal_fields` option with `:filterable_fields` to enable prefixed filtered queries.
 With this option, `tag:foo` will hit documents tagged with `foo`, or `foo/...`.
 
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new(filterable_fields: ["tag"], hierarchal_fields: ["tag"])
-#=> #<Qiita::Elasticsearch::QueryBuilder:0x007fe96d6d5ed0 @filterable_fields=["tag"], @hierarchal_fields=["tag"], @matchable_fields=nil, @range_fields=nil>
 
 query_builder.build("tag:ruby")
 #=> {"filtered"=>{"filter"=>{"bool"=>{"should"=>[{"prefix"=>{"tag"=>"ruby/"}}, {"term"=>{"tag"=>"ruby"}}]}}}}
 ```
 
 ### range_fields
-Pass `:range_fields` options with `:filterable_fields` to enable range filtered queries.
+Pass `:range_fields` option with `:filterable_fields` to enable range filtered queries.
 With this option, `created_at:<2015-04-16` will hit documents created before 2015-04-16.
 
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new(filterable_fields: ["created_at"], range_fields: ["created_at"])
-#=> #<Qiita::Elasticsearch::QueryBuilder:0x007fe96d6d5ed0 @filterable_fields=["created_at"], @hierarchal_fields=nil, @matchable_fields=nil, @range_fields=["created_at"]>
 
 query_builder.build("created_at:<2015-04-16")
 #=> {"filtered"=>{"filter"=>{"range"=>{"created_at"=>{"lt"=>"2015-04-16"}}}}}
 ```
+
+### downcased_fields
+Pass `:downcased_fields` option with `:filterable_fields` to downcase any terms in the fields.
+This option is useful when some fields are stored within downcased format on Elasticsearch.
+
+```rb
+query_builder = Qiita::Elasticsearch::QueryBuilder.new(downcased_fields: ["tag"], filterable_fields: ["tag"])
+
+query_builder.build("tag:Ruby")
+#=> {"filtered"=>{"filter"=>{"term"=>{"tag"=>"ruby"}}}}
+```

data/lib/qiita/elasticsearch/filterable_token.rb

@@ -0,0 +1,16 @@
+require "qiita/elasticsearch/token"
+
+module Qiita
+  module Elasticsearch
+    class FilterableToken < Token
+      # @return [Hash]
+      def to_hash
+        {
+          "term" => {
+            @field_name => proper_cased_term,
+          },
+        }
+      end
+    end
+  end
+end

data/lib/qiita/elasticsearch/hierarchal_token.rb

@@ -0,0 +1,27 @@
+require "qiita/elasticsearch/token"
+
+module Qiita
+  module Elasticsearch
+    class HierarchalToken < Token
+      # @return [Hash]
+      def to_hash
+        {
+          "bool" => {
+            "should" => [
+              {
+                "prefix" => {
+                  @field_name => proper_cased_term + "/",
+                },
+              },
+              {
+                "term" => {
+                  @field_name => proper_cased_term,
+                },
+              },
+            ],
+          },
+        }
+      end
+    end
+  end
+end

data/lib/qiita/elasticsearch/matchable_token.rb

@@ -0,0 +1,29 @@
+require "qiita/elasticsearch/token"
+
+module Qiita
+  module Elasticsearch
+    class MatchableToken < Token
+      attr_writer :matchable_fields
+
+      # @return [Hash]
+      def to_hash
+        if @matchable_fields.nil?
+          {
+            quoted? ? "match_phrase" : "match" => {
+              "_all" => @term,
+            }
+          }
+        else
+          hash = {
+            "multi_match" => {
+              "fields" => @matchable_fields,
+              "query" => @term,
+            },
+          }
+          hash["multi_match"]["type"] = "phrase" if quoted?
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/qiita/elasticsearch/nodes/filter_node.rb

@@ -6,23 +6,13 @@ module Qiita
     module Nodes
       class FilterNode
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
-        # @param [Array<String>, nil] hierarchal_fields
-        # @param [Array<String>, nil] matchable_fields
-        # @param [Array<String>, nil] range_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil, range_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @matchable_fields = matchable_fields
-          @range_fields = range_fields
+        def initialize(tokens)
           @tokens = tokens
         end
 
         def to_hash
           if must_not_tokens.empty? && must_tokens.length == 1
-            TermNode.new(
-              must_tokens.first,
-              hierarchal_fields: @hierarchal_fields,
-              range_fields: @range_fields,
-            ).to_hash
+            TermNode.new(must_tokens.first).to_hash
           else
             {
               "bool" => {
@@ -41,17 +31,10 @@ module Qiita
         def must_not_queries
           must_not_tokens.map do |token|
             if token.field_name.nil?
-              MatchNode.new(
-                token,
-                matchable_fields: @matchable_fields,
-              )
+              MatchNode.new(token).to_hash
             else
-              TermNode.new(
-                token,
-                hierarchal_fields: @hierarchal_fields,
-                range_fields: @range_fields,
-              )
-            end.to_hash
+              TermNode.new(token).to_hash
+            end
           end
         end
 
@@ -61,11 +44,7 @@ module Qiita
 
         def must_queries
           must_tokens.map do |token|
-            TermNode.new(
-              token,
-              hierarchal_fields: @hierarchal_fields,
-              range_fields: @range_fields,
-            ).to_hash
+            TermNode.new(token).to_hash
           end
         end
 

data/lib/qiita/elasticsearch/nodes/filterable_node.rb

@@ -6,35 +6,18 @@ module Qiita
     module Nodes
       class FilterableNode
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
-        # @param [Array<String>, nil] hierarchal_fields
-        # @param [Array<String>, nil] matchable_fields
-        # @param [Array<String>, nil] range_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil, range_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @matchable_fields = matchable_fields
-          @range_fields = range_fields
+        def initialize(tokens)
           @tokens = tokens
         end
 
         def to_hash
           if filter_tokens.empty?
-            QueryNode.new(
-              not_filter_tokens,
-              matchable_fields: @matchable_fields,
-            ).to_hash
+            QueryNode.new(not_filter_tokens).to_hash
           else
             {
               "filtered" => {
-                "filter" => FilterNode.new(
-                  filter_tokens,
-                  hierarchal_fields: @hierarchal_fields,
-                  matchable_fields: @matchable_fields,
-                  range_fields: @range_fields,
-                ).to_hash,
-                "query" => QueryNode.new(
-                  not_filter_tokens,
-                  matchable_fields: @matchable_fields,
-                ).to_hash,
+                "filter" => FilterNode.new(filter_tokens).to_hash,
+                "query" => QueryNode.new(not_filter_tokens).to_hash,
               }.reject do |key, value|
                 value.empty?
               end,

data/lib/qiita/elasticsearch/nodes/match_node.rb

@@ -3,29 +3,13 @@ module Qiita
     module Nodes
       class MatchNode
         # @param [Qiita::Elasticsearch::Token] token
-        # @param [Array<String>, nil] matchable_fields
-        def initialize(token, matchable_fields: nil)
-          @matchable_fields = matchable_fields
+        def initialize(token)
           @token = token
         end
 
+        # @return [Hash]
         def to_hash
-          if @matchable_fields.nil?
-            {
-              @token.quoted? ? "match_phrase" : "match" => {
-                "_all" => @token.term,
-              }
-            }
-          else
-            hash = {
-              "multi_match" => {
-                "fields" => @matchable_fields,
-                "query" => @token.term,
-              },
-            }
-            hash["multi_match"]["type"] = "phrase" if @token.quoted?
-            hash
-          end
+          @token.to_hash
         end
       end
     end

data/lib/qiita/elasticsearch/nodes/multi_should_node.rb

@@ -5,9 +5,7 @@ module Qiita
     module Nodes
       class MultiShouldNode
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
-        # @param [Array<String>, nil] matchable_fields
-        def initialize(tokens, matchable_fields: nil)
-          @matchable_fields = matchable_fields
+        def initialize(tokens)
           @tokens = tokens
         end
 
@@ -24,10 +22,7 @@ module Qiita
         # @return [Array<Hash>] Queries to be used as a value of `should` property of bool query.
         def should_queries
           @tokens.map do |token|
-            MatchNode.new(
-              token,
-              matchable_fields: @matchable_fields,
-            ).to_hash
+            MatchNode.new(token).to_hash
           end
         end
       end

data/lib/qiita/elasticsearch/nodes/or_separatable_node.rb

@@ -6,13 +6,7 @@ module Qiita
     module Nodes
       class OrSeparatableNode
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
-        # @param [Array<String>, nil] hierarchal_fields
-        # @param [Array<String>, nil] matchable_fields
-        # @param [Array<String>, nil] range_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil, range_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @matchable_fields = matchable_fields
-          @range_fields = range_fields
+        def initialize(tokens)
           @tokens = tokens
         end
 
@@ -21,22 +15,12 @@ module Qiita
           when 0
             Nodes::NullNode.new.to_hash
           when 1
-            Nodes::FilterableNode.new(
-              tokens_grouped_by_or_token.first,
-              hierarchal_fields: @hierarchal_fields,
-              matchable_fields: @matchable_fields,
-              range_fields: @range_fields,
-            ).to_hash
+            Nodes::FilterableNode.new(tokens_grouped_by_or_token.first).to_hash
           else
             {
               "bool" => {
                 "should" => tokens_grouped_by_or_token.map do |tokens|
-                  Nodes::FilterableNode.new(
-                    tokens,
-                    hierarchal_fields: @hierarchal_fields,
-                    matchable_fields: @matchable_fields,
-                    range_fields: @range_fields,
-                  ).to_hash
+                  Nodes::FilterableNode.new(tokens).to_hash
                 end,
               },
             }

data/lib/qiita/elasticsearch/nodes/query_node.rb

@@ -6,10 +6,7 @@ module Qiita
     module Nodes
       class QueryNode
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
-        # @param [Array<String>, nil] matchable_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @matchable_fields = matchable_fields
+        def initialize(tokens)
           @tokens = tokens
         end
 
@@ -18,15 +15,9 @@ module Qiita
           when 0
             {}
           when 1
-            MatchNode.new(
-              @tokens.first,
-              matchable_fields: @matchable_fields,
-            ).to_hash
+            MatchNode.new(@tokens.first).to_hash
           else
-            MultiShouldNode.new(
-              @tokens,
-              matchable_fields: @matchable_fields,
-            ).to_hash
+            MultiShouldNode.new(@tokens).to_hash
           end
         end
       end

data/lib/qiita/elasticsearch/nodes/term_node.rb

@@ -2,71 +2,14 @@ module Qiita
   module Elasticsearch
     module Nodes
       class TermNode
-        DEFAULT_HIERARCHAL_FIELDS = []
-        DEFAULT_RANGE_FIELDS = []
-
         # @param [Qiita::Elasticsearch::Token] token
-        # @param [Array<String>, nil] hierarchal_fields
-        # @param [Array<String>, nil] range_fields
-        def initialize(token, hierarchal_fields: nil, range_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @range_fields = range_fields
+        def initialize(token)
           @token = token
         end
 
         # @return [Hash]
         def to_hash
-          case
-          when has_hierarchal_token?
-            {
-              "bool" => {
-                "should" => [
-                  {
-                    "prefix" => {
-                      @token.field_name => @token.downcased_term + "/",
-                    },
-                  },
-                  {
-                    "term" => {
-                      @token.field_name => @token.downcased_term,
-                    },
-                  },
-                ],
-              },
-            }
-          when has_range_token?
-            {
-              "range" => {
-                @token.field_name => {
-                  @token.range_parameter => @token.range_query,
-                },
-              },
-            }
-          else
-            {
-              "term" => {
-                @token.field_name => @token.downcased_term,
-              },
-            }
-          end
-        end
-
-        private
-
-        def has_hierarchal_token?
-          hierarchal_fields.include?(@token.field_name)
-        end
-
-        def hierarchal_fields
-          @hierarchal_fields || DEFAULT_HIERARCHAL_FIELDS
-        end
-
-        def has_range_token?
-          range_fields.include?(@token.field_name) && @token.range_parameter
-        end
-
-        def range_fields
-          @range_fields || DEFAULT_RANGE_FIELDS
+          @token.to_hash
         end
       end
     end

data/lib/qiita/elasticsearch/query_builder.rb

@@ -5,11 +5,13 @@ require "qiita/elasticsearch/tokenizer"
 module Qiita
   module Elasticsearch
     class QueryBuilder
+      # @param [Array<String>, nil] downcased_fields
       # @param [Array<String>, nil] filterable_fields
       # @param [Array<String>, nil] hierarchal_fields
       # @param [Array<String>, nil] matchable_fields
       # @param [Array<String>, nil] range_fields
-      def initialize(hierarchal_fields: nil, filterable_fields: nil, matchable_fields: nil, range_fields: nil)
+      def initialize(downcased_fields: nil, hierarchal_fields: nil, filterable_fields: nil, matchable_fields: nil, range_fields: nil)
+        @downcased_fields = downcased_fields
         @hierarchal_fields = hierarchal_fields
         @filterable_fields = filterable_fields
         @matchable_fields = matchable_fields
@@ -23,19 +25,20 @@ module Qiita
         if tokens.size.zero?
           Nodes::NullNode.new.to_hash
         else
-          Nodes::OrSeparatableNode.new(
-            tokens,
-            hierarchal_fields: @hierarchal_fields,
-            matchable_fields: @matchable_fields,
-            range_fields: @range_fields,
-          ).to_hash
+          Nodes::OrSeparatableNode.new(tokens).to_hash
         end
       end
 
       private
 
       def tokenizer
-        @tokenizer ||= Tokenizer.new(filterable_fields: @filterable_fields)
+        @tokenizer ||= Tokenizer.new(
+          downcased_fields: @downcased_fields,
+          hierarchal_fields: @hierarchal_fields,
+          filterable_fields: @filterable_fields,
+          matchable_fields: @matchable_fields,
+          range_fields: @range_fields,
+        )
       end
     end
   end

data/lib/qiita/elasticsearch/range_token.rb

@@ -0,0 +1,57 @@
+require "qiita/elasticsearch/token"
+
+module Qiita
+  module Elasticsearch
+    class RangeToken < Token
+      RANGE_TERM_REGEXP = /\A(?<operand>\<|\<=|\>|\>=)(?<query>.*)\z/
+
+      # @return [Hash]
+      def to_hash
+        if range_parameter
+          {
+            "range" => {
+              @field_name => {
+                range_parameter => range_query,
+              },
+            },
+          }
+        else
+          {
+            "term" => {
+              @field_name => proper_cased_term,
+            },
+          }
+        end
+      end
+
+      private
+
+      # @return [String, nil]
+      # @example Suppose @term is "created_at:>=2015-04-16"
+      #   range_parameter #=> "gte"
+      def range_parameter
+        range_match[:operand] ? operand_map[range_match[:operand]] : nil
+      end
+
+      # @return [String, nil]
+      # @example Suppose @term is "created_at:>=2015-04-16"
+      #   range_query #=> "2015-04-16"
+      def range_query
+        range_match[:query]
+      end
+
+      def range_match
+        @range_match ||= RANGE_TERM_REGEXP.match(@term) || {}
+      end
+
+      def operand_map
+        {
+          ">" => "gt",
+          ">=" => "gte",
+          "<" => "lt",
+          "<=" => "lte",
+        }
+      end
+    end
+  end
+end

data/lib/qiita/elasticsearch/token.rb

@@ -1,11 +1,11 @@
 module Qiita
   module Elasticsearch
     class Token
-      RANGE_TERM_REGEXP = /\A(?<operand>\<|\<=|\>|\>=)(?<query>.*)\z/
-
       attr_reader :field_name, :term
 
-      def initialize(field_name: nil, minus: nil, quoted: nil, term: nil, token_string: nil)
+      # @param [true, false] downcased
+      def initialize(downcased: nil, field_name: nil, minus: nil, quoted: nil, term: nil, token_string: nil)
+        @downcased = downcased
         @field_name = field_name
         @minus = minus
         @quoted = quoted
@@ -13,10 +13,19 @@ module Qiita
         @token_string = token_string
       end
 
+      # @return [true, false] True if its term must be treated with downcased
+      def downcased?
+        !!@downcased
+      end
+
       def downcased_term
         @downcased_term ||= term.downcase
       end
 
+      def to_hash
+        fail NotImplementedError
+      end
+
       def filter?
         !field_name.nil? || negative?
       end
@@ -50,6 +59,15 @@ module Qiita
         @minus.nil?
       end
 
+      # @return [String] Downcased or not-downcased term
+      def proper_cased_term
+        if downcased?
+          downcased_term
+        else
+          term
+        end
+      end
+
       # @return [true, false] True if this token is for phrase matching
       # @note `Express OR "Ruby on Rails"`
       #                   ^^^^^^^^^^^^^^^
@@ -57,35 +75,6 @@ module Qiita
       def quoted?
         !!@quoted
       end
-
-      # @return [String, nil]
-      # @example Suppose @term is "created_at:>=2015-04-16"
-      #   range_parameter #=> "gte"
-      def range_parameter
-        range_match[:operand] ? operand_map[range_match[:operand]] : nil
-      end
-
-      # @return [String, nil]
-      # @example Suppose @term is "created_at:>=2015-04-16"
-      #   range_query #=> "2015-04-16"
-      def range_query
-        range_match[:query]
-      end
-
-      private
-
-      def range_match
-        @range_match ||= RANGE_TERM_REGEXP.match(@term) || {}
-      end
-
-      def operand_map
-        {
-          ">" => "gt",
-          ">=" => "gte",
-          "<" => "lt",
-          "<=" => "lte",
-        }
-      end
     end
   end
 end

data/lib/qiita/elasticsearch/tokenizer.rb

@@ -1,9 +1,15 @@
-require "qiita/elasticsearch/token"
+require "qiita/elasticsearch/filterable_token"
+require "qiita/elasticsearch/hierarchal_token"
+require "qiita/elasticsearch/matchable_token"
+require "qiita/elasticsearch/range_token"
 
 module Qiita
   module Elasticsearch
     class Tokenizer
+      DEFAULT_DOWNCASED_FIELDS = []
       DEFAULT_FILTERABLE_FIELDS = []
+      DEFAULT_HIERARCHAL_FIELDS = []
+      DEFAULT_RANGE_FIELDS = []
 
       TOKEN_PATTERN = /
         (?<token_string>
@@ -17,9 +23,17 @@ module Qiita
         )
       /x
 
+      # @param [Array<String>, nil] downcased_fields
       # @param [Array<String>, nil] filterable_fields
-      def initialize(filterable_fields: nil)
+      # @param [Array<String>, nil] hierarchal_fields
+      # @param [Array<String>, nil] matchable_fields
+      # @param [Array<String>, nil] range_fields
+      def initialize(downcased_fields: nil, filterable_fields: nil, hierarchal_fields: nil, matchable_fields: nil, range_fields: nil)
+        @downcased_fields = downcased_fields
         @filterable_fields = filterable_fields
+        @hierarchal_fields = hierarchal_fields
+        @matchable_fields = matchable_fields
+        @range_fields = range_fields
       end
 
       # @param [String] query_string Raw query string
@@ -31,21 +45,49 @@ module Qiita
             term = "#{field_name}:#{term}"
             field_name = nil
           end
-          Token.new(
+          token = token_class(field_name).new(
+            downcased: downcased_fields.include?(field_name),
             field_name: field_name,
             minus: minus,
             quoted: !quoted_term.nil?,
             term: term,
             token_string: token_string,
           )
+          token.matchable_fields = @matchable_fields if token.is_a?(MatchableToken)
+          token
         end
       end
 
       private
 
+      def downcased_fields
+        @downcased_fields || DEFAULT_DOWNCASED_FIELDS
+      end
+
       def filterable_fields
         @filterable_fields || DEFAULT_FILTERABLE_FIELDS
       end
+
+      def hierarchal_fields
+        @hierarchal_fields || DEFAULT_HIERARCHAL_FIELDS
+      end
+
+      def range_fields
+        @range_fields || DEFAULT_RANGE_FIELDS
+      end
+
+      def token_class(field_name)
+        case
+        when range_fields.include?(field_name)
+          RangeToken
+        when hierarchal_fields.include?(field_name)
+          HierarchalToken
+        when filterable_fields.include?(field_name)
+          FilterableToken
+        else
+          MatchableToken
+        end
+      end
     end
   end
 end

data/lib/qiita/elasticsearch/version.rb

@@ -1,5 +1,5 @@
 module Qiita
   module Elasticsearch
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-16 00:00:00.000000000 Z
+date: 2015-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,6 +97,9 @@ files:
 - README.md
 - Rakefile
 - lib/qiita/elasticsearch.rb
+- lib/qiita/elasticsearch/filterable_token.rb
+- lib/qiita/elasticsearch/hierarchal_token.rb
+- lib/qiita/elasticsearch/matchable_token.rb
 - lib/qiita/elasticsearch/nodes/filter_node.rb
 - lib/qiita/elasticsearch/nodes/filterable_node.rb
 - lib/qiita/elasticsearch/nodes/match_node.rb
@@ -106,6 +109,7 @@ files:
 - lib/qiita/elasticsearch/nodes/query_node.rb
 - lib/qiita/elasticsearch/nodes/term_node.rb
 - lib/qiita/elasticsearch/query_builder.rb
+- lib/qiita/elasticsearch/range_token.rb
 - lib/qiita/elasticsearch/token.rb
 - lib/qiita/elasticsearch/tokenizer.rb
 - lib/qiita/elasticsearch/version.rb
@@ -130,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Elasticsearch client helper for Qiita.