bio-sam-mutation 0.4.1

data/lib/bio-sam-mutation/bio/mutation_array.rb

@@ -0,0 +1,15 @@
+class Bio::MutationArray < Array
+  include VepHgvs
+  def to_hgvs(reference_type=nil)
+    if length > 0 && reference_type.nil?
+      reference_type = first.seqname.match(/^ENS/) ? "c" : "g"
+    end
+    if length == 1
+      first.to_hgvs(reference_type)
+    elsif length > 1
+      [first.seqname,":",reference_type,".["].join + map(&:to_hgvs).join(";") + "]"
+    elsif length == 0
+      nil
+    end
+  end
+end

data/lib/bio-sam-mutation/bio/vephgvs.rb

@@ -0,0 +1,21 @@
+module VepHgvs
+  require 'bio-ensembl-rest'
+  def vep(species="human",reference_type=nil)
+    return unless self.first.to_hgvs
+    if reference_type.nil?
+      reference_type = self.first.seqname.match(/^ENS/) ? "c" : "g"
+    end
+    EnsemblRest.connect_db
+    JSON.parse(EnsemblRest::Variation.vep_hgvs(species,self.to_hgvs(reference_type)))
+  end
+
+  def self.consequences_for_transcript (json_object,tscript)
+    if json_object.length > 0
+      if json_object.first["transcript_consequences"]
+        consequences = json_object.first["transcript_consequences"]
+        consequences.keep_if{|a| a["transcript_id"] == tscript}
+        consequences.map{|a| {"Allele" => json_object.first["allele_string"], "CDS position" => a["cds_start"], "Protein start" => a["protein_start"], "Mutation" => a["amino_acids"], "Consequence" => a["consequence_terms"]}}
+      end
+    end
+  end
+end

data/lib/bio-sam-mutation/mutationscli.rb

@@ -0,0 +1,83 @@
+module MutationsCLI
+  @default_species = "human"
+  @tag_to_add = "YH:m"
+  class << self
+    attr_accessor :default_species, :tag_to_add
+  end
+
+  def self.tag (sam, config, species=MutationsCLI.default_species)
+    # With multiple files, could end up with duplicate headers...
+    if sam.match(/^@/)
+      if config[:single_product]
+        config[:outfile].puts sam
+        return
+      else
+        # If we have multiple products, output sam headers to each output file
+        config.each do |key, config_hash|
+          next if [:start_length].include? key
+          config_hash[:outfile].puts sam
+        end
+        return
+      end
+    end
+    sam = Bio::DB::Alignment.new(sam)
+    # DRY up:
+    unless config[:single_product]
+      first_bases = sam.seq[0..config[:start_length]-1].upcase
+      config[first_bases] ? config = config[first_bases] : return
+    end
+    # Stop if a search file is specified, and this isn't it.
+    return if MutationsCLI.not_included_file?(config, ARGF)
+    mut_array = sam.mutations(config[:offset],config[:length],config[:translation_start])
+    if mut_array
+      new_tag = Bio::DB::Tag.new(MutationsCLI.tag_to_add + ":" + mut_array.to_hgvs)
+      config[:outfile].puts sam.add_tag(new_tag)
+    end
+  end
+
+  # Returns a MutationArray
+  def self.call_mutations sam, config
+    unless config[:single_product]
+      first_bases = sam.seq[0..config[:start_length]-1].upcase
+      config[first_bases] ? config = config[first_bases] : return
+    end
+    MutationsCLI.call_mutations_given_product sam, config
+  end
+
+  def self.call_mutations_given_product sam, config
+    # Stop if a search file is specified, and this isn't it.
+    return if MutationsCLI.not_included_file?(config, ARGF)
+    sam.mutations(config[:offset],config[:length],config[:translation_start])
+  end
+
+  def self.not_included_file? config, input
+    config[:file] && input.filename !~ config[:file]
+  end
+
+  def self.set_defaults config_hash
+    config_hash[:start] ||= "." # i.e. regexp will match anything
+    config_hash[:offset] ||= 1
+    config_hash[:length] ||= 100
+    config_hash[:translation_start] ||= 1
+    config_hash[:file] = Regexp.new(config_hash[:file]) if config_hash[:file]
+    config_hash
+  end
+
+  # Allows multiple amplicons to be considered
+  # Organises the configuration data by sequence start
+  def self.construct_products config_hash
+    new_hash = {}
+    config_hash[:products].each do |product_name, config|
+      new_hash[config[:start]] = config
+      new_hash[config[:start]][:output] ||= product_name + ".sam"
+      new_hash[config[:start]][:outfile] = File.open(new_hash[config[:start]][:output],'w')
+    end
+    lengths = new_hash.keys.map!(&:length).uniq
+    new_hash[:start_length] = lengths[0]
+    warn "Start sequences given must be same length" if lengths.size > 1
+    new_hash
+  end
+
+  #
+
+end

data/test/helper.rb

@@ -0,0 +1,34 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_adapter 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bio-sam-mutation'
+
+class Test::Unit::TestCase
+end

data/test/test_cigar.rb

@@ -0,0 +1,145 @@
+require 'helper'
+class CigarTest < Test::Unit::TestCase
+	def test_partition
+		s = Bio::Alignment::CIGAR.new("M 1 D 2 I 3","GAT",source="exonerate")
+		assert_equal([["M",1],["D",2],["I",3]], s.pairs)
+		assert_equal(3, s.pairs.length)
+		assert_equal(1, s.matched_length)
+	end
+
+	def test_auto_detect
+		exonerate  = Bio::Alignment::CIGAR.new("M 1 D 2 I 3","GAT")
+		sam =  Bio::Alignment::CIGAR.new("2M5D4M","ATCCTCCGGAA")
+		assert_raise {Bio::Alignment::CIGAR.new("rubbish","GATC")}
+		assert_nothing_raised {Bio::Alignment::CIGAR.new("M 1 D 2 I 3","GAT")}
+		assert_equal [["M",1],["D",2],["I",3]], exonerate.pairs
+		assert_equal [["M",2],["D",5],["M",4]], sam.pairs
+	end
+
+	def test_subalignment
+		m = Bio::Alignment::CIGAR.new("M 35","GGATCGATCGATCGATCGATCGATCGATCGATCGA")
+		msa = m.subalignment(10,12)
+		assert_equal "GATCGATCGATC", msa.reference
+		assert_equal [["M", 12]], msa.pairs
+
+		s = Bio::Alignment::CIGAR.new("M 16 I 1 M 325 D 3 M 4 D 2 M 178 I 1 M 17","TTTAATTGCATTTAATTGCATTTAATTGCATTAATTGCATGGTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTA")
+		sa = s.subalignment(340,7)
+		# M 16 + M 325 [I not included] = 341
+		# Start at 340 = include 340 and 341, i.e. M 2
+		# Total of all M+D in subalignment should be 7
+		assert_equal([["M", 2],["D",3],["M",2]],sa.pairs)
+		assert_equal("CATTTAA",sa.reference)
+		# Case where subalignment starts at the end of a pair (M 325 in test case)
+		sa2 = s.subalignment(341,7)
+		assert_equal([["M", 1],["D",3],["M",3]],sa2.pairs)
+	end
+
+	def test_subcigar
+		s = Bio::Alignment::CIGAR.new("M 16 I 1 M 325 D 3 M 4 D 2 M 178 I 1 M 17","TTTAATTGCATTTAATTGCATTTAATTGCATTAATTGCATGGTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTAATTGCATTTA")
+		soft = Bio::Alignment::CIGAR.new("1S5M6D15M","CCCTGACGTTGAGGTGGATGGGTTCTCTGAGCTTCGG",source="sam")
+		assert_equal [["M", 2],["I",1],["M",4]], s.subcigar(15,7).pairs
+		assert_equal [["M",16],["I",1]], s.subcigar(1,17).pairs
+		assert_equal [["S",1],["M",2]], soft.subcigar(1,3).pairs
+	end
+
+	def test_small
+		s = Bio::Alignment::CIGAR.new("M 20 D 1 I 1 M 1 D 8 I 2 M 10","GGATCGATCGATCGATCGATCGATCGATCGATCGATCGAT")
+		assert_equal([["M",20],["M",1],["M",1],["D",8],["I",2],["M",10]],s.remove_small!.pairs)
+		# Could improve by combining adjacent pairs of same type.
+	end
+
+	def test_small_deletions
+		d = Bio::Alignment::CIGAR.new("M 20 D 1 M 10 D 4","GGATCGATCGATCGATCGATCGATCGATCGATCGA")
+		i = Bio::Alignment::CIGAR.new("M 20 I 1 M 10 D 4","GGATCGATCGATCGATCGATCGATCGATCGATCG")
+		assert_equal([["M",20],["M",1],["M",10],["D",4]],d.remove_small!.pairs)
+		assert_equal([["M",20],["M",10],["D",4]],i.remove_small!.pairs)
+
+	end
+
+	def test_lengths
+		m = Bio::Alignment::CIGAR.new("M 1 D 2 M 3 I 4 M 5","AAAATAAAATA")
+		d = Bio::Alignment::CIGAR.new("M 1 D 2 M 3 I 4 D 5","AAAATAAAATA")
+		i = Bio::Alignment::CIGAR.new("M 1 I 2 M 3 I 4 D 5","AAAATAAAA")
+		assert_equal(9,m.matched_length)
+		assert_equal(7,d.deleted_length)
+		assert_equal(6,i.inserted_length)
+		assert_equal(11,m.reference_length)
+		assert_equal(11,d.reference_length)
+		assert_equal(9,i.reference_length)
+	end
+
+  def test_masking
+		s1 = Bio::Alignment::CIGAR.new("1S10M","AAAATAAAA",source="sam")
+		s2 = Bio::Alignment::CIGAR.new("10M5D","AAAATAAAA",source="sam")
+		h = Bio::Alignment::CIGAR.new("25H1I10M","AAAATAAAA",source="sam")
+		assert_equal 1, s1.masked_length
+		assert_equal 0, s2.masked_length
+		assert_equal 25, h.masked_length
+	end
+
+	def test_query_length
+		m = Bio::Alignment::CIGAR.new("M 1 D 2 M 3 I 4 M 5","AAAATAAAATA")
+		d = Bio::Alignment::CIGAR.new("M 1 D 2 M 3 I 4 D 5","AAAATAAAATA")
+		i = Bio::Alignment::CIGAR.new("M 1 I 2 M 3 I 4 D 5","AAAATAAAA")
+		s1 = Bio::Alignment::CIGAR.new("1S10M","AAAATAAAA",source="sam")
+		s = Bio::Alignment::CIGAR.new("1S5M2D2M1I5M","AAAATAAAA",source="sam")
+		assert_equal 13, m.query_length
+		assert_equal 8, d.query_length
+		assert_equal 10, i.query_length
+		assert_equal 11, s1.query_length
+		assert_equal 14, s.query_length
+	end
+
+	def test_query_output
+		m = Bio::Alignment::CIGAR.new("M 11","AAAATAAAATA")
+		lc = Bio::Alignment::CIGAR.new("M 11","aaaataaaata")
+    d = Bio::Alignment::CIGAR.new("M 5 D 2 M 4","AAAATAAAATA")
+    i = Bio::Alignment::CIGAR.new("M 5 I 10 M 6","AAAATAAAATA")
+    i2 = Bio::Alignment::CIGAR.new("M 5 I 2 M 3 I 4 M 6","AAAATGCCAAAATA")
+		assert_equal("AAAATAAAATA",m.query)
+		assert_equal("AAAATAAAATA",lc.query)
+		assert_equal("AAAAT--AATA",d.query)
+		assert_equal("AAAAT[10]AAAATA",i.query)
+		assert_equal("AAAAT-insertion-AAAATA",i.query("-insertion-"))
+		assert_equal("AAAATttGCCataaAAAATA",i2.query(["tt","ataa"]))
+	end
+
+	def test_positions
+    i = Bio::Alignment::CIGAR.new("M 5 I 10 M 6","AAAATAAAATA")
+		assert_equal({"I" => [[5, 10, 5]]}, i.positions(/I/))
+    d = Bio::Alignment::CIGAR.new("M 5 D 2 M 4","AAAATAAAATA")
+		assert_equal({"M" => [[0,5,0],[7,4,5]], "D" => [[5,2,5]]},d.positions(/[MD]/))
+	end
+	def test_positions_on_query
+		i = Bio::Alignment::CIGAR.new("M 5 I 10 D 3 M 6","AAAATAAAATA")
+		assert_equal({"D" => [[5, 3, 15]]}, i.positions(/D/))
+	end
+
+	def test_hgnc
+		d = Bio::Alignment::CIGAR.new("M 5 D 2 M 4","AAAATAAAATA")
+		i = Bio::Alignment::CIGAR.new("M 5 I 10 M 6","AAAATAAAATA")
+		i2 = Bio::Alignment::CIGAR.new("M 5 I 2 M 3 D 1 M 6","AAAATGCCGAAAATA")
+		dsam = Bio::Alignment::CIGAR.new("155M6D15M","CCCTGACGTTGAGGTGGATGGGTTCTCTGAGCTTCGGTGGGATGACCAGCAGAAAGTCAAGAAGACAGCGGAAGCTGGAGGAGTGACAGGCAAAGGCCAGGATGGAATTGGTAGCAAGGCAGAGAAGACTCTGGGTGACTTTGCAGCAGAGTATGCCAAGTCCAACAGAAGTACGT",source="sam")
+		assert_equal "g.6_7delAA", d.hgnc
+		assert_equal "g.25_26insGATCGATCGA", i.hgnc(20,"GATCGATCGA")
+		assert_equal "g.[5_6insGA;9delG]", i2.hgnc(0,"GA")
+		assert_equal "g.156_161delCCAAGT", dsam.hgnc(0)
+	end
+
+	def test_hgnc_from_subalignment
+		align = Bio::Alignment::CIGAR.new("M 5 I 2 M 3 D 1 M 6","AAAATGCCGAAAATA")
+		sa = align.subalignment(6,7)
+	  assert_equal([["M", 3],["D",1],["M",3]],sa.pairs)
+		assert_equal("GCCGAAA",sa.reference)
+		assert_equal "g.4delG", sa.hgnc
+	end
+
+	def test_substitutions
+		d = Bio::Alignment::CIGAR.new("M 5 D 2 M 4","AAAATAAAATA")
+		s = Bio::Alignment::CIGAR.new("M 11","AAAATAAAATA")
+		assert_equal "c.5T>A", s.hgnc(0,[],"c",["5T>A"])
+		assert_equal "g.[6_7delAA;1A>T]", d.hgnc(0,[],"g",["1A>T"])
+
+	end
+
+end

data/test/test_mdtag.rb

@@ -0,0 +1,46 @@
+require 'helper'
+class MDZTest < Test::Unit::TestCase
+	def test_match
+		mdz = Bio::DB::Tag::MD.new("MD:Z:60^G13")
+		assert_equal "60^G13", mdz.tag
+	end
+
+	def test_ref_length
+		mdz_del = Bio::DB::Tag::MD.new("MD:Z:60^G13")
+		assert_equal(mdz_del.ref_length, 74)
+		mdz_sub = Bio::DB::Tag::MD.new("MD:Z:60G0A13")
+		assert_equal(mdz_sub.ref_length, 75)
+		mdz_none = Bio::DB::Tag::MD.new("MD:Z:150")
+		assert_equal(mdz_none.ref_length, 150)
+
+	end
+
+	def test_pairs
+		mdz = Bio::DB::Tag::MD.new("MD:Z:60^G13T")
+		assert_equal [["m",60],["d","G"],["m",13],["s","T"]], mdz.pairs
+		assert_equal [["m",60,0,0],["d","G",60,60],["m",13,61,60],["s","T",74,73]], mdz.cumulative
+	end
+
+	def test_reconstruct_tag
+		mdz = Bio::DB::Tag::MD.new("MD:Z:60^G13T")
+		assert_equal "60^G13T",  mdz.reconstruct_tag
+	end
+
+	def test_slice
+		mdz = Bio::DB::Tag::MD.new("MD:Z:60^G13T")
+
+		new_mdz = Bio::DB::Tag::MD.new("MD:Z:6^G3")
+		assert_equal new_mdz.tag, mdz.slice(55,10).tag
+	end
+
+	def test_report
+		mdz_del = Bio::DB::Tag::MD.new("MD:Z:60^G13")
+		assert_equal([["d","G",60,60]], mdz_del.deletions)
+		mdz_sub = Bio::DB::Tag::MD.new("MD:Z:60G0A13")
+		assert_equal([["s","G",60,60],["s","A",61,61]], mdz_sub.substitutions)
+		mdz_none = Bio::DB::Tag::MD.new("MD:Z:150")
+		assert_equal([], mdz_none.report)
+		mdz_del_sub = Bio::DB::Tag::MD.new("MD:Z:60^G5A13")
+		assert_equal [["s","A",66,65]], mdz_del_sub.substitutions
+	end
+end

data/test/test_mutant_allele.rb

@@ -0,0 +1,21 @@
+require 'helper'
+class MutantAlleleTest < Test::Unit::TestCase
+  def test_initialization
+    ma = MutantAllele.new
+    assert_equal 0, ma.count
+  end
+
+  def test_cached_lookup
+    ma = MutantAllele.new
+    m = Bio::Mutation.new
+    m.position = 358
+    m.reference = "TCC"
+    m.seqname = "ENST00000366794"
+    m.type = :deletion
+    m.mutant = nil
+    ma.mutations = Bio::MutationArray.new([m])
+    MutantAllele.previous_lookups[ma.mutations.to_hgvs] = "mock previous lookup"
+    assert_equal "mock previous lookup", ma.lookup
+  end
+
+end

data/test/test_mutation.rb

@@ -0,0 +1,84 @@
+require 'helper'
+class MutationTest < Test::Unit::TestCase
+  def test_mutation_initialisation
+    params = {position: 1234,
+              type: :deletion,
+              reference: "ATGG",
+              mutant: nil,
+              seqname: 5}
+    mut = Bio::Mutation.new(params)
+    assert_equal 1234, mut.position
+    assert_equal :deletion, mut.type
+    assert_equal "ATGG", mut.reference
+    assert_nil mut.mutant
+    assert_equal 5, mut.seqname
+  end
+
+  def test_single_deletion_hgvs
+    params = {position: 1234,
+              type: :deletion,
+              reference: "G",
+              mutant: nil,
+              seqname: 5}
+    mut = Bio::Mutation.new(params)
+    assert_equal "1234delG", mut.to_hgvs
+    assert_equal "5:g.1234delG", mut.to_hgvs("g")
+  end
+
+  def test_deletion_hgvs
+    params = {position: 1234,
+              type: :deletion,
+              reference: "ATGG",
+              mutant: nil,
+              seqname: 5}
+    mut = Bio::Mutation.new(params)
+    assert_equal "1234_1237delATGG", mut.to_hgvs
+    assert_equal "5:g.1234_1237delATGG", mut.to_hgvs("g")
+  end
+
+  def test_substitution_hgvs
+    params = {position: 1234,
+              type: :substitution,
+              reference: "A",
+              mutant: "T",
+              seqname: 5}
+    mut = Bio::Mutation.new(params)
+    assert_equal "1234A>T", mut.to_hgvs
+    assert_equal "5:g.1234A>T", mut.to_hgvs("g")
+  end
+
+  def test_longer_substitution_hgvs
+    params = {position: 1234,
+              type: :substitution,
+              reference: "ATG",
+              mutant: "CCT",
+              seqname: 5}
+    mut = Bio::Mutation.new(params)
+    assert_equal "1234_1236ATG>CCT", mut.to_hgvs
+    assert_equal "5:c.1234_1236ATG>CCT", mut.to_hgvs("c")
+  end
+
+  def test_insertion_hgvs
+    params = {position: 1234,
+              type: :insertion,
+              reference: nil,
+              mutant: "T",
+              seqname: 5}
+    mut = Bio::Mutation.new(params)
+    assert_equal "1234_1235insT", mut.to_hgvs
+    assert_equal "5:g.1234_1235insT", mut.to_hgvs("g")
+  end
+
+  # def test_vep
+  #   params = {position: 112839914,
+  #             type: :deletion,
+  #             reference: "ACCACC",
+  #             mutant: nil,
+  #             seqname: 5}
+  #   mut = Bio::Mutation.new(params)
+  #   result = mut.vep("human","g")
+  #   assert_equal "inframe_deletion", result.first["most_severe_consequence"], "NB: Test written for GRCh38"
+  #   assert_equal "ACCACC/-", result.first["allele_string"], "NB: Test written for GRCh38"
+  #   # TODO Continue...
+  # end
+end