codon_table_parser 0.2.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Stefan Rohlfing
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,290 @@
+# CodonTableParser
+
+Parses the [NCBI genetic code](ftp://ftp.ncbi.nih.gov/entrez/misc/data/gc.prt) table with a multiline Regex, generating hash maps of each species' name, start codons, stop codons and codon table. 
+The output can be easily customized and used to update the respective constants of BioRuby's [CodonTable](https://github.com/bioruby/bioruby/blob/master/lib/bio/data/codontable.rb) class whenever the original data changes.
+
+## Installation
+
+``` bash
+gem install codon_table_parser
+
+```
+
+## Usage
+
+Without any parameters, the genetic code file is downloaded directly from the NCBI web site
+
+``` ruby
+parser = CodonTableParser.new
+```
+
+Alternatively, the genetic code file can be loaded from a path
+
+``` ruby
+file = 'path/to/genetic_code.txt'
+parser = CodonTableParser.new(file)
+```
+
+The first line of the file is read to determine if the content is correct. If not, an exception is thrown:
+
+``` ruby
+wrong_content = 'path/to/wrong_content.txt'
+parser = CodonTableParser.new(wrong_content)
+# Exception: This is not the NCBI genetic code table
+```
+
+### Instance Methods
+
+The following instance methods are available:
+
+* CodonTableParser#definitions
+* CodonTableParser#starts
+* CodonTableParser#stops
+* CodonTableParser#tables
+* CodonTableParser#bundle
+
+Every intance method can take a *:range* option that specifies the ids of the species to be considered in the output. 
+A range is specified as an array of integers, Ranges or both. 
+Example:
+
+``` ruby
+:range => [(1..3), 5, 9] # converted internally to [1, 2, 3, 5, 9]
+
+```
+ids not present in the originial data are ignored.
+Besides the *:range* option, several methods also take other options as demonstrated below.
+
+#### CodonTableParser#definitions
+
+``` ruby
+
+parser = CodonTableParser.new
+
+# Return default hash map of names
+definitions = parser.definitions
+
+definitions
+# {1=>"Standard",
+#  2=>"Vertebrate Mitochondrial",
+#  3=>"Yeast Mitochondrial",
+#  4=>"Mold Mitochondrial; Protozoan Mitochondrial; Coelenterate Mitochondrial; Mycoplasma; Spiroplasma",
+#  5=>"Invertebrate Mitochondrial",
+#  6=>"Ciliate Nuclear; Dasycladacean Nuclear; Hexamita Nuclear",
+#  9=>"Echinoderm Mitochondrial; Flatworm Mitochondrial",
+#  10=>"Euplotid Nuclear",
+#  11=>"Bacterial and Plant Plastid",
+#  12=>"Alternative Yeast Nuclear",
+#  13=>"Ascidian Mitochondrial",
+#  14=>"Alternative Flatworm Mitochondrial",
+#  15=>"Blepharisma Macronuclear",
+#  16=>"Chlorophycean Mitochondrial",
+#  21=>"Trematode Mitochondrial",
+#  22=>"Scenedesmus obliquus Mitochondrial",
+#  23=>"Thraustochytrium Mitochondrial"}
+
+# Return the names names for the ids specified in :range
+definitions = parser.definitions :range => [(1..3), 5, 9]
+
+# Return default hash map with custom names for the ids 1 and 3
+definitions = parser.definitions :names => {1  => "Standard (Eukaryote)",
+                                            3  => "Yeast Mitochondorial"}
+definitions[1]
+# "Standard (Eukaryote)"
+definitions[3]
+# "Yeast Mitochondorial"
+
+# Return the names for the ids specified in :range, with custom names for the ids 1 and 3
+parser.definitions :range => [(1..3), 5, 9],
+                   :names => {1 => "Standard (Eukaryote)",
+                              3 => "Yeast Mitochondorial"}
+
+```
+
+#### CodonTableParser#starts
+
+``` ruby
+
+parser = CodonTableParser.new
+
+# Return default hash map of start codons
+start_codons = parser.starts
+
+start_codons
+# {1=>["ttg", "ctg", "atg"],
+#  2=>["att", "atc", "ata", "atg", "gtg"],
+#  3=>["ata", "atg"],
+#  4=>["tta", "ttg", "ctg", "att", "atc", "ata", "atg", "gtg"],
+#  5=>["ttg", "att", "atc", "ata", "atg", "gtg"],
+#  6=>["atg"],
+#  9=>["atg", "gtg"],
+#  10=>["atg"],
+#  11=>["ttg", "ctg", "att", "atc", "ata", "atg", "gtg"],
+#  12=>["ctg", "atg"],
+#  13=>["ttg", "ata", "atg", "gtg"],
+#  14=>["atg"],
+#  15=>["atg"],
+#  16=>["atg"],
+#  21=>["atg", "gtg"],
+#  22=>["atg"],
+#  23=>["att", "atg", "gtg"]}
+
+# Return the start codons for the ids specified in :range
+start_codons = parser.starts :range => [(1..3), 5, 9]
+
+# Add or remove start codons as necessary
+start_codons = parser.starts 1  => {:add => ['gtg']}, 
+                             13 => {:remove => ['ttg', 'ata', 'gtg']} 
+
+start_codons[1]
+# ["ttg", "ctg", "atg", "gtg"]
+start_codons[13]
+# ["atg"]
+
+# Alternative syntax, normally only used in the bundle method described below
+start_codons = parser.starts :starts => {1  => {:add => ['gtg']}, 
+                                         13 => {:remove => ['ttg', 'ata', 'gtg']}} 
+
+# Return the start codons for the ids specified with :range, add or remove codons from specific ids
+start_codons = parser.starts :range => [(1..3), 13],
+                             1  => {:add => ['gtg']}, 
+                             13 => {:remove => ['ttg', 'ata', 'gtg']} 
+
+```                           
+
+#### CodonTableParser#stops
+
+``` ruby
+
+parser = CodonTableParser.new
+
+# Return the default hash map of stop codons
+stop_codons = parser.stops
+
+stops
+# {1=>["taa", "tag", "tga"],
+#  2=>["taa", "tag", "aga", "agg"],
+#  3=>["taa", "tag"],
+#  4=>["taa", "tag"],
+#  5=>["taa", "tag"],
+#  6=>["tga"],
+#  9=>["taa", "tag"],
+#  10=>["taa", "tag"],
+#  11=>["taa", "tag", "tga"],
+#  12=>["taa", "tag", "tga"],
+#  13=>["taa", "tag"],
+#  14=>["tag"],
+#  15=>["taa", "tga"],
+#  16=>["taa", "tga"],
+#  21=>["taa", "tag"],
+#  22=>["tca", "taa", "tga"],
+#  23=>["tta", "taa", "tag", "tga"]}
+
+
+# Return the stop codons for the ids specified with :range
+stop_codons = parser.stops :range => [(1..3), 5, 9]
+
+# Add or remove stop codons as necessary
+
+stop_codons = parser.stops 1  => {:add => ['gtg'], :remove => ['taa']},
+                           13 => {:add => ['gcc'], :remove => ['taa', 'tag']} 
+
+stop_codons[1]
+# ["tag", "tga", "gtg"]
+stop_codons[13]
+# ["gcc"]
+
+# Alternative syntax, normally only used in the bundle method described below
+stop_codons = parser.stops :stops => {1  => {:add => ['gtg'], :remove => ['taa']},
+                                      13 => {:add => ['gcc'], :remove => ['taa', 'tag']}}
+
+
+# Return the stop codons for the ids specified with :range, add or remove codons from specific ids
+stop_codons = parser.stops :range => [(1..3), 5, 13],
+                            1  => {:add => ['gtg'], :remove => ['taa']},
+                            13 => {:add => ['gcc'], :remove => ['taa', 'tag']}
+
+```
+
+#### CodonTableParser#tables
+
+``` ruby
+
+parser = CodonTableParser.new
+
+# Return codon tables of all species
+codon_tables = parser.tables
+
+tables
+# {
+#     1 => {
+#       'ttt' => 'F', 'tct' => 'S', 'tat' => 'Y', 'tgt' => 'C',
+#       'ttc' => 'F', 'tcc' => 'S', 'tac' => 'Y', 'tgc' => 'C',
+#       'tta' => 'L', 'tca' => 'S', 'taa' => '*', 'tga' => '*',
+#       'ttg' => 'L', 'tcg' => 'S', 'tag' => '*', 'tgg' => 'W',
+# 
+#       'ctt' => 'L', 'cct' => 'P', 'cat' => 'H', 'cgt' => 'R',
+#       'ctc' => 'L', 'ccc' => 'P', 'cac' => 'H', 'cgc' => 'R',
+#       'cta' => 'L', 'cca' => 'P', 'caa' => 'Q', 'cga' => 'R',
+#       'ctg' => 'L', 'ccg' => 'P', 'cag' => 'Q', 'cgg' => 'R',
+# 
+#       'att' => 'I', 'act' => 'T', 'aat' => 'N', 'agt' => 'S',
+#       'atc' => 'I', 'acc' => 'T', 'aac' => 'N', 'agc' => 'S',
+#       'ata' => 'I', 'aca' => 'T', 'aaa' => 'K', 'aga' => 'R',
+#       'atg' => 'M', 'acg' => 'T', 'aag' => 'K', 'agg' => 'R',
+# 
+#       'gtt' => 'V', 'gct' => 'A', 'gat' => 'D', 'ggt' => 'G',
+#       'gtc' => 'V', 'gcc' => 'A', 'gac' => 'D', 'ggc' => 'G',
+#       'gta' => 'V', 'gca' => 'A', 'gaa' => 'E', 'gga' => 'G',
+#       'gtg' => 'V', 'gcg' => 'A', 'gag' => 'E', 'ggg' => 'G',
+#     },
+#     2 => { ... },
+#     3 => { ... },
+#     ...
+#     23 => { ... }
+# }
+
+# Return the codon tables for the ids specified with :range
+codon_tables = parser.tables :range => [(1..3), 5, 9, 23]
+
+```
+
+#### CodonTableParser#bundle
+
+``` ruby
+
+parser = CodonTableParser.new
+
+# Return the definitions, codon table, start and stop codons for all species as a hash map
+bundle = parser.bundle
+
+bundle
+# {:definitions => {return value of the 'definitions' method}
+#  :starts      => {return value of the 'starts' method}
+#  :stops       => {return value of the 'stops' method}
+#  :tables      => {return value of the 'tables' method}
+# }
+
+```
+The *bundle* method accepts all options from the methods described above, that is:
+
+* :range  (applied to all methods) 
+* :names  (applied to the *definitions* method) 
+* :starts (applied to the *starts* method)
+* :stops  (applied to the *stops* method)
+
+
+To return the same values as are assigned to the constants *DEFINITIONS*, *STARTS*, *STOPS*, and *TABLES* of BioRuby's [CodonTable](https://github.com/bioruby/bioruby/blob/master/lib/bio/data/codontable.rb) class, calling *bundle* with the following options will do:
+
+``` ruby
+bundle = parser.bundle :names  => {1  => "Standard (Eukaryote)",
+                                   4  => "Mold, Protozoan, Coelenterate Mitochondrial and Mycoplasma/Spiroplasma",
+                                   3  => "Yeast Mitochondorial",
+                                   6  => "Ciliate Macronuclear and Dasycladacean",
+                                   9  => "Echinoderm Mitochondrial",
+                                   11 => "Bacteria",
+                                   14 => "Flatworm Mitochondrial",
+                                   22 => "Scenedesmus obliquus mitochondrial"},
+                       :starts => {1  => {:add    => ['gtg']}, 
+                                   13 => {:remove => ['ttg', 'ata', 'gtg']}}
+
+```

data/Rakefile

@@ -0,0 +1,25 @@
+# require 'spec/rake/spectask' # depreciated
+require 'rspec/core/rake_task'
+require 'rake/gempackagetask'
+require 'rdoc/task'
+
+# Build gem: rake gem
+# Push gem:  rake push
+
+task :default => [ :spec, :gem ]
+
+RSpec::Core::RakeTask.new :spec
+
+gem_spec = eval(File.read('codon_table_parser.gemspec'))
+
+Rake::GemPackageTask.new( gem_spec ) do |t|
+  t.need_zip = true
+end
+
+#RDoc::Task.new do |rdoc|
+#
+#end
+
+task :push => :gem do |t|
+  sh "gem push pkg/#{gem_spec.name}-#{gem_spec.version}.gem"
+end

data/lib/codon_table_parser/version.rb

@@ -0,0 +1,3 @@
+class CodonTableParser
+  VERSION = "0.2.0"
+end

data/lib/codon_table_parser.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+# Parses the NCBI genetic code table, generating separate hash maps of each species' name, start & stop codons and codon table.  
+#
+# to return definitions, start  & stop codons as well as codon tables that can be used 
+class CodonTableParser
+
+  attr_reader :address
+
+  @default_address = 'ftp://ftp.ncbi.nih.gov/entrez/misc/data/gc.prt'
+
+  class << self
+    attr_accessor :default_address
+  end
+
+  def initialize(path = '')
+    @address     = CodonTableParser.default_address
+    data         = content(path)
+    @codons      = triplets(data)
+    @parsed_data = parse(data)
+  end
+
+  def content path
+    if path.empty?
+      require 'open-uri'
+      f = open(@address)
+    else
+      f = File.new(path)
+    end
+
+    first_line = f.readline
+    raise Exception, "This is not the NCBI genetic code table" unless first_line =~ /--\*+/
+    f.read.each_line do |line|
+      next if line.match(/-- /)
+      line
+    end
+  end
+
+  def triplets data
+    base1, base2, base3 = bases data
+    arr = []
+
+    base1.each_with_index do |base, i|
+      arr << (base + base2[i] + base3[i]).downcase
+    end
+    arr
+  end
+
+  def parse data 
+    del       = /.*?\s/.source               # .+ does not work as the regex is greedy.
+    # del       = /.*?(?=[a-z])/.source        # Using non-greedy search + pos. lookahead also works        
+    l_name    = /name "(.*?)"#{del}/.source
+    s_name    = /(|name ".*?"#{del})/.source # Either nothing 'line does not exists' or the short name.
+    id        = /id (\d+)#{del}/.source
+    ncbieaa   = /ncbieaa  "(.*?)"#{del}/.source
+    sncbieaa  = /sncbieaa "(.*?)"/.source
+
+    # flag 'o':
+    # Perform inline substitutions (#{variable}) only once on creation. 
+    # Normally, the variable is inserted on every evaluation.
+    result = data.scan(/#{l_name}#{s_name}#{id}#{ncbieaa}#{sncbieaa}/mo).
+    inject([]) do |res, (l_name, s_name, id, ncbieaa, sncbieaa)|
+
+      short  = s_name.match(/[A-Z]{3}\d/)[0] unless s_name.empty?
+      l_name = l_name.gsub(/\n/,'')
+
+      res << {:id         => id.to_i, 
+              :long_name  => l_name,
+              :short_name => short,
+              :ncbieaa    => ncbieaa,
+              :sncbieaa   => sncbieaa}
+    end
+
+    result
+  end
+
+
+  def definitions options = {}
+    Hash[@parsed_data.map do |species|
+      id        = species[:id]
+      name      = species[:long_name]
+      new_names = options[:names]
+      if new_names
+        name = new_names[id] if new_names[id]
+      end
+      custom_range(options[:range], id) {[id, name]}
+    end]
+  end
+
+  def starts options = {}
+    Hash[@parsed_data.map do |species| 
+      codons = []
+      species[:sncbieaa].split(//).each_with_index do |pos, i|
+        if pos == 'M'
+          codons << @codons[i]
+        end
+      end
+      id  = species[:id]
+      # Options can either be passed as :starts => {1 => {:add => ...}} or 1 => {:add => ...}
+      selection = options[:starts] || options
+      codons = custom_codons(selection[id], codons)
+      custom_range(options[:range], id) {[id, codons]}
+    end]
+  end
+
+
+  def stops options = {}
+    Hash[@parsed_data.map do |species|
+      codons = []
+      species[:ncbieaa].split(//).each_with_index do |pos, i|
+        if pos == '*'
+          codons << @codons[i]
+        end
+      end
+
+      id = species[:id]
+      # Options can either be passed as :stops => {1 => {:add => ...}} or 1 => {:add => ...}
+      selection = options[:stops] || options
+      codons = custom_codons(selection[id], codons)
+      custom_range(options[:range], id) {[id, codons]}
+    end]
+  end
+
+  def tables options = {}
+    Hash[@parsed_data.map do |species|
+      id = species[:id]
+      codon_table = table(@codons, species[:ncbieaa])
+      custom_range(options[:range], id) {[id, codon_table]}
+    end]
+  end
+
+  def bundle options = {}
+    {:definitions => definitions(options),
+     :starts       => starts(options),
+     :stops        => stops(options),
+     :tables       => tables(options)}
+  end
+
+
+  def bases data
+    del   = /[^\n]*\n\s+/.source
+    base1 = /-- Base1\s+([A-Z]+)#{del}/.source
+    base2 = /-- Base2\s+([A-Z]+)#{del}/.source
+    base3 = /-- Base3\s+([A-Z]+)/.source
+    data.scan(/#{base1}#{base2}#{base3}/m).first.map do |base|
+      base.split(//)
+    end
+  end
+
+  def prepare_range range
+    require 'set'
+    range.map do |val|
+      val.is_a?(Range) ? val.to_a : val
+    end.flatten.to_set.sort
+  end
+
+
+  def custom_range options, id, &block
+    range = prepare_range options if options
+    if range
+      block.call if range.include?(id)
+    else
+      block.call
+    end
+  end
+
+
+  def custom_codons options, codons
+    opt = options
+    if opt 
+      codons = codons | opt[:add] if opt[:add]
+      codons = codons.delete_if {|codon| opt[:remove].include?(codon)} if opt[:remove]
+    end
+    codons
+  end
+
+  def table triplets, ncbieaa
+    ncbieaa = ncbieaa.split(//)
+
+    hash = {}
+    triplets.each_with_index do |codon, i|
+      hash[codon] = ncbieaa[i]
+    end
+    hash
+  end
+
+  private :content, :bases, :prepare_range, :custom_range, :custom_codons, :table
+end
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: codon_table_parser
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Stefan Rohlfing
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &13232540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13232540
+description: ! '   Parses the NCBI genetic code table, generating hash maps of each
+  species'' name, start codons, stop codons and codon table. The output of CodonTableParser
+  can be customized easily and used to update the respective constants of BioRuby''s
+  CodonTable class whenever the original data has changed.
+
+'
+email: stefan.rohlfing@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/codon_table_parser.rb
+- lib/codon_table_parser/version.rb
+- README.md
+- Rakefile
+- LICENSE
+homepage: http://github.com/bytesource/codon_table_parser
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: codon_table_parser
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Parses the NCBI genetic code table, generating hash maps of each species'
+  name, start codons, stop codons and codon table.
+test_files: []