bio-ngs 0.4.6.alpha.01 → 0.4.6.alpha.02

data/lib/bio/appl/ngs/cufflinks/gtf/gtf.rb

@@ -0,0 +1,23 @@
+module Bio
+  module Ngs
+    module Cufflinks
+      class Gtf
+        #include MarkCall
+        include GtfParser
+        def initialize(file)
+          @fh=File.open(File.absolute_path(file))
+        end
+
+        def source
+          @fh
+        end
+
+        def source=(src)
+          @fh=src
+        end
+
+      end #Gtf
+
+    end
+  end
+end

data/lib/bio/appl/ngs/cufflinks/gtf/gtf_parser.rb

@@ -0,0 +1,248 @@
+# TODO: 
+# * when select or first each trasncript create and index. Be aware to return/crete the right index for the requested filtering.
+#   issue: filtering is applied but the index is created and saved for the original source file.
+
+
+module Bio
+  module Ngs
+    module Cufflinks
+      # TODO use a specific class for each block (transcript)
+      module GtfParser
+        attr_accessor :lazy
+        require 'tempfile'
+        def each_transcript(&block)
+          if @blocks.nil? || @blocks.empty?
+            transcript = Transcript.new
+            @fh.rewind
+            transcript.tra = @fh.readline
+            @fh.each_line do |line|
+              if line =~ /\ttranscript\t/
+                block.call(transcript, @fh.lineno)
+                transcript.clear
+                transcript.tra = line
+              else line =~ /\texon\t/
+                transcript.exons << line
+              end
+            end
+          else #lazy
+            not_lazy
+            blocks_to_run = @blocks
+            @blocks=[]
+            result=select do |transcript|
+              bool_blocks = blocks_to_run.map do |b|
+                b.call(transcript)
+              end
+              !(bool_blocks.include?(nil) || bool_blocks.include?(false))
+            end
+            set_lazy
+            result.send(:each_transcript, &block)
+          end #lazy or not?
+        end
+
+        def select(&block)
+          if is_lazy?
+            @blocks||=[]
+            @blocks << block
+            self
+          else
+            # Find out how to concatenate multiple selections
+            file = Tempfile.new("transcripts")
+            each_transcript do |transcript|
+              if block.call(transcript)
+                file.write transcript.to_s
+              end
+            end
+            gtf=Gtf.new(file.path) unless file.size == 0
+          end
+        end #select
+
+        def multi_exon_with_lengh_and_coverage(length, coverage)
+          select do |transcript|
+            transcript.multi_exons? && (transcript.size > length) && (transcript.attributes[:cov] > coverage)
+          end
+        end
+
+        def multi_exons
+          # mark
+          select do |transcript|
+            transcript.multi_exons? #transcript line and exon line
+          end
+        end
+
+        def mono_exon
+          # mark
+          select do |transcript|
+            transcript.mono_exon? #transcript line and exon line
+          end
+        end
+
+        def length_gt(length)
+          select do |transcript|
+            transcript.size > length
+          end
+        end
+
+
+        def brand_new_isoforms
+          select do |transcript|
+            transcript.brand_new_isoform?
+          end
+        end
+
+        def new_isoforms
+          select do |transcript|
+            transcript.new_isoform?
+          end
+        end
+
+        def annotated_isoforms
+          select do |transcript|
+            transcript.annotated_isoform?
+          end
+        end
+
+        def coverage_gt(size)
+          select do |transcript|
+            transcript.attributes[:cov] > size
+          end
+        end
+
+        def to_gff3(path=".")
+          if File.exists?(File.join(path,"transcripts.gtf"))
+            gffread = GffRead.new
+            gffread.params = {output:"transcripts.gff3"}
+            gffread.run :arguments=>["transcripts.gtf"], :separator=>''
+          else
+            raise ArgumentError, "transcripts.gtf doesn't exists in #{path}"
+          end
+        end #to_gff3
+
+        def to_bed(only_exons=true, &block)
+          each_transcript do |t|
+            block.call(t, t.to_bed(only_exons))
+          end
+        end #to_bed
+
+        def set_lazy
+          @lazy=true
+        end
+
+        def is_lazy?
+          @lazy
+        end
+
+        def not_lazy
+          @lazy = false
+        end
+
+        def save(filename=nil)
+          fn = filename || "#{@fh.path}.gtf"
+          File.open(fn, 'w') do |f|
+            each_transcript do |transcript|
+                f.write transcript
+            end
+          end
+          # dump_idx("#{fn}.idx") #BUGGY this saves the old index in case the user called a select 
+        end #save
+
+        def count
+          size = 0
+          each_transcript do
+            size+=1
+          end
+          size
+        end #count
+
+        def build_idx
+          idx = Hash.new {|h,k| h[k]=[]}
+          idx[:transcripts]
+          idx[:exons]
+          each_transcript do |t, f_lno|
+            # t_idx=(f_lno-t.exons.size-2)
+            idx[:transcripts] << t.byte_length
+            # eidx_b = t_idx +1
+            # t.exons.each_index do |ei|
+            #   idx[t_idx] << eidx_b + ei
+            #   idx[:exons] << eidx_b + ei
+            # end
+          end
+          @idx = idx
+        end #build_idx
+
+        def dump_idx(fn=nil)
+          fn||="#{source.path}.idx"
+
+          build_idx unless defined?(@idx)
+          @idx[:default_hash] = @idx.default
+          @idx.default = nil
+          File.open(fn, "w+") do |f|
+            Marshal.dump(@idx, f)
+          end
+          @idx.default = @idx[:default_hash]
+          fn
+        end #dump_idx
+
+        def load_idx
+          if File.exists?("#{source.path}.idx")
+            @idx = Marshal.load(File.open("#{source.path}.idx"))
+            @idx.default = @idx[:default_hash]
+          else
+            build_idx
+            dump_idx
+          end
+        end # load_idx
+
+        def index
+          @idx
+        end
+
+        # start from 1
+        def read_transcript(n=1)
+          load_idx unless defined?(@idx)
+          if n==1
+            source.seek(0)
+            source.read(@idx[:transcripts][0])
+          elsif n==2
+            source.seek(@idx[:transcripts][0])
+            source.read(@idx[:transcripts][n-1])
+          else
+            source.seek(@idx[:transcripts][0..n-2].sum)
+            source.read(@idx[:transcripts][n-1])
+          end
+        end
+
+        def get_transcript(n=1)
+          r=read_transcript(n)
+          s=r.split("\n").first
+          e=r.split("\n")[1..-1]
+          x=Bio::Ngs::Cufflinks::Transcript.new
+          x.tra= s+"\n"
+          x.exons=e.map{|ei| ei+"\n"}
+          x
+        end
+
+        alias :[]  :get_transcript
+
+      end #GtfParser
+
+    end #Cufflinks
+  end #Ngs
+end #Bio
+
+# class Array
+#   def to_ranges
+#     sorted=self.sort
+#     left = sorted.first
+#     ranges = sorted.compact.uniq.sort.map do |e|
+#       if sorted[sorted.index(e) +1] == e.succ
+#         right = e.succ
+#         nil # set the elements between the ranges to nil
+#       else
+#         range_left = left
+#         left=sorted[sorted.index(e) +1]
+#         range_left == e ? e : Range.new(range_left, e)
+#       end
+#     end
+#     ranges.compact
+#   end
+# end

data/lib/bio/appl/ngs/cufflinks/gtf/transcript.rb

@@ -0,0 +1,154 @@
+
+module Bio
+  module Ngs
+    module Cufflinks
+      class Transcript
+        Fields = %w(seqname source feature start stop score strand frame)
+        Attr_to_Float = %w(FPKM frac conf_lo conf_hi cov)
+        Attr_to_Integer = %w(exon_number)
+        ChrNotation = {ensembl:"", ucsc:"chr"}
+
+        attr_accessor :seqname, :source, :feature, :start, :stop, :score, :strand, :frame, :chr_notation
+
+        def initialize()
+          @tra = nil
+          @exons = []
+          @attributes = {}
+          @chr_notation = :ensembl #ensembl/ucsc
+        end
+
+        def tra
+          if @chr_notation == :ensembl && @tra=~/^chr(.*?)\s/
+            "#{ChrNotation[:ensembl]}#{$1}"
+          elsif @chr_notation == :ucsc && @tra=~/^(.*?)\s/
+            "#{ChrNotation[:ucsc]}#{$1}"
+          else
+            @tra
+          end
+        end
+
+        def exons
+          @exons
+        end
+
+        def exons=(ary)
+          @exons=ary
+        end
+
+        def attributes
+          @attributes
+        end
+        def tra=(line)
+          @tra = line
+          data=line.split
+          @seqname = data[0]
+          @source = data[1]
+          @feature = data[2]
+          @start = data[3].to_i
+          @stop = data[4].to_i
+          @score = data[5]
+          @strand = data[6]
+          @frame = data[7]
+          data[8..-1].join(" ").split(';').each do |attribute|
+            data_attr=attribute.tr('"','').split
+            @attributes[data_attr[0].to_sym]= if Attr_to_Float.include? data_attr[0]
+            data_attr[1].to_f
+          elsif Attr_to_Integer.include? data_attr[0]
+            data_attr[1].to_i
+          else
+            data_attr[1]
+          end
+        end
+      end
+
+      def multi_exons?
+        exons.size > 1
+      end
+
+      def mono_exon?
+        exons.size == 1
+      end
+
+      def size
+        @stop-@start+1
+      end
+
+
+      # def method_missing(meth, *args, &block)
+      #   meth_name = meth.to_s.tr("=")
+      #   if Fields.include? meth_name
+      #     method_define meth_name do |args|
+
+      #     end
+      #   else
+      #     super # You *must* call super if you don't handle the
+      #     # method, otherwise you'll mess up Ruby's method
+      #     # lookup.
+      #     puts "There's no method called #{m} here -- please try again."
+      #   end
+
+      # add last "\n" to last row.
+      def to_s
+        s=tra #+"\n"
+        s << exons.join #("\n") #<< "\n"
+      end
+
+      def to_bed(only_exons=true)
+        bed_str=""
+        unless only_exons
+#          puts seqname
+#TODO fix seqname does not print the right  transcript line
+          if @chr_notation == :ensembl && seqname=~/^chr(.*)/
+            seqname="#{ChrNotation[:ensembl]}#{$1}"
+          elsif @chr_notation == :ucsc && seqname=~/^(.*)/
+            seqname="#{ChrNotation[:ucsc]}#{$1}"
+          end
+
+          bed_str<<"#{seqname}\t#{start}\t#{stop}\t#{attributes[:gene_id]}_#{attributes[:transcript_id]}\n"
+        end
+        exons.each do |e|
+          data = e.tr('";','').split
+          if @chr_notation == :ensembl && data[0]=~/^chr(.*)/
+            data[0]="#{ChrNotation[:ensembl]}#{$1}"
+          elsif @chr_notation == :ucsc && data[0]=~/^(.*)/
+            data[0]="#{ChrNotation[:ucsc]}#{$1}"
+          end
+
+          bed_str<<"#{data[0]}\t#{data[3]}\t#{data[4]}\t#{data[9]}_#{data[11]}\n"
+        end
+        bed_str
+      end
+
+      def clear
+        @tra=""
+        @exons.clear
+      end
+
+      def brand_new_isoform?
+        attributes[:gene_id]=~/CUFF\.\d+/ && attributes[:transcript_id]=~/CUFF\.\d+\.\d+/
+      end
+
+      def new_isoform?
+        attributes[:gene_id]=~/CUFF\.\d+/ && attributes[:transcript_id]!~/CUFF\.\d+\.\d+/
+      end
+
+      def annotated_isoform?
+        attributes[:gene_id]!~/CUFF\.\d+/ && attributes[:transcript_id]!~/CUFF\.\d+\.\d+/
+      end
+
+      def byte_length
+        exons.map{|e| e.length}.sum + tra.length
+      end
+
+      def set_ucsc_notation
+        @chr_notation = :ucsc
+      end
+
+      def set_ensembl_notation
+        @chr_notation = :ensembl
+      end
+
+    end #Transcript
+  end #Cufflinks
+end #Ngs
+end #Bio

data/lib/bio/ngs/fs.rb

@@ -0,0 +1,46 @@
+module Bio
+  module Ngs
+    module FS
+      # def self.included(base)
+      #   base.extend(ClassMethods)
+      # end
+      class << self
+        # Write a file 'merged' which is the concatenation of multipes fastq.gz 'files'
+        # files is an array of filenames
+  	    def cat(files, merged)
+            if files.is_a? Array
+              File.open(merged,'wb') do |fmerge|
+                files.each do |fname|
+                  File.open(fname,'rb:binary') do |file|
+                  	while line = file.gets
+                  		fmerge << line
+                  	end
+                  end #read
+                end #each
+              end #write
+            end #if
+        end #cat
+        alias :merge :cat
+
+
+        def files(everything, suffix=nil)
+          if everything.is_a? String
+            if File.file? everything
+              [File.expand_path(everything)]
+            elsif File.directory? everything
+                files(Dir.glob(File.join(everything, suffix.nil? ? "*" : "*"+suffix)).select{|item| File.file? item}).flatten
+            elsif everything=~/\*/
+              files(Dir.glob(everything)).flatten
+            elsif everything=~/[ ,:;]/
+             files(everything.split(/[ ,:;]/))
+            end
+          elsif everything.is_a? Array
+            everything.map do |item|
+              files(item)
+            end.flatten
+          end
+        end
+      end  #self
+    end #FS
+  end #Ngs
+end #Bio