qiita-elasticsearch 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8560c892e6ef0e111e0a382d6d194b93eed3fb82
-  data.tar.gz: c7fde536c988141b2550462cac74a38419b8933c
+  metadata.gz: aaa3120e317dceee23661a755b4a9eb2f38f2694
+  data.tar.gz: db119b903847b6287106d7205a945aa6218c7816
 SHA512:
-  metadata.gz: 4835e6a0299c1dc4e930b347e26854763a1e5e968488a91db46e40b773acc6ebb0472d21103c8c9e9cec460ee9f6f31e8553149068dc98a2e09aa3896ccc0b90
-  data.tar.gz: 074d7ecd0a00f12fea0513bae0a875aa6b554c46c2a3d8d0cabe6c691ba92d0ace07e43ef41d5f846d56ca01194746014305ddbdf44922aaa30c616e40edf271
+  metadata.gz: 5f3454a506c3c3fae11b682c23acd2a4d0b197cd8409f67b98078e6cead69c8e92a9949119d556675c6333439204a0dc25bae5c819cc843968267c593083de9e
+  data.tar.gz: 54baba6c1bd52bba643b8961c5038ce86f8d3de46afd6682f706b0a139995c16dc0685667e9af16f0bfb9bdcfbd7fb12643ed90fba344367ccde0b639672b8ad

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.2.2
+- Support range fields
+
 ## 0.2.1
 - Fix _cache property on filtered queries
 

data/README.md

@@ -6,7 +6,7 @@ Elasticsearch client helper for Qiita.
 
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new
-#=> #<Qiita::Elasticsearch::QueryBuilder:0x007ff81e67c4d8 @filterable_fields=nil, @matchable_fields=nil>
+#=> #<Qiita::Elasticsearch::QueryBuilder:0x007ff81e67c4d8 @filterable_fields=nil, @hierarchal_fields=nil, @matchable_fields=nil>
 
 query_builder.build("a")
 #=> {"match"=>{"_all"=>"a"}}
@@ -15,7 +15,7 @@ query_builder.build("a b")
 #=> {"bool"=>{"should"=>[{"match"=>{"_all"=>"a"}}, {"match"=>{"_all"=>"b"}}]}}
 
 query_builder.build("a -b")
-#=> {"bool"=>{"must_not"=>[{"match"=>{"_all"=>"b"}}], "should"=>[{"match"=>{"_all"=>"a"}}]}}
+#=> {"filtered"=> {"filter"=>{"bool"=>{"_cache"=>true, "must_not"=>[{"match"=>{"_all"=>"b"}}]}}, "query"=>{"match"=>{"_all"=>"a"}}}}
 
 query_builder.build('"a b"')
 #=> {"match_phrase"=>{"_all"=>"a b"}}
@@ -29,7 +29,7 @@ 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, @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,13 +40,13 @@ 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"], @matchable_fields=nil>
+#=> #<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"}}}}
 
 query_builder.build("tag:a b")
-#=> {"bool"=>{"must"=>[{"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}}}], "should"=>[{"match"=>{"_all"=>"b"}}]}}
+#=> {"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}, "query"=>{"match"=>{"_all"=>"b"}}}}
 
 query_builder.build("user:a b")
 #=> {"bool"=>{"should"=>[{"match"=>{"_all"=>"user:a"}}, {"match"=>{"_all"=>"b"}}]}}
@@ -58,8 +58,20 @@ 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>
+#=> #<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.
+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"}}}}}
+```

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

@@ -8,9 +8,11 @@ module Qiita
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
         # @param [Array<String>, nil] hierarchal_fields
         # @param [Array<String>, nil] matchable_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil)
+        # @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
           @tokens = tokens
         end
 
@@ -19,6 +21,7 @@ module Qiita
             TermNode.new(
               must_tokens.first,
               hierarchal_fields: @hierarchal_fields,
+              range_fields: @range_fields,
             ).to_hash
           else
             {
@@ -46,6 +49,7 @@ module Qiita
               TermNode.new(
                 token,
                 hierarchal_fields: @hierarchal_fields,
+                range_fields: @range_fields,
               )
             end.to_hash
           end
@@ -60,6 +64,7 @@ module Qiita
             TermNode.new(
               token,
               hierarchal_fields: @hierarchal_fields,
+              range_fields: @range_fields,
             ).to_hash
           end
         end

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

@@ -8,9 +8,11 @@ module Qiita
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
         # @param [Array<String>, nil] hierarchal_fields
         # @param [Array<String>, nil] matchable_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil)
+        # @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
           @tokens = tokens
         end
 
@@ -27,6 +29,7 @@ module Qiita
                   filter_tokens,
                   hierarchal_fields: @hierarchal_fields,
                   matchable_fields: @matchable_fields,
+                  range_fields: @range_fields,
                 ).to_hash,
                 "query" => QueryNode.new(
                   not_filter_tokens,

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

@@ -8,9 +8,11 @@ module Qiita
         # @param [Array<Qiita::Elasticsearch::Tokens>] tokens
         # @param [Array<String>, nil] hierarchal_fields
         # @param [Array<String>, nil] matchable_fields
-        def initialize(tokens, hierarchal_fields: nil, matchable_fields: nil)
+        # @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
           @tokens = tokens
         end
 
@@ -23,6 +25,7 @@ module Qiita
               tokens_grouped_by_or_token.first,
               hierarchal_fields: @hierarchal_fields,
               matchable_fields: @matchable_fields,
+              range_fields: @range_fields,
             ).to_hash
           else
             {
@@ -32,6 +35,7 @@ module Qiita
                     tokens,
                     hierarchal_fields: @hierarchal_fields,
                     matchable_fields: @matchable_fields,
+                    range_fields: @range_fields,
                   ).to_hash
                 end,
               },

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

@@ -3,17 +3,21 @@ module Qiita
     module Nodes
       class TermNode
         DEFAULT_HIERARCHAL_FIELDS = []
+        DEFAULT_RANGE_FIELDS = []
 
         # @param [Qiita::Elasticsearch::Token] token
         # @param [Array<String>, nil] hierarchal_fields
-        def initialize(token, hierarchal_fields: nil)
+        # @param [Array<String>, nil] range_fields
+        def initialize(token, hierarchal_fields: nil, range_fields: nil)
           @hierarchal_fields = hierarchal_fields
+          @range_fields = range_fields
           @token = token
         end
 
         # @return [Hash]
         def to_hash
-          if has_hierarchal_token?
+          case
+          when has_hierarchal_token?
             {
               "bool" => {
                 "should" => [
@@ -30,6 +34,14 @@ module Qiita
                 ],
               },
             }
+          when has_range_token?
+            {
+              "range" => {
+                @token.field_name => {
+                  @token.range_parameter => @token.range_query,
+                },
+              },
+            }
           else
             {
               "term" => {
@@ -48,6 +60,14 @@ module Qiita
         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
+        end
       end
     end
   end

data/lib/qiita/elasticsearch/query_builder.rb

@@ -1,6 +1,6 @@
 require "qiita/elasticsearch/nodes/null_node"
 require "qiita/elasticsearch/nodes/or_separatable_node"
-require "qiita/elasticsearch/parser"
+require "qiita/elasticsearch/tokenizer"
 
 module Qiita
   module Elasticsearch
@@ -8,16 +8,18 @@ module Qiita
       # @param [Array<String>, nil] filterable_fields
       # @param [Array<String>, nil] hierarchal_fields
       # @param [Array<String>, nil] matchable_fields
-      def initialize(hierarchal_fields: nil, filterable_fields: nil, matchable_fields: nil)
+      # @param [Array<String>, nil] range_fields
+      def initialize(hierarchal_fields: nil, filterable_fields: nil, matchable_fields: nil, range_fields: nil)
         @hierarchal_fields = hierarchal_fields
         @filterable_fields = filterable_fields
         @matchable_fields = matchable_fields
+        @range_fields = range_fields
       end
 
       # @param [String] query_string Raw query string
       # @return [Hash]
       def build(query_string)
-        tokens = parser.parse(query_string)
+        tokens = tokenizer.tokenize(query_string)
         if tokens.size.zero?
           Nodes::NullNode.new.to_hash
         else
@@ -25,14 +27,15 @@ module Qiita
             tokens,
             hierarchal_fields: @hierarchal_fields,
             matchable_fields: @matchable_fields,
+            range_fields: @range_fields,
           ).to_hash
         end
       end
 
       private
 
-      def parser
-        @parser ||= Parser.new(filterable_fields: @filterable_fields)
+      def tokenizer
+        @tokenizer ||= Tokenizer.new(filterable_fields: @filterable_fields)
       end
     end
   end

data/lib/qiita/elasticsearch/token.rb

@@ -1,6 +1,8 @@
 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)
@@ -55,6 +57,35 @@ 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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-18 00:00:00.000000000 Z
+date: 2015-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,7 +105,6 @@ files:
 - lib/qiita/elasticsearch/nodes/or_separatable_node.rb
 - lib/qiita/elasticsearch/nodes/query_node.rb
 - lib/qiita/elasticsearch/nodes/term_node.rb
-- lib/qiita/elasticsearch/parser.rb
 - lib/qiita/elasticsearch/query_builder.rb
 - lib/qiita/elasticsearch/token.rb
 - lib/qiita/elasticsearch/tokenizer.rb
@@ -131,9 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Elasticsearch client helper for Qiita.
 test_files: []
-has_rdoc: 

data/lib/qiita/elasticsearch/parser.rb

@@ -1,24 +0,0 @@
-require "qiita/elasticsearch/tokenizer"
-
-module Qiita
-  module Elasticsearch
-    class Parser
-      # @param [Array<String>, nil] filterable_fields
-      def initialize(filterable_fields: nil)
-        @filterable_fields = filterable_fields
-      end
-
-      # @param [String] query_string Raw query string
-      # @return [Array<Qiita::Elasticsearch::Token>]
-      def parse(query_string)
-        tokenizer.tokenize(query_string)
-      end
-
-      private
-
-      def tokenizer
-        @tokenizer ||= Tokenizer.new(filterable_fields: @filterable_fields)
-      end
-    end
-  end
-end