rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

data/ext/groonga/rb-grn.h

@@ -101,7 +101,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 5
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 1
+#define RB_GRN_MICRO_VERSION 2
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 

data/lib/groonga/query-logger.rb

@@ -18,7 +18,18 @@
 module Groonga
   class QueryLogger
     module Flags
+      NAMES = {
+        :none        => NONE,
+        :command     => COMMAND,
+        :result_code => RESULT_CODE,
+        :destination => DESTINATION,
+        :cache       => CACHE,
+        :size        => SIZE,
+        :score       => SCORE,
+      }
+
       LABELS = {
+        NONE        => "none",
         COMMAND     => "command",
         RESULT_CODE => "result_code",
         DESTINATION => "destination",
@@ -28,9 +39,43 @@ module Groonga
       }
 
       class << self
-        def parse(input, base_flags)
-          # TODO
-          base_flags
+        # TODO: Document me.
+        def parse(input, base_flags=nil)
+          base_flags |= Flags::NONE
+          case input
+          when nil
+            base_flags
+          when Integer
+            input | base_flags
+          when String, Symbol
+            value = NAMES[input.to_sym]
+            if value.nil?
+              message =
+                "flag name must be one of #{NAMES.keys.inspect}: " +
+                "<#{input.inspect}>"
+              raise ArgumentError, message
+            end
+            value | base_flags
+          when ::Array
+            input.inject(base_flags) do |flags, sub_input|
+              parse(sub_input, flags)
+            end
+          when ::Hash
+            flags = base_flags
+            input.each do |key, use_key|
+              if use_key
+                flags = parse(key, flags)
+              else
+                flags &= ~parse(key, 0)
+              end
+            end
+            flags
+          else
+            message =
+              "flags value must be nil, Integer, names, " +
+              "Array of flag or Hash of name and boolean: <#{input.inspect}>"
+            raise ArgumentError, message
+          end
         end
 
         def label(flags)

data/lib/groonga/schema.rb

@@ -1209,8 +1209,16 @@ module Groonga
       # @private
       def table_type
         type = @options[:type]
+        if type.nil?
+          if @options[:key_type]
+            type = :hash
+          else
+            type = :array
+          end
+        end
+
         case type
-        when :array, nil
+        when :array
           Groonga::Array
         when :hash
           Groonga::Hash
@@ -1219,8 +1227,13 @@ module Groonga
         when :double_array_trie
           Groonga::DoubleArrayTrie
         else
-          supported_types = [nil, :array, :hash, :patricia_trie,
-                             :double_array_trie]
+          supported_types = [
+            nil,
+            :array,
+            :hash,
+            :patricia_trie,
+            :double_array_trie,
+          ]
           raise UnknownTableType.new(type, supported_types)
         end
       end

data/rroonga-build.rb

@@ -20,15 +20,15 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 5
     MINOR = 0
-    MICRO = 2
+    MICRO = 3
     VERSION = [MAJOR, MINOR, MICRO]
-    RELEASED_DATE = Time.utc(2015, 2, 9)
+    RELEASED_DATE = Time.utc(2015, 3, 31)
   end
 
   module LatestGroongaVersion
     MAJOR = 5
     MINOR = 0
-    MICRO = 2
+    MICRO = 3
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

data/test/test-logger.rb

@@ -18,12 +18,12 @@ class LoggerTest < Test::Unit::TestCase
 
   def setup
     @default_log_path = Groonga::Logger.path
-    @default_query_log_path = Groonga::QueryLogger.path
+    @default_rotate_threshold_size = Groonga::Logger.rotate_threshold_size
   end
 
   def teardown
     Groonga::Logger.path = @default_log_path
-    Groonga::QueryLogger.path = @default_query_log_path
+    Groonga::Logger.rotate_threshold_size = @default_rotate_threshold_size
   end
 
   def test_reopen
@@ -36,4 +36,99 @@ class LoggerTest < Test::Unit::TestCase
     Groonga::Logger.reopen
     assert_true(@log_path.exist?)
   end
+
+  sub_test_case ".log" do
+    test "no options" do
+      messages = []
+      Groonga::Logger.register do |event, level, time, title, message, location|
+        messages << message
+      end
+      Groonga::Logger.log("1")
+      Groonga::Logger.log("2")
+      Groonga::Logger.log("3")
+      assert_equal(["1", "2", "3"],
+                   messages)
+    end
+
+    test ":level" do
+      levels = []
+      Groonga::Logger.register(:max_level => :dump) do |event, level, *rest|
+        levels << level
+      end
+      Groonga::Logger.log("default")
+      Groonga::Logger.log("debug", :level => :debug)
+      assert_equal([:notice, :debug],
+                   levels)
+    end
+
+    test "default location" do
+      locations = []
+      Groonga::Logger.register do |event, level, time, title, message, location|
+        locations << location
+      end
+      Groonga::Logger.log("message"); line = __LINE__
+      function = caller_locations(0, 1)[0].label
+      assert_equal([
+                     "#{Process.pid} #{__FILE__}:#{line} #{function}()",
+                   ],
+                   locations)
+    end
+
+    test ":file" do
+      locations = []
+      Groonga::Logger.register do |event, level, time, title, message, location|
+        locations << location
+      end
+      Groonga::Logger.log("message", :file => "file.rb")
+      locations = locations.collect do |location|
+        location.gsub(/\A(\d+) (.*?):(\d+) (.*?)\(\)\z/,
+                      "0 \\2:0 function()")
+      end
+      assert_equal([
+                     "0 file.rb:0 function()",
+                   ],
+                   locations)
+    end
+
+    test ":line" do
+      locations = []
+      Groonga::Logger.register do |event, level, time, title, message, location|
+        locations << location
+      end
+      Groonga::Logger.log("message", :line => 100)
+      locations = locations.collect do |location|
+        location.gsub(/\A(\d+) (.*?):(\d+) (.*?)\(\)\z/,
+                      "0 test.rb:\\3 function()")
+      end
+      assert_equal([
+                     "0 test.rb:100 function()",
+                   ],
+                   locations)
+    end
+
+    test ":function" do
+      locations = []
+      Groonga::Logger.register do |event, level, time, title, message, location|
+        locations << location
+      end
+      Groonga::Logger.log("message", :function => "method_name")
+      locations = locations.collect do |location|
+        location.gsub(/\A(\d+) (.*?):(\d+) (.*?)\(\)\z/,
+                      "0 test.rb:0 \\4()")
+      end
+      assert_equal([
+                     "0 test.rb:0 method_name()",
+                   ],
+                   locations)
+    end
+  end
+
+  def test_rotate_threshold_size
+    Groonga::Logger.unregister
+    Groonga::Logger.path = @log_path.to_s
+    Groonga::Logger.rotate_threshold_size = 10
+    assert_equal([], Dir.glob("#{@log_path}.*"))
+    Groonga::Logger.log("Hello")
+    assert_not_equal([], Dir.glob("#{@log_path}.*"))
+  end
 end

data/test/test-plugin.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2011-2015  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
@@ -35,6 +35,10 @@ class PluginTest < Test::Unit::TestCase
     end
   end
 
+  def test_ruby_suffix
+    assert_equal(".rb", Groonga::Plugin.ruby_suffix)
+  end
+
   class UnregisterTest < self
     def test_by_name
       context.register_plugin("token_filters/stop_word")

data/test/test-query-logger.rb

@@ -0,0 +1,149 @@
+# Copyright (C) 2015  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 version 2.1 as published by the Free Software Foundation.
+#
+# 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
+
+class QueryLoggerTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    @default_log_path = Groonga::QueryLogger.path
+    @default_rotate_threshold_size = Groonga::QueryLogger.rotate_threshold_size
+  end
+
+  def teardown
+    Groonga::QueryLogger.path = @default_log_path
+    Groonga::QueryLogger.rotate_threshold_size = @default_rotate_threshold_size
+  end
+
+  def test_reopen
+    Groonga::QueryLogger.unregister
+    Groonga::QueryLogger.path = @query_log_path.to_s
+    if @query_log_path.exist?
+      FileUtils.mv(@query_log_path, "#{@query_log_path}.old")
+    end
+    assert do
+      not @query_log_path.exist?
+    end
+    Groonga::QueryLogger.reopen
+    assert do
+      @query_log_path.exist?
+    end
+  end
+
+  sub_test_case ".parse" do
+    def parse(input, base_flags=nil)
+      base_flags ||= Groonga::QueryLogger::Flags::NONE
+      Groonga::QueryLogger::Flags.parse(input, base_flags)
+    end
+
+    test "nil" do
+      assert_equal(Groonga::QueryLogger::Flags::NONE,
+                   parse(nil))
+    end
+
+    test "Integer" do
+      assert_equal(Groonga::QueryLogger::Flags::COMMAND,
+                   parse(Groonga::QueryLogger::Flags::COMMAND))
+    end
+
+    test "String" do
+      assert_equal(Groonga::QueryLogger::Flags::COMMAND,
+                   parse("command"))
+    end
+
+    test "Symbol" do
+      assert_equal(Groonga::QueryLogger::Flags::COMMAND,
+                   parse(:command))
+    end
+
+    test "Array" do
+      assert_equal(Groonga::QueryLogger::Flags::COMMAND |
+                   Groonga::QueryLogger::Flags::RESULT_CODE,
+                   parse([:command, :result_code]))
+    end
+
+    test "Hash" do
+      assert_equal(Groonga::QueryLogger::Flags::COMMAND |
+                   Groonga::QueryLogger::Flags::DESTINATION,
+                   parse({
+                           :command => true,
+                           :result_code => false,
+                           :destination => true,
+                         },
+                         Groonga::QueryLogger::Flags::COMMAND |
+                         Groonga::QueryLogger::Flags::RESULT_CODE))
+    end
+  end
+
+  sub_test_case ".log" do
+    test "no options" do
+      messages = []
+      Groonga::QueryLogger.register do |action, flag, timestamp, info, message|
+        messages << message
+      end
+      Groonga::QueryLogger.log("1")
+      Groonga::QueryLogger.log("2")
+      Groonga::QueryLogger.log("3")
+      assert_equal(["1", "2", "3"],
+                   messages)
+    end
+
+    test ":flags" do
+      infos = []
+      Groonga::QueryLogger.register do |action, flag, timestamp, info, message|
+        infos << info
+      end
+      Groonga::QueryLogger.log("default")
+      Groonga::QueryLogger.log("flags", :flags => "command")
+      normalized_infos = infos.collect do |info|
+        info = info.gsub(/\A0x[a-f\d]+\|/,
+                         "context_id|")
+        info.gsub(/\|[\d]+ \z/,
+                  "|timestamp ")
+      end
+      assert_equal([
+                     "context_id|timestamp ",
+                     "context_id|",
+                   ],
+                   normalized_infos)
+    end
+
+    test ":mark" do
+      infos = []
+      Groonga::QueryLogger.register do |action, flag, timestamp, info, message|
+        infos << info
+      end
+      Groonga::QueryLogger.log("default")
+      Groonga::QueryLogger.log("mark", :mark => ":")
+      normalized_infos = infos.collect do |info|
+        info.gsub(/\A0x[a-f\d]+\|([^\d])?[\d]+ \z/,
+                  "context_id|\\1timestamp ")
+      end
+      assert_equal([
+                     "context_id|timestamp ",
+                     "context_id|:timestamp ",
+                   ],
+                   normalized_infos)
+    end
+  end
+
+  def test_rotate_threshold_size
+    Groonga::QueryLogger.unregister
+    Groonga::QueryLogger.path = @query_log_path.to_s
+    Groonga::QueryLogger.rotate_threshold_size = 10
+    assert_equal([], Dir.glob("#{@query_log_path}.*"))
+    Groonga::QueryLogger.log("command")
+    assert_not_equal([], Dir.glob("#{@query_log_path}.*"))
+  end
+end

data/test/test-schema.rb

@@ -71,6 +71,25 @@ class SchemaTest < Test::Unit::TestCase
     end
   end
 
+  sub_test_case "define table" do
+    sub_test_case ":key_type" do
+      test "exist" do
+        Groonga::Schema.create_table("Posts",
+                                     :key_type => :short_text) do |table|
+        end
+        posts = context["Posts"]
+        assert_kind_of(Groonga::Hash, posts)
+      end
+
+      test "not exist" do
+        Groonga::Schema.create_table("Posts") do |table|
+        end
+        posts = context["Posts"]
+        assert_kind_of(Groonga::Array, posts)
+      end
+    end
+  end
+
   class DefineHashTest < self
     def test_default
       Groonga::Schema.create_table("Posts", :type => :hash) do |table|