groonga 0.0.5 → 0.0.6

data/test/test-database.rb

@@ -63,8 +63,7 @@ class DatabaseTest < Test::Unit::TestCase
   def test_each
     db_path = @tmp_dir + "db"
     database = Groonga::Database.create(:path => db_path.to_s)
-    assert_equal(["/q/define_selector",
-                  "Bool",
+    assert_equal(["Bool",
                   "Float",
                   "Int16",
                   "Int32",
@@ -83,7 +82,16 @@ class DatabaseTest < Test::Unit::TestCase
                   "UInt16",
                   "UInt32",
                   "UInt64",
-                  "UInt8"],
+                  "UInt8",
+                  "column_create",
+                  "column_list",
+                  "define_selector",
+                  "expr_missing",
+                  "load",
+                  "select",
+                  "status",
+                  "table_create",
+                  "table_list"],
                  database.collect {|object| object.name}.sort)
   end
 

data/test/test-expression-builder.rb

@@ -28,6 +28,10 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     @terms = Groonga::PatriciaTrie.create(:name => "<terms>",
                                           :default_tokenizer => "TokenBigram")
     @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")
   end
 
   def setup_data
@@ -40,6 +44,11 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     @yu = @users.add("yu",
                      :name => "Yutaro Shimamura",
                      :hp => 200)
+
+    @groonga = @bookmarks.add(:user => @morita, :uri => "http://groonga.org/")
+    @ruby = @bookmarks.add(:user => @morita, :uri => "http://ruby-lang.org/")
+    @nico_dict = @bookmarks.add(:user => @gunyara_kun,
+                                :uri => "http://dic.nicovideo.jp/")
   end
 
   def test_equal
@@ -106,9 +115,24 @@ class ExpressionBuilderTest < Test::Unit::TestCase
   end
 
   def test_query_string
-    omit("not supported yet!!!")
-    result = @name.select("ro")
+    result = @users.select("name:%ro")
     assert_equal(["morita", "yu"],
                  result.collect {|record| record.key.key})
   end
+
+  def test_record
+    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_record_id
+    result = @bookmarks.select do |record|
+      record["user"] == @morita.id
+    end
+    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
+                 result.collect {|record| record.key["uri"]})
+  end
 end

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

@@ -38,7 +38,8 @@ class FixSizeColumnTest < Test::Unit::TestCase
                  "name: <bookmarks.viewed>, " +
                  "path: <#{@viewed_column_path}>, " +
                  "domain: <#{@bookmarks.inspect}>, " +
-                 "range: <#{context['<int>'].inspect}>" +
+                 "range: <#{context['<int>'].inspect}>, " +
+                 "flags: <KEY_INT>" +
                  ">",
                  @viewed.inspect)
   end

data/test/test-hash.rb

@@ -42,11 +42,12 @@ class HashTest < Test::Unit::TestCase
 
   def test_array_reference
     value = "groonga"
+    value_type = Groonga::Type.new("Text#{value.size}", :size => value.size)
     bookmarks_path = @tables_dir + "bookmarks"
     bookmarks = Groonga::Hash.create(:name => "bookmarks",
                                      :path => bookmarks_path.to_s,
                                      :key_type => "<shorttext>",
-                                     :value_size => value.size)
+                                     :value_type => value_type)
     bookmarks["http://google.com/"] = value
     assert_equal(value, bookmarks["http://google.com/"])
   end
@@ -70,6 +71,7 @@ class HashTest < Test::Unit::TestCase
                  "path: <#{path}>, " +
                  "domain: <nil>, " +
                  "range: <nil>, " +
+                 "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
                  anonymous_table.inspect)
@@ -83,6 +85,7 @@ class HashTest < Test::Unit::TestCase
                  "path: (temporary), " +
                  "domain: <nil>, " +
                  "range: <nil>, " +
+                 "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
                  anonymous_table.inspect)
@@ -97,6 +100,7 @@ class HashTest < Test::Unit::TestCase
                  "path: <#{path}>, " +
                  "domain: <nil>, " +
                  "range: <nil>, " +
+                 "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
                  named_table.inspect)
@@ -110,6 +114,7 @@ class HashTest < Test::Unit::TestCase
                  "path: (temporary), " +
                  "domain: <nil>, " +
                  "range: <nil>, " +
+                 "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
                  named_table.inspect)

data/test/test-record.rb

@@ -55,8 +55,9 @@ class RecordTest < Test::Unit::TestCase
 
   def setup_bookmarks_table
     @bookmarks_path = @tables_dir + "bookmarks"
+    value_type = Groonga::Type.new("Text512", :size => 512)
     @bookmarks = Groonga::Array.create(:name => "bookmarks",
-                                       :value_size => 512,
+                                       :value_type => value_type,
                                        :path => @bookmarks_path.to_s)
 
     @uri_column_path = @columns_dir + "uri"

data/test/test-schema.rb

@@ -25,6 +25,24 @@ class SchemaTest < Test::Unit::TestCase
     assert_not_nil(context["<posts>"])
   end
 
+  def test_create_table_force
+    Groonga::Schema.create_table("posts") do |table|
+    end
+    assert_raise(Groonga::InvalidArgument) do
+      Groonga::Schema.create_table("posts") do |table|
+      end
+    end
+    Groonga::Schema.create_table("posts", :force => true) do |table|
+    end
+  end
+
+  def test_remove_table
+    Groonga::Array.create(:name => "posts")
+    assert_not_nil(context["posts"])
+    Groonga::Schema.remove_table("posts")
+    assert_nil(context["posts"])
+  end
+
   def test_define_hash
     Groonga::Schema.create_table("<posts>", :type => :hash) do |table|
     end
@@ -34,11 +52,12 @@ class SchemaTest < Test::Unit::TestCase
   def test_define_hash_with_full_option
     path = @tmp_dir + "hash.groonga"
     tokenizer = context["<token:trigram>"]
+    type = Groonga::Type.new("Niku", :size => 29)
     Groonga::Schema.create_table("<posts>",
                                  :type => :hash,
                                  :key_type => "integer",
                                  :path => path.to_s,
-                                 :value_size => 29,
+                                 :value_type => type,
                                  :default_tokenizer => tokenizer) do |table|
     end
     table = context["<posts>"]
@@ -47,7 +66,8 @@ class SchemaTest < Test::Unit::TestCase
                  "name: <<posts>>, " +
                  "path: <#{path}>, " +
                  "domain: <#{context['<int>'].inspect}>, " +
-                 "range: <nil>, " +
+                 "range: <#{type.inspect}>, " +
+                 "flags: <>, " +
                  "encoding: <#{Groonga::Encoding.default.inspect}>, " +
                  "size: <0>>",
                  table.inspect)
@@ -62,11 +82,12 @@ class SchemaTest < Test::Unit::TestCase
 
   def test_define_patricia_trie_with_full_option
     path = @tmp_dir + "patricia-trie.groonga"
+    type = Groonga::Type.new("Niku", :size => 29)
     Groonga::Schema.create_table("<posts>",
                                  :type => :patricia_trie,
                                  :key_type => "integer",
                                  :path => path.to_s,
-                                 :value_size => 29,
+                                 :value_type => type,
                                  :default_tokenizer => "<token:bigram>",
                                  :key_normalize => true,
                                  :key_with_sis => true) do |table|
@@ -77,7 +98,8 @@ class SchemaTest < Test::Unit::TestCase
                  "name: <<posts>>, " +
                  "path: <#{path}>, " +
                  "domain: <#{context['<int>'].inspect}>, " +
-                 "range: <nil>, " +
+                 "range: <#{type.inspect}>, " +
+                 "flags: <KEY_WITH_SIS|KEY_NORMALIZE|WITH_SECTION>, " +
                  "encoding: <#{Groonga::Encoding.default.inspect}>, " +
                  "size: <0>>",
                  table.inspect)
@@ -92,10 +114,11 @@ class SchemaTest < Test::Unit::TestCase
 
   def test_define_array_with_full_option
     path = @tmp_dir + "array.groonga"
+    type = Groonga::Type.new("Niku", :size => 29)
     Groonga::Schema.create_table("<posts>",
                                  :type => :array,
                                  :path => path.to_s,
-                                 :value_size => 29) do |table|
+                                 :value_type => type) do |table|
     end
     table = context["<posts>"]
     assert_equal("#<Groonga::Array " +
@@ -103,7 +126,8 @@ class SchemaTest < Test::Unit::TestCase
                  "name: <<posts>>, " +
                  "path: <#{path}>, " +
                  "domain: <nil>, " +
-                 "range: <nil>, " +
+                 "range: <#{type.inspect}>, " +
+                 "flags: <>, " +
                  "size: <0>>",
                  table.inspect)
   end
@@ -180,28 +204,79 @@ class SchemaTest < Test::Unit::TestCase
     assert_equal(context["<longtext>"], context["<posts>.content"].range)
   end
 
+  def test_remove_column
+    Groonga::Schema.create_table("posts") do |table|
+      table.long_text :content
+    end
+    assert_not_nil(context["posts.content"])
+
+    Groonga::Schema.change_table("posts") do |table|
+      table.remove_column("content")
+    end
+    assert_nil(context["posts.content"])
+  end
+
   def test_index
     assert_nil(context["<terms>.content"])
     Groonga::Schema.create_table("<posts>") do |table|
       table.long_text :content
     end
     Groonga::Schema.create_table("<terms>") do |table|
-      table.index :posts_content, "<posts>.content"
+      table.index "<posts>.content"
     end
     assert_equal([context["<posts>.content"]],
-                 context["<terms>.posts_content"].sources)
+                 context["<terms>.<posts>_content"].sources)
   end
 
   def test_dump
     Groonga::Schema.define do |schema|
-      schema.create_table("<posts>") do |table|
+      schema.create_table("posts") do |table|
         table.short_text :title
       end
     end
     assert_equal(<<-EOS, Groonga::Schema.dump)
-create_table("<posts>") do |table|
+create_table("posts") do |table|
+  table.short_text("title")
+end
+EOS
+  end
+
+  def test_reference_dump
+    Groonga::Schema.define do |schema|
+      schema.create_table("items") do |table|
+        table.short_text("title")
+      end
+
+      schema.create_table("users") do |table|
+        table.short_text("name")
+      end
+
+      schema.create_table("comments") do |table|
+        table.reference("item", "items")
+        table.reference("author", "users")
+        table.text("content")
+        table.time("issued")
+      end
+    end
+
+    assert_equal(<<-EOS, Groonga::Schema.dump)
+create_table("comments") do |table|
+  table.text("content")
+  table.time("issued")
+end
+
+create_table("items") do |table|
   table.short_text("title")
 end
+
+create_table("users") do |table|
+  table.short_text("name")
+end
+
+change_table("comments") do |table|
+  table.reference("author", "users")
+  table.reference("item", "items")
+end
 EOS
   end
 end

data/test/test-table.rb

@@ -158,9 +158,10 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_set_value
+    value_type = Groonga::Type.new("Text512", :size => 512)
     table_path = @tables_dir + "bookmarks"
     bookmarks = Groonga::Hash.create(:name => "bookmarks",
-                                     :value_size => 512,
+                                     :value_type => value_type,
                                      :path => table_path.to_s)
     comment_column_path = @columns_dir + "comment"
     bookmarks_comment =
@@ -178,8 +179,9 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_array_set
+    value_type = Groonga::Type.new("Text512", :size => 512)
     bookmarks = Groonga::Hash.create(:name => "bookmarks",
-                                     :value_size => 512)
+                                     :value_type => value_type)
     url = "http://groonga.org/"
     bookmarks["groonga"] = "#{url}\0"
 
@@ -205,10 +207,12 @@ class TableTest < Test::Unit::TestCase
     users_path = @tables_dir + "users"
     users = Groonga::Hash.create(:name => "users",
                                  :path => users_path.to_s)
+
+    value_type = Groonga::Type.new("Text512", :size => 512)
     bookmarks_path = @tables_dir + "bookmarks"
     bookmarks = Groonga::Hash.create(:name => "bookmarks",
                                      :key_type => users,
-                                     :value_size => 512,
+                                     :value_type => value_type,
                                      :path => bookmarks_path.to_s)
     morita = users.add("morita")
     groonga = bookmarks.add(morita.id)
@@ -229,6 +233,15 @@ class TableTest < Test::Unit::TestCase
                  bookmarks.columns.collect {|column| column.name}.sort)
   end
 
+  def test_column_by_symbol
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "bookmarks",
+                                      :path => bookmarks_path.to_s)
+
+    uri_column = bookmarks.define_column("uri", "Text")
+    assert_equal(uri_column, bookmarks.column(:uri))
+  end
+
   def test_size
     bookmarks_path = @tables_dir + "bookmarks"
     bookmarks = Groonga::Array.create(:name => "bookmarks",
@@ -343,6 +356,19 @@ class TableTest < Test::Unit::TestCase
                  results.collect {|record| record["id"]})
   end
 
+  def test_sort_by_array
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    id_column = bookmarks.define_column("id", "<int>")
+    100.times do |i|
+      bookmark = bookmarks.add
+      bookmark["id"] = i + 100
+    end
+
+    results = bookmarks.sort([["id", "descending"]], :limit => 20)
+    assert_equal((180..199).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
   def test_sort_without_limit
     bookmarks = Groonga::Array.create(:name => "<bookmarks>")
     id_column = bookmarks.define_column("id", "<int>")
@@ -356,6 +382,15 @@ class TableTest < Test::Unit::TestCase
                  results.collect {|record| record["id"]})
   end
 
+  def test_select_without_block
+    comments = Groonga::Array.create(:name => "comments")
+    comment1 = comments.add
+    comment2 = comments.add
+    comment3 = comments.add
+    assert_equal([comment1, comment2, comment3],
+                 comments.select.collect {|record| record.key})
+  end
+
   def test_group
     bookmarks = Groonga::Hash.create(:name => "<bookmarks>")
     bookmarks.define_column("title", "<text>")
@@ -391,6 +426,67 @@ class TableTest < Test::Unit::TestCase
                  end)
   end
 
+  def test_union!
+    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    groonga = bookmarks.add("http://groonga.org/", :title => "groonga")
+    ruby = bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    groonga_bookmarks = bookmarks.select {|record| record["title"] == "groonga"}
+    assert_equal(["Ruby", "groonga"],
+                 ruby_bookmarks.union!(groonga_bookmarks).collect do |record|
+                   record[".title"]
+                 end)
+  end
+
+  def test_intersection!
+    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    all_bookmarks = bookmarks.select
+    assert_equal(["Ruby"],
+                 ruby_bookmarks.intersection!(all_bookmarks).collect do |record|
+                   record[".title"]
+                 end)
+  end
+
+  def test_difference!
+    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    all_bookmarks = bookmarks.select
+    assert_equal(["groonga"],
+                 all_bookmarks.difference!(ruby_bookmarks).collect do |record|
+                   record[".title"]
+                 end)
+  end
+
+  def test_merge!
+    omit("should write a test")
+    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    all_bookmarks = bookmarks.select
+    assert_equal(["groonga"],
+                 all_bookmarks.merge!(ruby_bookmarks).collect do |record|
+                   [record[".title"], record[".:score"]]
+                 end)
+  end
+
   def test_lock
     bookmarks = Groonga::Array.create(:name => "<bookmarks>")
     bookmark = bookmarks.add

data/test/test-type.rb

@@ -19,7 +19,7 @@ class TypeTest < Test::Unit::TestCase
   setup :setup_database
 
   def test_new
-    type = Groonga::Type.new("user-id", :type => :integer)
+    type = Groonga::Type.new("user-id", :option => :integer)
     assert_equal("user-id", type.name)
   end
 
@@ -47,7 +47,8 @@ class TypeTest < Test::Unit::TestCase
                  "name: <LongText>, " +
                  "path: (temporary), " +
                  "domain: <nil>, " +
-                 "range: <2147483648>>",
+                 "range: <2147483648>, " +
+                 "flags: <>>",
                  context["<longtext>"].inspect)
   end
 

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

@@ -38,7 +38,8 @@ class VariableSizeColumnTest < Test::Unit::TestCase
                  "name: <users.name>, " +
                  "path: <#{@users_name_column_path}>, " +
                  "domain: <#{@users.inspect}>, " +
-                 "range: <#{context['<shorttext>'].inspect}>" +
+                 "range: <#{context['<shorttext>'].inspect}>, " +
+                 "flags: <>" +
                  ">",
                  @name.inspect)
   end

data/test-unit/Rakefile

@@ -1,12 +1,17 @@
 # -*- ruby -*-
 
 require 'rubygems'
+gem 'rdoc'
 require 'hoe'
 require './lib/test/unit/version.rb'
 
+ENV["NODOT"] = "yes"
+
 version = Test::Unit::VERSION
 ENV["VERSION"] = version
-Hoe.new('test-unit', version) do |p|
+Hoe.spec('test-unit') do |p|
+  Hoe::Test::SUPPORTED_TEST_FRAMEWORKS[:testunit2] = "test/run-test.rb"
+  p.version = version
   p.developer('Kouhei Sutou', 'kou@cozmixng.org')
   p.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
 

data/test-unit/lib/test/unit/autorunner.rb

@@ -203,6 +203,13 @@ module Test
             end
           end
 
+          o.on("--default-priority=PRIORITY",
+               Priority.available_values,
+               "Uses PRIORITY as default priority",
+               "(#{keyword_display(Priority.available_values)})") do |priority|
+            Priority.default = priority
+          end
+
           o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
                "Appends directory list to $LOAD_PATH.") do |dirs|
             $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
@@ -220,6 +227,12 @@ module Test
             load_config(file)
           end
 
+          o.on("--order=ORDER", TestCase::AVAILABLE_ORDERS,
+               "Run tests in a test case in ORDER order.",
+               "(#{keyword_display(TestCase::AVAILABLE_ORDERS)})") do |order|
+            TestCase.test_order = order
+          end
+
           ADDITIONAL_OPTIONS.each do |option_builder|
             option_builder.call(self, o)
           end
@@ -251,10 +264,20 @@ module Test
       end
 
       def keyword_display(keywords)
-        keywords.collect do |keyword, _|
+        keywords = keywords.collect do |keyword, _|
           keyword.to_s
-        end.uniq.sort.collect do |keyword|
-          keyword.sub(/^(.)([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')
+        end.uniq.sort
+
+        i = 0
+        keywords.collect do |keyword|
+          if (i > 0 and keyword[0] == keywords[i - 1][0]) or
+              ((i < keywords.size - 1) and (keyword[0] == keywords[i + 1][0]))
+            n = 2
+          else
+            n = 1
+          end
+          i += 1
+          keyword.sub(/^(.{#{n}})([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')
         end.join(", ")
       end
 

data/test-unit/lib/test/unit/priority.rb

@@ -26,6 +26,19 @@ module Test
         def disable
           @@enabled = false
         end
+
+        @@default = :normal
+        def default
+          @@default || :normal
+        end
+
+        def default=(default)
+          @@default = default
+        end
+
+        def available_values
+          Checker.available_priorities
+        end
       end
 
       class Checker
@@ -36,7 +49,7 @@ module Test
           end
 
           def need_to_run?(test)
-            priority = test[:priority] || :normal
+            priority = test[:priority] || Priority.default
             if have_priority?(priority)
               send(priority_check_method_name(priority), test)
             else
@@ -44,6 +57,13 @@ module Test
             end
           end
 
+          def available_priorities
+            methods(false).collect do |name|
+              /\Arun_priority_(.+)\?\z/ =~ name.to_s
+              $1
+            end.compact
+          end
+
           def run_priority_must?(test)
             true
           end