scout-gear 10.4.0 → 10.7.0

data/test/scout/association/test_fields.rb

@@ -0,0 +1,105 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/tsv'
+class TestAssociationFields < Test::Unit::TestCase
+  def test_specs
+    spec = Association.parse_field_specification "=~Associated Gene Name=>Ensembl Gene ID"
+    assert_equal [nil, "Associated Gene Name", "Ensembl Gene ID"], spec
+
+    spec = Association.parse_field_specification "TG=~Associated Gene Name=>Ensembl Gene ID"
+    assert_equal ["TG", "Associated Gene Name", "Ensembl Gene ID"], spec
+
+    spec = Association.parse_field_specification "TG=~Associated Gene Name"
+    assert_equal ["TG", "Associated Gene Name", nil], spec
+
+    spec = Association.parse_field_specification "Associated Gene Name=>Ensembl Gene ID"
+    assert_equal ["Associated Gene Name", nil, "Ensembl Gene ID"], spec
+  end
+
+  def test_normalize_specs
+    spec = Association.normalize_specs "TG=~Associated Gene Name=>Ensembl Gene ID", %w(SG TG Effect directed?)
+    assert_equal ["TG", "Associated Gene Name", "Ensembl Gene ID"], spec
+
+    spec = Association.normalize_specs "Ensembl Gene ID", %w(SG TG Effect directed?)
+    assert_equal ["Ensembl Gene ID", nil, nil], spec
+
+    spec = Association.normalize_specs "Ensembl Gene ID"
+    assert_equal ["Ensembl Gene ID", nil, nil], spec
+  end
+
+  def test_process_specs
+    spec = Association.extract_specs %w(SG TG Effect directed?), :target => "TG=~Associated Gene Name=>Ensembl Gene ID"
+    assert_equal ["TG", "Associated Gene Name", "Ensembl Gene ID"], spec[:target]
+    assert_equal ["SG", nil, nil], spec[:source]
+
+    spec = Association.extract_specs %w(SG TG Effect directed?)
+    assert_equal ["SG", nil, nil], spec[:source]
+    assert_equal ["TG", nil,nil], spec[:target]
+
+    spec = Association.extract_specs %w(SG TG Effect directed?), :source => "TG"
+    assert_equal ["TG", nil, nil], spec[:source]
+    assert_equal ["SG", nil,nil], spec[:target]
+
+    spec = Association.extract_specs %w(SG TG Effect directed?), :source => "SG"
+    assert_equal ["SG", nil, nil], spec[:source]
+    assert_equal ["TG", nil,nil], spec[:target]
+
+    spec = Association.extract_specs %w(SG TG Effect directed?), :target => "SG"
+    assert_equal ["TG", nil, nil], spec[:source]
+    assert_equal ["SG", nil,nil], spec[:target]
+  end
+
+  def test_headers
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect)
+    assert_equal 0, spec[0]
+    assert_equal 1, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :source => "SG"
+    assert_equal 0, spec[0]
+    assert_equal 1, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "TG"
+    assert_equal 0, spec[0]
+    assert_equal 1, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "TG", :source => "SG"
+    assert_equal 0, spec[0]
+    assert_equal 1, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :source => "TG"
+    assert_equal 1, spec[0]
+    assert_equal 0, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "SG"
+    assert_equal 1, spec[0]
+    assert_equal 0, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "SG", :source => "TG"
+    assert_equal 1, spec[0]
+    assert_equal 0, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "SG", :source => "TG=~Associated Gene Name=>Ensembl Gene ID"
+    assert_equal 1, spec[0]
+    assert_equal 0, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "SG=~Associated Gene Name=>Ensembl Gene ID", :source => "TG=~Associated Gene Name=>Ensembl Gene ID"
+    assert_equal 1, spec[0]
+    assert_equal 0, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "SG=~Associated Gene Name", :source => "TG=~Associated Gene Name=>Ensembl Gene ID"
+    assert_equal 1, spec[0]
+    assert_equal 0, spec[1][0]
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "TG=~Associated Gene Name", :source => "SG=~Associated Gene Name", :target_format => "Ensembl Gene ID"
+    assert_equal 0, spec[0]
+    assert_equal "Ensembl Gene ID", spec[5]
+    assert_equal nil, spec[4]
+
+
+    spec = Association.headers  %w(SG TG Effect directed?), %w(Effect), :target => "TG=~Associated Gene Name", :source => "SG=~Associated Gene Name", :source_format => "Ensembl Gene ID"
+    assert_equal 0, spec[0]
+    assert_equal "Ensembl Gene ID", spec[4]
+    assert_equal nil, spec[5]
+  end
+end

data/test/scout/association/test_index.rb

@@ -0,0 +1,70 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/tsv'
+require 'scout/association'
+class TestAssociationIndex < Test::Unit::TestCase
+  def test_parents_simple
+    database = Association.database datadir_test.person.parents
+    index = Association.index datadir_test.person.parents
+    assert_include index, "Miki~Juan"
+  end
+
+  def test_parents
+    index = Association.index datadir_test.person.parents, target: "Parent=>Name", source: "=>Name"
+    assert_include index, "Miguel~Juan Luis"
+  end
+
+  def test_brothers
+    index = Association.index datadir_test.person.brothers, undirected: true, persist: false
+    assert_include index, "Clei~Guille"
+    assert_include index, "Guille~Clei"
+  end
+
+  def test_brothers_match
+    index = Association.index datadir_test.person.brothers, undirected: true
+    assert_equal ["Clei~Guille"], index.match("Clei")
+    assert_equal ["Guille~Clei"], index.match("Guille")
+  end
+
+  def test_parents_subset
+    index = Association.index datadir_test.person.parents
+    assert_include index.subset(["Miki", "Guille"], :all), "Miki~Juan"
+    assert_include index.subset(["Miki", "Guille"], :all), "Guille~Gloria"
+  end
+
+  def test_parents_reverse
+    index = Association.index datadir_test.person.parents
+    assert_include index.reverse.source_field, "Parent"
+    assert_include index.reverse.subset(["Juan"], :all), "Juan~Miki"
+  end
+
+  def test_parents_filter
+    index = Association.index datadir_test.person.parents
+    assert_include index.filter('Type of parent', 'mother'), "Miki~Mariluz"
+    assert_include index.filter('Type of parent', 'mother'), "Clei~Gloria"
+    refute index.filter('Type of parent', 'mother').include?("Miki~Juan")
+  end
+
+  def test_parents_flat
+    tsv = datadir_test.person.parents.tsv type: :flat, fields: ["Parent"]
+    index = Association.index tsv
+    assert_include index, "Miki~Juan"
+    assert_include index, "Isa~Mariluz"
+  end
+
+  def test_list_serializer
+    TmpFile.with_file <<-EOF do |f|
+#: :sep=,#:type=:list
+#lowcase,upcase,double,triple
+a,A,aa,aaa
+b,B,bb,bbb
+      EOF
+      tsv = TSV.open(f)
+      i = Association.index tsv
+      assert_equal ['aa', 'aaa'], i["a~A"]
+    end
+  end
+
+end
+

data/test/scout/association/test_item.rb

@@ -0,0 +1,21 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/tsv'
+require 'scout/association'
+class TestAssociationItem < Test::Unit::TestCase
+  def test_incidence
+    pairs = [[:A, :a], [:B, :b]].collect{|p| "#{p.first.to_s}~#{p.last.to_s}"}
+    assert TSV === AssociationItem.incidence(pairs)
+    assert_equal 2, AssociationItem.incidence(pairs).length
+    assert_equal 2, AssociationItem.incidence(pairs).fields.length
+  end
+
+  def test_brothers
+    incidence = TSV.incidence(datadir_test.person.brothers, undirected: true)
+    assert incidence["Clei"]["Guille"]
+    assert incidence["Guille"]["Clei"]
+    refute incidence["Clei"]["Isa"]
+  end
+end
+

data/test/scout/entity/test_format.rb

@@ -0,0 +1,19 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestEntityFormat < Test::Unit::TestCase
+  def test_format
+    index = Entity::FormatIndex.new
+    index["Ensembl Gene ID"] = "Gene"
+    assert_equal "Gene", index["Ensembl Gene ID"]
+    assert_equal "Gene", index["Transcription Factor (Ensembl Gene ID)"]
+
+    Entity::FORMATS["Ensembl Gene ID"] = "Gene"
+    assert_equal "Ensembl Gene ID", Entity::FORMATS.find("Ensembl Gene ID")
+    assert_equal "Ensembl Gene ID", Entity::FORMATS.find("Transcription Factor (Ensembl Gene ID)")
+
+    assert_equal "Gene", Entity::FORMATS["Ensembl Gene ID"]
+    assert_equal "Gene", Entity::FORMATS["Transcription Factor (Ensembl Gene ID)"]
+  end
+end
+

data/test/scout/entity/test_identifiers.rb

@@ -0,0 +1,58 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/tsv'
+require 'scout/entity'
+
+class TestEntityIdentifiers < Test::Unit::TestCase
+  module Person
+    extend Entity
+  end
+
+  module PersonWithNoIds
+    extend Entity
+    include Entity::Identified
+  end
+
+  Person.add_identifiers datafile_test(Entity::Identified::NAMESPACE_TAG + '/identifiers'), "Name", "Alias"
+
+  teardown do
+    Entity.formats.clear
+  end
+
+  def test_alias
+    miguel = Person.setup("Miguel", namespace: :person)
+    assert_equal "Miki", miguel.to("Alias")
+  end
+
+  def test_alias_no_namespace
+    miguel = Person.setup("Miguel")
+
+    assert_raise do
+      miguel.to("Name")
+    end
+  end
+
+  def test_alias_no_ids
+    miguel = PersonWithNoIds.setup("Miguel", namespace: :person)
+    assert_raise do
+      miguel.to("Name")
+    end
+  end
+
+
+  def test_name_from_ID
+    assert_equal "Miki", Person.setup("001", :format => 'ID', namespace: :person).to("Alias")
+    assert_equal "Miguel", Person.setup("001", :format => 'ID', namespace: :person).to("Name")
+    assert_equal ["Miguel"], Person.setup(["001"], :format => 'ID', namespace: :person).to("Name")
+  end
+
+
+  def test_identifier_files
+    assert Person.identifier_files.any?
+  end
+
+  def test_Entity_identifier_files
+    assert Entity.identifier_files("Name").any?
+  end
+end

data/test/scout/entity/test_property.rb

@@ -0,0 +1,345 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/entity'
+require 'scout/tsv'
+
+class TestEntityProperty < Test::Unit::TestCase
+  class TestA
+    attr_accessor :foo, :bar
+    def initialize(foo, bar)
+      @foo = foo
+      @bar = bar
+    end
+  end
+
+  $count = 0
+
+  module ReversableString
+    extend Entity
+
+    self.annotation :foo, :bar
+
+    property :times do |times|
+      [self] * times
+    end
+
+    property :reverse_both => :both do
+      if Array === self
+        self.collect{|s| s.reverse }
+      else
+        self.reverse
+      end
+    end
+
+    property :reverse_text_ary => :array do
+      $count += 1
+      self.collect{|s| s.reverse}
+    end
+
+
+    property :reverse_text_ary_hash => :array do
+      $count += 1
+      res = {}
+      self.each{|s| res[s] = s.reverse }
+      res
+    end
+
+    property :reverse_text_single => :single do
+      $count += 1
+      self.reverse
+    end
+
+    property :reverse_text_ary_p => :array2single do
+      $count += 1
+      self.collect{|s| s.reverse}
+    end
+
+    property :reverse_text_single_p => :single do
+      $count += 1
+      self.reverse
+    end
+
+    property :reverse_text_ary_p_array => :array do
+      $count += 1
+      self.collect{|s| s.reverse }
+    end
+
+    property :random => :single do
+      rand
+    end
+
+    property :annotation_list => :single do
+      self.chars.to_a.collect{|c| 
+        ReversableString.setup(c)
+      }
+    end
+
+    property :annotation_list_empty => :single do
+      []
+    end
+
+    $processed_multiple = []
+    property :multiple_annotation_list => :multiple do 
+      $processed_multiple.concat self
+      res = {}
+      self.collect do |e|
+        e.chars.to_a.collect{|c| 
+          ReversableString.setup(c)
+        }
+      end
+    end
+
+    #persist :multiple_annotation_list, :annotation, :dir => Rbbt.tmp.test.annots
+  end
+
+  setup do
+    ReversableString.persist :reverse_text_ary_p, :marshal
+
+    ReversableString.persist :reverse_text_ary_p_array, :array, :dir => TmpFile.tmp_file
+
+    ReversableString.persist :annotation_list, :annotation, :annotation_repo => TmpFile.tmp_file
+
+    ReversableString.persist :annotation_list_empty, :annotation, :dir => TmpFile.tmp_file
+
+    ReversableString.persist :multiple_annotation_list, :annotation, :dir => TmpFile.tmp_file
+  end
+
+
+  def test_property_ary_make_list
+    $count = 0
+    a = "String1"
+    ReversableString.setup(a)
+
+    assert_equal "1gnirtS", a.reverse_text_ary
+  end
+
+  def test_property_both
+    a = "String1"
+    ReversableString.setup(a)
+
+    $count = 0
+
+    assert_equal "1gnirtS", a.reverse_both
+
+    a = ["String1"]
+    ReversableString.setup(a)
+
+    assert_equal "1gnirtS", a.reverse_both.last
+  end
+
+  def test_property_single_simple
+    a = "String1"
+    ReversableString.setup(a)
+
+    $count = 0
+
+    assert_equal "1gnirtS", a.reverse_text_single
+  end
+
+  def test_property_ary
+    a = ["String1", "String2"]
+    ReversableString.setup(a)
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_ary.last
+    assert_equal 1, $count
+    a._ary_property_cache.clear
+    assert ReversableString === a[1]
+    assert Entity::Object === a[1]
+    assert_equal "2gnirtS", a[1].reverse_text_ary
+    assert_equal 2, $count
+    a._ary_property_cache.clear
+
+    $count = 0
+    a.each do |string|
+      string.reverse_text_ary
+      assert_equal 1, $count
+    end
+  end
+
+  def test_property_ary_hash
+    a = ["String1", "String2"]
+    ReversableString.setup(a)
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_ary_hash["String2"]
+    assert_equal 1, $count
+    a._ary_property_cache.clear
+    assert_equal "2gnirtS", a[1].reverse_text_ary_hash
+    assert_equal 2, $count
+    a._ary_property_cache.clear
+
+    $count = 0
+    a.each do |string|
+      string.reverse_text_ary
+      assert_equal 1, $count
+    end
+  end
+
+  def test_property_single
+    a = ["String1", "String2"]
+    ReversableString.setup a
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_single.last
+    assert_equal 2, $count
+    assert_equal "2gnirtS", a[1].reverse_text_single
+    assert_equal 3, $count
+  end
+
+  def test_property_ary_p
+    a = ["String1", "String2"]
+    ReversableString.setup a
+
+    a.reverse_text_ary_p
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_ary_p.last
+    assert_equal "2gnirtS", a.collect{|e| e.reverse_text_ary_p }[1]
+    assert_equal 0, $count
+  end
+
+  def test_property_single_p
+    a = ["String1", "String2"]
+    ReversableString.setup a
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_single_p.last
+
+    assert_equal 2, $count
+
+    a = ["String1", "String2"]
+    ReversableString.setup a
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_single_p.last
+    assert_equal 2, $count
+    assert_equal "2gnirtS", a[1].reverse_text_single_p
+    assert_equal 3, $count
+  end
+
+  def test_property_ary_p_array
+    a = ["String1", "String2"]
+    ReversableString.setup a
+
+    assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
+
+    $count = 0
+
+    assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
+    assert_equal 0, $count
+    assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
+    assert_equal 0, $count
+  end
+
+  def test_unpersist
+    a = ["String1", "String2"]
+    ReversableString.setup a
+
+    # Before persist
+    assert(! ReversableString.persisted?(:random))
+
+    r1 = a.random
+    r2 = a.random
+    assert_not_equal r1, r2
+
+    # After persist
+    ReversableString.persist :random
+    assert ReversableString.persisted?(:random)
+
+    r1 = a.random
+    r2 = a.random
+    assert_equal r1, r2
+
+    # After unpersist
+    ReversableString.unpersist :random
+    refute ReversableString.persisted?(:random)
+
+    r1 = a.random
+    r2 = a.random
+    assert_not_equal r1, r2
+
+  end
+
+  def test_persist_annotations
+    string = 'aaabbbccc'
+    ReversableString.setup(string)
+    assert_equal string.length, string.annotation_list.length
+    assert_equal string.length, string.annotation_list.length
+  end
+
+  def test_persist_annotations_empty
+    string = 'aaabbbccc'
+    ReversableString.setup(string)
+    assert_equal [], string.annotation_list_empty
+    assert_equal [], string.annotation_list_empty
+  end
+
+  def test_persist_multiple_annotations
+    string1 = 'aaabbbccc'
+    string2 = 'AAABBBCCC'
+    string3 = 'AAABBBCCC_3'
+    string4 = 'AAABBBCCC_4'
+
+
+    $processed_multiple = []
+
+    array = ReversableString.setup([string1, string2])
+    assert_equal [string1, string2].collect{|s| s.chars}, array.multiple_annotation_list
+    assert_equal string1.length, array[0].multiple_annotation_list.length
+    assert_equal [string1, string2], $processed_multiple
+
+    array = ReversableString.setup([string2, string3])
+    assert_equal [string2, string3].collect{|s| s.chars}, array.multiple_annotation_list
+    assert_equal string3, array.multiple_annotation_list.last * ""
+    assert_equal [string1, string2, string3], $processed_multiple
+
+    $processed_multiple = []
+    array = ReversableString.setup([string2, string3])
+    assert_equal [string2, string3].collect{|s| s.chars}, array.multiple_annotation_list
+    assert_equal string2.length, array[0].multiple_annotation_list.length
+    assert_equal [], $processed_multiple
+
+    $processed_multiple = []
+    array = ReversableString.setup([string2, string3, string4])
+    assert_equal string2.length, array.multiple_annotation_list[0].length
+    assert_equal [string4], $processed_multiple
+
+    string1 = 'aaabbbccc'
+    string2 = 'AAABBBCCC'
+    string3 = 'AAABBBCCC_3'
+    string4 = 'AAABBBCCC_4'
+
+    $processed_multiple = []
+    array = ReversableString.setup([string2, string3, string4])
+    assert_equal string2.length, array[0].multiple_annotation_list.length
+    assert_equal $processed_multiple, []
+
+  end
+
+  def test_clean_annotations
+
+    string = "test_string"
+    ReversableString.setup string
+    assert string.respond_to?(:reverse_text_single)
+    assert ! string.purge.respond_to?(:reverse_text_single)
+
+  end
+
+  def test_all_properties
+    assert ReversableString.setup("TEST").all_properties.include?(:reverse_text_ary)
+    assert_equal ReversableString.setup("TEST").all_properties, ReversableString.properties
+  end
+
+  def test_times
+    assert_equal ["TEST", "TEST"], ReversableString.setup("TEST").times(2)
+  end
+end
+

data/test/scout/{tsv/persist → persist/engine}/test_fix_width_table.rb

@@ -1,7 +1,6 @@
 require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
 require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
 
-require 'scout/tsv'
 class TestFixWidthTable < Test::Unit::TestCase
   def load_data(data)
     tsv = TSV.open(data, type: :list, :sep=>":", :cast => proc{|e| e =~ /(\s*)(_*)/; ($1.length..($1.length + $2.length - 1))})