rbbt-util 3.2.1 → 4.0.0

data/test/rbbt/util/test_workflow.rb

@@ -1,135 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/util/workflow'
-
-module MathWF
-  extend WorkFlow
-  self.tasks[:input] = Task.new(:input, :marshal, :value) do |value| value end
-  self.tasks[:add_1] = Task.new(:add_1, :marshal) do input + 1 end
-  self.tasks[:add_1].dependencies << tasks[:input]
-  self.tasks[:times_2] = Task.new(:times_2, :marshal) do input * 2 end
-  self.tasks[:times_2].dependencies << tasks[:add_1]
-  self.tasks[:times_4] = Task.new(:times_4, :marshal) do input * 4 end
-  self.tasks[:times_4].dependencies << tasks[:add_1]
-  self.tasks.each do |name, task| task.workflow = self end
-end
-
-
-module MathWF2
-  def mult(num, t)
-    num * t
-  end
-
-  extend WorkFlow
-
-
-  task_option :value
-  task :input => :integer do |value| value end
-
-  task :add_1 => :integer do input + 1 end
-
-  task :times_2 => :integer do input * 2 end
-
-  task_dependencies :add_1
-  task :times_4 => :integer do input * 4 end
-  
-  task_option :times, "Times to multiply by", :integer, 10
-  task_dependencies :add_1
-  task :times => :integer do |times| mult(input, times) end
-
-  task_dependencies []
-  task :persist do  
-    task.workflow.methods.include?(:local_persist) or
-    task.workflow.methods.include?("local_persist") 
-  end
-end
-
-
-module ConWF
-  extend WorkFlow
-  task :one => :integer do 1 end
-
-  task_dependencies []
-  task :two => :integer do 2 end
-
-  task_option :init, "Initial value", :string
-  task_dependencies  Proc.new{|jobname,run_options| 
-    ConWF.job(run_options[:init].to_sym, jobname, {})
-  }
-  task :times_2 => :integer do 
-    input * 2
-  end
-end
-
-MathWF2.jobdir = Rbbt.tmp.test.jobs.mathwf.find :user
-MathWF.jobdir  = Rbbt.tmp.test.jobs.mathwf.find :user
-ConWF.jobdir   = Rbbt.tmp.test.jobs.mathwf.find :user
-
-class TestWorkFlow < Test::Unit::TestCase
- 
-  def test_math_wf
-    job = MathWF.tasks[:times_2].job(:job1, 1)
-    assert_equal 4, job.recursive_clean.fork.join.load
-    job = MathWF.tasks[:times_4].job(:job1, 1)
-    assert_equal 8, job.recursive_clean.fork.join.load
-  end
-
-  def test_math_wf2
-    job = MathWF2.tasks[:times_2].job(:job1, 1)
-    job.recursive_clean.fork.join
-    assert_equal 4, job.load
-    job = MathWF2.tasks[:times_4].job(:job1, 1)
-    assert_equal 8, job.recursive_clean.fork.join.load
-  end
-
-  def test_math_run
-    job = MathWF2.job(:times_2, :job1, 1)
-    job.recursive_clean.fork.join
-    assert_equal 4, job.load
-  end
-
-  def test_math_defaults
-    assert MathWF2.tasks[:times].option_defaults.include? :times
-
-    job = MathWF2.job(:times, :job1, 1)
-    job.recursive_clean.fork.join
-    assert job.done?
-    puts job.messages
-    assert File.exists? job.path
-    assert_equal 20, job.load
-
-
-    job = MathWF2.job(:times, :job1, 1, :times => 20)
-    job.recursive_clean.fork.join
-    assert_equal 40, job.load
-  end
-
-  def test_recursive_clean
-    job = MathWF2.job(:times, :job1, 1, :times => 20)
-    job.fork.join
-    assert File.exists?(job.path)
-    job.clean
-    assert (not File.exists?(job.path))
-    assert File.exists?(job.previous_jobs.first.path)
-    job.recursive_clean
-    assert (not File.exists?(job.previous_jobs.first.path))
-  end
-
-  def test_local_persist
-    MathWF2.job(:persist, :persist).clean
-    assert MathWF2.run(:persist, :persist).load
-  end
-
-  def test_conditional
-    assert_equal 2, ConWF.run(:times_2, "Test", "one").load
-    assert_equal 4, ConWF.run(:times_2, "Test", "two").load
-  end
-
-  def test_option_summary
-   assert MathWF.tasks[:times_2].option_summary.first.first[:name] == :value
-  end
-
-  def test_usage
-    assert  MathWF.tasks[:times_2].usage =~ /^Task:/
-  end
-end
-

data/test/rbbt/util/tsv/test_accessor.rb

@@ -1,150 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../../..', 'test_helper.rb')
-require 'rbbt/util/tsv/accessor'
-require 'rbbt/util/tsv'
-
-class TestTSVAcessor < Test::Unit::TestCase
-
-  def test_zip_fields
-    a = [%w(1 2), %w(a b)]
-    assert_equal a, TSV.zip_fields(TSV.zip_fields(a))
-  end
-
-  def test_values_at
-    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.new(File.open(filename), :list, :sep => /\s+/, :key => "OtherID", :persistence => true)
-      assert_equal "row2", tsv.values_at("Id1", "Id3").last.first 
-    end
-  end
-
-  def test_to_s
-    content =<<-EOF
-#Id	ValueA	ValueB	OtherID
-row1	a|aa|aaa	b	Id1|Id2
-row2	A	B	Id3
-    EOF
-
-    content2 =<<-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.new(File.open(filename), :sep => /\s+/)
-      assert_equal content, tsv.to_s.sub(/^#: [^\n]*\n/s,'')
-    end
-  end
-
-  def test_to_s_ordered
-    content =<<-EOF
-#Id	ValueA	ValueB	OtherID
-row1	a|aa|aaa	b	Id1|Id2
-row2	A	B	Id3
-    EOF
-
-    content2 =<<-EOF
-#Id	ValueA	ValueB	OtherID
-row2	A	B	Id3
-row1	a|aa|aaa	b	Id1|Id2
-    EOF
-
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/)
-      assert_equal content, tsv.to_s(%w(row1 row2)).sub(/^#: [^\n]*\n/s,'')
-      assert_not_equal content, tsv.to_s(%w(row2 row1)).sub(/^#: [^\n]*\n/s,'')
-      assert_equal content2, tsv.to_s(%w(row2 row1)).sub(/^#: [^\n]*\n/s,'')
-    end
-  end
-
-  def test_field_compare
-     content =<<-EOF
-#Id    Letter:LetterValue    Other:LetterValue    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.new(filename + '#:sep=/\s+/')
-
-      assert tsv.fields.include?("LetterValue")
-    end
-  end
-
-  def test_indentify_fields
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :double, :sep => /\s/)
-      assert_equal :key, tsv.identify_field("ID")
-    end
-  end
-
-  def test_named_fields
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :double, :sep => /\s/)
-
-      assert_equal "ValueA", tsv.fields["ValueA"]
-    end
-  end
-
-  def test_namespace
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :double, :sep => /\s/, :namespace => "TEST")
-
-      assert_equal "TEST", tsv.fields.first.namespace
-      assert_equal "TEST", tsv.key_field.namespace
-    end
-  end
-
-  def test_delete
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :double, :sep => /\s/)
-      tsv.delete "row1"
-      
-      assert_equal 1, tsv.size
-      assert_equal ["row2"], tsv.keys
-
-      tsv = TSV.new(File.open(filename), :double, :sep => /\s/, :persistence => true)
-      assert_equal 2, tsv.size
-      assert_equal ["row1", "row2"], tsv.keys
-      tsv.write
-      tsv.delete "row1"
-      tsv.read
-
-      assert_equal 1, tsv.size
-      assert_equal ["row2"], tsv.keys
-    end
-  end
-
-end
-

data/test/rbbt/util/tsv/test_index.rb

@@ -1,241 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../../..', 'test_helper.rb')
-require 'rbbt/util/tsv'
-require 'rbbt/util/tsv/index'
-
-class TestTSVManipulate < Test::Unit::TestCase
-
-  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.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :persistence => false)
-      index = tsv.index(:case_insensitive => true, :persistence => true)
-      assert index["row1"].include? "Id1"
-      assert_equal "OtherID", index.fields.first
-    end
-
-#    TmpFile.with_file(content) do |filename|
-#      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID")
-#      index = tsv.index(:case_insensitive => true)
-#      assert index["row1"].include? "Id1"
-#      assert_equal "OtherID", index.fields.first
-#    end
-  end
-
-  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.new(File.open(filename), :sep => /\s+/)
-      index = tsv.index(:case_insensitive => true, :target => 2)
-      assert index["row1"].include? "Id1"
-    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.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :persistence => true)
-      index = tsv.index(:case_insensitive => false, :order => true, :persistence => true)
-      assert_equal "Id1", index['a'].first
-      assert_equal "Id3", index['A'].first
-      assert_equal "OtherID", index.fields.first
-    end
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID")
-      index = tsv.index(:case_insensitive => true)
-      assert index["row1"].include? "Id1"
-      assert_equal "OtherID", index.fields.first
-    end
-  end
-
-  #{{{ Test Attach
-
-  def test_smart_merge_single
-    content1 =<<-EOF
-#: :case_insensitive=false
-#Id    ValueA    ValueB
-row1    a|aa|aaa    b
-row2    A    B
-    EOF
-
-    content2 =<<-EOF
-#: :case_insensitive=false
-#ValueC    ValueB    OtherID
-c|cc|ccc    b    Id1|Id2
-C    B    Id3
-    EOF
-
-    tsv1 = tsv2 = nil
-    TmpFile.with_file(content1) do |filename|
-      tsv1 = TSV.new(File.open(filename), :double, :sep => /\s+/)
-    end
-
-    TmpFile.with_file(content2) do |filename|
-      tsv2 = TSV.new(File.open(filename), :double, :sep => /\s+/)
-    end
-
-    tsv1 = tsv1.smart_merge tsv2, "ValueB"
-
-    assert_equal "C", tsv1["row2"]["ValueC"].first
-    assert %w(c cc ccc).include? tsv1["row1"]["ValueC"].first
-    assert_equal %w(Id1 Id2), tsv1["row1"]["OtherID"].sort
-  end
-
-  def test_index_to_key
-     content =<<-EOF
-#: :sep=/\\s+/
-#Id    ValueA    ValueB
-row1    a|aa|aaa    b
-row2    A    B
-    EOF
-
-    tsv1 = tsv2 = nil
-    TmpFile.with_file(content) do |filename|
-      tsv1 = TSV.new(File.open(filename), :double, :sep => /\s+/, :key => "ValueA", :case_insensitive =>  true)
-    end
-  end
-
-  # {{{ Test sorted index
-
-  def load_data(data)
-    Log.debug("Data:\n#{Open.read(data)}")
-    tsv = TSV.new(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_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.new(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.new(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
-#ID:Range
-#:012345678901234567890
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      tsv = load_data(datafile)
-      f   = tsv.range_index("Start", "End")
-
-      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
-#ID:Range
-#:012345678901234567890
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      TmpFile.with_file(load_data(datafile)) 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
-
-  def test_range_index_persistent_with_filter
-    data =<<-EOF
-#ID:Range
-#:012345678901234567890
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      TmpFile.with_file(load_data(datafile)) do |tsvfile|
-        f = TSV.range_index(tsvfile, "Start", "End", :filters => [["field:Start", "3"]])
-
-        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
-