qiita-elasticsearch 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c85be5babc5ed5cefb8af6487087d0612347eaee
-  data.tar.gz: 73a5134cf3385b9e1616faebb4cace348b46313a
+  metadata.gz: 3fc76e99680f3ae5cf6f574778cf5ca6478784bc
+  data.tar.gz: ab714fac5fbc1dda9b07ff2ee94244941f6525ba
 SHA512:
-  metadata.gz: 12222f5696ef38b2afd9b27a0959b965da581deba85bc6b3272cf47d344daf9afa6c2b0fa20b4f9b8b9e82691838a06f4cc8a0805668650a8b8ee16e32bfb922
-  data.tar.gz: 45d3786363ac701876d52f74679611e028e7a1ad1276f74fa0aca2a94226ff11976cb113627bf602c6854b7f2f2d4fbdbee120958fae1ed6fcc802a33d204abb
+  metadata.gz: 0f0419cf79eb3a511d2fbae7ce22cae22dd919abf45c15da5a11a9c4d64c2d5ccd4a219c78647d5512e9d26131d0946af80f87a508fcf35fd89ce97e4b371fb3
+  data.tar.gz: 525def987114b9e7567d0403d44b52a7164782e34ecc318ba2534818ef9a558f0679e400842e50180235eba773d98f189c7546481948cab0ab366cb03f255ce3

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.2.0
+- Use filtered query for negative or filter tokens
+
 ## 0.1.4
 - Use downcased term for term and prefix on filtered query
 

data/README.md

@@ -2,6 +2,8 @@
 Elasticsearch client helper for Qiita.
 
 ## Usage
+`Qiita::Elasticsearch::QueryBuilder` builds Elasticsearch query from query string.
+
 ```rb
 query_builder = Qiita::Elasticsearch::QueryBuilder.new
 #=> #<Qiita::Elasticsearch::QueryBuilder:0x007ff81e67c4d8 @filterable_fields=nil, @matchable_fields=nil>
@@ -20,10 +22,11 @@ query_builder.build('"a b"')
 
 query_builder.build("a OR b")
 #=> {"bool"=>{"should"=>[{"match"=>{"_all"=>"a"}}, {"match"=>{"_all"=>"b"}}]}}
-
 ```
 
 ### matchable_fields
+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"]>
@@ -33,16 +36,30 @@ query_builder.build("a")
 ```
 
 ### filterable_fields
+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>
 
 query_builder.build("tag:a")
-#=> {"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}, "query"=>{"match_all"=>{}}}}
+#=> {"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}}}
 
 query_builder.build("tag:a b")
-#=> {"bool"=>{"must"=>[{"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}, "query"=>{"match_all"=>{}}}}], "should"=>[{"match"=>{"_all"=>"b"}}]}}
+#=> {"bool"=>{"must"=>[{"filtered"=>{"filter"=>{"term"=>{"tag"=>"a"}}}}], "should"=>[{"match"=>{"_all"=>"b"}}]}}
 
 query_builder.build("user:a b")
 #=> {"bool"=>{"should"=>[{"match"=>{"_all"=>"user:a"}}, {"match"=>{"_all"=>"b"}}]}}
 ```
+
+### hierarchal_fields
+Pass `:hierarchal_fields` options with `:matchable_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>
+
+query_builder.build("tag:ruby")
+=> {"filtered"=>{"filter"=>{"bool"=>{"should"=>[{"prefix"=>{"tag"=>"ruby/"}}, {"term"=>{"tag"=>"ruby"}}]}}}}
+```

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

@@ -0,0 +1,73 @@
+require "qiita/elasticsearch/nodes/match_node"
+require "qiita/elasticsearch/nodes/term_node"
+
+module Qiita
+  module Elasticsearch
+    module Nodes
+      class FilterNode
+        # @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)
+          @hierarchal_fields = hierarchal_fields
+          @matchable_fields = matchable_fields
+          @tokens = tokens
+        end
+
+        def to_hash
+          if must_not_tokens.empty? && must_tokens.length == 1
+            TermNode.new(
+              must_tokens.first,
+              hierarchal_fields: @hierarchal_fields,
+            ).to_hash
+          else
+            {
+              "_cache" => true,
+              "bool" => {
+                "must" => must_queries,
+                "must_not" => must_not_queries,
+              }.reject do |key, value|
+                value.empty?
+              end,
+            }
+          end
+        end
+
+        private
+
+        def must_not_queries
+          must_not_tokens.map do |token|
+            if token.field_name.nil?
+              MatchNode.new(
+                token,
+                matchable_fields: @matchable_fields,
+              )
+            else
+              TermNode.new(
+                token,
+                hierarchal_fields: @hierarchal_fields,
+              )
+            end.to_hash
+          end
+        end
+
+        def must_not_tokens
+          @must_not_tokens ||= @tokens.select(&:must_not?)
+        end
+
+        def must_queries
+          must_tokens.map do |token|
+            TermNode.new(
+              token,
+              hierarchal_fields: @hierarchal_fields,
+            ).to_hash
+          end
+        end
+
+        def must_tokens
+          @must_tokens ||= @tokens.select(&:must?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require "qiita/elasticsearch/nodes/filter_node"
+require "qiita/elasticsearch/nodes/query_node"
+
+module Qiita
+  module Elasticsearch
+    module Nodes
+      class FilterableNode
+        # @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)
+          @hierarchal_fields = hierarchal_fields
+          @matchable_fields = matchable_fields
+          @tokens = tokens
+        end
+
+        def to_hash
+          if filter_tokens.empty?
+            QueryNode.new(
+              not_filter_tokens,
+              matchable_fields: @matchable_fields,
+            ).to_hash
+          else
+            {
+              "filtered" => {
+                "filter" => FilterNode.new(
+                  filter_tokens,
+                  hierarchal_fields: @hierarchal_fields,
+                  matchable_fields: @matchable_fields,
+                ).to_hash,
+                "query" => QueryNode.new(
+                  not_filter_tokens,
+                  matchable_fields: @matchable_fields,
+                ).to_hash,
+              }.reject do |key, value|
+                value.empty?
+              end,
+            }
+          end
+        end
+
+        private
+
+        def filter_tokens
+          @filter_tokens ||= @tokens.select(&:filter?)
+        end
+
+        def not_filter_tokens
+          @not_filter_tokens ||= @tokens.reject(&:filter?)
+        end
+      end
+    end
+  end
+end

data/lib/qiita/elasticsearch/nodes/{match_query_node.rb → match_node.rb}

@@ -1,7 +1,7 @@
 module Qiita
   module Elasticsearch
     module Nodes
-      class MatchQueryNode
+      class MatchNode
         # @param [Qiita::Elasticsearch::Token] token
         # @param [Array<String>, nil] matchable_fields
         def initialize(token, matchable_fields: nil)
@@ -9,7 +9,6 @@ module Qiita
           @token = token
         end
 
-        # @return [Hash] match query or multi_match query
         def to_hash
           if @matchable_fields.nil?
             {

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

@@ -0,0 +1,36 @@
+require "qiita/elasticsearch/nodes/match_node"
+
+module Qiita
+  module Elasticsearch
+    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
+          @tokens = tokens
+        end
+
+        def to_hash
+          {
+            "bool" => {
+              "should" => should_queries,
+            },
+          }
+        end
+
+        private
+
+        # @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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require "qiita/elasticsearch/nodes/bool_query_node"
+require "qiita/elasticsearch/nodes/filterable_node"
 require "qiita/elasticsearch/nodes/null_node"
 
 module Qiita
@@ -19,7 +19,7 @@ module Qiita
           when 0
             Nodes::NullNode.new.to_hash
           when 1
-            Nodes::BoolQueryNode.new(
+            Nodes::FilterableNode.new(
               tokens_grouped_by_or_token.first,
               hierarchal_fields: @hierarchal_fields,
               matchable_fields: @matchable_fields,
@@ -28,7 +28,7 @@ module Qiita
             {
               "bool" => {
                 "should" => tokens_grouped_by_or_token.map do |tokens|
-                  Nodes::BoolQueryNode.new(
+                  Nodes::FilterableNode.new(
                     tokens,
                     hierarchal_fields: @hierarchal_fields,
                     matchable_fields: @matchable_fields,

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

@@ -0,0 +1,35 @@
+require "qiita/elasticsearch/nodes/match_node"
+require "qiita/elasticsearch/nodes/multi_should_node"
+
+module Qiita
+  module Elasticsearch
+    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
+          @tokens = tokens
+        end
+
+        def to_hash
+          case @tokens.length
+          when 0
+            {}
+          when 1
+            MatchNode.new(
+              @tokens.first,
+              matchable_fields: @matchable_fields,
+            ).to_hash
+          else
+            MultiShouldNode.new(
+              @tokens,
+              matchable_fields: @matchable_fields,
+            ).to_hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Qiita
+  module Elasticsearch
+    module Nodes
+      class TermNode
+        DEFAULT_HIERARCHAL_FIELDS = []
+
+        # @param [Qiita::Elasticsearch::Token] token
+        # @param [Array<String>, nil] hierarchal_fields
+        def initialize(token, hierarchal_fields: nil)
+          @hierarchal_fields = hierarchal_fields
+          @token = token
+        end
+
+        # @return [Hash]
+        def to_hash
+          if has_hierarchal_token?
+            {
+              "bool" => {
+                "should" => [
+                  {
+                    "prefix" => {
+                      @token.field_name => @token.downcased_term + "/",
+                    },
+                  },
+                  {
+                    "term" => {
+                      @token.field_name => @token.downcased_term,
+                    },
+                  },
+                ],
+              },
+            }
+          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
+      end
+    end
+  end
+end

data/lib/qiita/elasticsearch/token.rb

@@ -15,8 +15,12 @@ module Qiita
         @downcased_term ||= term.downcase
       end
 
+      def filter?
+        !field_name.nil? || negative?
+      end
+
       def must?
-        !field_name.nil? && !negative?
+        !field_name.nil? && positive?
       end
 
       def must_not?
@@ -51,10 +55,6 @@ module Qiita
       def quoted?
         !!@quoted
       end
-
-      def should?
-        !must? && !must_not?
-      end
     end
   end
 end

data/lib/qiita/elasticsearch/version.rb

@@ -1,5 +1,5 @@
 module Qiita
   module Elasticsearch
-    VERSION = "0.1.4"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qiita-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Ryo Nakamura
@@ -97,12 +97,14 @@ files:
 - README.md
 - Rakefile
 - lib/qiita/elasticsearch.rb
-- lib/qiita/elasticsearch/nodes/bool_query_node.rb
-- lib/qiita/elasticsearch/nodes/filter_query_node.rb
-- lib/qiita/elasticsearch/nodes/match_query_node.rb
+- lib/qiita/elasticsearch/nodes/filter_node.rb
+- lib/qiita/elasticsearch/nodes/filterable_node.rb
+- lib/qiita/elasticsearch/nodes/match_node.rb
+- lib/qiita/elasticsearch/nodes/multi_should_node.rb
 - lib/qiita/elasticsearch/nodes/null_node.rb
 - lib/qiita/elasticsearch/nodes/or_separatable_node.rb
-- lib/qiita/elasticsearch/nodes/token_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

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

@@ -1,103 +0,0 @@
-require "qiita/elasticsearch/nodes/token_node"
-
-module Qiita
-  module Elasticsearch
-    module Nodes
-      class BoolQueryNode
-        # @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)
-          @hierarchal_fields = hierarchal_fields
-          @matchable_fields = matchable_fields
-          @tokens = tokens
-        end
-
-        def to_hash
-          case
-          when has_only_one_should_token?
-            should_query
-          when has_only_one_must_token?
-            must_query
-          else
-            {
-              "bool" => {
-                "must" => must_queries,
-                "must_not" => must_not_queries,
-                "should" => should_queries,
-              }.reject do |key, value|
-                value.empty?
-              end,
-            }
-          end
-        end
-
-        private
-
-        def has_only_one_must_token?
-          must_not_tokens.empty? && should_tokens.empty? && must_tokens.size == 1
-        end
-
-        def has_only_one_should_token?
-          must_not_tokens.empty? && must_tokens.empty? && should_tokens.size == 1
-        end
-
-        def must_not_queries
-          must_not_tokens.map do |token|
-            Nodes::TokenNode.new(
-              token,
-              hierarchal_fields: @hierarchal_fields,
-              matchable_fields: @matchable_fields,
-            ).to_hash
-          end
-        end
-
-        def must_not_tokens
-          @must_not_tokens ||= @tokens.select(&:must_not?)
-        end
-
-        def must_query
-          Nodes::TokenNode.new(
-            must_tokens.first,
-            hierarchal_fields: @hierarchal_fields,
-            matchable_fields: @matchable_fields,
-          ).to_hash
-        end
-
-        def must_queries
-          must_tokens.map do |token|
-            Nodes::TokenNode.new(
-              token,
-              hierarchal_fields: @hierarchal_fields,
-              matchable_fields: @matchable_fields,
-            ).to_hash
-          end
-        end
-
-        def must_tokens
-          @must_tokens ||= @tokens.select(&:must?)
-        end
-
-        def should_query
-          Nodes::TokenNode.new(
-            should_tokens.first,
-            matchable_fields: @matchable_fields,
-          ).to_hash
-        end
-
-        def should_queries
-          should_tokens.map do |token|
-            Nodes::TokenNode.new(
-              token,
-              matchable_fields: @matchable_fields,
-            ).to_hash
-          end
-        end
-
-        def should_tokens
-          @should_tokens ||= @tokens.select(&:should?)
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-module Qiita
-  module Elasticsearch
-    module Nodes
-      class FilterQueryNode
-        DEFAULT_HIERARCHAL_FIELDS = []
-
-        # @param [Qiita::Elasticsearch::Token] token
-        def initialize(token, hierarchal_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @token = token
-        end
-
-        # @return [Hash]
-        def to_hash
-          if has_hierarchal_token?
-            {
-              "filtered" => {
-                "filter" => {
-                  "bool" => {
-                    "should" => [
-                      {
-                        "prefix" => {
-                          @token.field_name => @token.downcased_term + "/",
-                        },
-                      },
-                      {
-                        "term" => {
-                          @token.field_name => @token.downcased_term,
-                        },
-                      },
-                    ],
-                  },
-                },
-                "query" => {
-                  "match_all" => {},
-                },
-              },
-            }
-          else
-            {
-              "filtered" => {
-                "filter" => {
-                  "term" => {
-                    @token.field_name => @token.downcased_term,
-                  },
-                },
-                "query" => {
-                  "match_all" => {},
-                },
-              },
-            }
-          end
-        end
-
-        private
-
-        def has_hierarchal_token?
-          hierarchal_fields.include?(@token.field_name)
-        end
-
-        def hierarchal_fields
-          @hierarchal_fields || DEFAULT_HIERARCHAL_FIELDS
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require "qiita/elasticsearch/nodes/filter_query_node"
-require "qiita/elasticsearch/nodes/match_query_node"
-
-module Qiita
-  module Elasticsearch
-    module Nodes
-      class TokenNode
-        # @param [Qiita::Elasticsearch::Token] token
-        # @param [Array<String>, nil] hierarchal_fields
-        # @param [Array<String>, nil] matchable_fields
-        def initialize(token, hierarchal_fields: nil, matchable_fields: nil)
-          @hierarchal_fields = hierarchal_fields
-          @matchable_fields = matchable_fields
-          @token = token
-        end
-
-        def to_hash
-          if @token.field_name
-            FilterQueryNode.new(@token, hierarchal_fields: @hierarchal_fields).to_hash
-          else
-            MatchQueryNode.new(@token, matchable_fields: @matchable_fields).to_hash
-          end
-        end
-      end
-    end
-  end
-end