groonga-client 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d5741b1b6164b64e7182714c95af93da3b9ff9c
-  data.tar.gz: 3fbba89037ca39c830e91e9c0b3a067a1001ea5a
+  metadata.gz: 37800c0ceaac12320a9c1d92cf63012703cf8b1d
+  data.tar.gz: d7dfd6abd5db78f48e8602759245d110e593c632
 SHA512:
-  metadata.gz: 4db4ee9f1ee50a06dee0f93e48783dd9d831e11de89be558f071475adcb02dafbc4a770f6b136585bde797655446cbf2f831bbabdb27d13f4fbea736a63a3215
-  data.tar.gz: 6e0bd4b40e1967f45f0f3070f006a23178fa81aee66fe8b18227f41d2936a2a71eacffecebd23a2a6cecf2653c1f5694e05bd43b282d981bffa3e9450aaf72b3
+  metadata.gz: 48a5b7f236ada9ad6aa43d29901ac253721cb101ecb37141320fc3cddb29b0f6d45bf5b4ba37b85ae6b3630ea4f70305acce34d4425def8ec72badc1d7f47a3c
+  data.tar.gz: ff37c41507bcdf210f557eb6afa4b54443cd14b5ee9246bfc197b8c30691875ce1b78e66c601578e6726a37f63997d4f60d19e6685b6aa5ed9398758538efb2e

data/doc/text/news.md

@@ -1,5 +1,17 @@
 # NEWS
 
+## 0.2.6 - 2016-06-17
+
+### Improvements
+
+  * Supported command version 3.
+
+  * Added {Groonga::Client::Response#return_code}.
+    {Groonga::Client::Response#status_code} is deprecated. Use
+    `#return_code` instead.
+
+  * `select` response: Supported vector of `Time`.
+
 ## 0.2.5 - 2016-04-02
 
 ### Fixes

data/groonga-client.gemspec

@@ -51,7 +51,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency("bundler")
   spec.add_development_dependency("rake")
   spec.add_development_dependency("test-unit")
-  spec.add_development_dependency("test-unit-notify")
   spec.add_development_dependency("test-unit-rr")
   spec.add_development_dependency("packnga")
   spec.add_development_dependency("redcarpet")

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

@@ -39,7 +39,7 @@ module Groonga
         # response object.
         #
         # @param [Groonga::Command::Base] The command of the request.
-        # @param [String] The raw (not parsed) response returned by groonga
+        # @param [String] The raw (not parsed) response returned by Groonga
         #   server.
         # @return [Base]
         def parse(command, raw_response)
@@ -61,16 +61,26 @@ module Groonga
       class Base
         class << self
           def parse(command, raw_response)
+            return_code = nil
             case command.output_type
             when :json
-              header, body = JSON.parse(raw_response)
+              response = JSON.parse(raw_response)
+              if response.is_a?(::Array)
+                header, body = response
+                return_code = header[0] if header
+              else
+                header = response["header"]
+                body = response["body"]
+                return_code = header["return_code"] if header
+              end
             when :xml
               header, body = parse_xml(raw_response)
+              return_code = header[0] if header
             else
               header = nil
               body = raw_response
             end
-            if header.nil? or header[0].zero?
+            if header.nil? or return_code == 0
               response = new(command, header, body)
             else
               response = Error.new(command, header, body)
@@ -136,7 +146,7 @@ module Groonga
         #   `[return_code, start_time, elapsed_time_in_seconds, error_message, error_location]`
         #   for error case.
         # @see http://groonga.org/docs/reference/command/output_format.html#header
-        #   Defails for header format.
+        #   Details for header format.
         attr_accessor :header
         # @return [::Hash] The body of response. Its content is depends on
         #   command.
@@ -144,7 +154,7 @@ module Groonga
         #   The list of built-in commands.
         attr_accessor :body
         # @return [String] The unparsed response. It may be JSON, XML or
-        #   groonga command format.
+        #   Groonga command format.
         attr_accessor :raw
 
         def initialize(command, header, body)
@@ -154,35 +164,72 @@ module Groonga
           self.raw = nil
         end
 
+        # @return [Integer] The return code of the response.
+        # @since 0.2.6
+        def return_code
+          if header.nil?
+            0
+          elsif header_v1?
+            header[0]
+          else
+            header["return_code"] || 0
+          end
+        end
+
         # @return [Integer] The status code of the response.
         # @since 0.1.0
+        #
+        # @deprecated since 0.2.6. Use {return_code} instead.
         def status_code
-          (header || [0])[0]
+          return_code
         end
 
         # @return [Time] The time of the request is accepted.
         # @since 0.1.0
         def start_time
-          Time.at((header || [0, 0])[1])
+          if header.nil?
+            Time.at(0)
+          elsif header_v1?
+            Time.at(header[1])
+          else
+            Time.at(header["start_time"])
+          end
         end
 
-        # @return [Time] The elapsed time of the request.
+        # @return [Float] The elapsed time of the request.
         # @since 0.1.0
         def elapsed_time
-          (header || [0, 0, 0.0])[2]
+          if header.nil?
+            0.0
+          elsif header_v1?
+            header[2]
+          else
+            header["elapsed_time"]
+          end
         end
 
         # @return [String, nil] The error message of the response.
         # @since 0.2.4
         def error_message
-          (header || [0, 0, 0.0, nil])[3]
+          if header.nil?
+            nil
+          elsif header_v1?
+            header[3]
+          else
+            (header["error"] || {})["message"]
+          end
         end
 
         # @return [Boolean] `true` if the request is processed successfully,
         #   `false` otherwise.
         # @since 0.1.0
         def success?
-          status_code.zero?
+          return_code.zero?
+        end
+
+        private
+        def header_v1?
+          header.is_a?(::Array)
         end
       end
     end

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

@@ -36,57 +36,92 @@ module Groonga
 
         private
         def parse_body(body)
-          @n_hits, @records = parse_match_records(body.first)
-          @drilldowns = parse_drilldowns(body[1..-1])
+          if body.is_a?(::Array)
+            @n_hits, @records = parse_match_records_v1(body.first)
+            @drilldowns = parse_drilldowns_v1(body[1..-1])
+          else
+            @n_hits, @records = parse_match_records_v3(body)
+            @drilldowns = parse_drilldowns_v3(body["drilldowns"])
+          end
           body
         end
 
-        def parse_result(raw_result)
-          n_hits = raw_result.first.first
+        def parse_records(raw_columns, raw_records)
           column_names = {}
-          properties = raw_result[1].collect do |column_name, column_type|
-            base_column_name = column_name
+          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?(column_name)
-              column_name = "#{base_column_name}#{suffix}"
+            while column_names.key?(name)
+              name = "#{base_column_name}#{suffix}"
               suffix += 1
             end
-            column_names[column_name] = true
-            [column_name, column_type]
+            column_names[name] = true
+            [name, type]
           end
-          infos = raw_result[2..-1] || []
-          items = infos.collect do |info|
-            item = {}
-            properties.each_with_index do |(name, type), i|
-              item[name] = convert_value(info[i], type)
+
+          (raw_records || []).collect do |raw_record|
+            record = {}
+            columns.each_with_index do |(name, type), i|
+              record[name] = convert_value(raw_record[i], type)
             end
-            item
+            record
           end
-          [n_hits, items]
         end
 
         def convert_value(value, type)
-          case type
-          when "Time"
-            Time.at(value)
+          case value
+          when ::Array
+            value.collect do |element|
+              convert_value(element, type)
+            end
           else
-            value
+            case type
+            when "Time"
+              Time.at(value)
+            else
+              value
+            end
           end
         end
 
-        def parse_match_records(raw_records)
-          parse_result(raw_records)
+        def parse_match_records_v1(raw_records)
+          [
+            raw_records.first.first,
+            parse_records(raw_records[1], raw_records[2..-1]),
+          ]
         end
 
-        def parse_drilldowns(raw_drilldowns)
+        def parse_match_records_v3(raw_records)
+          [
+            raw_records["n_hits"],
+            parse_records(raw_records["columns"], raw_records["records"]),
+          ]
+        end
+
+        def parse_drilldowns_v1(raw_drilldowns)
           (raw_drilldowns || []).collect.with_index do |raw_drilldown, i|
             key = @command.drilldowns[i]
-            n_hits, items = parse_result(raw_drilldown)
-            Drilldown.new(key, n_hits, items)
+            n_hits, records = parse_match_records_v1(raw_drilldown)
+            Drilldown.new(key, n_hits, records)
+          end
+        end
+
+        def parse_drilldowns_v3(raw_drilldowns)
+          (raw_drilldowns || {}).collect do |(key, raw_drilldown)|
+            n_hits, records = parse_match_records_v3(raw_drilldown)
+            Drilldown.new(key, n_hits, records)
           end
         end
 
-        class Drilldown < Struct.new(:key, :n_hits, :items)
+        class Drilldown < Struct.new(:key, :n_hits, :records)
+          # @deprecated since 0.2.6. Use {#records} instead.
+          alias_method :items, :records
         end
       end
     end

data/lib/groonga/client/version.rb

@@ -16,6 +16,6 @@
 
 module Groonga
   class Client
-    VERSION = "0.2.5"
+    VERSION = "0.2.6"
   end
 end

data/test/response/test-base.rb

@@ -18,95 +18,194 @@ require "response/helper"
 
 class TestResponseBase < Test::Unit::TestCase
   class TestHeader < self
-    class TestStatusCode < self
-      def test_have_header
-        header = [
-          -21,
-          1396012478.14975,
-          0.00050806999206543,
-        ]
-        response = Groonga::Client::Response::Base.new(nil, header, nil)
-        assert_equal(-21, response.status_code)
-      end
+    class TestCommandVersion1 < self
+      class TestReturnCode < self
+        def test_have_header
+          header = [
+            -21,
+            1396012478.14975,
+            0.00050806999206543,
+          ]
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(-21, response.return_code)
+        end
 
-      def test_no_header
-        response = Groonga::Client::Response::Error.new(nil, nil, nil)
-        assert_equal(0, response.status_code)
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_equal(0, response.return_code)
+        end
       end
-    end
 
-    class TestStartTime < self
-      def test_have_header
-        start_time = 1396012478.14975
-        header = [
-          -21,
-          start_time,
-          0.00050806999206543,
-        ]
-        response = Groonga::Client::Response::Base.new(nil, header, nil)
-        assert_equal(Time.at(start_time), response.start_time)
+      class TestStartTime < self
+        def test_have_header
+          start_time = 1396012478.14975
+          header = [
+            -21,
+            start_time,
+            0.00050806999206543,
+          ]
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(Time.at(start_time), response.start_time)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_equal(Time.at(0), response.start_time)
+        end
       end
 
-      def test_no_header
-        response = Groonga::Client::Response::Error.new(nil, nil, nil)
-        assert_equal(Time.at(0), response.start_time)
+      class TestElapsedTime < self
+        def test_have_header
+          elapsed_time = 0.00050806999206543
+          header = [
+            -21,
+            1396012478.14975,
+            elapsed_time,
+          ]
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(elapsed_time, response.elapsed_time)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_equal(0.0, response.elapsed_time)
+        end
       end
-    end
 
-    class TestElapsedTime < self
-      def test_have_header
-        elapsed_time = 0.00050806999206543
-        header = [
-          -21,
-          1396012478.14975,
-          elapsed_time,
-        ]
-        response = Groonga::Client::Response::Base.new(nil, header, nil)
-        assert_equal(elapsed_time, response.elapsed_time)
+      class TestErrorMessage < self
+        def test_have_header
+          error_message = "invalid argument"
+          header = [
+            -21,
+            1396012478.14975,
+            0.00050806999206543,
+            error_message,
+          ]
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(error_message, response.error_message)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_nil(response.error_message)
+        end
       end
 
-      def test_no_header
-        response = Groonga::Client::Response::Error.new(nil, nil, nil)
-        assert_equal(0.0, response.elapsed_time)
+      class TestSuccess < self
+        def test_have_header
+          header = [
+            -21,
+            1396012478.14975,
+            0.00050806999206543,
+          ]
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert do
+            not response.success?
+          end
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert do
+            response.success?
+          end
+        end
       end
     end
 
-    class TestErrorMessage < self
-      def test_have_header
-        error_message = "invalid argument"
-        header = [
-          -21,
-          1396012478.14975,
-          0.00050806999206543,
-          error_message,
-        ]
-        response = Groonga::Client::Response::Base.new(nil, header, nil)
-        assert_equal(error_message, response.error_message)
+    class TestCommandVersion3 < self
+      class TestReturnCode < self
+        def test_have_header
+          header = {
+            "return_code"  => -21,
+            "start_time"   => 1396012478.14975,
+            "elapsed_time" => 0.00050806999206543,
+          }
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(-21, response.return_code)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_equal(0, response.return_code)
+        end
       end
 
-      def test_no_header
-        response = Groonga::Client::Response::Error.new(nil, nil, nil)
-        assert_nil(response.error_message)
+      class TestStartTime < self
+        def test_have_header
+          start_time = 1396012478.14975
+          header = {
+            "return_code"  => -21,
+            "start_time"   => start_time,
+            "elapsed_time" => 0.00050806999206543,
+          }
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(Time.at(start_time), response.start_time)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_equal(Time.at(0), response.start_time)
+        end
+      end
+
+      class TestElapsedTime < self
+        def test_have_header
+          elapsed_time = 0.00050806999206543
+          header = {
+            "return_code"  => -21,
+            "start_time"   => 1396012478.14975,
+            "elapsed_time" => elapsed_time,
+          }
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(elapsed_time, response.elapsed_time)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_equal(0.0, response.elapsed_time)
+        end
       end
-    end
 
-    class TestSuccess < self
-      def test_have_header
-        header = [
-          -21,
-          1396012478.14975,
-          0.00050806999206543,
-        ]
-        response = Groonga::Client::Response::Base.new(nil, header, nil)
-        assert do
-          not response.success?
+      class TestErrorMessage < self
+        def test_have_header
+          error_message = "invalid argument"
+          header = {
+            "return_code"  => -21,
+            "start_time"   => 1396012478.14975,
+            "elapsed_time" => 0.00050806999206543,
+            "error" => {
+              "message" => error_message,
+            },
+          }
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert_equal(error_message, response.error_message)
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert_nil(response.error_message)
         end
       end
 
-      def test_no_header
-        response = Groonga::Client::Response::Error.new(nil, nil, nil)
-        assert do
-          response.success?
+      class TestSuccess < self
+        def test_have_header
+          header = {
+            "return_code"  => -21,
+            "start_time"   => 1396012478.14975,
+            "elapsed_time" => 0.00050806999206543,
+          }
+          response = Groonga::Client::Response::Base.new(nil, header, nil)
+          assert do
+            not response.success?
+          end
+        end
+
+        def test_no_header
+          response = Groonga::Client::Response::Error.new(nil, nil, nil)
+          assert do
+            response.success?
+          end
         end
       end
     end

data/test/response/{test-select.rb → test-select-command-version1.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2015  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2013  Kosuke Asami
 #
 # This library is free software; you can redistribute it and/or
@@ -17,7 +17,7 @@
 
 require "response/helper"
 
-class TestResponseSelect < Test::Unit::TestCase
+class TestResponseSelectCommandVersion1 < Test::Unit::TestCase
   class TestParseRawResponse < self
     include TestResponseHelper
 
@@ -54,6 +54,30 @@ class TestResponseSelect < Test::Unit::TestCase
                      records([[[1], [["updated_at", "Time"]], [updated_at]]]))
       end
 
+      def test_time_vector
+        update1 = 1379040474
+        update2 = 1464598349
+        assert_equal([
+                       {
+                         "updates" => [
+                           Time.at(update1),
+                           Time.at(update2),
+                         ],
+                       },
+                     ],
+                     records([
+                               [
+                                 [1],
+                                 [
+                                   ["updates", "Time"],
+                                 ],
+                                 [
+                                   [update1, update2],
+                                 ],
+                               ]
+                             ]))
+      end
+
       def test_duplicated_column_name
         assert_equal([
                        {
@@ -88,7 +112,7 @@ class TestResponseSelect < Test::Unit::TestCase
     class TestDrilldowns < self
       def setup
         pair_arguments = {
-          "drilldown" => "_key",
+          "drilldown" => "tag",
           "drilldown_output_columns" => "_key,_nsubrecs",
         }
         @command = Groonga::Command::Select.new("select", pair_arguments)
@@ -108,7 +132,7 @@ class TestResponseSelect < Test::Unit::TestCase
             ["rroonga",  9],
           ],
         ]
-        assert_equal(["_key"],
+        assert_equal(["tag"],
                      drilldowns(body).collect(&:key))
       end
 

data/test/response/test-select-command-version3.rb

@@ -0,0 +1,274 @@
+# Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013  Kosuke Asami
+#
+# 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 "response/helper"
+
+class TestResponseSelectCommandVersion3 < Test::Unit::TestCase
+  class TestParseRawResponse < self
+    include TestResponseHelper
+
+    def test_select
+      header = {
+        "return_code"  => 0,
+        "start_time"   => 1372430096.70991,
+        "elapsed_time" => 0.000522851943969727,
+      }
+      body = {
+        "n_hits" => 1,
+        "columns" => [
+          {
+            "name" => "_id",
+            "type" => "UInt32",
+          },
+        ],
+        "records" => [
+          1,
+        ],
+      }
+      raw_response = {
+        "header" => header,
+        "body"   => body,
+      }.to_json
+
+      response = parse_raw_response("select", raw_response)
+      assert_equal(Groonga::Client::Response::Select, response.class)
+    end
+  end
+
+  class TestBody < self
+    def setup
+      @command = Groonga::Command::Select.new("select", {})
+    end
+
+    def test_n_hits
+      response = create_response({
+                                   "n_hits" => 29,
+                                   "columns" => [
+                                     {
+                                       "name" => "_id",
+                                       "type" => "UInt32",
+                                     },
+                                   ],
+                                   "records" => [
+                                   ],
+                                 })
+      assert_equal(29, response.n_hits)
+    end
+
+    private
+    def create_response(body)
+      header = {
+        "return_code"  => 0,
+        "start_time"   => 1372430096.70991,
+        "elapsed_time" => 0.000522851943969727,
+      }
+      Groonga::Client::Response::Select.new(@command, header, body)
+    end
+
+    class TestRecords < self
+      def test_time
+        updated_at = 1379040474
+        assert_equal([{"updated_at" => Time.at(updated_at)}],
+                     records({
+                               "n_hits" => 1,
+                               "columns" => [
+                                 {
+                                   "name" => "updated_at",
+                                   "type" => "Time",
+                                 },
+                               ],
+                               "records" => [
+                                 [updated_at],
+                               ],
+                             }))
+      end
+
+      def test_time_vector
+        update1 = 1379040474
+        update2 = 1464598349
+        assert_equal([
+                       {
+                         "updates" => [
+                           Time.at(update1),
+                           Time.at(update2),
+                         ],
+                       },
+                     ],
+                     records({
+                               "n_hits" => 1,
+                               "columns" => [
+                                 {
+                                   "name" => "updates",
+                                   "type" => "Time",
+                                 },
+                               ],
+                               "records" => [
+                                 [
+                                   [update1, update2],
+                                 ],
+                               ],
+                             }))
+      end
+
+      def test_duplicated_column_name
+        assert_equal([
+                       {
+                         "html_escape"  => "content1",
+                         "html_escape2" => "content2",
+                         "html_escape3" => "content3",
+                       }
+                     ],
+                     records({
+                               "n_hits" => 1,
+                               "columns" => [
+                                 {
+                                   "name" => "html_escape",
+                                   "type" => nil,
+                                 },
+                                 {
+                                   "name" => "html_escape",
+                                   "type" => nil,
+                                 },
+                                 {
+                                   "name" => "html_escape",
+                                   "type" => nil,
+                                 }
+                               ],
+                               "records" => [
+                                 ["content1", "content2", "content3"],
+                               ],
+                             }))
+      end
+
+      private
+      def records(body)
+        create_response(body).records
+      end
+    end
+
+    class TestDrilldowns < self
+      def setup
+        pair_arguments = {
+          "drilldown" => "tag",
+          "drilldown_output_columns" => "_key,_nsubrecs",
+        }
+        @command = Groonga::Command::Select.new("select", pair_arguments)
+      end
+
+      def test_key
+        body = {
+          "n_hits" => 0,
+          "columns" => [],
+          "records" => [],
+          "drilldowns" => {
+            "tag" => {
+              "n_hits" => 29,
+              "columns" => [
+                {
+                  "name" => "_key",
+                  "type" => "ShortText",
+                },
+                {
+                  "name" => "_nsubrecs",
+                  "type" => "Int32",
+                },
+              ],
+              "records" => [
+                ["groonga", 29],
+                ["Ruby",    19],
+                ["rroonga",  9],
+              ],
+            },
+          },
+        }
+        assert_equal(["tag"],
+                     drilldowns(body).collect(&:key))
+      end
+
+      def test_n_hits
+        body = {
+          "n_hits" => 0,
+          "columns" => [],
+          "records" => [],
+          "drilldowns" => {
+            "tag" => {
+              "n_hits" => 29,
+              "columns" => [
+                {
+                  "name" => "_key",
+                  "type" => "ShortText",
+                },
+                {
+                  "name" => "_nsubrecs",
+                  "type" => "Int32",
+                },
+              ],
+              "records" => [
+                ["groonga", 29],
+                ["Ruby",    19],
+                ["rroonga",  9],
+              ],
+            },
+          },
+        }
+        assert_equal([29],
+                     drilldowns(body).collect(&:n_hits))
+      end
+
+      def test_items
+        body = {
+          "n_hits" => 0,
+          "columns" => [],
+          "records" => [],
+          "drilldowns" => {
+            "tag" => {
+              "n_hits" => 29,
+              "columns" => [
+                {
+                  "name" => "_key",
+                  "type" => "ShortText",
+                },
+                {
+                  "name" => "_nsubrecs",
+                  "type" => "Int32",
+                },
+              ],
+              "records" => [
+                ["groonga", 29],
+                ["Ruby",    19],
+                ["rroonga",  9],
+              ],
+            },
+          },
+        }
+        assert_equal([
+                       [
+                         {"_key" => "groonga", "_nsubrecs" => 29},
+                         {"_key" => "Ruby",    "_nsubrecs" => 19},
+                         {"_key" => "rroonga", "_nsubrecs" =>  9},
+                       ],
+                     ],
+                     drilldowns(body).collect(&:items))
+      end
+
+      private
+      def drilldowns(body)
+        create_response(body).drilldowns
+      end
+    end
+  end
+end

data/test/run-test.rb

@@ -41,7 +41,6 @@ test_dir = base_dir + "test"
 $LOAD_PATH.unshift(lib_dir.to_s)
 
 require "test-unit"
-require "test/unit/notify"
 
 Thread.abort_on_exception = true
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: groonga-client
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Haruka Yoshihara
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-01 00:00:00.000000000 Z
+date: 2016-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gqtp
@@ -96,20 +96,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: test-unit-notify
-  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'
 - !ruby/object:Gem::Dependency
   name: test-unit-rr
   requirement: !ruby/object:Gem::Requirement
@@ -232,7 +218,8 @@ files:
 - test/response/test-column-list.rb
 - test/response/test-error.rb
 - test/response/test-schema.rb
-- test/response/test-select.rb
+- test/response/test-select-command-version1.rb
+- test/response/test-select-command-version3.rb
 - test/response/test-status.rb
 - test/response/test-table-create.rb
 - test/response/test-table-list.rb
@@ -282,7 +269,8 @@ test_files:
 - test/response/test-table-list.rb
 - test/response/test-status.rb
 - test/response/test-schema.rb
-- test/response/test-select.rb
+- test/response/test-select-command-version3.rb
+- test/response/test-select-command-version1.rb
 - test/response/test-table-create.rb
 - test/response/test-table-remove.rb
 - test/results/test-column-list.rb