gene_assembler 0.0.9

data/lib/gene_assembler/exonerate_result.rb

@@ -0,0 +1,230 @@
+# Copyright (c) 2010 Dario Guerrero & Almudena Bocinos
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'blast_query.rb'
+require 'blast_hit.rb'
+
+class ExoBlastQuery < BlastQuery
+	attr_accessor :q_frameshift, :s_frameshift
+	def initialize(query_id)
+		super(query_id)
+		@s_frameshift=[]
+	  @q_frameshift=[]
+	end
+end
+
+# Extracts results from blast table's file and uses it to create instances of "BlastQuery" and "BlastHit"
+class ExonerateResult
+
+  # Parser initialization
+  def initialize(input,all)
+    @querys = []
+
+    if input.is_a?(Array)
+    	input.each do |file|
+      	fich = File.open(file,'r')
+      	lines = fich.readlines
+      	fich.close
+      	parse_file(lines,all)
+     	end
+    else
+      fich = File.open(input,'r')
+      lines = fich.readlines
+      fich.close
+      parse_file(lines,all)
+    end
+    query_name=''
+    
+  end
+
+  def parse_file(lines,all)
+    lines_parsed=nil
+    if !all
+      lines_parsed={}
+    else
+      lines_parsed=[]
+    end
+    lines.each do |line|
+			if line=~ /^vulgar:/
+				fields=line.split
+				features={'query_id'=> fields[1], 'query_start_align'=> fields[2], 'query_end_align'=> fields[3], 'query_strand'=> fields[4],'target_id'=> fields[5], 'target_start_align'=> fields[6], 'target_end_align'=> fields[7], 'target_strand'=> fields[8], 'score'=> fields[9], 'align_data'=> fields[10..fields.length]}
+				if all
+				  lines_parsed << features
+				else
+				  if !lines_parsed.key?(features['target_id']) # Añadir valor si no existe
+				    lines_parsed[features['target_id']]=features
+				  else
+				    if features['score']>lines_parsed[features['target_id']]['score'] # Si ya existe una query, ver si la nueva presenta un mayor score y reemplazar la antigua
+				      lines_parsed[features['target_id']]=features
+				    end
+				  end
+				end
+			end
+		end		
+		convert_parsed_lines(lines_parsed)	
+  end
+  
+  def convert_parsed_lines(lines_parsed)
+    lines_parsed.each do |line|
+      align_data=nil
+      features=nil
+      if lines_parsed.class.to_s=='Array'
+        align_data=line['align_data']
+        features=line
+      else #hash
+        align_data=line[1]['align_data']
+        features=line[1]        
+      end
+      tags=[]
+      elm=[]
+      align_data_len=align_data.length-1
+      align_data.each_with_index do |field,c|
+        mod=c.modulo(3)
+        if mod==0 #tag operation      
+          if c>0
+            tags << elm
+          end
+          elm=[] #array q inicia segunda dimension en el array principal
+          elm << field
+        elsif mod==1 # Coordenada relativa del query
+          elm << field.to_i
+        elsif mod==2 # Coordenada relativa del target
+          elm << field.to_i
+        end
+        if align_data_len==c #Guardar ultima operacion x fin de parseo
+          tags << elm
+        end           
+      end
+      hiting(features,tags)
+    end    
+  end
+   
+ 	def hiting(features,tags) #Convierte las coordenadas relativas del exonerate a absolutas tipo blast, definiendo solo los hits		
+  	query=ExoBlastQuery.new(features['target_id'])
+		#Variables para hit
+		if features['target_strand']=='+'
+			reversed=FALSE
+			strand=1
+		else 
+			reversed=TRUE 
+			strand=-1
+		end
+		#------------------
+		start_target=features['target_start_align'].to_i#paso de coord 0 a 1
+		ends_target=0
+		start_query=features['query_start_align'].to_i
+		ends_query=0
+		tag_len=tags.length-1
+		counter_target=start_target
+		counter_query=start_query
+		add=TRUE #Hay casos q hay q realizar la adicion de coordenadas relativas antes de la operacion de guardado, esta varible se define para impedir la suma al final de la iteracion
+		tags.each_with_index do |tag,c|
+			if c==tag_len||tag[0]=='S'||tag[0]=='G'
+				counter_query+=tag[1]
+				counter_target+=(tag[2]*strand)
+				add=FALSE
+			else
+				if tag[0]=='F'
+					query.s_frameshift << counter_query 
+					query.q_frameshift << counter_target
+				end
+				add=TRUE
+			end
+			if tag[0]=='5'||c==tag_len #Comienzo de intron o final de secuencia
+				ends_target=counter_target
+				ends_query=counter_query 
+				
+				# creates the hit
+				hit = BlastHit.new(start_target+1, ends_target, start_query+1, ends_query) 
+				hit.align_len=(ends_target-start_target)*strand
+				hit.ident=0
+
+				hit.gaps=0
+				hit.mismatches=0
+				hit.e_val=0
+				hit.bit_score=0
+
+				hit.score = features['score'].to_i
+				if reversed
+					hit.q_frame = -1
+				else
+					hit.q_frame =1
+				end
+				hit.s_frame = nil
+				
+				hit.reversed=reversed
+				hit.subject_id = features['query_id']
+				hit.full_subject_length=0
+				hit.definition=features['query_id']
+				hit.acc=features['query_id']
+				hit.q_seq=''
+				hit.s_seq=''
+				#puts "#{features['target_id']}\t#{hit.inspect}"
+				query.add_hit(hit)
+			end
+			if add
+				counter_query+=tag[1]
+				counter_target+=tag[2]*strand
+			end
+			
+			if tag[0]=='3' # Final de intron x lo tanto comienzo de exon
+				start_query=counter_query
+				start_target=counter_target
+			end
+		end#end do
+		@querys << query
+	end #def
+
+  # inspect results
+  def inspect
+    res = "Exonerate results:\n"
+    res+= '-'*20
+    res+= "\nQuerys: #{@querys.count}\n"
+    @querys.each{|q| res+=q.inspect+"\n"}
+    return res
+  end
+
+  # find query by name
+  def find_query(querys,name_q)
+    #  newq = querys.find{|q| ( q.find{|h| (h.subject_id)})}
+    new_q=nil
+
+    if !querys.empty?
+      new_q=querys.find{|q| (q.query_id==name_q)}
+    end
+
+    return new_q
+  end
+
+  # check if there are querys
+  def empty?
+
+    return @querys.empty?
+  end
+
+  # get query count
+  def size
+    @querys.size
+  end
+
+  attr_accessor :querys
+end

data/lib/gene_assembler/gff_contig.rb

@@ -0,0 +1,67 @@
+require 'gff_hit'
+require 'gff_snp'
+require 'gff_go'
+require 'gff_localization'
+require 'gff_stop'
+require 'gff_frameshift'
+
+class GffContig
+	def report(contig,seqid,parent,name_mode)
+		features_parent=nil
+		seq=nil # Para especificar la secuencia del contig o del hit
+		
+		#Contig
+		if !parent.nil? #Caso de q cada contig sea una unidad independiente
+			seqid=parent #Se redefine el seqid  con el nombre del contig q actua de parent
+			if !contig.seq.nil? #Se especifica secuencia para el contig hijo ya q Gbrowse toma como secuencia aquella perteneciente al parent, por lo q hay especificar la secuencia del contig en el gff
+				seq=contig.seq
+			end
+		end
+		parent_hit=nil
+		contig_text=[]
+		if parent.nil? #Caso de cada contig sea una unidad independiente
+			parent_hit=contig.name
+			text="#{seqid}\tunknown\t#{contig.type}\t1\t#{contig.length}\t.\t+\t.\tID=#{contig.name};Name=#{contig.name}"
+			contig_text << text
+		end
+		
+		#Hit
+		gff_hit=GffHit.new
+		contig.each_hit{|hit| 
+			text,features_parent= gff_hit.report(hit, parent_hit, seqid, contig.name, name_mode, seq) #En caso de que un contig dependa de otro, features_parent proporcio
+			contig_text << text
+		}
+
+		#Frameshift
+		gff_frameshift=GffFrameshift.new
+		contig.each_q_frameshift{|fs|
+			contig_text << gff_frameshift.report(fs,features_parent,seqid)
+		} 	
+
+		#Stop
+		gff_stop=GffStop.new
+		contig.each_stop{|stop|
+			contig_text << gff_stop.report(stop,features_parent,seqid)
+		} 	
+		
+		#SNP
+		gff_snp=GffSNP.new
+		contig.each_snp_with_index{|snp,n|
+			contig_text << gff_snp.report(snp, features_parent, seqid,n)
+		}
+		
+		#GO
+		gff_go=GffGo.new
+		contig.each_go{|go|
+			contig_text << gff_go.report(go, features_parent, seqid)	
+		}
+
+		#Localization
+		gff_localization=Localization.new
+		contig.each_localization_with_index{|localization,n|
+			contig_text << gff_localization.report(localization,features_parent, seqid, contig, n)	
+		}
+		
+		return contig_text
+	end
+end

data/lib/gene_assembler/gff_dataset.rb

@@ -0,0 +1,152 @@
+require 'gff_feature'
+require 'gff_master_feature'
+class Gff_dataset
+	@@undefined_features=0
+	attr_accessor :master_features, :index	
+	def initialize
+		@master_features={}
+		@index={}	
+	end
+	
+	def master_features
+	  if @master_features.length >1
+	   master_features=@master_features.values
+	  else
+	   master_features=@master_features.to_a[0][1]   
+	  end
+	  return master_features
+	end
+
+	def add_master_feature(master_seq_id, source, type, start, stop, score, strand, phase, attribs)
+		master=nil
+		if @index.key?(master_seq_id)#Check that feature region exists, if exists add master feature like a child of that region
+			attribs['Parent']=master_seq_id
+			master=add_feature(source, type, start, stop, score, strand, phase, attribs)
+			@index[attribs['ID']]=master
+			if stop.to_i > @master_features[master_seq_id].stop #Redefine master_feature with new child
+			  @master_features[master_seq_id].stop=stop.to_i
+			end
+		elsif attribs['ID']==master_seq_id #Check that exists a parent region for master_feature
+			master=Master_feature.new(source, type, start, stop, score, strand, phase, attribs)	
+			@master_features[master_seq_id]=master
+			@index[master_seq_id]=master
+		else #Creates a master feature with his child if it'sn defined master_feature
+			master=Master_feature.new(source, 'region', 1, stop, '.', '.', '.', {'ID'=> master_seq_id})	
+			@master_features[master_seq_id]=master
+			@index[master_seq_id]=master
+			attribs['Parent']=master_seq_id
+			child=master.add_child(source, type, start, stop, score, strand, phase, attribs)
+			@index[attribs['ID']]=child
+		end
+		return master
+	end
+
+	def add_feature(source, type, start, stop, score, strand, phase, attribs)
+		feature=@index[attribs['Parent']].add_child(source, type, start, stop, score, strand, phase, attribs)
+		if !attribs['ID'].nil?
+    		@index[attribs['ID']]=feature
+    	else
+    		@index[feature.attrib('Parent')+'_'+@@undefined_features.to_s]=feature
+    		@@undefined_features+=1
+     	end
+		return feature
+	end
+	
+	def each_feature
+	  @index.each_value do |feature|
+	    yield feature
+	  end
+	end
+	
+	def each_master_feature
+	  @master_features.each_value do |master_feature|
+	    yield master_feature
+	  end
+	end
+
+	def each_id_feat
+	  @index.each do |id,feature|
+	    yield id,feature
+	  end
+	end
+
+	def each_id_master
+	  @master_features.each do |id,master|
+	    yield id,master
+	  end
+	end
+
+	def inspects
+		@master_features.each do |item|
+			item[1].inspects
+		end
+	end
+
+	def feature(hash_key)
+		return @index[hash_key]
+	end
+	
+	def has_type?(type)
+	  has_type=FALSE
+	  @index.each_value do |feature|
+	    if feature.type==type
+	      has_type=TRUE
+	      break
+	    end
+	  end
+	  return has_type
+	end
+
+  def has_source?(source)
+    has_source=FALSE
+    @index.each_value do |feature|
+      if feature.source==source
+        has_source=TRUE
+        break
+      end
+    end
+    return has_source
+  end
+
+  def get(source=FALSE, type=FALSE)
+    features=[]
+    @index.each_value do |feature|
+      s=TRUE
+      if source
+        s=feature.is_source?(source)
+      end
+      t=TRUE
+      if type 
+        t=feature.is_type?(type)
+      end
+           
+      if s&t==TRUE
+        features << feature
+      end
+    end
+    return features
+  end
+
+	def tree
+		@master_features.each_value do |master|
+	    	master.tree
+	    	puts "\n",'--------------------------------'
+    	end
+	end
+
+  def add_parent_to(type_parent,type_child)
+    each_id_feat {|id,feature|
+      if feature.type==type_child
+        new_feature=Feature.new(feature.source, type_parent, feature.start, feature.stop, '.', feature.strand, '.', feature.attribs.dup)
+        feature.change_to_type_id_recursive
+        new_feature.transfer_child(feature.attrib('ID'),feature)
+        @index[feature.attrib('Parent')].child[id]=new_feature
+        @index[id]=new_feature
+        new_feature.each_child {|child|
+          child.attribs['Parent']=new_feature.attrib('ID') #Define new parent
+        }
+      end
+    }
+  end
+  
+end