mspire 0.2.4 → 0.3.0

data/specs/validator/bias_spec.rb

@@ -0,0 +1,146 @@
+require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
+require File.expand_path( File.dirname(__FILE__) + '/../validator_helper' )
+
+require 'validator/bias'
+
+require File.dirname(__FILE__) + '/fasta_helper'
+require 'spec_id'
+
+klass = Validator::Bias
+
+describe klass, "on small mock set" do
+  before(:each) do
+    @peps =  (0..6).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
+    references = %w(YAL002W  YAL001C YAL003W YAL004W YAL007C NOT_EXISTING1 NOT_EXISTING2 NOT_EXISTING3 NOT_EXISTING4)
+    # index:        0        1       2       3       4       5             6             7
+    # index: 8       
+    @prots = references.map do |ref|
+      v = SpecID::GenericProt.new
+      v.reference = ref + " something else that we don't care about"
+      v
+    end
+
+    # e=t  we expect to see the fasta proteins in our hit list
+    # cw=t a single peptide hit from one of these proteins constitutes a true
+    # positive
+    # cw=f all peptide hits must come from one of these proteins to be a true
+    # positive
+    #
+    # e=f  we do not expect to see the fasta obj proteins in our hit list
+    # cw=t a single peptide hit from *outside* this list constitues a true
+    # positive
+    # cw=f a single peptide hit from our fasta object constitutes a false
+    # positive
+    #
+
+    @peps[0].prots = [@prots[0], @prots[5], @prots[8]]  
+    @peps[1].prots = [@prots[1], @prots[5], @prots[8]]  
+    @peps[2].prots = [@prots[3], @prots[4], @prots[1]]  
+    @peps[3].prots = [@prots[7], @prots[8]]             
+    @peps[4].prots = [@prots[5], @prots[8]]             
+    @peps[5].prots = [@prots[8]]                        
+    @peps[6].prots = [@prots[5], @prots[6]]             
+
+    #################################################
+    # REFERENCE for small mock set:
+    #################################################
+    # pep 1inFst? allinFst? cw=t,e=t cw=t,e=f cw=f,e=f cw=f,e=t
+    # 0   y       n         t        t        f        f
+    # 1   y       n         t        t        f        f
+    # 2   y       y         t        f        f        t
+    # 3   n       n         f        t        t        f
+    # 4   n       n         f        t        t        f
+    # 5   n       n         f        t        t        f
+    # 6   n       n         f        t        t        f
+    # PR:                   3/7      6/7      4/7      1/7
+    # tp:fp                 3:4      6:1      4:3      1:6
+
+    @fasta_obj = FastaHelper::FastaObj
+    @validator = klass.new(@fasta_obj)
+  end
+
+  it_should_behave_like 'a validator'
+
+  it 'creates correct reference hash' do
+    expected = {"YAL001C"=>true, "YAL011W"=>true, "YAL010C"=>true,
+    "YAL009W"=>true, "YAL008W"=>true, "YAL007C"=>true, "YAL005C"=>true,
+    "YAL004W"=>true, "YAL003W"=>true, "YAL014C"=>true, "YAL013W"=>true,
+    "YAL002W"=>true, "YAL012W"=>true
+    }
+    val = klass.new(@fasta_obj)
+    val.short_reference_hash.should == expected
+  end
+
+  it 'gives correct precision and partitions (across all option combinations)' do
+    answ = [[3,4], [6,1], [1,6], [4,3]]
+    # cw=t,e=t; cw=t,e=f; cw=f,e=t; cw=f,e=f
+    [true, false].each do |correct_wins|
+      [true, false].each do |fasta_expected|
+        val = klass.new(@fasta_obj, :proteins_expected => fasta_expected, :correct_wins => correct_wins)
+        tp, fp = answ.shift
+        exp = calc_precision(tp, fp)
+        val.pephit_precision(@peps).should == exp
+        act_tp, act_fp = val.partition(@peps)
+        act_tp.size.should == tp
+        act_fp.size.should == fp
+      end
+    end
+  end
+
+  it 'correctly incorporates background' do
+    answ = [[3,4], [6,1], [1,6], [4,3]]
+    # cw=t,e=t; cw=t,e=f; cw=f,e=t; cw=f,e=f
+    background = 0.24
+    [true, false].each do |correct_wins|
+      [true, false].each do |fasta_expected|
+        val = klass.new(@fasta_obj, :proteins_expected => fasta_expected, :correct_wins => correct_wins, :background => background)
+        peps_size = @peps.size
+        exp_tp, exp_fp = answ.shift
+        exp = calc_precision(exp_tp, exp_fp)
+        val.pephit_precision(@peps).should_not == exp
+        actual_precision = val.pephit_precision(@peps)
+        act_tp, act_fp = val.partition(@peps)
+        act_tp.size.should == exp_tp
+        act_fp.size.should == exp_fp
+        exp_fp_correctd = exp_fp.to_f - (peps_size.to_f * background)
+        expected_precision = calc_precision(peps_size.to_f - exp_fp_correctd, exp_fp_correctd)
+        # internally, the num of false hits is controlled so as not to bottom
+        # out below zero, here we control the precision (same effect)
+        expected_precision = 1.0 if expected_precision > 1.0
+        actual_precision.should == expected_precision
+      end
+    end
+  end
+
+  it 'correctly incorporates background' do
+    answ = [[3,4], [6,1], [1,6], [4,3]]
+    # cw=t,e=t; cw=t,e=f; cw=f,e=t; cw=f,e=f
+    background = 0.24
+    [true, false].each do |correct_wins|
+      [true, false].each do |fasta_expected|
+        val = klass.new(@fasta_obj, :proteins_expected => fasta_expected, :correct_wins => correct_wins, :background => background)
+        peps_size = @peps.size
+        exp_tp, exp_fp = answ.shift
+        exp = calc_precision(exp_tp, exp_fp)
+        val.pephit_precision(@peps).should_not == exp
+        actual_precision = val.pephit_precision(@peps)
+        act_tp, act_fp = val.partition(@peps)
+        act_tp.size.should == exp_tp
+        act_fp.size.should == exp_fp
+        exp_fp_correctd = exp_fp.to_f - (peps_size.to_f * background)
+        expected_precision = calc_precision(peps_size.to_f - exp_fp_correctd, exp_fp_correctd)
+        # internally, the num of false hits is controlled so as not to bottom
+        # out below zero, here we control the precision (same effect)
+        expected_precision = 1.0 if expected_precision > 1.0
+        actual_precision.should == expected_precision
+      end
+    end
+  end
+
+  it_should 'work with false_to_total_ratio!'
+
+  def calc_precision(tp, fp)
+    prec = tp.to_f / (tp + fp)
+  end
+end
+

data/specs/validator/decoy_spec.rb

@@ -0,0 +1,51 @@
+
+require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
+require File.expand_path( File.dirname(__FILE__) + '/../validator_helper' )
+
+require 'validator/decoy'
+require 'spec_id'
+
+klass = Validator::Decoy
+
+describe klass, 'reporting precision on peptides from cat prots' do
+
+  before(:each) do
+    peps =  (0..5).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
+    prots = %w(gi|1245235|ProteinX gi|987654|ProteinY gi|1111111|ProteinZ FALSE_someOthergi FALSE_AnotherGi FALSE_YetAnotherReference).map do |ref|
+      v = SpecID::GenericProt.new
+      v.reference = ref
+      v
+    end
+    peps[0].prots = [prots[0], prots[5]]  # TP (only in tp wins)
+    peps[1].prots = [prots[1], prots[2]]  # TP always
+    peps[2].prots = [prots[3], prots[4]]  # FP 
+    peps[3].prots = [prots[2]]            # TP
+    peps[4].prots = [prots[5]]            # FP
+    peps[5].prots = [prots[4]]            # FP
+    @peps = peps
+    @validator = klass.new(/FAKE/)
+  end
+
+  it_should_behave_like 'a validator'
+
+  it 'gives correct precision (across all option combinations)' do 
+    answ_arr = [
+      [[@peps[0], @peps[1], @peps[3]], [@peps[2], @peps[4], @peps[5]]],
+      [[@peps[1], @peps[3]], [@peps[0], @peps[2], @peps[4], @peps[5]]],
+      [[@peps[0], @peps[1], @peps[3]], [@peps[2], @peps[4], @peps[5]]],
+      [[@peps[1], @peps[3]], [@peps[0], @peps[2], @peps[4], @peps[5]]]
+    ]
+    protein_matches = [/^FALSE_/, /^FALSE_/, 'Protein', 'Protein']
+
+    [true, false].each do |incorrect_on_match|
+      [true, false].each do |correct_wins|
+        val = klass.new(protein_matches.shift, incorrect_on_match, correct_wins)
+        answ = val.pephit_precision(@peps)
+        exp = ValidatorHelper::Decoy.precision_from_partition_array(answ_arr.shift)
+        answ.should == exp
+      end
+    end
+  end
+
+end
+

data/specs/validator/fasta_helper.rb

@@ -0,0 +1,26 @@
+
+
+module FastaHelper 
+  FastaObj = Fasta.new
+  data = {
+    '>YAL011W otherstuff' => 'MPAVLRTRSKESSIEQKPASRTRTRSRRGKRGRDDDDDDDDEESDDAYDEVGNDYDEYASRAKLATNRPFEIVAGLPASVELPNYNSSLTHPQSIKNSGVLYDSLVSSRRTWVQGEMFELYWRRPKKIVSESTPAATESPTSGTIPLIRDKMQKMCDCVMSGGPHTFKVRLFILKNDKIEQKWQDEQELKKKEKELKRKNDAEAKRLRMEERKRQQMQKKIAKEQKLQLQKENKAKQKLEQEALKLKRKEEMKKLKEQNKNKQGSPSSSMHDPRMIMNLNLMAQEDPKLNTLMETVAKGLANNSQLEEFKKFIEIAKKRSLEENPVNKRPSVTTTRPAPPSKAKDVAEDHRLNSITLVKSSKTAATEPEPKKADDENAEKQQSKEAKTTAESTQVDVKKEEEDVKEKGVKSEDTQKKEDNQVVPKRKRRKNAIKEDKDMQLTAFQQKYVQGAEIILEYLEFTHSRYYLPKKSVVEFLEDTDEIIISWIVIHNSKEIEKFKTKKIKAKLKADQKLNKEDAKPGSDVEKEVSFNPLFEADCPTPLYTPMTMKLSGIHKRFNQIIRNSVSPMEEVVKEMEKILQIGTRLSGYNLWYQLDGYDDEALSESLRFELNEWEHAMRSRRHKR',
+'>YAL001C otherstuff' => 'MVLTIYPDELVQIVSDKIASNKGKITLNQLWDISGKYFDLSDKKVKQFVLSCVILKKDIEVYCDGAITTKNVTDIIGDANHSYSVGITEDSLWTLLTGYTKKESTIGNSAFELLLEVAKSGEKGINTMDLAQVTGQDPRSVTGRIKKINHLLTSSQLIYKGHVVKQLKLKKFSHDGVDSNPYINIRDHLATIVEVVKRSKNGIRQIIDLKRELKFDKEKRLSKAFIAAIAWLDEKEYLKKVLVVSPKNPAIKIRCVKYVKDIPDSKGSPSFEYDSNSADEDSVSDSKAAFEDEDLVEGLDNFNATDLLQNQGLVMEEKEDAVKNEVLLNRFYPLQNQTYDIADKSGLKGISTMDVVNRITGKEFQRAFTKSSEYYLESVDKQKENTGGYRLFRIYDFEGKKKFFRLFTAQNFQKLTNAEDEISVPKGFDELGKSRTDLKTLNEDNFVALNNTVRFTTDSDGQDIFFWHGELKIPPNSKKTPNKNKRKRQVKNSTNASVAGNISNPKRIKLEQHVSTAQEPKSAEDSPSSNGGTVVKGKVVNFGGFSARSLRSLQRQRAILKVMNTIGGVAYLREQFYESVSKYMGSTTTLDKKTVRGDVDLMVESEKLGARTEPVSGRKIIFLPTVGEDAIQRYILKEKDSKKATFTDVIHDTEIYFFDQTEKNRFHRGKKSVERIRKFQNRQKNAKIKASDDAISKKSTSVNVSDGKIKRRDKKVSAGRTTVVVENTKEDKTVYHAGTKDGVQALIRAVVVTKSIKNEIMWDKITKLFPNNSLDNLKKKWTARRVRMGHSGWRAYVDKWKKMLVLAIKSEKISLRDVEELDLIKLLDIWTSFDEKEIKRPLFLYKNYEENRKKFTLVRDDTLTHSGNDLAMSSMIQREISSLKKTYTRKISASTKDLSKSQSDDYIRTVIRSILIESPSTTRNEIEALKNVGNESIDNVIMDMAKEKQIYLHGSKLECTDTLPDILENRGNYKDFGVAFQYRCKVNELLEAGNAIVINQEPSDISSWVLIDLISGELLNMDVIPMVRNVRPLTYTSRRFEIRTLTPPLIIYANSQTKLNTARKSAVKVPLGKPFSRLWVNGSGSIRPNIWKQVVTMVVNEIIFHPGITLSRLQSRCREVLSLHEISEICKWLLERQVLITTDFDGYWVNHNWYSIYEST',
+'>YAL010C otherstuff' => 'MLPYMDQVLRAFYQSTHWSTQNSYEDITATSRTLLDFRIPSAIHLQISNKSTPNTFNSLDFSTRSRINGSLSYLYSDAQQLEKFMRNSTDIPLQDATETYRQLQPNLNFSVSSANTLSSDNTTVDNDKKLLHDSKFVKKSLYYGRMYYPSSDLEAMIIKRLSPQTQFMLKGVSSFKESLNVLTCYFQRDSHRNLQEWIFSTSDLLCGYRVLHNFLTTPSKFNTSLYNNSSLSLGAEFWLGLVSLSPGCSTTLRYYTHSTNTGRPLTLTLSWQPLFGHISSTYSAKTGTNSTFCAKYDFNLYSIESNLSFGCEFWQKKHHLLETNKNNNDKLEPISDELVDINPNSRATKLLHENVPDLNSAVNDIPSTLDIPVHKQKLLNDLTYAFSSSLRKIDEERSTIEKFDNKINSSIFTSVWKLSTSLRDKTLKLLWEGKWRGFLISAGTELVFTRGFQESLSDDEKNDNAISISATDTENGNIPVFPAKFGIQFQYST',
+'>YAL009W otherstuff' => 'MEPESIGDVGNHAQDDSASIVSGPRRRSTSKTSSAKNIRNSSNISPASMIFRNLLILEDDLRRQAHEQKILKWQFTLFLASMAGVGAFTFYELYFTSDYVKGLHRVILQFTLSFISITVVLFHISGQYRRTIVIPRRFFTSTNKGIRQFNVKLVKVQSTWDEKYTDSVRFVSRTIAYCNIYCLKKFLWLKDDNAIVKFWKSVTIQSQPRIGAVDVKLVLNPRAFSAEIREGWEIYRDEFWAREGARRRKQAHELRPKSE',
+'>YAL008W otherstuff' => 'MTLAFNMQRLVFRNLNVGKRMFKNVPLWRFNVANKLGKPLTRSVGLGGAGIVAGGFYLMNRQPSKLIFNDSLGAAVKQQGPLEPTVGNSTAITEERRNKISSHKQMFLGSLFGVVLGVTVAKISILFMYVGITSMLLCEWLRYKGWIRINLKNIKSVIVLKDVDLKKLLIDGLLGTEYMGFKVFFTLSFVLASLNANK',
+'>YAL007C otherstuff' => 'MIKSTIALPSFFIVLILALVNSVAASSSYAPVAISLPAFSKECLYYDMVTEDDSLAVGYQVLTGGNFEIDFDITAPDGSVITSEKQKKYSDFLLKSFGVGKYTFCFSNNYGTALKKVEITLEKEKTLTDEHEADVNNDDIIANNAVEEIDRNLNKITKTLNYLRAREWRNMSTVNSTESRLTWLSILIIIIIAVISIAQVLLIQFLFTGRQKNYV',
+'>YAL005C otherstuff' => 'MSKAVGIDLGTTYSCVAHFANDRVDIIANDQGNRTTPSFVAFTDTERLIGDAAKNQAAMNPSNTVFDAKRLIGRNFNDPEVQADMKHFPFKLIDVDGKPQIQVEFKGETKNFTPEQISSMVLGKMKETAESYLGAKVNDAVVTVPAYFNDSQRQATKDAGTIAGLNVLRIINEPTAAAIAYGLDKKGKEEHVLIFDLGGGTFDVSLLFIEDGIFEVKATAGDTHLGGEDFDNRLVNHFIQEFKRKNKKDLSTNQRALRRLRTACERAKRTLSSSAQTSVEIDSLFEGIDFYTSITRARFEELCADLFRSTLDPVEKVLRDAKLDKSQVDEIVLVGGSTRIPKVQKLVTDYFNGKEPNRSINPDEAVAYGAAVQAAILTGDESSKTQDLLLLDVAPLSLGIETAGGVMTKLIPRNSTISTKKFEIFSTYADNQPGVLIQVFEGERAKTKDNNLLGKFELSGIPPAPRGVPQIEVTFDVDSNGILNVSAVEKGTGKSNKITITNDKGRLSKEDIEKMVAEAEKFKEEDEKESQRIASKNQLESIAYSLKNTISEAGDKLEQADKDTVTKKAEETISWLDSNTTASKEEFDDKLKELQDIANPIMSKLYQAGGAPGGAAGGAPGGFPGGAPPAPEAEGPTVEEVD',
+'>YAL004W otherstuff' => 'MGVTSGGLNFKDTVFNEQQRDIESTTTQVENQDVFFLTLLVQTVSNGSGGRFVNNTQDIQTSNGTSILGSLSLRIVEVSWDSDDSVIDLGSQVRFGSFLHLTQDHGGDLFWGKVLGFTLKFNLNLRLTVNIDQLEWEVLHVSLHFWVVEVSTDQTLSVENGIRRIHSSLILSSITNQSFSVSESDKRWSGSVTLIVGNNVHTIISKVSNTRVCCT',
+'>YAL003W otherstuff' => 'MASTDFSKIETLKQLNASLADKSYIEGTAVSQADVTVFKAFQSAYPEFSRWFNHIASKADEFDSFPAASAAAAEEEEDDDVDLFGSDDEEADAEAEKLKAERIAAYNAKKAAKPAKPAAKSIVTLDVKPWDDETNLEEMVANVKAIEMEGLTWGAHQFIPIGFGIKKLQINCVVEDDKVSLDDLQQSIEEDEDHVQSTDIAAMQKL',
+'>YAL014C otherstuff' => 'MDVLKLGYELDQLSDLVEERTRLVSVLKLAPTSNDNVTLKRQLGSILELLQKCAPNDELISRYNTILDKIPDTAVDKELYRFQQQVARNTDEVSKESLKKVRFKNDDELTVMYKDDDEQDEESPLPSTHTPYKDEPLQSQLQSQSQPQPPQPMVSNQELFINQQQQLLEQDSHLGALSQSIGRTHDISLDLNNEIVSQNDSLLVDLENLIDNNGRNLNRASRSMHGFNNSRFKDNGNCVIILVLIVVLLLLLLVL',
+'>YAL013W otherstuff' => 'MSQQTPQESEQTTAKEQDLDQESVLSNIDFNTDLNHNLNLSEYCISSDAGTEKMDSDEEKSLANLPELKYAPKLSSLVKQETLTESLKRPHEDEKEAIDEAKKMKVPGENEDESKEEEKSQELEEAIDSKEKSTDARDEQGDEGDNEEENNEEDNENENEHTAPPALVMPSPIEMEEQRMTALKEITDIEYKFAQLRQKLYDNQLVRLQTELQMCLEGSHPELQVYYSKIAAIRDYKLHRAYQRQKYELSCINTETIATRTFIHQDFHKKVTDLRARLLNRTTQTWYDINKERRDMDIVIPDVNYHVPIKLDNKTLSCITGYASAAQLCYPGEPVAEDLACESIEYRYRANPVDKLEVIVDRMRLNNEISDLEGLRKYFHSFPGAPELNPLRDSEINDDFHQWAQCDRHTGPHTTSFCYS',
+'>YAL002W otherstuff' => 'MEQNGLDHDSRSSIDTTINDTQKTFLEFRSYTQLSEKLASSSSYTAPPLNEDGPKGVASAVSQGSESVVSWTTLTHVYSILGAYGGPTCLYPTATYFLMGTSKGCVLIFNYNEHLQTILVPTLSEDPSIHSIRSPVKSIVICSDGTHVAASYETGNICIWNLNVGYRVKPTSEPTNGMTPTPALPAVLHIDDHVNKEITGLDFFGARHTALIVSDRTGKVSLYNGYRRGFWQLVYNSKKILDVNSSKEKLIRSKLSPLISREKISTNLLSVLTTTHFALILLSPHVSLMFQETVEPSVQNSLVVNSSISWTQNCSRVAYSVNNKISVISISSSDFNVQSASHSPEFAESILSIQWIDQLLLGVLTISHQFLVLHPQHDFKILLRLDFLIHDLMIPPNKYFVISRRSFYLLTNYSFKIGKFVSWSDITLRHILKGDYLGALEFIESLLQPYCPLANLLKLDNNTEERTKQLMEPFYNLSLAALRFLIKKDNADYNRVYQLLMVVVRVLQQSSKKLDSIPSLDVFLEQGLEFFELKDNAVYFEVVANIVAQGSVTSISPVLFRSIIDYYAKEENLKVIEDLIIMLNPTTLDVDLAVKLCQKYNLFDLLIYIWNKIFDDYQTPVVDLIYRISNQSEKCVIFNGPQVPPETTIFDYVTYILTGRQYPQNLSISPSDKCSKIQRELSAFIFSGFSIKWPSNSNHKLYICENPEEEPAFPYFHLLLKSNPSRFLAMLNEVFEASLFNDDNDMVASVGEAELVSRQYVIDLLLDAMKDTGNSDNIRVLVAIFIATSISKYPQFIKVSNQALDCVVNTICSSRVQGIYEISQIALESLLPYYHSRTTENFILELKEKNFNKVLFHIYKSENKYASALSLILETKDIEKEYNTDIVSITDYILKKCPPGSLECGKVTEVIETNFDLLLSRIGIEKCVTIFSDFDYNLHQEILEVKNEETQQKYLDKLFSTPNINNKVDKRLRNLHIELNCKYKSKREMILWLNGTVLSNAESLQILDLLNQDSNFEAAAIIHERLESFNLAVRDLLSFIEQCLNEGKTNISTLLESLRRAFDDCNSAGTEKKSCWILLITFLITLYGKYPSHDERKDLCNKLLQEAFLGLVRSKSSSQKDSGGEFWEIMSSVLEHQDVILMKVQDLKQLLLNVFNTYKLERSLSELIQKIIEDSSQDLVQQYRKFLSEGWSIHTDDCEICGKKIWGAGLDPLLFLAWENVQRHQDMISVDLKTPLVIFKCHHGFHQTCLENLAQKPDEYSCLICQTESNPKIV',
+'>YAL012W otherstuff' => 'MTLQESDKFATKAIHAGEHVDVHGSVIEPISLSTTFKQSSPANPIGTYEYSRSQNPNRENLERAVAALENAQYGLAFSSGSATTATILQSLPQGSHAVSIGDVYGGTHRYFTKVANAHGVETSFTNDLLNDLPQLIKENTKLVWIETPTNPTLKVTDIQKVADLIKKHAAGQDVILVVDNTFLSPYISNPLNFGADIVVHSATKYINGHSDVVLGVLATNNKPLYERLQFLQNAIGAIPSPFDAWLTHRGLKTLHLRVRQAALSANKIAEFLAADKENVVAVNYPGLKTHPNYDVVLKQHRDALGGGMISFRIKGGAEAASKFASSTRLFTLAESLGGIESLLEVPAVMTHGGIPKEAREASGVFDDLVRISVGIEDTDDLLEDIKQALKQATN',
+  }
+  data.map do |header,aaseq|
+    FastaObj << Fasta::Prot.new(header, aaseq)
+  end
+
+end
+
+

data/specs/validator/prot_from_pep_spec.rb

@@ -0,0 +1,141 @@
+
+
+
+require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
+
+require 'validator/prot_from_pep'
+
+klass = Validator::ProtFromPep
+
+describe klass, "on fake, simple prots and peps" do
+  before(:each) do
+    # create some proteins and peptides linked up
+    prots = ('a'..'g').to_a.inject( { } ) do |hash,let|
+      prot = OpenStruct.new
+      prot.peps = []
+      hash[let.to_sym] = prot
+      hash
+    end
+    # prots: a.peps = 0,1,4
+    #        b.peps = 1
+    #        c.peps = 2
+    #        d.peps = 2,5,6
+    #        e.peps = 2
+    #        f.peps = 3,4
+    #        g.peps = 3,4,8,9,10
+
+    #        0    1         2            3        4          5     6     7   
+    peps = [[:a], [:a,:b], [:c,:d,:e], [:f,:g], [:a,:f,:g], [:c], [:c], [:d], 
+      # 8    9     10
+      [:g], [:g], [:g]].map do |belongs_to|
+      pep = OpenStruct.new 
+      pep.prots = belongs_to.map {|v| prots[v].peps << pep ; prots[v]}
+      pep
+    end
+    @peps = peps
+    @prots = prots
+
+    @normal_frozen = [[0.971428571428572, 0.0586273344048647], [0.95, 0.0838775640874857], [0.907142857142857, 0.116103957269609], [0.878571428571428, 0.133328857783819], [0.814285714285714, 0.147299354691691], [0.735714285714286, 0.186982368192933], [0.65, 0.18812775328873], [0.535714285714286, 0.206630166671598], [0.414285714285714, 0.178909454503803], [0.228571428571429, 0.117254668809732]]
+    @worstcase_frozen = [0.857142857142857, 0.714285714285714, 0.571428571428571, 0.571428571428571, 0.428571428571429, 0.285714285714286, 0.285714285714286, 0.142857142857143, 0.142857142857143, 0.142857142857143]
+  end
+
+  it 'calculates normal precision edge cases' do
+    val = klass.new
+    all_wrong = @peps.size
+    val.normal_prothit_precision( @peps, all_wrong, :num_its => 10 ).should == [0.0,0.0]
+    val.normal_prothit_precision( @peps, all_wrong, :num_its => 1).should == 0.0
+
+    val.normal_prothit_precision( @peps, all_wrong+10, :num_its => 10).should == [0.0,0.0]
+    val.normal_prothit_precision( @peps, all_wrong+10, :num_its => 1).should == 0.0
+
+    all_right = 0
+    val.normal_prothit_precision( @peps, all_right, :num_its => 10).should == [1.0,0.0]
+    val.normal_prothit_precision( @peps, all_right, :num_its => 1).should == 1.0
+  end
+
+  it 'calculates normal precision that behaves properly' do
+    val = klass.new
+    prev_mean = 1.0
+    (1...(@peps.size)).to_a.zip( @normal_frozen ) do |num_false, expected|
+      (mean, stdev) = val.normal_prothit_precision( @peps, num_false, :num_its => 20)
+      (mean < prev_mean).should be_true
+      (stdev < 0.4 and stdev > 0.0001).should be_true
+      mean.should be_close(expected[0], 0.000000001)
+      stdev.should be_close(expected[1], 0.000000001)
+      val.normal_prothit_precision( @peps, num_false, :num_its => 1).should be_close(mean, 0.25)
+    end
+  end
+
+  it 'calculates worstcase edge cases' do
+    val = klass.new
+    all_wrong = @peps.size
+    val.worstcase_prothit_precision( @peps, all_wrong, :num_its => 10 ).should == 0.0
+    val.worstcase_prothit_precision( @peps, all_wrong, :num_its => 1).should == 0.0
+
+    val.worstcase_prothit_precision( @peps, all_wrong+10, :num_its => 10).should == 0.0
+    val.worstcase_prothit_precision( @peps, all_wrong+10, :num_its => 1).should == 0.0
+
+    all_right = 0
+    val.worstcase_prothit_precision( @peps, all_right, :num_its => 10).should == 1.0
+    val.worstcase_prothit_precision( @peps, all_right, :num_its => 1).should == 1.0
+  end
+
+  it 'calculates worstcase precision that behaves properly' do
+
+    val = klass.new
+    prev_worst = 1.0
+    worsts = []
+    (1...(@peps.size)).to_a.zip( @worstcase_frozen ) do |num_false, expected|
+      worst = val.worstcase_prothit_precision( @peps, num_false, :num_its => 20)
+      (worst <= prev_worst).should be_true
+      worst.should be_close(expected, 0.0000000001)
+    end
+
+  end
+
+  it 'calculates prothit precision (worstcase + normal)' do
+    val = klass.new
+    (1...(@peps.size)).to_a.zip( @normal_frozen, @worstcase_frozen ) do |num_false, normal_expected, worstcase_expected|
+      (worst, norm_mean, norm_stdev) = val.prothit_precision( @peps, num_false, :num_its_normal => 20, :num_its_worstcase => 10)
+      worst.should be_close(worstcase_expected, 0.0000000001)
+      norm_mean.should be_close(normal_expected[0], 0.0000000001)
+      norm_stdev.should be_close(normal_expected[1], 0.0000000001)
+    end
+  end
+
+  it 'gives 1.0 precision for no pephits' do
+    val = klass.new
+    val.prothit_precision( [], 0).should == [1.0, 1.0, 0.0]
+  end
+
+end
+
+describe klass, "calculating worstcase prothit precision by numbers" do
+  it "calculates precision correctly in easy cases" do
+    peps_per_prot = [4,4,3,2,2]
+    # no prots completely wrong
+    precision = klass.new.worstcase_prothit_precision_by_numbers(peps_per_prot, 1)
+    precision.should == 1
+
+    # only one protein partially correct
+    precision = klass.new.worstcase_prothit_precision_by_numbers(peps_per_prot, 14)
+    precision.should == 0.2
+  end
+
+  it 'works correctly on other cases' do
+    #      0    1      2      3      4      5      6      7      8     
+    expected = [1.0, 5.0/6, 5.0/6, 4.0/6, 4.0/6, 3.0/6, 3.0/6, 3.0/6, 2.0/6, 
+    #      9      10     11     12     13     14     15     16     17
+           2.0/6, 2.0/6, 2.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 1.0/6, 0.0]
+    num_peps_per_prot = [5,4,3,2,2,1].sort_by { rand }
+    total_peps = num_peps_per_prot.inject(0) {|memo,obj| obj + memo }
+    val = klass.new
+    (0..total_peps).to_a.zip(expected) do |num_wrong, exp|
+      val.worstcase_prothit_precision_by_numbers(num_peps_per_prot, num_wrong).should == exp
+    end
+  end
+
+
+end
+
+

data/specs/validator/transmem_spec.rb

@@ -0,0 +1,145 @@
+require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
+require File.expand_path( File.dirname(__FILE__) + '/../validator_helper' )
+
+require 'validator/transmem'
+require 'spec_id/digestor'
+require File.dirname(__FILE__) + '/fasta_helper'
+require 'spec_id'
+
+klass = Validator::Transmem::Protein
+
+describe klass, "on small mock set" do
+  before(:each) do
+    @toppred_file = Tfiles + '/toppred.small.out'
+    @peps =  (0..7).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
+    # certain:      3        0       0       0       2       3       2       1
+    references = %w(YAL002W  YAL001C YAL003W YAL004W YAL007C YAL008W YAL009W YAL010C NOTEXISTING1 NOTEXISTING2)
+    # index:        0        1       2       3       4       5       6       7
+    @prots = references.map do |ref|
+      v = SpecID::GenericProt.new
+      v.reference = ref
+      v
+    end
+
+    # TM (? = both)
+    # @prots[8] doesn't have a key in the guy (nil)
+    # SHOULD NOT change the results
+    @peps[0].prots = [@prots[0], @prots[5], @prots[8]]   # y
+    @peps[1].prots = [@prots[1], @prots[5], @prots[8]]   # ?
+    @peps[2].prots = [@prots[3], @prots[4], @prots[8]]   # ?
+    @peps[3].prots = [@prots[2], @prots[8]]             # n
+    @peps[4].prots = [@prots[5], @prots[8]]             # y
+    @peps[5].prots = [@prots[4], @prots[8]]             # y
+    @peps[6].prots = [@prots[8]]            # nil pep
+    @peps[7].prots = [@prots[8], @prots[9]] # nil pep
+
+    @validator = klass.new(@toppred_file)
+  end
+
+  it_should_behave_like 'a validator'
+
+  it 'gives correct precision with false ratio (across all option combinations)' do
+    answ = [[2,4], [0,6], [0,6], [-2,8]].map {|v| calc_precision(*v) }
+    [true, false].each do |correct_wins|
+      [true, false].each do |soluble_fraction|
+        val = klass.new(@toppred_file, :min_num_tms => 3, :soluble_fraction => soluble_fraction, :correct_wins => correct_wins)
+        val.false_to_total_ratio = 0.5
+        val.pephit_precision(@peps).should == answ.shift
+        #p val.pephit_precision(@peps)
+      end
+    end
+  end
+  
+  it 'calculates a correct false to total ratio' do
+    val = klass.new(@toppred_file)
+    fasta_obj = FastaHelper::FastaObj
+    sequest_params_obj = Sequest::Params.new(Tfiles + '/bioworks32.params')
+    sequest_params_obj.opts['first_database_name'] = 'not_real'
+    val.set_false_to_total_ratio( Digestor.digest(fasta_obj, sequest_params_obj) )
+    ratio = val.false_to_total_ratio
+    num_tps_soluble_peps = 777
+    num_fps_insoluble_peps = 741
+    expected_ratio = num_tps_soluble_peps.to_f / (num_tps_soluble_peps + num_fps_insoluble_peps)
+    ratio.should == expected_ratio
+  end
+
+  it 'can grant transmem status to proteins for speed' do
+    val = klass.new(@toppred_file)
+    fasta_obj = FastaHelper::FastaObj
+    sequest_params_obj = Sequest::Params.new(Tfiles + '/bioworks32.params')
+    hash = val.create_transmem_status_hash( Digestor.digest(fasta_obj.prots, sequest_params_obj))
+    fasta_obj.prots.each do |prot|
+      hash.key?(prot).should be_true
+    end
+    frozen = [true, true, false, true, false, false, true, false, true, false, true, true, true]
+    fasta_obj.prots.map {|prot| hash[prot] }.should == frozen
+  end
+
+  def calc_precision(norm, trans)
+    prec = norm.to_f / (norm + trans)
+  end
+
+  it 'can calculate precision incrementally' do
+    val = klass.new(@toppred_file, :min_num_tms => 2)
+    # usually we'd update the false_to_total_ratio, but not bothering for test
+    # here we HAVE to set the status hash before hand... (we could redo this
+    # section)
+    val.transmem_status_hash = val.create_transmem_status_hash(@peps)
+
+    # manually done:
+    precisions = [0.0, 1.0/2, 2.0/3, 3.0/4, 3.0/5, 3.0/6, 3.0/6, 3.0/6]
+
+    #frozen:
+    calc_bkgs = [1.0, 0.5, 0.333333333333333, 0.25, 0.4, 0.5, 0.5, 0.5]
+    #frozen:
+    false_to_total_ratios = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+
+    @peps.zip(precisions, calc_bkgs, false_to_total_ratios) do |pep, exp_prec, calc_bkg, false_to_total_ratio|
+      val.increment_pephits_precision(pep).should == exp_prec
+      val.calculated_background.should be_close(calc_bkg, 0.00000000000001)
+      val.false_to_total_ratio.should == false_to_total_ratio
+    end
+  end
+
+  it 'creates correct reference hash' do
+    val = klass.new(@toppred_file, :min_num_tms => 3, :soluble_fraction => true, :correct_wins => true)
+    val.transmem_by_ti_key.should == {"YAL001C"=>false, "YAL011W"=>false, "YAL009W"=>false, "YAL010C"=>false, "YAL008W"=>true, "YAL007C"=>false, "YAL004W"=>false, "YAL005C"=>false, "YAL003W"=>false, "YAL002W"=>true, "YAL013W"=>false, "YAL014C"=>false, "YAL012W"=>false}
+  end
+
+
+end
+
+
+#################################################
+# REFERENCE for small mock set:
+#################################################
+    #    for mintm >= 3 (T = TP, F = FP, sf = soluble_fraction)
+    #        sf=false sf=true
+    #    TM  cw fw    cw fw
+    # 0  y   T  T     F  F
+    # 1  ?   T  F     T  F
+    # 2  n   F  F     T  T
+    # 3  n   F  F     T  T
+    # 4  y   T  T     F  F
+    # 5  n   F  F     T  T
+    #
+    # [tps, fps]
+    # cw=true(  sf=true [4,2],  sf=false [3,3] )
+    # cw=false( sf=true [3,3],  sf=false [2,4] )
+   
+    #    for mintm >= 2 (T = TP, F = FP, sf = soluble_fraction)
+    #        sf=false sf=true
+    #    TM  cw fw    cw fw
+    # 0  y   T  T     F  F
+    # 1  ?   T  F     T  F
+    # 2  ?   T  F     T  F
+    # 3  n   F  F     T  T
+    # 4  y   T  T     F  F
+    # 5  y   T  T     F  F
+    #
+    # [tps, fps]
+    # cw=true(  sf=true [3,3],  sf=false [5,1] )
+    # cw=false( sf=true [1,5],  sf=false [3,3] )
+    #
+    # sf=true(  cw=true [3,3],  cw=false[1,5] )
+    # sf=false( cw=true [5,1],  cw=false[3,3] )

data/specs/validator/true_pos_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path( File.dirname(__FILE__) + '/../spec_helper' )
+require File.expand_path(File.dirname(__FILE__) + '/../validator_helper')
+
+require 'validator/true_pos'
+require 'fasta'
+require 'spec_id'
+
+klass = Validator::TruePos
+describe klass, 'reporting precision on peptides' do
+
+  before(:each) do
+    @myfasta_string =<<END
+>gi|1245235|ProteinX
+ABCDEFGHIJKLMNOP
+>gi|987654|ProteinY
+AAAAAABBBBBBBBBBBB
+>gi|1111111|ProteinZ
+FFFFFFFFFGGGGGGZZZZ
+END
+
+    @peps =  (0..5).to_a.map {|n| v = SpecID::GenericPep.new; v.aaseq = n.to_s ; v }
+    prots = %w(gi|1245235|ProteinX gi|987654|ProteinY gi|1111111|ProteinZ someOthergi AnotherGi YetAnotherReference).map do |ref|
+      v = SpecID::GenericProt.new
+      v.reference = ref
+      v
+    end
+    @peps[0].prots = [prots[0], prots[5]]  # TP (only in tp wins)
+    @peps[1].prots = [prots[1], prots[2]]  # TP always
+    @peps[2].prots = [prots[3], prots[4]]  # FP 
+    @peps[3].prots = [prots[2]]            # TP
+    @peps[4].prots = [prots[5]]            # FP
+    @peps[5].prots = [prots[4]]            # FP
+    @myfasta_obj = Fasta.new.load(StringIO.new(@myfasta_string))
+
+    @validator = klass.new(@myfasta_obj)
+  end
+
+  it_should_behave_like 'a validator'
+
+  it 'gives correct precision (across all options)' do
+    answ_ar = [
+      [[@peps[0], @peps[1], @peps[3]], [@peps[2], @peps[4], @peps[5]]],
+      [[@peps[1], @peps[3]], [@peps[0], @peps[2], @peps[4], @peps[5]]]
+    ]
+
+    [true, false].each do |correct_wins|
+      val = klass.new(@myfasta_obj, correct_wins)
+      answ = val.pephit_precision(@peps)
+      exp = ValidatorHelper.precision_from_partition_array(answ_ar.shift)
+      answ.should == exp
+    end
+
+  end
+
+end
+
+
+

data/specs/validator_helper.rb

@@ -0,0 +1,33 @@
+require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
+
+class ValidatorHelper
+  def self.precision_from_partition_array(ar)
+    (num_tp, num_fp) = ar.map {|v| v.size}
+    num_tp.to_f / (num_tp + num_fp)
+  end
+end
+
+module ValidatorHelper::Decoy
+  def self.precision_from_partition_array(ar)
+    (num_maybe_true, num_decoy) = ar.map {|v| v.size}
+    num_tp = num_maybe_true - num_decoy
+    num_fp = num_maybe_true - num_tp
+    num_tp.to_f / (num_tp + num_fp)
+  end
+end
+
+describe 'a validator', :shared => true do
+  before(:each) do
+    @empty_peps = []
+  end
+  it 'gives 1.0 for zero peptides (w/ pephit_precision)' do 
+    @validator.pephit_precision(@empty_peps).should == 1.0
+    
+  end
+  it 'gives 1.0 for zero peptides (w/ increment_pephits_precision)' do
+    @validator.increment_pephits_precision(@empty_peps).should == 1.0
+  end
+
+end
+
+

data/specs/xml_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
+
+require 'xml'
+
+describe XML, 'converting duration to seconds' do
+  it 'converts hours/mins/seconds in combinations' do
+    answ = [0.234, 624, 7392.2]
+    %w(PT0.234S PT10M24S PT2H3M12.2S).zip(answ) do |string, answ|
+      XML.duration_to_seconds(string).should == answ
+    end
+  end
+end