Class: MiGA::Taxonomy

Inherits:
Object
  • Object
show all
Defined in:
lib/miga/taxonomy.rb

Constant Summary collapse

@@KNOWN_RANKS =

Class Cannonical ranks

%w{ns d k p c o f g s ssp str ds}.map{|r| r.to_sym}
@@RANK_SYNONYMS =

Synonms for cannonical ranks

{
	 "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"
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(str, ranks = nil) ⇒ Taxonomy

Returns a new instance of Taxonomy.



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/miga/taxonomy.rb', line 40

def initialize(str, ranks=nil)
	 @ranks = {}
	 if ranks.nil?
	    if str.is_a? Array or str.is_a? Hash
  self << str
	    else
  (str + " ").scan(/([A-Za-z]+):([^:]*)( )/) do |r,n,s|
		  self << {r=>n}
  end
	    end
	 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]}" }
	 end
end

Instance Attribute Details

#ranks ⇒ Object (readonly)

Instance



39
40
41
 
# File 'lib/miga/taxonomy.rb', line 39

def ranks
  @ranks
end

Class Method Details

.json_create(o) ⇒ Object 



29
 
# File 'lib/miga/taxonomy.rb', line 29

def self.json_create(o) new(o["str"]) ; end

.KNOWN_RANKS ⇒ Object 



28
 
# File 'lib/miga/taxonomy.rb', line 28

def self.KNOWN_RANKS() @@KNOWN_RANKS ; end

.normalize_rank(rank) ⇒ Object 



30
31
32
33
34
35
36
37
 
# File 'lib/miga/taxonomy.rb', line 30

def self.normalize_rank(rank)
	 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.include? rank
	 rank
end

Instance Method Details

#<<(value) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/miga/taxonomy.rb', line 60

def <<(value)
	 if value.is_a? Array
	    value.each{ |v| self << v }
	 elsif value.is_a? String
	    (rank,name) = value.split /:/
	    self << { rank => name }
	 elsif value.is_a? Hash
	    value.each_pair do |rank, name|
  next if name.nil? or name == ""
  @ranks[ Taxonomy.normalize_rank rank ] = name.gsub(/_/," ")
	    end
	 else
	    raise "Unsupported class '#{value.class.name}'."
	 end
end

#[](rank) ⇒ Object 



76
 
# File 'lib/miga/taxonomy.rb', line 76

def [](rank) @ranks[ rank.to_sym ] ; end

#highest ⇒ Object 



94
 
# File 'lib/miga/taxonomy.rb', line 94

def highest; sorted_ranks.first ; end

#is_in?(taxon) ⇒ Boolean

Evaluates if the loaded taxonomy includes ‘taxon`. It assumes that `taxon` only has one informative rank. The evaluation is case-insensitive.

Returns:

  • (Boolean) 


81
82
83
84
85
 
# File 'lib/miga/taxonomy.rb', line 81

def is_in? taxon
	 r = taxon.ranks.keys.first
	 return false if self[ r ].nil?
	 self[ r ].downcase == taxon[ r ].downcase
end

#lowest ⇒ Object 



96
 
# File 'lib/miga/taxonomy.rb', line 96

def lowest; sorted_ranks.last ; end

#sorted_ranks ⇒ Object

Sorted list of ranks, as two-entry arrays



88
89
90
91
92
 
# File 'lib/miga/taxonomy.rb', line 88

def sorted_ranks
	 @@KNOWN_RANKS.map do |r|
	    ranks[r].nil? ? nil : [r, ranks[r]]
	 end.compact
end

#to_json(*a) ⇒ Object 



102
103
104
 
# File 'lib/miga/taxonomy.rb', line 102

def to_json(*a)
	 { JSON.create_id => self.class.name, "str" => self.to_s }.to_json(*a)
end

#to_s ⇒ Object 



98
99
100
 
# File 'lib/miga/taxonomy.rb', line 98

def to_s
	 sorted_ranks.map{ |r| "#{r[0].to_s}:#{r[1].gsub(/\s/,"_")}" }.join(" ")
end