tx 0.0.5

data/lib/tx.rb

@@ -0,0 +1,219 @@
+require "tx_core"
+require "forwardable"
+
+
+module Tx  #:nodoc: all
+    
+    module Util
+        
+      module_function
+        
+        # Defines wrapper methods which perform boundary checking of pos and len.
+        def def_wrapper_methods(*methods)
+          methods.each() do |name|
+            define_method(name) do |*args|
+              (str, pos, len, *opt) = args
+              raise(ArgumentError, "argument pos is negative") if pos && pos < 0
+              str_len = bytesize(str)
+              pos ||= 0
+              pos = str_len if pos > str_len
+              len = str_len - pos if !len || len < 0 || len > str_len - pos
+              add_encoding(@unsafe.__send__(name, str, pos, len, *opt))
+            end
+          end
+        end
+        
+        if RUBY_VERSION >= "1.9.0"
+          
+          def default_encoding
+            return Encoding.default_internal || Encoding::UTF_8
+          end
+          
+          def add_encoding(obj)
+            case obj
+              when Array
+                obj.each(){ |e| add_encoding(e) }
+              when String
+                obj.force_encoding(@encoding)
+            end
+            return obj
+          end
+          
+          def to_binary(str)
+            return str.dup().force_encoding(Encoding::ASCII_8BIT)
+          end
+          
+          def bytesize(str)
+            return str.bytesize
+          end
+          
+        else
+          
+          def default_encoding
+            return nil
+          end
+          
+          def add_encoding(obj)
+            return obj
+          end
+          
+          def to_binary(str)
+            return str
+          end
+          
+          def bytesize(str)
+            return str.length
+          end
+          
+        end
+        
+    end
+    
+    # Wrapper of UnsafeIndex. Boundary checking of pos/len and some methods are added.
+    class Index
+        
+        extend(Forwardable)
+        extend(Util)
+        include(Util)
+        include(Enumerable)
+        
+        class << self
+          alias open new
+        end
+        
+        def initialize(arg, encoding = nil)
+          if arg.is_a?(UnsafeIndex)
+            @unsafe = arg
+          else
+            @unsafe = UnsafeIndex.new()
+            if !@unsafe.open(arg)
+              raise(IOError, "failed to open #{arg}")
+            end
+          end
+          @encoding = encoding || default_encoding()
+        end
+        
+        attr_reader(:encoding)
+        def_delegators(:@unsafe, :num_keys, :result_log, :error_log)
+        def_wrapper_methods(:longest_prefix, :include, :search_prefixes, :search_expansions)
+        alias common_prefix_search search_prefixes
+        alias predictive_search search_expansions
+        alias include? include
+        alias size num_keys
+        
+        def inspect()
+          return "\#<%p:0x%x>" % [self.class, self.object_id]
+        end
+        
+        def to_a()
+          return search_expansions("")
+        end
+        
+        def each(&block)
+          to_a().each(&block)
+        end
+        
+        def scan(str, &block)
+          bstr = to_binary(str)
+          result = []
+          pos = 0
+          while pos < bytesize(str)
+            plen = longest_prefix(str, pos)
+            if plen >= 0
+              args = [add_encoding(bstr[pos, plen]), pos]
+              block ? yield(*args) : result.push(args)
+            end
+            pos += plen > 0 ? plen : 1
+          end
+          return block ? str : result
+        end
+        
+        def gsub(str, &block)
+          bstr = to_binary(str)
+          result = add_encoding("")
+          prev_pos = 0
+          scan(str) do |match, pos|
+            result << add_encoding(bstr[prev_pos...pos])
+            result << yield(match, pos)
+            prev_pos = pos + bytesize(match)
+          end
+          result << add_encoding(bstr[prev_pos..-1])
+          return result
+        end
+        
+    end
+    
+    # Wrapper of UnsafeMap. Boundary checking of pos/len and some methods are added.
+    class Map
+        
+        extend(Forwardable)
+        extend(Util)
+        include(Util)
+        include(Enumerable)
+        
+        class << self
+          alias open new
+        end
+        
+        def initialize(file_pefix, encoding = nil)
+          @unsafe = UnsafeMap.new()
+          if !@unsafe.open(file_pefix)
+            raise(IOError, "failed to open #{file_pefix}.key, #{file_pefix}.val or #{file_pefix}.map")
+          end
+          @encoding = encoding || default_encoding()
+          @key_index = Index.new(@unsafe.key_index, @encoding)
+          @value_index = Index.new(@unsafe.value_index, @encoding)
+        end
+        
+        attr_reader(:key_index, :value_index, :encoding)
+        def_wrapper_methods(:has_key, :lookup)
+        alias has_key? has_key
+        
+        def inspect()
+          return "\#<%p:0x%x>" % [self.class, self.object_id]
+        end
+        
+        def [](str, pos = 0, len = -1)
+          return has_key(str, pos, len) ? lookup(str, pos, len) : nil
+        end
+        
+        def size
+          return self.keys.sizse
+        end
+        
+        def keys
+          return @key_index.search_expansions("")
+        end
+        
+        def values
+          return self.keys.map(){ |k| lookup(k) }
+        end
+        
+        def each_key(&block)
+          return self.keys.each(&block)
+        end
+        
+        def each_value(&block)
+          return self.values.each(&block)
+        end
+        
+        def each(&block)
+          each_key(){ |k| yield([k, lookup(k)]) }
+        end
+        
+        def each_pair(&block)
+          each_key(){ |k| yield(k, lookup(k)) }
+        end
+        
+        def scan(str, &block)
+          result = []
+          @key_index.scan(str) do |key, pos|
+            args = [key, pos, lookup(key)]
+            block ? yield(*args) : result.push(args)
+          end
+          return block ? str : result
+        end
+        
+    end
+    
+end

data/test/test_tx.rb

@@ -0,0 +1,169 @@
+# -*- encoding: UTF-8 -*-
+
+$KCODE = "u"
+$LOAD_PATH.unshift("./lib", "./ext")
+require "test/unit"
+require "enumerator"
+require "tempfile"
+require "tx"
+
+TEST_ENCODING = RUBY_VERSION >= "1.9.0" ? Encoding::UTF_8 : nil
+
+class TC_TxIndex < Test::Unit::TestCase
+    
+    def setup
+      @builder = Tx::Builder.new()
+      @builder.add_all(%w(foo ho hog hoga hoge hogeshi))
+      @tempfile = Tempfile.new("tx_test")
+      @builder.build(@tempfile.path)
+      @index = Tx::Index.open(@tempfile.path, TEST_ENCODING)
+    end
+
+    def test_basic
+      assert_equal(6, @index.num_keys)
+      assert_equal(4, @index.longest_prefix("hogeshaa"))
+      assert_equal(6, @index.longest_prefix("hogeshaa", 0, -1, true))
+      assert(@index.include("hoge"))
+      assert(!@index.include("hogera"))
+      assert_equal(%w(ho hog), @index.search_prefixes("hog"))
+      assert_equal(%w(ho hog), @index.search_prefixes("aahog", 2, 5))
+      assert_equal(%w(hog hoga hoge hogeshi), @index.search_expansions("hog").sort())
+      assert_equal(%w(hog hoga hoge hogeshi), @index.search_expansions("aahogeshi", 2, 3).sort())
+      assert_equal(%w(foo ho hog hoga hoge hogeshi), @index.to_a().sort())
+      assert_equal(%w(foo ho hog hoga hoge hogeshi), @index.enum_for(:each).to_a().sort())
+    end
+    
+    def test_scan
+      str = "hohogefugahogaboke"
+      expected = [["ho", 0], ["hoge", 2], ["hoga", 10]]
+      assert_equal(expected, @index.scan(str))
+      result = []
+      @index.scan(str) do |s, i|
+        result.push([s, i])
+      end
+      assert_equal(expected, result)
+    end
+    
+    def test_gsub
+      result = @index.gsub("hohogefugahogaboke"){ |s, i| s.upcase }
+      assert_equal("HOHOGEfugaHOGAboke", result)
+    end
+    
+    def test_open
+      assert_raise(IOError) do
+        Tx::Index.new("noexist.index")
+      end
+    end
+    
+    def test_no_error_log
+      assert_equal("", @builder.error_log)
+      assert_equal("", @index.error_log)
+    end
+    
+end
+
+class TC_TxIndexMultiByte < Test::Unit::TestCase
+    
+    def setup
+      @builder = Tx::Builder.new()
+      @builder.add_all(%w(ふー ほ ほが ほげ ほげし))
+      @tempfile = Tempfile.new("tx_test")
+      @builder.build(@tempfile.path)
+      @index = Tx::Index.open(@tempfile.path, TEST_ENCODING)
+    end
+    
+    def test_encoding
+      if RUBY_VERSION >= "1.9.0"
+        assert_equal(TEST_ENCODING, @index.search_prefixes("ほが")[0].encoding)
+        assert_equal(TEST_ENCODING, @index.search_expansions("ほが")[0].encoding)
+        assert_equal(TEST_ENCODING, @index.to_a()[0].encoding)
+      end
+    end
+    
+    def test_scan
+      str = "ほほげふがほがぼけ"
+      expected = [["ほ", 0], ["ほげ", 3], ["ほが", 15]]
+      assert_equal(expected, @index.scan(str))
+      result = []
+      @index.scan(str) do |s, i|
+        result.push([s, i])
+      end
+      assert_equal(expected, result)
+    end
+    
+    def test_gsub
+      result = @index.gsub("ほほげふがほがぼけ") do |s, i|
+        s.gsub(/ほ/, "ホ").gsub(/が/, "ガ").gsub(/げ/, "ゲ")
+      end
+      assert_equal("ホホゲふがホガぼけ", result)
+    end
+    
+end
+
+class TC_TxMap < Test::Unit::TestCase
+    
+    def setup
+      @builder = Tx::MapBuilder.new()
+      @builder.add("ho", "foo")
+      @builder.add_all(["hoge", "bar", "hogeshi", "foobar"])
+      @tempfile = Tempfile.new("tx_test")
+      @builder.build(@tempfile.path)
+      @map = Tx::Map.open(@tempfile.path, TEST_ENCODING)
+    end
+
+    def test_basic
+      assert(@map.has_key("hoge"))
+      assert_equal("bar", @map.lookup("hoge"))
+      assert_equal("bar", @map["hoge"])
+      assert(!@map.has_key("foo"))
+      assert_equal("", @map.lookup("foo"))
+      assert_equal(nil, @map["foo"])
+      assert(@map.key_index.include("hoge"))
+      assert(@map.value_index.include("foo"))
+      assert_equal(%w(ho hoge hogeshi), @map.keys.sort())
+      assert_equal(%w(bar foo foobar), @map.values.sort())
+      assert_equal(%w(ho hoge hogeshi), @map.enum_for(:each_key).sort())
+      assert_equal(%w(bar foo foobar), @map.enum_for(:each_value).sort())
+      assert_equal(
+        [["ho", "foo"], ["hoge", "bar"], ["hogeshi", "foobar"]],
+        @map.enum_for(:each).sort())
+      assert_equal(
+        [["ho", "foo"], ["hoge", "bar"], ["hogeshi", "foobar"]],
+        @map.enum_for(:each_pair).sort())
+    end
+    
+    def test_scan
+      str = "hogehogahoyo"
+      expected = [["hoge", 0, "bar"], ["ho", 4, "foo"], ["ho", 8, "foo"]]
+      assert_equal(expected, @map.scan(str))
+      result = []
+      @map.scan(str) do |k, i, v|
+        result.push([k, i, v])
+      end
+      assert_equal(expected, result)
+    end
+    
+end
+
+class TC_TxMapMultiByte < Test::Unit::TestCase
+    
+    def setup
+      @builder = Tx::MapBuilder.new()
+      @builder.add("ほ", "ふー")
+      @builder.add_all(["ほげ", "ばー", "ほげし", "ふーばー"])
+      @tempfile = Tempfile.new("tx_test")
+      @builder.build(@tempfile.path)
+      @map = Tx::Map.open(@tempfile.path, TEST_ENCODING)
+    end
+
+    def test_encoding
+      if RUBY_VERSION >= "1.9.0"
+        assert_equal(TEST_ENCODING, @map.lookup("ほげ").encoding)
+        assert_equal(TEST_ENCODING, @map.key_index.encoding)
+        assert_equal(TEST_ENCODING, @map.value_index.encoding)
+        assert_equal(TEST_ENCODING, @map.keys[0].encoding)
+        assert_equal(TEST_ENCODING, @map.values[0].encoding)
+      end
+    end
+    
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: tx
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Hiroshi Ichikawa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-19 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: Ruby 1.8/1.9 binding of Tx, a library for a compact trie data structure
+email: gimite+txruby@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.txt
+files: 
+- README.txt
+- lib/tx.rb
+- lib/i386-msvcrt/tx_core.so
+- ext/depend
+- ext/tx_swig.h
+- ext/tx.cpp
+- ext/tx_swig.i
+- ext/swig.patch
+- ext/Makefile
+- ext/tx_swig_wrap.cxx
+- ext/tx.hpp
+- ext/tx_swig.cpp
+- ext/extconf.rb
+- ext/ssv.cpp
+- ext/ssv.hpp
+- test/test_tx.rb
+has_rdoc: true
+homepage: http://gimite.net/en/index.php?tx-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- tx-ruby Reference
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby 1.8/1.9 binding of Tx, a library for a compact trie data structure
+test_files: []
+