RubyGems - rroonga - Versions diffs - 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32 - Mend

rroonga 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (398) hide show

data/test/test-column.rb DELETED Viewed

@@ -1,350 +0,0 @@
-# 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
-# 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 ColumnTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  def setup
-    setup_database
-    setup_users_table
-    setup_bookmarks_table
-    setup_indexes
-  end
-  def setup_users_table
-    @users_path = @tables_dir + "users"
-    @users = Groonga::Array.create(:name => "Users",
-                                   :path => @users_path.to_s)
-    @users_name_column_path = @columns_dir + "name"
-    @users_name_column =
-      @users.define_column("name", "ShortText",
-                           :path => @users_name_column_path.to_s)
-  end
-  def setup_bookmarks_table
-    @bookmarks_path = @tables_dir + "bookmarks"
-    @bookmarks = Groonga::Array.create(:name => "Bookmarks",
-                                       :path => @bookmarks_path.to_s)
-    @uri_column_path = @columns_dir + "uri"
-    @bookmarks_uri = @bookmarks.define_column("uri", "ShortText",
-                                              :path => @uri_column_path.to_s)
-    @comment_column_path = @columns_dir + "comment"
-    @bookmarks_comment =
-      @bookmarks.define_column("comment", "Text",
-                               :path => @comment_column_path.to_s)
-    @content_column_path = @columns_dir + "content"
-    @bookmarks_content = @bookmarks.define_column("content", "LongText")
-    @user_column_path = @columns_dir + "user"
-    @bookmarks_user = @bookmarks.define_column("user", @users)
-  end
-  def setup_indexes
-    @bookmarks_index_path = @tables_dir + "bookmarks-index"
-    @bookmarks_index =
-      Groonga::PatriciaTrie.create(:name => "BookmarksIndex",
-                                   :path => @bookmarks_index_path.to_s,
-                                   :key_type => "ShortText")
-    @bookmarks_index.default_tokenizer = "TokenBigram"
-    @content_index_column_path = @columns_dir + "content-index"
-    @bookmarks_index_content =
-      @bookmarks_index.define_index_column("content", @bookmarks,
-                                           :with_section => true,
-                                           :with_weight => true,
-                                           :with_position => true,
-                                           :path => @content_index_column_path.to_s)
-    @uri_index_column_path = @columns_dir + "uri-index"
-    @bookmarks_index_uri =
-      @bookmarks_index.define_index_column("uri", @bookmarks,
-                                           :path => @uri_index_column_path.to_s)
-  end
-  def test_source_info
-    @bookmarks_index_content.sources = [@bookmarks_content]
-    groonga = @bookmarks.add
-    groonga["content"] = "<html><body>groonga</body></html>"
-    ruby = @bookmarks.add
-    ruby["content"] = "<html><body>ruby</body></html>"
-    assert_content_search([groonga], "groonga")
-    assert_content_search([groonga, ruby], "html")
-    assert_equal([@bookmarks_content], @bookmarks_index_content.sources)
-  end
-  def test_update_index_column
-    groonga = @bookmarks.add
-    groonga["content"] = "<html><body>groonga</body></html>"
-    ruby = @bookmarks.add
-    ruby["content"] = "<html><body>ruby</body></html>"
-    @bookmarks_index_content[groonga.id] = groonga["content"]
-    @bookmarks_index_content[ruby.id] = ruby["content"]
-    assert_content_search([groonga], "groonga")
-    assert_content_search([groonga, ruby], "html")
-  end
-  def test_range
-    assert_equal(context[Groonga::Type::SHORT_TEXT], @bookmarks_uri.range)
-    assert_equal(context[Groonga::Type::TEXT], @bookmarks_comment.range)
-    assert_equal(context[Groonga::Type::LONG_TEXT], @bookmarks_content.range)
-    assert_equal(@users, @bookmarks_user.range)
-    assert_equal(@bookmarks, @bookmarks_index_content.range)
-    assert_equal(@bookmarks, @bookmarks_index_uri.range)
-  end
-  def test_accessor
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("body", "Text")
-    comments = Groonga::Hash.create(:name => "Comments",
-                                    :key_type => "ShortText")
-    content = comments.define_column("content", "ShortText")
-    comments.define_column("post", posts)
-    index = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :key_type => "ShortText")
-    index.default_tokenizer = "TokenBigram"
-    content_index = index.define_index_column("content_index", comments,
-                                              :with_position => true)
-    content_index.source = content
-    first_post = posts.add("Hello!")
-    first_post["body"] = "World"
-    hobby = posts.add("My Hobby")
-    hobby["body"] = "Drive and Eat"
-    friend = comments.add("Me too")
-    friend["content"] = "I'm also like drive"
-    friend["post"] = hobby
-    result = content_index.search("drive")
-    assert_equal([["I'm also like drive", "My Hobby"]],
-                 result.records.collect do |record|
-                   [record[".content"], record[".post._key"]]
-                 end)
-  end
-  def test_accessor_reference
-    bookmark = @bookmarks.add
-    assert_nil(@bookmarks_user[bookmark.id])
-    daijiro = @users.add
-    daijiro["name"] = "daijiro"
-    @bookmarks_user[bookmark.id] = daijiro
-    assert_equal(daijiro, @bookmarks_user[bookmark.id])
-  end
-  def test_array_set_with_key_of_table
-    languages = Groonga::Hash.create(:name => "Languages",
-                                     :key_type => "ShortText")
-    sites = Groonga::Hash.create(:name => "Sites")
-    sites.define_column("language", languages)
-    languages.add("Ruby")
-    taiyaki_ru = sites.add("http://taiyaki.ru/", :language => "Ruby")
-    assert_equal("Ruby", taiyaki_ru[:language].key)
-  end
-  def test_local_name
-    items = Groonga::Array.create(:name => "Items")
-    title = items.define_column("title", "ShortText")
-    assert_equal("Items.title", title.name)
-    assert_equal("title", title.local_name)
-  end
-  def test_select_query
-    populate_table_for_select
-    result = @body.select("drive")
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_select_query_from_ctx
-    populate_table_for_select
-    body = Groonga::Context.default['Posts.body']
-    # select twice.
-    result = body.select("drive")
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    result = body.select("drive")
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-  end
-  def test_select_query_with_parser
-    populate_table_for_select
-    result = @body.select("body @ \"drive\"", :syntax => :script)
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_select_expression
-    populate_table_for_select
-    expression = Groonga::Expression.new
-    variable = expression.define_variable(:domain => @posts)
-    expression.append_object(variable)
-    expression.parse("body:@drive", :syntax => :query)
-    expression.compile
-    result = @body.select(expression)
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{0\"\",2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_select_with_block
-    populate_table_for_select
-    result = @body.select do |column|
-      column =~ "drive"
-    end
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{1\"\",2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_set_time
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("issued", "Time")
-    post = posts.add("hello", :issued => 123456)
-    assert_equal(Time.at(123456), post[".issued"])
-    post = posts.add("groonga", :issued => 1251380635)
-    assert_equal(Time.parse("2009-08-27 22:43:55"), post[".issued"])
-    post = posts.add("mroonga", :issued => 1251380635.1234567)
-    assert_in_delta(Time.at(1251380635.1234567).usec, post[".issued"].usec, 10)
-  end
-  def test_set_nil_to_time
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("issued", "Time")
-    post = posts.add("hello", :issued => nil)
-    assert_equal(Time.at(0), post["issued"])
-  end
-  def test_bool
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("hidden", "Bool")
-    post = posts.add("hello")
-    assert_false(post["hidden"])
-    post["hidden"] = true
-    assert_true(post["hidden"])
-    post["hidden"] = false
-    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
-  def test_builtin?
-    assert_not_predicate(@users_name_column, :builtin?)
-  end
-  private
-  def assert_content_search(expected_records, term)
-    records = @bookmarks_index_content.search(term).records
-    expected_contents = expected_records.collect do |record|
-      record["content"]
-    end
-    actual_contents = records.collect do |record|
-      record.key["content"]
-    end
-    assert_equal(expected_contents, actual_contents)
-  end
-  def populate_table_for_select
-    @posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    @body = @posts.define_column("body", "Text")
-    index = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :key_type => "ShortText",
-                                         :key_normalize => true)
-    index.default_tokenizer = "TokenBigram"
-    index.define_index_column("body_index", @posts,
-                              :with_position => true,
-                              :source => @body)
-    @posts.add("Hello!", :body => "World")
-    @posts.add("My Hobby", :body => "Drive and Eat")
-  end
-end

data/test/test-command-select.rb DELETED Viewed

@@ -1,147 +0,0 @@
-# Copyright (C) 2010-2012  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 CommandSelectTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  setup :setup_database
-  setup
-  def setup_data
-    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([4,
-                  [{"_id" => 1, "_key" => "morita",
-                     "book" => "the groonga book"},
-                   {"_id" => 2, "_key" => "gunyara-kun",
-                     "book" => "the groonga book"},
-                   {"_id" => 3, "_key" => "yu",
-                     "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([4,
-                  [{"_key" => "morita"},
-                   {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"},
-                   {"_key" => "ryoqun"}]],
-                 [result.n_hits, result.records])
-  end
-  def test_drill_down
-    result = context.select(@users,
-                            :output_columns => ["_key"],
-                            :drill_down => ["_key", "book"],
-                            :drill_down_output_columns => "_key",
-                            :drill_down_limit => 10)
-    drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([4,
-                  [{"_key" => "morita"},
-                   {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"},
-                   {"_key" => "ryoqun"}],
-                  {
-                    "_key" => [4, [{"_key" => "morita"},
-                                   {"_key" => "gunyara-kun"},
-                                   {"_key" => "yu"},
-                                   {"_key" => "ryoqun"}]],
-                    "book" => [2, [{"_key" => "the groonga book"},
-                                   {"_key" => "the groonga book (2)"}]],
-                  },
-                 ],
-                 [result.n_hits, result.records, drill_down])
-  end
-  def test_drill_down_with_no_hit
-    result = context.select(@users,
-                            :filter => "_key == \"no\\ hit\"",
-                            :output_columns => ["_key"],
-                            :drill_down => ["_key", "book"],
-                            :drill_down_output_columns => "_key",
-                            :drill_down_limit => 10)
-    drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([0, [],
-                  {
-                    "_key" => [0, []],
-                    "book" => [0, []],
-                  },
-                 ],
-                 [result.n_hits, result.records, drill_down])
-  end
-  def test_time
-    result = context.select(@books)
-    assert_equal([{
-                    "_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
-    assert_raise(Groonga::SyntaxError) do
-      context.select(@books, :query => "<")
-    end
-  end
-  private
-  def normalize_drill_down(drill_down)
-    normalized_drill_down = {}
-    drill_down.each do |key, drill|
-      normalized_drill_down[key] = [drill.n_hits, drill.records]
-    end
-    normalized_drill_down
-  end
-end

data/test/test-context.rb DELETED Viewed

@@ -1,130 +0,0 @@
-# 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
-# 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 ContextTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  def test_default
-    context = Groonga::Context.default
-    assert_equal(Groonga::Encoding.default, context.encoding)
-  end
-  def test_default_options
-    Groonga::Context.default_options = {
-      :encoding => :utf8,
-    }
-    context = Groonga::Context.default
-    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)
-    context = Groonga::Context.new(:encoding => :utf8)
-    assert_equal(Groonga::Encoding::UTF8, context.encoding)
-  end
-  def test_inspect
-    context = Groonga::Context.new(:encoding => Groonga::Encoding::UTF8)
-    assert_equal("#<Groonga::Context " +
-                 "encoding: <:utf8>, " +
-                 "database: <nil>>",
-                 context.inspect)
-  end
-  def test_inspect_with_database
-    db = Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("#<Groonga::Context " +
-                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
-                 "database: <#{db.inspect}>>",
-                 context.inspect)
-  end
-  def test_array_reference_by_string
-    Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("Int32", context["<int>"].name)
-  end
-  def test_array_reference_by_symbol
-    Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("Bool", context[:Bool].name)
-  end
-  def test_shortcut_access
-    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
-  def test_match_escalation_threshold
-    assert_equal(0, context.match_escalation_threshold)
-    context.match_escalation_threshold = -1
-    assert_equal(-1, context.match_escalation_threshold)
-  end
-  def test_close
-    context = Groonga::Context.new
-    assert_false(context.closed?)
-    context.close
-    assert_true(context.closed?)
-  end
-end