fstrozzi-Gmap 1.0.0

data/lib/gmap.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/gmap/core.rb'

data/lib/gmap/core.rb

@@ -0,0 +1,269 @@
+
+# Author:: Francesco Strozzi
+# Email:: francesco.strozzi@gmail.com
+# Copyright:: 2008 Francesco Strozzi   
+# License:: The Ruby License
+
+
+
+module Gmap
+
+  # This module allows the parsing of the standard output of Gmap (http://www.gene.com/share/gmap/)
+  # 
+  # Example: 
+  # 
+  #   Gmap::Core.open("output.gmap") do |gmap|
+  #   
+  #     gmap.each_sequence do |seq|
+  #     
+  #       seq.each do |result|
+  #      
+  #         result.query (Query sequence name)
+  #         result.target  (Target sequence name)
+  #         result.q_start (Start coordinate of the query sequence) 
+  #         result.q_end (End coordinate of the query sequence)
+  #         result.start (Start coordintate of the target sequence)
+  #         result.end (End coordinate of the target sequence) 
+  #         result.strand (Strand of the target sequence) 
+  #         result.exons (# exons found) 
+  #         result.coverage (Coverage of the query sequence) 
+  #         result.perc_identity (Pecentage of identity from the alignment)
+  #         result.indels (# insertion or deletions) 
+  #         result.mismatch (# mismatch)  
+  #         result.aa_change (Prediction of AA changes from mismatches and indels found) 
+  #         result.aln (Raw alignment between target and query sequences)
+  #         
+  #         ONLY IF GENE MAPS ARE USED WITH GMAP
+  #
+  #         result.gene_start (Start coordinate of the overlapping gene)
+  #         result.gene_end (End coordinate of the overlapping gene)
+  #         result.gene_id (ID of the overlapping gene)
+  #       end
+  #   
+  #     end
+  #   
+  #   end
+  #
+
+  class Core
+
+    attr_reader :io
+    def initialize(io)
+      @io = io
+    end
+
+    # Open the gmap file for reading
+
+    def self.open(file)
+
+      f = File.open(file)
+      if block_given?
+        yield Gmap::Core.new(f)
+        f.close
+      else
+        Gmap::Core.new(f)
+      end
+    end
+
+    # Close the IO stream on the Gmap file
+
+    def close
+      @io.close
+    end
+
+    # Iterates on every sequence processed by Gmap and returns an array of Gmap::Result objects
+    # each of them corresponding to a Path (result) for that sequence 
+
+
+    def each_sequence
+      start = false
+      res = Gmap::Result.new
+      all_results = []
+      query = nil
+      @io.each_line do |l| 
+         if l=~/>(\d+|\w+)\s/ and !start then 
+           start = true
+           query = "#{$1}"                          
+         elsif l=~/>(\d+|\w+)\s/ and start then
+           res.query = query
+           all_results << res.dup if res.target != nil
+           query = "#{$1}"
+           if block_given?
+             yield all_results
+           else
+             raise ArgumentError, "Block needed"
+           end 
+           all_results.clear
+           res.clear      
+         elsif l=~/Path\s\d+/ and res.target != nil then
+           res.query = query
+           all_results << res.dup
+           res.clear
+         end    
+         res = parse_line(res,l)
+      end
+      if start then
+        res.query = query
+        all_results << res.dup if res.target != nil
+        if block_given?
+          yield all_results
+        else
+          raise ArgumentError, "Block needed"
+        end
+      end
+    end
+
+    private
+
+    # The method is called internally from the Gmap#each_result method, 
+    # to parse the lines in the output of Gmap and save the information into a Gmap::Result object        
+
+    def parse_line(res,l)
+      l.chomp!
+      if res.search_aln then
+        res = get_aln(res,l)
+      else 	
+        case l
+        when /Path \d+:\s+query\s+(\d+)--(\d+)\s+\(\d+ bp\)\s+=>/
+          res.q_start = "#{$1}".to_i
+          res.q_end = "#{$2}".to_i
+        when /Genomic pos:.*\((.*)\sstrand\)/	
+          if "#{$1}"=~/\+/ then
+            res.strand = 1
+          else 
+            res.strand = -1
+          end
+        when /Accessions:\s+(.*):(.*)--(.*)\s+\(out of.*/
+            res.target = "#{$1}"
+            t_start = "#{$2}"
+            t_end = "#{$3}"
+            t_start.gsub!(/,/,'')
+            t_end.gsub!(/,/,'')
+            res.start = t_start.to_i
+            res.end = t_end.to_i
+        when /Number of exons: (\d+)/
+          if res.exons.nil?
+            res.exons = "#{$1}".to_i
+          end	
+        when /Trimmed coverage:\s(.*)\s\(trimmed length/
+          res.coverage = "#$1".to_f if res.coverage.nil?
+        when /Percent identity:\s(.*)\s\(\d+ matches, (\d+) mismatches, (\d+) indels,/
+          if res.perc_identity.nil?	
+            res.perc_identity = "#{$1}".to_f
+            res.mismatch = "#{$2}".to_i
+            res.indels = "#{$3}".to_i
+          end	
+        when /Amino acid changes: (.*)/	
+          aa = "#{$1}"
+          res.aa_change = aa if aa.to_s=~/\w+/
+        when /Alignment for path \d+:/
+          res.set_search
+        when /.*gene_maps\s+\S+:(\d+)..(\d+)\s+(\d+)/	
+            res.gene_start = "#{$1}".to_i
+            res.gene_end = "#{$2}".to_i
+            res.gene_id = "#{$3}".to_i	
+        end
+      end  
+      res
+    end
+
+    # The method is called from 'parse_line' to save the sequence alignment information from the gmap output 
+
+    def get_aln(res,l)
+      
+      if l =~/.*:\d+\s[A|T|C|G].+.*/ then
+        res.aln << l+"\n"
+        res.set_save      
+      end
+
+      if res.c >= 1 and res.c < 3 then
+        res.aln << l+"\n"
+      end
+      res.aln << l+"\n" if l=~/aa.g/
+      res.aln << l+"\n" if l=~/aa.c/
+      if res.c == 3 then
+        res.aln.chomp!
+        res.set_search
+        res.set_save
+      end
+      if res.search_aln and res.save_aln then
+        res.count
+      end
+      res
+    end
+
+
+  end
+
+  # This class store the informations of a single Gmap result
+
+  class Result 
+
+  	attr_accessor :query, :target, :q_start, :q_end, :start, :end, :strand ,:exons, :coverage, :perc_identity, :indels, :mismatch, :aa_change, :gene_start, :gene_end, :gene_id, :aln
+    attr_reader :search_aln, :c, :save_aln
+    
+    def initialize
+        clear
+    end
+    # Initializes all the attributes of the result
+  	def clear
+  		@query = nil
+  		@target = nil
+  		@start = nil
+  		@end = nil
+  		@strand = nil
+  		@exons = nil
+  		@coverage = nil
+  		@perc_identity = nil
+  		@indels = nil
+  		@mismatch = nil
+  		@aa_change = nil
+  		@gene_start = nil
+  		@gene_end = nil
+  		@gene_id = nil
+  		@q_start = nil
+  		@q_end = nil 
+  		@aln = ""
+  		
+  	# Inizalize control attributes
+  		  		 		
+  		@maps = false
+  		@search_aln = false
+  		@save_aln = false
+  		@c = 0
+  	end
+  	
+  	def set_search
+  	  if @search_aln then
+  	    @search_aln = false
+  	  else
+  	    @search_aln = true
+  	  end  
+	  end
+	  
+	  
+  	def set_save
+  	  if @save_aln then
+  	    @save_aln = false
+  	  else
+  	    @save_aln = true
+  	  end  
+	  end
+	  
+	  def count
+      @c += 1
+    end
+
+  protected
+
+    attr_writer :search_aln, :c, :path, :maps
+
+  end
+
+
+end
+
+
+
+
+

data/samples/test.gmap

@@ -0,0 +1,148 @@
+>FIRST
+Paths (8):
+  Path 1: query 14--26 (13 bp) => chr ENSBTAT00000028007:11,489--11,477 (-13 bp)
+    cDNA direction: indeterminate
+    Genomic pos: cow_trans:38,344,745--38,344,733 (- strand)
+    Accessions: ENSBTAT00000028007:11,477--11,489 (out of 16907 bp)
+    Number of exons: 1
+    Coverage: 36.1 (query length: 36 bp)
+    Trimmed coverage: 36.1 (trimmed length: 36 bp, trimmed region: 1..36)
+    Percent identity: 100.0 (13 matches, 0 mismatches, 0 indels, 0 unknowns)
+    Amino acid changes: 
+
+Alignments:
+  Alignment for path 1:
+
+    -ENSBTAT00000028007:11489-11477  (14-26)   100%
+
+                         0     .    :   
+                                        
+ -ENSBTAT00000028007:11489 CTTCGTATTGCTG
+                           |||||||||||||
+                        14 CTTCGTATTGCTG
+                                        
+
+  Path 2: query 1--36 (36 bp) => chr ENSBTAT00000042528:264--229 (-36 bp)
+    cDNA direction: indeterminate
+    Genomic pos: cow_trans:264--229 (- strand)
+    Accessions: ENSBTAT00000042528:229--264 (out of 957 bp)
+    Number of exons: 1
+    Coverage: 100.0 (query length: 36 bp)
+    Trimmed coverage: 100.0 (trimmed length: 36 bp, trimmed region: 1..36)
+    Percent identity: 97.2 (35 matches, 1 mismatches, 0 indels, 0 unknowns)
+    Translation: 2..34 (11 aa)
+    Amino acid changes: K10T [28]
+
+Alignments:
+  Alignment for path 2:
+
+    -ENSBTAT00000042528:264-229  (1-36)   97%
+
+                       0     .    :    .    :    .    :    . 
+aa.g                   1  G  I  H  M  V  K  A  R  P  K  A    
+ -ENSBTAT00000042528:264 GGGAATTCACATGGTTAAGGCTAGGCCTAAAGCTAT
+                         ||||||||||||||||||||||||||||| ||||||
+                       1 GGGAATTCACATGGTTAAGGCTAGGCCTACAGCTAT
+aa.c                   1  G  I  H  M  V  K  A  R  P  T  A    
+
+  Path 3: query 18--31 (14 bp) => chr ENSBTAT00000044819:611--624 (14 bp)
+    cDNA direction: indeterminate
+    Genomic pos: cow_trans:30,682,928--30,682,941 (+ strand)
+    Accessions: ENSBTAT00000044819:611--624 (out of 1972 bp)
+    Number of exons: 1
+    Coverage: 38.9 (query length: 36 bp)
+    Trimmed coverage: 38.9 (trimmed length: 36 bp, trimmed region: 1..36)
+    Percent identity: 100.0 (14 matches, 0 mismatches, 0 indels, 0 unknowns)
+    Amino acid changes: 
+
+Alignments:
+  Alignment for path 3:
+
+    +ENSBTAT00000044819:611-624  (18-31)   100%
+
+                       0     .    :    
+                                       
+ +ENSBTAT00000044819:611 GAAATCTTGACTGA
+                         ||||||||||||||
+                      18 GAAATCTTGACTGA
+
+>SECOND 
+Paths (37):
+  Path 1: query 12--26 (15 bp) => chr chr17:21,154,442--21,154,428 (-15 bp)
+    cDNA direction: indeterminate
+    Genomic pos: bt3.1:609,940,407--609,940,393 (- strand)
+    Accessions: chr17:21,154,428--21,154,442 (out of 70149481 bp)
+    Number of exons: 1
+    Coverage: 41.7 (query length: 36 bp)
+    Trimmed coverage: 41.7 (trimmed length: 36 bp, trimmed region: 1..36)
+    Percent identity: 100.0 (15 matches, 0 mismatches, 0 indels, 0 unknowns)
+    Amino acid changes: 
+
+Alignments:
+  Alignment for path 1:
+
+    -chr17:21154442-21154428  (12-26)   100%
+
+               0     .    :    .
+                                
+ -chr17:21154442 TTCGTATACCGTATT
+                 |||||||||||||||
+              12 TTCGTATACCGTATT
+                                
+
+Maps:
+  Map hits for path 1 (0):
+
+  Path 2: query 9--27 (19 bp) => chr chr11:99,537,167--99,537,185 (19 bp)
+    cDNA direction: indeterminate
+    Genomic pos: bt3.1:195,355,821--195,355,839 (+ strand)
+    Accessions: chr11:99,537,167--99,537,185 (out of 101635058 bp)
+    Number of exons: 1
+    Coverage: 52.8 (query length: 36 bp)
+    Trimmed coverage: 52.8 (trimmed length: 36 bp, trimmed region: 1..36)
+    Percent identity: 94.7 (18 matches, 1 mismatches, 0 indels, 0 unknowns)
+    Amino acid changes: 
+
+Alignments:
+  Alignment for path 2:
+
+    +chr11:99537167-99537185  (9-27)   94%
+
+               0     .    :    .    
+                                    
+ +chr11:99537167 AGGCATGCATGGCCCGAAC
+                 | |||||||||||||||||
+               9 ACGCATGCATGGCCCGAAC
+                                    
+
+Maps:
+  Map hits for path 2 (1):
+    gene_maps   chr11:3711585..3721335  788340
+
+  Path 3: query 1--36 (36 bp) => chr chr22:57,923,909--57,926,444 (36 bp)
+    cDNA direction: indeterminate
+	Genomic pos: bt3.1:1,120,956,262--1,120,953,727 (- strand)
+	Accessions: chr22:57,923,909--57,926,444 (out of 59883977 bp)
+	Number of exons: 2
+	Coverage: 100.0 (query length: 36 bp)
+	Trimmed coverage: 100.0 (trimmed length: 36 bp, trimmed region: 1..36)
+	Percent identity: 100.0 (36 matches, 0 mismatches, 0 indels, 0 unknowns)
+	Translation: 1..36 (11 aa)
+	Amino acid changes: 
+
+Alignments:
+	Alignment for path 3:
+
+	  -chr22:57923925-57923909  (20-36)   100%
+
+	               0     .    :    .    :    .    :    .    :    .
+	aa.g           1 R  A  P  R  R  A  G           E  G  R  G  *  
+	 -chr22:57926444 CGCGCACCTCGGCGTGCAGGTG...CAGGTGAAGGGAGAGGATGA
+	                 ||||||||||||||||||||||||||||||||||||
+	               1 CGCGCACCTCGGCGTGCAG  2500   GTGAAGGGAGAGGATGA
+	aa.c           1 R  A  P  R  R  A  G           E  G  R  G  *  
+
+Maps:
+  Map hits for path 3 (1):
+    gene_maps   chr10:57912718..57926714        507939
+

data/test/unit/gmap_test.rb

@@ -0,0 +1,127 @@
+require 'test/unit'
+require 'lib/gmap'
+
+class GmapTest < Test::Unit::TestCase
+  
+  def setup
+    @data = 'samples/test.gmap'
+  end
+  
+  def test_open
+    assert_nothing_raised do 
+      g = Gmap::Core.open(@data)
+      g.close
+    end
+  end
+  
+  def test_result
+    Gmap::Core.open(@data) do |g|
+      g.each_sequence do |seq|
+        assert_equal 3,seq.size
+        assert_equal 'Array',seq.class.to_s
+        check_first(seq) if seq[0].query == 'FIRST'
+        check_second(seq) if seq[0].query == 'SECOND'  
+      end
+    end
+  end
+  
+  def check_first(seq)
+    # first result
+    assert_equal 'ENSBTAT00000028007',seq[0].target
+    assert_equal 36.1, seq[0].coverage
+    assert_equal 100.0, seq[0].perc_identity
+    assert_equal 0, seq[0].mismatch
+    assert_equal 0, seq[0].indels
+    assert_equal 14, seq[0].q_start
+    assert_equal 26, seq[0].q_end
+    assert_equal -1, seq[0].strand
+    assert_equal 11477, seq[0].start
+    assert_equal 11489, seq[0].end
+    assert_equal 1, seq[0].exons
+    assert_equal nil, seq[0].aa_change
+    assert_match(/CTTCGTATTGCTG/,seq[0].aln)
+    # second result
+    assert_equal 'ENSBTAT00000042528',seq[1].target
+    assert_equal 100.0, seq[1].coverage
+    assert_equal 97.2, seq[1].perc_identity
+    assert_equal 1, seq[1].mismatch
+    assert_equal 0, seq[1].indels
+    assert_equal 1, seq[1].q_start
+    assert_equal 36, seq[1].q_end
+    assert_equal -1, seq[1].strand
+    assert_equal 229, seq[1].start
+    assert_equal 264, seq[1].end
+    assert_equal 1, seq[1].exons
+    assert_equal 'K10T [28]', seq[1].aa_change
+    assert_match(/G  I  H  M  V  K  A  R  P  K  A/,seq[1].aln)
+    assert_match(/GGGAATTCACATGGTTAAGGCTAGGCCTAAAGCTAT/,seq[1].aln)
+    assert_match(/GGGAATTCACATGGTTAAGGCTAGGCCTACAGCTAT/,seq[1].aln)
+    assert_match(/G  I  H  M  V  K  A  R  P  T  A/,seq[1].aln)
+    # third result
+    assert_equal 'ENSBTAT00000044819',seq[2].target
+    assert_equal 38.9, seq[2].coverage
+    assert_equal 100.0, seq[2].perc_identity
+    assert_equal 0, seq[2].mismatch
+    assert_equal 0, seq[2].indels
+    assert_equal 18, seq[2].q_start
+    assert_equal 31, seq[2].q_end
+    assert_equal 1, seq[2].strand
+    assert_equal 611, seq[2].start
+    assert_equal 624, seq[2].end
+    assert_equal 1, seq[2].exons
+    assert_equal nil, seq[2].aa_change
+    assert_match(/GAAATCTTGACTGA/,seq[2].aln)
+  end
+  
+  def check_second(seq)
+    # first result
+    assert_equal 'chr17',seq[0].target
+    assert_equal 41.7, seq[0].coverage
+    assert_equal 100.0, seq[0].perc_identity
+    assert_equal 0, seq[0].mismatch
+    assert_equal 0, seq[0].indels
+    assert_equal 12, seq[0].q_start
+    assert_equal 26, seq[0].q_end
+    assert_equal -1, seq[0].strand
+    assert_equal 21154428, seq[0].start
+    assert_equal 21154442, seq[0].end
+    assert_equal 1, seq[0].exons
+    assert_equal nil, seq[0].aa_change
+    assert_match(/TTCGTATACCGTATT/,seq[0].aln)
+    # second result
+    assert_equal 'chr11',seq[1].target
+    assert_equal 52.8, seq[1].coverage
+    assert_equal 94.7, seq[1].perc_identity
+    assert_equal 1, seq[1].mismatch
+    assert_equal 0, seq[1].indels
+    assert_equal 9, seq[1].q_start
+    assert_equal 27, seq[1].q_end
+    assert_equal 1, seq[1].strand
+    assert_equal 99537167, seq[1].start
+    assert_equal 99537185, seq[1].end
+    assert_equal 1, seq[1].exons
+    assert_equal nil, seq[1].aa_change
+    assert_match(/AGGCATGCATGGCCCGAAC/,seq[1].aln)
+    assert_match(/ACGCATGCATGGCCCGAAC/,seq[1].aln)
+    # third result
+    assert_equal 'chr22',seq[2].target
+    assert_equal 100.0, seq[2].coverage
+    assert_equal 100.0, seq[2].perc_identity
+    assert_equal 0, seq[2].mismatch
+    assert_equal 0, seq[2].indels
+    assert_equal 1, seq[2].q_start
+    assert_equal 36, seq[2].q_end
+    assert_equal -1, seq[2].strand
+    assert_equal 57923909, seq[2].start
+    assert_equal 57926444, seq[2].end
+    assert_equal 2, seq[2].exons
+    assert_equal nil, seq[2].aa_change
+    assert_match(/R  A  P  R  R  A  G           E  G  R  G  \*/,seq[2].aln)
+    assert_match(/CGCGCACCTCGGCGTGCAGGTG\.\.\.CAGGTGAAGGGAGAGGATGA/,seq[2].aln)
+    assert_match(/CGCGCACCTCGGCGTGCAG  2500   GTGAAGGGAGAGGATGA/,seq[2].aln)
+    assert_equal 57912718,seq[2].gene_start
+    assert_equal 57926714,seq[2].gene_end
+    assert_equal 507939,seq[2].gene_id
+  end
+  
+end