groonga-client 0.5.2 → 0.5.3

data/test/response/test-column-list.rb

@@ -1,16 +1,142 @@
+# Copyright (C) 2013  Kosuke Asami
+# Copyright (C) 2017  Kouhei Sutou <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 "response/helper"
 
 class TestResponseColumnList < Test::Unit::TestCase
-  include TestResponseHelper
+  class TestParse < self
+    include TestResponseHelper
+
+    def column(attributes)
+      c = Groonga::Client::Response::ColumnList::Column.new
+      attributes.each do |name, value|
+        c[name] = value
+      end
+      c
+    end
+
+    def test_parse
+      header = [0, 1372430096.70991, 0.000522851943969727]
+      body = [
+        [
+          ["id", "UInt32"],
+          ["name", "ShortText"],
+          ["path", "ShortText"],
+          ["type", "ShortText"],
+          ["flags", "ShortText"],
+          ["domain", "ShortText"],
+          ["range", "ShortText"],
+          ["source", "ShortText"],
+        ],
+        [
+          256,
+          "content",
+          "/tmp/test.db.0000100",
+          "var",
+          "COLUMN_SCALAR|PERSISTENT",
+          "TestTable",
+          "ShortText",
+          [],
+        ],
+      ]
+      raw_response = [header, body].to_json
+
+      response = parse_raw_response("column_list", raw_response)
+      assert_equal([
+                     column(:id => 256,
+                            :name => "content",
+                            :path => "/tmp/test.db.0000100",
+                            :type => "var",
+                            :flags => "COLUMN_SCALAR|PERSISTENT",
+                            :domain => "TestTable",
+                            :range => "ShortText",
+                            :source => []),
+                   ],
+                   response.to_a)
+    end
+  end
+
+  class TestBody < self
+    def setup
+      @command = Groonga::Command::Base.new("column_list", "table" => "Memos")
+    end
+
+    def create_response(columns)
+      header = [0, 1372430096.70991, 0.000522851943969727]
+      body = [
+        [
+          ["id", "UInt32"],
+          ["name", "ShortText"],
+          ["path", "ShortText"],
+          ["type", "ShortText"],
+          ["flags", "ShortText"],
+          ["domain", "ShortText"],
+          ["range", "ShortText"],
+          ["source", "ShortText"],
+        ],
+        *columns,
+      ]
+      Groonga::Client::Response::ColumnList.new(@command, header, body)
+    end
+
+    class TestFlags < self
+      def create_response(flags)
+        columns = [
+          [
+            256,
+            "content",
+            "/tmp/test.db.0000100",
+            "var",
+            flags,
+            "Memos",
+            "ShortText",
+            [],
+          ]
+        ]
+        super(columns)
+      end
+
+      def test_multiple
+        response = create_response("COLUMN_SCALAR|PERSISTENT")
+        assert_equal(["COLUMN_SCALAR", "PERSISTENT"],
+                     response[0].flags)
+      end
+
+      def test_scalar?
+        response = create_response("COLUMN_SCALAR|PERSISTENT")
+        assert do
+          response[0].scalar?
+        end
+      end
 
-  def test_column_list
-    header = [0,1372430096.70991,0.000522851943969727]
-    body = [[["id","UInt32"],["name","ShortText"],["path","ShortText"],["type","ShortText"],["flags","ShortText"],["domain","ShortText"],["range","ShortText"],["source","ShortText"]],
-      [256,"Text","/tmp/test.db.0000100","var","COLUMN_SCALAR|PERSISTENT","TestTable","ShortText",[]]]
-    raw_response = [header, body].to_json
+      def test_vector?
+        response = create_response("COLUMN_VECTOR|PERSISTENT")
+        assert do
+          response[0].vector?
+        end
+      end
 
-    response = parse_raw_response("column_list", raw_response)
-    assert_equal(Groonga::Client::Response::ColumnList, response.class)
+      def test_index?
+        response = create_response("COLUMN_INDEX|WITH_POSITION|PERSISTENT")
+        assert do
+          response[0].index?
+        end
+      end
+    end
   end
 end
 

data/test/response/test-schema.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2016-2017  Kouhei Sutou <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
@@ -20,7 +20,7 @@ class TestResponseSchema < Test::Unit::TestCase
   class TestParseRawResponse < self
     include TestResponseHelper
 
-    def test_select
+    def test_parse
       header = [0, 1372430096.70991, 0.000522851943969727]
       body = {}
       raw_response = [header, body].to_json
@@ -40,6 +40,139 @@ class TestResponseSchema < Test::Unit::TestCase
       Groonga::Client::Response::Schema.new(@command, header, body)
     end
 
+    class TestReferenceShortCut < self
+      def test_plugin
+        body = {
+          "plugins" => {
+            "token_filters/stop_word" => {
+              "name" => "token_filters/stop_word",
+            },
+          },
+          "types" => {},
+          "tokenizers" => {},
+          "normalizers" => {},
+          "token_filters" => {},
+          "tables" => {},
+        }
+        response = create_response(body)
+        assert_equal({"name" => "token_filters/stop_word"},
+                     response["token_filters/stop_word"])
+      end
+
+      def test_type
+        body = {
+          "plugins" => {},
+          "types" => {
+            "ShortText" => {
+              "name" => "ShortText",
+            },
+          },
+          "tokenizers" => {},
+          "normalizers" => {},
+          "token_filters" => {},
+          "tables" => {},
+        }
+        response = create_response(body)
+        assert_equal({"name" => "ShortText"},
+                     response["ShortText"])
+      end
+
+      def test_tokenizer
+        body = {
+          "plugins" => {},
+          "types" => {},
+          "tokenizers" => {
+            "TokenBigram" => {
+              "name" => "TokenBigram",
+            },
+          },
+          "normalizers" => {},
+          "token_filters" => {},
+          "tables" => {},
+        }
+        response = create_response(body)
+        assert_equal({"name" => "TokenBigram"},
+                     response["TokenBigram"])
+      end
+
+      def test_normalizer
+        body = {
+          "plugins" => {},
+          "types" => {},
+          "tokenizers" => {},
+          "normalizers" => {
+            "NormalizerAuto" => {
+              "name" => "NormalizerAuto",
+            },
+          },
+          "token_filters" => {},
+          "tables" => {},
+        }
+        response = create_response(body)
+        assert_equal({"name" => "NormalizerAuto"},
+                     response["NormalizerAuto"])
+      end
+
+      def test_token_filters
+        body = {
+          "plugins" => {},
+          "types" => {},
+          "tokenizers" => {},
+          "normalizers" => {},
+          "token_filters" => {
+            "TokenFilterStopWord" => {
+              "name" => "TokenFilterStopWord",
+            },
+          },
+          "tables" => {},
+        }
+        response = create_response(body)
+        assert_equal({"name" => "TokenFilterStopWord"},
+                     response["TokenFilterStopWord"])
+      end
+
+      def test_table
+        body = {
+          "plugins" => {},
+          "types" => {},
+          "tokenizers" => {},
+          "normalizers" => {},
+          "token_filters" => {},
+          "tables" => {
+            "Users" => {
+              "name" => "Users",
+            },
+          },
+        }
+        response = create_response(body)
+        assert_equal({"name" => "Users"},
+                     response["Users"])
+      end
+
+      def test_column
+        body = {
+          "plugins" => {},
+          "types" => {},
+          "tokenizers" => {},
+          "normalizers" => {},
+          "token_filters" => {},
+          "tables" => {
+            "Users" => {
+              "name" => "Users",
+              "columns" => {
+                "age" => {
+                  "name" => "age",
+                },
+              },
+            },
+          },
+        }
+        response = create_response(body)
+        assert_equal({"name" => "age"},
+                     response["Users.age"])
+      end
+    end
+
     class TestTable < self
       def test_key_type
         body = {
@@ -263,6 +396,30 @@ class TestResponseSchema < Test::Unit::TestCase
           end
         end
       end
+
+      def test_command
+        body = {
+          "tables" => {
+            "Users" => {
+              "command" => {
+                "name" => "table_create",
+                "arguments" => {
+                  "name" => "Users",
+                  "flags" => "TABLE_HASH_KEY",
+                  "key_type" => "ShortText",
+                },
+              }
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal({
+                       "name" => "Users",
+                       "flags" => "TABLE_HASH_KEY",
+                       "key_type" => "ShortText",
+                     },
+                     response.tables["Users"].command.arguments)
+      end
     end
 
     class TestColumn < self
@@ -410,6 +567,36 @@ class TestResponseSchema < Test::Unit::TestCase
           end
         end
       end
+
+      def test_command
+        body = {
+          "tables" => {
+            "Users" => {
+              "columns" => {
+                "name" => {
+                  "command" => {
+                    "name" => "column_create",
+                    "arguments" => {
+                      "table" => "Users",
+                      "name" => "name",
+                      "flags" => "COLUMN_SCALAR",
+                      "type" => "ShortText",
+                    },
+                  }
+                }
+              }
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal({
+                       "table" => "Users",
+                       "name" => "name",
+                       "flags" => "COLUMN_SCALAR",
+                       "type" => "ShortText",
+                     },
+                     response.tables["Users"].columns["name"].command.arguments)
+      end
     end
 
     class TestIndex < self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: groonga-client
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Haruka Yoshihara
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-27 00:00:00.000000000 Z
+date: 2017-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gqtp
@@ -161,6 +161,7 @@ email:
 - kou@clear-code.com
 - tfortress58@gmail.com
 executables:
+- groonga-client-index-recreate
 - groonga-client
 extensions: []
 extra_rdoc_files: []
@@ -170,11 +171,13 @@ files:
 - README.md
 - Rakefile
 - bin/groonga-client
+- bin/groonga-client-index-recreate
 - doc/text/lgpl-2.1.txt
 - doc/text/news.md
 - groonga-client.gemspec
 - lib/groonga/client.rb
-- lib/groonga/client/cli.rb
+- lib/groonga/client/command-line/groonga-client-index-recreate.rb
+- lib/groonga/client/command-line/groonga-client.rb
 - lib/groonga/client/command.rb
 - lib/groonga/client/default.rb
 - lib/groonga/client/empty-request.rb
@@ -221,6 +224,7 @@ files:
 - lib/groonga/client/test/fixture.rb
 - lib/groonga/client/test/groonga-server-runner.rb
 - lib/groonga/client/version.rb
+- test/command-line/test-index-recreate.rb
 - test/protocol/test-gqtp.rb
 - test/protocol/test-http.rb
 - test/request/select/test-backward-compatible-sort-keys-parameter.rb
@@ -245,7 +249,6 @@ files:
 - test/response/test-table-create.rb
 - test/response/test-table-list.rb
 - test/response/test-table-remove.rb
-- test/results/test-column-list.rb
 - test/results/test-table-list.rb
 - test/run-test.rb
 - test/test-client.rb
@@ -271,13 +274,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Groonga-client is a client for Groonga (http://groonga.org/) implemented
   with pure Ruby. You can use it without Groonga.
 test_files:
 - test/test-client.rb
+- test/command-line/test-index-recreate.rb
 - test/test-script-syntax.rb
 - test/request/select/test-backward-compatible-sort-keys-parameter.rb
 - test/request/select/test-filter.rb
@@ -305,5 +309,4 @@ test_files:
 - 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
 - test/results/test-table-list.rb

data/lib/groonga/client/cli.rb

@@ -1,233 +0,0 @@
-# Copyright (C) 2015-2016  Kouhei Sutou <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 "ostruct"
-require "optparse"
-require "json"
-require "securerandom"
-
-require "groonga/client"
-
-require "groonga/command/parser"
-
-module Groonga
-  class Client
-    class CLI
-      def initialize
-        @protocol = :http
-        @host     = "localhost"
-        @port     = nil
-
-        @read_timeout = Client::Default::READ_TIMEOUT
-
-        @chunk = false
-
-        @runner_options = {
-          :split_load_chunk_size => 10000,
-          :generate_request_id   => false,
-        }
-      end
-
-      def run(argv)
-        command_file_paths = parse_command_line(argv)
-
-        @client = Client.new(:protocol => @protocol,
-                             :host     => @host,
-                             :port     => @port,
-                             :read_timeout => @read_timeout,
-                             :chunk    => @chunk,
-                             :backend  => :synchronous)
-        runner = Runner.new(@client, @runner_options)
-
-        if command_file_paths.empty?
-          $stdin.each_line do |line|
-            runner << line
-          end
-        else
-          command_file_paths.each do |command_file_path|
-            File.open(command_file_path) do |command_file|
-              last_line = nil
-              command_file.each_line do |line|
-                last_line = line
-                runner << line
-              end
-              if last_line and !last_line.end_with?("\n")
-                runner << "\n"
-              end
-            end
-          end
-        end
-        runner.finish
-
-        true
-      end
-
-      private
-      def parse_command_line(argv)
-        parser = OptionParser.new
-        parser.version = VERSION
-        parser.banner += " GROONGA_COMMAND_FILE1 GROONGA_COMMAND_FILE2 ..."
-
-        parser.separator("")
-
-        parser.separator("Connection:")
-
-        available_protocols = [:http, :gqtp]
-        parser.on("--protocol=PROTOCOL", [:http, :gqtp],
-                  "Protocol to connect to Groonga server.",
-                  "[#{available_protocols.join(", ")}]",
-                  "(#{@protocol})") do |protocol|
-          @protocol = protocol
-        end
-
-        parser.on("--host=HOST",
-                  "Groonga server to be connected.",
-                  "(#{@host})") do |host|
-          @host = host
-        end
-
-        parser.on("--port=PORT", Integer,
-                  "Port number of Groonga server to be connected.",
-                  "(auto)") do |port|
-          @port = port
-        end
-
-        parser.on("--read-timeout=TIMEOUT", Integer,
-                  "Timeout on reading response from Groonga server.",
-                  "You can disable timeout by specifying -1.",
-                  "(#{@read_timeout})") do |timeout|
-          @read_timeout = timeout
-        end
-
-        parser.on("--split-load-chunk-size=SIZE", Integer,
-                  "Split a large load to small loads.",
-                  "Each small load has at most SIZE records.",
-                  "Set 0 to SIZE to disable this feature.",
-                  "(#{@runner_options[:split_load_chunk_size]})") do |size|
-          @runner_options[:split_load_chunk_size] = size
-        end
-
-        parser.on("--[no-]generate-request-id",
-                  "Add auto generated request ID to all commands.",
-                  "(#{@runner_options[:generate_request_id]})") do |boolean|
-          @runner_options[:generate_request_id] = boolean
-        end
-
-        parser.on("--[no-]chunk",
-                  "Use \"Transfer-Encoding: chunked\" for load command.",
-                  "HTTP only.",
-                  "(#{@chunk})") do |boolean|
-          @chunk = boolean
-        end
-
-        command_file_paths = parser.parse(argv)
-
-        @port ||= default_port(@protocol)
-
-        command_file_paths
-      end
-
-      def default_port(protocol)
-        case protocol
-        when :http
-          10041
-        when :gqtp
-          10043
-        end
-      end
-
-      class Runner
-        def initialize(client, options={})
-          @client = client
-          @split_load_chunk_size = options[:split_load_chunk_size] || 10000
-          @generate_request_id   = options[:generate_request_id]
-          @load_values = []
-          @parser = create_command_parser
-        end
-
-        def <<(line)
-          @parser << line
-        end
-
-        def finish
-          @parser.finish
-        end
-
-        private
-        def create_command_parser
-          parser = Groonga::Command::Parser.new
-
-          parser.on_command do |command|
-            run_command(command)
-          end
-
-          parser.on_load_columns do |command, columns|
-            command[:columns] ||= columns.join(",")
-          end
-
-          parser.on_load_value do |command, value|
-            unless command[:values]
-              @load_values << value
-              if @load_values.size == @split_load_chunk_size
-                consume_load_values(command)
-              end
-            end
-            command.original_source.clear
-          end
-
-          parser.on_load_complete do |command|
-            if command[:values]
-              run_command(command)
-            else
-              consume_load_values(command)
-            end
-          end
-
-          parser
-        end
-
-        def consume_load_values(load_command)
-          return if @load_values.empty?
-
-          values_json = "["
-          @load_values.each_with_index do |value, i|
-            values_json << "," unless i.zero?
-            values_json << "\n"
-            values_json << JSON.generate(value)
-          end
-          values_json << "\n]\n"
-          load_command[:values] = values_json
-          run_command(load_command)
-          @load_values.clear
-          load_command[:values] = nil
-        end
-
-        def run_command(command)
-          command[:request_id] ||= SecureRandom.uuid if @generate_request_id
-          response = @client.execute(command)
-          case command.output_type
-          when :json
-            puts(JSON.pretty_generate([response.header, response.body]))
-          when :xml
-            puts(response.raw)
-          else
-            puts(response.body)
-          end
-        end
-      end
-    end
-  end
-end