bio-vcf 0.0.2 → 0.0.3

data/features/support/env.rb

@@ -14,4 +14,9 @@ require 'bio-vcf'
 
 require 'rspec/expectations'
 
+# Add the regression module if in the path (it can also be a gem)
+rootdir = File.dirname(__FILE__) + '/../..'
+$LOAD_PATH.unshift(rootdir+'/lib',rootdir+'/../regressiontest/lib')
+require 'regressiontest'
+
 include BioVcf

data/lib/bio-vcf.rb

@@ -8,7 +8,9 @@
 #
 # In this file only require other files. Avoid other source code.
 
+require 'bio-vcf/utils'
 require 'bio-vcf/vcf'
+require 'bio-vcf/vcfsample'
 require 'bio-vcf/vcfheader'
 require 'bio-vcf/vcfline'
 require 'bio-vcf/vcfgenotypefield'

data/lib/bio-vcf/utils.rb

@@ -0,0 +1,23 @@
+module BioVcf
+
+  module ConvertStringToValue
+    def self::integer?(str)
+      !!Integer(str) rescue false
+    end
+
+    def self::float?(str)
+      !!Float(str) rescue false
+    end
+
+    def self::convert v
+      if integer?(v)  # the common case
+        v = v.to_i
+      else
+        # 150.268 or 9.68463e-05
+        v = v.to_f if float?(v)
+      end
+      v
+    end
+  end
+
+end

data/lib/bio-vcf/vcfgenotypefield.rb

@@ -3,23 +3,28 @@ module BioVcf
   MAXINT=100_000
 
   # Helper class for a list of (variant) values, such as A,G. 
-  # The [] function does the hard work (see ./features for examples)
-  class VcfNucleotides 
+  # The [] function does the hard work. You can pass in an index (integer)
+  # or nucleotide which translates to an index.
+  # (see ./features for examples)
+  class VcfNucleotideCount4
     def initialize alt,list
       @alt = alt
-      @list = list.map{|i| i.to_i}
+      @list = list.split(/,/).map{|i| i.to_i}
     end
   
     def [] idx
       if idx.kind_of?(Integer)
-        @list[idx].to_i
+        # return a value
+        @list[idx]
       elsif idx.kind_of?(String)
-        @list[["A","C","G","T"].index(idx)].to_i
+        # return a value
+        @list[["A","C","G","T"].index(idx)]
       else idx.kind_of?(Array)
+        # return a list of values
         idx.map { |nuc|
           idx2 = ["A","C","G","T"].index(nuc)
           # p [idx,nuc,idx2,@list]
-          @list[idx2].to_i
+          @list[idx2]
         }
       end
     end
@@ -47,10 +52,11 @@ module BioVcf
 
   end
 
-  class VcfAltInfo
+  # Handle info fields with multiple entries, possibly relating to ALT (single nucleotide only)
+  class VcfAltInfoList
     def initialize alt,list
       @alt = alt
-      @list = list.map{|i| i.to_i}
+      @list = list.split(/,/).map{|i| i.to_i}
     end
   
     def [] idx
@@ -86,43 +92,78 @@ module BioVcf
   end
 
   class VcfGenotypeField
+
+    attr_reader :format, :values, :header
+
     def initialize s, format, header, alt
-      @values = s.split(/:/)
+      @is_empty = (s == '' or s == nil or s == './.')
+      @original_s = s
       @format = format
       @header = header
       @alt = alt
     end
 
-    def dp4
-      @values[@format['DP4']].split(',').map{|i| i.to_i}
+    def values
+      @cache_values ||= @original_s.split(/:/)
     end
 
-    def ad
-      @values[@format['AD']].split(',').map{|i| i.to_i}
+    def empty?
+      @is_empty
     end
 
-    def pl
-      @values[@format['PL']].split(',').map{|i| i.to_i}
+    def valid?
+      !@is_empty
+    end
+
+    def dp4 
+      ilist('DP4') 
+    end
+    def ad 
+      ilist('AD') 
+    end
+    def pl 
+      ilist('PL') 
     end
 
     def bcount
-      VcfNucleotides.new(@alt,@values[@format['BCOUNT']].split(','))
+      VcfNucleotideCount4.new(@alt,values[fetch('BCOUNT')])
     end
 
     def bq
-      VcfAltInfo.new(@alt,@values[@format['BQ']].split(','))
+      VcfAltInfoList.new(@alt,values[fetch('BQ')])
     end
 
     def amq
-      VcfAltInfo.new(@alt,@values[@format['AMQ']].split(','))
+      VcfAltInfoList.new(@alt,values[fetch('AMQ')])
+    end
+
+    def method_missing(m, *args, &block)
+      return nil if @is_empty
+      if m =~ /\?$/
+        # query if a value exists, e.g., r.info.dp?
+        v = values[fetch(m.to_s.upcase.chop)]
+        v != nil
+      else
+        v = values[fetch(m.to_s.upcase)]
+        v = v.to_i if v =~ /^\d+$/
+        v = v.to_f if v =~ /^\d+\.\d+$/
+        v
+      end
+    end  
+
+  private
+
+    def fetch name
+      raise "ERROR: Field with name #{name} does not exist!" if !@format[name]
+      @format[name]
+    end
+
+    def ilist name
+      v = values[fetch(name)]
+      return nil if not v
+      v.split(',').map{|i| i.to_i} 
     end
 
-    def method_missing(m, *args, &block)  
-      v = @values[@format[m.to_s.upcase]]
-      v = v.to_i if v =~ /^\d+$/
-      v = v.to_f if v =~ /^\d+\.\d+$/
-      v
-    end  
 
   end
 
@@ -134,17 +175,21 @@ module BioVcf
       @header = header
       @alt = alt
       @samples = {} # lazy cache
-      @index = {}
-      @header.samples.each_with_index { |k,i| @index[k] = i+9 ; @index[k.downcase] = i+9 }
+      @sample_index = @header.sample_index()
     end
 
     def [] name
-      @samples[name] ||= VcfGenotypeField.new(@fields[@index[name]],@format,@header,@alt)
+      @samples[name] ||= VcfGenotypeField.new(@fields[@sample_index[name]],@format,@header,@alt)
     end
 
     def method_missing(m, *args, &block) 
       name = m.to_s
-      @samples[name] ||= VcfGenotypeField.new(@fields[@index[name]],@format,@header,@alt)
+      if name =~ /\?$/
+        # test for valid sample
+        return !VcfSample::empty?(@fields[@sample_index[name.chop]])
+      else
+        @samples[name] ||= VcfGenotypeField.new(@fields[@sample_index[name]],@format,@header,@alt)
+      end
     end  
 
   end

data/lib/bio-vcf/vcfheader.rb

@@ -42,6 +42,14 @@ module BioVcf
     def samples
       @samples ||= column_names[9..-1]
     end
+
+    def sample_index
+      return @sample_index if @sample_index
+      index = {}
+      samples.each_with_index { |k,i| index[k] = i+9 ; index[k.downcase] = i+9 }
+      @sample_index = index
+      index
+    end
   end
 
 end

data/lib/bio-vcf/vcfline.rb

@@ -4,6 +4,7 @@ module BioVcf
     # Split a line into fields and check size
     def VcfLine.parse line,expected_size=nil
       fields = line.strip.split(/\t/)
+      raise "Unexpected line #{line}" if line.strip.size == 0 or fields.size < 6
       raise "Expected #{expected_size} fields but got #{fields.size} in "+fields.to_s if expected_size and fields.size != expected_size
       fields
     end

data/lib/bio-vcf/vcfrecord.rb

@@ -1,26 +1,72 @@
 module BioVcf
 
-  class VcfRecordInfo
+  class VcfRecordInfo 
     def initialize s
-      h = {}
-      s.split(/;/).each { |f| k,v=f.split(/=/) ; h[k.upcase] = v }
-      @h = h
-    end
-    def method_missing(m, *args, &block)  
-      v = @h[m.to_s.upcase]
-      v = v.to_i if v =~ /^\d+$/
-      v = v.to_f if v =~ /^\d+\.\d+$/
-      v
+      @info = s
+    end
+
+    def to_s
+      if @h
+        @h.map { |k,v| (v ? @original_key[k] + '=' + v : @original_key[k])  }.join(';')
+      else
+        @info
+      end
+    end
+
+    # Set INFO fields (used by --rewrite)
+    def []= k, v   
+      split_fields if not @h
+      kupper = k.upcase
+      @h[kupper] = v
+      @original_key[kupper] = k
+    end
+
+    def method_missing(m, *args, &block)
+      # split_fields if not @h
+      # /#{m}=(?<value>[^;])/.@info
+      v = if @h
+            @h[m.to_s.upcase]
+          else
+            @info =~ /#{m.to_s.upcase}=([^;]+)/
+            value = $1
+            # m = @info.match(/#{m.to_s.upcase}=(?<value>[^;]+)/)
+            # value = m[:value]
+            if value == nil
+              split_fields # no option but to split
+              @h[m.to_s.upcase]
+            else
+              value
+            end
+          end
+      ConvertStringToValue::convert(v)
     end  
 
+  private
+ 
+    def split_fields
+      @h = {}
+      @original_key = {}
+      @info.split(/;/).each do |f| 
+        k,v = f.split(/=/) 
+        kupper = k.upcase
+        @h[kupper] = v
+        @original_key[kupper] = k
+      end
+    end
   end
 
   module VcfRecordParser
     # Parse the format field into a Hash
     def VcfRecordParser.get_format s
-      h = {}
-      s.split(/:/).each_with_index { |v,i| h[v] = i }
-      h
+      if s==$cached_sample_format_s
+        $cached_sample_format
+      else
+        h = {}
+        s.split(/:/).each_with_index { |v,i| h[v] = i }
+        $cached_sample_format = h
+        $cached_sample_format_s = s
+        h
+      end
     end
     def VcfRecordParser.get_info s
       VcfRecordInfo.new(s)
@@ -36,6 +82,15 @@ module BioVcf
       ['A','C','G','T'][index()]
     end
 
+    # Get the GT when 0 is REF and >0 is ALT
+    def get_gt(index)
+      if index == 0
+        ref()
+      else
+        alt[index-1]
+      end
+    end
+
     def call_tumor_count
       tumor.bcount.to_ary[index()]
     end
@@ -63,11 +118,13 @@ module BioVcf
       @fields = fields
       @header = header
     end
-     
+
     def chrom
       @fields[0]
     end
 
+    alias :chr :chrom
+
     def pos
       @pos ||= @fields[1].to_i
     end
@@ -114,5 +171,76 @@ module BioVcf
     def sample 
       @sample ||= VcfGenotypeFields.new(@fields,format,@header,alt)
     end
+
+    def sample_by_name name
+      sample[name]
+    end
+
+    def each_sample(list = nil)
+      samples = @header.column_names[9..-1]
+      raise "Empty sample list, can not execute query!" if not samples
+      samples.each_with_index { |name,i|
+        # p [i,list]
+        next if list and not list.index(i.to_s)
+        yield VcfSample::Sample.new(self,sample[name]) 
+      }
+    end
+
+    def missing_samples?
+      @fields[9..-1].each { |sample|
+        return true if VcfSample::empty?(sample)
+      }
+      false
+    end
+
+    def valid?
+      @fields.size == @header.column_names.size
+    end
+
+    def eval expr, ignore_missing_data, quiet
+      begin
+        if not respond_to?(:call_cached_eval)
+          code =
+          """
+          def call_cached_eval(rec,fields)
+            r = rec
+            #{expr}
+          end
+          """
+          self.class.class_eval(code)
+        end
+        res = call_cached_eval(self,@fields)
+        if res.kind_of?(Array)
+          res.join("\t")
+        else
+          res
+        end
+      rescue NoMethodError => e
+        if not quiet
+          $stderr.print "RECORD ERROR!\n"
+          $stderr.print [@fields],"\n"
+          $stderr.print expr,"\n"
+        end
+        if ignore_missing_data
+          $stderr.print e.message if not quiet
+          return false
+        else
+          raise
+        end
+      end
+    end
+
+    # Return the sample
+    def method_missing(m, *args, &block)  
+      name = m.to_s
+      if name =~ /\?$/
+        # Query for empty sample name
+        @sample_index ||= @header.sample_index
+        return !VcfSample::empty?(@fields[@sample_index[name.chop]])
+      else
+        sample[name]
+      end
+    end  
+
   end
 end

data/lib/bio-vcf/vcfsample.rb

@@ -0,0 +1,88 @@
+module BioVcf
+  module VcfSample
+
+  # Check whether a sample is empty (on the raw string value)
+  def VcfSample::empty? raw_sample
+    s = raw_sample.strip
+    s == './.' or s == '' or s == nil
+  end
+
+  class Sample
+    # #<BioVcf::VcfGenotypeField:0x00000001a0c188 @values=["0/0", "151,8", "159", "99", "0,195,2282"], @format={"GT"=>0, "AD"=>1, "DP"=>2, "GQ"=>3, "PL"=>4}, 
+    def initialize rec,sample
+      @rec = rec
+      @sample = sample
+      @format = @sample.format
+      @values = @sample.values
+    end
+
+    def eval expr, ignore_missing_data, quiet
+      begin
+        if not respond_to?(:call_cached_eval)
+          code = 
+          """
+          def call_cached_eval(rec,sample)
+            r = rec
+            s = sample 
+            #{expr}
+          end
+          """
+          self.class.class_eval(code)
+        end
+        call_cached_eval(@rec,self)
+      rescue NoMethodError => e
+        empty = VcfSample::empty?(@sample.values.to_s)
+        $stderr.print "\nTrying to evaluate on an empty sample #{@sample.values.to_s}!\n" if not empty
+        if not quiet
+          $stderr.print [@format,@values],"\n"
+          $stderr.print expr,"\n"
+        end
+        if ignore_missing_data
+          $stderr.print e.message if not quiet and not empty
+          return false
+        else
+          raise
+        end
+      end
+    end
+
+    # Split GT into index values
+    def gti
+      v = fetch_values("GT")
+      v.split(/\//).map{ |v| (v=='.' ? nil : v.to_i) }
+    end
+
+    # Split GT into into a nucleode sequence
+    def gts
+      gti.map { |i| (i ? @rec.get_gt(i) : nil) }
+    end
+
+    def cache_method(name, &block)
+      self.class.send(:define_method, name, &block)
+    end
+
+    def method_missing(m, *args, &block)
+      name = m.to_s.upcase
+      if @format[name]
+        cache_method(m) { 
+          ConvertStringToValue::convert(fetch_values(name))
+        }
+        self.send(m)
+      else
+        super(m, *args, &block)
+      end
+    end  
+
+private
+
+    def fetch_values name
+      n = @format[name]
+      raise "Unknown sample field <#{name}>" if not n
+      @values[n]  # <-- save names with upcase!
+    end
+
+  end
+
+
+  end
+end