mspire-sequest 0.2.5

data/spec/mspire/sequest/srf/pepxml_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+require 'mspire/sequest/srf/pepxml'
+
+describe 'an Mspire::Ident::Pepxml object from an srf file with modifications' do
+
+  before(:all) do
+    @out_path = TESTFILES + '/tmp'
+    srf_file = SEQUEST_DIR + '/opd1_2runs_2mods/sequest331/020.srf'
+    @srf = Mspire::Sequest::Srf.new(srf_file)
+  end
+
+  before(:each) do
+    FileUtils.mkdir @out_path unless File.exist?(@out_path)
+  end
+
+  after(:each) do
+    FileUtils.rm_rf @out_path
+  end
+
+
+  it 'produces xml with all the expected parts' do
+    tags = %w(msms_pipeline_analysis msms_run_summary sample_enzyme specificity search_summary search_database enzymatic_search_constraint aminoacid_modification parameter spectrum_query search_result search_hit modification_info mod_aminoacid_mass search_score)
+    pepxml = @srf.to_pepxml(:verbose => false)
+    xml_string = pepxml.to_xml
+    tags.each do |tag|
+      xml_string.should match( %r{<#{tag}} )
+    end
+  end
+
+  # takes an xml string of attributes (' key="val" key2="val2" ') and a xml
+  # node that is expected to have those attributes
+  def has_attributes(node, string)
+    if node.nil?
+      raise "your xml node is nil!!!"
+    end
+    if node == []
+      raise "you gave me an empty array instead of a node"
+    end
+    # strips the tail end quote mark, also
+    string.strip!
+    string.chomp!('"')
+    string.split(/"\s+/).each do |str|
+      (key,val) = str.split('=',2)
+      val=val[1..-1] if val[0,1] == '"' 
+      if node[key] != val
+        puts "FAILING"
+        puts "EXPECT: #{key} => #{val} ACTUAL => #{val}"
+        puts "NODE KEYS: "
+        p node.keys
+        puts "NODE VALUES: "
+        p node.values
+      end
+      node[key].should == val
+    end
+  end
+
+  it 'gets everything right' do
+    xml_string = @srf.to_pepxml(:verbose => false).to_xml
+    doc = Nokogiri::XML.parse(xml_string, nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS)
+
+    root = doc.root
+
+    root.name.should == "msms_pipeline_analysis"
+    has_attributes( root, 'schemaLocation="http://regis-web.systemsbiology.net/pepXML /tools/bin/TPP/tpp/schema/pepXML_v115.xsd"' )
+    root['date'].should_not be_nil
+    root['summary_xml'].should match( "020.xml" )
+    root.namespaces.should == ( {"xmlns" => "http://regis-web.systemsbiology.net/pepXML" } )
+
+    mrs_node = root.child
+    mrs_node.name.should ==  'msms_run_summary'
+    has_attributes( mrs_node, 'msManufacturer="Thermo" msModel="LCQ Deca XP" msIonization="ESI" msMassAnalyzer="Ion Trap" msDetector="UNKNOWN" raw_data=".mzML"' )
+    se_node = mrs_node.child
+    se_node.name.should ==  'sample_enzyme'
+    has_attributes se_node, 'name="Trypsin"'
+    specificity_node = se_node.child
+    specificity_node.name.should ==  'specificity'
+    has_attributes specificity_node, 'cut="KR" no_cut="P" sense="C"'
+    search_summary_node = se_node.next_sibling
+    search_summary_node.name.should ==  'search_summary'
+    has_attributes search_summary_node, 'search_engine="SEQUEST" precursor_mass_type="average" fragment_mass_type="average" search_id="1"'
+    search_summary_node['base_name'].should match( %r{sequest/opd1_2runs_2mods/sequest331/020$} )
+    # TODO: expand the search summary check!
+    # TODO: finish testing other guys for accurcy
+  
+  end
+end
+
+

data/spec/mspire/sequest/srf/search_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'fileutils'
+
+require 'mspire/sequest/srf'
+require 'mspire/sequest/srf/search'
+
+class SRF_TO_MGF_HELPER
+  FIRST_MSMS = {
+    :first_lines => ['BEGIN IONS', 'TITLE=000.2.2.1.dta', 'CHARGE=1+', 'PEPMASS=391.04541015625'],
+    :first_two_ion_lines => ['111.976043701172 41418.0', '112.733383178711 88292.0'],
+    :last_two_ion_lines => ['407.412780761719 18959.0', '781.085327148438 10104.0'],
+    :last_line => 'END IONS',
+  }
+  LAST_MSMS = { 
+    :first_lines => ['BEGIN IONS', 'TITLE=000.3748.3748.3.dta', 'CHARGE=3+', 'PEPMASS=433.56494129743004'],
+    :first_two_ion_lines => ['143.466918945312 2110.0', '151.173095703125 4134.0'],
+    :last_two_ion_lines => ['482.678771972656 3357.0', '610.4111328125 8968.0'],
+    :last_line => 'END IONS',
+  }
+end
+
+# these have been checked against Bioworks .dta output
+class SRF_TO_DTA_HELPER
+  FIRST_SCAN = {
+    :first_line => '391.045410 1',
+    :first_two_ion_lines => ['111.9760 41418', '112.7334 88292'],
+    :last_two_ion_lines => ['407.4128 18959', '781.0853 10104'],
+  }
+  LAST_SCAN = {
+    :first_line => '1298.680271 3',
+    :first_two_ion_lines => ['143.4669 2110', '151.1731 4134'],
+    :last_two_ion_lines => ['482.6788 3357', '610.4111 8968'],
+  }
+end
+
+Srf_file = MS::TESTDATA + '/sequest/opd1_static_diff_mods/000.srf'
+TMPDIR = TESTFILES + '/tmp'
+Mgf_output = TMPDIR + '/000.mgf.tmp'
+Dta_output = TMPDIR + '/000.dta.tmp'
+
+shared_examples_for 'an srf to ms2 search converter' do |convert_to_mgf, convert_to_dta|
+  def assert_ion_line_close(expected, actual, delta)
+    expected.split(/\s+/).zip(actual.split(/\s+/)).each do |exp,act|
+      exp.to_f.should be_within(delta).of(act.to_f)
+    end
+  end
+
+  def compare_dtas(key, filename)
+    File.exist?(filename).should be_true
+    lines = IO.read(filename).strip.split("\n")
+    (exp1, act1) = [key[:first_line], lines[0]].map {|l| l.split(/\s+/) }
+    exp1.first.to_f.should be_within(0.000001).of(act1.first.to_f)
+    exp1.last.should == act1.last
+    (key[:first_two_ion_lines] + key[:last_two_ion_lines]).zip(lines[1,2]+lines[-2,2]) do |exp,act|
+      assert_ion_line_close(exp, act, 0.0001)
+    end
+  end
+
+  def compare_mgfs(key, string_chunk)
+    lines = string_chunk.strip.split("\n")
+    key[:first_lines][0,3].should == lines[0,3]
+    (exp_pair, act_pair) = [key[:first_lines][3], lines[3]].map {|line| line.split('=') }
+    exp_pair.first.should == act_pair.first
+    exp_pair.last.to_f.should be_within(0.0000001).of( act_pair.last.to_f )
+
+    (key[:first_two_ion_lines] + key[:last_two_ion_lines]).zip(lines[4,2] + lines[-3,2]).each do |exp_line,act_line|
+      assert_ion_line_close(exp_line, act_line, 0.00000001)
+    end
+
+    key[:last_line].should == lines[-1]
+  end
+
+  it 'converts to mgf' do
+    output = Mgf_output
+    convert_to_mgf.call
+    File.exist?(output).should be_true
+    output = IO.read(output)
+    chunks = output.split("\n\n")
+
+    compare_mgfs(SRF_TO_MGF_HELPER::FIRST_MSMS, chunks.first)
+    compare_mgfs(SRF_TO_MGF_HELPER::LAST_MSMS, chunks.last)
+  end
+
+  it 'generates .dta files' do
+    output = Dta_output
+    convert_to_dta.call
+    File.exist?(output).should be_true
+    File.directory?(output).should be_true
+    # frozen (not verified):
+    Dir[output + "/*.*"].size.should == 3893 # the correct number files
+
+    compare_dtas(SRF_TO_DTA_HELPER::FIRST_SCAN, output + '/000.2.2.1.dta')
+    compare_dtas(SRF_TO_DTA_HELPER::LAST_SCAN, output + '/000.3748.3748.3.dta')
+  end
+
+end
+
+describe 'converting an srf to ms2 search format: programmatic' do
+  before do
+    FileUtils.mkdir(TMPDIR) unless File.exist?(TMPDIR)
+  end
+  after do
+    FileUtils.rmtree(TMPDIR)
+  end
+
+  srf = Mspire::Sequest::Srf.new(Srf_file)
+
+  convert_to_mgf = lambda { srf.to_mgf(Mgf_output) }
+  convert_to_dta = lambda { srf.to_dta(Dta_output) }
+
+  it_behaves_like 'an srf to ms2 search converter', convert_to_mgf, convert_to_dta
+
+end
+
+describe 'converting an srf to ms2 search format: commandline' do
+  def self.commandline_lambda(string)
+    lambda { Mspire::Sequest::Srf::Search.commandline(string.split(/\s+/)) }
+  end
+
+  convert_to_mgf = self.commandline_lambda "#{Srf_file} -o #{Mgf_output}"
+  convert_to_dta = self.commandline_lambda "#{Srf_file} -o #{Dta_output} -f dta"
+
+  before(:each) do
+    FileUtils.mkdir(TMPDIR) unless File.exist?(TMPDIR)
+  end
+  after(:each) do
+    FileUtils.rmtree(TMPDIR)
+  end
+
+  it_behaves_like 'an srf to ms2 search converter', convert_to_mgf, convert_to_dta
+end

data/spec/mspire/sequest/srf/sqt_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+require 'mspire/sequest/srf'
+require 'mspire/sequest/srf/sqt'
+
+SpecHelperHeaderHash = {
+  'SQTGenerator' => 'mspire: ms-sequest',
+  'SQTGeneratorVersion' => String,
+  'Database' => 'C:\\Xcalibur\\database\\ecoli_K12_ncbi_20060321.fasta',
+  'FragmentMasses' => 'AVG',
+  'PrecursorMasses' => 'AVG',
+  'StartTime' => nil, 
+  'Alg-MSModel' => 'LCQ Deca XP',
+  'Alg-PreMassUnits' => 'amu',
+  'DBLocusCount' => '4237',
+  'Alg-FragMassTol' => '1.0000',
+  'Alg-PreMassTol' => '1.4000',
+  'Alg-IonSeries' => '0 1 1 0.0 1.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0',
+  'Alg-Enzyme' => 'Trypsin(KR/P) (2)',
+  'Comment' => ['Created from Bioworks .srf file'],
+  'DynamicMod' => ['STY*=+79.97990', 'M#=+14.02660'],
+}
+
+ExpasyStaticMods = ['C=160.1901','Cterm=10.1230','E=161.4455']
+MoleculesStaticMods = ["C=160.1942", "Cterm=10.1230", "E=161.44398"]
+SpecHelperHeaderHash['StaticMod'] = MoleculesStaticMods 
+
+# these only need to be really close
+Close_indices = {
+  'S' => [6,7],
+  'M' => [3,4,5,6],
+}
+
+SpecHelperOtherLines =<<END
+S	2	2	1	0.0	VELA	391.04541015625	3021.5419921875	0.0	0
+S	3	3	1	0.0	VELA	446.009033203125	1743.96911621094	0.0	122
+M	1	1	445.5769264522	0.0	0.245620265603065	16.6666660308838	1	6	R.SNSK.S	U
+L	gi|16128266|ref|NP_414815.1|
+END
+
+SpecHelperOtherLinesEnd =<<END
+L	gi|90111093|ref|NP_414704.4|
+M	10	17	1298.5350544522	0.235343858599663	0.823222815990448	151.717300415039	12	54	K.LQKIITNSY*K	U
+L	gi|90111124|ref|NP_414904.2|
+END
+
+
+module SPEC
+  Srf_file = MS::TESTDATA + '/sequest/opd1_static_diff_mods/000.srf' 
+  TMPDIR = TESTFILES + '/tmp'
+  Srf_output = TMPDIR + '/000.sqt.tmp'
+end
+
+
+# {
+#   :lambdas => { :basic_conversion, :with_new_db_path, :update_the_db_path }
+#   :original_db_filename = String
+#                        # "C:\\Xcalibur\\database\\ecoli_K12_ncbi_20060321.fasta"
+#   :output => String  # SPEC::Srf_output
+# }
+
+shared_examples_for 'an srf to sqt converter' do |opts|
+
+  # returns true or false
+  def header_hash_match(header_lines, hash)
+    header_lines.all? do |line|
+      (h, k, v) = line.chomp.split("\t")
+      if hash[k].is_a? Array
+        if hash[k].include?(v) 
+          true
+        else
+          puts "FAILED: "
+          p k
+          p v
+          p hash[k]
+          false
+        end
+      elsif hash[k] == String
+        v.is_a?(String)
+      else
+        if v == hash[k]
+          true
+        else
+          puts "FAILED: "
+          p k
+          p v
+          p hash[k]
+          false
+        end
+      end
+    end
+  end
+
+  def sqt_line_match(act_line_ar, exp_line_ar)
+    exp_line_ar.zip(act_line_ar) do |exp_line, act_line|
+      (e_pieces, a_pieces) = [exp_line, act_line].map {|line| line.chomp.split("\t") } 
+      if %w(S M).include?(k = e_pieces[0])
+        (e_close, a_close) = [e_pieces, a_pieces].map do |pieces| 
+          Close_indices[k].sort.reverse.map do |i|
+            pieces.delete_at(i).to_f
+          end.reverse
+        end
+        e_close.zip(a_close) do |ex, ac|
+          ex.should be_within(0.0000001).of( ac )
+        end
+      end
+      e_pieces.should == a_pieces
+    end
+  end
+
+  it 'converts without bothering with the database' do
+    opts[:lambdas][:basic_conversion].call
+    File.exist?(opts[:output]).should be_true
+    lines = File.readlines(opts[:output])
+    lines.size.should == 80910
+    header_lines = lines.grep(/^H/)
+    (header_lines.size > 10).should be_true
+    header_hash_match(header_lines, SpecHelperHeaderHash).should be_true
+    other_lines = lines.grep(/^[^H]/)
+
+    sqt_line_match(other_lines[0,4], SpecHelperOtherLines.strip.split("\n"))
+    sqt_line_match(other_lines[-3,3], SpecHelperOtherLinesEnd.strip.split("\n"))
+
+    File.unlink(opts[:output]) rescue false
+  end
+
+  it 'can get db info with correct path' do
+    opts[:lambdas][:with_new_db_path].call
+    File.exist?(opts[:output]).should be_true
+    lines = IO.readlines(opts[:output])
+    has_md5 = lines.any? do |line|
+      line =~ /DBMD5Sum\s+202b1d95e91f2da30191174a7f13a04e/
+    end
+    has_md5.should be_true
+
+    has_seq_len = lines.any? do |line|
+      # frozen
+      line =~ /DBSeqLength\s+1342842/
+    end
+    has_seq_len.should be_true
+    lines.size.should == 80912
+    File.unlink(opts[:output]) rescue false
+  end
+
+  it 'can update the Database' do
+    opts[:lambdas][:update_the_db_path].call
+    regexp = Regexp.new("Database\t/.*/opd1_2runs_2mods/sequest33/ecoli_K12_ncbi_20060321.fasta")
+    updated_db = IO.readlines(opts[:output]).any? do |line|
+      line =~ regexp
+    end
+    updated_db.should be_true
+    File.unlink(opts[:output]) rescue false
+  end
+
+end
+
+describe "programmatic interface srf to sqt" do
+
+  srf = Mspire::Sequest::Srf.new(SPEC::Srf_file)
+
+  shared_hash = {
+    :lambdas => { 
+    basic_conversion: lambda { srf.to_sqt(SPEC::Srf_output) },
+    with_new_db_path: lambda { srf.to_sqt(SPEC::Srf_output, :db_info => true, :new_db_path => MS::TESTDATA + '/sequest/opd1_2runs_2mods/sequest33') },
+    update_the_db_path: lambda { srf.to_sqt(SPEC::Srf_output, :new_db_path => MS::TESTDATA + '/sequest/opd1_2runs_2mods/sequest33', :update_db_path => true) },
+  },
+  output: SPEC::Srf_output,
+  mkdir: SPEC::TMPDIR,
+  original_db_filename: "C:\\Xcalibur\\database\\ecoli_K12_ncbi_20060321.fasta"
+  }
+
+  it_behaves_like "an srf to sqt converter", shared_hash
+
+  before(:each) do
+    FileUtils.mkdir(SPEC::TMPDIR) unless File.exist?(SPEC::TMPDIR)
+  end
+  after(:each) do
+    FileUtils.rm_rf(SPEC::TMPDIR)
+  end
+
+  # this requires programmatic interface to manipulate the object for this
+  # test
+  it 'warns if the db path is incorrect and we want to update db info' do
+    output = shared_hash[:output]
+    # requires some knowledge of how the database file is extracted
+    # internally
+    wacky_path = '/not/a/real/path/wacky.fasta'
+
+    srf.header.db_filename = wacky_path
+    my_error_string = ''
+    StringIO.open(my_error_string, 'w') do |strio|
+      $stderr = strio
+      srf.to_sqt(output, :db_info => true)
+    end
+    my_error_string.include?(wacky_path).should be_true
+    srf.header.db_filename = shared_hash[:original_db_filename]
+    $stderr = STDERR
+    File.exists?(output).should be_true
+    IO.readlines(output).size.should == 80910
+    File.delete(output) rescue false
+  end
+end
+
+describe "command-line interface srf to sqt" do
+  before(:each) do
+    FileUtils.mkdir(SPEC::TMPDIR) unless File.exist?(SPEC::TMPDIR)
+  end
+  after(:each) do
+    FileUtils.rm_rf(SPEC::TMPDIR)
+  end
+
+  def self.commandline_lambda(string)
+    lambda { Mspire::Sequest::Srf::Sqt.commandline( string.split(/\s+/) ) }
+  end
+
+  base_cmd = "#{SPEC::Srf_file} -o #{SPEC::Srf_output}"
+  shared_hash = {
+    lambdas: {
+    basic_conversion: self.commandline_lambda(base_cmd),
+    with_new_db_path: self.commandline_lambda(base_cmd + " --db-info --db-path #{MS::TESTDATA + '/sequest/opd1_2runs_2mods/sequest33'}"),
+    update_the_db_path: self.commandline_lambda(base_cmd + " --db-path #{MS::TESTDATA + '/sequest/opd1_2runs_2mods/sequest33'} --db-update" ),
+  },
+  output: SPEC::Srf_output,
+  mkdir: SPEC::TMPDIR,
+  }
+
+  it_behaves_like "an srf to sqt converter", shared_hash
+end

data/spec/mspire/sequest/srf_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'mspire/sequest/srf_spec_helper' # in spec/
+
+require 'mspire/sequest/srf'
+
+require 'fileutils'
+
+include SRFHelper
+
+class Hash
+  def object_match(obj)
+    self.all? do |k,v|
+      k = k.to_sym
+      retval = 
+        if k == :peaks or k == :hits or k == :proteins
+          obj.send(k).size == v
+        elsif v.class == Float
+          delta = 
+            if k == :ppm ; 0.0001          
+            else ; 0.0000001          
+            end
+          (v - obj.send(k)).abs <= delta
+        else
+          obj.send(k) == v
+        end
+      if retval == false
+        puts "BAD KEY: #{k}"
+        puts "need: #{v}"
+        puts "got: #{obj.send(k)}"
+      end
+      retval
+    end
+  end
+end
+
+shared_examples_for 'an srf reader' do |srf_obj, test_hash|
+
+  it 'retrieves correct header info' do
+    test_hash[:header].object_match(srf_obj.header).should be_true
+    test_hash[:dta_gen].object_match(srf_obj.header.dta_gen).should be_true
+  end
+
+  # a few more dta params could be added in here:
+  it 'retrieves correct dta files' do
+    test_hash[:dta_files_first].object_match(srf_obj.dta_files.first).should be_true
+    test_hash[:dta_files_last].object_match(srf_obj.dta_files.last).should be_true
+  end
+
+  # given an array of out_file objects, returns the first set of hits
+  def get_first_peps(out_files)
+    out_files.each do |outf|
+      if outf.num_hits > 0
+        return outf.hits
+      end
+    end
+    return nil
+  end
+
+  it 'retrieves correct out files' do
+    test_hash[:out_files_first].object_match(srf_obj.out_files.first).should be_true
+    test_hash[:out_files_last].object_match(srf_obj.out_files.last).should be_true
+    # first available peptide hit
+    test_hash[:out_files_first_pep].object_match(get_first_peps(srf_obj.out_files).first).should be_true
+    # last available peptide hit
+    test_hash[:out_files_last_pep].object_match(get_first_peps(srf_obj.out_files.reverse).last).should be_true
+  end
+
+  it 'retrieves correct params' do
+    test_hash[:params].object_match(srf_obj.params).should be_true
+  end
+
+  # TODO:
+  #it_should 'retrieve probabilities if available'
+end
+
+# TODO:, we should try to get some tests with sf values present!
+
+
+Expected_hash_keys = %w(header dta_gen dta_files_first dta_files_last out_files_first out_files_last out_files_first_pep out_files_last_pep params)
+
+To_run = {
+  '3.2' => {:hash => File_32, :file => '/opd1_2runs_2mods/sequest32/020.srf'},
+  '3.3' => {:hash => File_33, :file => '/opd1_2runs_2mods/sequest33/020.srf'},
+  '3.3.1' => {:hash => File_331, :file => '/opd1_2runs_2mods/sequest331/020.srf'},
+}
+
+# I had these nicely combined under RSpec, but this is not as obvious a task
+# under minispec given the corrupted include behavior...
+
+describe 'reading srf with duplicate refs v3.2' do
+
+  info = To_run['3.2']
+  file = MS::TESTDATA + '/sequest' + info[:file]
+  srf_obj = Mspire::Sequest::Srf.new(file)
+
+  it_behaves_like 'an srf reader', srf_obj, info[:hash]
+end
+
+describe 'reading srf with duplicate refs v3.3' do
+  info = To_run['3.3']
+  file = MS::TESTDATA + '/sequest' + info[:file]
+  srf_obj = Mspire::Sequest::Srf.new(file)
+
+  it_behaves_like 'an srf reader', srf_obj, info[:hash]
+end
+
+describe 'reading srf with duplicate refs v3.3.1' do
+  info = To_run['3.3.1']
+  file = MS::TESTDATA + '/sequest' + info[:file]
+  srf_obj = Mspire::Sequest::Srf.new(file)
+
+  it_behaves_like 'an srf reader', srf_obj, info[:hash]
+end