miga-base 0.7.4.0 → 0.7.5.0

data/test/tax_dist_test.rb

@@ -2,7 +2,6 @@ require 'test_helper'
 require 'miga/tax_dist'
 
 class TaxDistTest < Test::Unit::TestCase
-
   def test_aai_path
     assert_path_exist(MiGA::TaxDist.aai_path(:intax))
     assert_path_exist(MiGA::TaxDist.aai_path(:novel))
@@ -54,5 +53,4 @@ class TaxDistTest < Test::Unit::TestCase
     close_intax = MiGA::TaxDist.aai_taxtest(99.0, :intax, engine: :blast)
     assert_equal(:s, close_intax[:probably][0])
   end
-
 end

data/test/tax_index_test.rb

@@ -1,7 +1,9 @@
 require 'test_helper'
+require 'miga'
 require 'miga/tax_index'
 
 class TaxIndexTest < Test::Unit::TestCase
+  include TestHelper
 
   def test_initialization
     ti = MiGA::TaxIndex.new
@@ -9,12 +11,8 @@ class TaxIndexTest < Test::Unit::TestCase
   end
 
   def test_dataset
-    $tmp = Dir.mktmpdir
-    ENV['MIGA_HOME'] = $tmp
-    FileUtils.touch(File.expand_path('.miga_rc', ENV["MIGA_HOME"]))
-    FileUtils.touch(File.expand_path('.miga_daemon.json', ENV["MIGA_HOME"]))
-    p = MiGA::Project.new(File.expand_path('project1', $tmp))
-    d = p.add_dataset('dataset1')
+    initialize_miga_home
+    d = dataset
 
     ti = MiGA::TaxIndex.new
     assert_empty(ti.datasets)
@@ -24,9 +22,6 @@ class TaxIndexTest < Test::Unit::TestCase
     ti << d
     assert_equal(1, ti.datasets.size, 'index should have one dataset')
     assert_equal(1, ti.root.datasets_count)
-  ensure
-    FileUtils.rm_rf $tmp
-    ENV["MIGA_HOME"] = nil
   end
 
   def test_to_json
@@ -40,5 +35,4 @@ class TaxIndexTest < Test::Unit::TestCase
     ti = MiGA::TaxIndex.new
     assert_equal("root:biota: 0\n", ti.to_tab)
   end
-
 end

data/test/taxonomy_test.rb

@@ -2,7 +2,6 @@ require 'test_helper'
 require 'miga/taxonomy'
 
 class TaxonomyTest < Test::Unit::TestCase
-
   def test_ranks
     assert_respond_to(MiGA::Taxonomy, :KNOWN_RANKS)
     assert_include(MiGA::Taxonomy.KNOWN_RANKS, :s)
@@ -14,7 +13,7 @@ class TaxonomyTest < Test::Unit::TestCase
   def test_json
     txt = 'k:Fantasia f:Dragonaceae s:Dragonia_azura'
     js = '{"json_class":"MiGA::Taxonomy","str":"' + txt + '"}'
-    tx = JSON.parse(js, {symbolize_names: false, create_additions: true})
+    tx = JSON.parse(js, { symbolize_names: false, create_additions: true })
     assert_equal(MiGA::Taxonomy, tx.class)
     assert_equal('Dragonaceae', tx[:f])
     assert_equal(js, tx.to_json)
@@ -25,7 +24,7 @@ class TaxonomyTest < Test::Unit::TestCase
     tx = MiGA::Taxonomy.new(txt)
     assert_equal(txt, tx.to_s)
     assert_equal(
-      [[:k, 'Fantasia'],[:f, 'Dragonaceae'],[:s, 'Dragonia azura']],
+      [[:k, 'Fantasia'], [:f, 'Dragonaceae'], [:s, 'Dragonia azura']],
       tx.sorted_ranks
     )
     assert_equal('Irrealis', tx.namespace)
@@ -46,7 +45,7 @@ class TaxonomyTest < Test::Unit::TestCase
   end
 
   def test_init_methods
-    tx = MiGA::Taxonomy.new({k: 'Mascot', c: 'Cereal', s: 'Melvin'})
+    tx = MiGA::Taxonomy.new({ k: 'Mascot', c: 'Cereal', s: 'Melvin' })
     assert_equal('k:Mascot c:Cereal s:Melvin', tx.to_s)
     tx = MiGA::Taxonomy.new('Mascot College Buzz', 'k c s')
     assert_equal('k:Mascot c:College s:Buzz', tx.to_s)
@@ -56,7 +55,7 @@ class TaxonomyTest < Test::Unit::TestCase
   end
 
   def test_rank_order
-    tx = MiGA::Taxonomy.new({k: 'Mascot', s: 'Melvin', c: 'Cereal'})
+    tx = MiGA::Taxonomy.new({ k: 'Mascot', s: 'Melvin', c: 'Cereal' })
     assert_equal([:d, nil], tx.highest(true))
     assert_equal([:k, 'Mascot'], tx.highest)
     assert_equal([:ds, nil], tx.lowest(true))
@@ -65,7 +64,7 @@ class TaxonomyTest < Test::Unit::TestCase
 
   def test_alternative
     tx = MiGA::Taxonomy.new('ns:a s:Arnie', nil,
-      ['ns:b s:Bernie','ns:c s:Cornie','s:Darnie'])
+                            ['ns:b s:Bernie', 'ns:c s:Cornie', 's:Darnie'])
     # Fields
     assert_equal('ns:a s:Arnie', tx.to_s)
     assert_equal([[:s, 'Arnie']], tx.sorted_ranks)
@@ -77,7 +76,7 @@ class TaxonomyTest < Test::Unit::TestCase
     assert_equal(3, tx.alternative.size)
     # JSON
     js = tx.to_json
-    tx_js = JSON.parse(js, {symbolize_names: false, create_additions: true})
+    tx_js = JSON.parse(js, { symbolize_names: false, create_additions: true })
     assert_equal(tx.to_s, tx_js.to_s)
     assert_equal(tx.alternative(2).to_s, tx_js.alternative(2).to_s)
     assert_equal(tx.alternative.size, tx_js.alternative.size)
@@ -94,7 +93,7 @@ class TaxonomyTest < Test::Unit::TestCase
 
   def test_reset
     tx = MiGA::Taxonomy.new('ns:Letters d:Latin s:A', nil,
-      ['ns:Words d:English s:A', 'ns:Music d:Tone s:A'])
+                            ['ns:Words d:English s:A', 'ns:Music d:Tone s:A'])
     # Reset
     assert_equal(2, tx.alternative.size)
     assert_equal('Letters', tx.namespace)
@@ -112,5 +111,4 @@ class TaxonomyTest < Test::Unit::TestCase
     tx.add_alternative(MiGA::Taxonomy.new('ns:Letters d:Unicode s:A'))
     assert_equal('ns:Letters d:Unicode s:A', tx.to_s)
   end
-
 end

data/test/test_helper.rb

@@ -11,7 +11,6 @@ require 'stringio'
 # Kernel extensions tp capture +$stdout+ and +$stderr+ based on
 # http://thinkingdigitally.com/archive/capturing-output-from-puts-in-ruby/
 module Kernel
-
   def capture_stdout
     out = StringIO.new
     $stdout = out
@@ -29,5 +28,47 @@ module Kernel
   ensure
     $stderr = STDERR
   end
+end
 
+module TestHelper
+  def teardown
+    @tmpdir ||= nil
+    FileUtils.rm_rf tmpdir unless @tmpdir.nil?
+    ENV['MIGA_HOME'] = nil
+  end
+
+  def declare_remote_access
+    omit_if(ENV['REMOTE_TESTS'].nil?, 'Remote access is error-prone')
+  end
+
+  def declare_forks
+    omit_if(!ENV['JRUBY_TESTS'].nil?, 'JRuby doesn\'t implement fork')
+  end
+
+  def tmpdir
+    @tmpdir ||= Dir.mktmpdir
+  end
+
+  def tmpfile(name)
+    File.join(tmpdir, name)
+  end
+
+  def initialize_miga_home(daemon = '{}')
+    ENV['MIGA_HOME'] = tmpdir
+    FileUtils.touch(File.join(ENV['MIGA_HOME'], '.miga_rc'))
+    File.open(File.join(ENV['MIGA_HOME'], '.miga_daemon.json'), 'w') do |fh|
+      fh.puts daemon
+    end
+  end
+
+  def project(i = 0)
+    @project ||= {}
+    i = "project#{i}" unless i.is_a? String
+    @project[i] ||= MiGA::Project.new(tmpfile(i))
+  end
+
+  def dataset(project_i = 0, n = 0)
+    n = "dataset#{n}" unless n.is_a? String
+    project(project_i).dataset(n) || project(project_i).add_dataset(n)
+  end
 end

data/test/with_daemon_test.rb

@@ -2,15 +2,7 @@ require 'test_helper'
 require 'miga/common/with_daemon'
 
 class WithDaemonTest < Test::Unit::TestCase
-
-  def setup
-    $jruby_tests = !ENV['JRUBY_TESTS'].nil?
-    $tmp = Dir.mktmpdir
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-  end
+  include TestHelper
 
   class TestWithDaemon < MiGA::MiGA
     include MiGA::Common::WithDaemon
@@ -40,7 +32,7 @@ class WithDaemonTest < Test::Unit::TestCase
       puts(*o)
     end
   end
-  
+
   class TestWithDaemon2 < TestWithDaemon
     def daemon_loop
       puts 'I am 2.0!'
@@ -54,20 +46,20 @@ class WithDaemonTest < Test::Unit::TestCase
   end
 
   def test_with_daemon
-    d = TestWithDaemon.new($tmp)
+    d = TestWithDaemon.new(tmpdir)
     assert_respond_to(d, :pid_file)
     assert_respond_to(d.class, :daemon_home)
     assert_nil(d.loop_i)
   end
 
   def test_daemon_run
-    d = TestWithDaemon2.new($tmp)
+    d = TestWithDaemon2.new(tmpdir)
     capture_stdout { d.run }
     assert_path_not_exist(d.pid_file)
   end
 
   def test_daemmon_status
-    d = TestWithDaemon.new($tmp)
+    d = TestWithDaemon.new(tmpdir)
     out = capture_stdout { d.status }.string
     assert_match(/Not running/, out)
 
@@ -84,11 +76,11 @@ class WithDaemonTest < Test::Unit::TestCase
   end
 
   def test_daemon_operations
-    d = TestWithDaemon.new($tmp)
+    d = TestWithDaemon.new(tmpdir)
     FileUtils.touch(d.output_file)
     assert_not_predicate(d, :active?)
 
-    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
+    declare_forks
     capture_stdout do
       pid = d.start
       assert_gt(pid, 0)
@@ -112,7 +104,7 @@ class WithDaemonTest < Test::Unit::TestCase
   end
 
   def test_termination_file
-    d = TestWithDaemon2.new($tmp)
+    d = TestWithDaemon2.new(tmpdir)
     assert { !d.termination_file?(nil) }
     FileUtils.touch(d.terminate_file)
     err = capture_stdout do
@@ -124,19 +116,19 @@ class WithDaemonTest < Test::Unit::TestCase
   end
 
   def test_process_alive
-    d = TestWithDaemon2.new($tmp)
+    d = TestWithDaemon2.new(tmpdir)
     assert { d.process_alive?(Process.pid) }
     assert { !d.process_alive?(1e9) }
   end
 
   def test_declare_alive_loop
-    d = TestWithDaemon.new(File.join($tmp, 'nope'))
+    d = TestWithDaemon.new(tmpfile('nope'))
     assert_equal(:no_home, d.declare_alive_loop)
 
-    d = TestWithDaemon.new($tmp)
+    d = TestWithDaemon.new(tmpdir)
     assert_equal(:no_process_alive, d.declare_alive_loop(1e9))
 
-    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
+    declare_forks
     FileUtils.touch(d.terminate_file)
     child = fork { sleep(3) }
     capture_stdout do
@@ -145,12 +137,12 @@ class WithDaemonTest < Test::Unit::TestCase
   end
 
   def test_write_alive_file
-    d = TestWithDaemon.new(File.join($tmp, 'nope'))
+    d = TestWithDaemon.new(tmpfile('nope'))
     assert_not_predicate(d, :active?)
     assert_raise { d.write_alive_file }
     assert_not_predicate(d, :active?)
 
-    d = TestWithDaemon.new($tmp)
+    d = TestWithDaemon.new(tmpdir)
     assert_not_predicate(d, :active?)
     d.write_alive_file
     assert_predicate(d, :active?)

data/utils/cleanup-databases.rb

@@ -10,23 +10,24 @@ p = MiGA::Project.load(ARGV[0])
 ds_names = p.dataset_names
 thr = ARGV[1].to_i
 
-pc = [0] + (1 .. 100).map{ |i| ds_names.size * i / 100 }
-$stderr.puts (('.'*9 + '|')*10) + ' 100%'
+pc = [0] + (1..100).map { |i| ds_names.size * i / 100 }
+$stderr.puts (('.' * 9 + '|') * 10) + ' 100%'
 
-(0 .. thr-1).each do |t|
+(0..thr - 1).each do |t|
   fork do
     ds_names.each_with_index do |i, idx|
-      while t == 0 and idx+1 > pc.first
+      while t == 0 and idx + 1 > pc.first
         $stderr.print '#'
         pc.shift
       end
       next unless (idx % thr) == t
+
       d = p.dataset(i)
       next unless d.is_ref? and d.is_active?
+
       d.cleanup_distances!
     end
   end
 end
 Process.waitall
 $stderr.puts ' Done'
-

data/utils/distance/base.rb

@@ -1,4 +1,3 @@
-
 require 'miga'
 require 'miga/tax_dist'
 

data/utils/distance/commands.rb

@@ -1,12 +1,13 @@
-
 module MiGA::DistanceRunner::Commands
   # Estimates or calculates AAI against +target+
   def aai(target)
     # Check if the request makes sense
     return nil if target.nil? || target.result(:essential_genes).nil?
+
     # Check if it's been calculated
     y = stored_value(target, :aai)
     return y unless y.nil? || y.zero?
+
     # Try hAAI (except in clade projects)
     unless @ref_project.is_clade?
       y = haai(target)
@@ -14,24 +15,27 @@ module MiGA::DistanceRunner::Commands
     end
     # Full AAI
     aai_cmd(
-          tmp_file('proteins.fa'), target.result(:cds).file_path(:proteins),
-          dataset.name, target.name, tmp_dbs[:aai]).tap{ checkpoint :aai }
+      tmp_file('proteins.fa'), target.result(:cds).file_path(:proteins),
+      dataset.name, target.name, tmp_dbs[:aai]
+    ).tap { checkpoint :aai }
   end
 
   ##
   # Estimates AAI against +target+ using hAAI
   def haai(target)
     return nil if opts[:haai_p] == 'no'
+
     haai = aai_cmd(tmp_file('ess_genes.fa'),
-          target.result(:essential_genes).file_path(:ess_genes),
-          dataset.name, target.name, tmp_dbs[:haai],
-          aai_save_rbm: 'no-save-rbm', aai_p: opts[:haai_p])
+                   target.result(:essential_genes).file_path(:ess_genes),
+                   dataset.name, target.name, tmp_dbs[:haai],
+                   aai_save_rbm: 'no-save-rbm', aai_p: opts[:haai_p])
     checkpoint :haai
     return nil if haai.nil? || haai.zero? || haai > 90.0
-    aai = 100.0 - Math.exp(2.435076 + 0.4275193*Math.log(100.0-haai))
+
+    aai = 100.0 - Math.exp(2.435076 + 0.4275193 * Math.log(100.0 - haai))
     SQLite3::Database.new(tmp_dbs[:aai]) do |conn|
       conn.execute 'insert into aai values(?, ?, ?, 0, 0, 0)',
-            [dataset.name, target.name, aai]
+                   [dataset.name, target.name, aai]
     end
     checkpoint :aai
     aai
@@ -44,13 +48,16 @@ module MiGA::DistanceRunner::Commands
     t = tmp_file('largecontigs.fa')
     r = target.result(:assembly)
     return nil if r.nil? || !File.size?(t)
+
     # Check if it's been calculated
     y = stored_value(target, :ani)
     return y unless y.nil? || y.zero?
+
     # Run it
     ani_cmd(
-        t, r.file_path(:largecontigs),
-        dataset.name, target.name, tmp_dbs[:ani]).tap{ checkpoint :ani }
+      t, r.file_path(:largecontigs),
+      dataset.name, target.name, tmp_dbs[:ani]
+    ).tap { checkpoint :ani }
   end
 
   ##
@@ -74,7 +81,7 @@ module MiGA::DistanceRunner::Commands
 
   ##
   # Execute an ANI command
-  def ani_cmd(f1, f2, n1, n2, db, o={})
+  def ani_cmd(f1, f2, n1, n2, db, o = {})
     o = opts.merge(o)
     v = nil
     if o[:ani_p] == 'fastani'
@@ -83,7 +90,7 @@ module MiGA::DistanceRunner::Commands
       unless out.empty?
         SQLite3::Database.new(db) do |conn|
           conn.execute 'insert into ani values(?, ?, ?, 0, ?, ?)',
-                [n1, n2, out[2], out[3], out[4]]
+                       [n1, n2, out[2], out[3], out[4]]
         end
       end
       v = out[2]

data/utils/distance/database.rb

@@ -1,4 +1,3 @@
-
 require 'sqlite3'
 
 module MiGA::DistanceRunner::Database
@@ -9,7 +8,7 @@ module MiGA::DistanceRunner::Database
     @dbs = {}
     @tmp_dbs = {}
     @db_counts = {}
-    {haai: :aai, aai: :aai, ani: :ani}.each do |m, t|
+    { haai: :aai, aai: :aai, ani: :ani }.each do |m, t|
       @db_counts[m] = 0
       @dbs[m] = for_ref ? ref_db(m) : query_db(m)
       # Remove if corrupt
@@ -25,9 +24,9 @@ module MiGA::DistanceRunner::Database
       # Initialize if it doesn't exist
       SQLite3::Database.new(dbs[m]) do |conn|
         conn.execute "create table if not exists #{t}(" +
-            "seq1 varchar(256), seq2 varchar(256), " +
-            "#{t} float, sd float, n int, omega int" +
-          ")"
+                     "seq1 varchar(256), seq2 varchar(256), " +
+                     "#{t} float, sd float, n int, omega int" +
+                     ")"
       end unless File.size? dbs[m]
       # Copy over to (local) temporals
       @tmp_dbs[m] = tmp_file("#{m}.db")
@@ -38,16 +37,17 @@ module MiGA::DistanceRunner::Database
   ##
   # Path to the database +metric+ for +dataset_name+ in +project+
   # (assumes that +dataset_name+ is a reference dataset)
-  def ref_db(metric, dataset_name=nil)
+  def ref_db(metric, dataset_name = nil)
     dataset_name ||= dataset.name
-    b = case metric
-    when :haai
-      "01.haai/#{dataset_name}.db"
-    when :aai
-      "02.aai/#{dataset_name}.db"
-    when :ani
-      "03.ani/#{dataset_name}.db"
-    end
+    b =
+      case metric
+      when :haai
+        "01.haai/#{dataset_name}.db"
+      when :aai
+        "02.aai/#{dataset_name}.db"
+      when :ani
+        "03.ani/#{dataset_name}.db"
+      end
     File.expand_path(b, home)
   end
 
@@ -63,13 +63,14 @@ module MiGA::DistanceRunner::Database
   def stored_value(target, metric)
     # Check if self.dataset -> target is done (previous run)
     y = value_from_db(dataset.name, target.name, tmp_dbs[metric], metric)
-    return y unless y.nil? or y.zero?
+    return y unless y.nil? || y.zero?
 
     # Check if self.dataset <- target is done (another thread)
-    if dataset.is_ref? and project.path == ref_project.path
+    if dataset.is_ref? && project.path == ref_project.path
       y = data_from_db(
-        target.name, dataset.name, ref_db(metric, target.name), metric)
-      unless y.nil? or y.first.nil? or y.first.zero?
+        target.name, dataset.name, ref_db(metric, target.name), metric
+      )
+      unless y.nil? || y.first.nil? || y.first.zero?
         # Store a copy
         data_to_db(dataset.name, target.name, tmp_dbs[metric], metric, y)
         return y.first
@@ -94,7 +95,8 @@ module MiGA::DistanceRunner::Database
     SQLite3::Database.new(db) do |conn|
       y = conn.execute(
         "select #{metric}, sd, n, omega from #{metric} where seq1=? and seq2=?",
-        [n1, n2]).first
+        [n1, n2]
+      ).first
     end if File.size? db
     y
   end
@@ -105,7 +107,8 @@ module MiGA::DistanceRunner::Database
     SQLite3::Database.new(db) do |conn|
       conn.execute(
         "insert into #{metric} (seq1, seq2, #{metric}, sd, n, omega) " +
-        "values (?, ?, ?, ?, ?, ?)", [n1, n2] + data)
+        "values (?, ?, ?, ?, ?, ?)", [n1, n2] + data
+      )
     end
     checkpoint metric
   end
@@ -114,7 +117,7 @@ module MiGA::DistanceRunner::Database
   # Iterates for each entry in +db+
   def foreach_in_db(db, metric, &blk)
     SQLite3::Database.new(db) do |conn|
-      conn.execute("select * from #{metric}").each{ |r| blk[r] }
+      conn.execute("select * from #{metric}").each { |r| blk[r] }
     end
   end
 end