miga-base 0.4.1.0 → 0.4.2.0

data/actions/ncbi_get.rb

@@ -1,192 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-require 'miga/remote_dataset'
-require 'csv'
-
-o = {q: true, query: false, unlink: false,
-  reference: false, legacy_name: false,
-  complete: false, chromosome: false,
-  scaffold: false, contig: false, add_version: true, dry: false,
-  get_md: false, only_md: false, save_every: 1}
-OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project])
-  opt.on('-T', '--taxon STRING',
-    '(Mandatory unless --reference) Taxon name (e.g., a species binomial).'
-    ){ |v| o[:taxon]=v }
-  opt.on('--reference',
-    'Download all reference genomes (ignores any other status).'
-    ){ |v| o[:reference]=v }
-  opt.on('--complete', 'Download complete genomes.'){ |v| o[:complete]=v }
-  opt.on('--chromosome',
-    'Download complete chromosomes.'){ |v| o[:chromosome]=v }
-  opt.on('--scaffold', 'Download genomes in scaffolds.'){ |v| o[:scaffold]=v }
-  opt.on('--contig', 'Download genomes in contigs.'){ |v| o[:contig]=v }
-  opt.on('--all', 'Download all genomes (in any status).') do
-    o[:complete] = true
-    o[:chromosome] = true
-    o[:scaffold] = true
-    o[:contig] = true
-  end
-  opt.on('--no-version-name',
-    'Do not add sequence version to the dataset name.',
-    'Only affects --complete and --chromosome.'){ |v| o[:add_version]=v }
-  opt.on('--legacy-name',
-    'Use dataset names based on chromosome entries instead of assembly.'
-    ){ |v| o[:legacy_name] = v }
-  opt.on('--blacklist PATH',
-    'A file with dataset names to blacklist.'){ |v| o[:blacklist] = v }
-  opt.on('--dry', 'Do not download or save the datasets.'){ |v| o[:dry] = v }
-  opt.on('--get-metadata',
-    'Only download and update metadata for existing datasets'
-    ){ |v| o[:get_md] = v }
-  opt.on('--only-metadata',
-    'Create datasets without input data but retrieve all metadata.'
-    ){ |v| o[:only_md] = v }
-  opt.on('--save-every INT',
-    'Save project every this many downloaded datasets.',
-    'If zero, it saves the project only once upon completion.',
-    'By default: 1.'){ |v| o[:save_every] = v.to_i }
-  opt.on('-q', '--query',
-    'Register the datasets as queries, not reference datasets.'
-    ){ |v| o[:query]=v }
-  opt.on('-u', '--unlink',
-    'Unlink all datasets in the project missing from the download list.'
-    ){ |v| o[:unlink]=v }
-  opt.on('-R', '--remote-list PATH',
-    'Path to an output file with the list of all datasets listed remotely.'
-    ){ |v| o[:remote_list]=v }
-  opt.on('--api-key STRING', 'NCBI API key.'){ |v| ENV['NCBI_API_KEY'] = v }
-  opt_common(opt, o)
-end.parse!
-
-opt_require(o, project: '-P')
-opt_require(o, taxon: '-T') unless o[:reference]
-unless %w[reference complete chromosome scaffold contig].any?{ |i| o[i.to_sym] }
-  raise 'No action requested. Pick at least one type of genome.'
-end
-o[:save_every] = 1 if o[:dry]
-
-##=> Main <=
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-d = []
-ds = {}
-downloaded = 0
-
-url_base = 'https://www.ncbi.nlm.nih.gov/genomes/solr2txt.cgi?'
-url_param = {
-  q: '[display()].' +
-    'from(GenomeAssemblies).' +
-    'usingschema(/schema/GenomeAssemblies).' +
-    'matching(tab==["Prokaryotes"] and q=="' + o[:taxon].tr('"',"'") + '"',
-  fields: 'organism|organism,assembly|assembly,replicons|replicons,' +
-    'level|level,ftp_path_genbank|ftp_path_genbank,release_date|release_date,' +
-    'strain|strain',
-  nolimit: 'on',
-}
-if o[:reference]
-  url_param[:q] += ' and refseq_category==["representative"]'
-else
-  status = {
-    complete: 'Complete',
-    chromosome: ' Chromosome', # <- The leading space is *VERY* important!
-    scaffold: 'Scaffold',
-    contig: 'Contig'
-  }.map { |k, v| '"' + v + '"' if o[k] }.compact.join(',')
-  url_param[:q] += ' and level==[' + status + ']'
-end
-url_param[:q] += ')'
-url = url_base + URI.encode_www_form(url_param)
-$stderr.puts 'Downloading genome list' unless o[:q]
-lineno = 0
-doc = MiGA::RemoteDataset.download_url(url)
-CSV.parse(doc, headers: true).each do |r|
-  asm = r['assembly']
-  next if asm.nil? or asm.empty? or asm == '-'
-  next unless r['ftp_path_genbank']
-
-  # Get replicons
-  rep = r['replicons'].nil? ? nil : r['replicons'].
-      split('; ').map{ |i| i.gsub(/.*:/,'') }.map{ |i| i.gsub(/\/.*/, '') }
-
-  # Set name
-  if o[:legacy_name] and o[:reference]
-    n = r['#organism'].miga_name
-  else
-    if o[:legacy_name] and ['Complete',' Chromosome'].include? r['level']
-      acc = rep.nil? ? '' : rep.first
-    else
-      acc = asm
-    end
-    acc.gsub!(/\.\d+\Z/, '') unless o[:add_version]
-    n = "#{r['#organism']}_#{acc}".miga_name
-  end
-
-  # Register for download
-  fna_url = r['ftp_path_genbank'] + '/' +
-    File.basename(r['ftp_path_genbank']) + '_genomic.fna.gz'
-  ds[n] = {
-    ids: [fna_url], db: :assembly_gz, universe: :web,
-    md: {
-      type: :genome, ncbi_asm: asm, strain: r['strain']
-    }
-  }
-  ds[n][:md][:ncbi_nuccore] = rep.join(',') unless rep.nil?
-  ds[n][:md][:release_date] =
-    Time.parse(r['release_date']).to_s unless r['release_date'].nil?
-end
-
-# Discard blacklisted
-unless o[:blacklist].nil?
-  $stderr.puts "Discarding datasets in #{o[:blacklist]}." unless o[:q]
-  File.readlines(o[:blacklist]).
-    select{ |i| i !~ /^#/ }.map(&:chomp).each{ |i| ds.delete i }
-end
-
-# Download entries
-$stderr.puts "Downloading #{ds.size} " +
-  (ds.size == 1 ? 'entry' : 'entries') unless o[:q]
-p.do_not_save = true if o[:save_every] != 1
-ds.each do |name, body|
-  d << name
-  puts name
-  next if p.dataset(name).nil? == o[:get_md]
-  downloaded += 1
-  next if o[:dry]
-  $stderr.puts '  Locating remote dataset.' unless o[:q]
-  body[:md][:metadata_only] = true if o[:only_md]
-  rd = MiGA::RemoteDataset.new(body[:ids], body[:db], body[:universe])
-  if o[:get_md]
-    $stderr.puts '  Updating dataset.' unless o[:q]
-    rd.update_metadata(p.dataset(name), body[:md])
-  else
-    $stderr.puts '  Creating dataset.' unless o[:q]
-    rd.save_to(p, name, !o[:query], body[:md])
-    p.add_dataset(name)
-  end
-  p.save! if o[:save_every] > 1 and (downloaded % o[:save_every]) == 0
-end
-
-p.do_not_save = false
-p.save! if o[:save_every] != 1
-
-# Finalize
-$stderr.puts "Datasets listed: #{d.size}" unless o[:q]
-$stderr.puts "Datasets #{o[:dry] ? 'to download' : 'downloaded'}: " +
-  downloaded.to_s unless o[:q]
-unless o[:remote_list].nil?
-  File.open(o[:remote_list], 'w') do |fh|
-    d.each { |i| fh.puts i }
-  end
-end
-if o[:unlink]
-  unlink = p.dataset_names - d
-  unlink.each { |i| p.unlink_dataset(i).remove! }
-  $stderr.puts "Datasets unlinked: #{unlink.size}" unless o[:q]
-end
-

data/actions/new.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q: true, update: false}
-OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project, :project_type_req])
-  opt.on('-n', '--name STRING', 'Name of the project.'){ |v| o[:name] = v }
-  opt.on('-d', '--description STRING',
-    'Description of the project.'){ |v| o[:description] = v }
-  opt.on('-c', '--comments STRING',
-    'Comments on the project.'){ |v| o[:comments] = v }
-  opt.on('-m', '--metadata STRING',
-    'Metadata as key-value pairs separated by = and delimited by comma.',
-    'Values are saved as strings except for booleans (true / false) or nil.'
-    ){ |v| o[:metadata] = v }
-  opt.on('--update', 'Updates the project if it already exists.',
-    'Same as "miga edit".'){ o[:update] = true }
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opt_require(o, project: '-P')
-opt_require_type(o, MiGA::Project) unless o[:update]
-
-unless File.exist? "#{ENV["HOME"]}/.miga_rc" and
-      File.exist? "#{ENV["HOME"]}/.miga_daemon.json"
-  raise "You must initialize MiGA before creating the first project.\n" +
-    'Please use "miga init".'
-end
-
-$stderr.puts 'Creating project.' unless o[:q]
-raise 'Project already exists, aborting.' unless
-  o[:update] or not MiGA::Project.exist? o[:project]
-p = MiGA::Project.new(o[:project], o[:update])
-# The following check is redundant with MiGA::Project#create,
-# but allows upgrading projects from (very) early code versions
-o[:name] = File.basename(p.path) if o[:update] and o[:name].nil?
-p = add_metadata(o, p)
-p.save
-
-$stderr.puts 'Done.' unless o[:q]

data/actions/next_step.rb

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q: true}
-opts = OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project, :dataset_opt])
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opts.parse!
-opt_require(o, project: '-P')
-
-$stderr.puts 'Loading project.' unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-n = nil
-if not o[:dataset].nil?
-  $stderr.puts 'Loading dataset.' unless o[:q]
-  d = p.dataset o[:dataset]
-  raise "Impossible to load dataset: #{o[:dataset]}" if d.nil?
-  n = d.next_preprocessing if d.is_active?
-else
-  n = p.next_distances(false)
-  n ||= p.next_inclade(false)
-end
-n ||= '?'
-puts n
-

data/actions/plugins.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, update:false}
-OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project])
-  opt.on("--install PATH",
-    "Installs the specified plugin in the project."){ |v| o[:install]=v }
-  opt.on("--uninstall PATH",
-    "Uninstalls the specified plugin from the project."){ |v| o[:uninstall]=v }
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opt_require(o, project:"-P")
-
-p = MiGA::Project.new(o[:project], true)
-p.install_plugin(o[:install]) unless o[:install].nil?
-p.uninstall_plugin(o[:uninstall]) unless o[:uninstall].nil?
-p.plugins.each { |i| puts i }
-
-$stderr.puts "Done." unless o[:q]

data/actions/rm.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q: true, remove: false}
-OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o)
-  opt.on('-r', '--remove', 'Also remove all associated files.',
-    'By default, only unlinks from metadata.'){ o[:remove] = true }
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opt_require(o)
-
-$stderr.puts 'Loading project.' unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts 'Unlinking dataset.' unless o[:q]
-raise 'Dataset doesn\'t exist, aborting.' unless
-  MiGA::Dataset.exist?(p, o[:dataset])
-d = p.unlink_dataset(o[:dataset])
-d.remove! if o[:remove]
-
-$stderr.puts 'Done.' unless o[:q]
-

data/actions/run.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-require 'shellwords'
-
-o = {q: true, try_load: false, thr: 1}
-OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project, :dataset_opt, :result])
-  opt.on('-t', '--threads INT',
-    "Threads to use in the local run (by default: #{o[:thr]})."
-    ){ |v| o[:thr] = v.to_i }
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opt_require(o, project: '-P', name: '-r')
-
-$stderr.puts 'Loading project.' unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-virtual_task = false
-miga = MiGA::MiGA.root_path
-cmd = ["PROJECT=#{p.path.shellescape}", 'RUNTYPE=bash',
-  "MIGA=#{miga.shellescape}", "CORES=#{o[:thr]}"]
-if o[:dataset].nil?
-  type = MiGA::Project
-  virtual_task = true if o[:name] == :p
-else
-  d = p.dataset(o[:dataset])
-  raise 'Cannot load dataset.' if d.nil?
-  cmd << "DATASET=#{d.name.shellescape}"
-  type = MiGA::Dataset
-  virtual_task = true if o[:name] == :d
-end
-raise "Unsupported #{type.to_s.gsub(/.*::/, '')} result: #{o[:name]}." if
-  type.RESULT_DIRS[o[:name].to_sym].nil? and not virtual_task
-cmd << MiGA::MiGA.script_path(o[:name], miga: miga, project: p).shellescape
-pid = spawn cmd.join(' ')
-Process.wait pid
-
-$stderr.puts 'Done.' unless o[:q]

data/actions/stats.rb

@@ -1,149 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q:true, try_load:false}
-opts = OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project, :dataset_opt, :result])
-  opt.on("--key STRING",
-    "Returns only the value of the requested key."){ |v| o[:key] = v }
-  opt.on("--compute-and-save",
-    "Computes and saves the statistics."){ |v| o[:compute] = v }
-  opt.on("--try-load",
-    "Checks if stat exists instead of computing on --compute-and-save."
-    ){ |v| o[:try_load] = v }
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opts.parse!
-opt_require(o, project:"-P", name:"-r")
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts "Loading result." unless o[:q]
-d = nil
-if o[:dataset].nil?
-  r = p.add_result(o[:name], false)
-else
-  d = p.dataset(o[:dataset])
-  r = d.add_result(o[:name], false)
-end
-raise "Cannot load result." if r.nil?
-
-o[:compute] = false if o[:try_load] and
-  (not r[:stats].nil?) and (not r[:stats].empty?)
-
-if o[:compute]
-  $stderr.puts "Computing statistics." unless o[:q]
-  stats = {}
-  case o[:name]
-  when :raw_reads
-    if r[:files][:pair1].nil?
-      s = MiGA::MiGA.seqs_length(r.file_path(:single), :fastq, gc: true)
-      stats = {
-        reads: s[:n],
-        length_average: [s[:avg], "bp"],
-        length_standard_deviation: [s[:sd], "bp"],
-        g_c_content: [s[:gc], "%"]}
-    else
-      s1 = MiGA::MiGA.seqs_length(r.file_path(:pair1), :fastq, gc: true)
-      s2 = MiGA::MiGA.seqs_length(r.file_path(:pair2), :fastq, gc: true)
-      stats = {
-        read_pairs: s1[:n],
-        forward_length_average: [s1[:avg], "bp"],
-        forward_length_standard_deviation: [s1[:sd], "bp"],
-        forward_g_c_content: [s1[:gc], "%"],
-        reverse_length_average: [s2[:avg], "bp"],
-        reverse_length_standard_deviation: [s2[:sd], "bp"],
-        reverse_g_c_content: [s2[:gc], "%"]}
-    end
-  when :trimmed_fasta
-    f = r[:files][:coupled].nil? ? r.file_path(:single) : r.file_path(:coupled)
-    s = MiGA::MiGA.seqs_length(f, :fasta, gc: true)
-    stats = {
-      reads: s[:n],
-      length_average: [s[:avg], "bp"],
-      length_standard_deviation: [s[:sd], "bp"],
-      g_c_content: [s[:gc], "%"]}
-  when :assembly
-    s = MiGA::MiGA.seqs_length(r.file_path(:largecontigs), :fasta,
-      n50: true, gc: true)
-    stats = {
-      contigs: s[:n],
-      n50: [s[:n50], "bp"],
-      total_length: [s[:tot], "bp"],
-      g_c_content: [s[:gc], "%"]}
-  when :cds
-    s = MiGA::MiGA.seqs_length(r.file_path(:proteins), :fasta)
-    stats = {
-      predicted_proteins: s[:n],
-      average_length: [s[:avg], "aa"]}
-    asm = d.add_result(:assembly, false)
-    unless asm.nil? or asm[:stats][:total_length].nil?
-      stats[:coding_density] =
-        [300.0 * s[:tot] / asm[:stats][:total_length][0], "%"]
-    end
-  when :essential_genes
-    if d.is_multi?
-      stats = {median_copies:0, mean_copies:0}
-      File.open(r.file_path(:report), "r") do |fh|
-        fh.each_line do |ln|
-          if /^! (Mean|Median) number of copies per model: (.*)\./.match(ln)
-            stats["#{$1.downcase}_copies".to_sym] = $2.to_f
-          end
-        end
-      end
-    else
-      # Fix estimate for Archaea
-      if not d.metadata[:tax].nil? and
-            d.metadata[:tax].is_in? MiGA::Taxonomy.new("d:Archaea") and
-            r.file_path(:bac_report).nil?
-        scr = "#{MiGA::MiGA.root_path}/utils/arch-ess-genes.rb"
-        rep = r.file_path(:report)
-        $stderr.print `ruby '#{scr}' '#{rep}' '#{rep}.archaea'`
-        r.add_file(:bac_report, "#{d.name}.ess/log")
-        r.add_file(:report, "#{d.name}.ess/log.archaea")
-      end
-      # Extract/compute quality values
-      stats = {completeness: [0.0,"%"], contamination: [0.0,"%"]}
-      File.open(r.file_path(:report), "r") do |fh|
-        fh.each_line do |ln|
-          if /^! (Completeness|Contamination): (.*)%/.match(ln)
-            stats[$1.downcase.to_sym][0] = $2.to_f
-          end
-        end
-      end
-      stats[:quality] = stats[:completeness][0] - stats[:contamination][0] * 5
-      d.metadata[:quality] = case stats[:quality]
-        when 80..100 ; :excellent
-        when 50..80  ; :high
-        when 20..50  ; :intermediate
-        else         ; :low
-      end
-      d.save
-    end
-  else
-    stats = nil
-  end
-  unless stats.nil?
-    r[:stats] = stats
-    r.save
-  end
-end
-
-if o[:key].nil?
-  r[:stats].each do |k,v|
-    puts "#{k==:g_c_content ? "G+C content" : k.to_s.unmiga_name.capitalize}: #{
-      v.is_a?(Array) ? v.join(" ") : v}."
-  end
-else
-  v = r[:stats][o[:key].downcase.miga_name.to_sym]
-  puts v.is_a?(Array) ? v.first : v
-end
-
-$stderr.puts "Done." unless o[:q]

data/actions/summary.rb

@@ -1,57 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-o = {q: true, units: false, tabular: false}
-opts = OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project, :dataset_opt])
-  opt_filter_datasets(opt, o)
-  opt_object(opt, o, [:result_dataset])
-  opt.on("--tab",
-    "Returns a tab-delimited table."){ |v| o[:tabular] = v }
-  opt.on("--key STRING",
-    "Returns only the value of the requested key."){ |v| o[:key_md] = v }
-  opt.on("--with-units",
-    "Includes units in each cell."){ |v| o[:units] = v }
-  opt_common(opt, o)
-end.parse!
-
-##=> Main <=
-opts.parse!
-opt_require(o, project:"-P", name:"-r")
-
-$stderr.puts "Loading project." unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-$stderr.puts "Listing datasets." unless o[:q]
-if o[:dataset].nil?
-  ds = p.datasets
-elsif MiGA::Dataset.exist? p, o[:dataset]
-  ds = [p.dataset(o[:dataset])]
-else
-  ds = []
-end
-ds = filter_datasets!(ds, o)
-
-$stderr.puts "Loading results." unless o[:q]
-stats = ds.map do |d|
-  r = d.add_result(o[:name].to_sym, false)
-  s = r.nil? ? {} : r[:stats]
-  s.tap{ |i| i[:dataset] = d.name }
-end
-keys = o[:key_md].nil? ? stats.map(&:keys).flatten.uniq :
-      [:dataset, o[:key_md].downcase.miga_name.to_sym]
-keys.delete :dataset
-keys.unshift :dataset
-
-table = o[:units] ?
-      stats.map{ |s| keys.map{ |k|
-            s[k].is_a?(Array) ? s[k].map(&:to_s).join('') : s[k] } } :
-      stats.map{ |s| keys.map{ |k| s[k].is_a?(Array) ? s[k].first : s[k] } }
-puts MiGA::MiGA.tabulate(keys, table, o[:tabular])
-
-$stderr.puts "Done." unless o[:q]
-

data/actions/tax_dist.rb

@@ -1,106 +0,0 @@
-#!/usr/bin/env ruby
-
-# @package MiGA
-# @license Artistic-2.0
-
-require 'miga/tax_index'
-require 'zlib'
-require 'tmpdir'
-
-o = {q: true, format: :json}
-OptionParser.new do |opt|
-  opt_banner(opt)
-  opt_object(opt, o, [:project])
-  opt_filter_datasets(opt, o)
-  opt.on('-i', '--index FILE',
-    'Pre-calculated tax-index (in tabular format) to be used.',
-    'If passed, dataset filtering arguments are ignored.'
-    ){ |v| o[:index] = v }
-  opt_common(opt, o)
-end.parse!
-
-##=> Functions <=
-# Returns the _cannonical_ ID between strings +a+ and +b+.
-def cannid(a, b) ; (a > b ? [b, a] : [a, b]).join('-') ; end
-
-##=> Main <=
-opt_require(o, project: '-P')
-
-$stderr.puts 'Loading project.' unless o[:q]
-p = MiGA::Project.load(o[:project])
-raise "Impossible to load project: #{o[:project]}" if p.nil?
-
-metric = p.is_clade? ? 'ani' : 'aai'
-res_n  = "#{metric}_distances"
-$stderr.puts "Reading distances (1-#{metric.upcase})." unless o[:q]
-res = p.result res_n
-raise "#{res_n} not yet calculated." if res.nil?
-matrix = res.file_path(:matrix)
-raise "#{res_n} has no matrix." if matrix.nil?
-dist = {}
-mfh = matrix =~ /\.gz$/ ? Zlib::GzipReader.open(matrix) : File.open(matrix, 'r')
-mfh.each_line do |ln|
-  next if mfh.lineno==1
-  row = ln.chomp.split("\t")
-  dist[cannid(row[1], row[2])] = [row[3], row[5], row[6], 0, ['root:biota']]
-  $stderr.print("  Ln:#{mfh.lineno} \r") if !o[:q] and (mfh.lineno % 1_000) == 0
-end
-$stderr.puts "  Lines: #{mfh.lineno}" unless o[:q]
-mfh.close
-
-Dir.mktmpdir do |dir|
-  if o[:index].nil?
-    $stderr.puts 'Loading datasets.' unless o[:q]
-    ds = p.datasets
-    ds.select!{ |d| not d.metadata[:tax].nil? }
-    ds = filter_datasets!(ds, o)
-    
-    $stderr.puts 'Indexing taxonomy.' unless o[:q]
-    tax_index = MiGA::TaxIndex.new
-    ds.each { |d| tax_index << d }
-    tab = File.expand_path('index.tab', dir)
-    File.open(tab, 'w') { |fh| fh.print tax_index.to_tab }
-  else
-    tab = o[:index]
-  end
-
-  $stderr.puts 'Traversing taxonomy.' unless o[:q]
-  rank_i = 0
-  MiGA::Taxonomy.KNOWN_RANKS.each do |rank|
-    $stderr.print "o #{rank}: " unless o[:q]
-    rank_n = 0
-    rank_i += 1
-    in_rank = nil
-    ds_name = []
-    File.open(tab, 'r') do |fh|
-      fh.each_line do |ln|
-        if ln =~ /^ {#{(rank_i-1)*2}}\S+:\S+:/
-          in_rank = nil
-          ds_name = []
-        elsif ln =~ /^ {#{rank_i*2}}(#{rank}:(\S+)):/
-          in_rank = $2 == '?' ? nil : $1
-          ds_name = []
-        elsif ln =~ /^ *# (\S+)/ and not in_rank.nil?
-          ds_i = $1
-          ds_name << ds_i
-          ds_name.each do |ds_j|
-            k = cannid(ds_i, ds_j)
-            next if dist[k].nil?
-            rank_n += 1
-            dist[k][3] = rank_i
-            dist[k][4].unshift in_rank
-          end
-        end
-      end
-    end
-    $stderr.puts "#{rank_n} pairs of datasets." unless o[:q]
-  end
-end
-
-$stderr.puts 'Generating report.' unless o[:q]
-dist.keys.each do |k|
-  dist[k][5] = dist[k][4].reverse.join(' ')
-  dist[k][4] = dist[k][4].first
-  puts (k.split('-') + dist[k]).join("\t")
-end
-