bio-vcf 0.0.1 → 0.0.2

data/features/step_definitions/diff_count.rb

@@ -0,0 +1,41 @@
+
+Given(/^normal and tumor counts \[(\d+),(\d+),(\d+),(\d+)\] and \[(\d+),(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8|
+  @normal = [arg1,arg2,arg3,arg4].map{|i|i.to_i}
+  @tumor = [arg5,arg6,arg7,arg8].map{|i|i.to_i}
+end
+
+When(/^I look for the difference$/) do
+end
+
+Then(/^I expect the diff to be \[(\d+),(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4|
+  expect(Variant.diff(@normal,@tumor)).to eq [arg1.to_i,arg2.to_i,arg3.to_i,arg4.to_i]
+end
+
+Then(/^the relative diff to be \[(\d+),(\d+)\.(\d+),(\d+),(\d+)\.(\d+)\]$/) do |arg1, arg2, arg3, arg4, arg5, arg6|
+  res = [arg1.to_f,(arg2+'.'+arg3).to_f,arg4.to_i,(arg5+'.'+arg6).to_f]
+  expect(Variant.relative_diff(@normal,@tumor)).to eq res
+end
+
+Then(/^I expect the defining tumor nucleotide to be "(.*?)"$/) do |arg1|
+  expect(['A','C','G','T'][Variant.index(@normal,@tumor)]).to eq arg1
+end
+
+Then(/^I expect the tumor count to be (\d+)$/) do |arg1|
+  expect(@tumor[Variant.index(@normal,@tumor)]).to eq arg1.to_i
+end
+
+When(/^I set an inclusion threshold for the reference$/) do
+end
+
+Then(/^I expect the diff for threshold (\d+) to be \[(\d+),(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4, arg5|
+  @t = arg1.to_i
+  @t_diff = Variant.threshold_diff(@t,@normal,@tumor) 
+  expect(@t_diff).to eq [arg2.to_i,arg3.to_i,arg4.to_i,arg5.to_i]
+end
+
+Then(/^the relative diff to be \[(\d+),(\d+),(\d+),(\d+)\.(\d+)\]$/) do |arg1, arg2, arg3, arg4, arg5|
+  res = [arg1.to_f,arg2.to_i,arg3.to_i,(arg4+'.'+arg5).to_f]
+  expect(Variant.relative_threshold_diff(@t,@normal,@tumor)).to eq res
+end
+
+

data/features/step_definitions/multisample.rb

@@ -0,0 +1,73 @@
+Given(/^the multi sample header line$/) do |string|
+  @header = VcfHeader.new
+  @header.add(string)
+end
+
+When(/^I parse the header$/) do
+  expect(@header.column_names.size).to eq 16
+  expect(@header.samples.size).to eq 7
+  expect(@header.samples).to eq ["BIOPSY17513D", "clone10", "clone3", "clone4", "subclone105", "subclone33", "subclone46"]
+end
+
+Given(/^multisample vcf line$/) do |string|
+  @fields = VcfLine.parse(string.split(/\s+/).join("\t"))
+  @rec1 = VcfRecord.new(@fields,@header)
+end
+
+Then(/^I expect multisample rec\.alt to contain \["(.*?)"\]$/) do |arg1|
+  expect(@rec1.alt).to eq ["T"]
+end
+
+Then(/^I expect rec\.qual to be (\d+)\.(\d+)$/) do |arg1, arg2|
+  expect(@rec1.qual).to eq 106.3
+end
+
+Then(/^I expect rec\.info\.ac to be (\d+)$/) do |arg1|
+  expect(@rec1.info.ac).to eq arg1.to_i
+end
+Then(/^I expect rec\.info\.af to be (\d+)\.(\d+)$/) do |arg1, arg2|
+  expect(@rec1.info.af).to eq 0.357
+end
+
+Then(/^I expect rec\.info\.dp to be (\d+)$/) do |arg1|
+  expect(@rec1.info.dp).to eq 1537
+end
+
+Then(/^I expect rec\.info\.readposranksum to be (\d+)\.(\d+)$/) do |arg1, arg2|
+  expect(@rec1.info.readposranksum).to eq 0.815
+end
+
+Then(/^I expect rec\.sample\['BIOPSY(\d+)D'\]\.gt to be "(.*?)"$/) do |arg1, arg2|
+  # p @rec1.sample
+  expect(@rec1.sample['BIOPSY17513D'].gt).to eq "0/1"
+end
+
+Then(/^I expect rec\.sample\['BIOPSY(\d+)D'\]\.ad to be \[(\d+),(\d+)\]$/) do |arg1, arg2, arg3|
+  expect(@rec1.sample['BIOPSY17513D'].ad).to eq [189,25]
+end
+
+Then(/^I expect rec\.sample\['subclone(\d+)'\]\.ad to be \[(\d+),(\d+)\]$/) do |arg1, arg2, arg3|
+  expect(@rec1.sample['subclone46'].ad).to eq [167,26]
+end
+
+Then(/^I expect rec\.sample\['subclone(\d+)'\]\.dp to be (\d+)$/) do |arg1, arg2|
+  expect(@rec1.sample['subclone46'].dp).to eq 196
+end
+
+Then(/^I expect rec\.sample\['subclone(\d+)'\]\.gq to be (\d+)$/) do |arg1, arg2|
+  expect(@rec1.sample['subclone46'].gq).to eq 20 
+end
+
+Then(/^I expect rec\.sample\['subclone(\d+)'\]\.pl to be \[(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4|
+  expect(@rec1.sample['subclone46'].pl).to eq [20,0,522]
+end
+
+Then(/^I expect rec\.sample\.biopsy(\d+)d\.gt to be \[(\d+),(\d+)\]$/) do |arg1, arg2, arg3|
+  expect(@rec1.sample.biopsy17513d.gt).to eq "0/1"
+end
+
+Then(/^I expect rec\.sample\.subclone(\d+)\.pl to be \[(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4|
+  expect(@rec1.sample.subclone46.pl).to eq [20,0,522]
+end
+
+

data/features/step_definitions/somaticsniper.rb

@@ -0,0 +1,122 @@
+Given(/^the somatic sniper vcf line$/) do |string|
+  @fields = VcfLine.parse(string.split(/\s+/).join("\t"))
+end
+
+When(/^I parse the record$/) do
+  header = VcfHeader.new
+  @rec = VcfRecord.new(@fields,header)
+end
+
+Then(/^I expect rec\.chrom to contain "(.*?)"$/) do |arg1|
+  expect(@rec.chrom).to eq  "1"
+end
+
+Then(/^I expect rec\.pos to contain (\d+)$/) do |arg1|
+  expect(@rec.pos).to eq arg1.to_i
+end
+
+Then(/^I expect rec\.ref to contain "(.*?)"$/) do |arg1|
+  expect(@rec.ref).to eq arg1
+end
+
+Then(/^I expect rec\.alt to contain \["(.*?)","(.*?)"\]$/) do |arg1, arg2|
+  expect(@rec.alt).to eq [arg1,arg2]
+end
+
+Then(/^I expect rec\.alt to contain one \["(.*?)"\]$/) do |arg1|
+  expect(@rec.alt).to eq [arg1]
+end
+
+Then(/^I expect rec\.tumor\.dp to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.dp).to eq arg1.to_i
+end
+
+Then(/^I expect rec\.tumor\.dp(\d+) to be \[(\d+),(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4, arg5|
+  expect(@rec.tumor.dp4).to eq [arg2.to_i,arg3.to_i,arg4.to_i,arg5.to_i]
+end
+
+
+Then(/^I expect rec\.tumor\.bcount.to_ary to be \[(\d+),(\d+),(\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4|
+  expect(@rec.tumor.bcount.to_ary).to eq [arg1.to_i,arg2.to_i,arg3.to_i,arg4.to_i]
+end
+
+Then(/^I expect rec\.tumor\.bcount\[rec\.alt\] to be \[(\d+),(\d+)\]$/) do |arg1, arg2|
+  expect(@rec.tumor.bcount[@rec.alt]).to eq [arg1.to_i,arg2.to_i]
+end
+
+Then(/^I expect rec\.tumor\.bcount\[rec\.alt\] to be one \[(\d+)\]$/) do |arg1|
+  expect(@rec.tumor.bcount[@rec.alt]).to eq [arg1.to_i]
+end
+
+Then(/^I expect rec\.tumor\.bcount\["(.*?)"\] to be (\d+)$/) do |arg1, arg2|
+  expect(@rec.tumor.bcount[arg1]).to eq arg2.to_i
+end
+
+Then(/^I expect rec\.tumor\.bcount\[(\d+)\] to be (\d+)$/) do |arg1, arg2|
+  expect(@rec.tumor.bcount[arg1.to_i]).to eq arg2.to_i
+end
+
+Then(/^I expect rec\.tumor\.bcount\.sum to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.bcount.sum).to eq arg1.to_i
+end
+
+Then(/^I expect rec\.tumor\.bcount\.max to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.bcount.max).to eq arg1.to_i
+end
+
+
+Then(/^I expect rec\.tumor\.bq\.to_ary to be \[(\d+),(\d+)\]$/) do |arg1, arg2|
+  expect(@rec.tumor.bq.to_ary).to eq [arg1.to_i,arg2.to_i]
+end
+
+Then(/^I expect rec\.tumor\.bq\["(.*?)"\] to be (\d+)$/) do |arg1, arg2|
+  expect(@rec.tumor.bq[arg1]).to eq arg2.to_i
+end
+
+Then(/^I expect rec\.tumor\.bq\[(\d+)\] to be (\d+)$/) do |arg1, arg2|
+  expect(@rec.tumor.bq[arg1.to_i]).to eq arg2.to_i
+end
+
+Then(/^I expect rec\.tumor\.bq\.min to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.bq.min).to eq arg1.to_i
+end
+
+Then(/^I expect rec\.tumor\.bq\.max to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.bq.max).to eq arg1.to_i
+end
+
+
+Then(/^I expect rec\.tumor\.amq.to_ary to be \[(\d+),(\d+)\]$/) do |arg1, arg2|
+  expect(@rec.tumor.amq.to_ary).to eq [arg1.to_i,arg2.to_i]
+end
+
+Then(/^I expect rec\.tumor\.mq to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.mq).to eq arg1.to_i
+end
+
+Then(/^I expect rec\.tumor\.ss to be (\d+)$/) do |arg1|
+  expect(@rec.tumor.ss).to eq arg1.to_i
+end
+
+
+Then(/^I expect rec.call_diff to be \[(\-\d+),(\d+),(\-\d+),(\d+)\]$/) do |arg1, arg2, arg3, arg4|
+  expect(@rec.call_diff).to eq [arg1.to_i,arg2.to_i,arg3.to_i,arg4.to_i]
+end
+
+Then(/^I expect rec.call_nuc to be "(.*?)"$/) do |arg1|
+  expect(@rec.call_nuc).to eq arg1
+end
+
+Then(/^I expect rec.call_tumor_count to be (\d+)$/) do |arg1|
+  expect(@rec.call_tumor_count).to eq arg1.to_i
+end
+
+Then(/^I expect rec.call_normal_count to be (\d+)$/) do |arg1|
+  expect(@rec.call_normal_count).to eq arg1.to_i
+end
+
+Then(/^I expect rec.call_tumor_relative_count to be (\d+)\.(\d+)$/) do |arg1, arg2|
+  expect(@rec.call_tumor_relative_count).to eq (arg1+'.'+arg2).to_f
+end
+
+

data/features/support/env.rb

@@ -7,7 +7,11 @@ rescue Bundler::BundlerError => e
   exit e.status_code
 end
 
+# require 'mini/test'
+
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
 require 'bio-vcf'
 
 require 'rspec/expectations'
+
+include BioVcf

data/lib/bio-vcf/variant.rb

@@ -0,0 +1,38 @@
+module BioVcf
+
+  module Variant
+
+    def Variant.diff normal,tumor
+      tumor.each_with_index.map {|t,i| t-normal[i]}
+    end
+
+    def Variant.threshold_diff t,normal,tumor
+      normal2,tumor2 = apply_threshold(t,normal,tumor)
+      diff(normal2,tumor2)
+    end
+
+    def Variant.relative_diff normal,tumor
+      d = diff(normal,tumor)
+      total = tumor.each_with_index.map {|t,i| t+normal[i]}
+      total.each_with_index.map {|t,i| (t==0 ? 0 : ((d[i].to_f/t)*100.0).round/100.0)}
+    end
+
+    def Variant.relative_threshold_diff t,normal,tumor
+      normal2,tumor2 = apply_threshold(t,normal,tumor)
+      relative_diff(normal2,tumor2)
+    end
+
+    def Variant.index normal,tumor
+      rd = relative_diff(normal,tumor) 
+      max = rd.reduce(0){|mem,v| (v>mem ? v : mem) }
+      rd.index(max)
+    end
+
+    def Variant.apply_threshold t,normal,tumor
+      normal2 = normal.map{|v| (v>t ? 0 : v) }
+      tumor2 = tumor.each_with_index.map{|v,i| (normal2[i]==0 ? 0 : v) }
+      return normal2,tumor2
+    end
+  end
+
+end

data/lib/bio-vcf/vcfgenotypefield.rb

@@ -1,37 +1,122 @@
 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 
-    def initialize list
-      @list = list
+    def initialize alt,list
+      @alt = alt
+      @list = list.map{|i| i.to_i}
     end
   
     def [] idx
-      idx = ["A","C","G","T"].index(idx) if idx.kind_of?(String)
-      return 0 if idx == nil
-      @list[idx].to_i
+      if idx.kind_of?(Integer)
+        @list[idx].to_i
+      elsif idx.kind_of?(String)
+        @list[["A","C","G","T"].index(idx)].to_i
+      else idx.kind_of?(Array)
+        idx.map { |nuc|
+          idx2 = ["A","C","G","T"].index(nuc)
+          # p [idx,nuc,idx2,@list]
+          @list[idx2].to_i
+        }
+      end
+    end
+
+    def to_ary
+      @list
+    end
+
+    # Return the max value on the nucleotides in the list (typically rec.alt)
+    def max list = @alt
+      values = self[list]
+      values.reduce(0){ |memo,v| (v>memo ? v : memo) }
+    end
+
+    def min list = @alt
+      values = self[list]
+      values.reduce(MAXINT){ |memo,v| (v<memo ? v : memo) }
+    end
+
+    def sum list = @alt
+      values = self[list]
+      values.reduce(0){ |memo,v| v+memo }
+    end
+
+
+  end
+
+  class VcfAltInfo
+    def initialize alt,list
+      @alt = alt
+      @list = list.map{|i| i.to_i}
+    end
+  
+    def [] idx
+      if idx.kind_of?(Integer)
+        @list[idx].to_i
+      elsif idx.kind_of?(String)
+        @list[@alt.index(idx)].to_i
+      else idx.kind_of?(Array)
+        idx.map { |nuc|
+          idx2 = @alt.index(nuc)
+          # p [idx,nuc,idx2,@list]
+          @list[idx2].to_i
+        }
+      end
+    end
+
+    def to_ary
+      @list
+    end
+
+    # Return the max value on the nucleotides in the list (typically rec.alt)
+    def max 
+      @list.reduce(0){ |memo,v| (v>memo ? v : memo) }
+    end
+
+    def min 
+      @list.reduce(MAXINT){ |memo,v| (v<memo ? v : memo) }
+    end
+
+    def sum 
+      @list.reduce(0){ |memo,v| v+memo }
     end
   end
 
   class VcfGenotypeField
-    def initialize s, format, header
+    def initialize s, format, header, alt
       @values = s.split(/:/)
       @format = format
       @header = header
+      @alt = alt
+    end
+
+    def dp4
+      @values[@format['DP4']].split(',').map{|i| i.to_i}
+    end
+
+    def ad
+      @values[@format['AD']].split(',').map{|i| i.to_i}
+    end
+
+    def pl
+      @values[@format['PL']].split(',').map{|i| i.to_i}
     end
 
     def bcount
-      VcfNucleotides.new(@values[@format['BCOUNT']].split(','))
+      VcfNucleotides.new(@alt,@values[@format['BCOUNT']].split(','))
     end
 
     def bq
-      VcfNucleotides.new(@values[@format['BQ']].split(','))
+      VcfAltInfo.new(@alt,@values[@format['BQ']].split(','))
     end
 
     def amq
-      VcfNucleotides.new(@values[@format['AMQ']].split(','))
+      VcfAltInfo.new(@alt,@values[@format['AMQ']].split(','))
     end
 
-
     def method_missing(m, *args, &block)  
       v = @values[@format[m.to_s.upcase]]
       v = v.to_i if v =~ /^\d+$/
@@ -40,4 +125,27 @@ module BioVcf
     end  
 
   end
+
+  # Holds all samples
+  class VcfGenotypeFields
+    def initialize fields, format, header, alt
+      @fields = fields
+      @format = format
+      @header = header
+      @alt = alt
+      @samples = {} # lazy cache
+      @index = {}
+      @header.samples.each_with_index { |k,i| @index[k] = i+9 ; @index[k.downcase] = i+9 }
+    end
+
+    def [] name
+      @samples[name] ||= VcfGenotypeField.new(@fields[@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)
+    end  
+
+  end
 end

data/lib/bio-vcf/vcfheader.rb

@@ -5,6 +5,7 @@ module BioVcf
     def VcfHeaderParser.get_column_names(lines)
       lines.each do | line |
         if line =~ /^#[^#]/
+          # the first line that starts with a single hash 
           names = line.split
           names[0].sub!(/^#/,'')
           return names
@@ -37,6 +38,10 @@ module BioVcf
     def columns
       @column ||= column_names.size
     end
+
+    def samples
+      @samples ||= column_names[9..-1]
+    end
   end
 
 end

data/lib/bio-vcf/vcfrdf.rb

@@ -0,0 +1,30 @@
+module BioVcf
+
+  # This is some primarily RDF support - which may be moved to another gem
+
+  module VcfRdf
+
+    def VcfRdf::header
+      print <<EOB
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix dc: <http://purl.org/dc/elements/1.1/> .
+@prefix hgnc: <http://identifiers.org/hgnc.symbol/> .
+@prefix doi: <http://dx.doi.org/> .
+@prefix : <http://biobeat.org/rdf/ns#> .
+EOB
+    end
+
+    def VcfRdf::record id,rec,hash = {}
+      id2 = [id,'ch'+rec.chrom,rec.pos].join('_')
+      print <<OUT
+:#{id2} :chr \"#{rec.chrom}\" .
+:#{id2} :pos #{rec.pos} .
+:#{id2} :vcf true .
+OUT
+      hash.each do |k,v|
+        print ":#{id2} :#{k} #{v} .\n"
+      end
+    end
+  end
+end

data/lib/bio-vcf/vcfrecord.rb

@@ -1,18 +1,67 @@
 module BioVcf
 
+  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
+    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
     end
+    def VcfRecordParser.get_info s
+      VcfRecordInfo.new(s)
+    end
+  end
+
+  module VcfRecordCall
+    def call_diff
+      Variant.diff(normal.bcount.to_ary,tumor.bcount.to_ary)
+    end
+
+    def call_nuc
+      ['A','C','G','T'][index()]
+    end
+
+    def call_tumor_count
+      tumor.bcount.to_ary[index()]
+    end
+
+    def call_tumor_relative_count
+      Variant.relative_diff(normal.bcount.to_ary,tumor.bcount.to_ary)[index()]
+    end
+
+    def call_normal_count
+      normal.bcount.to_ary[index()]
+    end
+
+    def index
+      Variant.index(self.normal.bcount.to_ary,self.tumor.bcount.to_ary)
+    end
   end
 
   class VcfRecord
 
+    include VcfRecordCall
+
+    attr_reader :header
+
     def initialize fields, header
-      @header = header
       @fields = fields
+      @header = header
     end
      
     def chrom
@@ -36,20 +85,34 @@ module BioVcf
     end
 
     def alt
-      @alt ||= @fields[4]
+      @alt ||= @fields[4].split(/,/)
+    end
+
+    def qual
+      @qual ||= @fields[5].to_f
+    end
+
+    def info
+      @info ||= VcfRecordParser.get_info(@fields[7])
     end
 
     def format
       @format ||= VcfRecordParser.get_format(@fields[8])
     end
 
+    # Return the normal sample (used in two sample VCF)
     def normal
-      @normal ||= VcfGenotypeField.new(@fields[9],format,@header)
+      @normal ||= VcfGenotypeField.new(@fields[9],format,@header,alt)
     end
 
+    # Return the tumor sample (used in two sample VCF)
     def tumor
-      @tumor ||= VcfGenotypeField.new(@fields[10],format,@header)
+      @tumor ||= VcfGenotypeField.new(@fields[10],format,@header,alt)
+    end
+   
+    # Return the sample as a named hash 
+    def sample 
+      @sample ||= VcfGenotypeFields.new(@fields,format,@header,alt)
     end
-
   end
 end

data/lib/bio-vcf.rb

@@ -13,3 +13,4 @@ require 'bio-vcf/vcfheader'
 require 'bio-vcf/vcfline'
 require 'bio-vcf/vcfgenotypefield'
 require 'bio-vcf/vcfrecord'
+require 'bio-vcf/variant'