gene_assembler 0.0.9

data/lib/gene_assembler/gff_feature.rb

@@ -0,0 +1,175 @@
+class Feature
+	attr_accessor :source, :type, :start, :stop, :score, :strand, :phase, :attribs, :child
+	@@undefined_features=0
+	def initialize(source, type, start, stop, score, strand, phase, attribs)
+		@source=source
+		@type=type
+		@start=start.to_i
+		@stop=stop.to_i
+		if score=='.'
+			@score='.'
+		else
+			@score=score.to_f
+		end
+		@strand=strand
+		if phase=='.'
+			@phase='.'
+		else
+			@phase=phase.to_i
+		end
+		@attribs=attribs
+		if attrib('Name').nil? #Añade el atributo name en base a la ID de forma automatica
+			@attribs['Name']=attrib('ID')
+    else
+      revised_name = @attribs['Name']
+      revised_name.gsub!(';','-')
+      @attribs['Name'] = revised_name
+		end
+		@child={}
+	end
+
+	def add_child(source, type, start, stop, score, strand, phase, attribs)
+	  child=Feature.new(source, type, start, stop, score, strand, phase, attribs)
+	  if !attribs['ID'].nil?
+    		@child[attribs['ID']]=child
+    else
+    		@child[child.attrib('Parent')+'_'+@@undefined_features.to_s]=child
+    		@@undefined_features+=1
+    end
+    return child
+	end
+	
+	def transfer_child(id,child)
+	  @child[id]=child
+	end
+	
+	def each_child
+	  @child.each_value do |child|
+	    yield child
+	  end
+	end
+	
+	def attrib(tag)
+		attrib=@attribs[tag]
+		return attrib
+	end
+
+  def each_tag_attrib
+    @attribs.each do |tag,attrib|
+      yield tag,attrib
+    end
+  end
+
+	def inspects
+		print attrib('ID')+" ---> "
+		@child.keys.each do |ch|
+			print "#{ch} (#{@child[ch].count})\t"
+		end
+		print "\n"
+	end
+
+	def count
+		return @child.count
+	end
+
+	def cds
+		cds_exones=[]
+		@child.each do |key_cds|
+			if key_cds[1].type=='CDS'
+				cds_exones << [key_cds[1].start, key_cds[1].stop]
+			end
+		end
+		return cds_exones
+	end
+	
+	def tree(level=0)
+    puts "\t"*level+"#{attrib('ID')}\t\t#{@type}\t#{@source}"
+    level+=1
+    each_child {|child|
+      child.tree(level)
+    }
+	end
+	
+	def is_type?(type)
+	  t=FALSE
+    type=[type].flatten
+    type.each do |typ|
+      if typ == @type
+        t=TRUE
+        break
+      end
+    end
+    return t
+	end
+	
+  def is_source?(source)
+    s=FALSE
+    source=[source].flatten
+    source.each do |sour|
+      if sour == @source
+        s=TRUE
+        break
+      end
+    end
+    return s
+  end
+
+  def compare(feature) #Resultado oscila entre 0 y 1
+    overlap=0
+    if feature.start >= self.start && feature.start <= self.stop && feature.stop >= self.start && feature.stop <= self.stop
+      overlap=feature.length*1.00/self.length
+    elsif  self.start >= feature.start && self.start <= feature.stop && self.stop >= feature.start && self.stop <= feature.stop
+      overlap=1
+    elsif feature.start > self.start && feature.start < self.stop   
+      overlap=(self.stop-feature.start)*1.00/self.length
+    elsif feature.stop > self.start && feature.stop < self.stop
+      overlap=(feature.stop-self.start)*1.00/self.length
+    end
+    return overlap
+  end
+  
+  def length
+    length=self.stop-(self.start-1)
+    return length
+  end
+  
+ 
+  def change_to_type_id_recursive(parent=FALSE)
+    new_parent="#{attrib('ID')}_#{@type}"
+    if !attrib('ID').nil?
+      @attribs['ID']=new_parent
+    end
+
+    if !attrib('Name').nil?
+      @attribs['Name']=new_parent
+    end
+
+    if !attrib('Parent').nil? && parent
+      @attribs['Parent']=parent
+    end
+    
+    each_child {|child|
+      child.change_to_type_id_recursive(new_parent)
+    } 
+  end
+  
+  def write(file,id)
+    file.print "#{id}\t#{@source}\t#{@type}\t#{@start}\t#{@stop}\t#{@score}\t#{@strand}\t#{@phase}\t"
+    each_tag_attrib {|tag,attrib|
+      file.print "#{tag}=#{attrib};"
+    }
+    file.puts #Print \n
+    each_child {|child|
+      child.write(file,id)
+    }
+  end
+
+  def add_attribs(array_attribs)
+    array_attribs.each do |attrib|
+      if !attrib[1].nil?
+        @attribs[attrib[0]]=attrib[1]
+      end
+    end
+  end
+  
+end

data/lib/gene_assembler/gff_frameshift.rb

@@ -0,0 +1,6 @@
+class GffFrameshift
+	def report(fs,parent,seqid)
+		fs_text="#{seqid}\tunknown\tframeshift\t#{fs}\t#{fs}\t.\t+\t.\tParent=#{parent}"
+		return fs_text
+	end
+end

data/lib/gene_assembler/gff_go.rb

@@ -0,0 +1,13 @@
+class GffGo
+	def report(go,parent,seqid)
+		if go.source.nil?
+			go.source='Unknown'
+		end
+		obsolete=nil
+		if go.obsolete
+			obsolete="Obsolete=True"
+		end
+		go_text="#{seqid}\t#{go.source}\tOntology\t#{go.beg}\t#{go.end}\t.\t+\t.\tID=#{parent}_#{go.name}#{go.code};Parent=#{parent};Name=#{go.name}_#{go.code};Note=#{go.name}_#{go.code};#{obsolete}"
+		return go_text
+	end
+end

data/lib/gene_assembler/gff_hit.rb

@@ -0,0 +1,53 @@
+require 'gff_hsp'
+
+class GffHit
+	def report(hit,parent,seqid,id,name_mode,seq)
+		hit_text=[]
+		feature_parent=hit.name #Parent par las demas caracteristicas
+		if name_mode=='l'
+			feature_parent=feature_parent+'_'+hit.type
+		end
+		parent_tag=nil
+		if !parent.nil?# si hay parent, hit se comporta como una estructura tipo proteina, o secuencia nucleotidica. En caso contrario pasara a ser un contig hijo de otro contig ya escrito
+			parent_tag="Parent=#{parent};"
+			name=hit.name
+			feature_parent=id
+		else
+			name=id
+			feature_parent=id			
+		end
+		hit_seq=nil
+		if !seq.nil?
+			hit_seq="seq=#{seq};"
+		end
+		strand='+'
+		if hit.reversed
+			strand='-'
+		end
+		ident="Perc_Qidentities=#{hit.q_p_ident};"
+		if hit.q_p_ident.nil?
+			ident=nil
+		end
+		conserved="Perc_Qconserved=#{hit.q_p_conserved};"
+		if hit.q_p_conserved.nil?
+			conserved=nil
+		end
+		description=nil
+		if !hit.description.nil?
+			description="Note=#{hit.description.gsub(';','_')};"	
+		end
+		if hit.source.nil?
+			hit.source='Unknown'
+		end
+		text="#{seqid}\t#{hit.source}\t#{hit.type}\t#{hit.first_hsp.q_beg}\t#{hit.last_hsp.q_end}\t.\t#{strand}\t.\tID=#{name};#{parent_tag}Name=#{name};#{hit_seq}#{description}#{ident}#{conserved}"
+		hit_text << text
+		gff_hsp=GffHsp.new
+		if hit.hsp_count>1 #Desarrollar si el hit presenta varias coincidencias parciales
+			hit.each_hsp_with_index{|hsp,n|
+				hit_text << gff_hsp.report(hsp,name,seqid,n,hit.type,hit.source)
+			}
+		end
+		return hit_text,feature_parent
+	end
+	
+end

data/lib/gene_assembler/gff_hsp.rb

@@ -0,0 +1,6 @@
+class GffHsp
+	def report(hsp,parent,seqid,n,hit_type,source)
+		text="#{seqid}\t#{source}\t#{hsp.type}\t#{hsp.q_beg}\t#{hsp.q_end}\t.\t+\t.\tParent=#{parent};Name=Hsp_#{n}"
+		return text
+	end
+end

data/lib/gene_assembler/gff_localization.rb

@@ -0,0 +1,6 @@
+class Localization
+	def report(localization,parent, seqid, contig, n)
+		localization_text="#{seqid}\tunknown\tLocalization\t1\t#{contig.length}\t.\t+\t.\tID=#{parent}_loc_#{n};Parent=#{parent};Name=#{localization};Note=#{localization};"		
+		return localization_text
+	end
+end

data/lib/gene_assembler/gff_master_feature.rb

@@ -0,0 +1,5 @@
+require 'gff_feature'
+class Master_feature < Feature
+
+
+end

data/lib/gene_assembler/gff_parser.rb

@@ -0,0 +1,35 @@
+require 'gff_dataset'
+class Gff_parser
+attr_accessor :dataset
+	def initialize(file)
+		@dataset=Gff_dataset.new
+		File.open(file,'r').each do |line|
+			line.chomp!
+			if line=~ /^#/ || line=='' #Skip gff comments and blank lines
+				next
+			end
+			if line=~ /^>/ #Skip sequences
+				break
+			end
+
+			fields=line.split("\t")
+			attribs=parse_attribs(fields.last)
+			if !attribs.key?('Parent')
+				@dataset.add_master_feature(fields[0], fields[1],  fields[2], fields[3], fields[4], fields[5], fields[6], fields[7], attribs)
+			else
+				@dataset.add_feature(fields[1],  fields[2], fields[3], fields[4], fields[5], fields[6], fields[7], attribs) # Feature is a child so it's put on his parent and it hasn't a parent attrib
+			end
+		end
+		return @dataset
+	end
+	
+	def parse_attribs(attribs) #Attribs must be a string with info of last column of gff
+		attribs_hash={}
+		fields=attribs.split(';')
+		fields.each do |attrib|
+			attrib_items= attrib.split('=')
+			attribs_hash[attrib_items[0]]=attrib_items[1]
+		end
+		return attribs_hash
+	end
+end

data/lib/gene_assembler/gff_snp.rb

@@ -0,0 +1,21 @@
+class GffSNP
+	def report(snp, parent, seqid,n)
+		depth="Depth=#{snp.depth};"
+		if snp.depth.nil?
+			depth=nil
+		end
+		zygosity="Zygosity=#{snp.zygosity};"
+		if snp.zygosity.nil?
+			zygosity=nil	
+		end
+		mapping_qual="Mapping_qual=#{snp.mapping_qual};"
+		if snp.mapping_qual.nil?
+			mapping_qual=nil
+		end
+		strand_bias="Strand_bias=#{snp.strand_bias};"
+			if snp.strand_bias.nil?
+		end
+		snp_text="#{seqid}\t#{snp.source}\tSNP\t#{snp.position}\t#{snp.position}\t.\t+\t.\tID=#{parent}_SNP_#{n};Parent=#{parent};Name=#{snp.ref} -> #{snp.var};Note=#{snp.ref} -> #{snp.var};#{depth}#{zygosity}#{mapping_qual}#{strand_bias}"
+		return snp_text
+	end
+end

data/lib/gene_assembler/gff_stop.rb

@@ -0,0 +1,6 @@
+class GffStop
+	def report(stop,parent,seqid)
+		stop_text="#{seqid}\tunknown\tstop_gained\t#{stop}\t#{stop+2}\t.\t+\t.\tParent=#{parent}"
+		return stop_text
+	end
+end

data/lib/gene_assembler/go.rb

@@ -0,0 +1,13 @@
+class GO
+	attr_accessor :code, :ontology, :beg, :end, :source, :name, :obsolete 
+	def initialize(code,name,obsolete)
+		@beg=nil
+		@end=nil
+		@source=nil
+		@code=code
+		@name=name
+		@obsolete=obsolete
+	end
+end
+	
+			

data/lib/gene_assembler/hit.rb

@@ -0,0 +1,191 @@
+require 'hsp'
+class Hit
+	attr_accessor :name, :hsps, :s_length, :reversed, :type, :source, :description, :e_value, :q_p_ident, :q_p_conserved
+	def initialize (hit_name, s_length, q_frame, type)
+		@name=hit_name #Nombre tomado del subject_id
+		#@s_seq=s_seq #Secuencia del subject
+		#@q_seq=q_seq #Secuencia del query
+		@s_length=s_length # Longitud total del subject
+		@hsps=[]
+		if q_frame>0
+			@reversed=FALSE
+		else
+			@reversed=TRUE
+		end
+		@type=type
+		@source=nil
+		@description=nil
+		@e_value=nil
+		@q_p_ident=nil
+		@q_p_conserved=nil
+		
+	end
+	
+	def add_hsp(q_beg, q_end, s_beg, s_end, align_len, score, ident, gaps)
+		hsp= Hsp.new(q_beg, q_end, s_beg, s_end, align_len, score, ident, gaps)
+		@hsps << hsp
+		return hsp
+	end
+	
+  def each_hsp
+  	@hsps.each do |hsp|
+  		yield hsp
+  	end
+  end
+  
+  def hsp_at(n)
+  	hsp_at=nil
+  	each_hsp_with_index{|hsp,i|
+  		if n==i
+  			hsp_at=hsp
+  			break
+  		end
+  	}
+  	return hsp_at
+  end
+
+  def each_hsp_with_index
+  	@hsps.each_with_index do |hsp,i|
+  		yield hsp,i
+  	end
+  end
+	
+	def hsps_sort! # Se ordenan los hsps en base a posicion en el subject
+		@hsps.sort!{|e1,e2| e1.s_beg<=>e2.s_beg}
+	end
+	
+	def hsp_count
+		n=0
+		each_hsp{|hsp|
+			n+=1
+		}
+		return n
+	end
+	
+	def first_hsp
+	  h=nil
+	  each_hsp{|hit|
+	     h=hit
+	     break
+	  }
+	  return h
+	end
+
+	def last_hsp
+	  h=nil
+	  each_hsp{|hit|
+	     h=hit
+	  }
+	  return h
+	end
+	
+	def hsps_correlative?  # Ver si los hsps del hit son contiguos en la query
+		is_correlative=FALSE
+		ends=0
+		each_hsp_with_index{|hsp,i|
+			if i==0
+				ends=hsp.q_end
+				next
+			end
+			if (ends-hsp.q_beg).abs>3
+				is_correlative=TRUE
+				break
+			end
+			ends=hsp.q_end
+		}
+		return is_correlative
+	end
+	
+	def modified_coordenates(add)
+		each_hsp{|hsp|
+			hsp.modified_coordenates(add)
+		}
+	end
+	
+	def rev_coord(contig_length)
+		each_hsp{|hsp|
+			hsp.rev_coord(contig_length)
+		}
+	end
+	
+	def hsp_overlap
+	  overlap=[]
+	  last_hsp=nil
+	  each_hsp_with_index{|hsp,i|
+	    if i>0
+	      diference=hsp.overlap_with(last_hsp)
+	      if diference<0
+	        overlap << diference
+	      end
+	    end
+	    last_hsp=hsp
+	   }
+	   return overlap
+	end
+	
+	def overlap_with(last_hit)
+	  overlap=0
+	  if self.name==last_hit.name
+	    diference=self.first_hsp.overlap_with(last_hit.last_hsp)
+	    if diference<0
+	      overlap=diference
+	    end
+	  end
+	  return overlap
+	end
+	
+	def hsp_minor_than?(hsp_length)# En nt
+		minor=FALSE
+		each_hsp {|hsp|
+			if hsp.length_q < hsp_length
+				minor=TRUE
+				break
+			end	
+		}
+		return minor
+	end
+	
+	def correct_hsps(blast_coor_type)# 's' => subject, 'q' => query 
+#	  puts self.inspect
+    if hsp_count>1
+	    delete_hsps=[]
+  	  each_hsp_with_index{|hsp,i|
+  	    each_hsp_with_index{|hsp_second,j|
+  	      if i==j
+  	        next
+  	      end
+#  	      puts hsp.compare(hsp_second)
+          compare=nil
+          if blast_coor_type == 's'
+            compare = hsp.compare(hsp_second)
+          else
+            compare = hsp.compare_q(hsp_second)
+          end
+  	      if compare >= 0.9
+  	        if hsp.score == hsp_second.score # En caso de hsps con scores iguales, nos quedamos con el mas pequeño
+  	          if hsp.align_len == hsp_second.align_len # Si dos hsps son exactamente iguales eliminamos el segundo
+  	            delete_hsps << j
+  	          elsif hsp.align_len < hsp_second.align_len
+  	            delete_hsps << j
+  	          else
+  	            delete_hsps << i
+  	          end  	        
+  	        elsif hsp.score > hsp_second.score
+  	          delete_hsps << j
+  	        else
+  	          delete_hsps << i
+  	        end
+  	      end
+  	    }
+  	  }
+  	  delete_hsps.uniq!
+  	  delete_hsps.reverse_each do |hsp|
+  	    drop_hsp(hsp)
+  	  end
+	  end
+	end
+	
+	def drop_hsp(position)
+	  hsps.delete_at(position)
+	end
+end