groonga-client 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 525ea4e0715bed716fde7af9813a55e0d0b90fd6
-  data.tar.gz: ff541cecc8a018112201af5af4fc978f32578f8d
+  metadata.gz: 13c9c1e871ac9bb792323a889b57eff795821300
+  data.tar.gz: 0437713eec1f8aae199978bda285fbc765958a81
 SHA512:
-  metadata.gz: 1b6db2d64ce83681ddb33181c9289944f5c79d13b2df9127bdbc3280d584ad4b7cf6afdede3ad20b45d85d31c4af9604a80496a400f481cfc8b05fc58f2a5ff1
-  data.tar.gz: c9e40baebc159097c8b3b0196f0964050d38e515cc7957a1f22f4d6f05f449e567d1d39656fb7822377873086505e4215e1c0fb3de9e54dd93c7ef2a4070f38d
+  metadata.gz: dad7cfa134e3e11c426ab8cc62c399c455a1fbd4859759107bdf93f150ca1a581b9f8e7ffa5c025f6b20c334c39f9ea0e3d1077a0c45d24c0cb9abedf484e035
+  data.tar.gz: f2c0a41b91e8dbbcbbb93adf21b1845c13817f0c28e9868e9c4ccfe640e3f139d8a09b7a0123fdc3b5126eb4557cec2c0bfde891793b79f7ba3ac8b3c3e78cbe

data/doc/text/news.md

@@ -1,6 +1,6 @@
 # NEWS
 
-## 0.2.2 - 2016-03-22
+## 0.2.3 - 2016-03-22
 
 ### Improvements
 
@@ -8,6 +8,18 @@
 
   * response: Supported `schema` command partially.
 
+## 0.2.2 - 2016-03-22
+
+### Improvements
+
+  * response: `schema`: Supported index.
+
+  * response: `schema`: Supported normalizer.
+
+  * response: `schema`: Supported token filter.
+
+  * response: `schema`: Supported tokenizer.
+
 ### Fixes
 
   * Fixed a bug that `Groonga::Command` isn't accepted.

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

@@ -45,18 +45,49 @@ module Groonga
           end
         end
 
+        # @return [Hash<String, Normalizer>] Key is normalizer name and
+        #   value is the definition of the normalizer.
+        #
+        # @since 0.2.3
+        def normalizers
+          @normalizers ||= HashValueConverter.convert(@body["normalizers"]) do |normalizer|
+            Normalizer[normalizer]
+          end
+        end
+
+        # @return [Hash<String, TokenFilter>] Key is token filter name and
+        #   value is the definition of the token filter.
+        #
+        # @since 0.2.3
+        def token_filters
+          @token_filters ||= HashValueConverter.convert(@body["token_filters"]) do |token_filter|
+            TokenFilter[token_filter]
+          end
+        end
+
         # @return [Hash<String, Table>] Key is table name and value is the
         #   definition of the table.
         #
         # @since 0.2.2
         def tables
-          @tables ||= HashValueConverter.convert(@body["tables"]) do |raw_table|
-            table = Table.new(self)
-            raw_table.each do |key, value|
-              table[key] = value
+          @tables ||= nil
+          return @tables if @tables
+
+          @tables = {}
+          @body["tables"].each do |key, _|
+            @tables[key] = Table.new(self)
+          end
+          @body["tables"].each do |key, raw_table|
+            table = @tables[key]
+            raw_table.each do |table_key, table_value|
+              table[table_key] = table_value
             end
-            table
           end
+          @tables
+        end
+
+        private
+        def coerce_tables
         end
 
         module HashValueConverter
@@ -79,6 +110,14 @@ module Groonga
           include Hashie::Extensions::MethodAccess
         end
 
+        class Normalizer < Hash
+          include Hashie::Extensions::MethodAccess
+        end
+
+        class TokenFilter < Hash
+          include Hashie::Extensions::MethodAccess
+        end
+
         class KeyType < Hash
           include Hashie::Extensions::MethodAccess
         end
@@ -87,16 +126,67 @@ module Groonga
           include Hashie::Extensions::MethodAccess
         end
 
+        class Index < Hash
+          include Hashie::Extensions::MethodAccess
+
+          def initialize(schema, raw_index)
+            @schema = schema
+            super()
+            raw_index.each do |key, value|
+              self[key] = value
+            end
+          end
+
+          def []=(key, value)
+            case key.to_sym
+            when :table
+              super(key, coerce_table(value))
+            else
+              super
+            end
+          end
+
+          def column
+            column_name = name
+            if column_name.nil?
+              column_name
+            else
+              table.columns[column_name]
+            end
+          end
+
+          private
+          def coerce_table(table_name)
+            @schema.tables[table_name]
+          end
+        end
+
         class Column < Hash
           include Hashie::Extensions::MethodAccess
 
-          def initialize(schema, properties)
+          def initialize(schema, raw_column)
             @schema = schema
             super()
-            properties.each do |key, value|
+            raw_column.each do |key, value|
               self[key] = value
             end
           end
+
+          def []=(key, value)
+            case key.to_sym
+            when :indexes
+              super(key, coerce_indexes(value))
+            else
+              super
+            end
+          end
+
+          private
+          def coerce_indexes(raw_indexes)
+            raw_indexes.collect do |raw_index|
+              Index.new(@schema, raw_index)
+            end
+          end
         end
 
         class Table < Hash
@@ -112,9 +202,13 @@ module Groonga
             when :key_type
               super(key, coerce_key_type(value))
             when :tokenizer
-              super(key, coerce_tokenzer(value))
+              super(key, coerce_tokenizer(value))
+            when :normalizer
+              super(key, coerce_normalizer(value))
             when :columns
               super(key, coerce_columns(value))
+            when :indexes
+              super(key, coerce_indexes(value))
             else
               super
             end
@@ -139,11 +233,31 @@ module Groonga
             end
           end
 
+          def coerce_normalizer(raw_normalizer)
+            if raw_normalizer.nil?
+              nil
+            else
+              @schema.normalizers[raw_normalizer["name"]]
+            end
+          end
+
+          def coerce_token_filters(raw_token_filters)
+            raw_token_filters.collect do |raw_token_filter|
+              TokenFilter[raw_token_filter]
+            end
+          end
+
           def coerce_columns(raw_columns)
             HashValueConverter.convert(raw_columns) do |raw_column|
               Column.new(@schema, raw_column)
             end
           end
+
+          def coerce_indexes(raw_indexes)
+            raw_indexes.collect do |raw_index|
+              Index.new(@schema, raw_index)
+            end
+          end
         end
       end
     end

data/lib/groonga/client/version.rb

@@ -16,6 +16,6 @@
 
 module Groonga
   class Client
-    VERSION = "0.2.2"
+    VERSION = "0.2.3"
   end
 end

data/test/response/test-schema.rb

@@ -40,7 +40,7 @@ class TestResponseSchema < Test::Unit::TestCase
       Groonga::Client::Response::Schema.new(@command, header, body)
     end
 
-    class TestTables < self
+    class TestTable < self
       def test_key_type
         body = {
           "types" => {
@@ -62,6 +62,68 @@ class TestResponseSchema < Test::Unit::TestCase
                      response.tables["Users"].key_type.name)
       end
 
+      def test_tokenizer
+        body = {
+          "tokenizers" => {
+            "TokenBigram" => {
+              "name" => "TokenBigram",
+            },
+          },
+          "tables" => {
+            "Terms" => {
+              "tokenizer" => {
+                "name" => "TokenBigram",
+              },
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal(response.tokenizers["TokenBigram"],
+                     response.tables["Terms"].tokenizer)
+      end
+
+      def test_normalizer
+        body = {
+          "normalizers" => {
+            "NormalizerAuto" => {
+              "name" => "NormalizerAuto",
+            },
+          },
+          "tables" => {
+            "Users" => {
+              "normalizer" => {
+                "name" => "NormalizerAuto",
+              },
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal(response.normalizers["NormalizerAuto"],
+                     response.tables["Users"].normalizer)
+      end
+
+      def test_token_filters
+        body = {
+          "token_filters" => {
+            "TokenFilterStopWord" => {
+              "name" => "TokenFilterStopWord",
+            },
+          },
+          "tables" => {
+            "Names" => {
+              "token_filters" => [
+                {
+                  "name" => "TokenFilterStopWord",
+                },
+              ]
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal([response.token_filters["TokenFilterStopWord"]],
+                     response.tables["Names"].token_filters)
+      end
+
       def test_columns
         body = {
           "tables" => {
@@ -78,6 +140,94 @@ class TestResponseSchema < Test::Unit::TestCase
         assert_equal("age",
                      response.tables["Users"].columns["age"].name)
       end
+
+      def test_indexes
+        body = {
+          "tables" => {
+            "Users" => {
+              "indexes" => [
+                {
+                  "full_name" => "Names.users"
+                }
+              ]
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal("Names.users",
+                     response.tables["Users"].indexes[0].full_name)
+      end
+    end
+
+    class TestColumn < self
+      def test_indexes
+        body = {
+          "tables" => {
+            "Users" => {
+              "columns" => {
+                "age" => {
+                  "indexes" => [
+                    {
+                      "full_name" => "Ages.users",
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal("Ages.users",
+                     response.tables["Users"].columns["age"].indexes[0].full_name)
+      end
+    end
+
+    class TestIndex < self
+      def test_table
+        body = {
+          "tables" => {
+            "Names" => {
+              "name" => "Names",
+            },
+            "Users" => {
+              "indexes" => [
+                {
+                  "table" => "Names"
+                }
+              ]
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal(response.tables["Names"],
+                     response.tables["Users"].indexes[0].table)
+      end
+
+      def test_column
+        body = {
+          "tables" => {
+            "Names" => {
+              "name" => "Names",
+              "columns" => {
+                "users_key" => {
+                  "name" => "users_key",
+                },
+              },
+            },
+            "Users" => {
+              "indexes" => [
+                {
+                  "table" => "Names",
+                  "name" => "users_key",
+                }
+              ]
+            }
+          }
+        }
+        response = create_response(body)
+        assert_equal(response.tables["Names"].columns["users_key"],
+                     response.tables["Users"].indexes[0].column)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: groonga-client
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Haruka Yoshihara
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-21 00:00:00.000000000 Z
+date: 2016-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gqtp