ms-error_rate 0.0.7

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright shared among contributing institutions:
+Copyright (c) 2006-2008 University of Texas at Austin (the initial project)
+Copyright (c) 2009 Regents of the University of Colorado and Howard Hughes Medical Institute. (modularization of the project)
+
+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.

data/README.rdoc

@@ -0,0 +1,53 @@
+= {ms-error_rate}[http://mspire.rubyforge.org/projects/ms-error_rate]
+
+An {Mspire}[http://mspire.rubyforge.org] library for calculating or dealing
+with error rates.  These may be from target-decoy searches, sample bias
+validation, or other sources.  
+
+== Examples
+
+=== Target-Decoy with Mascot
+
+Generate q-values (right now only with Mascot and MascotPercolator):
+
+    require 'ms/error_rate/qvalue'
+    target_hits = Ms::ErrorRate::Qvalue::Mascot.qvalues(target_files, decoy_files)
+    # target_hit is a PeptideHit Struct (:filename, :query_title, :charge, :sequence, :mowse, :qvalue)
+
+    # or on the commandline:
+    % qvalues.rb <target>.dat <decoy>.dat
+
+The same output can be produced from Mascot-Percolator output:
+
+    require 'ms/error_rate/qvalue'
+    target_hits = Ms::ErrorRate::Qvalue::Mascot::Percolator.qvalues(datp_files, tab_dot_text_files)
+    # or commandline:
+    % qvalues.rb <target>.datp <target>.tab.txt
+
+=== Sample Bias Validation
+
+Sample Bias Validation allows error rate determination based on expected biases in sample composition.  Here is an example using transmembrane sequence content.  We will assume a fasta file called `proteins.fasta`:
+
+    # create a peptide-centric database
+    fasta_to_peptide_centric_db.rb proteins.fasta  # defaults 2 missed cleavages, min aaseq 4
+       # generates a file: proteins.msd_clvg2.min_aaseq4.yml
+
+    # create a transmembrane sequence prediction file
+    fasta_to_phobius.rb proteins.fasta     # => generates proteins.phobius
+
+    generate_sbv_input_hashes.rb proteins.msd_clvg2.min_aaseq4.yml --tm proteins.phobius,1
+       # creates two files:
+       # proteins.msd_clvg2.min_aaseq4.tm_min1.by_aaseq.yml
+       # proteins.msd_clvg2.min_aaseq4.tm_min1.freq_by_length.yml
+
+    # cytosolic fraction (transmembrane sequences not expected):
+    error_rate qvalues.yml --fp-sbv proteins.msd_clvg2.min_aaseq4.tm_min1.by_aaseq.yml,\
+        proteins.msd_clvg2.min_aaseq4.tm_min1.freq_by_length.yml,0.05
+
+== Installation
+
+  gem install ms-error_rate
+
+== Copyright
+
+See LICENSE

data/VERSION

@@ -0,0 +1 @@
+0.0.7

data/bin/error_rate

@@ -0,0 +1,92 @@
+#!/usr/bin/ruby
+
+require 'support/sort_by_attributes'
+require 'ms/error_rate'
+require 'optparse'
+
+@num_tp_validators = 0
+@num_fp_validators = 0
+
+
+arg_strings_ar = [true,false].map do |boolean|
+["a false positive indicator", "A = aaseq to indictor (0-1) yml file", "B = aaseq_length to frequency yml file", "C = rate indicators are #{boolean} pos.", "D = name of the validator"]
+end
+
+op_sbv_ars = [true,false].zip(arg_strings_ar).map do |boolean, arg_strings|
+  letter = boolean ? 't' : 'f'
+  ["--#{letter}p-sbv <A,B,C[,D]>,", Array, *arg_strings]
+end
+
+raw_validator_args = []
+validator_names = []
+
+opt = {
+  :order_by => [:qvalue],
+}
+
+opts = OptionParser.new do |op|
+  op.banner = "usage: #{File.basename(__FILE__)} qvalues.yml ..."
+
+  op.on("--order-by <Array>", Array, "the keys to order on (default: [qvalue])") {|v| opt[:order_by] = v.map {|v| v.to_sym } }
+  op.on("--best-is-low <Array>", Array, "the keys where better score is lower") {|v| opt[:best_is_low] = v.map {|v| v.to_sym } }
+
+  [true, false].each do |boolean|
+    index = boolean ? 0 : 1
+    op.on(*op_sbv_ars[index]) do |v| 
+      (a,b,c,d) = v
+      name = 
+        if d 
+          d
+        else
+          if boolean 
+            @num_tp_validator += 1
+            "tp#{@num_tp_validator}" 
+          else
+            @num_fp_validator += 1
+            "fp#{@num_fp_validators}"
+          end
+        end
+      validator_names << name
+      raw_validator_args << [a,b,c]
+    end
+  end
+end
+
+opts.parse!
+
+
+if ARGV.size != 1
+  puts opts.to_s
+  exit
+elsif !opt[:order_by]
+  puts "you must specify the order-by array!"
+  exit
+end
+
+sort_args = opt[:order_by]
+sort_args << {:down => opt[:best_is_low] } # because we will sort normal and reverse the array
+
+
+# load one validator at a time
+
+raw_validator_args.zip(validator_names) do |args, name|
+  (a,b,c) = args 
+  val = Ms::ErrorRate::Sbv.new(YAML.load_file(a), YAML.load_file(b), c)
+
+  ARGV.each do |file|
+    yaml = YAML.load_file(file)
+    pepclass = Struct.new(yaml['headers'].map {|v| v.to_sym })
+    peps = yaml['data'].each do |ar|
+      pepclass.new(*ar) 
+    end
+    sorted_best_to_worst = peps.sort_by_attributes(sort_args)
+
+    precision_vals = sorted_best_to_worst.map do |pep|
+      val.update_precision(pep.aaseq)
+    end
+
+  end
+  p precision_vals
+end
+
+

data/bin/fasta_to_nuclear.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby
+
+
+if ARGV.size == 0
+  puts "usage: #{File.basename(__FILE__)} <file>.fasta"
+  puts "output: <file>"
+  #puts "WARNING!!: you need to run phobius_to_nontransmembrane.rb before"
+  #puts "this to weed out transmembrane proteins!"
+  exit
+end
+
+
+
+

data/bin/fasta_to_peptide_centric_db.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'optparse'
+require 'ms/ident/peptidedb'
+
+Ms::Ident::Peptidedb.cmdline(ARGV)

data/bin/fasta_to_phobius.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby
+
+require 'mechanize'
+
+page = 'http://phobius.sbc.su.se/'
+
+if ARGV.size == 0
+  puts "usage: #{File.basename(__FILE__)} <file>.fasta"
+  puts "outputs <file>.phobius "
+  puts "in short format"
+  exit
+end
+
+
+a = WWW::Mechanize.new { |agent|
+  agent.user_agent_alias = 'Mac Safari'
+}
+
+ARGV.each do |file|
+  outfile = file.chomp(File.extname(file)) + '.phobius'
+  a.get(page) do |page|
+    form = page.forms.first
+    form.radiobuttons.select {|v| v.value == 'short' }.first.click
+    fu = form.file_uploads.first
+    fu.file_name = File.expand_path(file)
+    #fu.file_data = IO.read(file)
+    reply = form.submit
+    html = reply.body
+    start = html.index("<pre>") + 5
+    stop = html.rindex("</pre>")
+    File.open(outfile, 'w') {|out| out.print html[start...stop] }
+  end
+end
+

data/bin/generate_sbv_input_hashes.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+
+require 'ms/error_rate/sbv/peptide_based'
+require 'ms/error_rate/sbv/protein_based'
+
+opt = {}
+opt[:protein_bias] = []
+
+opts = OptionParser.new do |op|
+  op.banner = "usage: #{File.basename(__FILE__)} peptide_centric_db [OPTION]" 
+  op.on("--tm <phobius,min>", Array, "transmembrane, <phobius> is path to phobius ", "output file (see fasta_to_phobius.rb)", "<min> is the min number of tm sequences required") {|v| opt[:tm] = [v.first, v.last.to_i]}
+  op.on("--aa <aa,min>", Array, "amino acid, <aa> is a string found in the peptides", "<min> is the min number of required for counting") {|v| opt[:aa] = [v.first, v.last.to_i]}
+  op.on("--protein-bias <name,file>", Array, "<name> bias, <file> is path to a yaml hash", "    keyed prot -> <0-1>") {|v| opt[:protein_bias] << [v.first.to_sym, v.last]}
+  op.separator "outputs for each bias type:"
+op.separator "    <peptide_centric_db>.<info>.#{Ms::ErrorRate::Sbv::LENGTH_EXT}"
+op.separator "    <peptide_centric_db>.<info>.#{Ms::ErrorRate::Sbv::AASEQ_EXT}"
+end
+
+opts.parse!
+
+if ARGV.size == 0
+  puts opts.to_s
+  exit
+end
+
+peptide_centric_db = ARGV.first
+
+def note_files(files)
+  files.each do |file| puts "WROTE: #{file}" end
+end
+
+klass = Ms::ErrorRate::Sbv
+prot_klass = Ms::ErrorRate::Sbv::ProteinBased
+pep_klass = Ms::ErrorRate::Sbv::PeptideBased
+
+if opt[:tm]
+  index = TransmembraneIndex.new(opt[:tm].first)
+
+  protid_to_transmembrane = {}
+  regexp = nil
+  index.each do |k,v|
+    regexp ||= Ms::Fasta.id_regexp(k)
+    new_key = regexp.match(k)[1] 
+    protid_to_transmembrane[new_key] = ((v[:num_certain_transmembrane_segments] >= opt[:tm].last) ? 1 : 0)
+  end
+
+  fnames = prot_klass.generate_hashes( peptide_centric_db, protid_to_transmembrane, {:type_code => "tm_min#{opt[:tm].last}"})
+  note_files fnames
+end
+
+if opt[:aa]
+  fnames = pep_klass.generate_hashes( peptide_centric_db, *opt[:aa] )
+  note_files fnames
+end
+
+if opt[:protein_bias].size > 0
+  opt[:protein_bias].each do |name, hash_file|
+    prot_klass.generate_hashes( peptide_centric_db, hash_file)
+  end
+end

data/bin/mascot_pepxml_to_peptide_hit_qvalues.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'nokogiri'
+require 'set'
+
+require 'ms/error_rate/qvalue'
+
+opts = Trollop::Parser.new do
+  banner %Q{usage: #{File.basename(__FILE__)} <fwd>.xml <decoy>.xml ...
+outputs: <fwd>.phq.csv
+phq.tsv?: see schema/peptide_hit_qvalues.phq.tsv
+}
+  opt :z_together, "do not group by charge state", :default => false
+end
+
+DELIMITER = "\t"
+
+opt = opts.parse(ARGV)
+if ARGV.size == 0 || (ARGV.size%2 != 0)
+  puts "\n\n!! only even numbers of files accepted (target decoy target decoy ...) !!\n\n" if (ARGV.size%2 != 0)
+  opts.educate
+  exit 
+end
+
+files = ARGV.to_a
+
+PeptideHit = Struct.new(:aaseq, :charge, :ionscore, :qvalue)
+
+# this is a list of high quality peptide hits associated with each group
+peptide_hits_per_file = files.map do |file|
+  File.open(file) do |io|
+    doc = Nokogiri::XML.parse(io, nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS)
+    # we can work with namespaces, or just remove them ...
+    doc.remove_namespaces!
+    root = doc.root
+    search_hits = root.xpath('//search_hit')
+    search_hits.map do |search_hit| 
+      aaseq = search_hit['peptide']
+      ionscore = search_hit.children.find {|node| node.name == 'search_score' && node['name'] == 'ionscore' }['value'].to_f
+      charge = search_hit.parent.parent['assumed_charge'].to_i
+      PeptideHit.new(aaseq, charge, ionscore)
+    end
+  end
+end
+
+hits_per_target = peptide_hits_per_file.each_slice(2).map do |target_hits, decoy_hits|
+  pairs = Ms::ErrorRate::Qvalue.target_decoy_qvalues(target_hits, decoy_hits, :z_together => opt[:z_together], &:ionscore)
+  target_peptide_hits = pairs.map {|peptide_hit, qvalue| peptide_hit.qvalue = qvalue ; peptide_hit }
+end
+
+files.each_slice(2).map(&:first).zip(hits_per_target) do |file, hits|
+  newfile = file.chomp(File.extname(file)) + ".phq.tsv"
+  File.open(newfile,'w') do |out| 
+    out.puts %w(aaseq charge qvalue).join(DELIMITER)
+    hits.each do |hit|
+      out.puts hit.values_at(0,1,3).join(DELIMITER)
+    end
+  end
+end
+

data/bin/phobius_to_nontransmembrane.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+require 'ms/fasta'
+require 'transmembrane/phobius.rb'
+
+if ARGV.size != 3
+  puts "usage: #{File.basename(__FILE__)} <max#tm> phobius_file_short <file>.fasta"
+  puts "max#tm = max # of transmembrane sequences allowed to be a non-transmembrane."
+  puts ""
+  puts "outputs: <file>_NONTM.fasta"
+  exit
+end
+
+(max_num_tm, phobius_short_file, fasta_db_file) = ARGV
+max_num_tm = max_num_tm.to_i
+
+base = fasta_db_file.chomp(File.extname(fasta_db_file))
+outfile = base + "_NONTM.fasta"
+
+index = Phobius::Index.new(phobius_short_file)
+
+File.open(outfile, 'w') do |out|
+  Ms::Fasta.open(fasta_db_file) do |fasta|
+    fasta.each do |entry|
+      key = index.reference_to_key(entry.header)
+      abort "can't find key: #{key} for #{entry.header}"  unless index.key?(key)
+      num_tms = index[key][:num_certain_transmembrane_segments]
+      if num_tms <= max_num_tm
+        out.print entry.to_s
+      end
+    end
+  end
+end
+
+

data/bin/qvalues.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'ms/error_rate/qvalue'
+
+DEF_EXT = "_flip"
+NORMAL_EXT = 'qval.yml'
+
+def print_out(outfile, filenames, headers, target_hits)
+  File.open(outfile, 'w') do |out|
+    out.print( {'headers' => headers, 'filenames' => filenames, 'data' => target_hits }.to_yaml )
+  end
+end
+
+opt = {
+  :outfile => NORMAL_EXT,
+  :min_peptide_length => 9,
+}
+
+opts = OptionParser.new do |op|
+  op.banner = "usage: #{File.basename(__FILE__)} <target> <decoy> [... (as pairs)]"
+  op.separator "or:    #{File.basename(__FILE__)} <target>.datp <target>.tab.txt [... (as pairs)]"
+  op.separator "for each pair of files"
+  op.separator "sorts the peptide hits by score and determines the precision at each hit"
+  op.separator ""
+  op.separator "writes a yaml file <target>.'#{NORMAL_EXT}' which"
+  op.separator "has three keys: 'headers', 'filenames', and 'data'"
+  op.separator "    headers contains an array showing what is in the data"
+  op.separator "    filenames: (a hash with two keys holding an array of full path names)"
+  op.separator "      target:"
+  op.separator "      decoy:"
+  op.separator "    data: (an array with the data values)"
+  op.separator "headers:  <the headers of the hits>"
+  op.separator ""
+  op.separator "headers guaranteed to have at least: filename, query_title, charge, sequence, qvalue"
+  op.separator ""
+  op.on("-l", "--min-peptide-length <Int>", Integer, "min num aa's to accept (default: #{opt[:min_peptide_length]})") {|v| opt[:min_peptide_length] = v }
+  op.on("--z-together", "combines all charge states for precision calc") {|v| opt[:z_together] = v }
+  op.on("-o", "--outfile <name>", "write to specified file") {|v| opt[:outfile] = v }
+  op.on("-g", "--group-together", "process all forwards together and all decoys together", "will output to opt[:outfile] unless -o given") {|v| opt[:group_together] = v }
+  op.on("-f", "--find-decoy [ext]", "finds the decoy file, default <file>#{DEF_EXT}.<ext>", "obviating the need to specify it on the commandline") do |v| 
+    if v.is_a? String
+      opt[:find_decoy] = v
+    else
+      opt[:find_decoy] = DEF_EXT
+    end
+  end
+end
+
+opts.parse!
+
+if ARGV.size == 0
+  puts opts.to_s
+  exit
+end
+
+target_files = []
+decoy_files = []
+if opt[:find_decoy]
+  target_files = ARGV.to_a.dup
+  decoy_files = target_files.map do |tf|
+    ext = File.extname(tf)
+    basename = tf.chomp(ext)
+    decoy_file = basename + opt[:find_decoy] + ext
+    raise ArgumentError, "cannot find #{decoy_file}" unless File.exist?(decoy_file)
+    decoy_file
+  end
+else
+  ARGV.each_slice(2) do |target, decoy|
+    target_files << target
+    decoy_files << decoy
+  end
+end
+
+require 'ms/error_rate/qvalue/mascot'
+require 'ms/error_rate/qvalue/mascot/percolator'
+
+mascot_percolator = (File.extname(target_files.first) == '.datp')
+headers = Ms::ErrorRate::Qvalue::Mascot::MEMBERS.map(&:to_s)
+if opt[:group_together]
+  outfile = opt[:outfile]
+  if mascot_percolator
+    filenames = { 'target' => target_files, 'decoy' => decoy_files }
+    # in the case of mascot_percolator, the "target" files are .datp files and
+    # "decoy" files the .tab.txt files
+    target_hits = Ms::ErrorRate::Qvalue::Mascot::Percolator.qvalues( target_files, decoy_files, opt).sort_by(&:qvalue)
+  else
+    filenames = { 'target' => target_files, 'decoy' => decoy_files }
+    target_hits = Ms::ErrorRate::Qvalue::Mascot.qvalues(target_files, decoy_files, opt).sort_by(&:qvalue)
+  end
+  print_out(outfile, filenames, headers, target_hits)
+else
+  target_files.zip(decoy_files) do |target_file, decoy_file|
+    if mascot_percolator
+      filenames = { 'datp' => [target_file], 'tab_txt' => [decoy_file] }
+      target_hits = Ms::ErrorRate::Qvalue::Mascot::Percolator.qvalues([target_file], [decoy_file], opt).sort_by(&:qvalue)
+    else
+      filenames = { 'target' => [target_file], 'decoy' => [decoy_file] }
+      target_hits = Ms::ErrorRate::Qvalue::Mascot.qvalues([target_file], [decoy_file], opt).sort_by(&:qvalue)
+    end
+    base = target_file.chomp(File.extname(target_file))
+    outfile = base + '.' + NORMAL_EXT
+    print_out(outfile, filenames, headers, target_hits)
+  end
+end

data/spec/ms/error_rate/qvalue_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+require 'ms/error_rate/qvalue'
+
+Hit = Struct.new(:score, :charge)
+
+describe 'calculating q-values' do
+
+  before do
+    scores = [14,15,13,12,11]
+    qvals_expected = [0.5 ,0.0, 2.0/3.0, 3.0/4, 4.0/5]
+    @target_hits = scores.zip(Array.new(scores.size, 2)).map {|pair| Hit.new(*pair) } 
+    @decoy_hits = scores.zip(Array.new(scores.size, 2)).map {|pair| Hit.new(pair.first-0.5, pair.last) }
+    @qval_by_hit = {}
+    @target_hits.zip(qvals_expected) {|hit, qval|  @qval_by_hit[hit] = qval }
+  end
+
+  it 'can calculate qvalues on target deccoy sets' do
+    pairs = Ms::ErrorRate::Qvalue.target_decoy_qvalues(@target_hits, @decoy_hits)
+    pairs.each do |hit, qval|
+      @qval_by_hit[hit].should.be.close(qval, 0.00000001)
+    end
+  end
+  
+end

data/spec/ms/error_rate_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+require 'ms/error_rate'
+require 'ostruct'
+
+xdescribe 'not quite sure what this is' do
+
+  it 'calculates bayesian probabilities' do
+    # C = is a correct ID
+    # T = transmembrane content
+    # Y = cysteine content
+    # A = abundance
+    # p(C|T,Y,A) = p(T|C)p(Y|C)p(A|C)p(C) / p(T)p(Y)p(A)
+    peps.map do |pep|
+      # what is the probability of that un-transmembraneyness being correct?
+      # what is the probability of that un-cysteineness being correct?
+      # what is the probability of that high abundanceness being correct?
+      pep.bayes_probs.reduce(prob_being_correct) do |prob| 
+      end
+      p_correct = pep.prior_prob_correct
+      pep.not_transmembrane? * pep.not_cysteine? * pep.not_low_abundance?
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'spec/more'
+
+Bacon.summary_on_exit
+
+TESTFILES = File.dirname(__FILE__) + "/testfiles"

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: ms-error_rate
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 7
+  version: 0.0.7
+platform: ruby
+authors: 
+- John T. Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ms-core
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 2
+        version: 0.0.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ms-fasta
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 3
+        version: 0.2.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: spec-more
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: aids for creating and calculating error rates using target-decoy searches and sample validation.
+email: jtprince@gmail.com
+executables: 
+- error_rate
+- fasta_to_nuclear.rb
+- fasta_to_peptide_centric_db.rb
+- fasta_to_phobius.rb
+- generate_sbv_input_hashes.rb
+- mascot_pepxml_to_peptide_hit_qvalues.rb
+- phobius_to_nontransmembrane.rb
+- qvalues.rb
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- VERSION
+- LICENSE
+- README.rdoc
+- spec/ms/error_rate/qvalue_spec.rb
+- spec/ms/error_rate_spec.rb
+- spec/spec_helper.rb
+- bin/error_rate
+- bin/fasta_to_nuclear.rb
+- bin/fasta_to_peptide_centric_db.rb
+- bin/fasta_to_phobius.rb
+- bin/generate_sbv_input_hashes.rb
+- bin/mascot_pepxml_to_peptide_hit_qvalues.rb
+- bin/phobius_to_nontransmembrane.rb
+- bin/qvalues.rb
+has_rdoc: true
+homepage: http://jtprince.github.com/ms-error_rate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: mspire
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An mspire library for calculating error rates in MS/MS identifications (FDRs).
+test_files: 
+- spec/ms/error_rate/qvalue_spec.rb
+- spec/ms/error_rate_spec.rb
+- spec/spec_helper.rb