miga-base 1.3.8.2 → 1.3.9.0

data/scripts/read_quality.bash

@@ -19,6 +19,10 @@ for s in 1 2 ; do
 done
 
 # Finalize
-miga date > "$DATASET.done"
-miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f
+miga date > "${DATASET}.done"
+cat <<VERSIONS \
+  | miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f --stdin-versions
+=> MiGA
+$(miga --version)
+VERSIONS
 

data/scripts/ssu.bash

@@ -65,4 +65,22 @@ fi
 
 # Finalize
 miga date > "${DATASET}.done"
-miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f
+cat <<VERSIONS \
+  | miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f --stdin-versions
+=> MiGA
+$(miga --version)
+$(
+  if [[ -s $fa ]] ; then
+    echo "=> barrnap"
+    barrnap --version 2>&1 | perl -pe 's/^barrnap //'
+    echo "=> bedtools"
+    bedtools --version 2>&1 | perl -pe 's/^bedtools //'
+    echo "=> Enveomics Collection"
+    echo "version unknown"
+    echo "=> RDP Naive Bayes Classifier"
+    gzip -cd "${DATASET}.rdp.tsv.gz" | tail -n 1 | perl -pe 's/.*: //'
+    echo "=> tRNAscan-SE"
+    tRNAscan-SE -h 2>&1 | head -n 2 | tail -n 1 | perl -pe 's/^tRNAscan-SE //'
+  fi
+)
+VERSIONS

data/scripts/stats.bash

@@ -12,11 +12,17 @@ cd "$DIR"
 miga date > "${DATASET}.start"
 
 # Calculate statistics
-for i in raw_reads trimmed_fasta assembly cds essential_genes distances taxonomy ssu ; do
+for i in raw_reads trimmed_fasta assembly \
+         cds essential_genes distances taxonomy ssu ; do
   echo "# $i"
   miga stats --compute-and-save --ignore-empty -P "$PROJECT" -D "$DATASET" -r $i
 done
 
 # Finalize
-miga date > "$DATASET.done"
-miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f
+miga date > "${DATASET}.done"
+cat <<VERSIONS \
+  | miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f --stdin-versions
+=> MiGA
+$(miga --version)
+VERSIONS
+

data/scripts/taxonomy.bash

@@ -16,5 +16,101 @@ ruby -I "$MIGA/lib" \
       "$MIGA/utils/distances.rb" "$PROJECT" "$DATASET" run_taxonomy=1
 
 # Finalize
-miga date > "$DATASET.done"
-miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f
+fastaai=no
+aai=no
+ani=no
+blast=no
+blat=no
+diamond=no
+fastani=no
+REF_PROJECT=$(miga option -P "$PROJECT" -k ref_project)
+if [[ -S "$REF_PROJECT" ]] ; then
+  case $(miga option -P "$REF_PROJECT" -k haai_p) in
+    fastaai)
+      fastaai=yes
+      ;;
+    diamond)
+      diamond=yes
+      aai=yes
+      ;;
+    blast)
+      blast=yes
+      aai=yes
+      ;;
+  esac
+
+  case $(miga option -P "$REF_PROJECT" -k aai_p) in
+    diamond)
+      diamond=yes
+      aai=yes
+      ;;
+    blast)
+      blast=yes
+      aai=yes
+      ;;
+  esac
+
+  case $(miga option -P "$REF_PROJECT" -k ani_p) in
+    blast)
+      blast=yes
+      ani=yes
+      ;;
+    blat)
+      blat=yes
+      ani=yes
+    ;;
+  fastani)
+    fastani=yes
+    ;;
+  esac
+fi
+
+miga date > "${DATASET}.done"
+cat <<VERSIONS \
+  | miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f --stdin-versions
+=> MiGA
+$(miga --version)
+$(
+  if [[ "$fastaai" == "yes" ]] ; then
+    echo "=> FastAAI"
+    fastaai version 2>&1 | perl -pe 's/.*=//'
+  fi
+)
+$(
+  if [[ "$fastani" == "yes" ]] ; then
+    echo "=> FastANI"
+    fastANI --version 2>&1 | grep . | perl -pe 's/^version //'
+  fi
+)
+$(
+  if [[ "$aai" == "yes" ]] ; then
+    echo "=> Enveomics Collection: aai.rb"
+    aai.rb --version 2>&1 | perl -pe 's/.*: //'
+  fi
+)
+$(
+  if [[ "$ani" == "yes" ]] ; then
+    echo "=> Enveomics Collection: ani.rb"
+    ani.rb --version 2>&1 | perl -pe 's/.*: //'
+  fi
+)
+$(
+  if [[ "$blast" == "yes" ]] ; then
+    echo "=> NCBI BLAST+"
+    blastp -version 2>&1 | tail -n 1 | perl -pe 's/.*: blast //'
+  fi
+)
+$(
+  if [[ "$blat" == "yes" ]] ; then
+    echo "=> BLAT"
+    blat 2>&1 | head -n 1 | perl -pe 's/.* v\. //' | perl -pe 's/ fast .*//'
+  fi
+)
+$(
+  if [[ "$diamond" == "yes" ]] ; then
+    echo "=> Diamond"
+    diamond --version 2>&1 | perl -pe 's/^diamond version //'
+  fi
+)
+VERSIONS
+

data/scripts/trimmed_fasta.bash

@@ -32,6 +32,14 @@ for x in 1.fasta 2.fasta SingleReads.fa CoupledReads.fa ; do
 done
 
 # Finalize
-miga date > "$DATASET.done"
-miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f
+miga date > "${DATASET}.done"
+cat <<VERSIONS \
+  | miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f --stdin-versions
+=> MiGA
+$(miga --version)
+=> Enveomics Collection: FastQ.maskQual.rb
+$(FastQ.maskQual.rb --version | perl -pe 's/.* //')
+=> Enveomics Collection: FastA.interpose.pl
+version unknown
+VERSIONS
 

data/scripts/trimmed_reads.bash

@@ -36,15 +36,19 @@ if [[ -s "$b.2.fastq.gz" ]] ; then
   $CMD -1 "$b.1.fastq.gz" -2 "$b.2.fastq.gz"
   for s in 1 2 ; do
     mv "$b/${s}.post_trim_${b}.${s}.fq.gz" "${b}.${s}.clipped.fastq.gz"
-    mv "$b/${s}.pre_trim_QC_${b}.${s}.html" "../03.read_quality/${b}.pre.${s}.html"
-    mv "$b/${s}.post_trim_QC_${b}.${s}.html" "../03.read_quality/${b}.post.${s}.html"
+    mv "$b/${s}.pre_trim_QC_${b}.${s}.html" \
+       "../03.read_quality/${b}.pre.${s}.html"
+    mv "$b/${s}.post_trim_QC_${b}.${s}.html" \
+       "../03.read_quality/${b}.post.${s}.html"
   done
 else
   # Unpaired
   $CMD -u "$b.1.fastq.gz"
   mv "$b/unpaired.post_trim_${b}.1.fq.gz" "${b}.1.clipped.fastq.gz"
-  mv "$b/unpaired.pre_trim_QC_${b}.1.html" "../03.read_quality/${b}.pre.1.html"
-  mv "$b/unpaired.post_trim_QC_${b}.1.html" "../03.read_quality/${b}.post.1.html"
+  mv "$b/unpaired.pre_trim_QC_${b}.1.html" \
+     "../03.read_quality/${b}.pre.1.html"
+  mv "$b/unpaired.post_trim_QC_${b}.1.html" \
+     "../03.read_quality/${b}.post.1.html"
 fi
 mv "$b/Subsample_Adapter_Detection.stats.txt" \
   "../03.read_quality/$b.adapters.txt"
@@ -54,6 +58,22 @@ rm -r "$b"
 rm -f "$b".[12].fastq.gz
 
 # Finalize
-miga date > "$DATASET.done"
-miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f
+miga date > "${DATASET}.done"
+cat <<VERSIONS \
+  | miga add_result -P "$PROJECT" -D "$DATASET" -r "$SCRIPT" -f --stdin-versions
+=> MiGA
+$(miga --version)
+=> Enveomics Collection: FastQ.tag.rb
+$(FastQ.tag.rb --version | perl -pe 's/.* //')
+=> Multitrim
+version unknown
+=> FaQCs
+$(FaQCs --version 2>&1 | perl -pe 's/.*: //')
+=> Seqtk
+$(seqtk 2>&1 | grep Version | perl -pe 's/.*: //')
+=> Fastp
+$(fastp --version 2>&1 | perl -pe 's/^fastp //')
+=> Falco
+$(falco -V 2>&1 | tee)
+VERSIONS
 

data/test/dataset_test.rb

@@ -40,7 +40,7 @@ class DatasetTest < Test::Unit::TestCase
     d2.save
     assert_not_predicate(d2, :multi?)
     assert_not_predicate(d2, :nonmulti?)
-    assert_nil(d2.metadata[:type])
+    assert_equal(:empty, d2.metadata[:type])
     d2.metadata[:type] = :metagenome
     d2.save
     assert_equal(:metagenome, d2.metadata[:type])
@@ -89,25 +89,40 @@ class DatasetTest < Test::Unit::TestCase
     assert_equal(:trimmed_reads, d2.first_preprocessing(true))
     assert_equal(:read_quality, d2.next_preprocessing(true))
     assert { !d2.done_preprocessing?(true) }
-    # Ref and undeclared multi
+
+    # Ref and undeclared type (empty)
     assert { d2.ignore_task?(:mytaxa) }
     assert { d2.ignore_task?(:mytaxa_scan) }
     assert { d2.ignore_task?(:distances) }
+    assert { d2.ignore_task?(:essential_genes) }
+
     # Ref and multi
     d2.metadata[:type] = :metagenome
     assert { !d2.ignore_task?(:mytaxa) }
     assert { d2.ignore_task?(:mytaxa_scan) }
     assert { d2.ignore_task?(:distances) }
+    assert { !d2.ignore_task?(:essential_genes) }
+
     # Ref and nonmulti
     d2.metadata[:type] = :genome
     assert { d2.ignore_task?(:mytaxa) }
     assert { !d2.ignore_task?(:mytaxa_scan) }
     assert { !d2.ignore_task?(:distances) }
+    assert { !d2.ignore_task?(:essential_genes) }
+
     # Qry and nonmulti
     d2.metadata[:ref] = false
     assert { d2.ignore_task?(:mytaxa) }
     assert { d2.ignore_task?(:mytaxa_scan) }
     assert { !d2.ignore_task?(:distances) }
+    assert { !d2.ignore_task?(:essential_genes) }
+
+    # Qry and plasmid
+    d2.metadata[:type] = :plasmid
+    assert { d2.ignore_task?(:mytaxa) }
+    assert { d2.ignore_task?(:mytaxa_scan) }
+    assert { !d2.ignore_task?(:distances) }
+    assert { d2.ignore_task?(:essential_genes) }
   end
 
   def test_profile_advance

data/test/hook_test.rb

@@ -9,9 +9,10 @@ class HookTest < Test::Unit::TestCase
   end
 
   def test_add_hook
-    assert_nil(dataset.hooks[:on_save])
-    dataset.add_hook(:on_save, :run_lambda, Proc.new { $counter += 1 })
+    assert_nil(dataset.hooks[:on_remove])
     assert_equal(1, dataset.hooks[:on_save].size)
+    dataset.add_hook(:on_save, :run_lambda, Proc.new { $counter += 1 })
+    assert_equal(2, dataset.hooks[:on_save].size)
     $counter = 1
     dataset.save
     assert_equal(2, $counter)

data/test/net_test.rb

@@ -15,20 +15,36 @@ class FormatTest < Test::Unit::TestCase
     declare_remote_access
     m = MiGA::MiGA
     assert_raise { m.remote_connection(:bad_descriptor) }
-    assert_raise { m.remote_connection('http://microbial-genomes.org/') }
+    assert_raise { m.remote_connection('ssh://microbial-genomes.org/') }
     c = m.remote_connection(:miga_db)
     assert_equal(Net::FTP, c.class)
     c.close
   end
 
-  def test_download_file_ftp
+  def test_download_file_http
     declare_remote_access
     m = MiGA::MiGA
+    #o = m.http_request(:get, 'http://uibk.microbial-genomes.org/robots.txt')
+    o = m.http_request(:get, 'http://disc-genomics.uibk.ac.at/miga/robots.txt')
+    o = o.split(/\n/)
+    assert_equal(6, o.count)
+    assert_equal('#', o[1])
+    assert_equal('User-agent: *', o[2])
+  end
+
+  def test_download_file_ftp
+    declare_remote_access
     f = tmpfile('t/test.txt')
     d = File.dirname(f)
     assert(!Dir.exist?(d))
-    m.download_file_ftp(:miga_online_ftp, 'test.txt', f)
-    assert(Dir.exist?(d))
-    assert_equal('miga', File.read(f).chomp)
+    # TODO
+    # Bring back when I can connect to the Gatech's FTP
+    ### m = MiGA::MiGA
+    ### m.download_file_ftp(:miga_online_ftp, 'api_test.txt', f)
+    ### assert(Dir.exist?(d))
+    ### assert_equal('miga', File.read(f).chomp)
+    ### File.unlink(f)
+    ### m.download_file_ftp(:miga_db, '../api_test.txt', f)
+    ### assert_equal('miga', File.read(f).chomp)
   end
 end

data/test/project_test.rb

@@ -8,6 +8,12 @@ class ProjectTest < Test::Unit::TestCase
     initialize_miga_home
   end
 
+  def test_class_variables
+    assert(MiGA::Project.INCLADE_TASKS.is_a? Array)
+    assert(MiGA::Project.DISTANCE_TASKS.is_a? Array)
+    assert(MiGA::Project.KNOWN_TYPES.is_a? Hash)
+  end
+
   def create_result_files(project, res, exts)
     d = MiGA::Project.RESULT_DIRS[res]
     (['.done'] + exts).each do |x|
@@ -155,4 +161,11 @@ class ProjectTest < Test::Unit::TestCase
     date3 = p1.add_result(:ogs, true, force: true)[:created]
     assert_not_equal(date1, date3)
   end
+
+  def test_options
+    assert_equal('fastaai', project.option(:haai_p))
+    assert_equal(false, project.option(:aai_save_rbm))
+    project.metadata[:type] = 'clade'
+    assert_equal(true, project.option(:aai_save_rbm))
+  end
 end

data/test/remote_dataset_test.rb

@@ -7,6 +7,7 @@ class RemoteDatasetTest < Test::Unit::TestCase
 
   def setup
     initialize_miga_home
+    ENV.delete('NCBI_API_KEY')
   end
 
   def test_class_universe
@@ -19,7 +20,7 @@ class RemoteDatasetTest < Test::Unit::TestCase
     assert_raise { MiGA::RemoteDataset.new('ids', :google, :ebi) }
   end
 
-  def test_rest
+  def test_get
     hiv2 = 'M30502.1'
     { embl: :ebi, nuccore: :ncbi }.each do |db, universe|
       rd = MiGA::RemoteDataset.new(hiv2, db, universe)
@@ -47,7 +48,8 @@ class RemoteDatasetTest < Test::Unit::TestCase
   end
 
   def test_net_ftp
-    cjac = 'ftp://ftp.ebi.ac.uk/pub/databases/ena/tsa/public/gap/GAPJ01.fasta.gz'
+    cjac = 'ftp://ftp.ebi.ac.uk/pub/databases/ena/tsa/' \
+           'public/gap/GAPJ01.fasta.gz'
     n = 'Cjac_L14'
     rd = MiGA::RemoteDataset.new(cjac, :assembly_gz, :web)
     assert_equal([cjac], rd.ids)
@@ -86,26 +88,56 @@ class RemoteDatasetTest < Test::Unit::TestCase
   def test_type_status_asm
     declare_remote_access
     rd = MiGA::RemoteDataset.new('GCF_000018105.1', :assembly, :ncbi)
-    assert { rd.get_metadata[:is_type] }
+    md = rd.get_metadata
+    assert(md[:is_type])
   end
 
   def test_nontype_status_asm
     declare_remote_access
     rd = MiGA::RemoteDataset.new('GCA_004684205.1', :assembly, :ncbi)
-    assert { !rd.get_metadata[:is_type] }
+    md = rd.get_metadata
+    assert(!md[:is_type])
   end
 
   def test_type_status_nuccore
     declare_remote_access
     rd = MiGA::RemoteDataset.new('NC_019748.1', :nuccore, :ncbi)
-    assert { rd.get_metadata[:is_type] }
+    md = rd.get_metadata
+    assert(md[:is_type])
   end
 
   def test_ref_type_status
     declare_remote_access
     rd = MiGA::RemoteDataset.new('GCA_003144295.1', :assembly, :ncbi)
-    assert { !rd.get_metadata[:is_type] }
-    assert { rd.get_metadata[:is_ref_type] }
+    md = rd.get_metadata
+    assert(!md[:is_type])
+    assert(md[:is_ref_type])
+  end
+
+  def test_gtdb_taxonomy
+    declare_remote_access
+    rd = MiGA::RemoteDataset.new('GCA_018200315.1', :assembly, :gtdb)
+    md = rd.get_metadata
+    assert(!md[:is_type])
+    assert_not_nil(md[:gtdb_release])
+    assert(md[:tax].is_a? MiGA::Taxonomy)
+    assert_equal('GCA_018200315.1', md[:gtdb_assembly])
+    assert_equal('gtdb', md[:tax][:ns])
+    assert_equal('Bacteroidia', md[:tax][:c])
+  end
+
+  def test_gtdb_alt_taxonomy
+    declare_remote_access
+    rd = MiGA::RemoteDataset.new('GCA_018200315.1', :assembly, :gtdb)
+    rd.metadata[:get_ncbi_taxonomy] = true
+    md = rd.get_metadata
+    assert(md[:tax].is_a? MiGA::Taxonomy)
+    assert_equal('ncbi', md[:tax][:ns])
+    assert_equal('Flavobacteriia', md[:tax][:c])
+    assert(md[:tax].alternative(1).is_a? MiGA::Taxonomy)
+    assert(md[:tax].alternative(:gtdb).is_a? MiGA::Taxonomy)
+    assert_equal('gtdb', md[:tax].alternative(1)[:ns])
+    assert_equal('gtdb', md[:tax].alternative(:gtdb)[:ns])
   end
 
   def test_missing_data
@@ -114,6 +146,73 @@ class RemoteDatasetTest < Test::Unit::TestCase
     assert_raise(MiGA::RemoteDataMissingError) { rd.save_to(project, 'bad') }
   end
 
+  def test_gtdb_request
+    # No remote access needed
+    rd = MiGA::RemoteDataset.new('g__Macondimonas', :taxon, :gtdb)
+    u = rd.download_uri
+    h = rd.download_headers
+
+    assert(u.is_a? URI)
+    assert_equal('https', u.scheme)
+    assert_equal('genomes', File.basename(u.path))
+
+    assert(h.is_a? Hash)
+    assert_equal(1, h.size)
+    assert_equal('application/json', h['Accept'])
+  end
+
+  def test_ncbi_datasets_download_request
+    # No remote access needed
+    rd = MiGA::RemoteDataset.new(
+      'GCF_004684205.1', :genome, :ncbi_datasets_download
+    )
+    u = rd.download_uri
+    h = rd.download_headers
+
+    assert(u.is_a? URI)
+    assert_equal('https', u.scheme)
+    assert_equal('download', File.basename(u.path))
+
+    assert(h.is_a? Hash)
+    assert_equal(1, h.size)
+    assert_equal('application/zip', h['Accept'])
+
+    ENV['NCBI_API_KEY'] = 'Not-a-real-key'
+    h = rd.download_headers
+    ENV.delete('NCBI_API_KEY')
+    assert_equal(2, h.size)
+    assert_equal('Not-a-real-key', h['api-key'])
+  end
+
+  def test_seqcode_request
+    # No remote access needed
+    rd = MiGA::RemoteDataset.new(nil, 'type-genomes', :seqcode)
+    u = rd.download_uri
+
+    assert(u.is_a? URI)
+    assert_equal('https', u.scheme)
+    assert_equal('type-genomes.json', File.basename(u.path))
+  end
+
+  def test_ncbi_datasets_request
+    rd = MiGA::RemoteDataset.new({ taxons: 'Bos' }, :genome, :ncbi_datasets)
+    u = rd.download_uri
+    h = rd.download_headers
+    p = rd.download_payload
+
+    assert(u.is_a? URI)
+    assert_equal('https', u.scheme)
+    assert_equal('dataset_report', File.basename(u.path))
+
+    assert(h.is_a? Hash)
+    assert_equal(1, h.size)
+    assert_equal('application/json', h['Content-Type'])
+
+    assert(p.is_a? String)
+    assert_equal('{', p[0])
+    assert_equal('}', p[-1])
+  end
+
   # This test is too expensive (too much time to run it!)
   # def test_net_timeout
   #   declare_remote_access

data/test/result_test.rb

@@ -6,27 +6,15 @@ class ResultTest < Test::Unit::TestCase
 
   def setup
     initialize_miga_home
-    FileUtils.touch(
-      File.join(
-        project.path, 'data', '02.trimmed_reads',
-        "#{dataset.name}.1.clipped.fastq"
-      )
-    )
-    FileUtils.touch(
-      File.join(
-        project.path, 'data', '02.trimmed_reads', "#{dataset.name}.done"
-      )
-    )
-    FileUtils.touch(
-      File.join(
-        project.path, 'data', '10.clades', '01.find', 'miga-project.empty'
-      )
-    )
-    FileUtils.touch(
-      File.join(
-        project.path, 'data', '10.clades', '01.find', 'miga-project.done'
-      )
-    )
+    to_touch = [
+      ['02.trimmed_reads', "#{dataset.name}.1.clipped.fastq"],
+      ['02.trimmed_reads', "#{dataset.name}.done"],
+      ['10.clades', '01.find', 'miga-project.empty'],
+      ['10.clades', '01.find', 'miga-project.done']
+    ]
+    to_touch.each do |path|
+      FileUtils.touch(File.join(project.path, 'data', *path))
+    end
   end
 
   def test_add_result
@@ -89,4 +77,42 @@ class ResultTest < Test::Unit::TestCase
     r = dataset.add_result(:trimmed_reads)
     assert_equal(5.0, r.running_time)
   end
+
+  def test_status
+    d = dataset
+    assert_equal(:ignore_empty, d.result_status(:trimmed_reads))
+    d.add_result(:trimmed_reads)
+    assert_equal(:-, d.result_status(:raw_reads))
+    assert_equal(:complete, d.result_status(:trimmed_reads))
+    assert_equal(:pending, d.result_status(:read_quality))
+    assert_equal(:pending, d.result_status(:assembly))
+
+    h = d.results_status
+    assert(h.is_a? Hash)
+    assert_equal(:-, h[:raw_reads])
+    assert_equal(:complete, h[:trimmed_reads])
+    assert_equal(:pending, h[:read_quality])
+
+    # Test the "advance" interface from Project
+    a = project.profile_datasets_advance
+    assert(a.is_a? Array)
+    assert_equal(1, a.size)
+    assert(a[0].is_a? Array)
+    assert_equal([0, 1, 2, 2], a[0][0..3])
+  end
+
+  def test_versions
+    r = dataset.add_result(:trimmed_reads)
+    assert_respond_to(r, :add_versions)
+    assert_respond_to(r, :versions_md)
+    assert_equal(MiGA::VERSION.join('.'), r.versions[:MiGA])
+    assert_nil(r.versions[:GoodSoftware])
+
+    r.add_versions('GoodSoftware' => '1.2.3')
+    assert_equal('1.2.3', r.versions[:GoodSoftware])
+
+    md = r.versions_md
+    assert_equal('-', md[0])
+    assert_equal(2, md.split("\n").size)
+  end
 end

data/test/taxonomy_test.rb

@@ -92,8 +92,12 @@ class TaxonomyTest < Test::Unit::TestCase
   end
 
   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'])
+    tx = MiGA::Taxonomy.new(
+      'ns:Letters d:Latin s:A', nil,
+      ['ns:Words d:English s:A', 'ns:Music d:Tone s:A']
+    )
+    assert_equal('Latin', tx.domain)
+
     # Reset
     assert_equal(2, tx.alternative.size)
     assert_equal('Letters', tx.namespace)
@@ -102,11 +106,13 @@ class TaxonomyTest < Test::Unit::TestCase
     assert_nil(tx.namespace)
     tx.reset('ns:Letters d:Latin s:A')
     assert_equal('Letters', tx.namespace)
+
     # Change of alternative
     assert_equal('ns:Words d:English s:A', tx.alternative('Words').to_s)
     tx.add_alternative(MiGA::Taxonomy.new('ns:Words d:Spanish s:A'))
     assert_equal('ns:Words d:Spanish s:A', tx.alternative('Words').to_s)
-    # Change of master
+
+    # Change of main
     assert_equal('ns:Letters d:Latin s:A', tx.to_s)
     tx.add_alternative(MiGA::Taxonomy.new('ns:Letters d:Unicode s:A'))
     assert_equal('ns:Letters d:Unicode s:A', tx.to_s)

data/utils/distance/runner.rb

@@ -54,7 +54,9 @@ class MiGA::DistanceRunner
     # first-come-first-serve traverse
     sbj = []
     ref_project.each_dataset do |ds|
-      sbj << ds if ds.ref? && !ds.multi? && ds.result(:essential_genes)
+      torun = ds.ref? && !ds.multi?
+      torun &&= ds.result(:essential_genes) || (!ds.markers? && ds.result(:cds))
+      sbj << ds if torun
     end
     ani_after_aai(sbj)
 

data/utils/distances.rb

@@ -4,6 +4,6 @@ require_relative 'distance/runner.rb'
 
 project = ARGV.shift
 dataset = ARGV.shift
-opts = Hash[ARGV.map { |i| i.split("=", 2).tap { |j| j[0] = j[0].to_sym } }]
+opts = Hash[ARGV.map { |i| i.split('=', 2).tap { |j| j[0] = j[0].to_sym } }]
 runner = MiGA::DistanceRunner.new(project, dataset, opts)
 runner.go!