germ 0.1

data/lib/germ.rb

@@ -0,0 +1,11 @@
+require 'fasta'
+require 'gtf'
+require 'hash_table'
+require 'indelocator'
+require 'intervals'
+require 'maf'
+require 'mutation_set'
+require 'mutect'
+require 'oncotator'
+require 'sam'
+require 'vcf'

data/lib/germ/config.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+class TaylorlibConfig
+  def self.get_conf *keys
+    config = TaylorlibConfig.new
+    config.get_key *keys if config.loaded?
+  end
+
+  def initialize
+    load_file if file_exists?
+  end
+
+  def loaded?
+    @config != nil
+  end
+
+  def get_key *keys
+    keys.inject(@config) do |obj,key|
+      obj = obj[key]
+    end
+  end
+
+  private
+  def config_file
+    ENV["TAYLORLIB_CONF"]
+  end
+
+  def file_exists?
+    config_file && File.exists?(config_file)
+  end
+
+  def load_file
+    @config = YAML.load File.read(config_file)
+  end
+end

data/lib/germ/data_types.rb

@@ -0,0 +1,47 @@
+module DataTypes
+  def attr_accessor_of_type name, type=nil
+    send :define_method, name do
+      instance_variable_get("@#{name}")
+    end
+    send :define_method, "#{name}=" do  |v|
+      if block_given?
+        instance_variable_set "@#{name}", yield(v) 
+      else
+        if v.respond_to? type
+          instance_variable_set "@#{name}", v.send(type)
+        else
+          raise ArgumentException
+        end
+      end
+    end
+  end
+
+  def attr_string *names
+    names.each do |name|
+      attr_accessor_of_type name, :to_s
+    end
+  end
+  def attr_integer *names
+    names.each do |name|
+      attr_accessor_of_type name, :to_i
+    end
+  end
+
+  def attr_sym *names
+    names.each do |name|
+      attr_accessor_of_type name, :to_sym
+    end
+  end
+
+  def attr_array *names
+    names.each do |name|
+      attr_accessor_of_type name do |v|
+        if block_given?
+          yield v
+        else
+          v.split(//)
+        end
+      end
+    end
+  end
+end

data/lib/germ/flagstat.rb

@@ -0,0 +1,23 @@
+class Flagstat
+  def initialize file
+    @headers = [ :total, :duplicates, :mapped, :paired_in_sequence, :read1, :read2, 
+      :properly_paired, :both_mapped, :singletons, :mate_mapped_chr, :mate_mapped_chr_highq ]
+    @flags = Hash[@headers.zip(File.foreach(file).each_with_index.map do |l|
+      l.scan(/([0-9]+) \+ ([0-9]+)/).flatten
+    end)]
+  end
+
+  def each
+    @flags.each do |f,l|
+      yield f,l
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    return @flags[method].first.to_i if @flags[method]
+    method.to_s.match(/^chastity_(.*)/) do |m|
+      return @flags[m[1].to_sym].last.to_i if @flags[m[1].to_sym]
+    end
+    super
+  end
+end

data/lib/germ/printer.rb

@@ -0,0 +1,15 @@
+module Printer
+  def write file, &block
+    File.open(file,"w") do |f|
+      output f, &block
+    end
+  end
+
+  def print f=nil, &block
+    if f
+      write f, &block
+    else
+      output STDOUT, &block
+    end
+  end
+end

data/lib/gtf.rb

@@ -0,0 +1,248 @@
+require 'hash_table'
+require 'intervals'
+
+class GTF < HashTable
+  header_off
+
+  class GTFLine < HashTable::HashLine
+    include IntervalList::Interval
+    def chrom; seqname; end
+    def chrom= nc; seqname = nc; end
+    def copy
+      c = self.class.new @hash.clone
+    end
+  end
+  line_class GTFLine
+
+  class Gene
+    class Transcript
+      attr_reader :name, :intervals, :introns
+      def initialize array, name
+        @intervals = array
+        @name = name
+
+        @transcript = @intervals.find{|t| t.feature == "transcript"}
+
+        build_introns
+      end
+
+      def site pos
+        i = @transcript.clone :pos => pos
+        intron = nil
+        overlaps = @intervals.select{|f| f.contains? i }
+        return cds_pos i if overlaps.find{|f| f.feature == "cds" }
+        return intron_pos intron if intron = overlaps.find{|f| f.feature == "intron" }
+        return utr_pos if overlaps.find{|f| f.feature =~ /UTR/ }
+        { :type => :transcript }
+      end
+
+      
+      def utr_pos
+        { :type => :utr }
+      end
+
+      def intron_frame intron
+        # find the terminal frame of the leading exon
+        if strand == "+"
+          (intron.prev_exon.frame + intron.prev_exon.size)%3
+        else
+          intron.post_exon.frame
+        end
+      end
+
+      def cds_pos pos
+        bases = 0
+        if @strand == "+"
+          cds.each do |c|
+            if c.contains? pos
+              bases += pos - c.start + 1
+              break
+            else
+              bases += c.size
+            end
+          end
+        else
+          cds.reverse.each do |c|
+            if c.contains? pos
+              bases += c.stop - pos + 1
+              break
+            else
+              bases += c.size
+            end
+          end
+        end
+        { :type => :cds, :pos => bases/3 }
+      end
+
+      def intron_pos intron
+        { :type => :intron, :pos => cds_pos(intron.start-1), :frame => intron_frame(intron) }
+      end
+
+      def utr3
+        return @utr3 if @utr3
+        cs = strand == "+" ? cds.first : cds.last
+        @utr3 = exons.select{ |e| strand == "+" ? !e.above?(cs) : !e.below?(cs) }
+          .map{|e| e.strict_diff(cs) }
+          .compact.map(&:to_a)
+        @utr3.each do |u|
+          u.feature = "3' UTR"
+        end
+      end
+
+      def utr5
+        return @utr5 if @utr5
+        cs = strand == "+" ? cds.last : cds.first
+        @utr5 = exons.select{|e| strand == "+" ? !e.below?(cs) : !e.above?(cs) }
+          .map{|e| e.strict_diff(cs)}
+          .compact.map(&:to_a)
+        @utr5.each do |u|
+          u.feature = "5' UTR"
+        end
+      end
+
+      def build_introns
+        return if !exons
+        @introns = exons.map.with_index do |e1,i|
+          e2 = @exons[i+1]
+          next if !e2
+          intron = e1.clone(:start => e1.stop+1, :stop => e2.start-1)
+          intron.feature = "intron"
+          intron.prev_exon = e1
+          intron.post_exon = e2
+          intron
+        end.compact
+        @intervals.concat @introns
+      end
+
+      def build_utrs
+        @intervals.concat @utr3 if @utr3
+        @intervals.concat @utr5 if @utr5
+      end
+
+      def start
+        @transcript.start
+      end
+      def stop
+        @transcript.stop
+      end
+      def strand
+        @transcript.strand
+      end
+      def contains? pos
+        start <= pos && stop >= pos
+      end
+      def exons
+        @exons ||= @intervals.select{|e| e.feature == "exon"}.sort_by &:start
+      end
+      def cds
+        @cds ||= @intervals.select{|e| e.feature == "CDS"}.sort_by &:start
+      end
+    end
+
+    attr_reader :name, :strand, :transcripts, :intervals
+    def initialize array
+      @intervals = array
+      @gene = @intervals.find{|l| l.feature == "gene"}
+      @name = @gene.attribute[:gene_name]
+      @strand = @gene.strand
+      @transcripts = build_transcripts
+    end
+
+    def start
+      @gene.start
+    end
+
+    def stop
+      @gene.stop
+    end
+
+    def site pos
+      score = { :cds => 1, :exon => 2, :utr => 3, :intron => 4, :transcript => 5, :igr => 6 }
+      sites = @transcripts.map do |t|
+        { :gene => name }.update(t.site pos) if t.contains? pos
+      end.compact
+      sites.push(:type => :igr)
+      sites.sort_by{|s| score[s[:type]] }.first
+    end
+
+    # compute unified intervals from the list of intervals
+    def unified
+      ints = @intervals
+      if block_given?
+        ints = ints.select do |i|
+          yield i
+        end
+      end
+      list = IntervalList.new ints, :type => :flat
+      list.collapse!
+      list.to_a
+    end
+
+    def canonical
+      # find out which transcript has the longest cds
+      @transcripts.max_by do |t|
+        t.cds.inject(0) do |sum,cds|
+          sum += cds.size
+        end
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} @transcripts=#{@transcripts.count}>"
+    end
+
+    private
+    def build_transcripts
+      (@intervals.select{|l| l.feature == "transcript"} || []).map do |t|
+        name = t.attribute[:transcript_name]
+        Transcript.new @intervals.select{|l| l.attribute[:transcript_name] == name}, name
+      end
+    end
+  end
+
+  def gene name
+    intervals = gene_name[name]
+    @genes[name] ||= GTF::Gene.new intervals if intervals
+  end
+
+  def initialize file, opts=nil
+    opts = { :comment => "#", :sep => " "}.merge(opts || {})
+
+    @sep = opts[:sep]
+
+    @genes = {}
+
+    super file, :comment => opts[:comment], :idx => opts[:idx],
+      :header => [ :seqname, :source, :feature, :start, :stop, :score, :strand, :frame, :attribute ],
+      :types => [ :str, :str, :str, :int, :int, :int, :str, :int, [ ";", @sep ] ]
+  end
+
+  def inspect
+    "#<#{self.class}:0x#{'%x' % (object_id << 1)} @lines=#{@lines.count}>"
+  end
+
+  def to_interval_list
+    IntervalList.new self
+  end
+
+  def format_line g
+    [ :seqname, :source, :feature, :start, :stop, :score, :strand, :frame, :attribute ].map do |h|
+      if h == :attribute
+        g[:attribute].map do |k,v| 
+          "#{k}#{@sep}#{v}" 
+        end.join("; ")
+      else
+        g[h]
+      end
+    end.join("\t")
+  end
+
+  protected
+  def add_index line
+    @index.each do |key,ind|
+      ikey = line[key] || line[:attribute][key]
+      next if !ikey
+      (ind[ ikey ] ||= []) << line
+    end
+  end
+end

data/lib/hash_table.rb

@@ -0,0 +1,195 @@
+require 'zlib'
+require 'extlib'
+require 'germ/printer'
+require 'hash_table_aux/hash_table_aux'
+
+class HashTable
+  include Enumerable
+  include Printer
+  include HashTableAux
+
+  class HashLine
+    def initialize h
+      if h.is_a? Array
+        @hash = Hash[h]
+      elsif h.is_a? Hash
+        @hash = h
+      end
+    end
+
+    def update hash
+      @hash.update hash
+    end
+
+    def [] ind
+      @hash[ind]
+    end
+
+    def []= ind,v
+      @hash[ind] = v
+    end
+
+    def invalidate!
+      @invalid = true
+    end
+
+    def approve!
+      @invalid = nil
+    end
+
+    def invalid?
+      @invalid
+    end
+
+    def method_missing sym, *args, &block
+      if @hash[sym]
+        @hash[sym]
+      elsif sym.to_s =~ /(.*)=/ 
+        @hash[$1.to_sym] = args.first
+      else
+        nil
+      end
+    end
+  end
+
+  class << self
+    def line_type
+      @line_type || HashLine
+    end
+
+    def line_class klass
+      @line_type = const_get klass.to_s.camel_case
+    end
+
+    def use_header?
+      @use_header
+    end
+    def header_on
+      @use_header = true
+    end
+    def header_off
+      @use_header = nil
+    end
+  end
+  header_on
+
+  attr_accessor :header
+  def [](ind)
+    @lines[ind]
+  end
+
+  def method_missing sym, *args, &block
+    if @index[sym]
+      @index[sym]
+    else
+      super sym, *args, &block
+    end
+  end
+
+  def sum(col)
+    inject(0) do |sum,line|
+      sum += line[col].to_f
+    end
+  end
+
+  def select! &block
+    @lines.select! &block
+  end
+
+  def sort_by! &block
+    @lines.sort_by! &block
+  end
+
+  def use_header?
+    self.class.use_header?
+  end
+
+  def output f
+    f.puts @header.join("\t") if use_header?
+    @lines.each do |l|
+      l = yield l if block_given?
+      next if !l || l.invalid?
+      f.puts format_line(l)
+    end
+  end
+
+  def inspect
+    "#<#{self.class.name}:#{object_id} @lines=#{@lines.count}>"
+  end
+
+  def each
+    @lines.each do |l|
+      yield l
+    end
+  end
+
+  def initialize(file,opts={})
+    @header = opts[:header]
+    @skip_header = opts[:skip_header] && opts[:header]
+    if @header.is_a? Hash
+      @types = @header.values
+      @header = @header.keys
+    end
+    create_index opts[:idx]
+    @lines = []
+    @comment = opts[:comment]
+    @types ||= opts[:types]
+
+    parse_file(file) if file && File.exists?(file)
+  end
+
+  def add_line hash
+    if hash.is_a? HashLine
+      @lines.push hash
+    else
+      @lines.push create_line(hash)
+    end
+  end
+
+  private
+  def parse_file file
+    load_file file
+    @lines.each_index do |i|
+      @lines[i] = create_line @lines[i]
+      add_index @lines[i] unless @index.empty?
+    end
+  end
+
+  def create_index idx
+    if !idx
+      @index = {}
+      return
+    end
+    idx = [ idx ] if !idx.is_a? Array
+    @index = Hash[idx.map{|i| [ i, {} ] }]
+  end
+
+  def set_header s, downcase=nil
+    return nil if @header
+    @header = s.chomp.split(/\t/).map{|s| downcase ? s.downcase.to_sym : s.to_sym }
+  end
+
+  def format_line l
+    @header.map{|h| l[h]}.join("\t")
+  end
+
+  def line_hash s
+    @header.zip(s.split(/\t/))
+  end
+
+  def is_comment? s
+    @comment && s =~ @comment
+  end
+
+  protected
+  def create_line s
+    self.class.line_type.new s
+  end
+
+  def add_index line
+    @index.each do |key,ind|
+      next if !line[key]
+      (ind[ line[key] ] ||= []) << line
+    end
+  end
+end