rbbt-util 5.43.0 → 5.44.1

data/test/rbbt/persist/tsv/test_sharder.rb

@@ -1,164 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../../test_helper')
-require 'test/unit'
-require 'rbbt-util'
-require 'rbbt/persist/tsv'
-
-class TestSharder < Test::Unit::TestCase
-  def test_shard
-    TmpFile.with_file do |dir|
-      shard_function = Proc.new do |key|
-        key[-1]
-      end
-
-      size = 10
-      sharder = Persist.persist_tsv(nil, "ShardTest", {}, :file => dir, :shard_function => shard_function, :persist => true, :serializer => :float_array) do |db|
-        size.times do |v| 
-          db[v.to_s] = [v, v*2]
-        end
-        db
-      end
-      assert_equal dir, sharder.persistence_path
-      assert_equal size, sharder.keys.length
-
-      assert_equal [2,4], sharder["2"]
-      count = 0
-      sharder.through do |k,v|
-        count += 1
-      end
-      assert_equal count, size
-
-      sharder = Persist::Sharder.new dir do |key|
-        key[-1]
-      end
-
-      assert_equal size, sharder.keys.length
-
-    end
-  end
-
-  def test_shard_fwt
-    TmpFile.with_file do |dir|
-      shard_function = Proc.new do |key|
-        key[0..(key.index(":")-1)]
-      end
-
-      pos_function = Proc.new do |key|
-        key.split(":").last.to_i
-      end
-
-      size = 10
-      sharder = Persist.persist_tsv(nil, "ShardTest", {}, :update => true, :range => false, :value_size => 64, :engine => 'fwt', :file => dir, :shard_function => shard_function, :pos_function => pos_function, :persist => true, :serializer => :float) do |db|
-        size.times do |v| 
-          v = v + 1
-          chr = "chr" << (v % 5).to_s
-          key = chr + ":" << v.to_s
-          db << [key, v*2]
-        end
-      end
-      sharder.read
-
-      assert_equal dir, sharder.persistence_path
-      assert_equal size, sharder.size
-
-      assert_equal [4.0], sharder["chr2:2"]
-
-      count = 0
-      sharder.through do |k,v|
-        count += 1
-      end
-      assert_equal count, size
-
-      sharder = Persist.open_sharder(dir, false, :float, 'fwt', {:range => false, :value_size => 64, :pos_function => pos_function}, &shard_function)
-
-      assert_equal [4.0], sharder["chr2:2"]
-
-      assert_equal size, sharder.size 
-    end
-  end
-
-  def test_shard_pki
-    TmpFile.with_file do |dir|
-      shard_function = Proc.new do |key|
-        key[0..(key.index(":")-1)]
-      end
-
-      pos_function = Proc.new do |key|
-        key.split(":").last.to_i
-      end
-
-      size = 10
-      chrs = (1..10).to_a
-      sharder = Persist.persist_tsv(nil, "ShardTest", {}, :pattern => %w(f), :update => true, :range => false, :value_size => 64, :engine => 'pki', :file => dir, :shard_function => shard_function, :pos_function => pos_function, :persist => true, :serializer => :clean) do |db|
-        chrs.each do |c|
-          size.times do |v| 
-            v = v 
-            chr = "chr" << c.to_s
-            key = chr + ":" << v.to_s
-            db << [key, [v*2]]
-          end
-        end
-      end
-      sharder.read
-
-      assert_equal dir, sharder.persistence_path
-      assert_equal size*chrs.length, sharder.size
-
-      assert_equal [4.0], sharder["chr2:2"]
-
-      count = 0
-      sharder.through do |k,v|
-        count += 1
-      end
-      assert_equal count, size*chrs.length
-
-      sharder = Persist.open_sharder(dir, false, :float, 'fwt', {:range => false, :value_size => 64, :pos_function => pos_function}, &shard_function)
-
-      assert_equal [4.0], sharder["chr2:2"]
-
-      assert_equal chrs.length*size, sharder.size 
-    end
-  end
-
-  def test_shard_pki_skip
-    TmpFile.with_file do |dir|
-      shard_function = Proc.new do |key|
-        key[0..(key.index(":")-1)]
-      end
-
-      pos_function = Proc.new do |key|
-        key.split(":").last.to_i
-      end
-
-      size = 10
-      chrs = (1..10).to_a
-      sharder = Persist.persist_tsv(nil, "ShardTest", {}, :pattern => %w(f), :update => true, :range => false, :value_size => 64, :engine => 'pki', :file => dir, :shard_function => shard_function, :pos_function => pos_function, :persist => true, :serializer => :clean) do |db|
-        chrs.each do |c|
-          size.times do |v| 
-            v = v + 1
-            chr = "chr" << c.to_s
-            key = chr + ":" << (v*2).to_s
-            db << [key, [v*2]]
-          end
-        end
-      end
-      sharder.read
-
-      assert_equal dir, sharder.persistence_path
-
-      assert_equal [2.0], sharder["chr2:2"]
-      assert_equal [4.0], sharder["chr2:4"]
-
-      count = 0
-      sharder.through do |k,v|
-        count += 1 unless v.nil?
-      end
-      assert_equal count, size*chrs.length
-
-      sharder = Persist.open_sharder(dir, false, :float, 'fwt', {:range => false, :value_size => 64, :pos_function => pos_function}, &shard_function)
-
-      assert_equal [2.0], sharder["chr2:2"]
-
-    end
-  end
-end
-

data/test/rbbt/persist/tsv/test_tokyocabinet.rb

@@ -1,262 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../../test_helper')
-require 'rbbt/persist'
-require 'rbbt/annotations'
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-
-module TestAnnotationModule
-  extend Annotation
-
-  self.annotation :test_annotation
-end
-
-class TestPersistTSVTC < Test::Unit::TestCase
-
-  def test_organism
-    require 'rbbt/sources/organism'
-    TmpFile.with_file do |tmp_file|
-      tsv = Organism.identifiers("Hsa").tsv :key_field => "Associated Gene Name", :fields => ["Ensembl Gene ID"], :type => :single, :persist => true, :persist_engine => "HDB", :persist_dir => tmp_file
-      assert_equal "ENSG00000141510", tsv["TP53"]
-    end
-  end
-
-  def test_annotation_persist
-    TmpFile.with_file do |tmp|
-      entity1 = "Entity 1"
-      entity2 = "Entity 2"
-
-      TestAnnotationModule.setup(entity1, :test_annotation => "1")
-      TestAnnotationModule.setup(entity2, :test_annotation => "2")
-
-      annotations = [entity1, entity2]
-
-      persisted_annotations = Persist.persist("Test", :annotations, :file => tmp) do
-        annotations
-      end
-
-      assert_equal "Entity 1", persisted_annotations.first
-      assert_equal "Entity 2", persisted_annotations.last
-      assert_equal "1", persisted_annotations.first.test_annotation
-      assert_equal "2", persisted_annotations.last.test_annotation
-
-      persisted_annotations = Persist.persist("Test", :annotations, :file => tmp) do
-        annotations
-      end
-
-      assert_equal "Entity 1", persisted_annotations.sort.first
-      assert_equal "Entity 2", persisted_annotations.sort.last
-      assert_equal "1", persisted_annotations.sort.first.test_annotation
-      assert_equal "2", persisted_annotations.sort.last.test_annotation
-    end
-  end
-
-  def test_annotation_persist_with_repetitions
-    TmpFile.with_file do |tmp|
-      entity1 = "Entity 1"
-      entity2 = "Entity 2"
-      entity2bis = "Entity 2"
-
-      TestAnnotationModule.setup(entity1, :test_annotation => "1")
-      TestAnnotationModule.setup(entity2, :test_annotation => "2")
-      TestAnnotationModule.setup(entity2bis, :test_annotation => "2")
-
-      annotations = [entity1, entity2, entity2bis]
-
-      persisted_annotations = Persist.persist("Test", :annotations, :file => tmp) do
-        annotations
-      end
-
-      assert_equal 3, persisted_annotations.length
-
-      assert_equal "Entity 1", persisted_annotations.first
-      assert_equal "Entity 2", persisted_annotations.last
-      assert_equal "1", persisted_annotations.first.test_annotation
-      assert_equal "2", persisted_annotations.last.test_annotation
-
-      persisted_annotations = Persist.persist("Test", :annotations, :file => tmp) do
-        annotations
-      end
-
-      assert_equal 3, persisted_annotations.length
-
-      assert_equal "Entity 1", persisted_annotations.sort.first
-      assert_equal "Entity 2", persisted_annotations.sort.last
-      assert_equal "1", persisted_annotations.sort.first.test_annotation
-      assert_equal "2", persisted_annotations.sort.last.test_annotation
-    end
-  end
-
-  def test_bdb
-    TmpFile.with_file do |tmp|
-      repo = Persist.open_tokyocabinet(tmp, true, :double, TokyoCabinet::BDB)
-      repo["test:string1"] = [["STR1"]]
-      repo["test:string2"] = [["STR2"]]
-      repo["other_test:string3"] = [["STR2"]]
-
-      assert_equal ["test:string1", "test:string2"].sort, repo.range("test:" << 0.chr, false, "test:" << 255.chr, false).sort
-      assert_equal ["other_test:string3"].sort, repo.range("other_test:" << 0.chr, false, "other_test:" << 255.chr, false).sort
-    end
-  end
-
-  def test_annotation_persist_repo
-    TmpFile.with_file do |tmp|
-      repo = Persist.open_tokyocabinet(tmp, true, :list, TokyoCabinet::BDB)
-
-      entity1 = "Entity 1"
-      entity2 = "Entity 2"
-
-      TestAnnotationModule.setup(entity1, :test_annotation => "1")
-      TestAnnotationModule.setup(entity2, :test_annotation => "2")
-
-      annotations = [entity1, entity2]
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations
-      end
-
-      assert_equal "Entity 1", persisted_annotations.first
-      assert_equal "Entity 2", persisted_annotations.last
-      assert_equal "1", persisted_annotations.first.test_annotation
-      assert_equal "2", persisted_annotations.last.test_annotation
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations
-      end
-
-      assert_equal "Entity 1", persisted_annotations.sort.first
-      assert_equal "Entity 2", persisted_annotations.sort.last
-      assert_equal "1", persisted_annotations.sort.first.test_annotation
-      assert_equal "2", persisted_annotations.sort.last.test_annotation
-    end
-  end
-
-  def test_annotation_persist_repo_annotated_array
-    TmpFile.with_file do |tmp|
-      repo = Persist.open_tokyocabinet(tmp, true, :list, TokyoCabinet::BDB)
-
-      entity1 = "Entity 1"
-      entity2 = "Entity 2"
-
-      annotations = [entity1, entity2]
-      TestAnnotationModule.setup(annotations, :test_annotation => "1")
-      annotations.extend AnnotatedArray
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations
-      end
-
-      assert_equal "Entity 1", persisted_annotations.first
-      assert_equal "Entity 2", persisted_annotations.last
-      assert_equal "1", persisted_annotations.first.test_annotation
-      assert_equal "1", persisted_annotations.last.test_annotation
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations
-      end
-
-      persisted_annotations.extend AnnotatedArray
-
-      assert_equal "Entity 1", persisted_annotations.sort.first
-      assert_equal "Entity 2", persisted_annotations.sort.last
-      assert_equal "1", persisted_annotations.sort.first.test_annotation
-      assert_equal "1", persisted_annotations.sort.last.test_annotation
-    end
-  end
-
-  def test_annotation_persist_repo_triple_array
-    TmpFile.with_file(nil, false) do |tmp|
-      repo = Persist.open_database(tmp, true, :list, "BDB")
-
-      entity1 = "Entity 1"
-      entity2 = "Entity 2"
-
-      annotations = [entity1, entity2]
-      TestAnnotationModule.setup(annotations, :test_annotation => "1")
-      annotations.extend AnnotatedArray
-
-      annotations_ary = [annotations]
-      TestAnnotationModule.setup(annotations_ary, :test_annotation => "1")
-      annotations_ary.extend AnnotatedArray
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations_ary
-      end
-      assert AnnotatedArray === persisted_annotations
-
-      assert_equal "Entity 1", persisted_annotations.first.first
-      assert_equal "Entity 2", persisted_annotations.first.last
-      assert_equal "1", persisted_annotations.first.first.test_annotation
-      assert_equal "1", persisted_annotations.first.last.test_annotation
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations_ary
-      end
-
-      assert AnnotatedArray === persisted_annotations
-
-      assert_equal "Entity 1", persisted_annotations.sort.first.first
-      assert_equal "Entity 2", persisted_annotations.sort.first.last
-      assert_equal "1", persisted_annotations.sort.first.first.test_annotation
-      assert_equal "1", persisted_annotations.sort.first.last.test_annotation
-
-    end
-  end
-
-  def test_annotation_persist_repo_with_repetitions
-    TmpFile.with_file do |tmp|
-      repo = Persist.open_tokyocabinet(tmp, true, :list, TokyoCabinet::BDB)
-
-      entity1 = "Entity 1"
-      entity2 = "Entity 2"
-      entity2bis = "Entity 2"
-
-      TestAnnotationModule.setup(entity1, :test_annotation => "1")
-      TestAnnotationModule.setup(entity2, :test_annotation => "2")
-      TestAnnotationModule.setup(entity2bis, :test_annotation => "2")
-
-      annotations = [entity1, entity2, entity2bis]
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations
-      end
-
-      assert_equal 3, persisted_annotations.length
-
-      assert_equal "Entity 1", persisted_annotations.first
-      assert_equal "Entity 2", persisted_annotations.last
-      assert_equal "1", persisted_annotations.first.test_annotation
-      assert_equal "2", persisted_annotations.last.test_annotation
-
-      persisted_annotations = Persist.persist("Test", :annotations, :annotation_repo => repo) do
-        annotations
-      end
-
-      assert_equal 3, persisted_annotations.length
-
-      assert_equal "Entity 1", persisted_annotations.sort.first
-      assert_equal "Entity 2", persisted_annotations.sort.last
-      assert_equal "1", persisted_annotations.sort.first.test_annotation
-      assert_equal "2", persisted_annotations.sort.last.test_annotation
-    end
-  end
-
-  def __test_fdb
-    TmpFile.with_file do |tmp|
-      repo = Persist.open_tokyocabinet(tmp, true, :list, TokyoCabinet::FDB)
-      repo.write
-      repo.put(1, "hola")
-      repo.put(2, "adios")
-      47000.times do |i|
-        repo.put(i*500, "key: " << i.to_s)
-      end
-      repo.read
-      Misc.profile do
-        repo.values_at *repo.range("[100,1000]")
-      end
-      Misc.benchmark(60_000) do
-        repo.values_at *repo.range("[100,1000]")
-      end
-    end
-  end
-end

data/test/rbbt/resource/test_path.rb

@@ -1,49 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '../../../test_helper')
-require 'rbbt/resource/path'
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-class TestTSV < Test::Unit::TestCase
-
-  def test_find
-    name = 'test_name_for_unexistent_file'
-    path = Path.setup "tmp/#{ name }"
-
-    TmpFile.with_file do |dir|
-      assert File.join(ENV['HOME'], path), path.find(nil, nil, {:root => File.join(dir, '{TOPLEVEL}/{SUBPATH}'), :default => :user, :user => File.join(ENV['HOME'], "{TOPLEVEL}", "{SUBPATH}")})
-      FileUtils.mkdir_p File.dirname(File.join(dir, path))
-      FileUtils.touch File.join(dir, path)
-      assert File.join(dir, "tmp/test"), path.find(nil, nil, {:root => File.join(dir, '{TOPLEVEL}/{SUBPATH}'), :default => :user, :user => File.join(ENV['HOME'], "{TOPLEVEL}", "{SUBPATH}")})
-    end
-  end
-
-  def test_find_current
-    TmpFile.with_file do |dir|
-      Misc.in_dir dir do
-        CMD.cmd('touch foo')
-        p = Path.setup('foo')
-        assert_equal File.join(dir, 'foo'), p.find(:current)
-      end
-    end
-  end
-
-  def test_prev
-    path = Path.setup "/tmp"
-    assert_equal "/tmp/bar/foo", path.foo("bar")
-  end
-
-  def test_doc_file
-    path = Path.setup "lib/rbbt/resource.rb"
-    assert_equal File.join('doc', path), path.doc_file
-    assert_equal Path.setup(File.join('doc', path)).find(:lib), path.find(:lib).doc_file
-
-    assert_equal "lib/rbbt/resource.rb", path.doc_file.source_for_doc_file
-    assert_equal File.realpath(path.find), File.realpath(path.doc_file.find(:lib).source_for_doc_file)
-    assert_equal File.realpath(path.find), File.realpath(path.doc_file.source_for_doc_file.find)
-
-    assert_equal "doc/lib/rbbt/resource.rb.doc", path.doc_file.set_extension('doc')
-    #assert_equal "lib/rbbt/resource.rb", path.doc_file.set_extension('doc').source_for_doc_file
-
-    assert_equal "doc/lib/rbbt/resource.rb.doc", path.doc_file.set_extension('doc')
-  end
-end

data/test/rbbt/test_annotations.rb

@@ -1,167 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require 'rbbt/annotations'
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-module AnnotatedString
-  extend Annotation
-  self.annotation :annotation_str
-
-  def add_annot
-    self + annotation_str
-  end
-end
-
-module AnnotatedString2
-  extend Annotation
-  include AnnotatedString
-  self.annotation :annotation_str2
-end
-
-class TestAnnotations < Test::Unit::TestCase
-
-  def test_annotated_string
-    assert_equal %w(annotation_str), AnnotatedString.annotations.collect{|a| a.to_s}
-  end
-
-  def test_string
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, annotation_str)
-    assert_equal [AnnotatedString], str.annotation_types
-    assert_equal annotation_str, str.annotation_str
-  end
-
-  def test_array
-    ary = ["string"]
-    annotation_str = "Annotation String"
-    ary.extend AnnotatedArray
-    AnnotatedString.setup(ary, annotation_str)
-    assert_equal [AnnotatedString], ary.annotation_types
-    assert_equal annotation_str, ary.annotation_str
-    assert_equal annotation_str, ary[0].annotation_str
-  end
-
-
-  def test_info
-    ary = ["string"]
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(ary, annotation_str)
-    
-    assert_equal({:annotation_str => annotation_str, :annotation_types => [AnnotatedString], :annotated_array => true}, ary.info)
-  end
-
-  def test_load
-    str = "string"
-    annotation_str = "Annotation String"
-    info = {:annotation_str => annotation_str, :annotation_types => [AnnotatedString]}
-
-    Annotated.load_entity(str, info)
-    assert_equal annotation_str, str.annotation_str
-  end
-
-  def test_json
-    str1 = "string1"
-    annotation_str1 = "Annotation String 1"
-    str2 = "string2"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString.setup(str1, annotation_str1)
-    AnnotatedString.setup(str2, annotation_str2)
-  end
-
-  def test_tsv
-    str1 = "string1"
-    annotation_str1 = "Annotation String 1"
-    str2 = "string2"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString.setup(str1, annotation_str1)
-    AnnotatedString.setup(str2, annotation_str2)
-    
-    assert_equal str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["literal"] 
-    assert_equal annotation_str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["annotation_str"] 
-    assert_equal str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["literal"] 
-    assert_equal annotation_str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["annotation_str"] 
-    assert_equal annotation_str1, Annotated.tsv([str1, str2], :annotation_str, :JSON).tap{|t| t.unnamed = false}[str1.id + "#0"]["annotation_str"] 
-  end
-
-  def test_literal
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, annotation_str)
-    assert_equal ["string"], str.tsv_values("literal")
-  end
-
-  def test_load_tsv
-    str1 = "string1"
-    annotation_str1 = "Annotation String 1"
-    str2 = "string2"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString.setup(str1, annotation_str1)
-    AnnotatedString.setup(str2, annotation_str2)
-    assert_equal annotation_str1, Annotated.load_tsv(Annotated.tsv([str1, str2], :all)).sort.first.annotation_str
-    assert_equal str1, Annotated.load_tsv(Annotated.tsv([str1, str2], :literal, :JSON)).sort.first
-  end
-
-  def test_load_array_tsv
-    str1 = "string1"
-    str2 = "string2"
-    a = [str1, str2]
-    annotation_str = "Annotation String 2"
-    AnnotatedString.setup(a, annotation_str)
-    a.extend AnnotatedArray
-
-
-    assert_equal annotation_str, Annotated.load_tsv(Annotated.tsv(a, :all)).annotation_str
-
-    assert_equal str2, Annotated.load_tsv(Annotated.tsv(a, :literal, :JSON)).sort.last
-  end
-
-  def test_inheritance
-    str = "string1"
-    annotation_str1 = "Annotation String 1"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString2.setup(str, annotation_str1, annotation_str2)
-    assert_equal annotation_str1, str.annotation_str
-    assert_equal annotation_str2, str.annotation_str2
-  end
-
-  def test_annotation_methods
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, annotation_str)
-    assert_equal str + annotation_str, str.add_annot
-  end
-
-  def test_double_array_1
-    ary = ["string"]
-    annotation_str = "Annotation String"
-    ary.extend AnnotatedArray
-    ary_ary = [ary]
-    ary_ary.extend AnnotatedArray
-    AnnotatedString.setup(ary, annotation_str)
-    AnnotatedString.setup(ary_ary, annotation_str)
-    assert_equal [AnnotatedString], ary.annotation_types
-    assert_equal annotation_str, ary.annotation_str
-    assert_equal annotation_str, ary[0].annotation_str
-  end
-
-  def test_double_array_2
-    a = ["a"]
-    b = AnnotatedString.setup([AnnotatedString.setup(["a"])])
-    AnnotatedString.setup(a)
-    a.extend AnnotatedArray
-    assert AnnotatedString === b[0]
-    b.extend AnnotatedArray
-    assert AnnotatedString === b[0, true]
-    assert(!a.double_array)
-    assert(b.double_array)
-  end
-
-  def test_annotation_positional2hash
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, :annotation_str => annotation_str)
-    assert_equal str + annotation_str, str.add_annot
-  end
-
-end