bio-vcf 0.7.0 → 0.7.3

data/lib/bio-vcf/vcfheader.rb

@@ -64,7 +64,7 @@ module BioVcf
     end
 
     def samples_index_array
-      @all_samples_index ||= column_names[9..-1].fill{|i| i} 
+      @all_samples_index ||= column_names[9..-1].fill{|i| i}
     end
 
     def sample_index

data/lib/bio-vcf/vcfrecord.rb

@@ -159,19 +159,24 @@ module BioVcf
       @format ||= VcfRecordParser.get_format(@fields[8])
     end
 
+    # Return the first (single) sample (used in one sample VCF)
+    def first
+      @first ||= VcfGenotypeField.new(@fields[9],format,@header,ref,alt)
+    end
+
     # Return the normal sample (used in two sample VCF)
     def normal
-      @normal ||= VcfGenotypeField.new(@fields[9],format,@header,alt)
+      first
     end
 
     # Return the tumor sample (used in two sample VCF)
     def tumor
-      @tumor ||= VcfGenotypeField.new(@fields[10],format,@header,alt)
+      @tumor ||= VcfGenotypeField.new(@fields[10],format,@header,ref,alt)
     end
    
     # Return the sample as a named hash 
     def sample 
-      @sample ||= VcfGenotypeFields.new(@fields,format,@header,alt)
+      @sample ||= VcfGenotypeFields.new(@fields,format,@header,ref,alt)
     end
 
     def sample_by_name name
@@ -179,14 +184,15 @@ module BioVcf
     end
 
     def sample_by_index i
-      # p [i,@fields[i+9]]
-      @sample_by_index[i] ||= VcfGenotypeField.new(@fields[i+9],format,@header,alt)
+      # p @fields
+      raise "Can not index sample on parameter <#{i}>" if not i.kind_of?(Integer)
+      @sample_by_index[i] ||= VcfGenotypeField.new(@fields[i+9],format,@header,ref,alt)
     end
 
     # Walk the samples. list contains an Array of int (the index)
     def each_sample(list = nil)
       list = @header.samples_index_array() if not list 
-      list.each { |i| yield VcfSample::Sample.new(self,sample_by_index(i)) }
+      list.each { |i| yield VcfSample::Sample.new(self,sample_by_index(i.to_i)) }
     end
 
     def missing_samples?
@@ -200,7 +206,7 @@ module BioVcf
       @fields.size == @header.column_names.size
     end
 
-    def eval expr, ignore_missing_data, quiet
+    def eval expr, ignore_missing_data: true, quiet: false
       begin
         if not respond_to?(:call_cached_eval)
           code =
@@ -233,7 +239,7 @@ module BioVcf
       end
     end
 
-    def filter expr, ignore_missing_data, quiet
+    def filter expr, ignore_missing_data: true, quiet: false
       begin
         if not respond_to?(:call_cached_filter)
           code =

data/lib/bio-vcf/vcfsample.rb

@@ -1,177 +1,126 @@
 module BioVcf
   module VcfSample
 
-  # Check whether a sample is empty (on the raw string value)
-  def VcfSample::empty? s
-    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
+    # Check whether a sample is empty (on the raw string value)
+    def VcfSample::empty? s
+      s == './.' or s == '' or s == nil
     end
 
-    def empty?
-     cache_empty ||= VcfSample::empty?(@sample.to_s)
-    end
+    class Sample
+      # Initialized sample with rec and genotypefield
+      #
+      # #<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,genotypefield
+        @rec = rec
+        @sample = genotypefield
+        @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
-        $stderr.print "\nTrying to evaluate on an empty sample #{@sample.values.to_s}!\n" if not empty? and not quiet
-        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
+      def empty?
+       cache_empty ||= VcfSample::empty?(@sample.to_s)
       end
-    end
 
-    def sfilter expr, ignore_missing_data, quiet
-      begin
-        if not respond_to?(:call_cached_sfilter)
-          code = 
-          """
-          def call_cached_sfilter(rec,sample)
-            r = rec
-            s = sample 
-            #{expr}
-          end
-          """
-          self.class.class_eval(code)
-        end
-        call_cached_sfilter(@rec,self)
-      rescue NoMethodError => e
-        $stderr.print "\nTrying to evaluate on an empty sample #{@sample.values.to_s}!\n" if not empty? and not quiet
-        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
+      def eval expr, ignore_missing_data: false, quiet: false, do_cache: true
+        caching_eval :eval, :call_cached_eval, expr, ignore_missing_data: ignore_missing_data, quiet: quiet, do_cache: do_cache
       end
-    end
 
-    def ifilter expr, ignore_missing_data, quiet
-      begin
-        if not respond_to?(:call_cached_ifilter)
-          code = 
-          """
-          def call_cached_ifilter(rec,sample)
-            r = rec
-            s = sample 
-            #{expr}
-          end
-          """
-          self.class.class_eval(code)
-        end
-        call_cached_ifilter(@rec,self)
-      rescue NoMethodError => e
-        $stderr.print "\nTrying to evaluate on an empty sample #{@sample.values.to_s}!\n" if not empty? and not quiet
-        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
+      def sfilter expr, ignore_missing_data: false, quiet: true, do_cache: true
+        caching_eval :sfilter, :call_cached_sfilter, expr, ignore_missing_data: ignore_missing_data, quiet: quiet, do_cache: do_cache
       end
-    end
 
-    def efilter expr, ignore_missing_data, quiet
-      begin
-        if not respond_to?(:call_cached_efilter)
-          code = 
-          """
-          def call_cached_efilter(rec,sample)
-            r = rec
-            s = sample 
-            #{expr}
-          end
-          """
-          self.class.class_eval(code)
-        end
-        call_cached_efilter(@rec,self)
-      rescue NoMethodError => e
-        $stderr.print "\nTrying to evaluate on an empty sample #{@sample.values.to_s}!\n" if not empty? and not quiet
-        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
+      def ifilter expr, ignore_missing_data: false, quiet: false, do_cache: true
+        caching_eval :ifilter, :call_cached_ifilter, expr, ignore_missing_data: ignore_missing_data, quiet: quiet, do_cache: do_cache
       end
-    end
 
-    # Split GT into index values
-    def gti
-      v = fetch_values("GT")
-      v.split(/\//).map{ |v| (v=='.' ? nil : v.to_i) }
-    end
+      def efilter expr, ignore_missing_data: false, quiet: false, do_cache: true
+        caching_eval :efilter, :call_cached_efilter, expr, ignore_missing_data: ignore_missing_data, quiet: quiet, do_cache: do_cache
+      end
 
-    # Split GT into into a nucleode sequence
-    def gts
-      gti.map { |i| (i ? @rec.get_gt(i) : nil) }
-    end
+      # Split GT into index values
+      def gti
+        v = fetch_values("GT")
+        v.split(/\//).map{ |v| (v=='.' ? nil : v.to_i) }
+      end
 
-    def cache_method(name, &block)
-      self.class.send(:define_method, name, &block)
-    end
+      # Split GT into into a nucleode sequence
+      def gts
+        gti.map { |i| (i ? @rec.get_gt(i) : nil) }
+      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)
+      def cache_method(name, &block)
+        self.class.send(:define_method, name, &block)
       end
-    end  
+    
+      def method_missing(m, *args, &block)
+        name = m.to_s.upcase
+        # p [:here,name,m ,@values]
+        # p [:respond_to_call_cached_eval,respond_to?(:call_cached_eval)]
+        if name =~ /\?$/
+          # test for valid field
+          return !VcfValue::empty?(fetch_values(name.chop))
+        else
+          if @format[name]
+            cache_method(m) {
+              v = fetch_values(name) 
+              return nil if VcfValue::empty?(v)
+              ConvertStringToValue::convert(v)
+            }
+            self.send(m)
+          else
+            super(m, *args, &block)
+          end
+        end
+      end  
 
-private
+  private
 
-    def fetch_values name
-      n = @format[name]
-      raise "Unknown sample field <#{name}>" if not n
-      @values[n]  # <-- save names with upcase!
-    end
+      def fetch_values name
+        n = @format[name]
+        raise "Unknown sample field <#{name}>" if not n
+        @values[n]  # <-- save names with upcase!
+      end
 
-  end
+      def caching_eval method, cached_method, expr, ignore_missing_data: false, quiet: false, do_cache: true
+        begin
+          if do_cache
+            if not respond_to?(cached_method)
+              code = 
+              """
+              def #{cached_method}(rec,sample)
+                r = rec
+                s = sample 
+                #{expr}
+              end
+              """
+              self.class.class_eval(code)
+            end
+            self.send(cached_method,@rec,self)
+          else 
+            # This is used for testing mostly
+            print "WARNING: NOT CACHING #{method}\n"
+            self.class.class_eval { undef :call_cached_eval } if respond_to?(:call_cached_eval)
+            self.class.class_eval { undef :call_cached_sfilter } if respond_to?(:call_cached_sfilter)
+            r = @rec
+            s = @sample
+            eval(expr)
+          end
+        rescue NoMethodError => e
+          $stderr.print "\n#{method} trying to evaluate on an empty sample #{@sample.values.to_s}!\n" if not empty? and not quiet
+          if not quiet
+            $stderr.print [:format,@format,:sample,@values],"\n"
+            $stderr.print [:filter,expr],"\n"
+          end
+          if ignore_missing_data
+            $stderr.print e.message if not quiet and not empty?
+            return false
+          else
+            raise NoMethodError.new(e.message + ". Can not evaluate empty sample data by default: test for s.empty? or use the -i switch!")
+          end
+        end
+      end
 
+    end
 
   end
 end

data/lib/bio-vcf/vcfstatistics.rb

@@ -0,0 +1,28 @@
+module BioVcf
+
+  class VcfStatistics
+
+    def initialize
+      @count = 0
+      @ref_alt_count = {}
+    end
+
+    def add rec
+      @count += 1
+      s = rec.ref+">"+rec.alt[0]
+      @ref_alt_count[s] ||= 0
+      @ref_alt_count[s] += 1
+    end
+
+    def print
+      puts "## ==== Statistics =================================="
+      @ref_alt_count.sort_by {|k,v| v}.reverse.each do |k,v|
+        printf k+"\t%d\t%2.0d%%\n",v,(v.to_f/@count*100).round
+      end
+      puts "Total\t#{@count}"
+      puts "## =================================================="
+    end
+  end
+
+end
+

data/test/data/regression/ifilter_s.dp.ref

@@ -0,0 +1,31 @@
+1	10257	159	242	249	249	186	212	218
+1	10291	165	249	249	247	161	163	189
+1	10297	182	246	250	246	165	158	183
+1	10303	198	247	248	248	172	157	182
+1	10315	212	246	242	245	190	157	189
+1	10321	218	246	248	248	193	164	196
+1	10327	237	238	229	237	209	183	210
+1	12783	58	164	144	182	126	103	158
+1	13116	32	131	102	152	104	88	109
+1	13118	34	129	101	145	99	85	108
+1	13178	52	172	137	172	129	119	148
+1	13302	36	136	99	146	90	65	117
+1	13757	53	201	181	250	152	130	182
+1	13868	75	192	182	224	142	111	167
+1	13896	62	135	143	175	112	81	121
+1	14354	43	158	115	145		72	119
+1	14464	51	155	141	150	83	89	140
+1	14673	36	142	117	157	95	76	131
+1	14699	43	128	109	147	98	78	114
+1	14907	57	216	162	205	153	118	158
+1	14930	68	216	170	210	136	125	164
+1	14933	68	216	169	212	132	128	164
+1	14948	63	192	181	211	129	121	153
+1	14976	56	166	161	196	109	116	135
+1	15118	46	198	129	230	113	126	158
+1	15190	53	208	170	200	126	145	179
+1	15211	54	183	161	171	120	134	168
+1	15274	37	121	102	137	71	67	98
+1	15447	46	242	183	226	137	173	175
+1	15688	37	182	147	184	100	101	148
+1	16103	50	79	86	106	60	61	84

data/test/data/regression/thread4_4_failed_filter-stderr.ref

@@ -0,0 +1 @@
+unexpected return

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bio-vcf
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.3
 platform: ruby
 authors:
 - Pjotr Prins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-24 00:00:00.000000000 Z
+date: 2014-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -42,31 +42,32 @@ dependencies:
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: regressiontest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Smart parser for VCF format
+        version: 0.0.3
+description: Smart lazy multi-threaded parser for VCF format with useful filtering
+  and output rewriting
 email: pjotr.public01@thebird.nl
 executables:
 - bio-vcf
@@ -106,10 +107,12 @@ files:
 - lib/bio-vcf/vcfrdf.rb
 - lib/bio-vcf/vcfrecord.rb
 - lib/bio-vcf/vcfsample.rb
+- lib/bio-vcf/vcfstatistics.rb
 - test/data/input/dbsnp.vcf
 - test/data/input/multisample.vcf
 - test/data/input/somaticsniper.vcf
 - test/data/regression/eval_r.info.dp.ref
+- test/data/regression/ifilter_s.dp.ref
 - test/data/regression/r.info.dp.ref
 - test/data/regression/rewrite.info.sample.ref
 - test/data/regression/s.dp.ref
@@ -117,6 +120,7 @@ files:
 - test/data/regression/sfilter_seval_s.dp.ref
 - test/data/regression/thread4.ref
 - test/data/regression/thread4_4.ref
+- test/data/regression/thread4_4_failed_filter-stderr.ref
 - test/performance/metrics.md
 homepage: http://github.com/pjotrp/bioruby-vcf
 licenses:
@@ -141,5 +145,5 @@ rubyforge_project:
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: VCF parser
+summary: Fast multi-threaded VCF parser
 test_files: []