rroonga 5.0.0 → 5.0.1

data/test/test-exception.rb

@@ -99,6 +99,7 @@ class ExceptionTest < Test::Unit::TestCase
     assert_const_defined(Groonga, :TokenFilterError)
     assert_const_defined(Groonga, :CommandError)
     assert_const_defined(Groonga, :PluginError)
+    assert_const_defined(Groonga, :ScorerError)
   end
 end
 

data/test/test-expression-builder.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
+# Copyright (C) 2014-2015  Masafumi Yokoyama <yokoyama@clear-code.com>
 # Copyright (C) 2009-2012  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -248,6 +248,88 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     end
   end
 
+  class RegexpSearchTest < self
+    def setup_tables
+      Groonga::Schema.define do |schema|
+        schema.create_table("Users",
+                            :type => :hash,
+                            :key_type => "ShortText") do |table|
+          table.short_text("name")
+        end
+
+        schema.create_table("Terms",
+                            :type => :patricia_trie,
+                            :key_type => "ShortText",
+                            :default_tokenizer => "TokenRegexp",
+                            :normalizer => "NormalizerAuto") do |table|
+          table.index("Users.name")
+        end
+      end
+
+      @users = Groonga["Users"]
+    end
+
+    def setup_data
+      @users.add("sato",   :name => "kazuki sato")
+      @users.add("suzuki", :name => "Shiro SUZUKI")
+      @users.add("ito",    :name => "Takashi Ito")
+    end
+
+    class BlockTest < self
+      def test_match
+        result = @users.select do |record|
+          record["name"] =~ /sh/
+        end
+        assert_equal(["ito", "suzuki"],
+                     result.collect {|record| record.key.key}.sort)
+      end
+
+      def test_not_match
+        result = @users.select do |record|
+          record["name"] =~ /abcabcabc/
+        end
+        assert_equal([],
+                     result.collect {|record| record.key.key}.sort)
+      end
+
+      def test_beginning_of_text
+        result = @users.select do |record|
+          record["name"] =~ /\Ash/
+        end
+        assert_equal(["suzuki"],
+                     result.collect {|record| record.key.key}.sort)
+      end
+
+      def test_end_of_text
+        result = @users.select do |record|
+          record["name"] =~ /ki\z/
+        end
+        assert_equal(["suzuki"],
+                     result.collect {|record| record.key.key}.sort)
+      end
+    end
+
+    class QueryStringTest < self
+      def test_match
+        result = @users.select("name:~t")
+        assert_equal(["ito", "sato"],
+                     result.collect {|record| record.key.key}.sort)
+      end
+
+      def test_not_match
+        result = @users.select("name:~x")
+        assert_equal([],
+                     result.collect {|record| record.key.key}.sort)
+      end
+
+      def test_beginning_of_text
+        result = @users.select("name:~\\\\As")
+        assert_equal(["suzuki"],
+                     result.collect {|record| record.key.key}.sort)
+      end
+    end
+  end
+
   class PrefixSearchTest < self
     def setup_tables
       Groonga::Schema.define do |schema|

data/test/test-expression.rb

@@ -78,15 +78,14 @@ class ExpressionTest < Test::Unit::TestCase
     expression.compile
 
     assert_equal(<<-INSPECTED.chomp, expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:2, value:1>,
-    1:<push(), modify:0, value:1>,
-    2:<plus(), modify:0, value:(NULL)>
-  }
->>
+    0:<push n_args:1, flags:0, modify:2, value:1>,
+    1:<push n_args:1, flags:0, modify:0, value:1>,
+    2:<plus n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
     INSPECTED
   end
 
@@ -172,26 +171,24 @@ class ExpressionTest < Test::Unit::TestCase
                                   Groonga::Operator::PUSH,
                                   1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
+  }>
         INSPECTED
       end
 
       def test_name
         @expression.append_object(Groonga["TokenBigram"], "push", 1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
+  }>
         INSPECTED
       end
     end
@@ -207,67 +204,102 @@ class ExpressionTest < Test::Unit::TestCase
       def test_constant
         @expression.append_constant(29, Groonga::Operator::PUSH, 1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:29>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:29>
+  }>
         INSPECTED
       end
 
       def test_name
         @expression.append_constant(29, "push", 1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:29>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:29>
+  }>
         INSPECTED
       end
     end
   end
 
   class AppendOperatorTest < self
-    setup
-    def setup_expression
-      @expression = Groonga::Expression.new
-      @expression.append_constant(29)
-      @expression.append_constant(92)
-    end
+    class PlusTest < self
+      setup
+      def setup_expression
+        @expression = Groonga::Expression.new
+        @expression.append_constant(29)
+        @expression.append_constant(92)
+      end
+
+      def test_constant
+        @expression.append_operation(Groonga::Operator::PLUS, 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
+  vars:{
+  },
+  codes:{
+    0:<push n_args:1, flags:0, modify:2, value:29>,
+    1:<push n_args:1, flags:0, modify:0, value:92>,
+    2:<plus n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
 
-    def test_constant
-      @expression.append_operation(Groonga::Operator::PLUS, 2)
-      assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+      def test_name
+        @expression.append_operation("plus", 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:2, value:29>,
-    1:<push(), modify:0, value:92>,
-    2:<plus(), modify:0, value:(NULL)>
-  }
->>
-      INSPECTED
+    0:<push n_args:1, flags:0, modify:2, value:29>,
+    1:<push n_args:1, flags:0, modify:0, value:92>,
+    2:<plus n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
     end
 
-    def test_name
-      @expression.append_operation("plus", 2)
-      assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+    class RegexpTest < self
+      setup
+      def setup_expression
+        @expression = Groonga::Expression.new
+        @expression.append_constant("Alice")
+        @expression.append_constant(/\A[aA].*l/.source)
+      end
+
+      def test_constant
+        @expression.append_operation(Groonga::Operator::REGEXP, 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:2, value:29>,
-    1:<push(), modify:0, value:92>,
-    2:<plus(), modify:0, value:(NULL)>
-  }
->>
-      INSPECTED
+    0:<push n_args:1, flags:0, modify:2, value:"Alice">,
+    1:<push n_args:1, flags:0, modify:0, value:"\\\\A[aA].*l">,
+    2:<regexp n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
+
+      def test_name
+        @expression.append_operation("regexp", 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
+  vars:{
+  },
+  codes:{
+    0:<push n_args:1, flags:0, modify:2, value:"Alice">,
+    1:<push n_args:1, flags:0, modify:0, value:"\\\\A[aA].*l">,
+    2:<regexp n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
     end
   end
 

data/test/test-index-column.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2015  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
@@ -502,43 +502,116 @@ class IndexColumnTest < Test::Unit::TestCase
   end
 
   class EstimateSizeTest < self
-    setup
-    def setup_schema
-      Groonga::Schema.define do |schema|
-        schema.create_table("Articles") do |table|
-          table.text("content")
-        end
+    sub_test_case "token ID" do
+      setup
+      def setup_schema
+        Groonga::Schema.define do |schema|
+          schema.create_table("Articles") do |table|
+            table.text("content")
+          end
 
-        schema.create_table("Terms",
-                            :type => :hash,
-                            :key_type => "ShortText",
-                            :default_tokenizer => "TokenBigram",
-                            :normalizer => "NormalizerAuto") do |table|
-          table.index("Articles.content",
-                      :name => "articles_content",
-                      :with_position => true,
-                      :with_section => true)
+          schema.create_table("Terms",
+                              :type => :hash,
+                              :key_type => "ShortText",
+                              :default_tokenizer => "TokenBigram",
+                              :normalizer => "NormalizerAuto") do |table|
+            table.index("Articles.content",
+                        :name => "articles_content",
+                        :with_position => true,
+                        :with_section => true)
+          end
         end
+
+        @articles = Groonga["Articles"]
+        @terms = Groonga["Terms"]
+        @index = Groonga["Terms.articles_content"]
       end
 
-      @articles = Groonga["Articles"]
-      @terms = Groonga["Terms"]
-      @index = Groonga["Terms.articles_content"]
-    end
+      setup
+      def setup_data
+        @articles.add(:content => "Groonga is fast")
+        @articles.add(:content => "Rroonga is fast")
+        @articles.add(:content => "Mroonga is fast")
+      end
 
-    setup
-    def setup_data
-      @articles.add(:content => "Groonga is fast")
-      @articles.add(:content => "Rroonga is fast")
-      @articles.add(:content => "Mroonga is fast")
+      def test_id
+        assert_equal(7, @index.estimate_size(@terms["fast"].id))
+      end
+
+      def test_record
+        assert_equal(7, @index.estimate_size(@terms["fast"]))
+      end
     end
 
-    def test_id
-      assert_equal(7, @index.estimate_size(@terms["fast"].id))
+    sub_test_case "query" do
+      setup
+      def setup_schema
+        Groonga::Schema.define do |schema|
+          schema.create_table("Articles") do |table|
+            table.text("content")
+          end
+
+          schema.create_table("Terms",
+                              :type => :hash,
+                              :key_type => "ShortText",
+                              :default_tokenizer => "TokenBigramSplitSymbolAlpha",
+                              :normalizer => "NormalizerAuto") do |table|
+            table.index("Articles.content",
+                        :name => "articles_content",
+                        :with_position => true,
+                        :with_section => true)
+          end
+        end
+
+        @articles = Groonga["Articles"]
+        @index = Groonga["Terms.articles_content"]
+      end
+
+      setup
+      def setup_data
+        @articles.add(:content => "Groonga is fast")
+        @articles.add(:content => "Rroonga is fast")
+        @articles.add(:content => "Mroonga is fast")
+      end
+
+      def test_query
+        assert_equal(6, @index.estimate_size("roonga"))
+      end
     end
 
-    def test_record
-      assert_equal(7, @index.estimate_size(@terms["fast"]))
+    sub_test_case "lexicon cursor" do
+      setup
+      def setup_schema
+        Groonga::Schema.define do |schema|
+          schema.create_table("Memos") do |table|
+            table.short_text("tags", :type => :vector)
+          end
+
+          schema.create_table("Tags",
+                              :type => :patricia_trie,
+                              :key_type => "ShortText") do |table|
+            table.index("Memos.tags",
+                        :name => "memos_tags")
+          end
+        end
+
+        @memos = Groonga["Memos"]
+        @tags = Groonga["Tags"]
+        @index = Groonga["Tags.memos_tags"]
+      end
+
+      setup
+      def setup_data
+        @memos.add(:tags => ["Groonga"])
+        @memos.add(:tags => ["Rroonga", "Ruby"])
+        @memos.add(:tags => ["grndump", "Rroonga"])
+      end
+
+      def test_query
+        @tags.open_prefix_cursor("R") do |cursor|
+          assert_equal(5, @index.estimate_size(cursor))
+        end
+      end
     end
   end
 end

data/test/test-normalizer.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2015  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
@@ -20,33 +20,39 @@ class NormalizerTest < Test::Unit::TestCase
 
   setup :setup_database
 
-  def test_normalize
-    assert_equal("abc", Groonga::Normalizer.normalize("AbC"))
-  end
-
-  def test_normalize_with_space
-    assert_equal("abcdefgh", Groonga::Normalizer.normalize("AbC Def　gh"))
-  end
-
-  def test_normalize_with_space_explicitly
-    assert_equal("abcdefgh",
-                 Groonga::Normalizer.normalize("AbC Def　gh",
-                                               :remove_blank => true))
-  end
-
-  def test_normalize_group_text
-    assert_equal("キロメートルキロメートルキロメートルキロメートル",
-                 Groonga::Normalizer.normalize("㌖㌖㌖㌖"));
-  end
-
-  def test_normalize_keep_space
-    # full width space => half width space
-    assert_equal("abc def gh",
-                 Groonga::Normalizer.normalize("AbC Def　gh",
-                                               :remove_blank => false))
-  end
-
-  def test_normalize_tilda
-    assert_equal("~~~", Groonga::Normalizer.normalize("~～〜"))
+  sub_test_case(".normalize") do
+    def test_normal
+      assert_equal("abc", Groonga::Normalizer.normalize("AbC"))
+    end
+
+    def test_space
+      assert_equal("abcdefgh", Groonga::Normalizer.normalize("AbC Def　gh"))
+    end
+
+    def test_remove_blank
+      assert_equal("abcdefgh",
+                   Groonga::Normalizer.normalize("AbC Def　gh",
+                                                 :remove_blank => true))
+    end
+
+    def test_group_text
+      assert_equal("キロメートルキロメートルキロメートルキロメートル",
+                   Groonga::Normalizer.normalize("㌖㌖㌖㌖"));
+    end
+
+    def test_keep_space
+      # full width space => half width space
+      assert_equal("abc def gh",
+                   Groonga::Normalizer.normalize("AbC Def　gh",
+                                                 :remove_blank => false))
+    end
+
+    def test_tilda
+      assert_equal("~~~", Groonga::Normalizer.normalize("~～〜"))
+    end
+
+    def test_empty
+      assert_equal("", Groonga::Normalizer.normalize(""))
+    end
   end
 end