scout-gear 10.3.0 → 10.6.1

data/test/scout/test_association.rb

@@ -0,0 +1,51 @@
+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 TestAssociation < Test::Unit::TestCase
+
+  def test_marriages_simple
+    database = Association.database(datadir_test.person.marriages, :source => "Wife", :target => "Husband")
+    assert_equal "001", database["002"]["Husband"]
+    assert_equal "2021", database["002"]["Date"]
+  end
+
+  def test_marriages_open
+    database = Association.database(datadir_test.person.marriages, :source => "Wife (ID)=>Alias", :target => "Husband (ID)=>Name")
+    assert_equal "Miguel", database["Clei"]["Husband"]
+    assert_equal "2021", database["Clei"]["Date"]
+    assert_include database.key_field, "Alias"
+  end
+
+  def test_marriages_partial_field
+    database = Association.database(datadir_test.person.marriages, :source => "Wife=>Alias", :target => "Husband=>Name")
+    assert_equal "Miguel", database["Clei"]["Husband"]
+    assert_equal "2021", database["Clei"]["Date"]
+    assert_include database.key_field, "Alias"
+    assert_include database.fields.first, "Name"
+  end
+
+  def test_marriages_open_from_tsv
+    database = Association.database(datadir_test.person.marriages.tsv, :source => "Wife (ID)=>Alias", :target => "Husband (ID)=>Name")
+    assert_equal "Miguel", database["Clei"]["Husband"]
+    assert_equal "2021", database["Clei"]["Date"]
+    assert_include database.key_field, "Alias"
+  end
+  
+  def test_brothers_id
+    database = Association.database(datadir_test.person.brothers, :source => "Older=~Older (Alias)=>Name", :target => "Younger=~Younger (Alias)=>ID")
+    assert_equal '001', database["Isabel"]["Younger"]
+  end
+
+  def test_brothers_rename
+    database = Association.database(datadir_test.person.brothers, :source => "Older=~Older (Alias)=>Name")
+    assert_equal "Older (Name)", database.key_field
+  end
+
+  def test_parents_flat
+    tsv = datadir_test.person.parents.tsv type: :flat, fields: ["Parent"]
+    database = Association.database(tsv)
+    assert_equal database["Miki"], %w(Juan Mariluz)
+  end
+end
+

data/test/scout/test_entity.rb

@@ -0,0 +1,40 @@
+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 TestEntity < Test::Unit::TestCase
+
+  setup do
+    Entity.entity_property_cache = tmpdir.property_cache
+  end
+
+  module Person
+    extend Entity
+
+    annotation :language
+
+    property :salutation do
+      case language
+      when 'es'
+        "Hola #{self}"
+      else
+        "Hi #{self}"
+      end
+    end
+  end
+
+  module EmptyEntity
+    extend Entity
+  end
+
+  def test_person
+    person = Person.setup("Miguel", 'es')
+    assert_equal "Hola Miguel", person.salutation
+
+    person.language = 'en'
+    assert_equal "Hi Miguel", person.salutation
+  end
+
+  def test_empty
+    refute EmptyEntity.setup("foo").nil?
+  end
+end

data/test/scout/test_tsv.rb

@@ -2,6 +2,11 @@ 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 TestTSV < Test::Unit::TestCase
+  def test_identifier_file
+    tsv = datadir_test.person.marriages.tsv
+    assert tsv.identifier_files.any?
+  end
+
   def test_open_with_data
     content =<<-'EOF'
 #: :sep=/\s+/#:type=:double#:merge=:concat
@@ -20,7 +25,7 @@ row4    a    a    id3
     EOF
 
     tsv = TmpFile.with_file(content) do |filename|
-      TSV.open(filename, :persist => false)
+      TSV.open(filename)
     end
     
     TmpFile.with_file(content2) do |filename|
@@ -263,7 +268,7 @@ c 3
     end
   end
 
-  def TODO_test_tsv_grep
+  def test_tsv_grep
     content =<<-EOF
 #: :sep=/\\s+/#:type=:single
 #Id Value
@@ -277,8 +282,7 @@ d 22
       tsv = TSV.open(filename, :key_field => "Value", :tsv_grep => "2")
       assert_includes tsv, "2"
       refute_includes tsv, "3"
-      assert(tsv.include?("2"))
-      assert(! tsv.include?("3"))
+      refute_includes tsv, "1"
     end
   end
 
@@ -310,6 +314,9 @@ row2   b  bbb bbbb bb
 
     tsv = TSV.str_setup("ID~ValueA,ValueB#:type=:flat", {})
     assert_equal "ID", tsv.key_field
+
+    tsv = TSV.setup({}, "ID~ValueA,ValueB#:type=:flat")
+    assert_equal "ID", tsv.key_field
   end
 
   def test_cast_in_header
@@ -328,4 +335,56 @@ c 3
       assert_include tsv.to_s, ":cast=:to_f"
     end
   end
+
+  def test_open_persist_parser
+    content =<<-'EOF'
+#: :sep=/\s+/#:type=:double#:merge=:concat
+#Id    ValueA    ValueB    OtherID
+row1    a|aa|aaa    b    Id1|Id2
+row2    A    B    Id3
+row2    a    a    id3
+    EOF
+
+    tsv = TmpFile.with_file(content) do |filename|
+      parser = TSV::Parser.new filename
+      tsv = TSV.open(parser, :persist => true)
+      tsv.close
+      Persist::CONNECTIONS.clear
+      TSV.open(filename, :persist => true)
+    end
+
+    assert_equal "Id", tsv.key_field
+
+    assert tsv.respond_to?(:persistence_class)
+    assert_equal TokyoCabinet::HDB, tsv.persistence_class
+
+    assert_include tsv.keys, 'row1'
+    assert_include tsv.keys, 'row2'
+  end
+
+  def test_to_hash
+    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+/)
+      hash = tsv.to_hash
+      refute TSV === hash
+    end
+  end
+
+  def test_identifiers
+    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+/, :identifiers => Scout.share.identifiers)
+    end
+  end
 end

data/test/scout/test_work_queue.rb

@@ -91,7 +91,7 @@ class TestWorkQueue < Test::Unit::TestCase
 
   def test_queue_error
     5.times do |i|
-      num = 100
+      num = 20
       reps = 10_000
 
       q = WorkQueue.new num do |obj|
@@ -106,8 +106,8 @@ class TestWorkQueue < Test::Unit::TestCase
 
       Log.with_severity 7 do
         t = Thread.new do
-          Thread.current["name"] = "queue writer"
           Thread.current.report_on_exception = false
+          Thread.current["name"] = "queue writer"
           reps.times do |i|
             q.write i
           end
@@ -123,6 +123,7 @@ class TestWorkQueue < Test::Unit::TestCase
             raise $!
           ensure
             t.join
+            q.close
           end
         end
       end

data/test/scout/test_workflow.rb

@@ -6,6 +6,9 @@ class TestWorkflow < Test::Unit::TestCase
   module Pantry
     extend Resource
     self.subdir = 'share/pantry'
+    self.path_maps[:tmp] = TestWorkflow.tmpdir
+    self.path_maps[:default] = :tmp
+    self.map_order = [:tmp]
 
     Pantry.claim Pantry.eggs, :proc do
       Log.info "Buying Eggs in the store"
@@ -24,42 +27,40 @@ class TestWorkflow < Test::Unit::TestCase
   end
 
   module Baking
-    def self.whisk(eggs)
+    extend Workflow
+
+    helper :whisk do |eggs|
       "Whisking eggs from #{eggs}"
     end
 
-    def self.mix(base, mixer)
+    helper :mix do |base, mixer|
       "Mixing base (#{base}) with mixer (#{mixer})"
     end
 
-    def self.bake(batter)
+    helper :bake do |batter|
       "Baking batter (#{batter})"
     end
-  end
-
-  module Baking
-    extend Workflow
 
     dep :prepare_batter
     task :bake_muffin_tray => :string do 
-      Baking.bake(step(:prepare_batter).load)
+      bake(step(:prepare_batter).load)
     end
 
     dep :whisk_eggs
     input :add_bluberries, :boolean
     task :prepare_batter => :string do |add_bluberries|
       whisked_eggs = step(:whisk_eggs).load
-      batter = Baking.mix(whisked_eggs, Pantry.flour.produce)
+      batter = mix(whisked_eggs, Pantry.flour.produce)
 
       if add_bluberries
-        batter = Baking.mix(batter, Pantry.blueberries.produce) 
+        batter = mix(batter, Pantry.blueberries.produce) 
       end
 
       batter
     end
 
     task :whisk_eggs => :string do
-      Baking.whisk(Pantry.eggs.produce)
+      whisk(Pantry.eggs.produce)
     end
   end
 
@@ -78,10 +79,10 @@ class TestWorkflow < Test::Unit::TestCase
   end
 
   def test_baking
-    assert_equal "Baking batter (Mixing base (Mixing base (Whisking eggs from share/pantry/eggs) with mixer (share/pantry/flour)) with mixer (share/pantry/blueberries))",
-      Baking.job(:bake_muffin_tray, :add_bluberries => true).run
-
     assert_equal "Baking batter (Mixing base (Whisking eggs from share/pantry/eggs) with mixer (share/pantry/flour))",
-      Baking.job(:bake_muffin_tray).run
+      Baking.job(:bake_muffin_tray, "Normal muffin").run
+
+    assert_equal "Baking batter (Mixing base (Mixing base (Whisking eggs from share/pantry/eggs) with mixer (share/pantry/flour)) with mixer (share/pantry/blueberries))",
+      Baking.job(:bake_muffin_tray, "Blueberry muffin", :add_bluberries => true).run
   end
 end

data/test/scout/tsv/annotation/test_repo.rb

@@ -0,0 +1,150 @@
+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/annotation'
+
+class TestAnnotationRepo < Test::Unit::TestCase
+  module AnnotationClass
+    extend Annotation
+
+    annotation :code
+  end
+
+  def test_simple_annotation_nil
+
+    TmpFile.with_file do |repo|
+      annotation = Persist.annotation_repo_persist(repo, "My annotation nil") do
+        nil
+      end
+
+      assert_nil annotation
+
+      annotation = assert_nothing_raised do
+        Persist.annotation_repo_persist(repo, "My annotation nil") do
+          raise
+        end
+      end
+
+      assert_nil annotation
+    end
+  end
+
+  def test_simple_annotation_empty
+
+    TmpFile.with_file do |repo|
+      annotation = Persist.annotation_repo_persist(repo, "My annotation nil") do
+        []
+      end
+
+      assert_empty annotation
+
+      annotation = assert_nothing_raised do
+        Persist.annotation_repo_persist(repo, "My annotation nil") do
+          raise
+        end
+      end
+
+      assert_empty annotation
+    end
+  end
+
+
+
+  def test_simple_annotation
+
+    TmpFile.with_file do |repo|
+      annotation = Persist.annotation_repo_persist(repo, "My annotation simple") do
+        AnnotationClass.setup("TESTANNOTATION", code: "test_code")
+      end
+
+      assert_equal "TESTANNOTATION", annotation
+      assert_equal "test_code", annotation.code
+
+      annotation = assert_nothing_raised do
+        Persist.annotation_repo_persist(repo, "My annotation simple") do
+          raise
+        end
+      end
+
+      assert_equal "TESTANNOTATION", annotation
+      assert_equal "test_code", annotation.code
+    end
+  end
+
+  def test_array_with_annotation
+
+    TmpFile.with_file do |repo|
+      annotation = Persist.annotation_repo_persist(repo, "My annotation") do
+        [
+          AnnotationClass.setup("TESTANNOTATION", code: "test_code"),
+          AnnotationClass.setup("TESTANNOTATION2", code: "test_code2")
+        ]
+      end.first
+
+      assert_equal "TESTANNOTATION", annotation
+      assert_equal "test_code", annotation.code
+
+      annotation = assert_nothing_raised do
+        Persist.annotation_repo_persist(repo, "My annotation") do
+          raise
+        end.last
+      end
+
+      assert_equal "TESTANNOTATION2", annotation
+      assert_equal "test_code2", annotation.code
+    end
+  end
+
+  def test_annotation_array
+
+    TmpFile.with_file do |repo|
+      annotation = Persist.annotation_repo_persist(repo, "My annotation array") do
+        a = AnnotationClass.setup(["TESTANNOTATION", "TESTANNOTATION2"], code: "test_code")
+        a.extend AnnotatedArray
+        a
+      end.first
+
+      assert_equal "TESTANNOTATION", annotation
+      assert_equal "test_code", annotation.code
+
+      annotation = assert_nothing_raised do
+        Persist.annotation_repo_persist(repo, "My annotation array") do
+          raise
+        end.last
+      end
+
+      assert_equal "TESTANNOTATION2", annotation
+      assert_equal "test_code", annotation.code
+    end
+  end
+
+  def test_annotation_array_with_fields
+
+    TmpFile.with_file do |repo_file|
+      repo = Persist.open_tokyocabinet(repo_file, false, :list, :BDB)
+      TSV.setup(repo, :fields => ["literal", "annotation_types", "code"], :key_field => "Annotation ID", type: :list)
+      repo.extend TSVAdapter
+
+      annotation = Persist.annotation_repo_persist(repo, "My annotation array") do
+        a = AnnotationClass.setup(["TESTANNOTATION", "TESTANNOTATION2"], code: "test_code")
+        a.extend AnnotatedArray
+        a
+      end.first
+
+      assert_equal "TESTANNOTATION", annotation
+      assert_equal "test_code", annotation.code
+
+      repo = Persist.open_tokyocabinet(repo_file, false, :list, :BDB)
+      annotation2 = assert_nothing_raised do
+        Persist.annotation_repo_persist(repo, "My annotation array") do
+          raise
+        end.last
+      end
+
+      assert_equal "TESTANNOTATION2", annotation2
+      assert_equal "test_code", annotation2.code
+    end
+  end
+end
+

data/test/scout/tsv/change_id/test_translate.rb

@@ -0,0 +1,178 @@
+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 TestTSVTranslate < Test::Unit::TestCase
+  def test_marriage_index
+    marriages = datadir_test.person.marriages.tsv
+    identifiers = datadir_test.person.identifiers.tsv
+    index = TSV.translation_index [marriages, identifiers], "Husband (ID)", "Husband (Name)"
+    assert_equal 'Miguel', index["001"]
+  end
+
+  def test_translate_marriages
+    marriages = datadir_test.person.marriages.tsv
+    marriages = marriages.translate "Husband (ID)", "Husband (Name)"
+    marriages = marriages.translate "Wife (ID)", "Wife (Name)"
+    assert_equal "Cleia", marriages["Miguel"]["Wife"]
+  end
+
+
+  def test_translation_path
+    file_paths = {
+      :file1 => %w(A B C),
+      :file2 => %w(Y Z A),
+      :file3 => %w(Y X),
+      :file4 => %w(X R),
+      :file5 => %w(A R),
+    }
+
+    assert_equal [:file1], TSV.translation_path(file_paths, "C", "A")
+    assert_equal [:file1, :file2], TSV.translation_path(file_paths, "B", "Y")
+    assert_equal [:file1, :file2, :file3], TSV.translation_path(file_paths, "B", "X")
+    assert_equal [:file1, :file5], TSV.translation_path(file_paths, "B", "R")
+  end
+
+  def test_translation_index
+    f1=<<-EOF
+#: :sep=' '
+#A B C
+a b c
+aa bb cc
+    EOF
+
+    f2=<<-EOF
+#: :sep=' '
+#Y Z A
+y z a
+yy zz aa
+    EOF
+
+    f3=<<-EOF
+#: :sep=' '
+#Y X
+y x
+yy xx
+    EOF
+
+    TmpFile.with_file(f1) do |tf1|
+      TmpFile.with_file(f2) do |tf2|
+        TmpFile.with_file(f3) do |tf3|
+          index = TSV.translation_index([tf1, tf2, tf3], 'A', 'X')
+          assert_equal 'x', index['a']
+          assert_equal 'xx', index['aa']
+
+          index = TSV.translation_index([tf1, TSV.open(tf2), tf3], 'A', 'X')
+          assert_equal 'x', index['a']
+          assert_equal 'xx', index['aa']
+
+          index = TSV.translation_index([tf1, TSV.open(tf2), tf3], 'C', 'Y')
+          assert_equal 'y', index['c']
+          assert_equal 'yy', index['cc']
+
+          index = TSV.translation_index([tf1, TSV.open(tf2), tf3], 'Z', 'Y')
+          assert_equal 'y', index['z']
+          assert_equal 'yy', index['zz']
+
+          index = TSV.translation_index([tf1, tf2, tf3], 'X', 'A')
+          assert_equal 'a', index['x']
+          assert_equal 'aa', index['xx']
+        end
+      end
+    end
+  end
+
+  def test_translation_index_no_source
+    f1=<<-EOF
+#: :sep=' '
+#A B C
+a b c
+aa bb cc
+    EOF
+
+    f2=<<-EOF
+#: :sep=' '
+#Y Z A
+y z a
+yy zz aa
+    EOF
+
+    f3=<<-EOF
+#: :sep=' '
+#Y X
+y x
+yy xx
+    EOF
+
+    TmpFile.with_file(f1) do |tf1|
+      TmpFile.with_file(f2) do |tf2|
+        TmpFile.with_file(f3) do |tf3|
+          index = TSV.translation_index([tf2,tf3],nil , 'X')
+          assert_equal 'x', index['a']
+          assert_equal 'xx', index['aa']
+        end
+      end
+    end
+  end
+  def test_translate
+
+    f1=<<-EOF
+#: :sep=' '
+#A B C
+a b c
+aa bb cc
+    EOF
+
+    identifiers=<<-EOF
+#: :sep=' '
+#A X
+a x
+aa xx
+    EOF
+
+    TmpFile.with_file(f1) do |tf1|
+      TmpFile.with_file(identifiers) do |ti|
+        tsv = TSV.open tf1, :identifiers => ti
+
+        assert TSV.translate(tsv, tsv.key_field, "X").include? "x"
+      end
+    end
+  end
+
+  def test_translate_two_files
+
+    f1=<<-EOF
+#: :sep=' '
+#A B C
+a b c
+aa bb cc
+    EOF
+
+    identifiers1=<<-EOF
+#: :sep=' '
+#Y Z A
+y z a
+yy zz aa
+    EOF
+
+    identifiers2=<<-EOF
+#: :sep=' '
+#Y X
+y x
+yy xx
+    EOF
+
+    TmpFile.with_file(f1) do |tf1|
+      TmpFile.with_file(identifiers1) do |ti1|
+        TmpFile.with_file(identifiers2) do |ti2|
+          tsv = TSV.open tf1, :identifiers => [ti1, ti2]
+
+          assert TSV.translate(tsv, tsv.key_field, "X").include? "x"
+        end
+      end
+    end
+  end
+
+end
+

data/test/scout/tsv/test_annotation.rb

@@ -0,0 +1,52 @@
+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 TestAnnotationTSV < Test::Unit::TestCase
+  module AnnotationClass
+    extend Annotation
+
+    annotation :code, :code2
+  end
+
+  def test_tsv
+    str1 = "string1"
+    str2 = "string2"
+    AnnotationClass.setup(str1, :c11, :c12)
+    AnnotationClass.setup(str2, :c21, :c22)
+
+    assert_equal str1, Annotation.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.annotation_id + "#0"]["literal"] 
+    assert_equal :c11, Annotation.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.annotation_id + "#0"]["code"] 
+    assert_equal str2, Annotation.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str2.annotation_id + "#1"]["literal"] 
+    assert_equal :c21, Annotation.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str2.annotation_id + "#1"]["code"] 
+    assert_equal "c11", JSON.parse(Annotation.tsv([str1, str2], :code, :JSON).tap{|t| t.unnamed = false}[str1.annotation_id + "#0"]["JSON"])["code"]
+  end
+
+  def test_load_array_tsv
+    str1 = "string1"
+    str2 = "string2"
+    AnnotationClass.setup(str1, :c11, :c12)
+    AnnotationClass.setup(str2, :c21, :c22)
+
+    tsv = Annotation.tsv([str1, str2], :all)
+
+    list = Annotation.load_tsv(tsv)
+    assert_equal [str1, str2], list
+    assert_equal :c11, list.first.code
+  end
+
+  def test_load_extended_array_tsv
+    str1 = "string1"
+    str2 = "string2"
+    a = [str1, str2]
+    code = "Annotation String 2"
+    AnnotationClass.setup(a, code)
+    a.extend AnnotatedArray
+
+
+    assert_equal code, Annotation.load_tsv(Annotation.tsv(a, :all)).code
+
+    assert_equal str2, Annotation.load_tsv(Annotation.tsv(a, :literal, :JSON)).sort.last
+  end
+end
+