bio-assembly 0.0.0

data/lib/bio-assembly.rb

@@ -0,0 +1,169 @@
+
+require 'bio/sequence'
+require 'bio-assembly/contig'
+require 'bio-assembly/read'
+
+module Bio
+
+  class Assembly
+    attr_accessor :contigs
+  
+    def initialize(path)
+      @file = File.new(path, 'r') 
+      @contigs = Array.new
+      parse_as
+    end
+    
+    def contigs
+      # use each_contig to stream large files
+      parse_whole_file if @contigs.empty?
+      @contigs
+    end
+  
+    def each_contig
+      # check if file is already parsed
+      if @total_num_contigs.to_i == @contigs.size
+        @contigs.each{ |contig| yield contig }
+      else
+        each_identifier do |identifier, attrs|
+          next unless identifier == 'CO'
+          contig = parse_contig(attrs)
+          @contigs.push contig
+          yield(contig)   
+        end
+      end
+    end
+    
+    def to_ace
+      ace = ""
+      ace += "AS " + num_contigs.to_s + " " + num_reads.to_s + "\n\n"
+      each_contig { |contig| ace += contig.to_ace + "\n" }
+      ace
+    end
+  
+    private
+  
+    def parse_contig(attrs)
+      contig = Bio::Assembly::Contig.new
+      contig.name, base_num, @num_reads, base_segments_num, contig.orientation = attrs.split(" ")
+      # keep track of the number of RD identifiers parsed
+      @num_rds_parsed = 0
+      
+      # get sequence
+      seq = @file.gets("\n\n").tr(" \r\n", "")
+      contig.seq = seq
+    
+      # loop through identifiers (e.g AF, RD, etc)
+      each_identifier do |identifier, attrs|    
+        case identifier
+          when "BQ" then parse_bq(contig)
+          when "AF" then parse_af(contig, attrs)
+          when "BS" then parse_bs(contig, attrs)
+          when "RD" then parse_rd(contig, attrs); break if @num_rds_parsed == @num_reads.to_i
+          when "WR" then parse_wr(contig, attrs)
+          when "RT" then parse_rt(contig, attrs)
+          when "CT" then parse_ct(contig, attrs)
+          when "WA" then parse_wa(contig, attrs)
+        end
+      end
+     
+     contig
+    end
+  
+    # Finds the next_identifier
+    def each_identifier
+      @file.each do |line|
+        next if line !~ /^[ABCDQRW][ADFOQRST][\s\n].*/
+        yield(line[0..1], line[3..-1])
+      end
+    end
+    
+    # parse assembly meta data
+    def parse_as
+      line = @file.gets
+      identifier, @total_num_contigs, total_num_reads = line.split(" ")
+    end
+  
+    # parse contig sequence quality data
+    def parse_bq(contig)
+      contig.quality = @file.gets("\n\n").tr("\r\n", "").gsub(/^\s/, "").split(' ')
+    end
+  
+    # parse read meta data
+    def parse_af(contig, attrs)
+      read = Bio::Assembly::Read.new
+      read.name , read.orientation, read.from = attrs.split(" ")
+      contig.add_read read
+    end
+  
+    # parse base sequence data
+    def parse_bs(contig, attrs)
+      from, to, read_name = attrs.split(" ")
+      read = contig.find_read_by_name( read_name )
+      read.add_base_sequence(from, to, read_name)
+    end
+  
+    # parse read sequence and position data
+    def parse_rd(contig, attrs)
+      # increment counter
+      @num_rds_parsed += 1
+      
+      # parse read
+      read_name, num_padded_bases, num_read_infos, num_read_tags = attrs.split(" ") 
+      seq = @file.gets("\n\n").tr( " \r\n", "")
+    
+      # get read with matching name
+      read = contig.find_read_by_name( read_name )
+      read.seq = seq
+      read.to = read.from.to_i + read.seq.length
+      # set read.to to contig length if read runs off contig
+      read.to = contig.seq.length if read.to > contig.seq.length
+    
+      # if present parse QA and DS associated with this read
+      each_identifier do |identifier, attrs|
+        case identifier
+          when "QA" then parse_qa(read, attrs)
+          when "DS" then parse_ds(read, attrs); break
+        end
+      end
+   
+    end
+  
+    # parse a read's clear ranges (the part of the read that contributes to the contig)
+    def parse_qa(read, attrs)
+      start, stop, clear_range_from, clear_range_to = attrs.split(" ")
+      read.clear_range_from = clear_range_from
+      read.clear_range_to = clear_range_to
+    end
+  
+    # parse file data - ignored
+    def parse_ds(read, attrs)
+    end
+  
+    # parse run meta data - ignored
+    def parse_wa(contig, attrs)
+    end
+    
+    # parse run meta data - ignored
+    def parse_ct(contig, attrs)
+    end
+    
+    def num_contigs
+      contigs.size
+    end
+    
+    def num_reads
+      read_num = 0
+      each_contig { |contig| read_num += contig.num_reads }
+      read_num
+    end
+    
+    def parse_whole_file
+      each_contig { |x| 1 }
+    end
+  
+  end
+
+end
+
+

data/lib/bio-assembly/contig.rb

@@ -0,0 +1,97 @@
+module Bio
+  class Assembly
+    
+    class Contig 
+      attr_accessor :seq, :orientation, :quality, :to, :from, :name, :reads
+      alias consensus_seq seq
+
+      def initialize(str="")
+        @reads = Hash.new
+        @seq = Bio::Sequence::NA.new(str)
+        # counter for RD identifier
+        @rds_parsed = 0
+      end
+
+      def find_read_by_name(name)
+        @reads[name]
+      end
+      
+      def find_reads_in_range(clear_range_from, clear_range_to)
+        reads_in_range = Array.new
+        each_read do |read|
+          
+          # Read starts in region
+          if read.from+read.clear_range_from > clear_range_from and read.from+read.clear_range_from < clear_range_to
+             reads_in_range.push read
+          # Read ends in region
+          elsif read.to+read.clear_range_to < clear_range_to and read.to+read.clear_range_to > clear_range_from
+             reads_in_range.push read
+          # Read encompasses region
+          elsif read.from+read.clear_range_from < clear_range_from and read.to+read.clear_range_to > clear_range_to
+             reads_in_range.push read
+          end
+          
+        end
+        reads_in_range;
+      end
+      
+      def add_read(read)
+        # TODO do some checks for pos location
+        @reads[read.name] = read
+      end
+  
+      def each_read
+        @reads.each_value { |read| yield read }
+      end
+      
+      def num_reads
+        @reads.size
+      end
+      
+      def num_bases
+        seq.length
+      end
+      
+      def num_base_segments
+        num_base_sequences = 0
+        each_read do |read|
+          num_base_sequences += read.base_sequences.size unless read.base_sequences.nil?
+        end
+        num_base_sequences
+      end
+      
+      def to_ace
+        ace = ""
+        ace += ['CO', name, num_bases, num_reads, num_base_segments, orientation].join(' ') + "\n"
+        ace += seq.to_s.gsub(Regexp.new(".{1,50}"), "\\0\n") + "\n"
+        ace += "BQ\n"
+        last_stop = quality.size - 1
+        (quality.size/50+1).times do |i|
+          start = i * 50
+          stop = (i+1) * 50 - 1
+          stop = last_stop if stop > last_stop
+          ace += ' ' + quality[start..stop].join(' ')  + "\n"
+        end
+        ace += "\n"
+        
+        # holds BS data for reads
+        bs_str = ""
+        # holds RD, QA, and DS data for reads 
+        rest_str = ""
+        @reads.values.sort.each do |read|
+          ace += read.to_ace_af
+          bs_str += read.to_ace_bs
+          rest_str += read.to_ace_rest
+        end
+        
+        # compile data in correct order
+        ace += bs_str
+        ace += "\n"
+        ace += rest_str
+        ace
+      end
+
+    end
+    
+  end
+end

data/lib/bio-assembly/read.rb

@@ -0,0 +1,93 @@
+
+require 'bio-assembly/read/ace'
+
+module Bio
+  class Assembly
+    class Read 
+      include Bio::Assembly::Read::Ace
+      
+      attr_accessor :seq, :name, :orientation, :from, :to, :clear_range_from, :clear_range_to
+      def initialize(str="")
+       @seq = Bio::Sequence::NA.new(str)
+      end
+      
+      def ==(other_read)
+         name == other_read.name
+      end
+      
+      def num_bases
+        seq.length
+      end
+      
+      def from=(new_from)
+        @from = new_from.to_i
+      end
+      
+      def to=(new_to)
+        @to = new_to.to_i
+      end
+      
+      def clear_range_from=(new_clear_range_from)
+        @clear_range_from = new_clear_range_from.to_i
+      end
+      
+      def clear_range_to=(new_clear_range_to)
+        @clear_range_to = new_clear_range_to.to_i
+      end
+      
+      def to_ace
+        ace += ""
+        # holds BS data for reads
+        bs_str = ""
+        # holds RD, QA, and DS data for reads 
+        rest_str = ""
+        ace += to_ace_af
+        bs_str += to_ace_bs
+        rest_str = to_ace_rest
+        
+        # compile data in correct order
+        ace += bs_str
+        ace += "\n"
+        ace += rest_str
+        ace
+      end
+      
+      def <=>(other)
+        unless other.kind_of?(Bio::Assembly::Read)
+          raise "[Error] markers are not comparable"
+        end
+        if self.from == other.from
+          # sort by to if froms are identical
+          return self.to.<=>(other.to)
+        else
+          return self.from.<=>(other.from)
+        end
+      end
+      
+      def to_ace_bs
+        bs_str = ""
+        unless base_sequences.nil?
+          base_sequences.each do |bs|
+            bs_str += ['BS', bs.from, bs.to, bs.read_name].join(' ') + "\n"
+          end
+        end
+        bs_str
+      end
+      
+      def to_ace_af
+        ['AF', name, orientation, from].join(' ') + "\n"
+      end
+      
+      def to_ace_rest
+        rest_str = ""
+        rest_str += ['RD', name, num_bases, 0, 0].join(' ') + "\n"
+        rest_str += seq.to_s.gsub(Regexp.new(".{1,50}"), "\\0\n")  + "\n"
+        rest_str += ['QA', clear_range_from, clear_range_to, clear_range_from, clear_range_to].join(' ') + "\n"
+        rest_str += ['DS', 'CHROMAT_FILE:', name, 'PHD_FILE:', "#{name}.phd.1", 'TIME:', Time.now].join(' ') + "\n"
+        rest_str
+      end
+      
+    end
+    
+  end
+end

data/lib/bio-assembly/read/ace.rb

@@ -0,0 +1,39 @@
+module Bio
+  class Assembly
+    class Read
+      
+      module Ace 
+        attr_accessor :base_sequences
+        
+        def add_base_sequence(from, to, read_name)
+          @base_sequences = Array.new if @base_sequences.nil?
+          @base_sequences.push BaseSequence.new(from, to, read_name)
+        end
+        
+        class BaseSequence
+          attr_accessor :from, :to, :read_name
+          
+          def initialize(from, to, read_name)
+            @from = from
+            @to = to
+            @read_name = read_name
+          end
+          
+          def <=>(other)
+            unless other.kind_of?(Bio::Assembly::Read::BaseSequence)
+              raise "[Error] markers are not comparable"
+            end
+            if self.from == other.from
+              # sort by to if froms are identical
+              return self.to.<=>(other.to)
+            else
+              return self.from.<=>(other.from)
+            end
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bio-assembly'
+
+class Test::Unit::TestCase
+end

data/test/test_bio-assembly.rb

@@ -0,0 +1,78 @@
+require 'helper'
+
+class TestBioAssembly < Test::Unit::TestCase
+
+     def setup
+       ace_filename = File.join('data', 'example1.ace')
+       @obj = Bio::Assembly.new(ace_filename)
+
+       # pick a contig to do in depth tests on
+       @contig = nil
+       @obj.each_contig { |c| @contig = c if c.name.to_i == 5 }
+
+       # pick a read to do in depth tests on
+       @read = nil
+       @contig.each_read{ |r| @read = r if r.name == '235283518' }
+     end
+
+     def test_num_contigs_parsed
+       contigs_parsed = 13
+       assert_equal(contigs_parsed, @obj.contigs.size)
+     end
+
+     def test_num_reads_parsed
+       reads_parsed_known = 1760
+       reads_parsed = 0
+       @obj.contigs.each { |c| reads_parsed += c.reads.size }
+       assert_equal(reads_parsed_known, reads_parsed)
+     end
+
+     def test_contig_num_reads
+       num_reads = 15
+       assert_equal(num_reads, @contig.reads.size )
+     end
+
+     def test_contig_seq
+       seq = "TTTCCGTCAGATGTAAAGGTTGCAGAACCGGACCATTCTTGCGTCTGATCTTTCAGGATCGGATCGTTGGCGTCGAACTTATCGCTGTCTTTAAAGACACGGCCCGCGTTTTTCCAGCTGTCGATTGAGTTGTCGCCGACCTTTTGATAAAACATGTAGATTGATGTGTCATCAGCGTCTTTCGGGCTTCCCGCAAGAGCAAACACAACGTGATAGCCGTTGTATTCAGCTACTGTTCCGTCAGCGTTTTGCAGCGGCCAGCTGTCCCACACATCAAGTCCTTTTGCAGACTCAATATTTTTAATCGTTGATTGATCGAATTGAGGCACTTGGTATTTTTCGTTTTGCTGCTGTTTAGGGATCTGCAGCATATCATGGCGTGTAATATGAGAGACGCCGTACGTTTCTTTGTATGCTTTTTGGTTATTTTCTTTCGCGAAGGCTTGAGTCGCTCCTCCTGCCAGAAGTGCAGTCGTAAAAGTCAGAACTGTGGCTTGTTTTACAATTTTTTTGATGTTCATGTTCATGTCTCCTTCTGTATGTACTGTTTTTTGCGATCTGCCGTTTCGATCCTCCCGAATTGACTAGTGGGTAGGCCTGGCGGCCGCCTGGCCGTCGACATTTAGGTGACACTATAGAAGGATCCGCGGAATTCCTTTTTAGATTGAGATAATGACTTTGTTTGGAAGGATGTA*TTTTCATTTAATTAAAGCAAATTCGTAATAAT*AAAGTTAAACAATTTAATTTCAAGATGATTCACAGGTTTGTTGCCTCAAAAGAAAACTTATATTAATGGCAAGTTGTGAATAATTTATGCAACTCTTGTGGACAAGTTGACTCAACTTTTCAC*TTTATGTTATATTGTAAGGATGTGACTTTGTTTTGGAAAATTATATTTAATTTGATAATTAACCAATATAAAAAAGATAAACCAAAAGCTATAAGTCGTAAATAAGGACATTGGAAACAAGAAATATTCTCTCCTGAACATTATTTTAAATTATGCGCAATATGCAAATTTATAAGTGTTAAGTTAAAAAGATTGTTAATGGTTCTGTTTATTACCCAAAGACTTTTTTAAAGTTTAAGTCGTTGCTAAGAGTGCAGCGTTTAGACAAATAAAAATGCAATAATCTTCTCGCTCGGGAGCTATGTCCCTCGCATAATATTCTTCAAAGTGTACAGTAAATATTCTAGAAAAGTGAAGTGTGAAAAAGATATATTGCTTGTTTTTATATTTTGTTAATACAACAAAACTTCAAAAACCTGCGGTGGGGGGGGGGGGATAGTCACTTCCGTCACCTTCACCCCTCTCGTTCACTATACTCCCTCGCCCTGGCGTAATGATGGGGGGATTGGGGGTAGTTGCCCCTTAATAAAGTTCAAACTTGATTTATTTCTAACTCGATACCAGTGATTTACAAATGTTTCTGAAATGGCATGGTTTTCCCTAATAAATGCCTAAAAACCCTGAGCTGAGCCCACGCCAATT"
+       assert_equal(seq, @contig.seq.to_s)
+     end
+
+     def test_read_seq
+       read_seq = 'GAAAAAAAAAGGCAGAAGTTTAATCAAAACGGATTTTTCCGTCAGATGTAAAGGTTGCAGAACCGGACCATTCTTGCGTCTGATCTTTCAGGATCGGATCGTTGGCGTCGAACTTATCGCTGTCTTTAAAGACACGGCCCGCGTTTTTCCAGCTGTCGATTGAGTTGTCGCCGACCTTTTGATAAAACATGTAGATTGATGTGTCATCAGCGTCTTTCGGGCTTCCCGCAAGAGCAAACACAACGTGATAGCCGTTGTATTCAGCTACTGTTCCGTCAGCGTTTTGCAGCGGCCAGCTGTCCCACACATCAAGTCCTTTTGCAGACTCAATATTTTTAATCGTTGATTGATCGAATTGAGGCACTTGGTATTTTTCGTTTTGCTGCTGTTTAGGGATCTGCAGCATATCATGGCGTGTAATATGAGAGACGCCGTACGTTTCTTTGTATGCTTTTTGGTTATTTTCTTTCGCGAAGGCTTGAGTCGCTCCTCCTGCCAGAAGTGCAGTCGTAAAAGTCAGAACTGTGGCTTGTTTTACAATTTTTTTGATGTTCATGTTCATGTCTCCTTCTGTATGTACTGTTTTTTGCGATCTGCCGTTTCGATCCTCCCGAATTGACTAGTGGGTAGGCCTGGCGGCCGCCTGGCCGTCGACATTTAGGTGACACTATAGAAGGATCCGCGGAATTCCTTTTTAGATTGAGATAATGACTTTGTTTGGAAGGATGTATTTTTCATTTAATTAAAGCAAATTCGTAATAAT*AAAGTTAAACAATTT*ATTTC*AGATGATTCACAGGTTTGTTGCCTCAAAAG*AAACTTATATTAATGGCAAGTTGTGAATAATTTATGCAACTCTTGTGGGACAAGTTGACTTCACCT'
+       assert_equal(read_seq, @read.seq.to_s)
+     end
+
+     def test_read_range
+       from = -34
+       to = 849
+       assert_equal(to, @read.to)      
+       assert_equal(from, @read.from)
+     end
+
+     def test_read_clear_range
+       clear_range_from = 36
+       clear_range_to = 862
+       assert_equal(clear_range_from, @read.clear_range_from)
+       assert_equal(clear_range_to, @read.clear_range_to)      
+     end
+
+     def test_read_orientation
+       orientation = 'U'
+       assert_equal(orientation, @read.orientation)
+     end
+     
+     def test_find_reads_in_range
+        known_reads = [ '235283518', '235288260', '235293813', '235288255', '235283548' ]
+        reads_in_range = @contig.find_reads_in_range(295, 424)
+        assert_equal( 5, known_reads.size )
+        known_reads.each do |read_name|
+          read = Bio::Assembly::Read.new()
+          read.name = read_name
+          reads_in_range.delete(read)
+        end
+        assert_equal(0, reads_in_range.size)
+      end
+
+end
+
+