rbbt-util 5.43.0 → 5.44.0

data/test/rbbt/tsv/test_index.rb

@@ -1,308 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/tsv'
-require 'rbbt/tsv/index'
-
-class TestTSVManipulate < Test::Unit::TestCase
-
-  def load_segment_data(data)
-    tsv = TSV.open(data, :list, :sep=>":", :cast => proc{|e| e =~ /(\s*)(_*)/; ($1.length..($1.length + $2.length - 1))})
-
-    tsv.add_field "Start" do |key, values|
-      values["Range"].first
-    end
-
-    tsv.add_field "End" do |key, values|
-      values["Range"].last
-    end
-
-    tsv = tsv.slice ["Start", "End"]
- 
-    tsv
-  end
-
-  def test_index
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/, :key_field => "OtherID", :persistence => false)
-      index = tsv.index(:persistence => true)
-      assert index["row1"].include? "Id1"
-      assert_equal "OtherID", index.fields.first
-    end
-
-  end
-
-  def test_index_fields_key
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/, :key_field => "OtherID", :persistence => false)
-      index = tsv.index(:persistence => false, :fields => ["Id"], :target => "ValueA")
-      assert_equal "A", index["row2"] 
-    end
-
-  end
-
-  def test_best_index
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b|A    Id1
-row2    A    a|B    Id3
-row3    A    a|B    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/, :key_field => "OtherID")
-      index = tsv.index(:order => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-      
-      index = tsv.index(:order => false)
-      assert_equal "Id1", index['a']
-    end
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/, :key_field => "OtherID")
-      index = tsv.index
-      assert index["row1"].include? "Id1"
-      assert_equal "OtherID", index.fields.first
-    end
-  end
-
-
-  def test_index_from_persit
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b|A    Id1
-row2    A    a|B    Id3
-row3    A    a|B    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(Open.open(filename), :sep => /\s+/, :key_field => "OtherID", :persist => true)
-      index = tsv.index(:order => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-    end
-  end
-
-  def test_index_to_persist
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b|A    Id1
-row2    A    a|B    Id3
-row3    A    a|B    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(Open.open(filename), :sep => /\s+/, :key_field => "OtherID", :persist => true)
-
-      index = tsv.index(:order => true, :persist => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-      assert_equal "Id1", index['a']
-
-      index = tsv.index(:order => true, :persist => false)
-      assert_equal "Id1", index['a']
-
-      tsv.delete "Id1"
-
-      index = tsv.index(:order => true, :persist => false)
-      assert_equal "Id3", index['a']
-
-      index = tsv.index(:order => true, :persist => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-      assert_equal "Id1", index['a']
-
-    end
-  end
-
-  def test_index_static
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b|B    Id1
-row2    A    bb    Id3
-row3    AA    bb    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      index = TSV.index(filename, :target => "OtherID", :data_sep => /\s+/, :order => true, :persist => true, :data_persist => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-    end
-  end
-
-  def test_index_static_persist
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b|A    Id1
-row2    A    a|B    Id3
-row3    A    a|B    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      index = TSV.index(filename, :target => "OtherID", :data_sep => /\s+/, :order => true, :persist => false)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-
-      index = TSV.index(filename, :target => "OtherID", :data_sep => /\s+/, :order => true, :persist => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-
-      Open.write(filename, Open.read(filename).sub(/row1.*Id1\n/,''))
-
-      index = TSV.index(filename, :target => "OtherID", :data_sep => /\s+/, :order => true, :persist => true)
-      assert_equal "Id1", index['a']
-      assert_equal "Id3", index['A']
-      assert_equal "OtherID", index.fields.first
-      assert index.include?('aaa')
-
-      index = TSV.index(filename, :target => "OtherID", :data_sep => /\s+/, :order => true, :persist => false)
-      assert ! index.include?('aaa')
-    end
-  end
-
-  def test_pos_index
-    content =<<-EOF
-#Id	ValueA    ValueB    Pos
-row1    a|aa|aaa    b    0|10
-row2    A    B    30
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :double, :sep => /\s+/)
-      index = tsv.pos_index("Pos")
-      assert_equal ["row1"], index[10]
-    end
-  end
-
-  def test_range_index
-    content =<<-EOF
-#Id	ValueA    ValueB    Pos1    Pos2
-row1    a|aa|aaa    b    0|10    10|30
-row2    A    B    30   35
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :double, :sep => /\s+/)
-      index = tsv.pos_index("Pos1")
-      assert_equal ["row1"], index[10]
-
-      index = tsv.range_index("Pos1", "Pos2")
-      assert_equal ["row1"], index[20]
-    end
-  end
-
-  def test_range_index2
-    data =<<-EOF
-# 012345678901234567890
-#ID:Range
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      tsv = load_segment_data(datafile)
-      f   = tsv.range_index("Start", "End", :persist => true)
-
-      assert_equal %w(), f[0].sort
-      assert_equal %w(b), f[1].sort
-      assert_equal %w(), f[20].sort
-      assert_equal %w(), f[(20..100)].sort
-      assert_equal %w(a b d), f[3].sort
-      assert_equal %w(a b c d e), f[(3..4)].sort
-    end
-  end
-
-  def test_range_index_persistent
-    data =<<-EOF
-# 012345678901234567890
-#ID:Range
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      load_segment_data(datafile)
-      TmpFile.with_file(load_segment_data(datafile).to_s) do |tsvfile|
-        f = TSV.range_index(tsvfile, "Start", "End", :persistence => true)
-
-        #assert_equal %w(), f[0].sort
-        #assert_equal %w(b), f[1].sort
-        #assert_equal %w(), f[20].sort
-        #assert_equal %w(), f[(20..100)].sort
-        #assert_equal %w(a b d), f[3].sort
-        #assert_equal %w(a b c d e), f[(3..4)].sort
-      end
-    end
-  end
-
-
-#  #{{{ Test Attach
-#  def test_index_headerless
-#    content =<<-EOF
-#row1    a|aa|aaa    b    Id1|Id2
-#row2    A    B    Id3
-#    EOF
-#
-#    TmpFile.with_file(content) do |filename|
-#      tsv = TSV.open(File.open(filename), :sep => /\s+/)
-#      index = tsv.index(:target => 2)
-#      assert index["row1"].include? "Id1"
-#    end
-#  end
-
-
-
-  def test_range_index_persistent_with_filter
-    data =<<-EOF
-# 012345678901234567890
-#ID:Range
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      TmpFile.with_file(load_segment_data(datafile).to_s) do |tsvfile|
-        f = TSV.range_index(tsvfile, "Start", "End", :filters => [["field:Start", "3"]], :persist_update => true)
-
-        assert_equal %w(), f[0].sort
-        assert_equal %w(), f[1].sort
-        assert_equal %w(), f[20].sort
-        assert_equal %w(), f[(20..100)].sort
-        assert_equal %w(a), f[3].sort
-        assert_equal %w(a), f[(3..4)].sort
-      end
-    end
-  end
-
-end
-

data/test/rbbt/tsv/test_manipulate.rb

@@ -1,334 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../../', 'test_helper.rb')
-require 'rbbt/tsv'
-require 'rbbt/tsv/manipulate'
-
-class TestTSVManipulate < Test::Unit::TestCase
-
-  def test_zipped
-    content =<<-EOF
-#Id    ValueA    ValueB ValueC
-rowA    A|AA    B|BB  C|CC
-rowa    a|aa    b|BB  C|CC
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/, :type => :double)
-      assert_equal ["A", "AA", "a", "aa"].sort, tsv.reorder("ValueA", nil, :zipped => true).keys.sort
-    end
-  end
-
-
-  def test_through
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/)
-
-      new_key, new_fields = tsv.through "ValueA" do |key, values|
-        assert(tsv.keys.include? values["Id"].first)
-      end
-
-      assert_equal "ValueA", new_key
-    end
-  end
-
-  def test_reorder_zipped
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b|bb|bbb    Id1|Id2|Id3
-row2    A    B    Id3
-row3    a    b_    Id1_
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/)
-
-      tsv1 = tsv.reorder("ValueA", nil, :zipped => true, :merge => true, :persist => true, :persist_file => '/tmp/foo.rbbt.tch')
-
-      assert_equal "ValueA", tsv1.key_field
-      assert_equal ["B"], tsv1["A"]["ValueB"]
-      assert_equal ["bb"], tsv1["aa"]["ValueB"]
-      assert_equal ["b","b_"], tsv1["a"]["ValueB"]
-      assert_equal %w(Id ValueB OtherID), tsv1.fields
-
-    end
-  end
-  def test_reorder_simple
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/)
-
-      tsv1 = tsv.reorder("ValueA")
-
-      assert_equal "ValueA", tsv1.key_field
-      assert_equal ["B"], tsv1["A"]["ValueB"]
-      assert_equal ["b","C"], tsv1["a"]["ValueB"]
-      assert_equal ["b"], tsv1["aa"]["ValueB"]
-      assert_equal %w(Id ValueB OtherID), tsv1.fields
-
-    end
-  end
-
-  def test_reorder_remove_field
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/)
-
-      tsv1 = tsv.reorder("ValueA", ["ValueB", "Id"])
-
-      assert_equal "ValueA", tsv1.key_field
-      assert_equal %w(ValueB Id), tsv1.fields
-      assert_equal ["B"], tsv1["A"]["ValueB"]
-      assert_equal ["b","C"], tsv1["a"]["ValueB"]
-      assert_equal ["row1"], tsv1["aa"]["Id"]
-      assert_equal ["row1","row3"], tsv1["a"]["Id"]
-    end
-  end
-
-  def test_slice
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :type => :double, :sep => /\s/)
-      assert_equal [["a"],["c"]], tsv.reorder(:key, ["ValueA", "Comment"])["row1"]
-    end
-  end
-
-  def test_slice_empty
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :type => :list, :sep => /\s/)
-      tsv = tsv.slice []
-      assert tsv.fields.empty?
-      TmpFile.with_file do |tmpfile|
-        Open.write(tmpfile, tsv.to_s)
-        tsv = TSV.open tmpfile
-        assert tsv.fields.empty?
-      end
-    end
-  end
-
-  def test_select
-     content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-      assert tsv.type == :double
-      
-      new = tsv.select %w(b Id4)
-      assert_equal %w(row1 row3).sort, new.keys
-
-      new = tsv.select "ValueB" => %w(b Id4)
-      assert_equal %w(row1).sort, new.keys
-
-      new = tsv.select /b|Id4/
-      assert_equal %w(row1 row3).sort, new.keys
-
-      new = tsv.select "ValueB" => /b|Id4/
-      assert_equal %w(row1).sort, new.keys
-
-      
-      new = tsv.select %w(b Id4)
-      assert_equal %w(row1 row3).sort, new.keys.sort
-
-      new = tsv.select do |k,v| 
-        v["ValueA"].include? "A" 
-      end
-      assert_equal %w(row2).sort, new.keys.sort
-
-      tsv = TSV.open(filename, :sep => /\s+/, :type => :flat)
-      assert tsv.type != :double
-    end
-  end
-
-  def test_select_invert
-     content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-      assert tsv.type == :double
-      
-      new = tsv.select %w(b Id4), true
-      assert_equal %w(row2).sort, new.keys
-
-      new = tsv.select /b|Id4/, true
-      assert_equal %w(row2).sort, new.keys
-      
-      new = tsv.select %w(b Id4)
-      assert_equal %w(row1 row3).sort, new.keys.sort
-
-      new = tsv.select do |k,v| 
-        v["ValueA"].include? "A" 
-      end
-      assert_equal %w(row2).sort, new.keys.sort
-
-      tsv = TSV.open(filename, :sep => /\s+/, :type => :flat)
-      assert tsv.type != :double
-    end
-  end
-
-  def test_process
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/)
-
-      tsv.process "ValueA" do |field_values,key,values|
-        field_values.collect{|v| "Pref:#{v}"}
-      end
-
-      assert_equal ["Pref:A"], tsv["row2"]["ValueA"]
-    end
-  end
-
-  def test_add_field
-     content =<<-EOF
-#Id    LetterValue:ValueA    LetterValue:ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
- 
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-      tsv.add_field "Str length" do |k,v| 
-        (v.flatten * " ").length 
-      end
-
-      assert tsv.fields.include?("Str length")
-    end
-  end
-
-  def test_add_field_double_with_list_result
-     content =<<-EOF
-#Id    LetterValue:ValueA    LetterValue:ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
- 
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-
-      tsv.add_field "Test" do
-        "test"
-      end
-
-      assert Array === tsv["row1"]["Test"]
-    end
-  end
-
-  def test_through_headless
-     content =<<-EOF
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
- 
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-
-      test = false
-      tsv.through do
-        test = true
-      end
-      assert test
-
-    end
- 
-  end
-
-  def test_reorder_flat
-    content =<<-EOF
-#Id    ValueA
-row1    a aa aaa
-row2    A
-row3    a
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(File.open(filename), :sep => /\s+/, :type => :flat)
-
-      assert_equal ["row1", "row3"].sort, tsv.reorder("ValueA")["a"]
-    end
-  end
-
-  def test_transpose
-     content =<<-EOF
-#: :type=:list
-#Row   vA   vB   vID
-row1    a    b    Id1
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
- 
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-
-      assert_equal %w(vA vB vID),  tsv.transpose("Values").keys
-      assert_equal %w(Id1 Id3 Id4),  tsv.transpose("Values")["vID"]
-    end
-
-  end
-
-  def test_through_flat
-     content =<<-EOF
-#: :type=:flat
-#Row   vA
-row1    a    b    Id1
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
- 
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-      tsv.through :key, ["vA"] do |k,v|
-        assert_equal 3, v.length
-      end
-
-
-    end
-  end
-
-end

data/test/rbbt/tsv/test_marshal.rb

@@ -1,24 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
-require 'rbbt/tsv'
-require 'rbbt/tsv/marshal'
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-class TestTSVUtil < Test::Unit::TestCase
-
-  def test_marshal
-   content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.open(filename, :sep => /\s+/)
-
-      assert TSV === Marshal.load(Marshal.dump(tsv))
-      assert_equal tsv.to_hash, Marshal.load(Marshal.dump(tsv)).to_hash
-      assert_equal({1 => 1}, Marshal.load(Marshal.dump({1 => 1})))
-    end
-  end
-end

data/test/rbbt/tsv/test_matrix.rb

@@ -1,20 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/tsv'
-require 'rbbt/tsv/matrix'
-
-class TestClass < Test::Unit::TestCase
-  def test_matrix
-    tsv = TSV.open <<-EOF, :sep => " ", :type => :list
-#X Y Z Type Case
-a 2 3 v l
-A 4 7 v L
-m 2 3 c l
-n 4 7 c L
-    EOF
-    tsv = TSV.open(tsv.to_s)
-
-    melt =  tsv.matrix_melt("Letter", "Value", "Type", "Case")
-    assert_equal "L", melt["A~Y"][2]
-  end
-end
-

data/test/rbbt/tsv/test_parallel.rb

@@ -1,7 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/tsv'
-require 'rbbt/tsv/parallel'
-
-class TestTSVParallel < Test::Unit::TestCase
-
-end