rroonga 3.0.5-x86-mingw32 → 3.0.6-x86-mingw32

data/ext/groonga/rb-groonga.c

@@ -54,17 +54,17 @@ rb_grn_init_runtime_version (VALUE mGrn)
     component_start = component_end + 1;
     component_end = strstr(component_start, "-");
     if (component_end) {
-	component_length = component_end - component_start;
+        component_length = component_end - component_start;
     } else {
-	component_length = strlen(component_start);
+        component_length = strlen(component_start);
     }
     micro = rb_str_new(component_start, component_length);
     rb_ary_push(runtime_version, rb_Integer(micro));
 
     if (component_end) {
-	tag = rb_str_new2(component_end + 1);
+        tag = rb_str_new2(component_end + 1);
     } else {
-	tag = Qnil;
+        tag = Qnil;
     }
     rb_ary_push(runtime_version, tag);
 
@@ -85,9 +85,9 @@ rb_grn_init_version (VALUE mGrn)
     rb_grn_init_runtime_version(mGrn);
 
     build_version = rb_ary_new3(3,
-				INT2NUM(GRN_MAJOR_VERSION),
-				INT2NUM(GRN_MINOR_VERSION),
-				INT2NUM(GRN_MICRO_VERSION));
+                                INT2NUM(GRN_MAJOR_VERSION),
+                                INT2NUM(GRN_MINOR_VERSION),
+                                INT2NUM(GRN_MICRO_VERSION));
     rb_obj_freeze(build_version);
     /*
      * ビルドしたgroongaのバージョン。 @[メジャーバージョン,
@@ -96,9 +96,9 @@ rb_grn_init_version (VALUE mGrn)
     rb_define_const(mGrn, "BUILD_VERSION", build_version);
 
     bindings_version = rb_ary_new3(3,
-				   INT2NUM(RB_GRN_MAJOR_VERSION),
-				   INT2NUM(RB_GRN_MINOR_VERSION),
-				   INT2NUM(RB_GRN_MICRO_VERSION));
+                                   INT2NUM(RB_GRN_MAJOR_VERSION),
+                                   INT2NUM(RB_GRN_MINOR_VERSION),
+                                   INT2NUM(RB_GRN_MICRO_VERSION));
     rb_obj_freeze(bindings_version);
     /*
      * rroongaのバージョン。 @[メジャーバージョン, マ

data/rroonga-build.rb

@@ -24,6 +24,13 @@ module RroongaBuild
     RELEASED_DATE = Time.utc(2013, 6, 29)
   end
 
+  module LatestGroongaVersion
+    MAJOR = 3
+    MINOR = 0
+    MICRO = 7
+    VERSION = [MAJOR, MINOR, MICRO]
+  end
+
   module_function
   def local_groonga_base_dir
     File.join(File.dirname(__FILE__), "vendor")

data/rroonga.gemspec

@@ -60,7 +60,7 @@ Gem::Specification.new do |s|
   s.summary, s.description, = description.split(/\n\n+/, 3)
 
   s.files = ["README.textile", "AUTHORS", "Rakefile", "Gemfile"]
-  s.files = Dir.glob("doc/text/*.textile")
+  s.files += Dir.glob("doc/text/*.textile")
   s.files += ["#{s.name}.gemspec"]
   s.files += ["rroonga-build.rb", "extconf.rb"]
   Dir.chdir(base_dir) do

data/test/test-hash.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2013  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
@@ -242,9 +242,9 @@ class HashTest < Test::Unit::TestCase
 
   def test_big_key
     hash = Groonga::Hash.create(:key_type => "UInt64")
-    assert_nothing_raised do
-      hash.add(1 << 63)
-    end
+    big_key = 1 << 63
+    record = hash.add(big_key)
+    assert_equal(big_key, record.key)
   end
 
   def test_value_by_key

data/test/test-index-column.rb

@@ -22,288 +22,302 @@ class IndexColumnTest < Test::Unit::TestCase
     setup_database
   end
 
-  def test_index?
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-    assert_predicate(content_index, :index?)
-  end
+  class PredicateTest < self
+    def setup
+      super
+      setup_index
+    end
 
-  def test_vector?
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
+    def setup_index
+      articles = Groonga::Array.create(:name => "Articles")
+      articles.define_column("content", "Text")
 
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-    assert_not_predicate(content_index, :vector?)
-  end
+      terms = Groonga::Hash.create(:name => "Terms",
+                                   :key_type => "ShortText",
+                                   :default_tokenizer => "TokenBigram")
+      @index = terms.define_index_column("content", articles,
+                                         :with_section => true)
+    end
 
-  def test_scalar?
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
+    def test_index?
+      assert_predicate(@index, :index?)
+    end
 
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-    assert_not_predicate(content_index, :scalar?)
-  end
+    def test_vector?
+      assert_not_predicate(@index, :vector?)
+    end
 
-  def test_array_set_with_record
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_section => true)
-
-    content = <<-EOC
-    groonga は組み込み型の全文検索エンジンライブラリです。
-    DBMSやスクリプト言語処理系等に組み込むことによって、その
-    全文検索機能を強化することができます。また、リレーショナ
-    ルモデルに基づくデータストア機能を内包しており、groonga
-    単体でも高速なデータストアサーバとして使用することができ
-    ます。
-
-    ■全文検索方式
-    転置索引型の全文検索エンジンです。転置索引は圧縮されてファ
-    イルに格納され、検索時のディスク読み出し量を小さく、かつ
-    局所的に抑えるように設計されています。用途に応じて以下の
-    索引タイプを選択できます。
-    EOC
-
-    groonga = articles.add(:content => content)
-
-    content.split(/\n{2,}/).each_with_index do |sentence, i|
-      content_index[groonga] = {:value => sentence, :section => i + 1}
+    def test_scalar?
+      assert_not_predicate(@index, :scalar?)
     end
-    assert_equal([groonga],
-                 content_index.search("エンジン").collect {|record| record.key})
   end
 
-  def test_add
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :key_type => "ShortText",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_position => true,
-                                              :with_section => true)
-
-    content = <<-CONTENT
-    Groonga is a fast and accurate full text search engine based on
-    inverted index. One of the characteristics of groonga is that a
-    newly registered document instantly appears in search
-    results. Also, groonga allows updates without read locks. These
-    characteristics result in superior performance on real-time
-    applications.
-
-    Groonga is also a column-oriented database management system
-    (DBMS). Compared with well-known row-oriented systems, such as
-    MySQL and PostgreSQL, column-oriented systems are more suited for
-    aggregate queries. Due to this advantage, groonga can cover
-    weakness of row-oriented systems.
-
-    The basic functions of groonga are provided in a C library. Also,
-    libraries for using groonga in other languages, such as Ruby, are
-    provided by related projects. In addition, groonga-based storage
-    engines are provided for MySQL and PostgreSQL. These libraries
-    and storage engines allow any application to use groonga. See
-    usage examples.
-    CONTENT
-
-    groonga = articles.add(:content => content)
-
-    content.split(/\n{2,}/).each_with_index do |sentence, i|
-      content_index.add(groonga, sentence, :section => i + 1)
+  class CRUDTest < self
+    setup
+    def setup_schema
+      @articles = Groonga::Array.create(:name => "Articles")
+      @articles.define_column("content", "Text")
+
+      terms = Groonga::Hash.create(:name => "Terms",
+                                   :key_type => "ShortText",
+                                   :default_tokenizer => "TokenBigram")
+      @index = terms.define_index_column("content", @articles,
+                                         :with_position => true,
+                                         :with_section => true)
     end
-    assert_equal([groonga], content_index.search("engine").collect(&:key))
-  end
 
-  def test_delete
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :key_type => "ShortText",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_position => true,
-                                              :with_section => true)
-
-    content = <<-CONTENT
-    Groonga is a fast and accurate full text search engine based on
-    inverted index. One of the characteristics of groonga is that a
-    newly registered document instantly appears in search
-    results. Also, groonga allows updates without read locks. These
-    characteristics result in superior performance on real-time
-    applications.
-
-    Groonga is also a column-oriented database management system
-    (DBMS). Compared with well-known row-oriented systems, such as
-    MySQL and PostgreSQL, column-oriented systems are more suited for
-    aggregate queries. Due to this advantage, groonga can cover
-    weakness of row-oriented systems.
-
-    The basic functions of groonga are provided in a C library. Also,
-    libraries for using groonga in other languages, such as Ruby, are
-    provided by related projects. In addition, groonga-based storage
-    engines are provided for MySQL and PostgreSQL. These libraries
-    and storage engines allow any application to use groonga. See
-    usage examples.
-    CONTENT
-
-    groonga = articles.add(:content => content)
-
-    content.split(/\n{2,}/).each_with_index do |sentence, i|
-      content_index.add(groonga, sentence, :section => i + 1)
+    def test_array_set_with_record
+      content = <<-EOC
+      groonga は組み込み型の全文検索エンジンライブラリです。
+      DBMSやスクリプト言語処理系等に組み込むことによって、その
+      全文検索機能を強化することができます。また、リレーショナ
+      ルモデルに基づくデータストア機能を内包しており、groonga
+      単体でも高速なデータストアサーバとして使用することができ
+      ます。
+
+      ■全文検索方式
+      転置索引型の全文検索エンジンです。転置索引は圧縮されてファ
+      イルに格納され、検索時のディスク読み出し量を小さく、かつ
+      局所的に抑えるように設計されています。用途に応じて以下の
+      索引タイプを選択できます。
+      EOC
+
+      groonga = @articles.add(:content => content)
+
+      content.split(/\n{2,}/).each_with_index do |sentence, i|
+        @index[groonga] = {:value => sentence, :section => i + 1}
+      end
+      assert_equal([groonga],
+                   @index.search("エンジン").collect {|record| record.key})
     end
-    content.split(/\n{2,}/).each_with_index do |sentence, i|
-      content_index.delete(groonga, sentence, :section => i + 1)
+
+    def test_add
+      content = <<-CONTENT
+      Groonga is a fast and accurate full text search engine based on
+      inverted index. One of the characteristics of groonga is that a
+      newly registered document instantly appears in search
+      results. Also, groonga allows updates without read locks. These
+      characteristics result in superior performance on real-time
+      applications.
+
+      Groonga is also a column-oriented database management system
+      (DBMS). Compared with well-known row-oriented systems, such as
+      MySQL and PostgreSQL, column-oriented systems are more suited for
+      aggregate queries. Due to this advantage, groonga can cover
+      weakness of row-oriented systems.
+
+      The basic functions of groonga are provided in a C library. Also,
+      libraries for using groonga in other languages, such as Ruby, are
+      provided by related projects. In addition, groonga-based storage
+      engines are provided for MySQL and PostgreSQL. These libraries
+      and storage engines allow any application to use groonga. See
+      usage examples.
+      CONTENT
+
+      groonga = @articles.add(:content => content)
+
+      content.split(/\n{2,}/).each_with_index do |sentence, i|
+        @index.add(groonga, sentence, :section => i + 1)
+      end
+      assert_equal([groonga], @index.search("engine").collect(&:key))
     end
-    assert_equal([], content_index.search("engine").collect(&:key))
-  end
 
-  def test_update
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :key_type => "ShortText",
-                                 :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :with_position => true,
-                                              :with_section => true)
-
-    old_sentence = <<-SENTENCE
-    Groonga is a fast and accurate full text search engine based on
-    inverted index. One of the characteristics of groonga is that a
-    newly registered document instantly appears in search
-    results. Also, groonga allows updates without read locks. These
-    characteristics result in superior performance on real-time
-    applications.
-    SENTENCE
-
-    new_sentence = <<-SENTENCE
-    Groonga is also a column-oriented database management system
-    (DBMS). Compared with well-known row-oriented systems, such as
-    MySQL and PostgreSQL, column-oriented systems are more suited for
-    aggregate queries. Due to this advantage, groonga can cover
-    weakness of row-oriented systems.
-    SENTENCE
-
-    groonga = articles.add(:content => old_sentence)
-
-    content_index.add(groonga, old_sentence, :section => 1)
-    assert_equal([groonga],
-                 content_index.search("engine").collect(&:key))
-    assert_equal([],
-                 content_index.search("MySQL").collect(&:key))
-
-    groonga[:content] = new_sentence
-    content_index.update(groonga, old_sentence, new_sentence, :section => 1)
-    assert_equal([],
-                 content_index.search("engine").collect(&:key))
-    assert_equal([groonga],
-                 content_index.search("MySQL").collect(&:key))
-  end
+    def test_delete
+      content = <<-CONTENT
+      Groonga is a fast and accurate full text search engine based on
+      inverted index. One of the characteristics of groonga is that a
+      newly registered document instantly appears in search
+      results. Also, groonga allows updates without read locks. These
+      characteristics result in superior performance on real-time
+      applications.
+
+      Groonga is also a column-oriented database management system
+      (DBMS). Compared with well-known row-oriented systems, such as
+      MySQL and PostgreSQL, column-oriented systems are more suited for
+      aggregate queries. Due to this advantage, groonga can cover
+      weakness of row-oriented systems.
+
+      The basic functions of groonga are provided in a C library. Also,
+      libraries for using groonga in other languages, such as Ruby, are
+      provided by related projects. In addition, groonga-based storage
+      engines are provided for MySQL and PostgreSQL. These libraries
+      and storage engines allow any application to use groonga. See
+      usage examples.
+      CONTENT
+
+      groonga = @articles.add(:content => content)
+
+      content.split(/\n{2,}/).each_with_index do |sentence, i|
+        @index.add(groonga, sentence, :section => i + 1)
+      end
+      content.split(/\n{2,}/).each_with_index do |sentence, i|
+        @index.delete(groonga, sentence, :section => i + 1)
+      end
+      assert_equal([], @index.search("engine").collect(&:key))
+    end
 
-  def test_shorter_query_than_ngram
-    articles = Groonga::Array.create(:name => "Articles")
-    articles.define_column("content", "Text")
-
-    terms = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :default_tokenizer => "TokenBigram")
-    content_index = terms.define_index_column("content", articles,
-                                              :source => "Articles.content")
-    articles.add(:content => 'l')
-    articles.add(:content => 'll')
-    articles.add(:content => 'hello')
-
-    assert_search(["hello"], content_index, "he")
-    assert_search(["ll", "hello"], content_index, "ll")
-    assert_search(["l", "ll", "hello"], content_index, "l")
+    def test_update
+      old_sentence = <<-SENTENCE
+      Groonga is a fast and accurate full text search engine based on
+      inverted index. One of the characteristics of groonga is that a
+      newly registered document instantly appears in search
+      results. Also, groonga allows updates without read locks. These
+      characteristics result in superior performance on real-time
+      applications.
+      SENTENCE
+
+      new_sentence = <<-SENTENCE
+      Groonga is also a column-oriented database management system
+      (DBMS). Compared with well-known row-oriented systems, such as
+      MySQL and PostgreSQL, column-oriented systems are more suited for
+      aggregate queries. Due to this advantage, groonga can cover
+      weakness of row-oriented systems.
+      SENTENCE
+
+      groonga = @articles.add(:content => old_sentence)
+
+      @index.add(groonga, old_sentence, :section => 1)
+      assert_equal([groonga],
+                   @index.search("engine").collect(&:key))
+      assert_equal([],
+                   @index.search("MySQL").collect(&:key))
+
+      groonga[:content] = new_sentence
+      @index.update(groonga, old_sentence, new_sentence, :section => 1)
+      assert_equal([],
+                   @index.search("engine").collect(&:key))
+      assert_equal([groonga],
+                   @index.search("MySQL").collect(&:key))
+    end
   end
 
-  def test_with_section?
-    define_index_column_with_flags
-    assert_equal({
-                   :section => true,
-                   :weight => false,
-                   :position => false,
-                 },
-                 {
-                   :section => context["Tags.section"].with_section?,
-                   :weight => context["Tags.weight"].with_section?,
-                   :position => context["Tags.position"].with_section?,
-                 })
-  end
+  class NGramTest < self
+    setup
+    def setup_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("Articles") do |table|
+          table.text("content")
+        end
+
+        schema.create_table("Terms",
+                            :type => :patricia_trie,
+                            :key_type => "ShortText",
+                            :default_tokenizer => "TokenBigram") do |table|
+          table.index("Articles.content", :name => "content")
+        end
+      end
 
-  def test_with_weight?
-    define_index_column_with_flags
-    assert_equal({
-                   :section => false,
-                   :weight => true,
-                   :position => false,
-                 },
-                 {
-                   :section => context["Tags.section"].with_weight?,
-                   :weight => context["Tags.weight"].with_weight?,
-                   :position => context["Tags.position"].with_weight?,
-                 })
-  end
+      @articles = Groonga["Articles"]
+      @index = Groonga["Terms.content"]
+    end
 
-  def test_with_position?
-    define_index_column_with_flags
-    assert_equal({
-                   :section => false,
-                   :weight => false,
-                   :position => true,
-                 },
-                 {
-                   :section => context["Tags.section"].with_position?,
-                   :weight => context["Tags.weight"].with_position?,
-                   :position => context["Tags.position"].with_position?,
-                 })
-  end
+    setup
+    def setup_records
+      @articles.add(:content => 'l')
+      @articles.add(:content => 'll')
+      @articles.add(:content => 'hello')
+    end
+
+    def test_N_length_query
+      assert_equal(["ll", "hello"], search("ll"))
+    end
 
-  private
-  def assert_search(expected, content_index, keyword)
-    result = content_index.search(keyword).collect do |entry|
-      entry.key["content"]
+    def test_shorter_query
+      assert_equal(["l", "ll", "hello"], search("l"))
+    end
+
+    private
+    def search(keyword)
+      @index.search(keyword).collect do |entry|
+        entry.key["content"]
+      end
     end
-    assert_equal(expected, result)
   end
 
-  def define_index_column_with_flags
-    Groonga::Schema.define do |schema|
-      schema.create_table("Articles") do |table|
-        table.text("tags", :type => :vector)
+  class FlagTest < self
+    def setup
+      super
+      define_table
+    end
+
+    def define_table
+      Groonga::Schema.define do |schema|
+        schema.create_table("Articles") do |table|
+          table.text("tags", :type => :vector)
+        end
       end
+    end
+
+    def test_with_section?
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            :type => :patricia_trie,
+                            :key_type => "ShortText",
+                            :default_tokenizer => "TokenDelimit") do |table|
+          table.index("Articles.tags",
+                      :name => "section",
+                      :with_section => true)
+          table.index("Articles.tags",
+                      :name => "no_section")
+        end
+      end
+
+      assert_equal([
+                     true,
+                     false,
+                   ],
+                   [
+                     context["Tags.section"].with_section?,
+                     context["Tags.no_section"].with_section?,
+                   ])
+    end
 
-      schema.create_table("Tags",
-                          :type => :patricia_trie,
-                          :key_type => "ShortText",
-                          :default_tokenizer => "TokenDelimit") do |table|
-        table.index("Articles.tags",
-                    :name => "section",
-                    :with_section => true)
-        table.index("Articles.tags",
-                    :name => "weight",
-                    :with_weight => true)
-        table.index("Articles.tags",
-                    :name => "position",
-                    :with_position => true)
+    def test_with_weight?
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            :type => :patricia_trie,
+                            :key_type => "ShortText",
+                            :default_tokenizer => "TokenDelimit") do |table|
+          table.index("Articles.tags",
+                      :name => "weight",
+                      :with_weight => true)
+          table.index("Articles.tags",
+                      :name => "no_weight")
+        end
       end
+
+      assert_equal([
+                     true,
+                     false,
+                   ],
+                   [
+                     context["Tags.weight"].with_weight?,
+                     context["Tags.no_weight"].with_weight?,
+                   ])
+    end
+
+    def test_with_position?
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            :type => :patricia_trie,
+                            :key_type => "ShortText",
+                            :default_tokenizer => "TokenDelimit") do |table|
+          table.index("Articles.tags",
+                      :name => "position",
+                      :with_position => true)
+          table.index("Articles.tags",
+                      :name => "no_position")
+        end
+      end
+
+      assert_equal([
+                     true,
+                     false,
+                   ],
+                   [
+                     context["Tags.position"].with_position?,
+                     context["Tags.no_position"].with_position?,
+                   ])
     end
   end
 end