rroonga 1.2.9 → 1.3.0

data/lib/groonga/view-record.rb

@@ -22,26 +22,20 @@ module Groonga
     # レコードのID
     attr_reader :id
 
-    # _table_の_id_に対応するレコードを作成する。
+    # _table_ の _id_ に対応するレコードを作成する。
     def initialize(view, id)
       @view = view
       @id = id
     end
 
-    # call-seq:
-    #   record == other -> true/false
-    #
-    # _record_と_other_が同じgroongaのレコードなら+true+を返し、
-    # そうでなければ+false+を返す。
+    # _record_ と _other_ が同じgroongaのレコードなら +true+ を返し、
+    # そうでなければ +false+ を返す。
     def ==(other)
       self.class == other.class and
         [view, id] == [other.view, other.id]
     end
 
-    # call-seq:
-    #   record[column_name] -> 値
-    #
-    # このレコードの_column_name_で指定されたカラムの値を返す。
+    # このレコードの _column_name_ で指定されたカラムの値を返す。
     def [](column_name)
       @view.column_value(@id, column_name)
     end

data/rroonga-build.rb

@@ -19,7 +19,7 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 1
     MINOR = 2
-    MICRO = 5
+    MICRO = 8
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

data/test/test-array.rb

@@ -62,9 +62,9 @@ class ArrayTest < Test::Unit::TestCase
                                       :source => "Bookmarks.user")
     morita = users.add(:name => "morita")
     gunyara_kun = users.add(:name => "gunyara-kun")
-    groonga = bookmarks.add(:title => "groonga", :user => morita)
-    google = bookmarks.add(:title => "google", :user => morita)
-    python = bookmarks.add(:title => "Python", :user => gunyara_kun)
+    bookmarks.add(:title => "groonga", :user => morita)
+    bookmarks.add(:title => "google", :user => morita)
+    bookmarks.add(:title => "Python", :user => gunyara_kun)
 
     assert_equal(["groonga", "google"],
                  index.search(morita.id).collect {|record| record.key["title"]})
@@ -86,7 +86,7 @@ class ArrayTest < Test::Unit::TestCase
 
   def test_column_value
     users = Groonga::Array.create(:name => "Users")
-    name = users.define_column("name", "ShortText")
+    users.define_column("name", "ShortText")
     morita_id = users.add.id
     users.set_column_value(morita_id, "name", "morita")
     assert_equal("morita", users.column_value(morita_id, "name"))
@@ -99,4 +99,25 @@ class ArrayTest < Test::Unit::TestCase
     second_user = users.add
     assert_predicate(second_user, :added?)
   end
+
+  def test_defrag
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "ShortText")
+    users.define_column("address", "ShortText")
+    1000.times do |i|
+      users.add(:name => "user #{i}" * 1000,
+                :address => "address #{i}" * 1000)
+    end
+    assert_equal(7, users.defrag)
+  end
+
+  def test_rename
+    users = Groonga::Array.create(:name => "Users")
+    name = users.define_column("name", "ShortText")
+    address = users.define_column("address", "ShortText")
+
+    users.rename("People")
+    assert_equal(["People", "People.name", "People.address"],
+                 [users.name, name.name, address.name])
+  end
 end

data/test/test-column.rb

@@ -254,7 +254,7 @@ class ColumnTest < Test::Unit::TestCase
 
   def test_set_time
     posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    body = posts.define_column("issued", "Time")
+    posts.define_column("issued", "Time")
 
     post = posts.add("hello", :issued => 123456)
     assert_equal(Time.at(123456), post[".issued"])
@@ -266,7 +266,7 @@ class ColumnTest < Test::Unit::TestCase
 
   def test_set_nil_to_time
     posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    body = posts.define_column("issued", "Time")
+    posts.define_column("issued", "Time")
 
     post = posts.add("hello", :issued => nil)
     assert_equal(Time.at(0), post["issued"])
@@ -274,7 +274,7 @@ class ColumnTest < Test::Unit::TestCase
 
   def test_bool
     posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    hidden = posts.define_column("hidden", "Bool")
+    posts.define_column("hidden", "Bool")
 
     post = posts.add("hello")
     assert_false(post["hidden"])
@@ -340,11 +340,11 @@ class ColumnTest < Test::Unit::TestCase
                                          :key_type => "ShortText",
                                          :key_normalize => true)
     index.default_tokenizer = "TokenBigram"
-    body_index = index.define_index_column("body_index", @posts,
-                                           :with_position => true,
-                                           :source => @body)
+    index.define_index_column("body_index", @posts,
+                              :with_position => true,
+                              :source => @body)
 
-    first_post = @posts.add("Hello!", :body => "World")
-    hobby = @posts.add("My Hobby", :body => "Drive and Eat")
+    @posts.add("Hello!", :body => "World")
+    @posts.add("My Hobby", :body => "Drive and Eat")
   end
 end

data/test/test-database.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
@@ -68,8 +68,7 @@ class DatabaseTest < Test::Unit::TestCase
       Groonga::Database.new(db_path.to_s)
     end
 
-    database = Groonga::Database.create(:path => db_path.to_s)
-
+    Groonga::Database.create(:path => db_path.to_s)
     assert_not_predicate(Groonga::Database.new(db_path.to_s), :closed?)
   end
 

data/test/test-double-array-trie.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 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
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class DoubleArrayTrieTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include ERB::Util
+
+  setup :setup_database
+
+  def test_support_key?
+    assert_predicate(Groonga::DoubleArrayTrie.create(:name => "Users",
+                                                     :key_type => "ShortText"),
+                     :support_key?)
+  end
+
+  def test_encoding
+    assert_equal(Groonga::Encoding.default,
+                 Groonga::DoubleArrayTrie.create.encoding)
+  end
+
+  def test_tokenizer
+    trie = Groonga::DoubleArrayTrie.create
+    assert_nil(trie.default_tokenizer)
+    trie.default_tokenizer = "TokenTrigram"
+    assert_equal(Groonga::Context.default["TokenTrigram"],
+                 trie.default_tokenizer)
+  end
+
+  def test_search
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "ShortText")
+
+    bookmarks = Groonga::DoubleArrayTrie.create(:name => "Bookmarks",
+                                                :key_type => "ShortText")
+    bookmarks.define_column("user_id", users)
+
+    daijiro = users.add
+    daijiro["name"] = "daijiro"
+    gunyarakun = users.add
+    gunyarakun["name"] = "gunyarakun"
+
+    groonga = bookmarks.add("http://groonga.org/")
+    groonga["user_id"] = daijiro
+
+    records = bookmarks.search("http://groonga.org/")
+    assert_equal(["daijiro"],
+                 records.records.collect {|record| record[".user_id.name"]})
+  end
+
+  def test_add
+    users = Groonga::DoubleArrayTrie.create(:name => "Users")
+    users.define_column("address", "Text")
+    me = users.add("me", :address => "me@example.com")
+    assert_equal("me@example.com", me[:address])
+  end
+
+  def test_default_tokenizer_on_create
+    terms = Groonga::DoubleArrayTrie.create(:name => "Terms",
+                                            :default_tokenizer => "TokenUnigram")
+    assert_equal(context[Groonga::Type::UNIGRAM],
+                 terms.default_tokenizer)
+  end
+
+  def test_duplicated_name
+    Groonga::DoubleArrayTrie.create(:name => "Users")
+    assert_raise(Groonga::InvalidArgument) do
+      Groonga::DoubleArrayTrie.create(:name => "Users")
+    end
+  end
+
+  def test_has_key?
+    users = Groonga::DoubleArrayTrie.create(:name => "Users")
+    assert_false(users.has_key?("morita"))
+    users.add("morita")
+    assert_true(users.has_key?("morita"))
+  end
+
+  def test_prefix_cursor
+    paths = Groonga::DoubleArrayTrie.create(:name => "Paths",
+                                            :key_type => 'ShortText')
+    paths.add('/')
+    paths.add('/tmp')
+    paths.add('/usr/bin')
+    paths.add('/usr/local/bin')
+
+    assert_prefix_cursor(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
+                         paths, "/", {:order => :desc})
+    assert_prefix_cursor(["/", "/tmp", "/usr/bin", "/usr/local/bin"],
+                         paths, "/")
+    assert_prefix_cursor(["/usr/local/bin", "/usr/bin"],
+                         paths, "/usr/local",
+                         {:key_bytes => "/usr".size, :order => :desc})
+    assert_prefix_cursor(["/tmp", "/usr/bin"],
+                         paths, "/",
+                         {:offset => 1, :limit => 2})
+  end
+
+  def assert_prefix_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_prefix_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key
+      end
+    end
+    assert_equal(expected, actual)
+  end
+
+  def test_add_uint_key
+    numbers = Groonga::DoubleArrayTrie.create(:name => "Numbers",
+                                              :key_type => "UInt32")
+    numbers.add(1)
+    numbers.add(2)
+    numbers.add(5)
+    numbers.add(7)
+    assert_equal([1, 2, 5, 7], numbers.collect {|number| number.key})
+  end
+
+  def test_added?
+    users = Groonga::DoubleArrayTrie.create(:name => "Users",
+                                            :key_type => "ShortText")
+    bob = users.add("bob")
+    assert_predicate(bob, :added?)
+    bob_again = users.add("bob")
+    assert_not_predicate(bob_again, :added?)
+  end
+
+  def test_defrag
+    users = Groonga::DoubleArrayTrie.create(:name => "Users",
+                                            :key_type => "ShortText")
+    users.define_column("name", "ShortText")
+    users.define_column("address", "ShortText")
+    1000.times do |i|
+      users.add("user #{i}",
+                :name => "user #{i}" * 1000,
+                :address => "address #{i}" * 1000)
+    end
+    assert_equal(7, users.defrag)
+  end
+
+  def test_rename
+    users = Groonga::DoubleArrayTrie.create(:name => "Users",
+                                            :key_type => "ShortText")
+    name = users.define_column("name", "ShortText")
+    address = users.define_column("address", "ShortText")
+
+    users.rename("People")
+    assert_equal(["People", "People.name", "People.address"],
+                 [users.name, name.name, address.name])
+  end
+end

data/test/test-expression-builder.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
@@ -75,7 +75,7 @@ class ExpressionBuilderTest < Test::Unit::TestCase
   end
 
   def test_not_equal
-    omit("not supported yet!!!")
+    only_ruby19
     result = @users.select do |record|
       record["name"] != "mori daijiro"
     end

data/test/test-expression.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2009  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
@@ -81,10 +82,10 @@ class ExpressionTest < Test::Unit::TestCase
 
   def test_snippet
     users = Groonga::Array.create(:name => "Users")
-    name = users.define_column("name", "ShortText")
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :key_type => "ShortText",
-                                 :default_tokenizer => "TokenBigram")
+    users.define_column("name", "ShortText")
+    Groonga::Hash.create(:name => "Terms",
+                         :key_type => "ShortText",
+                         :default_tokenizer => "TokenBigram")
     users.define_index_column("user_name", users,
                               :source => "Users.name",
                               :with_position => true)
@@ -111,10 +112,10 @@ class ExpressionTest < Test::Unit::TestCase
 
   def test_snippet_without_tags
     users = Groonga::Array.create(:name => "Users")
-    name = users.define_column("name", "ShortText")
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :key_type => "ShortText",
-                                 :default_tokenizer => "TokenBigram")
+    users.define_column("name", "ShortText")
+    Groonga::Hash.create(:name => "Terms",
+                         :key_type => "ShortText",
+                         :default_tokenizer => "TokenBigram")
     users.define_index_column("user_name", users,
                               :source => "Users.name",
                               :with_position => true)

data/test/test-gqtp.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-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
@@ -64,7 +64,7 @@ class GQTPTest < Test::Unit::TestCase
   private
   def process(gqtp)
     context.send(gqtp)
-    id, result = context.receive
+    _, result = context.receive
     JSON.parse(result)
   end
 end

data/test/test-hash.rb

@@ -31,7 +31,7 @@ class HashTest < Test::Unit::TestCase
     bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :path => bookmarks_path.to_s)
 
-    groonga = bookmarks.add("groonga")
+    bookmarks.add("groonga")
     google = bookmarks.add("Google")
     cutter = bookmarks.add("Cutter")
 
@@ -62,7 +62,7 @@ class HashTest < Test::Unit::TestCase
     bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :path => bookmarks_path.to_s,
                                      :key_type => "ShortText")
-    uri = bookmarks.define_column("uri", "ShortText")
+    bookmarks.define_column("uri", "ShortText")
     bookmarks.set_column_value("google", "uri", "http://google.com/")
     assert_equal("http://google.com/", bookmarks.column_value("google", "uri"))
   end
@@ -149,11 +149,11 @@ class HashTest < Test::Unit::TestCase
 
   def test_search
     users = Groonga::Array.create(:name => "Users")
-    user_name = users.define_column("name", "ShortText")
+    users.define_column("name", "ShortText")
 
     bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :key_type => "ShortText")
-    bookmark_user_id = bookmarks.define_column("user_id", users)
+    bookmarks.define_column("user_id", users)
 
     daijiro = users.add
     daijiro["name"] = "daijiro"
@@ -165,7 +165,7 @@ class HashTest < Test::Unit::TestCase
 
     records = bookmarks.search("http://groonga.org/")
     assert_equal(["daijiro"],
-                 records.records.collect {|record| record[".user_id.name"]})
+                 records.records.collect {|record| record["user_id.name"]})
   end
 
   def test_add
@@ -196,9 +196,9 @@ class HashTest < Test::Unit::TestCase
                                  :default_tokenizer => "TokenBigram")
     index = terms.define_index_column("comment", bookmarks,
                                       :source => "Bookmarks.comment")
-    groonga = bookmarks.add("groonga", :comment => "search engine by Brazil")
-    google = bookmarks.add("google", :comment => "search engine by Google")
-    ruby = bookmarks.add("ruby", :comment => "programing language")
+    bookmarks.add("groonga", :comment => "search engine by Brazil")
+    bookmarks.add("google", :comment => "search engine by Google")
+    bookmarks.add("ruby", :comment => "programing language")
 
     assert_equal(["groonga", "google"],
                  index.search("engine").collect {|record| record.key.key})
@@ -317,4 +317,28 @@ class HashTest < Test::Unit::TestCase
     bob_again = users.add("bob")
     assert_not_predicate(bob_again, :added?)
   end
+
+  def test_defrag
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    users.define_column("name", "ShortText")
+    users.define_column("address", "ShortText")
+    1000.times do |i|
+      users.add("user #{i}",
+                :name => "user #{i}" * 1000,
+                :address => "address #{i}" * 1000)
+    end
+    assert_equal(7, users.defrag)
+  end
+
+  def test_rename
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    name = users.define_column("name", "ShortText")
+    address = users.define_column("address", "ShortText")
+
+    users.rename("People")
+    assert_equal(["People", "People.name", "People.address"],
+                 [users.name, name.name, address.name])
+  end
 end