germ 0.1 → 0.3

data/lib/gtf.rb

@@ -1,209 +1,48 @@
 require 'hash_table'
 require 'intervals'
+require 'genomic_locus'
+require 'genetic_code'
+require 'gtf/gene'
+require 'fasta'
+require 'germ/config'
 
 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
+  extend GermDefault
+  include IntervalList
+
+  def self.default_create file, idx=nil
+    if idx
+      new file, :idx => idx
+    else
+      new file
     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
+  header_off
 
-    # 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
+  class Feature < HashTable::HashLine
+    include GenomicLocus
+    def copy
+      self.class.new @hash.clone, @table
     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
+    def seq
+      @seq ||= @table.fasta.locus_seq self
     end
 
-    def inspect
-      "#<#{self.class.name}:#{object_id} @transcripts=#{@transcripts.count}>"
+    def respond_to_missing? sym, include_all = false
+      self[:attribute].has_key?(sym) || super
     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
+    def method_missing sym, *args, &block
+      if self[:attribute].has_key?(sym)
+        self[:attribute][sym]
+      else
+        super
       end
     end
   end
-
-  def gene name
-    intervals = gene_name[name]
-    @genes[name] ||= GTF::Gene.new intervals if intervals
-  end
+  line_class GTF::Feature
 
   def initialize file, opts=nil
     opts = { :comment => "#", :sep => " "}.merge(opts || {})
@@ -214,27 +53,20 @@ class GTF < HashTable
 
     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 ] ]
+      :types => { :start => :int, :stop => :int, :score => :int, :frame =>
+                  :int, :attribute => [ ";", @sep ] }
   end
 
   def inspect
     "#<#{self.class}:0x#{'%x' % (object_id << 1)} @lines=#{@lines.count}>"
   end
 
-  def to_interval_list
-    IntervalList.new self
+  def fasta
+    @opts[:fasta] || Fasta.default
   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")
+  def add_line hash
+    add_interval(super)
   end
 
   protected

data/lib/hash_table.rb

@@ -9,18 +9,28 @@ class HashTable
   include HashTableAux
 
   class HashLine
-    def initialize h
-      if h.is_a? Array
-        @hash = Hash[h]
-      elsif h.is_a? Hash
-        @hash = h
+    def self.alias_key sym1, sym2
+      define_method sym1 do
+        send sym2
       end
+      define_method "#{sym1}=" do |v|
+        send "#{sym2}=", v
+      end
+    end
+
+    def initialize h, table
+      @hash = Hash[h]
+      @table = table
     end
 
     def update hash
       @hash.update hash
     end
 
+    def set_table t
+      @table = t
+    end
+
     def [] ind
       @hash[ind]
     end
@@ -41,18 +51,48 @@ class HashTable
       @invalid
     end
 
+    def respond_to_missing? sym, include_all = false
+      if sym.to_s =~ /^(.*)=$/
+        true
+      else
+        @hash.has_key?(sym) || super
+      end
+    end
+
     def method_missing sym, *args, &block
-      if @hash[sym]
+      if @hash.has_key? sym
         @hash[sym]
       elsif sym.to_s =~ /(.*)=/ 
         @hash[$1.to_sym] = args.first
       else
-        nil
+        super
+      end
+    end
+
+    def to_s
+      @table.header.map do |h| 
+        format_column h
+      end.join("\t")
+    end
+
+    def format_column column
+      if send(column).is_a?(Hash) && @table.types[column].is_a?(Array)
+        send(column).map do |key,value|
+          if value == true
+            # just print the key
+            key
+          else
+            "#{key}#{@table.types[column][1]}#{value}"
+          end
+        end.join @table.types[column][0]
+      else
+        send(column)
       end
     end
   end
 
   class << self
+    attr_reader :comment
     def line_type
       @line_type || HashLine
     end
@@ -73,44 +113,78 @@ class HashTable
   end
   header_on
 
-  attr_accessor :header
+  attr_accessor :header, :types
   def [](ind)
-    @lines[ind]
-  end
-
-  def method_missing sym, *args, &block
-    if @index[sym]
-      @index[sym]
+    if ind.is_a? Range
+      wrap @lines[ind]
     else
-      super sym, *args, &block
+      @lines[ind]
     end
   end
 
+  def idx key, value=nil
+    @wrapped_index[ [key, value] ] ||= get_wrapped_table key, value
+  end
+
+  def idx_keys(key)
+    @bare_index[key].keys
+  end
+
   def sum(col)
     inject(0) do |sum,line|
       sum += line[col].to_f
     end
   end
 
+  [ :select, :reject, :sort, :sort_by ].each do |meth|
+    define_method(meth) do |&block|
+      wrap @lines.send(meth, &block)
+    end
+  end
+
+  def sample *args
+    samp = @lines.sample *args
+    if samp.is_a? Array
+      wrap samp
+    else
+      samp
+    end
+  end
+
+
   def select! &block
     @lines.select! &block
+    self
   end
 
   def sort_by! &block
     @lines.sort_by! &block
+    self
   end
 
   def use_header?
     self.class.use_header?
   end
 
+  def formatted_header
+    @header.map do |h|
+      @sleeve[h] || h
+    end.join("\t")
+  end
+
+  def preamble
+    @preamble
+  end
+
   def output f
-    f.puts @header.join("\t") if use_header?
+    f.puts preamble
+    f.puts formatted_header if use_header?
     @lines.each do |l|
       l = yield l if block_given?
       next if !l || l.invalid?
-      f.puts format_line(l)
+      f.puts l.to_s
     end
+    true
   end
 
   def inspect
@@ -123,73 +197,135 @@ class HashTable
     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]
+  def initialize(obj=nil,opts={})
+    fix_opts(opts)
+    create_header
+    create_index
     @lines = []
-    @comment = opts[:comment]
-    @types ||= opts[:types]
+    @preamble = []
+    @sleeve = {}
+    @comment = @opts[:comment] || self.class.comment
+
+    if obj && obj.is_a?(String) && File.exists?(obj)
+      parse_file obj
+    elsif obj && obj.is_a?(Array)
+      # it's a stack of lines. Go with it.
+      @lines = obj
+    end
+  end
+
+  def << hash
+    add_line hash
+  end
+
+  def concat other_table
+    raise TypeError unless other_table.is_a? self.class
+    other_table.each do |line|
+      add_line line
+    end
+    self
+  end
 
-    parse_file(file) if file && File.exists?(file)
+  def wrap lines
+    self.class.new lines, @opts.merge( :header => @header.clone, :types => @types.clone )
   end
 
+  def update_index key
+    create_index_for key
+    @lines.each do |line|
+      index_line_to_key line, key
+    end
+  end
+
+  protected
   def add_line hash
     if hash.is_a? HashLine
       @lines.push hash
+      hash.set_table self
     else
       @lines.push create_line(hash)
     end
+    index_line @lines.last
+  end
+
+  def create_header
+    validate_header
+
+    validate_types
+  end
+
+  def validate_header
+    @header = @opts[:header]
+    if @header.is_a? Hash
+      @opts[:types] = @header
+      @header = @header.keys
+    end
+    @skip_header = @opts[:skip_header] && @header
+  end
+
+  def enforce_header
+  end
+
+  def validate_types
+    @types = @opts[:types] || {}
+
+    raise TypeError, "Types must be a Hash!" unless @types.is_a?(Hash)
+
+    @types.each do |key,type|
+      case type
+      when Array
+        raise ArgumentError unless type.length == 2 && type.all?{|n| n.is_a? String}
+      end
+    end
   end
 
-  private
   def parse_file file
     load_file file
+
+    fix_lines
+  end
+
+  def fix_lines
     @lines.each_index do |i|
       @lines[i] = create_line @lines[i]
-      add_index @lines[i] unless @index.empty?
+      index_line @lines[i]
     end
   end
 
-  def create_index idx
-    if !idx
-      @index = {}
-      return
-    end
-    idx = [ idx ] if !idx.is_a? Array
-    @index = Hash[idx.map{|i| [ i, {} ] }]
+  def fix_opts opts
+    @opts = opts
+    @opts[:idx] = [ @opts[:idx] ].flatten.compact
   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 }
+  def create_index
+    @bare_index = {}
+    @wrapped_index = {}
+    @opts[:idx].each do |key|
+      create_index_for key
+    end
   end
 
-  def format_line l
-    @header.map{|h| l[h]}.join("\t")
+  def create_index_for key
+    @bare_index[key] ||= Hash.new do |h,k| h[k] = []; end
   end
 
-  def line_hash s
-    @header.zip(s.split(/\t/))
+  def create_line s
+    self.class.line_type.new s, self
   end
 
-  def is_comment? s
-    @comment && s =~ @comment
+  def index_line line
+    @bare_index.each do |key,table|
+      index_line_to_key line, key
+    end
   end
 
-  protected
-  def create_line s
-    self.class.line_type.new s
+  def index_line_to_key line, key
+    if line.respond_to?(key)
+      @bare_index[key][ line.send(key) ] << line
+    end
   end
 
-  def add_index line
-    @index.each do |key,ind|
-      next if !line[key]
-      (ind[ line[key] ] ||= []) << line
-    end
+  def get_wrapped_table key, value
+    wrap @bare_index[key][value] if @bare_index[key] && @bare_index[key][value]
   end
 end