germ 0.1 → 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 64855f9c2948d62bdb9852a39efdb04ed70c9628
+  data.tar.gz: 9573d639fa846e9f6581221621b9adf4978895a7
+SHA512:
+  metadata.gz: d12a898d9e70a0554284e46d31ca51f0573b7a98abf1b4443f5b546ec45b3a790d4d35dc77bed97a3efd04365f3ddbc4e69698f31f3a71b16b57dc69b5aa4121
+  data.tar.gz: 0bc1bceb1363b210e7b3190693571d16c4ece1bc749440ab629f20c6a9bd02dcafaf955b749ee2c5b2056cde22814abdaa9a59d80c7c701659f7390868d8eba2

data/ext/hash_table_aux/HashTableAux.c

@@ -120,11 +120,11 @@ void make_hash_entry( VALUE h, VALUE s, char sep )
 	key = ID2SYM( rb_intern(kf) );
 
 	if (!vs || !*vs) {
-		rb_hash_aset( h, key, Qnil );
+		rb_hash_aset( h, key, Qtrue );
 	} else {
 		char *vf = strip_space_quotes(vs, RSTRING_LEN(s));
 		if (!vf)
-			rb_hash_aset( h, key, Qnil );
+			rb_hash_aset( h, key, Qtrue );
 		else {
 			rb_hash_aset( h, key, rb_str_new2(vf) );
 			xfree(vf);
@@ -179,10 +179,15 @@ void add_hash_line(VALUE lines, VALUE header, VALUE types, VALUE ary) {
 	for (i=0;i<RARRAY_LEN(header);i++) {
 		if (types == Qnil)
 			rb_hash_aset( hash, rb_ary_entry(header,i), rb_ary_entry(ary,i) );
-		else
-			rb_hash_aset( hash, rb_ary_entry(header,i), 
-				convert_to_type( rb_ary_entry(ary,i), rb_ary_entry( types, i ) )
-			);
+		else {
+			VALUE col_type = rb_hash_aref( types, rb_ary_entry(header,i) );
+			if (col_type == Qnil)
+				rb_hash_aset( hash, rb_ary_entry(header,i), rb_ary_entry(ary,i) );
+			else 
+				rb_hash_aset( hash, rb_ary_entry(header,i), 
+					convert_to_type( rb_ary_entry(ary,i), col_type )
+				);
+		}
 	}
 	rb_ary_push(lines, hash);
 }
@@ -190,6 +195,7 @@ void add_hash_line(VALUE lines, VALUE header, VALUE types, VALUE ary) {
 
 VALUE method_load_file(VALUE self, VALUE file) {
 	VALUE cmmt = rb_iv_get(self,"@comment");
+	VALUE preamble = rb_iv_get(self,"@preamble");
 	char *comment = (cmmt == Qnil) ? 0 : RSTRING_PTR(cmmt);
 	int commentsize = (cmmt == Qnil) ? 0 : (RSTRING_LEN(cmmt));
 
@@ -221,6 +227,8 @@ VALUE method_load_file(VALUE self, VALUE file) {
 			i = n - contents + 1;
 		}
 		if (comment && !strncmp(buf,comment,commentsize)) {
+			// if you haven't found the header yet, stick it on the preamble
+			if (!foundheader) rb_ary_push(preamble, rb_str_new2(buf));
 			continue;
 		}
 		// okay, now you can split your string into tokens and push it
@@ -229,6 +237,11 @@ VALUE method_load_file(VALUE self, VALUE file) {
 		if (header == Qnil) {
 			header = convert_to_symbols(ary);
 			rb_iv_set(self,"@header",header);
+			// enforce header quality
+			rb_funcall(self, rb_intern("enforce_header"),0);
+			// enforce_header might reset your header, so get it again
+			header = rb_iv_get(self,"@header");
+			foundheader = 1;
 			continue;
 		}
 		if (skip_header != Qnil && !foundheader) {

data/lib/fasta.rb

@@ -1,28 +1,65 @@
 #!/usr/bin/env ruby
 require 'fasta_aux/fasta_aux'
+require 'germ/config'
+require 'genomic_locus'
 
 class Fasta
   private
   include FastaAux
+  extend GermDefault
+
+  class << self
+    def guess_line_size file
+      io = File.open file
+
+      # Grab the first 50 lines
+      lines = 50.times.map do io.gets end.compact
+
+      chroms = lines.each_index.map.select do |i| lines[i] =~ /^>/ end
+
+      chroms.each_index do |i|
+        chrom_lines = lines[ chroms[i] + 1 ... chroms[i+1] || lines.size ]
+        # you need at least 2 lines to be sure.
+        next if chrom_lines.size < 2
+        return chrom_lines.first.chomp.size if chrom_lines[0].size == chrom_lines[1].size
+      end
+
+      # You can't guess, raise an exception.
+      raise "Could not guess file line size, please specify"
+    end
+  end
 
   class Chrom
-    attr_reader :name, :size, :start
-    def initialize n, fasta, sz, st
-      @name, @fasta, @size, @start = n, fasta, sz, st
+    include GenomicLocus
+    attr_reader :seqname, :size, :start, :total, :centromere
+    alias_method :pos, :start
+    alias_method :stop, :size
+    def initialize n, fasta, sz, st, t
+      @seqname, @fasta, @size, @byte_start, @total = n, fasta, sz, st, t
+      # truncate the name
+      @seqname = short_chrom
+      @start = 1
     end
 
-    def include? pos
-      if pos.is_a? Array
-        start,stop = pos.to_a
-        include?(start) && include?(stop)
-      else
-        pos.is_a?(Fixnum) && pos >= 1 && pos <= size
+    def file_pos pos
+      return nil if !contains? pos
+      @byte_start + pos/line_size*(line_size+1) + (pos % line_size) - 1 - ((pos % line_size == 0) ? 1 : 0)
+    end
+
+    def set_cen_pos pos
+      @centromere = pos
+    end
+
+    def p
+      if @centromere
+        @p ||= GenomicLocus::Region.new @seqname, 1, @centromere
       end
     end
 
-    def file_pos pos
-      return nil if !include? pos
-      start + pos/line_size*(line_size+1) + (pos % line_size) - 1 - ((pos % line_size == 0) ? 1 : 0)
+    def q
+      if @centromere
+        @q ||= GenomicLocus::Region.new @seqname, @centromere+1, stop
+      end
     end
 
     private
@@ -37,43 +74,104 @@ class Fasta
 
   def compute_chrom_stats
     @chroms = {}
+    @chrom_alias = {}
+    total = 0
     @seq_names.each_with_index do |name, i|
       if i < @seq_names.size-1
-        @chroms[name] = Fasta::Chrom.new name, self, seq_size_from_byte_size(@seq_starts[i+1] - @seq_starts[i] - @seq_names[i+1].size - 3), @seq_starts[i]
+        size = seq_size_from_byte_size(@seq_starts[i+1] - @seq_starts[i] - @seq_names[i+1].size - 3)
       else
-        @chroms[name] = Fasta::Chrom.new name, self, seq_size_from_byte_size(@io.size - @seq_starts[i]), @seq_starts[i]
+        size = seq_size_from_byte_size(@io.size - @seq_starts[i])
       end
+      total += size
+      chrom = Fasta::Chrom.new name, self, size, @seq_starts[i], total
+      name = chrom.short_chrom
+      @chroms[name] = chrom
+      # just save it as both
+      @chrom_alias[ chrom.short_chrom ] = chrom
+      @chrom_alias[ chrom.long_chrom ] = chrom
+    end
+  end
+
+  def shorten_seq_names
+    @seq_names = @seq_names.map do |name|
+      chrom(name).short_chrom
     end
   end
 
+  def position_from_total p, chrom_only=nil
+    p_chrom = @seq_names.bsearch do |name|
+      low = chrom(name).total - chrom(name).size + 1
+      high = chrom(name).total
+      p < low || p <= high
+    end
+    chrom_only ? p_chrom : GenomicLocus::Position.new(p_chrom, p - chrom(p_chrom).total + chrom(p_chrom).size)
+  end
 
   public
-  attr_reader :line_size, :chroms
-  def initialize file, size=nil
+  attr_reader :line_size, :chroms, :seq_names
+  def initialize file, size=nil, cen_file=nil
     @io = File.open(file)
 
-    @line_size = size || 50
+    @line_size = size || Fasta.guess_line_size(file)
 
     get_seq_starts
 
     compute_chrom_stats
+
+    shorten_seq_names
+
+    if cen_file
+      load_centromeres(cen_file)
+    end
   end
 
-  def size
-    @chroms.inject(0) { |s,v| s += v.last.size }
+  def chrom name
+    @chrom_alias[name]
+  end
+
+  def genome_size
+    @genome_size ||= @seq_names.inject(0) { |s,name| s += chrom(name).size; s }
+  end
+
+  # find a random chromosome, weighted by size
+  def random_chrom
+    position_from_total 1+rand(genome_size),true
+  end
+
+  # pick a random base in the genome
+  def random_pos
+    position_from_total 1+rand(genome_size)
   end
 
   def inspect
     "#<#{self.class.name}:#{object_id} @chroms=#{@seq_names.count}>"
   end
 
-  def get_seq chrom, start, stop
-    seq = get_masked_seq chrom, start, stop
+  def locus_seq locus
+    raise TypeError, "not a GenomicLocus!" unless locus.is_a? GenomicLocus
+    get_seq locus.short_chrom, locus.start, locus.stop
+  end
+
+  def get_seq seqname, start, stop
+    seq = get_masked_seq seqname, start, stop
     seq && seq.upcase
   end
 
-  def get_masked_seq chrom, start, stop
-    raise ArgumentError.new("Improper interval") if !@chroms[chrom] || !@chroms[chrom].include?([start,stop])
-    get_seq_chunk(@chroms[chrom].file_pos(start), @chroms[chrom].file_pos(stop)).gsub(/\n/,'')
+  def interval_missing?(locus)
+    !chrom(locus.seqname) || !chrom(locus.seqname).contains?(locus)
+  end
+
+  def get_masked_seq seqname, start, stop
+    raise ArgumentError, "Improper interval #{seqname}:#{start}-#{stop}" if interval_missing?(GenomicLocus::Region.new(seqname,start,stop))
+
+    get_seq_chunk(chrom(seqname).file_pos(start), chrom(seqname).file_pos(stop)).gsub(/\n/,'')
+  end
+
+  def load_centromeres file
+    File.foreach(file).each do |line|
+      seqname, cen_pos = line.split(/\t/)[0..1]
+      cen_pos = cen_pos.to_i
+      chrom(seqname).set_cen_pos(cen_pos)
+    end
   end
 end

data/lib/fastq.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require 'zlib'
+
+class Fastq
+  class Read
+    attr_reader :id, :seq, :qual
+    def initialize id, seq, qual
+      @id = id
+      @seq = seq
+      @qual = qual
+    end
+  end
+  def initialize file
+    if is_gzipped?(file)
+      @io = IO.popen("zcat #{file}")
+    else
+      @io = File.open file
+    end
+  end
+
+  def each_read
+    while read = get_read
+      yield read
+    end
+  end
+
+  def get_read
+    return nil unless id = @io.gets
+    seq = @io.gets
+    plus = @io.gets
+    qual = @io.gets
+    Fastq::Read.new *[ id, seq, qual ].map(&:chomp)
+  end
+
+  private
+  def is_gzipped? file
+    return nil unless file && File.readable?(file)
+    begin
+      Zlib::GzipReader.new(File.open file).close
+    rescue Zlib::GzipFile::Error => e
+      return nil
+    end
+    true
+  end
+end

data/lib/genetic_code.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+class GeneticCode
+  MAP = {
+    :alanine => [ :GCT, :GCC, :GCA, :GCG ],
+    :leucine => [ :TTA, :TTG, :CTT, :CTC, :CTA, :CTG ],
+    :arginine => [ :CGT, :CGC, :CGA, :CGG, :AGA, :AGG ],
+    :lysine => [ :AAA, :AAG ],
+    :asparagine => [ :AAT, :AAC ],
+    :methionine => [ :ATG ],
+    :aspartic_acid => [ :GAT, :GAC ],
+    :phenylalinine => [ :TTT, :TTC ],
+    :cysteine => [ :TGT, :TGC ],
+    :proline => [ :CCT, :CCC, :CCA, :CCG ],
+    :glutamine => [ :CAA, :CAG ],
+    :serine => [ :TCT, :TCC, :TCA, :TCG, :AGT, :AGC ],
+    :glutamic_acid => [ :GAA, :GAG ],
+    :threonine => [ :ACT, :ACC, :ACA, :ACG ],
+    :gylcine => [ :GGT, :GGC, :GGA, :GGG ],
+    :tryptophan => [ :TGG ],
+    :histidine => [ :CAT, :CAC ],
+    :tyrosine => [ :TAT, :TAC ],
+    :isoleucine => [ :ATT, :ATC, :ATA ],
+    :valine => [ :GTT, :GTC, :GTA, :GTG ],
+    :stop => [ :TAA, :TGA, :TAG ]
+  }
+  class << self
+    def codons_for aa
+      MAP[aa]
+    end
+
+    def aa_for codon
+      aa = MAP.keys.find do |aa|
+        MAP[aa].include? codon
+      end
+      AminoAcid[aa] if aa
+    end
+  end
+end
+
+class AminoAcid
+  BASE = {
+    :alanine => { :letter => :A, :short => :Ala },
+    :leucine => { :letter => :L, :short => :Leu },
+    :arginine => { :letter => :R, :short => :Arg },
+    :lysine => { :letter => :K, :short => :Lys },
+    :asparagine => { :letter => :N, :short => :Asn },
+    :methionine => { :letter => :M, :short => :Met },
+    :aspartic_acid => { :letter => :D, :short => :Asp },
+    :phenylalinine => { :letter => :F, :short => :Phe },
+    :cysteine => { :letter => :C, :short => :Cys },
+    :proline => { :letter => :P, :short => :Pro },
+    :glutamine => { :letter => :Q, :short => :Gln },
+    :serine => { :letter => :S, :short => :Ser },
+    :glutamic_acid => { :letter => :E, :short => :Glu },
+    :threonine => { :letter => :T, :short => :Thr },
+    :gylcine => { :letter => :G, :short => :Gly },
+    :tryptophan => { :letter => :W, :short => :Trp },
+    :histidine => { :letter => :H, :short => :His },
+    :tyrosine => { :letter => :Y, :short => :Tyr },
+    :isoleucine => { :letter => :I, :short => :Ile },
+    :valine => { :letter => :V, :short => :Val },
+    :stop => { :letter => :*, :short => :Stop }
+  }
+  class << self
+    def [] aa_name
+      @aa ||= {}
+      @aa[aa_name] ||= build_aa aa_name
+    end
+
+    def build_aa aa_name
+      new aa_name
+    end
+  end
+
+  attr_reader :letter, :short, :codons, :name
+  def initialize aa_name
+    raise ArgumentError, "No such amino acid." unless BASE[aa_name]
+    aa_info = BASE[aa_name]
+    @name = aa_name
+    @letter = aa_info[:letter]
+    @short = aa_info[:short]
+    @codons = aa_info[:codons]
+  end
+end
+
+class Codon
+  class << self
+    def [] seq
+      @codons ||= {}
+      @codons[seq] ||= build_codon seq
+    end
+
+    def build_codon seq
+      return nil unless seq.is_a?(Symbol) && seq.to_s =~ /^[ATGC]{3}$/
+      new seq
+    end
+  end
+
+  attr_reader :seq, :aliases, :aa
+  def initialize seq
+    @seq = seq
+    @aa = GeneticCode.aa_for seq
+    @aliases = @aa.codons
+  end
+
+  def degeneracy
+    @degeneracy ||= compute_degeneracy
+  end
+
+  def distance_to codon
+    s1 = seq.to_s
+    s2 = codon.seq.to_s
+    3.times.count do |i|
+      s1[i] != s2[i]
+    end
+  end
+
+  def compute_degeneracy
+    3.times.map do |i|
+      [ "A", "T", "G", "C" ].count do |n|
+        mut = seq.to_s
+        mut[i] = n
+        @aliases.include? mut.to_sym
+      end
+    end
+  end
+end
+
+class TriNuc
+  attr_reader :codon, :pos, :seq, :index, :strand
+  def initialize seq, pos, strand, ind=nil
+    raise ArgumentError, "Sequence is malformed" unless seq && seq =~ /^[ATGC]{3}$/
+    raise ArgumentError, "Three genomic coordinates are required" unless pos.is_a?(Array) && pos.length == 3
+    @seq = seq.to_sym
+    @pos = pos
+    @strand = strand
+    @index = ind
+    @codon = Codon[@seq]
+  end
+end

data/lib/genomic_locus.rb

@@ -0,0 +1,50 @@
+require 'intervals'
+module GenomicLocus
+  include IntervalList::Interval
+  class Position
+    include GenomicLocus
+    attr_accessor :seqname, :pos
+    def initialize seqname, pos
+      @seqname, @pos = seqname, pos
+    end
+
+    alias_method :start, :pos
+    alias_method :stop, :pos
+    def copy
+      self.class.new seqname, pos
+    end
+  end
+
+  class Region
+    include GenomicLocus
+    attr_accessor :seqname, :start, :stop
+    def initialize seqname, start, stop
+      @seqname, @start, @stop = seqname, start, stop
+    end
+
+    def copy
+      self.class.new seqname, start, stop
+    end
+  end
+
+  def loc
+    @loc ||= "#{short_chrom}:#{start}".to_sym
+  end
+
+  def default_stop
+    # this should always be correct! Even if there is a dash.
+    start + ref.size - 1
+  end
+
+  def range
+    @range ||= "#{short_chrom}:#{start}-#{stop}".to_sym
+  end
+
+  def long_chrom
+    @long_chrom ||= "chr#{short_chrom}"
+  end
+
+  def short_chrom
+    @short_chrom ||= seqname.sub(/^chr/,'')
+  end
+end

data/lib/germ/config.rb

@@ -1,8 +1,10 @@
 require 'yaml'
-class TaylorlibConfig
+require 'extlib'
+
+class GermConfig
   def self.get_conf *keys
-    config = TaylorlibConfig.new
-    config.get_key *keys if config.loaded?
+    @config ||= GermConfig.new
+    @config.get_key *keys if @config.loaded?
   end
 
   def initialize
@@ -15,13 +17,14 @@ class TaylorlibConfig
 
   def get_key *keys
     keys.inject(@config) do |obj,key|
+      raise GermConfig::KeyError, "Broken key chain: #{keys}" unless obj
       obj = obj[key]
     end
   end
 
   private
   def config_file
-    ENV["TAYLORLIB_CONF"]
+    ENV["GERM_CONF"]
   end
 
   def file_exists?
@@ -31,4 +34,61 @@ class TaylorlibConfig
   def load_file
     @config = YAML.load File.read(config_file)
   end
+
+  class KeyError < StandardError
+  end
+end
+
+
+module GermDefault
+  CACHE = {}
+
+  def has_default *key_chain
+    @key_chain = key_chain
+  end
+
+  def cache
+    CACHE[self] ||= {}
+  end
+
+  def default
+    # get the default key
+    cache[:default] ||= load_default
+  end
+
+
+  def cache_load key
+    cache[key] ||= load_key(key)
+  end
+
+  def method_missing sym, *args, &block
+    begin
+      cache_load sym
+    rescue GermConfig::KeyError
+      # the key does not exist, try to pass it on
+      super
+    end
+  end
+
+  protected
+  def default_create *args
+    new *args
+  end
+
+  private
+  def key_chain
+    @key_chain ||= name.split(/::/).map do |name| name.snake_case.to_sym; end
+  end
+
+  def load_default
+    key = GermConfig.get_conf *key_chain, :default
+    raise GermConfig::KeyError, "No default key defined!" unless key
+    cache_load key
+  end
+
+  def load_key key
+    args = GermConfig.get_conf *key_chain, key
+    raise GermConfig::KeyError, "No such key defined!" unless args
+    default_create *args
+  end
 end

data/lib/germ/flagstat.rb

@@ -13,6 +13,10 @@ class Flagstat
     end
   end
 
+  def respond_to_missing? sym, include_all = false
+    @flags[sym] || sym.to_s =~ /^chastity_/ || super
+  end
+
   def method_missing(method, *args, &block)
     return @flags[method].first.to_i if @flags[method]
     method.to_s.match(/^chastity_(.*)/) do |m|

data/lib/germ.rb

@@ -1,4 +1,5 @@
 require 'fasta'
+require 'fastq'
 require 'gtf'
 require 'hash_table'
 require 'indelocator'
@@ -9,3 +10,5 @@ require 'mutect'
 require 'oncotator'
 require 'sam'
 require 'vcf'
+require 'genetic_code'
+require 'genomic_locus'