rbbt-util 3.2.1 → 4.0.0

data/lib/rbbt/util/workflow.rb

@@ -1,135 +0,0 @@
-require 'rbbt/util/resource'
-require 'rbbt/util/task'
-require 'rbbt/util/persistence'
-require 'rbbt/util/misc'
-
-module WorkFlow
-
-  def self.require_workflow(wf_name, wf_dir = nil)
-
-    if File.exists? wf_name
-      require "./workflow.rb"
-      return
-    end
-
-    wf_dir ||= case
-               when File.exists?(File.join(File.dirname(Resource.caller_lib_dir), wf_name))
-                 File.join(File.dirname(Resource.caller_lib_dir), wf_name)
-               when defined? Rbbt
-                 if Rbbt.pkg.etc.workflow_dir.exists?
-                   File.join(pkg.etc.workflow_dir.read.strip, wf_name)
-                 else
-                   Rbbt.workflows[wf_name]
-                 end
-               else
-                 File.join(ENV["HOME"], '.workflows')
-               end
-
-    wf_dir = Resource::Path.path(wf_dir)
-    $LOAD_PATH.unshift(File.join(File.dirname(wf_dir["workflow.rb"].find), 'lib'))
-    require wf_dir["workflow.rb"].find
-  end
-
-  def self.extended(base)
-    class << base
-      attr_accessor :tasks, :jobdir, :dangling_options, :dangling_option_descriptions,
-        :dangling_option_types, :dangling_option_defaults, :dangling_dependencies, :last_task
-    end
-
-    base.extend Resource
-    base.lib_dir = Resource.caller_base_dir if base.class == Object
-    base.tasks = {}
-    base.tasks.extend IndiferentHash
-    base.jobdir = (File.exists?(base.var.find(:lib)) ? base.var.find(:lib) : base.var.find)
-    base.clear_dangling
-  end
-
-  def tasks=(tasks)
-    tasks.extend IndiferentHash
-    @tasks = tasks
-  end
-
-  def local_persist(*args, &block)
-    argsv = *args
-    options = argsv.pop
-    if Hash === options
-      options.merge!(:persistence_dir => cache.find(:lib))
-      argsv.push options
-    else
-      argsv.push options
-      argsv.push({:persistence_dir => cache.find(:lib)})
-    end
-    Persistence.persist(*argsv, &block)
-  end
-
-  def clear_dangling
-    @dangling_options = []
-    @dangling_option_descriptions = {}
-    @dangling_option_types = {} 
-    @dangling_option_defaults = {}
-    @dangling_dependencies = nil
-    @dangling_description = nil
-  end
-
-  def task_option(*args)
-    name, description, type, default = *args
-    @dangling_options << name if name
-    @dangling_option_descriptions[name] = description if description
-    @dangling_option_types[name] = type if type
-    @dangling_option_defaults[name] = default if default
-  end
-
-  def task_dependencies(*dependencies)
-    dependencies = dependencies.flatten
-    @dangling_dependencies = dependencies.collect{|dep| Symbol === dep ? tasks[dep] : dep }
-  end
-
-  def task_description(description)
-    @dangling_description = description
-  end
-
-  def process_dangling
-    res = [ 
-      @dangling_options, 
-      Misc.merge2hash(@dangling_options, @dangling_option_descriptions.values_at(*@dangling_options)),
-      Misc.merge2hash(@dangling_options, @dangling_option_types.values_at(*@dangling_options)),
-      Misc.merge2hash(@dangling_options, @dangling_option_defaults.values_at(*@dangling_options)),
-      (@dangling_dependencies || [@last_task]).compact,
-      @dangling_description,
-    ]
-
-    clear_dangling
-    res
-  end
-
-  def task(name, &block)
-    if Hash === name
-      persistence = name.values.first
-      name        = name.keys.first
-    else
-      persistence = :marshal
-    end
-
-    options, option_descriptions, option_types, option_defaults, dependencies, description = process_dangling
-    option_descriptions.delete_if do |k,v| v.nil? end
-    option_types.delete_if do |k,v| v.nil? end
-    option_defaults.delete_if do |k,v| v.nil? end
-    task = Task.new name, persistence, options, option_descriptions, option_types, option_defaults, self, dependencies, self, description, &block
-    tasks[name] = task
-    @last_task = task
-  end
-
-  def job(task, jobname = "Default", *args)
-    raise "Task '#{ task }' unkown" if tasks[task].nil?
-    tasks[task].job(jobname, *args)
-  end
-
-  def run(*args)
-    job(*args).run
-  end
-
-  def load_job(taskname, job_id)
-    tasks[taskname].load(job_id)
-  end
-
-end

data/lib/rbbt/util/workflow/soap.rb

@@ -1,116 +0,0 @@
-require 'simplews'
-require 'rbbt/util/workflow'
-require 'base64'
-
-class WorkFlowWS < SimpleWS
-
-  def self.klass=(klass)
-    @klass = klass
-  end
-
-  def self.klass
-    @klass || self
-  end
-
-  def task(name)
-    self.class.klass.tasks[name]
-  end
-
-  def export(name)
-    task = self.class.klass.tasks[name]
-
-    options, optional_options = task.option_summary
-
-    desc task.description
-    options.each do |option|
-      param_desc option[:name] => option[:description] if option[:description]
-    end
-    param_desc :return => "Job Identifier"
-    option_names = [:name] + options.collect{|option| option[:name]}
-    option_types = Hash[*option_names.zip([ :string] + options.collect{|option| option[:type] || :string}).flatten]
-    serve name, option_names, option_types do |*args|
-      task(name).job(*args).fork.id
-    end
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  serve :abort, %w(task id), {:return => false, :task => :string, :id => :string} do |task, id|
-    task(task).load(id).abort
-    nil
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "Info hash in yaml"
-  serve :info, %w(task id), {:task => :string, :id => :string} do |task, id|
-    Open.read(task(task).load(id).info_file)
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "Step"
-  serve :step, %w(task id), {:task => :string, :id => :string} do |task, id|
-    task(task).load(id).step.to_s
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "True if job is done (error or not)"
-  serve :done, %w(task id), {:return => :boolean, :task => :string, :id => :string} do |task, id|
-    task(task).load(id).done?
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "True if job finished with error. Error message is the last of the messages (see 'messages' method)."
-  serve :error, %w(task id), {:return => :boolean, :task => :string, :id => :string} do |task, id|
-    task(task).load(id).error?
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "Messages"
-  serve :messages, %w(task id), {:return => :array, :task => :string, :id => :string} do |task, id|
-    task(task).load(id).messages
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "Job result in Base64"
-  serve :load, %w(task id), {:return => :binary, :task => :string, :id => :string} do |task, id|
-    Base64.encode64(task(task).load(id).read)
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :return => "File names"
-  serve :files, %w(task id), {:return => :array, :task => :string, :id => :string} do |task, id|
-    task(task).load(id).files
-  end
-
-  param_desc :task => "Task name"
-  param_desc :id   => "Job id"
-  param_desc :file   => "File name"
-  param_desc :return => "File contents in Base64"
-  serve :file, %w(task id file), {:return => :array, :task => :string, :id => :string, :file => :string} do |task, id|
-    Base64.encode64(task(task).load(id).files(file).read)
-  end
-end
-
-
-if __FILE__ == $0
-
-  require 'rbbt/sources/organism/sequence'
-  class SequenceWF < WorkFlowWS
-    self.klass = Organism
-  end
-  
-  wf = SequenceWF.new
-  wf.export :genomic_mutations_to_genes
-  Open.write('/tmp/foo.wsdl', wf.wsdl)
-  wf.start
-end
-
-
-

data/test/rbbt/util/test_persistence.rb

@@ -1,201 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/util/persistence'
-
-class TestPersistence < Test::Unit::TestCase
-
-  def test_string
-    string = "test string"
-    TmpFile.with_file do |f|
-      Persistence.persist("token_file", :Test, :string, :persistence_file => f) do string end
-      assert File.exists? f
-      assert_equal string, Open.read(f)
-
-      FileUtils.rm f
-    end
-  end
-
-  def test_yaml
-    object = [1,2,2]
-    TmpFile.with_file do |f|
-      Persistence.persist("token_file", :Test, :yaml, :persistence_file => f) do object end
-      assert File.exists? f
-      assert_equal object, YAML.load(File.open(f))
-      assert_equal YAML.dump(object), Open.read(f)
-      
-      FileUtils.rm f
-    end
-  end
-
-  def test_marshal
-    object = [1,2,2]
-    TmpFile.with_file do |f|
-      Persistence.persist("token_file", :Test, :marshal, :persistence_file => f) do object end
-      assert File.exists? f
-      assert_equal object, Marshal.load(File.open(f))
-      assert_equal Marshal.dump(object), Open.read(f)
-      
-      FileUtils.rm f
-    end
-  end
-
-  def test_tsv
-    object = {:a => 1, :b => 2}
-    TmpFile.with_file do |f|
-      Persistence.persist("token_file", :Test, :tsv_extra, :persistence_file => f) do 
-        [object, {:fields => ["Number"], :key_field => "Letter", :type => :single, :cast => :to_i, :filename => "foo"}]
-      end
-
-      assert File.exists? f
-      new, extra = Persistence.persist("token_file", :Test, :tsv_extra, :persistence_file => f)
-
-      assert_equal 1, new["a"]
-      assert_equal "Letter", new.key_field
-      
-      FileUtils.rm f
-    end
-  end
-  
-  def test_tsv2
-    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(filename, :sep => /\s+/, :key => "OtherID")
-      tsv2 = Persistence.persist_tsv_string(tsv, 'Test', {}) do tsv end
-      tsv2 = Persistence.persist_tsv_string(tsv, 'Test', {}) do tsv end
-
-      (Object::TSV::EXTRA_ACCESSORS + [:fields, :key_field]).each do |key|
-        assert_equal tsv.send(key), tsv2.send(key)
-      end
-      tsv.each do |key,values|
-        assert_equal values, tsv2[key]
-      end
-    end
-  end
-  
-  def test_tsv3
-    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(filename, :sep => /\s+/, :key => "OtherID")
-      tsv2 = Persistence.persist_tsv(tsv, 'Test', {}) do tsv end
-      tsv2 = Persistence.persist_tsv(tsv, 'Test', {}) do tsv end
-
-      (Object::TSV::EXTRA_ACCESSORS + [:fields, :key_field]).each do |key|
-        assert_equal tsv.send(key), tsv2.send(key)
-      end
-      tsv.each do |key,values|
-        assert_equal values, tsv2[key]
-      end
-    end
-  end
-
-  def test_tsv4
-    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  = Persistence.persist_tsv(filename, 'Test', {}) do TSV.new(filename, :sep => /\s+/, :key => "OtherID") end
-      tsv2 = Persistence.persist_tsv(filename, 'Test', {}) do tsv end
-
-      (Object::TSV::EXTRA_ACCESSORS + [:fields, :key_field]).each do |key|
-        assert_equal tsv.send(key), tsv2.send(key)
-      end
-      tsv.each do |key,values|
-        assert_equal values, tsv2[key]
-      end
-    end
-  end
-
-  def test_integer
-    content =<<-EOF
-#Id    ValueA
-row1   1
-row2   2 
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(filename, :single, :sep => /\s+/, :cast => :to_i, :persistence => true)
-      assert_equal 1, tsv["row1"]
-    end
-  end
-
-  def test_integer
-    content =<<-EOF
-row1   1 2 3 4 5
-row2   2 4 6 8
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(filename, :flat, :sep => /\s+/, :cast => :to_i, :persistence => true)
-      assert_equal [1,2,3,4,5], tsv["row1"]
-    end
-  end
-
-  def test_persist_dir
-    string = Persistence.persist("Test", :Test, :string, :persistence_dir => Rbbt.tmp.test.persistence) do
-      "Test"
-    end
-
-    assert Dir.glob(Rbbt.tmp.test.persistence.find + '*').length == 1
-
-    assert_equal "Test", string
-  end
-
-  def test_non_blocking
-    $a = TSV.new datafile_test('test.tsv'), :persistence => true, :persistence_dir => Rbbt.tmp.test.persistence
-    $a.data.read
-
-    pid = Process.fork do
-      $b = TSV.new datafile_test('test.tsv'), :persistence => true, :persistence_dir => Rbbt.tmp.test.persistence
-      $b.data.close
-    end
-
-    Process.wait pid
-  end
-
-  def test_persist_fwt
-    content =<<-EOF
-#: :sep=/\\s+/
-#Id    Start    End
-row1   1        10
-row2   20       30
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      fwt = Persistence.persist(filename, :Range, :fwt, :persistence_dir => Rbbt.tmp.test.persistence) do
-        fwt = TSV.new(filename).range_index("Start", "End", :persistence => false)
-        assert fwt[15].empty?
-        assert fwt[25].include? "row2"
-        fwt
-      end
-
-      assert fwt[5].include? "row1"
-      assert fwt[(5..25)].include? "row1"
-      assert fwt[(5..25)].include? "row2"
-
-      fwt = Persistence.persist(filename, :Range, :fwt, :persistence_dir => Rbbt.tmp.test.persistence) do
-        assert false
-      end
-
-      assert fwt[5].include? "row1"
-      assert fwt[(5..25)].include? "row1"
-      assert fwt[(5..25)].include? "row2"
- 
-    end
-
-  end
-
-
-end
-