Class: MiGA::Taxonomy

Inherits:
MiGA
  • Object
show all
Includes:
Base
Defined in:
lib/miga/taxonomy.rb,
lib/miga/taxonomy/base.rb

Defined Under Namespace

Modules: Base

Constant Summary

Constants included from MiGA

CITATION, VERSION, VERSION_DATE, VERSION_NAME

Instance Attribute Summary collapse

Attributes included from Common::Net

#remote_connection_uri

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from MiGA

CITATION, CITATION_ARRAY, DEBUG, DEBUG_OFF, DEBUG_ON, DEBUG_TRACE_OFF, DEBUG_TRACE_ON, FULL_VERSION, LONG_VERSION, VERSION, VERSION_DATE, #advance, debug?, debug_trace?, initialized?, #like_io?, #num_suffix, rc_path, #result_files_exist?, #say

Methods included from Common::Path

#root_path, #script_path

Methods included from Common::Format

#clean_fasta_file, #seqs_length, #tabulate

Methods included from Common::Net

#download_file_ftp, #http_request, #known_hosts, #main_server, #net_method, #normalize_encoding, #remote_connection

Methods included from Common::SystemCall

#run_cmd, #run_cmd_opts

Constructor Details

#initialize(str, ranks = nil, alt = []) ⇒ Taxonomy

Create MiGA::Taxonomy from String or Array str. The string is a series of space-delimited entries, the array is a vector of entries. Each entry can be either a rank:value pair (if ranks is nil), or just values in the same order as ther ranks in ranks. Alternatively, str as a Hash with rank => value pairs is also supported. If alt is passed, it must be an Array of String, Array, or Hash entries as defined above (except ranks are not allowed).



23
24
25
26
 
# File 'lib/miga/taxonomy.rb', line 23

def initialize(str, ranks = nil, alt = [])
  reset(str, ranks)
  @alt = (alt || []).map { |i| Taxonomy.new(i) }
end

Instance Attribute Details

#ranks ⇒ Object (readonly)

Taxonomic hierarchy Hash.



13
14
15
 
# File 'lib/miga/taxonomy.rb', line 13

def ranks
  @ranks
end

Class Method Details

.json_create(o) ⇒ Object

Initialize from JSON-derived Hash o



24
25
26
 
# File 'lib/miga/taxonomy/base.rb', line 24

def json_create(o)
  new(o['str'], nil, o['alt'])
end

.KNOWN_RANKS ⇒ Object 



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

def KNOWN_RANKS()
  @@KNOWN_RANKS
end

.LONG_RANKS ⇒ Object 



32
33
34
 
# File 'lib/miga/taxonomy/base.rb', line 32

def LONG_RANKS()
  @@LONG_RANKS
end

.normalize_rank(rank) ⇒ Object

Returns cannonical rank (Symbol) for the rank String



8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/miga/taxonomy/base.rb', line 8

def normalize_rank(rank)
  return unless rank
  return rank.to_sym if @@_KNOWN_RANKS_H[rank.to_sym]

  rank = rank.to_s.downcase
  return if rank == 'no rank'

  rank = @@RANK_SYNONYMS[rank] unless @@RANK_SYNONYMS[rank].nil?
  rank = rank.to_sym
  return unless @@_KNOWN_RANKS_H[rank]

  rank
end

Instance Method Details

#<<(value) ⇒ Object

Add value to the hierarchy, that can be an Array, a String, or a Hash, as described in #initialize.



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

def <<(value)
  case value
  when Hash
    value.each do |r, n|
      next if n.nil? || n == ''

      @ranks[self.class.normalize_rank(r)] = n.tr('_', ' ')
    end
  when Array
    value.each { |v| self << v }
  when String
    self << Hash[*value.split(':', 2)]
  else
    raise 'Unsupported class: ' + value.class.name
  end
end

#[](rank) ⇒ Object Also known as: fetch

Get rank value.



62
63
64
 
# File 'lib/miga/taxonomy.rb', line 62

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

#add_alternative(tax, replace = true) ⇒ Object

Add an alternative taxonomy. If the namespace matches an existing namespace, the alternative (or master) is replaced instead if replace is true.



91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/miga/taxonomy.rb', line 91

def add_alternative(tax, replace = true)
  return if tax.nil?
  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

#alternative(which = nil) ⇒ Object

Get the alternative taxonomies.

  • If which is nil (default), returns all alternative taxonomies as Array (not including the master taxonomy).

  • If which is Integer, returns the indexed taxonomy (starting with 0, the master taxonomy).

  • Otherwise, returns the first taxonomy with namespace which (coerced as String), including the master taxonomy.

In the latter two cases it can be nil.



77
78
79
80
81
82
83
84
85
86
 
# File 'lib/miga/taxonomy.rb', line 77

def alternative(which = nil)
  case which
  when nil
    @alt
  when Integer
    ([self] + @alt)[which]
  else
    ([self] + @alt).find { |i| i.namespace.to_s == which.to_s }
  end
end

#delete_alternative ⇒ Object

Removes (and returns) all alternative taxonomies.



105
106
107
108
109
 
# File 'lib/miga/taxonomy.rb', line 105

def delete_alternative
  alt = @alt.dup
  @alt = []
  alt
end

#domain ⇒ Object

Domain of the taxonomy (a String) or nil



142
143
144
 
# File 'lib/miga/taxonomy.rb', line 142

def domain
  self[:d]
end

#dup ⇒ Object

Generate a duplicate of the current object



180
181
182
 
# File 'lib/miga/taxonomy.rb', line 180

def dup
  self.class.new(to_s, nil, alternative.map(&:dup))
end

#highest(force_ranks = false) ⇒ Object

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.



150
151
152
 
# File 'lib/miga/taxonomy.rb', line 150

def highest(force_ranks = false)
  sorted_ranks(force_ranks).first
end

#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) 


114
115
116
117
118
119
 
# File 'lib/miga/taxonomy.rb', line 114

def in?(taxon)
  r = taxon.ranks.keys.first
  return false if self[r].nil?

  self[r].casecmp(taxon[r]).zero?
end

#lowest(force_ranks = false) ⇒ Object

Get the most specific rank as a two-entry Array (rank and value). If force_ranks is true, it always returns the value for dataset (ds) even if undefined.



158
159
160
 
# File 'lib/miga/taxonomy.rb', line 158

def lowest(force_ranks = false)
  sorted_ranks(force_ranks).last
end

#namespace ⇒ Object

Namespace of the taxonomy (a String) or nil.



136
137
138
 
# File 'lib/miga/taxonomy.rb', line 136

def namespace
  self[:ns]
end

#reset(str, ranks = nil) ⇒ Object

Reset ranks (including namespace) while leaving alternatives untouched. See #initialize for str and ranks.



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

def reset(str, ranks = nil)
  @ranks = {}
  if ranks.nil?
    initialize_by_str(str)
  else
    initialize_by_ranks(str, ranks)
  end
end

#sorted_ranks(force_ranks = false, with_namespace = false) ⇒ Object

Sorted list of ranks, as an Array of two-entry Arrays (rank and value). If force_ranks is true, it returns all standard ranks even if undefined. If with_namespace is true, it includes also the namespace.



125
126
127
128
129
130
131
132
 
# File 'lib/miga/taxonomy.rb', line 125

def sorted_ranks(force_ranks = false, with_namespace = false)
  @@KNOWN_RANKS.map do |r|
    next if
      (r == :ns && !with_namespace) || (ranks[r].nil? && !force_ranks)

    [r, ranks[r]]
  end.compact
end

#to_json(*a) ⇒ Object

Generate JSON-formated String representing the taxonomy.



172
173
174
175
176
 
# File 'lib/miga/taxonomy.rb', line 172

def to_json(*a)
  hsh = { JSON.create_id => self.class.name, 'str' => to_s }
  hsh['alt'] = alternative.map(&:to_s) unless alternative.empty?
  hsh.to_json(*a)
end

#to_s(force_ranks = false) ⇒ Object

Generate cannonical String for the taxonomy. If force_ranks is true, it returns all the standard ranks even if undefined.



165
166
167
168
 
# File 'lib/miga/taxonomy.rb', line 165

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