miga-base 0.4.1.0 → 0.4.2.0

data/lib/miga/taxonomy/base.rb

@@ -0,0 +1,63 @@
+# @package MiGA
+# @license Artistic-2.0
+
+class MiGA::Taxonomy < MiGA::MiGA
+
+  class << self
+
+    ##
+    # Returns cannonical rank (Symbol) for the +rank+ String.
+    def normalize_rank(rank)
+      return rank.to_sym if @@_KNOWN_RANKS_H[rank.to_sym]
+      rank = rank.to_s.downcase
+      return nil if rank == 'no rank'
+      rank = @@RANK_SYNONYMS[rank] unless @@RANK_SYNONYMS[rank].nil?
+      rank = rank.to_sym
+      return nil unless @@_KNOWN_RANKS_H[rank]
+      rank
+    end
+
+    ##
+    # Initialize from JSON-derived Hash +o+.
+    def json_create(o)
+      new(o['str'], nil, o['alt'])
+    end
+
+    def KNOWN_RANKS() @@KNOWN_RANKS; end
+    def LONG_RANKS() @@LONG_RANKS; end
+
+  end
+
+end
+
+module MiGA::Taxonomy::Base
+
+  ##
+  # Cannonical ranks.
+  @@KNOWN_RANKS = %w{ns d k p c o f g s ssp str ds}.map { |r| r.to_sym }
+  @@_KNOWN_RANKS_H = Hash[ @@KNOWN_RANKS.map { |i| [i, true] } ]
+
+  ##
+  # Long names of the cannonical ranks.
+  @@LONG_RANKS = { root: 'root', ns: 'namespace', d: 'domain', k: 'kingdom',
+    p: 'phylum', c: 'class', o: 'order', f: 'family', g: 'genus', s: 'species',
+    ssp: 'subspecies', str: 'strain', ds: 'dataset' }
+
+  ##
+  # Synonms for cannonical ranks.
+  @@RANK_SYNONYMS = {
+    'namespace' => 'ns',
+    'domain' => 'd', 'superkingdom' => 'd',
+    'kingdom' => 'k',
+    'phylum' => 'p',
+    'class' => 'c',
+    'order' => 'o',
+    'family' => 'f',
+    'genus' => 'g',
+    'species' => 's', 'sp' => 's',
+    'subspecies' => 'ssp',
+    'strain' => 'str', 'isolate' => 'str', 'culture' => 'str',
+    'dataset' => 'ds', 'organism' => 'ds', 'genome' => 'ds', 'specimen' => 'ds'
+  }
+
+end

data/lib/miga/taxonomy.rb

@@ -1,60 +1,12 @@
 # @package MiGA
 # @license Artistic-2.0
 
+require 'miga/taxonomy/base'
+
 ##
 # Taxonomic classifications in MiGA.
 class MiGA::Taxonomy < MiGA::MiGA
-  # Class-level
-
-  ##
-  # Cannonical ranks.
-  def self.KNOWN_RANKS() @@KNOWN_RANKS ; end
-  @@KNOWN_RANKS = %w{ns d k p c o f g s ssp str ds}.map{|r| r.to_sym}
-  @@_KNOWN_RANKS_H = Hash[ @@KNOWN_RANKS.map{ |i| [i,true] } ]
-
-  ##
-  # Long names of the cannonical ranks.
-  def self.LONG_RANKS() @@LONG_RANKS ; end
-  @@LONG_RANKS = {root: 'root', ns: 'namespace', d: 'domain', k: 'kingdom',
-    p: 'phylum', c: 'class', o: 'order', f: 'family', g: 'genus', s: 'species',
-    ssp: 'subspecies', str: 'strain', ds: 'dataset'}
-
-  ##
-  # Synonms for cannonical ranks.
-  @@RANK_SYNONYMS = {
-    'namespace' => 'ns',
-    'domain' => 'd', 'superkingdom' => 'd',
-    'kingdom' => 'k',
-    'phylum' => 'p',
-    'class' => 'c',
-    'order' => 'o',
-    'family' => 'f',
-    'genus' => 'g',
-    'species' => 's', 'sp' => 's',
-    'subspecies' => 'ssp',
-    'strain' => 'str', 'isolate' => 'str', 'culture' => 'str',
-    'dataset' => 'ds', 'organism' => 'ds', 'genome' => 'ds', 'specimen' => 'ds'
-  }
-
-  ##
-  # Initialize from JSON-derived Hash +o+.
-  def self.json_create(o)
-    new(o['str'], nil, o['alt'])
-  end
-
-  ##
-  # Returns cannonical rank (Symbol) for the +rank+ String.
-  def self.normalize_rank(rank)
-    return rank.to_sym if @@_KNOWN_RANKS_H[rank.to_sym]
-    rank = rank.to_s.downcase
-    return nil if rank == 'no rank'
-    rank = @@RANK_SYNONYMS[rank] unless @@RANK_SYNONYMS[rank].nil?
-    rank = rank.to_sym
-    return nil unless @@_KNOWN_RANKS_H[rank]
-    rank
-  end
-
-  # Instance-level
+  include MiGA::Taxonomy::Base
 
   ##
   # Taxonomic hierarchy Hash.
@@ -69,46 +21,47 @@ class MiGA::Taxonomy < MiGA::MiGA
   # String, Array, or Hash entries as defined above (except +ranks+ are not
   # allowed).
   def initialize(str, ranks = nil, alt = [])
+    reset(str, ranks)
+    @alt = (alt || []).map { |i| Taxonomy.new(i) }
+  end
+
+  ##
+  # Reset ranks (including namespace) while leaving alternatives untouched.
+  # See #initialize for +str+ and +ranks+.
+  def reset(str, ranks = nil)
     @ranks = {}
     if ranks.nil?
-      case str when Array, Hash
-        self << str
-      else
-        "#{str} ".scan(/([A-Za-z]+):([^:]*)( )/){ |r,n,_| self << {r=>n} }
-      end
+      initialize_by_str(str)
     else
-      ranks = ranks.split(/\s+/) unless ranks.is_a? Array
-      str = str.split(/\s+/) unless str.is_a? Array
-      raise "Unequal number of ranks (#{ranks.size}) " +
-        "and names (#{str.size}):#{ranks} => #{str}" unless
-        ranks.size==str.size
-      (0 .. str.size).each{ |i| self << "#{ranks[i]}:#{str[i]}" }
+      initialize_by_ranks(str, ranks)
     end
-    @alt = (alt || []).map { |i| Taxonomy.new(i) }
+    initialize_by_str(str)
   end
-  
+
   ##
   # Add +value+ to the hierarchy, that can be an Array, a String, or a Hash, as
   # described in #initialize.
   def <<(value)
-    if value.is_a? Hash
-      value.each_pair do |rank_i, name_i|
-        next if name_i.nil? or name_i == ""
-        @ranks[ Taxonomy.normalize_rank rank_i ] = name_i.tr('_',' ')
+    case value
+    when Hash
+      value.each do |r, n|
+        next if n.nil? || n == ''
+        @ranks[self.class.normalize_rank(r)] = n.tr('_', ' ')
       end
-    elsif value.is_a? Array
-      value.each{ |v| self << v }
-    elsif value.is_a? String
-      (rank, name) = value.split(/:/)
-      self << { rank => name }
+    when Array
+      value.each { |v| self << v }
+    when String
+      self << Hash[*value.split(':', 2)]
     else
-      raise "Unsupported class: #{value.class.name}."
+      raise 'Unsupported class: ' + value.class.name
     end
   end
-  
+
   ##
   # Get +rank+ value.
-  def [](rank) @ranks[ rank.to_sym ] ; end
+  def [](rank)
+    @ranks[rank.to_sym]
+  end
 
   ##
   # Get the alternative taxonomies.
@@ -126,17 +79,38 @@ class MiGA::Taxonomy < MiGA::MiGA
     when Integer
       ([self] + @alt)[which]
     else
-      ([self] + @alt).find{ |i| i.namespace.to_s == which.to_s }
+      ([self] + @alt).find { |i| i.namespace.to_s == which.to_s }
     end
   end
-  
+
+  ##
+  # Add an alternative taxonomy. If the namespace matches an existing namespace,
+  # the alternative (or master) is replaced instead if +replace+ is true.
+  def add_alternative(tax, replace = true)
+    raise 'Unsupported taxonomy class.' unless tax.is_a? MiGA::Taxonomy
+    alt_ns = alternative(tax.namespace)
+    if !replace || tax.namespace.nil? || alt_ns.nil?
+      @alt << tax
+    else
+      alt_ns.reset(tax.to_s)
+    end
+  end
+
+  ##
+  # Removes (and returns) all alternative taxonomies. 
+  def delete_alternative
+    alt = @alt.dup
+    @alt = []
+    alt
+  end
+
   ##
   # Evaluates if the loaded taxonomy includes +taxon+. It assumes that +taxon+
   # only has one informative rank. The evaluation is case-insensitive.
-  def is_in? taxon
+  def in?(taxon)
     r = taxon.ranks.keys.first
-    return false if self[ r ].nil?
-    self[ r ].downcase == taxon[ r ].downcase
+    return false if self[r].nil?
+    self[r].casecmp(taxon[r]).zero?
   end
 
   ##
@@ -145,22 +119,24 @@ class MiGA::Taxonomy < MiGA::MiGA
   # If +with_namespace+ is true, it includes also the namespace.
   def sorted_ranks(force_ranks = false, with_namespace = false)
     @@KNOWN_RANKS.map do |r|
-      next if r == :ns and not with_namespace
-      next if ranks[r].nil? and not force_ranks
+      next if
+        (r == :ns && !with_namespace) || (ranks[r].nil? && !force_ranks)
       [r, ranks[r]]
     end.compact
   end
 
   ##
   # Namespace of the taxonomy (a String) or +nil+.
-  def namespace; self[ :ns ] ; end
-  
+  def namespace
+    self[:ns]
+  end
+
   ##
   # Get the most general rank as a two-entry Array (rank and value).
   # If +force_ranks+ is true, it always returns the value for domain (d)
   # even if undefined.
   def highest(force_ranks = false)
-    sorted_ranks.first
+    sorted_ranks(force_ranks).first
   end
 
   ##
@@ -170,21 +146,40 @@ class MiGA::Taxonomy < MiGA::MiGA
   def lowest(force_ranks = false)
     sorted_ranks(force_ranks).last
   end
-  
+
   ##
   # Generate cannonical String for the taxonomy. If +force_ranks+ is true,
   # it returns all the standard ranks even if undefined.
   def to_s(force_ranks = false)
-    sorted_ranks(force_ranks, true).
-      map{ |r| "#{r[0]}:#{(r[1] || '').gsub(/[\s:]/, '_')}" }.join(' ')
+    sorted_ranks(force_ranks, true)
+      .map { |r| "#{r[0]}:#{(r[1] || '').gsub(/[\s:]/, '_')}" }.join(' ')
   end
-  
+
   ##
   # Generate JSON-formated String representing the taxonomy.
   def to_json(*a)
-    hsh = { JSON.create_id => self.class.name, 'str' => self.to_s }
+    hsh = { JSON.create_id => self.class.name, 'str' => to_s }
     hsh['alt'] = alternative.map(&:to_s) unless alternative.empty?
     hsh.to_json(*a)
   end
-  
+
+  private
+
+  def initialize_by_str(str)
+    case str
+    when Array, Hash
+      self << str
+    else
+      "#{str} ".scan(/([A-Za-z]+):([^:]*)( )/) { |r, n, _| self << { r => n } }
+    end
+  end
+
+  def initialize_by_ranks(str, ranks)
+    ranks = ranks.split(/\s+/) unless ranks.is_a? Array
+    str = str.split(/\s+/) unless str.is_a? Array
+    unless ranks.size == str.size
+      raise "Unequal number of ranks and names: #{ranks} => #{str}"
+    end
+    str.each_with_index { |i, k| self << "#{ranks[k]}:#{i}" }
+  end
 end

data/lib/miga/version.rb

@@ -4,22 +4,22 @@ require 'date'
 ##
 # High-level minimal requirements for the MiGA::MiGA class.
 module MiGA
-  
+
   ##
   # Current version of MiGA. An Array with three values:
   # - Float representing the major.minor version.
   # - Integer representing gem releases of the current version.
   # - Integer representing minor changes that require new version number.
-  VERSION = [0.4, 1, 0]
-  
+  VERSION = [0.4, 2, 0]
+
   ##
   # Nickname for the current major.minor version.
   VERSION_NAME = 'aquatint'
-  
+
   ##
   # Date of the current gem release.
-  VERSION_DATE = Date.new(2019, 8, 17)
-  
+  VERSION_DATE = Date.new(2019, 9, 8)
+
   ##
   # Reference of MiGA.
   CITATION = 'Rodriguez-R et al (2018). ' \

data/test/taxonomy_test.rb

@@ -1,5 +1,5 @@
-require "test_helper"
-require "miga/taxonomy"
+require 'test_helper'
+require 'miga/taxonomy'
 
 class TaxonomyTest < Test::Unit::TestCase
   
@@ -40,23 +40,32 @@ class TaxonomyTest < Test::Unit::TestCase
     tx << { :genus => "v3" }
     assert_equal("v3", tx[:g])
     tx << "s:v3_0"
-    assert(tx.is_in? MiGA::Taxonomy.new("species:v3_0"))
+    assert(tx.in? MiGA::Taxonomy.new("species:v3_0"))
     assert_raise(RuntimeError) { tx << 123 }
   end
 
   def test_init_methods
-    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)
+    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)
     assert_raise do
-      tx = MiGA::Taxonomy.new("Mascot State Georgia Peach", "k c s")
+      tx = MiGA::Taxonomy.new('Mascot State Georgia Peach', 'k c s')
     end
   end
 
-  def test_alt
+  def test_rank_order
+    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))
+    assert_equal([:s, 'Melvin'], tx.lowest)
+  end
+
+  def test_alternative
     tx = MiGA::Taxonomy.new('ns:a s:Arnie', nil,
       ['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)
     assert_equal('ns:a s:Arnie', tx.alternative(0).to_s)
@@ -65,11 +74,42 @@ class TaxonomyTest < Test::Unit::TestCase
     assert_equal('s:Darnie', tx.alternative('').to_s)
     assert_nil(tx.alternative(:x))
     assert_equal(3, tx.alternative.size)
+    # JSON
     js = tx.to_json
     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)
+    # Add
+    tx.add_alternative(tx.alternative(3))
+    assert_equal(4, tx.alternative.size)
+    tx.add_alternative(tx.alternative(2))
+    assert_equal(4, tx.alternative.size)
+    # Delete
+    alt = tx.delete_alternative
+    assert_equal(4, alt.size)
+    assert(tx.alternative.empty?)
+  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'])
+    # Reset
+    assert_equal(2, tx.alternative.size)
+    assert_equal('Letters', tx.namespace)
+    tx.reset('g:A')
+    assert_equal(2, tx.alternative.size)
+    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
+    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)
   end
 
 end

data/utils/distance/commands.rb

@@ -3,14 +3,14 @@ module MiGA::DistanceRunner::Commands
   # Estimates or calculates AAI against +target+
   def aai(target)
     # Check if the request makes sense
-    return nil if target.nil? or target.result(:essential_genes).nil?
+    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? or y.zero?
+    return y unless y.nil? || y.zero?
     # Try hAAI (except in clade projects)
     unless @ref_project.is_clade?
       y = haai(target)
-      return y unless y.nil? or y.zero?
+      return y unless y.nil? || y.zero?
     end
     # Full AAI
     aai_cmd(
@@ -27,10 +27,10 @@ module MiGA::DistanceRunner::Commands
           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? or haai.zero? or haai > 90.0
+    return nil if haai.nil? || haai.zero? || haai > 90.0
     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)",
+      conn.execute 'insert into aai values(?, ?, ?, 0, 0, 0)',
             [dataset.name, target.name, aai]
     end
     checkpoint :aai
@@ -43,10 +43,10 @@ module MiGA::DistanceRunner::Commands
     # Check if the request makes sense
     t = tmp_file('largecontigs.fa')
     r = target.result(:assembly)
-    return nil if r.nil? or !File.size?(t)
+    return nil if r.nil? || !File.size?(t)
     # Check if it's been calculated
     y = stored_value(target, :ani)
-    return y unless y.nil? or y.zero?
+    return y unless y.nil? || y.zero?
     # Run it
     ani_cmd(
         t, r.file_path(:largecontigs),
@@ -58,7 +58,7 @@ module MiGA::DistanceRunner::Commands
   # Returns +nil+ otherwise
   def ani_after_aai(target, aai_limit = 85.0)
     aai = aai(target)
-    (aai.nil? or aai < aai_limit) ? nil : ani(target)
+    (aai.nil? || aai < aai_limit) ? nil : ani(target)
   end
 
   ##
@@ -69,7 +69,7 @@ module MiGA::DistanceRunner::Commands
           --name1 "#{n1}" --name2 "#{n2}" \
           -t "#{o[:thr]}" -a --lookup-first "--#{o[:aai_save_rbm]}" \
           -p "#{o[:aai_p] || "blast+"}"`.chomp
-    (v.nil? or v.empty?) ? 0 : v.to_f
+    (v.nil? || v.empty?) ? 0 : v.to_f
   end
 
   ##
@@ -82,7 +82,7 @@ module MiGA::DistanceRunner::Commands
             -o /dev/stdout 2>/dev/null`.chomp.split(/\s+/)
       unless out.empty?
         SQLite3::Database.new(db) do |conn|
-          conn.execute "insert into ani values(?, ?, ?, 0, ?, ?)",
+          conn.execute 'insert into ani values(?, ?, ?, 0, ?, ?)',
                 [n1, n2, out[2], out[3], out[4]]
         end
       end
@@ -93,6 +93,6 @@ module MiGA::DistanceRunner::Commands
             -t "#{opts[:thr]}" -a --no-save-regions --no-save-rbm \
             --lookup-first -p "#{o[:ani_p] || "blast+"}"`.chomp
     end
-    v.nil? or v.empty? ? 0 : v.to_f
+    v.nil? || v.empty? ? 0 : v.to_f
   end
 end

data/utils/distance/pipeline.rb

@@ -6,13 +6,13 @@ module MiGA::DistanceRunner::Pipeline
   # classification and cluster number
   def classify(clades, classif, metric, result_fh, val_cls=nil)
     dir = File.expand_path(classif, clades)
-    med = File.expand_path("miga-project.medoids", dir)
+    med = File.expand_path('miga-project.medoids', dir)
     return [classif,val_cls] unless File.size? med
     max_val = 0
-    val_med = ""
+    val_med = ''
     val_cls = nil
     i_n = 0
-    File.open(med, "r") do |med_fh|
+    File.open(med, 'r') do |med_fh|
       med_fh.each_line do |med_ln|
         i_n += 1
         med_ln.chomp!
@@ -36,7 +36,7 @@ module MiGA::DistanceRunner::Pipeline
     return unless File.size? db
     out_base = File.expand_path(dataset.name, home)
     ds_matrix = "#{out_base}.txt"
-    ds_matrix_fh = File.open(ds_matrix, "w")
+    ds_matrix_fh = File.open(ds_matrix, 'w')
     ds_matrix_fh.puts %w[a b value].join("\t")
     # Find all values in the database
     seq2 = []
@@ -54,7 +54,7 @@ module MiGA::DistanceRunner::Pipeline
       end
     end
     ds_matrix_fh.close
-    ref_tree = File.expand_path("utils/ref-tree.R", MiGA::MiGA.root_path)
+    ref_tree = File.expand_path('utils/ref-tree.R', MiGA::MiGA.root_path)
     `"#{ref_tree}" "#{ds_matrix}" "#{out_base}" "#{dataset.name}"`
     File.unlink ds_matrix
   end