mspire 0.4.9 → 0.5.0

data/specs/pi_zero_spec.rb

@@ -1,115 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
-require 'pi_zero'
-
-describe PiZero do
-  before(:all) do
-    @bools = "11110010110101010101000001101010101001010010100001001010000010010000010010000010010101010101000001010000000010000000000100001000100000100000100000001000000000000100000000".split('').map do |v| 
-      if v.to_i == 1
-        true
-      else
-        false
-      end
-    end
-    increment = 6.0 / @bools.size
-    @xcorrs = []
-    0.0.step(6.0, increment) {|v| @xcorrs << v }
-    @xcorrs.reverse!
-                 
-    @sorted_pvals = [0.0, 0.1, 0.223, 0.24, 0.55, 0.68, 0.68, 0.90, 0.98, 1.0]
-  end
-
-  xit 'calculates instantaneous pi_0 hats' do
-    answ = PiZero.pi_zero_hats(@sorted_pvals, :step => 0.1)
-    exp_lambdas =       [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
-    passing_threshold = [9,   8,   8,   6,   6,   6,   5,   3,   3,   2]
-    expected = passing_threshold.zip(exp_lambdas).map {|v,l| v.to_f / (10.0 * (1.0 - l)) }
-    (answ_lams, answ_pis) = answ
-    answ_lams.zip(exp_lambdas) {|a,e| a.should be_close(e, 0.0000000001) }
-    answ_pis.zip(expected) {|a,e| a.should be_close(e, 0.0000000001) }
-  end
-
-  xit 'can find a plateau height with exponential' do
-    x = [0.0, 0.01, 0.012, 0.13, 0.2, 0.3, 0.4, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]
-    y = [1.0, 0.95, 0.92, 0.8, 0.7, 0.6, 0.55, 0.58, 0.62, 0.53, 0.54, 0.59, 0.4, 0.72]
-
-    z = PiZero.plateau_exponential(x,y)
-    # still working on this one
-  end
-
-  xit 'can find a plateau height' do
-    x = [0.0, 0.01, 0.012, 0.13, 0.2, 0.3, 0.4, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]
-    y = [1.0, 0.95, 0.92, 0.8, 0.7, 0.6, 0.55, 0.58, 0.62, 0.53, 0.54, 0.59, 0.4, 0.72]
-    z = PiZero.plateau_height(x,y)
-    z.should be_close(0.57, 0.05)
-    #require 'rsruby'
-    #r = RSRuby.instance
-    #r.plot(x,y)
-    #sleep(8)
-  end
-
-  xit 'can calculate p values for SEQUEST hits' do
-    class FakeSequest ; attr_accessor :xcorr ; def initialize(xcorr) ; @xcorr = xcorr ; end ; end
-
-    target = []
-    decoy = []
-    cnt = 0
-    @xcorrs.zip(@bools) do |xcorr, bool|
-      if bool
-        target << FakeSequest.new(xcorr)
-      else
-        decoy << FakeSequest.new(xcorr)
-      end
-    end
-    pvalues = PiZero.p_values_for_sequest(target, decoy)
-    # frozen:
-    exp = [1.71344886775144e-07, 1.91226800512155e-07, 2.1332611415515e-07, 2.37879480495429e-07, 3.29004960353623e-07, 4.07557294032203e-07, 4.5332397295349e-07, 5.60147945165288e-07, 6.90985835582987e-07, 8.50958233458999e-07, 1.04621373866358e-06, 1.28412129273e-06, 2.35075612646546e-06, 2.59621031358335e-06, 3.16272156036349e-06, 3.84642913860656e-06, 4.67014790912829e-06, 5.66082984245324e-06, 7.53093419443452e-06, 9.09058296339405e-06, 1.20185706815653e-05, 1.44474800911154e-05, 2.27242185508328e-05, 2.967213280773e-05, 3.537451312629e-05, 5.93486219583748e-05, 7.64456599577934e-05, 0.000125433021038759, 0.000159783941297163, 0.000256431068540685, 0.000323066395099306, 0.00037608522266194, 0.000437091783629134, 0.000507167844234063, 0.000587522219112902, 0.000679502786805963, 0.00104103901250011, 0.00119624534498457, 0.00219153400681528, 0.00439503742960694, 0.00593498821589879, 0.00749365688957234, 0.0105069659581753, 0.0145259091109191, 0.0218905360424189, 0.0404530419122661]
-    pvalues.zip(exp) do |v,e|
-      v.should be_close(e, 0.000001)
-    end
-  end
-
-  xit 'can calculate pi zero for target/decoy booleans' do
-    pi_zero = PiZero.pi_zero_from_booleans(@bools)
-    # frozen
-    pi_zero.should be_close(0.03522869, 0.0001)
-  end
-
-  it 'can calculate frit for groups of hits' do
-    # setup
-    targets = [4,3,8,3,5,3,4,5,4]
-    decoys = [0,2,2,3,5,7,8,8,8]
-    targets_summed = []
-    targets.each_with_index do |ar,i|
-      sum = 0
-      (0..i).each do |j|
-        sum += targets[j]
-      end
-      targets_summed << sum
-    end
-    decoys_summed = []
-    decoys.each_with_index do |ar,i|
-      sum = 0
-      (0..i).each do |j|
-        sum += decoys[j]
-      end
-      decoys_summed << sum
-    end
-    zipped = targets_summed.zip(decoys_summed)
-    frit = PiZero.frit_from_groups(zipped)
-    # frozen
-    frit.should be_close(0.384064, 0.00001)
-  end
-
-  xit 'can calcuate pi zero for total number of hits and precision' do
-    tot_hits = [1,10,20,30,50,200]
-    precision = [1.0, 1.0, 0.85, 0.80, 0.7, 0.5]
-    reply = PiZero.frit_from_precision(tot_hits, precision)
-    puts "ANSER"
-    # frozen
-    puts reply
-    #reply.should be_close()
-
-  end
-
-end
-

data/specs/qvalue_spec.rb

@@ -1,39 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
-
-require 'qvalue'
-
-describe 'finding q-values' do
-
-  it 'can do num_le' do
-    x = VecD[1,8,10,8,9,10]
-    exp = VecD[1, 3, 6, 3, 4, 6]
-    x.num_le.should == exp
-
-    x = VecD[10,9,8,5,5,5,5,3,2]
-    exp = VecD[9, 8, 7, 6, 6, 6, 6, 2, 1]
-    x.num_le.should == exp
-  end
-
-  it 'can do qvalues with smooth pi0' do
-    pvals = VecD[0.00001, 0.0001, 0.001, 0.01, 0.03, 0.02, 0.01, 0.1, 0.2, 0.4, 0.5, 0.6, 0.77, 0.8, 0.99]
-    exp = [0.0000938637, 0.0004693185, 0.0031287899, 0.0187727394, 0.0402272988, 0.0312878991, 0.0187727394, 0.1173296215, 0.2085859937, 0.3754547887, 0.4266531690, 0.4693184859, 0.5363639839, 0.5363639839, 0.6195004014]
-    pvals.qvalues.zip(exp) do |a,b|
-      a.should be_close(b, 1.0e-9)
-    end
-  end
-
-  it 'can do qvalues with bootstrap pi0' do
-    puts "\nbootstrap pi0 needs further testing although answers seem to be close!"
-    pvals = VecD[0.00001, 0.0001, 0.001, 0.01, 0.03, 0.02, 0.01, 0.1, 0.2, 0.4, 0.5, 0.6, 0.77, 0.8, 0.99]
-    # this is what the Storey software gives for this:
-    # exp = [8.888889e-05, 4.444444e-04, 2.962963e-03, 1.777778e-02, 3.809524e-02, 2.962963e-02, 1.777778e-02, 1.111111e-01, 1.975309e-01, 3.555556e-01, 4.040404e-01, 4.444444e-01, 5.079365e-01, 5.079365e-01, 5.866667e-01]
-    exp = [9.38636971774565e-05, 0.000469318485887282, 0.00312878990591522, 0.0187727394354913, 0.0402272987903385, 0.0312878990591522, 0.0187727394354913, 0.117329621471821, 0.208585993727681, 0.375454788709826, 0.426653168988439, 0.469318485887282, 0.53636398387118, 0.53636398387118, 0.619500401371213]
-    robust = false
-    qvals = pvals.qvalues(robust, :method => :bootstrap)
-    qvals.zip(exp) do |a,b|
-      a.should be_close(b, 0.00001)
-    end
-  end
-
-end
-

data/specs/roc_spec.rb

@@ -1,251 +0,0 @@
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper'
 )
-require 'roc'
-
-describe 'an area under the curve calculator', :shared => true do
-
-  it 'calculates area under curve correctly' do
-    x_y_pairs = {
-      [[1,2,3],[2,3,4]]    => 6,
-      [[1,2,3],[-2,-3,-4]] => -6,
-      [[1,2,3],[4,3,2]]    => 6,
-      [[1,2,3],[-4,-3,-2]] => -6,
-      [[4,5,6],[2,1,2]]    => 3,
-      [[4,5,6],[-2,-1,-2]] => -3,
-    }
-    x_y_pairs.each do |k,v|
-      calculate(*k).should == v
-    end
-  end
-
-  def calculate(x,y)
-    @method.call(x,y)
-  end
-end
-
-describe ROC do
-  before(:all) do
-    @method = proc {|x,y| ROC.new.area_under_curve(x,y) }
-  end
-  it_should_behave_like 'an area under the curve calculator'
-
-  it 'gives doublets_to_separate' do
-    t = true
-    f = false
-    x,y = ROC.new.doublets_to_separate([[0,f],[1,f],[2,f],[3,t],[3,f],[0,f],[4,f],[1,t],[2,t]])
-    x.should == [1,2,3]
-    y.should == [0,0,1,2,3,4]
-  end
-
-  it 'gives tps_and_ppv' do
-    tp = %w(1 2 3 4 5 6 6 6 7 8 9 10 10 10 10 11 12 ).collect {|c| c.to_f } # 17 total
-    fp = %w(3.5 4 5 5 5 6 6 6.5 7 8 9 9.5 10 15).collect {|c| c.to_f } # 14 total
-    xe = [1, 2, 3, 4, 5, 8, 9, 10, 11, 15, 16, 17]
-    #       1, 2, 3, 4        5,   6,             7,             8,   9
-    #       10              11                12
-    ye = [1, 1, 1, 4.0/6.0, 0.5, 8.0/(7.0+8.0), 9.0/(9.0+9.0), 0.5, 11.0/(11.0+ 11.0),  15.0/(15.0+13.0), 16.0/(16.0+13.0), 17.0/(17.0+13.0)]
-    _test_tps_and_ppv_method(tp,fp,xe,ye,"complex real-life-like scenario")
-
-    ## leading fp's
-    tp = [1,2,3]
-    fp = [0,0,1,2,3,4]
-    xe = [1,2,3]
-    ye = [1.0/(1+3), 2.0/(2+4), 3.0/(3+5)]
-    _test_tps_and_ppv_method(tp,fp,xe,ye, "leading fps")
-
-    ## leading tp's
-    tp = [-1,2,3]
-    fp = [0,4]
-    xe = [1,2,3]
-    ye = [1.0/(1+0), 2.0/(2+1), 3.0/(3+1)]
-    _test_tps_and_ppv_method(tp,fp,xe,ye, "leading tps")
-
-    ## equal tp's leading
-    tp = [0.0001,0.0001,0.0001,2]
-    fp = [0.01,4.0]
-    xe = [3,4]
-    ye = [3.0/(3+0), 4.0/(4+1)]
-    _test_tps_and_ppv_method(tp,fp,xe,ye, "equal tps leading")
-
-    ## equal arrays with some repeated values
-    tp = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    fp = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    xe = [1,2,4,5,6,7]
-    ye = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
-    _test_tps_and_ppv_method(tp,fp,xe,ye, "equal arrays with some repeated values")
-
-  end
-
-  it 'gives numhits_and_ppv' do
-    ## leading fp's
-    tp = [1,2,3]
-    fp = [0,0,1,2,3,4]
-    xe = [2,4,6,8,9]
-    ye = [0.0/2, 1.0/4, 2.0/6, 3.0/8, 3.0/9]
-    _test_numhits_and_ppv_method(tp,fp,xe,ye, "leading fps")
-
-    ## leading tp's
-    tp = [-1,2,3]
-    fp = [0,4]
-    xe = [1, 2, 3, 4, 5]
-    ye = [1.0/1, 1.0/2, 2.0/3, 3.0/4, 3.0/5]
-    _test_numhits_and_ppv_method(tp,fp,xe,ye, "leading tps")
-
-    ## equal tp's leading
-    tp = [0.0001,0.0001,0.0001,2]
-    fp = [0.01,4.0]
-    xe = [3, 4, 5, 6]
-    ye = [3.0/3, 3.0/4, 4.0/5, 4.0/6]
-    _test_numhits_and_ppv_method(tp,fp,xe,ye, "equal tps leading")
-
-    ## equal arrays with some repeated values
-    tp = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    fp = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    xe = [2, 4, 8, 10, 12, 14]
-    ye = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
-    _test_numhits_and_ppv_method(tp,fp,xe,ye, "equal arrays with some repeated values")
-
-    ## @TODO: NEED TO FILL THIS OUT!
-=begin 
-    tp = %w(1 2 3 4 5 6 6 6 7 8 9 10 10 10 10 11 12 ).collect {|c| c.to_f } # 17 total
-    fp = %w(3.5 4 5 5 5 6 6 6.5 7 8 9 9.5 10 15).collect {|c| c.to_f } # 14 total
-    xe = [1, 2, 3, 4, ]
-    #       1, 2, 3, 4        5,   6,             7,             8,   9
-    #       10              11                12
-    ye = [1, 1, 1, 4.0/6.0, 0.5, 8.0/(7.0+8.0), 9.0/(9.0+9.0), 0.5, 11.0/(11.0+ 11.0),  15.0/(15.0+13.0), 16.0/(16.0+13.0), 17.0/(17.0+13.0)]
-    _test_tps_and_ppv_method(tp,fp,xe,ye,"complex real-life-like scenario")
-=end
-
-  end
-
-  def _test_numhits_and_ppv_method(tp,fp,xe,ye,message='')
-    roc = ROC.new
-    list = roc.separate_to_doublets(tp,fp)
-    (x,y) = roc.numhits_and_ppv(list)
-    y.size.should == x.size
-    x.should == xe
-    y.should == ye
-  end
-
-  def _test_tps_and_ppv_method(tp,fp,xe,ye,message='')
-    (x,y) = ROC.new.tps_and_ppv(tp,fp)
-    y.size.should == x.size
-    x.should == xe
-    y.should == ye
-  end
-
-end
-
-describe DecoyROC do
-
-  ###################################################################
-
-  it 'gives pred_and_ppv' do
-    hits = [1,2,3]
-    decoys = [0,0,1,2,3,4]
-    num_hits_e = [1,2,3]
-    num_fps = [3,4,5]
-    # expected = [-2.0/1, -2.0/2, -2.0/3] 
-    _test_pred_and_ppv(hits, decoys, num_hits_e, num_fps)
-  end
-
-  it 'gives pred_tps_ppv__leading_tps' do
-    ## leading tp's
-    hits = [-1,2,3]
-    decoys = [0,4]
-    num_hits_e = [1,2,3]
-    num_fps = [0,1,1]
-    _test_pred_and_ppv(hits, decoys, num_hits_e, num_fps)
-  end
-
-  it 'gives pred_tps_ppv__equal_tps_leading' do
-    hits = [0.0001,0.0001,0.0001,2]
-    decoys = [0.01,4.0]
-    num_hits_e = [3,4]
-    num_fps = [0,1]
-    _test_pred_and_ppv(hits, decoys, num_hits_e, num_fps)
-  end
-
-  it 'gives pred_tps_ppv__equal_arrays_with_some_repeated_values' do
-    hits = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    decoys = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    num_hits_e = [1,2,4,5,6,7]
-    num_fps = [1,2,4,5,6,7]
-    _test_pred_and_ppv(hits, decoys, num_hits_e, num_fps)
-  end
-
-  ###################################################################
-
-  it 'gives pred_tps_ppv__leading_fps' do
-    ## leading fp's
-    hits = [1,2,3]
-    decoys = [0,0,1,2,3,4]
-    num_hits_e = [1,2,3]
-    num_fps = [3,4,5]
-    tps_e = make_tps_e(num_fps, num_hits_e)
-    ppv_e = make_ppv_e(tps_e, num_hits_e)
-    _test_pred_and_tps_and_ppv(hits, decoys, num_hits_e, tps_e, ppv_e)
-  end
-
-  it 'gives pred_tps_ppv__leading_tps' do
-    ## leading tp's
-    hits = [-1,2,3]
-    decoys = [0,4]
-    num_hits_e = [1,2,3]
-    num_fps = [0,1,1]
-    tps_e = make_tps_e(num_fps, num_hits_e)
-    ppv_e = make_ppv_e(tps_e, num_hits_e)
-    _test_pred_and_tps_and_ppv(hits, decoys, num_hits_e, tps_e, ppv_e)
-  end
-
-  it 'gives pred_tps_ppv__equal_tps_leading' do
-    hits = [0.0001,0.0001,0.0001,2]
-    decoys = [0.01,4.0]
-    num_hits_e = [3,4]
-    num_fps = [0,1]
-    tps_e = make_tps_e(num_fps, num_hits_e)
-    ppv_e = make_ppv_e(tps_e, num_hits_e)
-    _test_pred_and_tps_and_ppv(hits, decoys, num_hits_e, tps_e, ppv_e)
-  end
-
-  it 'gives pred_tps_ppv__equal_arrays_with_some_repeated_values' do
-    hits = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    decoys = %w(1 2 3 3 4 5 6 ).collect {|x| x.to_f } # 17 total
-    num_hits_e = [1,2,4,5,6,7]
-    num_fps = [1,2,4,5,6,7]
-    tps_e = make_tps_e(num_fps, num_hits_e)
-    ppv_e = make_ppv_e(tps_e, num_hits_e)
-    _test_pred_and_tps_and_ppv(hits, decoys, num_hits_e, tps_e, ppv_e)
-  end
-
-  def  _test_pred_and_ppv(hits, decoys, num_hits_e, num_fps)
-    answer = DecoyROC.new.pred_and_ppv(hits, decoys)
-    precision = num_hits_e.zip(num_fps).map do |h,f|
-      (h - f).to_f / h
-    end
-    answer.should == [num_hits_e, precision]
-  end
-
-  def _test_pred_and_tps_and_ppv(hits, decoys, num_hits_e, tps_e, ppv_e)
-    answer = DecoyROC.new.pred_and_tps_and_ppv(hits, decoys)
-    expected = [num_hits_e, tps_e, ppv_e]
-    %w(num_hits num_tps ppv).each_with_index do |cat, i|
-      answer[i].should == expected[i]
-    end
-  end
-
-  def make_tps_e(num_fps, num_hits_e)
-    tps_e = []
-    num_hits_e.each_with_index do |v,i|
-      tps_e[i] = v - num_fps[i]
-    end
-    tps_e
-  end
-
-  def make_ppv_e(tps_e, num_hits_e)
-    ppv_e = []
-    tps_e.each_with_index {|v,i| ppv_e[i] = v.to_f/num_hits_e[i] }
-    ppv_e
-  end
-
-end
-

data/specs/rspec_autotest.rb

@@ -1,149 +0,0 @@
-# (c) Copyright 2006-2007 Nick Sieger <nicksieger@gmail.com>
-# 
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation files
-# (the "Software"), to deal in the Software without restriction,
-# including without limitation the rights to use, copy, modify, merge,
-# publish, distribute, sublicense, and/or sell copies of the Software,
-# and to permit persons to whom the Software is furnished to do so,
-# subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-require 'rubygems'
-gem 'ZenTest'
-require 'autotest'
-
-class RspecAutotest < Autotest
-  attr_accessor :spec_command
-  def initialize # :nodoc:
-    @spec_command = "spec --diff unified"
-    super
-    @exceptions = %r%^\./(?:coverage|doc)%
-  end
-
-  def tests_for_file(filename)
-    case filename
-    when /^lib\/.*\.rb$/ then
-      impl = File.basename(filename).gsub('_', '_?').sub(/\.rb$/, '')
-      @files.keys.select do |k|
-        k =~ %r%^spec/.*#{impl}_spec\.rb$%
-      end
-    when %r%^spec/spec_helper.rb% then
-      @files.keys.select do |f|
-        f =~ %r%^spec/.*_spec\.rb$%
-      end
-    when /^spec\/.*_spec\.rb$/ then
-      [filename]
-    when /#{Regexp.quote(File.basename(__FILE__))}/
-      # Don't respond to changes to this file
-      []
-    else
-      @output.puts "Dunno! #{filename}" if $TESTING
-      []
-    end
-  end
-
-  def handle_results(results)
-    failed = results.scan(/^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m)
-    @files_to_test = consolidate_failures failed
-    unless @files_to_test.empty? then
-      hook :red
-    else
-      hook :green
-    end unless $TESTING
-    @tainted = true unless @files_to_test.empty?
-  end
-
-  def consolidate_failures(failed)
-    filters = Hash.new { |h,k| h[k] = [] }
-    failed.each do |spec, failed_trace|
-      @files.keys.select{|f| f =~ /spec\//}.each do |f|
-        if failed_trace =~ Regexp.new(f)
-          filters[f] << spec 
-          break
-        end
-      end
-    end
-    return filters
-  end
-
-  def make_test_cmd(files_to_test)
-    cmds = []
-    full, partial = files_to_test.partition { |k,v| v.empty? }
-
-    unless full.empty? then
-      classes = full.map {|k,v| k}.flatten.join(' ')
-      cmds << "#{spec_command} #{classes}"
-    end
-
-    partial.each do |klass, methods|
-      methods.each { |meth| cmds << "#{spec_command} -s #{meth.inspect} #{klass}" }
-    end
-
-    return cmds.join('; ')
-  end
-end
-
-class RspecOnRailsAutotest < RspecAutotest
-  def initialize # :nodoc:
-    super
-    @exceptions = %r%^\./(?:coverage|db|doc|log|public|script|vendor)%
-  end
-
-  def tests_for_file(filename)
-    case filename
-    when %r%^spec/fixtures/(.*)s.yml% then
-      ["spec/models/#{$1}_spec.rb",
-       "spec/controllers/#{$1}_controller_spec.rb"]
-    when %r%^spec/models/.*rb$% then
-      [filename]
-    when %r%^spec/controllers/.*\.rb$% then
-      [filename]
-    when %r%^spec/views/.*\.rb$% then
-      [filename]
-    when %r%^spec/helpers/.*\.rb$% then
-      [filename]
-    when %r%^app/models/(.*)\.rb$% then
-      ["spec/models/#{$1}_spec.rb"]
-    when %r%^app/helpers/application_helper.rb% then
-      @files.keys.select { |f|
-        f =~ %r%^spec/controllers/.*_spec\.rb$%
-      }
-    when %r%^app/helpers/(.*)_helper.rb% then
-      ["spec/controllers/#{$1}_controller_spec.rb", "spec/helpers/#{$1}_spec.rb"]
-    when %r%^app/controllers/application.rb$% then
-      @files.keys.select { |f|
-        f =~ %r%^spec/controllers/.*_spec\.rb$%
-      }
-    when %r%^app/controllers/(.*)\.rb$% then
-      ["spec/controllers/#{$1}_spec.rb"]
-    when %r%^app/views/layouts/% then
-      []
-    when %r%^app/views/(.*)/% then
-      ["spec/controllers/#{$1}_controller_spec.rb", "spec/views/#{$1}_spec.rb"]
-    when %r%^config/routes.rb$% then
-      @files.keys.select do |f|
-        f =~ %r%^spec/controllers/.*_spec\.rb$%
-      end
-    when %r%^spec/spec_helper.rb%,
-         %r%^config/((boot|environment(s/test)?).rb|database.yml)% then
-      @files.keys.select do |f|
-        f =~ %r%^spec/(models|controllers)/.*_spec\.rb$%
-      end
-    else
-      @output.puts "Dunno! #{filename}" if $TESTING
-      []
-    end.uniq.select { |f| @files.has_key? f }
-  end
-end

data/specs/sample_enzyme_spec.rb

@@ -1,126 +0,0 @@
-
-require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
-require 'sample_enzyme'
-require 'set'
-
-describe SampleEnzyme, "digesting sequences" do
-  it 'can digest with no missed cleavages' do
-    st = "CRGATKKTAGRPMEK"
-    SampleEnzyme.tryptic(st).should == %w(CR GATK K TAGRPMEK)
-    st = "CATRP"
-    SampleEnzyme.tryptic(st).should == %w(CATRP)
-    st = "RCATRP"
-    SampleEnzyme.tryptic(st).should == %w(R CATRP)
-    st = ""
-    SampleEnzyme.tryptic(st).should == []
-    st = "R"
-    SampleEnzyme.tryptic(st).should == %w(R)
-  end
-
-  it 'can digest with missed cleavages' do
-    st = "CRGATKKTAGRPMEKLLLERTKY"
-    zero = %w(CR GATK K TAGRPMEK LLLER TK Y)
-    SampleEnzyme.tryptic(st,0).to_set.should == zero.to_set
-    one = %w(CRGATK GATKK KTAGRPMEK TAGRPMEKLLLER LLLERTK TKY)
-    SampleEnzyme.tryptic(st,1).to_set.should == (zero+one).to_set
-    two = %w(CRGATKK GATKKTAGRPMEK KTAGRPMEKLLLER TAGRPMEKLLLERTK LLLERTKY)
-    all = zero + one + two
-    SampleEnzyme.tryptic(st,2).to_set.should == all.to_set
-  end
-
-  it 'contains duplicates IF there are duplicate tryptic sequences' do
-    st = "AAAAKCCCCKDDDDKCCCCK"
-    peps = SampleEnzyme.new('trypsin').digest(st, 2)
-    peps.select {|aaseq| aaseq == 'CCCCK'}.size.should == 2
-  end
-  
-end
-
-describe SampleEnzyme, 'making enzyme calculations on sequences and aaseqs' do
-
-  before(:each) do
-    @full_KRP = SampleEnzyme.new do |se|
-      se.name = 'trypsin'
-      se.cut = 'KR'
-      se.no_cut = 'P'
-      se.sense = 'C'
-    end
-    @just_KR = SampleEnzyme.new do |se|
-      se.name = 'trypsin'
-      se.cut = 'KR'
-      se.no_cut = ''
-      se.sense = 'C'
-    end
-  end
-
-  it 'calculates the number of tolerant termini' do
-    exp = [{
-      # full KR/P
-      'K.EPTIDR.E' => 2,
-      'K.PEPTIDR.E' => 1,
-      'F.EEPTIDR.E' => 1,
-      'F.PEPTIDW.R' => 0,
-    },
-    {
-      # just KR
-      'K.EPTIDR.E' => 2,
-      'K.PEPTIDR.E' => 2,
-      'F.EEPTIDR.E' => 1,
-      'F.PEPTIDW.R' => 0,
-    }
-    ]
-    scall = Sequest::PepXML::SearchHit
-    sample_enzyme_ar = [@full_KRP, @just_KR]
-    sample_enzyme_ar.zip(exp) do |sample_enzyme,hash|
-      hash.each do |seq, val|
-        sample_enzyme.num_tol_term(seq).should == val
-      end
-    end
-  end
-
-  it 'calculates number of missed cleavages' do
-    exp = [{
-    "EPTIDR" => 0,
-    "PEPTIDR" => 0,
-    "EEPTIDR" => 0,
-    "PEPTIDW" => 0,
-    "PERPTIDW" => 0,
-    "PEPKPTIDW" => 0,
-    "PEPKTIDW" => 1,
-    "RTTIDR" => 1,
-    "RTTIKK" => 2,
-    "PKEPRTIDW" => 2,
-    "PKEPRTIDKP" => 2,
-    "PKEPRAALKPEERPTIDKW" => 3,
-    },
-    {
-    "EPTIDR" => 0,
-    "PEPTIDR" => 0,
-    "EEPTIDR" => 0,
-    "PEPTIDW" => 0,
-    "PERPTIDW" => 1,
-    "PEPKPTIDW" => 1,
-    "PEPKTIDW" => 1,
-    "RTTIDR" => 1,
-    "RTTIKK" => 2,
-    "PKEPRTIDW" => 2,
-    "PKEPRTIDKP" => 3,
-    "PKEPRAALKPEERPTIDKW" => 5,
-    }
-    ]
-
-    sample_enzyme_ar = [@full_KRP, @just_KR]
-    sample_enzyme_ar.zip(exp) do |sample_enzyme, hash|
-      hash.each do |aaseq, val|
-        #first, middle, last = SpecID::Pep.split_sequence(seq)
-        # note that we are only using the middle section!
-        sample_enzyme.num_missed_cleavages(aaseq).should == val
-      end
-    end
-  end
-
-end
-
-
-
-