groonga-client 0.5.9 → 0.6.4

data/lib/groonga/client/response/drilldownable.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2019  Sutou Kouhei <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    module Response
+      module Drilldownable
+        # @return [::Array<Groonga::Client::Response::Select::Drilldown>,
+        #          ::Hash<String, Groonga::Client::Response::Select::Drilldown>]
+        #   If labeled drilldowns are used or command version 3 or
+        #   later is used, `{"label1" => drilldown1, "label2" => drilldown2}`
+        #   is returned since 0.3.1.
+        #
+        #   Otherwise, `[drilldown1, drilldown2]` is returned.
+        attr_accessor :drilldowns
+
+        private
+        def parse_drilldown(label, keys, raw_drilldown)
+          if raw_drilldown.is_a?(::Array)
+            n_hits = raw_drilldown[0][0]
+            raw_columns = raw_drilldown[1]
+            raw_records = raw_drilldown[2..-1]
+          else
+            n_hits = raw_drilldown["n_hits"]
+            raw_columns = raw_drilldown["columns"]
+            raw_records = raw_drilldown["records"]
+          end
+          records = parse_records(raw_columns, raw_records)
+          Drilldown.new(label,
+                        keys,
+                        n_hits,
+                        records,
+                        raw_columns,
+                        raw_records)
+        end
+
+        def parse_drilldowns(keys, raw_drilldowns)
+          (raw_drilldowns || []).collect.with_index do |raw_drilldown, i|
+            key = keys[i]
+            parse_drilldown(key, [key], raw_drilldown)
+          end
+        end
+
+        def parse_labeled_drilldowns(labeled_drilldown_requests,
+                                     raw_drilldowns)
+          drilldowns = {}
+          (raw_drilldowns || {}).each do |label, raw_drilldown|
+            labeled_drilldown_request = labeled_drilldown_requests[label]
+            drilldowns[label] = parse_drilldown(label,
+                                                labeled_drilldown_request.keys,
+                                                raw_drilldown)
+          end
+          drilldowns
+        end
+
+        class Drilldown < Struct.new(:label,
+                                     :keys,
+                                     :n_hits,
+                                     :records,
+                                     :raw_columns,
+                                     :raw_records)
+          # @deprecated since 0.2.6. Use {#records} instead.
+          alias_method :items, :records
+
+          def key
+            keys.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/response/logical-range-filter.rb

@@ -0,0 +1,52 @@
+# Copyright (C) 2019  Sutou Kouhei <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga/client/response/base"
+require "groonga/client/response/searchable"
+
+module Groonga
+  class Client
+    module Response
+      class LogicalRangeFilter < Base
+        Response.register("logical_range_filter", self)
+
+        include Searchable
+
+        attr_accessor :records
+
+        def body=(body)
+          super(body)
+          parse_body(body)
+        end
+
+        private
+        def parse_body(body)
+          if body.is_a?(::Array)
+            @raw_columns, *@raw_records = body.first
+            @raw_records ||= []
+            @records = parse_records(raw_columns, raw_records)
+          else
+            @raw_columns = body["columns"]
+            @raw_records = body["records"] || []
+          end
+          @records = parse_records(@raw_columns, @raw_records)
+          body
+        end
+      end
+    end
+  end
+end
+

data/lib/groonga/client/response/logical-select.rb

@@ -0,0 +1,28 @@
+# Copyright (C) 2019  Sutou Kouhei <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga/client/response/select"
+
+module Groonga
+  class Client
+    module Response
+      class LogicalSelect < Select
+        Response.register("logical_select", self)
+      end
+    end
+  end
+end
+

data/lib/groonga/client/response/searchable.rb

@@ -0,0 +1,97 @@
+# Copyright (C) 2019  Sutou Kouhei <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    module Response
+      module Searchable
+        include Enumerable
+
+        attr_accessor :records
+        attr_accessor :raw_columns
+        attr_accessor :raw_records
+
+        # For Kaminari
+        def limit_value
+          (@command[:limit] || 10).to_i
+        end
+
+        # For Kaminari
+        def offset_value
+          (@command[:offset] || 0).to_i
+        end
+
+        # For Kaminari
+        def size
+          records.size
+        end
+
+        def each(&block)
+          records.each(&block)
+        end
+
+        private
+        def parse_records(raw_columns, raw_records)
+          column_names = {}
+          columns = raw_columns.collect do |column|
+            if column.is_a?(::Array)
+              name, type = column
+            else
+              name = column["name"]
+              type = column["type"]
+            end
+            base_column_name = name
+            suffix = 2
+            while column_names.key?(name)
+              name = "#{base_column_name}#{suffix}"
+              suffix += 1
+            end
+            column_names[name] = true
+            [name, type]
+          end
+
+          (raw_records || []).collect do |raw_record|
+            record = Record.new
+            columns.each_with_index do |(name, type), i|
+              record[name] = convert_value(raw_record[i], type)
+            end
+            record
+          end
+        end
+
+        def convert_value(value, type)
+          case value
+          when ::Array
+            value.collect do |element|
+              convert_value(element, type)
+            end
+          else
+            case type
+            when "Time"
+              Time.at(value)
+            else
+              value
+            end
+          end
+        end
+
+        class Record < ::Hash
+          include Hashie::Extensions::MethodAccess
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/response/select.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2019  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2013  Kosuke Asami
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
@@ -17,6 +17,8 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "groonga/client/response/base"
+require "groonga/client/response/drilldownable"
+require "groonga/client/response/searchable"
 
 module Groonga
   class Client
@@ -174,23 +176,14 @@ module Groonga
           end
         end
 
-        include Enumerable
+        include Drilldownable
+        include Searchable
 
         # @return [Integer] The number of records that match againt
         #   a search condition.
         attr_accessor :n_hits
         # For Kaminari
         alias_method :total_count, :n_hits
-        attr_accessor :records
-
-        # @return [::Array<Groonga::Client::Response::Select::Drilldown>,
-        #          ::Hash<String, Groonga::Client::Response::Select::Drilldown>]
-        #   If labeled drilldowns are used or command version 3 or
-        #   later is used, `{"label1" => drilldown1, "label2" => drilldown2}`
-        #   is returned since 0.3.1.
-        #
-        #   Otherwise, `[drilldown1, drilldown2]` is returned.
-        attr_accessor :drilldowns
 
         # @return [::Hash<String, Groonga::Client::Response::Select::Slice>]
         #
@@ -202,29 +195,11 @@ module Groonga
           parse_body(body)
         end
 
-        # For Kaminari
-        def limit_value
-          (@command[:limit] || 10).to_i
-        end
-
-        # For Kaminari
-        def offset_value
-          (@command[:offset] || 0).to_i
-        end
-
-        # For Kaminari
-        def size
-          records.size
-        end
-
-        def each(&block)
-          records.each(&block)
-        end
-
         private
         def parse_body(body)
           if body.is_a?(::Array)
-            @n_hits, @records = parse_match_records_v1(body.first)
+            @n_hits, @raw_columns, @raw_records, @records =
+              parse_record_set_v1(body.first)
             if @command.slices.empty?
               raw_slices = nil
               raw_drilldowns = body[1..-1]
@@ -232,105 +207,74 @@ module Groonga
               raw_slices, *raw_drilldowns = body[1..-1]
             end
             @slices = parse_slices_v1(raw_slices)
-            @drilldowns = parse_drilldowns_v1(raw_drilldowns)
-          else
-            @n_hits, @records = parse_match_records_v3(body)
-            @drilldowns = parse_drilldowns_v3(body["drilldowns"])
-            @slices = parse_slices_v3(body["slices"])
-          end
-          body
-        end
-
-        def parse_records(raw_columns, raw_records)
-          column_names = {}
-          columns = raw_columns.collect do |column|
-            if column.is_a?(::Array)
-              name, type = column
+            drilldown_keys = @command.drilldowns
+            labeled_drilldowns = @command.labeled_drilldowns
+            if drilldown_keys.empty? and !labeled_drilldowns.empty?
+              @drilldowns = parse_labeled_drilldowns(labeled_drilldowns,
+                                                     raw_drilldowns[0])
             else
-              name = column["name"]
-              type = column["type"]
-            end
-            base_column_name = name
-            suffix = 2
-            while column_names.key?(name)
-              name = "#{base_column_name}#{suffix}"
-              suffix += 1
-            end
-            column_names[name] = true
-            [name, type]
-          end
-
-          (raw_records || []).collect do |raw_record|
-            record = Record.new
-            columns.each_with_index do |(name, type), i|
-              record[name] = convert_value(raw_record[i], type)
-            end
-            record
-          end
-        end
-
-        def convert_value(value, type)
-          case value
-          when ::Array
-            value.collect do |element|
-              convert_value(element, type)
+              @drilldowns = parse_drilldowns(drilldown_keys, raw_drilldowns)
             end
           else
-            case type
-            when "Time"
-              Time.at(value)
-            else
-              value
+            @n_hits, @raw_columns, @raw_records, @records =
+              parse_record_set_v3(body)
+            drilldown_keys = @command.drilldowns
+            labeled_drilldowns = @command.labeled_drilldowns
+            if labeled_drilldowns.empty?
+              drilldown_keys.each do |key|
+                labeled_drilldown =
+                  Groonga::Command::Drilldownable::Drilldown.new
+                labeled_drilldown.label = key
+                labeled_drilldown.keys = [key]
+                labeled_drilldowns[key] = labeled_drilldown
+              end
             end
+            @drilldowns = parse_labeled_drilldowns(labeled_drilldowns,
+                                                   body["drilldowns"])
+            @slices = parse_slices_v3(body["slices"])
           end
+          body
         end
 
-        def parse_match_records_v1(raw_records)
+        def parse_record_set_v1(raw_record_set)
+          n_hits = raw_record_set.first.first
+          raw_columns = raw_record_set[1]
+          raw_records = raw_record_set[2..-1] || []
           [
-            raw_records.first.first,
-            parse_records(raw_records[1], raw_records[2..-1]),
+            n_hits,
+            raw_columns,
+            raw_records,
+            parse_records(raw_columns, raw_records),
           ]
         end
 
-        def parse_match_records_v3(raw_records)
+        def parse_record_set_v3(raw_record_set)
+          n_hits = raw_record_set["n_hits"]
+          raw_columns = raw_record_set["columns"]
+          raw_records = raw_record_set["records"] || []
           [
-            raw_records["n_hits"],
-            parse_records(raw_records["columns"], raw_records["records"]),
+            n_hits,
+            raw_columns,
+            raw_records,
+            parse_records(raw_columns, raw_records),
           ]
         end
 
-        def parse_drilldowns_v1(raw_drilldowns)
-          request_drilldowns = @command.drilldowns
-          if request_drilldowns.empty? and !@command.labeled_drilldowns.empty?
-            drilldowns = {}
-            (raw_drilldowns[0] || {}).each do |label, raw_drilldown|
-              n_hits, records = parse_match_records_v1(raw_drilldown)
-              drilldowns[label] = Drilldown.new(label, n_hits, records)
-            end
-            drilldowns
-          else
-            (raw_drilldowns || []).collect.with_index do |raw_drilldown, i|
-              key = request_drilldowns[i]
-              n_hits, records = parse_match_records_v1(raw_drilldown)
-              Drilldown.new(key, n_hits, records)
-            end
-          end
-        end
-
-        def parse_drilldowns_v3(raw_drilldowns)
-          drilldowns = {}
-          (raw_drilldowns || {}).each do |key, raw_drilldown|
-            n_hits, records = parse_match_records_v3(raw_drilldown)
-            drilldowns[key] = Drilldown.new(key, n_hits, records)
-          end
-          drilldowns
-        end
-
         def parse_slices_v1(raw_slices)
           slices = {}
           (raw_slices || {}).each do |key, raw_slice|
-            n_hits, records = parse_match_records_v1(raw_slice)
-            slices[key] = Slice.new(key, n_hits, records)
+            requested_slice = @command.slices[key]
+            if raw_slice.last.is_a?(::Hash)
+              raw_drilldowns = raw_slice.last
+              raw_slice = raw_slice[0..-2]
+              drilldowns =
+                parse_labeled_drilldowns(requested_slice.labeled_drilldowns,
+                                         raw_drilldowns)
+            else
+              drilldowns = {}
+            end
+            n_hits, _, _, records = parse_record_set_v1(raw_slice)
+            slices[key] = Slice.new(key, n_hits, records, drilldowns)
           end
           slices
         end
@@ -338,22 +282,17 @@ module Groonga
         def parse_slices_v3(raw_slices)
           slices = {}
           (raw_slices || {}).each do |key, raw_slice|
-            n_hits, records = parse_match_records_v3(raw_slice)
-            slices[key] = Slice.new(key, n_hits, records)
+            requested_slice = @command.slices[key]
+            n_hits, _, _, records = parse_record_set_v3(raw_slice)
+              drilldowns =
+                parse_labeled_drilldowns(requested_slice.labeled_drilldowns,
+                                         raw_slice["drilldowns"])
+            slices[key] = Slice.new(key, n_hits, records, drilldowns)
           end
           slices
         end
 
-        class Record < ::Hash
-          include Hashie::Extensions::MethodAccess
-        end
-
-        class Drilldown < Struct.new(:key, :n_hits, :records)
-          # @deprecated since 0.2.6. Use {#records} instead.
-          alias_method :items, :records
-        end
-
-        class Slice < Struct.new(:key, :n_hits, :records)
+        class Slice < Struct.new(:key, :n_hits, :records, :drilldowns)
         end
       end
     end