cheripic 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e478cb23cd45fd1287db7a7452a9320d9ade3722
-  data.tar.gz: 750333da30358c7a0d45a4927af00e0ae9cf3c33
+  metadata.gz: ace583d5063ea92f69faa4430b71f0bb0f654528
+  data.tar.gz: 00ae530b7c5c162aa0e699cae2c5dcaa9d159673
 SHA512:
-  metadata.gz: c7ec71513ff241e04b37d29ff0deb07b9cae44c815cb7ca7ce9bc8b437a5969e5784faf0028799c23b0067fd6bc19256adb292932a72f4a91545e5c9e3b2c72a
-  data.tar.gz: afac635b2e3df32c0bc7a20d28794d49226492cbfafaff9e95004bb9405c6f1c693404e1b97ef8c740bf341c231bfae66d9a4d98982905cb942d833185900156
+  metadata.gz: c179df9e44bdff364c8c9c7dd2a779609b05ed3d2f0ef5385c5c5ebb4910a98c35a05d861851dea3f34b14ab8d188994e6b7f254dde2b9356e73dbff08386cf0
+  data.tar.gz: f21ee021e4594bacaf319170746ad7655b0c579cb0c49495bf33dbef9dabd059f8d2e81edf44d64d24cea1f86a3e6315782d87fd8e475cf5698d35dce1bd3079

data/Gemfile

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'bio-samtools', :git => 'git://github.com/helios/bioruby-samtools.git', :tag => 'v2.3.5'
 # Specify your gem's dependencies in cheripic.gemspec
 gemspec

data/README.md

@@ -1,13 +1,18 @@
 # Cheripic
 
+[![Gem Version](https://badge.fury.io/rb/cheripic.svg)](https://badge.fury.io/rb/cheripic)
 [![Build Status](https://travis-ci.org/shyamrallapalli/cheripic.svg?branch=master)](https://travis-ci.org/shyamrallapalli/cheripic)
 [![Coverage Status](https://coveralls.io/repos/github/shyamrallapalli/cheripic/badge.svg?branch=master)](https://coveralls.io/github/shyamrallapalli/cheripic?branch=master)
+[![Code Climate](https://codeclimate.com/github/shyamrallapalli/cheripic/badges/gpa.svg)](https://codeclimate.com/github/shyamrallapalli/cheripic)
 
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/cheripic`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
 
+Computing Homozygosity Enriched Regions In genomes to Prioritize Identification of Candidate variants (CHERIPIC), 
+is a ruby tools to pick causative mutation from bulks segregant sequencing.     
+        
+Currently this gem is still in development and nearing complete working package.
+        
+        
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -36,7 +41,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cheripic. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/shyamrallapalli/cheripic. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
 
 ## License

data/cheripic.gemspec

@@ -19,18 +19,19 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'yell', '~> 2.0.5'
-  spec.add_dependency 'trollop', '~> 2.1.2'
-  spec.add_dependency 'bio', '~> 1.5.0'
+  spec.add_runtime_dependency 'yell', '~> 2.0', '>= 2.0.5'
+  spec.add_runtime_dependency 'trollop', '~> 2.1', '>= 2.1.2'
+  spec.add_runtime_dependency 'bio', '~> 1.5', '>= 1.5.0'
   # spec.add_dependency 'bio-samtools', '~> 2.3.3'
-  # spec.add_dependency 'bio-gngm', '~> 0.2.1'
-  spec.add_dependency 'rinruby', '~> 2.0.3'
+  spec.add_dependency 'bio-gngm', '~> 0.2.1'
+  spec.add_runtime_dependency 'rinruby', '~> 2.0', '>= 2.0.3'
 
+  spec.add_development_dependency 'activesupport', '~> 4.2.6'
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'minitest-reporters', '>= 1.0.17'
-  spec.add_development_dependency 'simplecov', '>= 0.8.2'
-  spec.add_development_dependency 'shoulda', '>= 3.5.0'
-  spec.add_development_dependency 'coveralls', '>= 0.7.2'
+  spec.add_development_dependency 'simplecov', '~> 0.8', '>= 0.8.2'
+  spec.add_development_dependency 'shoulda', '~> 3.5', '>= 3.5.0'
+  spec.add_development_dependency 'coveralls', '~> 0.7', '>= 0.7.2'
 end

data/lib/cheripic/bfr.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Cheripic
+
+  class BfrError < CheripicError; end
+
+  class Bfr
+
+    attr_accessor :bfr_adj
+
+    # get bulk frequency ratio (bfr) for marked hemi snps only
+    # ignore positions with complex variants
+    def self.get_bfr(mut_hash, bg_hash='')
+      @bfr_adj = Options.params.bfr_adjust
+      if bg_hash != ''
+        # checking if only two vars in base hash and that includes ref
+        # checking if only one var in hemi snp
+        # suggests enrichment for one of two alleles
+        if mut_hash.length == 2 and mut_hash.key?(:ref)
+          bfr = calculate_bfr(mut_hash, bg_hash)
+        elsif bg_hash.length == 2  and bg_hash.key?(:ref)
+          bfr = calculate_bfr(bg_hash, mut_hash)
+        elsif mut_hash.length == 1 and mut_hash[:ref] == nil
+          bfr = calculate_bfr(mut_hash, bg_hash)
+        elsif bg_hash.length == 1 and bg_hash[:ref] == nil
+          bfr = calculate_bfr(bg_hash, mut_hash)
+        else # complex
+          bfr = ''
+        end
+      elsif mut_hash.length == 2 and mut_hash.key?(:ref)
+        bfr = calc_fraction(mut_hash)[0]/ @bfr_adj
+      elsif mut_hash.length == 1 and mut_hash[:ref] == nil
+        bfr = calc_fraction(mut_hash)[0]/ @bfr_adj
+      else
+        bfr = ''
+      end
+      bfr
+    end
+
+    # calculate bfr using both mutant and background bulk information
+    def self.calculate_bfr(two_key_hash, other_hash)
+      # fix :ref value if absent due to below noise depth
+      unless two_key_hash.key?(:ref)
+        two_key_hash[:ref] = 0
+      end
+      unless other_hash.key?(:ref)
+        other_hash[:ref] = 0
+      end
+      frac_1, base = calc_fraction(two_key_hash)
+      if other_hash.key?(base)
+        sum = other_hash[base] + other_hash[:ref] + @bfr_adj
+        frac_2 = (other_hash[base] + @bfr_adj)/sum
+      else
+        sum = other_hash[:ref] + @bfr_adj
+        frac_2 = @bfr_adj/sum
+      end
+      # making sure ratio is always 1 or grater
+      if frac_1 > frac_2
+        bfr = frac_1/frac_2
+      else
+        bfr = frac_2/frac_1
+      end
+      bfr
+    end
+
+    def self.calc_fraction(hash)
+      unless hash.key?(:ref)
+        hash[:ref] = 0
+      end
+      array = hash.keys
+      sum = hash[array[0]] + hash[array[1]] + @bfr_adj
+      if array[0] == :ref
+        frac = (hash[array[1]] + @bfr_adj)/sum
+        base = array[1]
+      else
+        frac = (hash[array[0]] + @bfr_adj)/sum
+        base = array[0]
+      end
+      [frac, base]
+    end
+
+  end
+
+end

data/lib/cheripic/cmd.rb

@@ -8,13 +8,14 @@ module Cheripic
     require 'pathname'
     require 'ostruct'
 
-    def initialize (args)
-      @options = OpenStruct.new
-      @options = parse_arguments (args)
+    attr_accessor :options
+
+    def initialize(args)
+      @options = parse_arguments(args)
       check_arguments
     end
 
-    def parse_arguments (args)
+    def parse_arguments(args)
       Trollop::with_standard_exception_handling argument_parser do
         if args.empty? || args.include?('-h') || args.include?('--help')
           raise Trollop::HelpNeeded
@@ -45,7 +46,7 @@ module Cheripic
         opt :output, 'Directory to store results, will be created if not existing',
             :default => 'cheripic_results'
         opt :loglevel, 'Choose any one of "info / warn / debug" level for logs generated',
-            :default => 'info'
+            :default => 'debug'
         opt :hmes_adjust, 'factor added to snp count of each contig to adjust for hme score calculations',
             :type => Float,
             :default => 0.5
@@ -98,7 +99,7 @@ module Cheripic
             :short => '-r',
             :type => String,
             :default => ''
-        opt :br_adjust, 'factor added to hemi snp frequency of each parent to adjust for bfr calculations',
+        opt :bfr_adjust, 'factor added to hemi snp frequency of each parent to adjust for bfr calculations',
             :type => Float,
             :default => 0.05
         opt :examples, 'shows some example commands with explanation'
@@ -140,19 +141,20 @@ OPTIONS:
     end
 
     def check_arguments
-      check_output
-      check_loglevel
-      check_inputfiles
+      check_output_dir
+      check_log_level
+      check_input_files
     end
 
+    # TODO: check bulk input types and process associated files
     # def check_input_types
-    #   if @options.input_format == 'vcf'
+    #   if @options[:input_format] == 'vcf'
     #
     #   end
     # end
 
-    def check_inputfiles
-      if @options.polyploidy
+    def check_input_files
+      if @options[:polyploidy]
         inputfiles = %i{assembly mut_bulk bg_bulk mut_parent bg_parent}
       else
         inputfiles = %i{assembly mut_bulk bg_bulk}
@@ -171,35 +173,26 @@ OPTIONS:
       end
     end
 
-    def check_output
-      if Dir.exist?(@options.output)
-        raise CheripicArgError.new "#{@options.output} directory exists" +
+    def check_output_dir
+      if Dir.exist?(@options[:output])
+        raise CheripicArgError.new "#{@options[:output]} directory exists" +
                                        'please choose a different output directory name'
       end
     end
 
-    def check_loglevel
-      unless %w(error info warn debug).include?(@options.loglevel)
-        raise CheripicArgError.new "Loglevel #{@options.loglevel} is not valid. " +
+    def check_log_level
+      unless %w(error info warn debug).include?(@options[:loglevel])
+        raise CheripicArgError.new "Loglevel #{@options[:loglevel]} is not valid. " +
                                        'It must be one of: error, info, warn, debug.'
       end
-      logger.level = Yell::Level.new @options.loglevel.to_sym
+      logger.level = Yell::Level.new @options[:loglevel].to_sym
     end
 
-    # def run
-    #   @options.output = File.expand_path @options.output
-    #   FileUtils.mkdir_p @options.output
-    #   Dir.chdir @options.output
-    #   analyse_bulks
-    # end
-    #
-    # def analyse_bulks
-    #   assembly = @options.assembly
-    #   logger.info "Loading assembly: #{assembly}"
-    #   # a = Assembly.new assembly
-    #   logger.info "Analysing assembly: #{assembly}"
-    #
-    # end
+    def run
+      @options[:output] = File.expand_path @options[:output]
+      analysis = Implementer.new(@options)
+      analysis.run
+    end
 
   end # Cmd
 

data/lib/cheripic/contig.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require 'bio'
+require 'forwardable'
+
+module Cheripic
+
+  class ContigError < CheripicError; end
+
+  class Contig
+
+    include Enumerable
+    extend Forwardable
+    # delegate [:size, :length] => :@contig
+    # def_delegator :@contig, :entry_id, :id
+    attr_accessor :hm_pos, :ht_pos, :hemi_pos, :id, :length
+
+    def initialize (fasta)
+      @id = fasta.entry_id
+      @length = fasta.length
+      @hm_pos = {}
+      @ht_pos = {}
+      @hemi_pos = {}
+    end
+
+    def hm_num
+      self.hm_pos.length
+    end
+
+    def ht_num
+      self.ht_pos.length
+    end
+
+    def hme_score
+      hmes_adjust = Options.params.hmes_adjust
+      if self.hm_num == 0 and self.ht_num == 0
+        0.0
+      else
+        (self.hm_num + hmes_adjust) / (self.ht_num + hmes_adjust)
+      end
+    end
+
+    def hemi_num
+      self.hemi_pos.length
+    end
+
+    def bfr_score
+      if self.hemi_pos.values.empty?
+        0.0
+      else
+        geom_mean(self.hemi_pos.values)
+      end
+    end
+
+    # geometric mean of an array of numbers
+    def geom_mean(array)
+      return array[0].to_f if array.length == 1
+      array.reduce(:+) / array.size.to_f
+      # sum = 0.0
+      # array.each{ |v| sum += Math.log(v.to_f) }
+      # sum /= array.size
+      # Math.exp sum
+    end
+
+  end # Contig
+
+end # Cheripic

data/lib/cheripic/contig_pileups.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+require 'bio'
+require 'forwardable'
+
+module Cheripic
+
+  class ContigPileupsError < CheripicError; end
+
+  class ContigPileups
+
+    include Enumerable
+    extend Forwardable
+    def_delegators :@mut_bulk, :each, :each_key, :each_value, :length, :[], :store
+    def_delegators :@bg_bulk, :each, :each_key, :each_value, :length, :[], :store
+    def_delegators :@mut_parent, :each, :each_key, :each_value, :length, :[], :store
+    def_delegators :@bg_parent, :each, :each_key, :each_value, :length, :[], :store
+    attr_accessor :id, :parent_hemi
+    attr_accessor :mut_bulk, :bg_bulk, :mut_parent, :bg_parent
+
+    def initialize (fasta)
+      @id = fasta
+      @mut_bulk = {}
+      @bg_bulk = {}
+      @mut_parent = {}
+      @bg_parent = {}
+      @parent_hemi = {}
+    end
+
+    def bulks_compared
+      @hm_pos = {}
+      @ht_pos = {}
+      @hemi_pos = {}
+      @mut_bulk.each_key do | pos |
+        if Options.params.polyploidy and @parent_hemi.key?(pos)
+          bg_bases = ''
+          if @bg_bulk.key?(pos)
+            bg_bases = @bg_bulk[pos].var_base_frac
+          end
+          mut_bases = @mut_bulk[pos].var_base_frac
+          bfr = Bfr.get_bfr(mut_bases, bg_bases)
+          @hemi_pos[pos] = bfr
+        else
+          self.compare_pileup(pos)
+        end
+      end
+      [@hm_pos, @ht_pos, @hemi_pos]
+    end
+
+    # we are only dealing with single element hashes
+    # so discard hashes with more than one element and empty hashes
+    # empty hash results from position below selected coverage or bases freq below noise
+    def compare_pileup(pos)
+      base_hash = @mut_bulk[pos].var_base_frac
+      base_hash.delete(:ref)
+      return nil if base_hash.empty?
+      # we could ignore complex loci or
+      # take the variant type based on predominant base
+      if base_hash.length > 1
+        mut_type, ratio = var_mode(base_hash.values.max)
+      else
+        base = base_hash.keys[0]
+        mut_type, ratio = var_mode(base_hash[base])
+      end
+      if @bg_bulk.key?(pos)
+        bg_type = bg_bulk_var(pos)
+        mut_type = compare_var_type(mut_type, bg_type)
+      end
+      unless mut_type == nil
+        categorise_pos(mut_type, pos, ratio)
+      end
+    end
+
+    # if both bulks have homozygous var at this position
+    # then ignore the position
+    def compare_var_type(muttype, bgtype)
+      if muttype == :hom and bgtype == :hom
+        nil
+      else
+        muttype
+      end
+    end
+
+    def bg_bulk_var(pos)
+      bg_base_hash = @bg_bulk[pos].var_base_frac
+      if bg_base_hash.length > 1
+        # taking only var mode
+        var_mode(bg_base_hash.values.max)[0]
+      else
+        # taking only var mode
+        var_mode(bg_base_hash[0])[0]
+      end
+    end
+
+    def categorise_pos(var_type, pos, ratio)
+      if var_type == :hom
+        @hm_pos[pos] = ratio
+      elsif var_type == :het
+        @ht_pos[pos] = ratio
+      end
+    end
+
+    # calculate var zygosity for non-polyploid variants
+    # increased range is used for heterozygosity for RNA-seq data
+    def var_mode(ratio)
+      ht_low = Options.params.htlow
+      ht_high = Options.params.hthigh
+      mode = ''
+      if ratio.between?(ht_low, ht_high)
+        mode = :het
+      elsif ratio > ht_high
+        mode = :hom
+      end
+      [mode, ratio]
+    end
+
+    def hemisnps_in_parent
+      # mark all the hemi snp based on both parents
+      self.mut_parent.each_key do |pos|
+        mut_parent_frac = @mut_parent[pos].var_base_frac
+        if self.bg_parent.key?(pos)
+          bg_parent_frac = @bg_parent[pos].var_base_frac
+          bfr = Bfr.get_bfr(mut_parent_frac, bg_parent_frac)
+          @parent_hemi[pos] = bfr
+          self.bg_parent.delete(pos)
+        else
+          bfr = Bfr.get_bfr(mut_parent_frac)
+          @parent_hemi[pos] = bfr
+        end
+      end
+
+      # now include all hemi snp unique to background parent
+      self.bg_parent.each_key do |pos|
+        unless @parent_hemi.key?(pos)
+          bg_parent_frac = @bg_parent[pos].var_base_frac
+          bfr = Bfr.get_bfr(bg_parent_frac)
+          @parent_hemi[pos] = bfr
+        end
+      end
+    end
+
+  end
+
+end

data/lib/cheripic/implementer.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+module Cheripic
+
+  class ImplementerError < CheripicError; end
+
+  class Implementer
+
+    require 'ostruct'
+    require 'fileutils'
+    attr_accessor :options, :variants
+
+    def initialize(inputs)
+      set1 = %i{assembly
+                input_format
+                mut_bulk
+                bg_bulk
+                output
+                mut_parent
+                bg_parent}
+      @options = OpenStruct.new(inputs.select { |k| set1.include?(k) })
+
+      set2 = %i{hmes_adjust
+                htlow
+                hthigh
+                mindepth
+                min_non_ref_count
+                min_indel_count_support
+                ignore_reference_n
+                mapping_quality
+                base_quality
+                noise
+                cross_type
+                only_frag_with_vars
+                filter_out_low_hmes
+                polyploidy
+                bfr_adjust}
+      settings = inputs.select { |k| set2.include?(k) }
+      Options.update(settings)
+      FileUtils.mkdir_p @options.output
+    end
+
+    def extract_vars
+      @variants = Variants.new(@options)
+      @variants.compare_pileups
+    end
+
+    def process_variants
+      @variants.verify_bg_bulk_pileup
+      # print selected variants that could be potential markers or mutation
+      out_file = File.open("#{@options.output}/selected_variants.txt", 'w')
+      out_file.puts "HME_Score\tAlleleFreq\tseq_id\tposition\tref_base\tcoverage\tbases\tbase_quals\tsequence_left\tAlt_seq\tsequence_right"
+      regions = Regions.new(@options.assembly)
+      @variants.hmes_frags.each_key do | frag |
+        contig_obj = @variants.assembly[frag]
+        positions = contig_obj.hm_pos.keys
+        positions.each do | pos |
+          pileup = @variants.pileups[frag].mut_bulk[pos]
+          seqs = regions.fetch_seq(frag,pos)
+          out_file.puts "#{contig_obj.hme_score}\t#{contig_obj.hm_pos[pos]}\t#{pileup.to_s.chomp}\t#{seqs[0]}\t#{pileup.consensus}\t#{seqs[1]}"
+        end
+      end
+      out_file.close
+    end
+
+    def run
+      unless defined?(@variants.has_run)
+        self.extract_vars
+      end
+      if Options.params.polyploidy
+        self.process_variants
+        @variants.bfr_frags
+      else
+        self.process_variants
+      end
+    end
+
+  end
+
+end

data/lib/cheripic/options.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+module Cheripic
+
+  class Options
+
+    require 'ostruct'
+    # class << self; attr_accessor :params end
+
+    @defaults = {
+        :hmes_adjust => 0.5,
+        :htlow => 0.2,
+        :hthigh => 0.9,
+        :mindepth => 6,
+        :min_non_ref_count => 3,
+        :min_indel_count_support => 3,
+        :ignore_reference_n => true,
+        :mapping_quality => 20,
+        :base_quality => 15,
+        :noise => 0.1,
+        :cross_type => 'back',
+        :only_frag_with_vars => true,
+        :filter_out_low_hmes => true,
+        :polyploidy => false,
+        :bfr_adjust => 0.05,
+        :sel_seq_len => 50
+    }
+    # @params = OpenStruct.new(@defaults)
+
+    def self.update(newset)
+      @defaults.merge!(newset)
+      self.params
+      # @params = OpenStruct.new(@defaults)
+    end
+
+    def self.params
+      OpenStruct.new(@defaults)
+    end
+
+  end
+
+end

data/lib/cheripic/pileup.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+require 'bio'
+require 'bio-samtools'
+require 'bio/db/pileup'
+
+class Pileup < Bio::DB::Pileup
+
+  attr_accessor :defaults
+
+  def initialize(string, opts={})
+    super(string)
+    set_defaults(opts)
+    adj_read_bases
+    @indelbases = 'acgtryswkmbdhvnACGTRYSWKMBDHVN'
+  end
+
+  def set_defaults(opts)
+    @defaults = {
+      noise: 0.1,                  # noise level for read depth
+      ht_low: 0.2,                 # min allele freq for heterozygosity
+      ht_high: 0.9,                # max allele freq for heterozygosity
+      min_depth: 6,                # minimum coverage for variant
+      min_non_ref_count: 3,
+      ignore_reference_n: true,
+      min_indel_count_support: 3,
+    }
+    @defaults.merge(opts)
+  end
+
+  # removes mapping quality information
+  def adj_read_bases
+    # mapping quality after '^' symbol is substituted
+    # to avoid splitting at non indel + or - characters
+    # read ends marking by '$' symbol is substituted
+    # insertion and deletion marking by '*' symbol is substituted
+    self.read_bases.gsub!(/\^./, '')
+    self.read_bases.delete! '$'
+    self.read_bases.delete! '*'
+    # warn about reads with ambiguous codes
+    # if self.read_bases.match(/[^atgcATGC,\.\+\-0-9]/)
+    #   warn "Ambiguous nucleotide\t#{self.read_bases}"
+    # end
+  end
+
+  # count bases matching reference and non-reference
+  # from snp variant and make a hash of bases with counts
+  # for indels return the read bases information instead
+  def bases_hash
+    if self.read_bases =~ /\+/
+      bases_hash = indels_to_hash('+')
+    elsif self.read_bases =~ /\-/
+      bases_hash = indels_to_hash('-')
+    else
+      bases_hash = snp_base_hash(self.read_bases)
+    end
+    # some indels will have ref base in the read and using
+    # sum of hash values is going to give wrong additional coverage
+    # from indels so including actual coverage from pileup
+    # bases_hash keys are :A, :C, :G, :T, :N, :ref, :indel and :cov
+    bases_hash[:cov] = self.coverage
+    bases_hash
+  end
+
+  # count bases from indels
+  # array of pileup bases is split at + / -
+  # and number after each + / - is counted
+  def count_indel_bases(delimiter)
+    array = self.read_bases.split(delimiter)
+    number = 0
+    array.shift
+    array.each do |element|
+      # deletions in reference could contain ambiguous codes,
+      number += /^(\d+)[#{@indelbases}]/.match(element)[1].to_i
+    end
+    number
+  end
+
+  # count bases matching reference and non-reference
+  # and calculate ratio of non_ref allele to total bases
+  def non_ref_count
+    read_bases = self.read_bases
+    if read_bases =~ /\+/
+      non_ref_count = indel_non_ref_count('+')
+    elsif read_bases =~ /\-/
+      non_ref_count = indel_non_ref_count('-')
+    else
+      non_ref_count = read_bases.count('atgcATGC')
+    end
+    non_ref_count
+  end
+
+  # check if the pileup has the parameters we are looking for
+  def is_var
+    ignore_reference_n = @defaults[:ignore_reference_n]
+    min_depth  = @defaults[:min_depth]
+    min_non_ref_count = @defaults[:min_non_ref_count]
+
+    return false if self.ref_base == '*'
+    return false if ignore_reference_n and self.ref_base =~ /^[nN]$/
+    return true if self.coverage >= min_depth and self.non_ref_count >= min_non_ref_count
+    false
+  end
+
+  # count bases matching reference and non-reference
+  # and calculate ratio of non_ref allele to total bases
+  def non_ref_ratio
+    self.non_ref_count.to_f / self.coverage.to_f
+  end
+
+  # calculate var zygosity for non-polyploid variants
+  # increased range is used for heterozygosity for RNA-seq data
+  def var_mode
+    ht_low = @defaults[:ht_low]
+    ht_high = @defaults[:ht_high]
+    mode = ''
+    if self.non_ref_ratio.between?(ht_low, ht_high)
+      mode = :het
+    elsif self.non_ref_ratio > ht_high
+      mode = :hom
+    end
+    mode
+  end
+
+  # form hash of base information, [ATGC] counts for snp
+  # a hash of base proportion is calculated
+  # base proportion hash below a selected depth is empty
+  # base proportion below or equal to a noise factor are discarded
+  def var_base_frac
+    hash = self.bases_hash
+    snp_hash = {}
+    coverage = hash[:cov]
+    return snp_hash if coverage < @defaults[:min_depth]
+    # calculate proportion of each base in coverage
+    hash.each_key do | base |
+      next if base == :cov
+      freq = hash[base].to_f/coverage.to_f
+      next if freq <= @defaults[:noise]
+      snp_hash[base] = freq
+    end
+    snp_hash
+  end
+
+
+  private
+
+  # count number of indels and number non-indel base
+  # and return a hash with bases and indel counts
+  def indels_to_hash(delimiter)
+    non_indel_bases = String.new
+    array = self.read_bases.split(delimiter)
+    non_indel_bases << array.shift
+    array.each do |element|
+      # get number of nucleotides inserted or deleted
+      number = /^(\d+)[#{@indelbases}]/.match(element)[1].to_i
+      # capture remaining nucleotides
+      non_indel_bases << element.gsub(/^#{number}\w{#{number}}/, '')
+    end
+    bases_hash = snp_base_hash(non_indel_bases)
+    # check at least three reads are supporting indel
+    indel_count = self.read_bases.count(delimiter)
+    if indel_count >= @defaults[:min_indel_count_support]
+      bases_hash[:indel] = indel_count
+    end
+    bases_hash
+  end
+
+  def snp_base_hash(readbases)
+    non_indel_base_hash = {}
+    non_indel_base_hash[:ref] = readbases.count('.,')
+    non_indel_base_hash[:A] = readbases.count('aA')
+    non_indel_base_hash[:C] = readbases.count('cC')
+    non_indel_base_hash[:G] = readbases.count('gG')
+    non_indel_base_hash[:T] = readbases.count('tT')
+    # non_indel_base_hash[:N] = read_bases.count('nN')
+    non_indel_base_hash
+  end
+
+  def indel_non_ref_count(delimitter)
+    read_bases = self.read_bases
+    non_ref_count = read_bases.count(@indelbases)
+    indelcounts = read_bases.count(delimitter)
+    indel_bases = count_indel_bases(delimitter)
+    non_ref_count + indelcounts - indel_bases
+  end
+
+end

data/lib/cheripic/regions.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require 'bio-samtools'
+require 'forwardable'
+
+module Cheripic
+
+  class RegionsError < CheripicError; end
+
+  class Regions
+
+    include Enumerable
+    extend Forwardable
+    def_delegators :@id_len, :each, :each_key, :each_value, :length, :[]
+    attr_accessor :reference_db, :id_len
+
+    def initialize(assembly)
+      @reference_db = Bio::DB::Fasta::FastaFile.new({:fasta=>assembly})
+      @id_len = {}
+      self.get_id_len
+    end
+
+    def get_id_len
+      @reference_db.load_fai_entries
+      @reference_db.index.entries.each_entry do | entry |
+        @id_len[entry.id] = entry.length
+      end
+    end
+
+    # for each id and position returns left and right sequence
+    # of pre-selected length
+    def fetch_seq(id, pos)
+      limit = Options.params.sel_seq_len + 1
+      len = @id_len[id]
+      low = pos-limit <= 0 ? 0 : pos-limit
+      high = pos+limit >= len ? len : pos+limit
+      region = Bio::DB::Fasta::Region.parse_region("#{id}:#{low}-#{pos-1}")
+      seq_left = @reference_db.fetch_sequence(region)
+      region = Bio::DB::Fasta::Region.parse_region("#{id}:#{pos+1}-#{high}")
+      seq_right = @reference_db.fetch_sequence(region)
+      [seq_left, seq_right]
+    end
+
+  end
+
+end
+

data/lib/cheripic/variants.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+require 'bio'
+require 'forwardable'
+
+module Cheripic
+
+  class VariantsError < CheripicError; end
+
+  class Variants
+
+    include Enumerable
+    extend Forwardable
+    def_delegators :@assembly, :each, :each_key, :each_value, :size, :length, :[]
+    attr_accessor :assembly, :has_run, :pileups, :hmes_frags, :bfr_frags
+
+    def initialize(options)
+      @params = options
+      @assembly = {}
+      @pileups = {}
+      Bio::FastaFormat.open(@params.assembly).each do |entry|
+        if entry.seq.length == 0
+          logger.error "No sequence found for entry #{entry.entry_id}"
+          raise VariantsError
+        end
+        contig = Contig.new(entry)
+        if @assembly.key?(contig.id)
+          logger.error "fasta id already found in the file for #{contig.id}"
+          logger.error 'make sure there are no duplicate entries in the fasta file'
+          raise VariantsError
+        end
+        @assembly[contig.id] = contig
+        @pileups[contig.id] = ContigPileups.new(contig.id)
+      end
+    end
+
+    # Read and store pileup data for each bulk and parents
+    #
+    def analyse_pileups
+      @bg_bulk = @params.bg_bulk
+      @mut_parent = @params.mut_parent
+      @bg_parent = @params.bg_parent
+
+      %i{mut_bulk bg_bulk mut_parent bg_parent}.each do | input |
+        infile = @params[input]
+        if infile != ''
+          extract_pileup(infile, input)
+        end
+      end
+
+      @has_run = true
+    end
+
+    def extract_pileup(pileupfile, sym)
+      # read mpileup file and process each variant
+      File.foreach(pileupfile) do |line|
+        pileup = Pileup.new(line)
+        if pileup.is_var
+          contig_obj = @pileups[pileup.ref_name]
+          contig_obj.send(sym).store(pileup.pos, pileup)
+        end
+      end
+    end
+
+    def compare_pileups
+      unless defined?(@has_run)
+        self.analyse_pileups
+      end
+      @assembly.each_key do | id |
+        contig = @assembly[id]
+        # extract parental hemi snps for polyploids before bulks are compared
+        if @mut_parent != '' or @bg_parent != ''
+          @pileups[id].hemisnps_in_parent
+        end
+        contig.hm_pos, contig.ht_pos, contig.hemi_pos = @pileups[id].bulks_compared
+      end
+    end
+
+    def hmes_frags
+      # calculate every time method gets called
+      @hmes_frags = select_contigs(:hme_score)
+    end
+
+    def bfr_frags
+      unless defined?(@bfr_frags)
+        @bfr_frags = select_contigs(:bfr_score)
+      end
+      @bfr_frags
+    end
+
+    def select_contigs(ratio_type)
+      selected_contigs ={}
+      only_frag_with_vars = Options.params.only_frag_with_vars
+      @assembly.each_key do | frag |
+        if only_frag_with_vars
+          if ratio_type == :hme_score
+            # selecting fragments which have a variant
+            if @assembly[frag].hm_num + @assembly[frag].ht_num > 2 * Options.params.hmes_adjust
+              selected_contigs[frag] = @assembly[frag]
+            end
+          else # ratio_type == :bfr_score
+            # in polyploidy scenario selecting fragments with at least one bfr position
+            if @assembly[frag].hemi_num > 0
+              selected_contigs[frag] = @assembly[frag]
+            end
+          end
+        else
+          selected_contigs[frag] = @assembly[frag]
+        end
+      end
+      selected_contigs = filter_contigs(selected_contigs, ratio_type)
+      if only_frag_with_vars
+        logger.info "Selected #{selected_contigs.length} out of #{@assembly.length} fragments with #{ratio_type} score\n"
+      else
+        logger.info "No filtering was applied to fragments\n"
+      end
+      selected_contigs
+    end
+
+    def filter_contigs(selected_contigs, ratio_type)
+      cutoff = get_cutoff(selected_contigs, ratio_type)
+      selected_contigs.each_key do | frag |
+        if selected_contigs[frag].send(ratio_type) < cutoff
+          selected_contigs.delete(frag)
+        end
+      end
+      selected_contigs
+    end
+
+    def get_cutoff(selected_contigs, ratio_type)
+      filter_out_low_hmes = Options.params.filter_out_low_hmes
+      # set minimum cut off hme_score or bfr_score to pick fragments with variants
+      # calculate min hme score for back or out crossed data or bfr_score for polypoidy data
+      # if no filtering applied set cutoff to 1.1
+      if filter_out_low_hmes
+        if ratio_type == :hme_score
+          adjust = Options.params.hmes_adjust
+          if Options.params.cross_type == 'back'
+            cutoff = (1.0/adjust) + 1.0
+          else # outcross
+            cutoff = (2.0/adjust) + 1.0
+          end
+        else # ratio_type is bfr_score
+          cutoff = bfr_cutoff(selected_contigs)
+        end
+      else
+        cutoff = 0.0
+      end
+      cutoff
+    end
+
+    def bfr_cutoff(selected_contigs, prop=0.1)
+      ratios = []
+      selected_contigs.each_key do | frag |
+        ratios << selected_contigs[frag].bfr_score
+      end
+      ratios.sort!.reverse!
+      index = (ratios.length * prop)/100
+      # set a minmum index to get at least one contig
+      if index < 1
+        index = 1
+      end
+      ratios[index - 1]
+    end
+
+    # method is to discard homozygous variant positions for which background bulk
+    # pileup shows proportion higher than 0.35 for variant allele/non-reference allele
+    # a recessive variant is expected to have 1/3rd frequency in background bulk
+    def verify_bg_bulk_pileup
+      unless defined?(@hmes_frags)
+        self.hmes_frags
+      end
+      @hmes_frags.each_key do | frag |
+        positions = @assembly[frag].hm_pos.keys
+        contig_pileup_obj = @pileups[frag]
+        positions.each do | pos |
+          if contig_pileup_obj.mut_bulk.key?(pos)
+            mut_pileup = contig_pileup_obj.mut_bulk[pos]
+            if mut_pileup.is_var
+              if contig_pileup_obj.bg_bulk.key?(pos)
+                bg_pileup = contig_pileup_obj.bg_bulk[pos]
+                if bg_pileup.non_ref_ratio > 0.35
+                  @assembly[frag].hm_pos.delete(pos)
+                end
+              end
+            else
+              # this should not happen, may be catch as as an error
+              @assembly[frag].hm_pos.delete(pos)
+            end
+          else
+            # this should not happen, may be catch as as an error
+            @assembly[frag].hm_pos.delete(pos)
+          end
+        end
+      end
+      # recalculate hmes_frags once pileups are verified
+      self.hmes_frags
+    end
+
+  end # Variants
+
+end # Cheripic

data/lib/cheripic/version.rb

@@ -1,3 +1,3 @@
 module Cheripic
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/lib/cheripic.rb

@@ -1,5 +1,3 @@
-require 'cheripic/cmd'
-require 'cheripic/version'
 
 # set up a golbal logger object to access across module
 require 'yell'
@@ -23,3 +21,14 @@ module Cheripic
   Object.send :include, Yell::Loggable
 
 end # Cheripic
+
+require 'cheripic/cmd'
+require 'cheripic/version'
+require 'cheripic/implementer'
+require 'cheripic/variants'
+require 'cheripic/contig'
+require 'cheripic/pileup'
+require 'cheripic/options'
+require 'cheripic/contig_pileups'
+require 'cheripic/bfr'
+require 'cheripic/regions'

metadata

@@ -1,20 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: cheripic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Shyam Rallapalli
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-01 00:00:00.000000000 Z
+date: 2016-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yell
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.5
   type: :runtime
@@ -22,6 +25,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.5
 - !ruby/object:Gem::Dependency
@@ -29,6 +35,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
   type: :runtime
@@ -36,6 +45,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
 - !ruby/object:Gem::Dependency
@@ -43,6 +55,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.0
   type: :runtime
@@ -50,13 +65,33 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: bio-gngm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: rinruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.3
   type: :runtime
@@ -64,8 +99,25 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.3
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +178,9 @@ dependencies:
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
@@ -133,6 +188,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
@@ -140,6 +198,9 @@ dependencies:
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.5.0
@@ -147,6 +208,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.5.0
@@ -154,6 +218,9 @@ dependencies:
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.2
@@ -161,6 +228,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.2
@@ -183,7 +253,15 @@ files:
 - bin/setup
 - cheripic.gemspec
 - lib/cheripic.rb
+- lib/cheripic/bfr.rb
 - lib/cheripic/cmd.rb
+- lib/cheripic/contig.rb
+- lib/cheripic/contig_pileups.rb
+- lib/cheripic/implementer.rb
+- lib/cheripic/options.rb
+- lib/cheripic/pileup.rb
+- lib/cheripic/regions.rb
+- lib/cheripic/variants.rb
 - lib/cheripic/version.rb
 homepage: https://github.com/shyamrallapalli/cheripic
 licenses: