rroonga 1.0.1-x86-mingw32 → 1.1.0-x86-mingw32

data/rroonga-build.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  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
@@ -18,7 +18,7 @@
 module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 1
-    MINOR = 0
+    MINOR = 1
     MICRO = 0
     VERSION = [MAJOR, MINOR, MICRO]
   end
@@ -41,7 +41,7 @@ module RroongaBuild
 
   def prepend_pkg_config_path_for_local_groonga
     pkg_config_dir = File.join(local_groonga_install_dir, "lib", "pkgconfig")
-    PackageConfig.prepend_default_path(pkg_config_dir)
+    PKGConfig.add_path(pkg_config_dir)
   end
 
   def add_rpath_for_local_groonga

data/test/run-test.rb

@@ -67,7 +67,7 @@ $LOAD_PATH.unshift(test_dir)
 require 'groonga-test-utils'
 
 pkg_config = File.join(base_dir, "vendor", "local", "lib", "pkgconfig")
-PackageConfig.prepend_default_path(pkg_config)
+PKGConfig.add_path(pkg_config)
 
 Dir.glob("#{base_dir}/test/**/test{_,-}*.rb") do |file|
   require file.sub(/\.rb$/, '')

data/test/test-array.rb

@@ -18,6 +18,10 @@ class ArrayTest < Test::Unit::TestCase
 
   setup :setup_database
 
+  def test_support_key?
+    assert_not_predicate(Groonga::Array.create(:name => "Users"), :support_key?)
+  end
+
   def test_inspect_size
     path = @tables_dir + "named.groonga"
     contain_table = Groonga::Array.create(:name => "name", :path => path.to_s)

data/test/test-column.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  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
@@ -286,6 +286,36 @@ class ColumnTest < Test::Unit::TestCase
     assert_false(post["hidden"])
   end
 
+  def test_indexes
+    Groonga::Schema.define do |schema|
+      schema.create_table("Comments") do |table|
+        table.short_text("title")
+      end
+    end
+    title = Groonga["Comments.title"]
+    assert_equal([], title.indexes)
+
+    Groonga::Schema.define do |schema|
+      schema.create_table("Terms",
+                          :type => :patricia_trie,
+                          :default_tokenizer => "TokenBigram") do |table|
+        table.index("Comments.title")
+      end
+    end
+    assert_equal([Groonga["Terms.Comments_title"]],
+                 title.indexes)
+
+    Groonga::Schema.define do |schema|
+      schema.create_table("Titles",
+                          :type => :hash) do |table|
+        table.index("Comments.title")
+      end
+    end
+    assert_equal([Groonga["Titles.Comments_title"],
+                  Groonga["Terms.Comments_title"]],
+                 title.indexes)
+  end
+
   private
   def assert_content_search(expected_records, term)
     records = @bookmarks_index_content.search(term).records

data/test/test-context-select.rb

@@ -19,35 +19,58 @@ class ContextSelectTest < Test::Unit::TestCase
   setup :setup_database
   setup
   def setup_data
-    @books = Groonga::Hash.create(:name => "Books", :key_type => "ShortText")
-    @books.define_column("published", "Time")
-    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
-    @users.define_column("book", "Books")
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books",
+                          :type => :hash, :key_type => "ShortText") do |table|
+        table.time("published")
+      end
+
+      schema.create_table("Users",
+                          :type => :hash, :key_type => "ShortText") do |table|
+        table.reference("book", "Books")
+      end
+
+      schema.create_table("Bigram",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText",
+                          :default_tokenizer => "TokenBigramSplitSymbolAlpha") do |table|
+        table.index("Books._key")
+      end
+    end
+
+    @books = Groonga["Books"]
+    @users = Groonga["Users"]
 
     @books.add("the groonga book", :published => Time.parse("2010/04/01"))
+    @books.add("the groonga book (2)", :published => Time.parse("2011/04/01"))
+
     @users.add("morita", :book => "the groonga book")
     @users.add("gunyara-kun", :book => "the groonga book")
     @users.add("yu")
+    @users.add("ryoqun", :book => "the groonga book (2)")
   end
 
   def test_no_option
     result = context.select(@users)
-    assert_equal([3,
+    assert_equal([4,
                   [{"_id" => 1, "_key" => "morita",
                      "book" => "the groonga book"},
                    {"_id" => 2, "_key" => "gunyara-kun",
                      "book" => "the groonga book"},
                    {"_id" => 3, "_key" => "yu",
-                     "book" => ""}]],
+                     "book" => ""},
+                   {"_id" => 4, "_key" => "ryoqun",
+                     "book" => "the groonga book (2)"}]],
                  [result.n_hits, result.records])
   end
 
   def test_output_columns
     result = context.select(@users, :output_columns => ["_key"])
-    assert_equal([3,
+    assert_equal([4,
                   [{"_key" => "morita"},
                    {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"}]],
+                   {"_key" => "yu"},
+                   {"_key" => "ryoqun"}]],
                  [result.n_hits, result.records])
   end
 
@@ -58,15 +81,18 @@ class ContextSelectTest < Test::Unit::TestCase
                             :drill_down_output_columns => "_key",
                             :drill_down_limit => 10)
     drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([3,
+    assert_equal([4,
                   [{"_key" => "morita"},
                    {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"}],
+                   {"_key" => "yu"},
+                   {"_key" => "ryoqun"}],
                   {
-                    "_key" => [3, [{"_key" => "morita"},
+                    "_key" => [4, [{"_key" => "morita"},
                                    {"_key" => "gunyara-kun"},
-                                   {"_key" => "yu"}]],
-                    "book" => [1, [{"_key" => "the groonga book"}]],
+                                   {"_key" => "yu"},
+                                   {"_key" => "ryoqun"}]],
+                    "book" => [2, [{"_key" => "the groonga book"},
+                                   {"_key" => "the groonga book (2)"}]],
                   },
                  ],
                  [result.n_hits, result.records, drill_down])
@@ -95,11 +121,16 @@ class ContextSelectTest < Test::Unit::TestCase
                     "_id" => 1,
                     "_key" => "the groonga book",
                     "published" => Time.parse("2010/04/01"),
+                  },
+                  {
+                    "_id" => 2,
+                    "_key" => "the groonga book (2)",
+                    "published" => Time.parse("2011/04/01"),
                   }],
                  result.records)
   end
 
-  def test_invalid_select
+  def test_invalid
     assert_raise(Groonga::SyntaxError) do
       context.select(@books, :query => "<")
     end

data/test/test-context.rb

@@ -29,6 +29,42 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(Groonga::Encoding::UTF8, context.encoding)
   end
 
+  def test_create_database
+    db_path = @tmp_dir + "db"
+    assert_not_predicate(db_path, :exist?)
+    context = Groonga::Context.new
+    assert_equal(nil, context.database)
+    database = context.create_database(db_path.to_s)
+    assert_predicate(db_path, :exist?)
+    assert_not_predicate(database, :closed?)
+    assert_equal(database, context.database)
+  end
+
+  def test_create_temporary_database
+    before_files = @tmp_dir.children
+    context = Groonga::Context.new
+    database = context.create_database
+    assert_nil(database.name)
+    assert_equal(before_files, @tmp_dir.children)
+  end
+
+  def test_open_database
+    db_path = @tmp_dir + "db"
+    database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
+
+    assert_predicate(database, :closed?)
+    called = false
+    context = Groonga::Context.new
+    context.open_database(db_path.to_s) do |_database|
+      database = _database
+      assert_not_predicate(database, :closed?)
+      called = true
+    end
+    assert_true(called)
+    assert_predicate(database, :closed?)
+  end
+
   def test_encoding
     context = Groonga::Context.new
     assert_equal(Groonga::Encoding.default, context.encoding)
@@ -70,4 +106,12 @@ class ContextTest < Test::Unit::TestCase
     Groonga::Database.create
     assert_equal("ShortText", Groonga["ShortText"].name)
   end
+
+  def test_support_zlib?
+    assert_boolean(Groonga::Context.default.support_zlib?)
+  end
+
+  def test_support_lzo?
+    assert_boolean(Groonga::Context.default.support_lzo?)
+  end
 end

data/test/test-database.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2010  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
@@ -38,7 +38,9 @@ class DatabaseTest < Test::Unit::TestCase
   def test_open
     db_path = @tmp_dir + "db"
     database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
 
+    assert_predicate(database, :closed?)
     called = false
     Groonga::Database.open(db_path.to_s) do |_database|
       database = _database
@@ -49,6 +51,17 @@ class DatabaseTest < Test::Unit::TestCase
     assert_predicate(database, :closed?)
   end
 
+  def test_close
+    db_path = @tmp_dir + "db"
+    database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
+
+    database = Groonga::Database.open(db_path.to_s)
+    assert_not_predicate(database, :closed?)
+    database.close
+    assert_predicate(database, :closed?)
+  end
+
   def test_new
     db_path = @tmp_dir + "db"
     assert_raise(Groonga::NoSuchFileOrDirectory) do
@@ -110,4 +123,11 @@ class DatabaseTest < Test::Unit::TestCase
     database.clear_lock
     assert_not_predicate(database, :locked?)
   end
+
+  def test_touch
+    database = Groonga::Database.create
+    assert_nothing_raised do
+      database.touch
+    end
+  end
 end

data/test/test-expression-builder.rb

@@ -24,30 +24,41 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     @pets = Groonga::Hash.create(:name => "Pets", :key_type => "ShortText")
     @pets.define_column("name", "ShortText")
 
+    @sections = Groonga::PatriciaTrie.create(:name => "Sections",
+                                             :key_type => "ShortText")
+
     @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
     @name = @users.define_column("name", "ShortText")
     @hp = @users.define_column("hp", "UInt32")
-    @users.define_column("pet", @pets)
+    @user_pet = @users.define_column("pet", @pets)
+    @user_section = @users.define_column("section", @sections)
 
     @terms = Groonga::PatriciaTrie.create(:name => "Terms",
-                                          :default_tokenizer => "TokenBigram")
+                                          :default_tokenizer => "TokenBigram",
+                                          :key_type => "ShortText")
     @terms.define_index_column("user_name", @users, :source => @name)
 
     @bookmarks = Groonga::Array.create(:name => "Bookmarks")
     @bookmarks.define_column("user", @users)
     @bookmarks.define_column("uri", "ShortText")
+
+    @sections.define_index_column("user_section", @users,
+                                  :source => @user_section)
   end
 
   def setup_data
     @morita = @users.add("morita",
                          :name => "mori daijiro",
-                         :hp => 100)
+                         :hp => 100,
+                         :section => "search/core")
     @gunyara_kun = @users.add("gunyara-kun",
                               :name => "Tasuku SUENAGA",
-                              :hp => 150)
+                              :hp => 150,
+                              :section => "suggest/all")
     @yu = @users.add("yu",
                      :name => "Yutaro Shimamura",
-                     :hp => 200)
+                     :hp => 200,
+                     :section => "search/all")
 
     @groonga = @bookmarks.add(:user => @morita, :uri => "http://groonga.org/")
     @ruby = @bookmarks.add(:user => @morita, :uri => "http://ruby-lang.org/")
@@ -118,6 +129,22 @@ class ExpressionBuilderTest < Test::Unit::TestCase
                  result.collect {|record| record.key.key})
   end
 
+  def test_prefix_saerch
+    result = @users.select do |record|
+      record.section.prefix_search("search")
+    end
+    assert_equal(["morita", "yu"].sort,
+                 result.collect {|record| record.key.key}.sort)
+  end
+
+  def test_suffix_search
+    result = @users.select do |record|
+      record.name.suffix_search("jiro")
+    end
+    assert_equal(["morita"].sort,
+                 result.collect {|record| record.key.key}.sort)
+  end
+
   def test_query_string
     result = @users.select("name:@ro")
     assert_equal(["morita", "yu"],
@@ -140,6 +167,20 @@ class ExpressionBuilderTest < Test::Unit::TestCase
                  result.collect {|record| record.key["uri"]})
   end
 
+  def test_record_id_object
+    morita = Object.new
+    morita_singleton_class = (class << morita; self; end)
+    morita_id = @morita.id
+    morita_singleton_class.send(:define_method, :record_id) do
+      morita_id
+    end
+    result = @bookmarks.select do |record|
+      record["user"] == morita
+    end
+    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
+                 result.collect {|record| record.key["uri"]})
+  end
+
   def test_nested_column
     result = @bookmarks.select do |record|
       record[".user.name"] == @morita["name"]

data/test/test-fix-size-column.rb

@@ -32,6 +32,18 @@ class FixSizeColumnTest < Test::Unit::TestCase
                                        :path => @viewed_column_path.to_s)
   end
 
+  def test_index?
+    assert_not_predicate(@viewed, :index?)
+  end
+
+  def test_vector?
+    assert_not_predicate(@viewed, :vector?)
+  end
+
+  def test_scalar?
+    assert_predicate(@viewed, :scalar?)
+  end
+
   def test_inspect
     assert_equal("#<Groonga::FixSizeColumn " +
                  "id: <#{@viewed.id}>, " +

data/test/test-hash.rb

@@ -19,6 +19,12 @@ class HashTest < Test::Unit::TestCase
 
   setup :setup_database
 
+  def test_support_key?
+    assert_predicate(Groonga::Hash.create(:name => "Users",
+                                          :key_type => "ShortText"),
+                     :support_key?)
+  end
+
   def test_delete
     bookmarks_path = @tables_dir + "bookmarks"
     bookmarks = Groonga::Hash.create(:name => "Bookmarks",
@@ -77,7 +83,7 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{anonymous_table.id}>, " +
                  "name: (anonymous), " +
                  "path: <#{path}>, " +
-                 "domain: (nil), " +
+                 "domain: <ShortText>, " +
                  "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
@@ -91,7 +97,7 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{anonymous_table.id}>, " +
                  "name: (anonymous), " +
                  "path: (temporary), " +
-                 "domain: (nil), " +
+                 "domain: <ShortText>, " +
                  "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
@@ -106,7 +112,7 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{named_table.id}>, " +
                  "name: <Users>, " +
                  "path: <#{path}>, " +
-                 "domain: (nil), " +
+                 "domain: <ShortText>, " +
                  "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
@@ -120,7 +126,7 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{named_table.id}>, " +
                  "name: (anonymous), " +
                  "path: (temporary), " +
-                 "domain: (nil), " +
+                 "domain: <ShortText>, " +
                  "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +