ms-quant 0.0.4 → 0.0.6

data/Rakefile

@@ -15,7 +15,7 @@ Jeweler::Tasks.new do |gem|
   # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
   #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
   #  gem.add_development_dependency 'rspec', '> 1.2.3'
-  gem.add_runtime_dependency 'ms-ident', ">= 0.0.19"
+  gem.add_runtime_dependency 'ms-ident', ">= 0.1.1"
   gem.add_development_dependency "spec-more", ">= 0"
   gem.add_development_dependency "jeweler", "~> 1.5.2"
   gem.add_development_dependency "rcov", ">= 0"

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.6

data/bin/peptide_hit_qvalues_to_spectral_counts_table.rb

@@ -1,29 +1,24 @@
 #!/usr/bin/env ruby
 
+require 'andand'
+require 'set'
+require 'ruport'
+
 require 'ms/ident/peptide_hit/qvalue'
-require 'ms/ident/protein_hit'
+require 'ms/ident/protein'
 require 'ms/ident/peptide/db'
 require 'ms/quant/spectral_counts'
+require 'ms/quant/protein_group_comparison'
+require 'ms/quant/qspec/protein_group_comparison'
 require 'ms/quant/qspec'
+require 'ms/quant/cmdline'
+
 
 require 'yaml'
 require 'tempfile'
 
 require 'trollop'
 
-# inverse from Tilo Sloboda (now in facets)
-
-class Hash
-  def inverse
-    i = Hash.new
-    self.each_pair do |k,v|
-      if (Array === v) ; v.each{ |x| i[x] = ( i.has_key?(x) ? [k,i[x]].flatten : k ) }
-      else ; i[v] = ( i.has_key?(v) ? [k,i[v]].flatten : k ) end
-    end ; i  
-  end
-end
-
-
 def putsv(*args)
   if $VERBOSE
     puts(*args) ; $stdout.flush
@@ -36,8 +31,48 @@ def basename(file)
   base
 end
 
+class Ruport::Data::Table
+  # returns self
+  def add_column_with_data(colname, array_of_data, opts={})
+    self.add_column(colname, opts)
+    self.data.zip(array_of_data) do |row, newval|
+      row[colname] = newval
+    end
+    self
+  end
+
+  # acceptable opts:
+  #
+  #     :header => an array of lines (each which will be commented out)
+  def to_tsv(file, opt={})
+    delimiter = "\t" 
+    File.open(file,'w') do |out|
+      opt[:header].each {|line| out.puts "# #{line}" } if opt[:header]
+      out.puts self.column_names.join(delimiter)
+      self.data.each do |row|
+        out.puts row.to_a.join(delimiter)
+      end
+      opt[:footer].each {|line| out.puts "# #{line}" } if opt[:footer]
+    end
+  end
+
+end
+
+def write_subset(sample_to_pephits, outfile="peptidecentric_subset.yml")
+  aaseqs_to_prots = {} 
+  sample_to_pephits.map(&:last).flatten(1).each do |pephit|
+    aaseqs_to_prots[pephit.aaseq] = pephit.proteins.map(&:id)
+  end
+  File.open(outfile,'w') do |out| 
+    aaseqs_to_prots.each do |k,v| 
+      out.puts(%Q{#{k}: #{v.join("\t") }}) 
+    end
+  end
+end
+
 
 outfile = "spectral_counts.tsv"
+pephits_outfile = "spectral_counts.pephits.tsv"
 delimiter = "\t"
 
 opts = Trollop::Parser.new do
@@ -53,6 +88,7 @@ psq is really .psq.tsv file
   opt :descriptions, "include descriptions of proteins, requires :fasta", :default => false
   opt :fasta, "the fasta file.  Required for :qspec and :descriptions", :type => String
   opt :outfile, "the to which file data are written", :default => outfile
+  opt :peptides, "also write peptide hits (to: #{pephits_outfile})", :default => false
   opt :verbose, "speak up", :default => false
   opt :count_type, "type of spectral counts (<spectral|aaseqcharge|aaseq>)", :default => 'spectral'
   opt :qspec_normalize, "normalize spectral counts per run", :default => false
@@ -78,29 +114,8 @@ raise ArgumentError, "need .yml file for peptide centric db" unless File.extname
 putsv "using: #{peptide_centric_db_file} as peptide centric db"
 
 # groupname => files
-condition_to_samplenames = {}
-samplename_to_filename = {}
-ARGV.each do |arg|
-  (condition, files) = 
-    if arg.include?('=')
-      (condition, filestring) = arg.split('=')
-      [condition, filestring.split(',')]
-    else
-      [basename(arg), [arg]]
-    end
-  reptag = ARGV.size
-  sample_to_file_pairs = files.each_with_index.map {|file,i| ["#{condition}-rep#{i+1}", file] }
-  sample_to_file_pairs.each {|name,file| samplename_to_filename[name] = file }
-  condition_to_samplenames[condition] = sample_to_file_pairs.map(&:first)
-end
-
 
-if $VERBOSE
-  puts "** condition: sample_names"
-  puts condition_to_samplenames.to_yaml
-  puts "** samplename: filename"
-  puts samplename_to_filename.to_yaml
-end
+(samplename_to_filename, condition_to_samplenames, samplename_to_condition) = Ms::Quant::Cmdline.args_to_hashes(ARGV)
 
 raise ArgumentError, "must have 2 conditions for qspec!" if opt[:qspec] && condition_to_samplenames.size != 2
 
@@ -108,144 +123,122 @@ samplenames = samplename_to_filename.keys
 
 class Ms::Ident::PeptideHit
   attr_accessor :experiment_name
+  attr_accessor :protein_groups
+end
+class Ms::Ident::Protein
+  attr_accessor :length
 end
+
+
 fdr_cutoff = opt[:fdr_percent] / 100
 
-start=Time.now
-
-ar_of_pephit_ars = Ms::Ident::Peptide::Db::IO.open(peptide_centric_db_file) do |peptide_to_proteins|
-  putsv "#{Time.now-start} seconds to read #{peptide_centric_db_file}"
-  samplename_to_filename.map do |sample, file|
-    peptide_hits = Ms::Ident::PeptideHit::Qvalue.from_file(file)
-    putsv "#{file}: #{peptide_hits.size} hits"
-    peptide_hits.select! do |hit|
-      if hit.qvalue <= fdr_cutoff
-        # update each peptide with its protein hits
-        prot_ids = peptide_to_proteins[hit.aaseq]
-        if prot_ids
-          hit.experiment_name = sample
-          hit.proteins = prot_ids
-        else ; false end
-      else
-        false
-      end
-    end
-    peptide_hits
-  end
+if opt[:qspec] || opt[:descriptions]
+  putsv "reading lengths and descriptions from #{opt[:fasta]}"
+  (id_to_length, id_to_desc) = Ms::Fasta.protein_lengths_and_descriptions(opt[:fasta])
 end
 
-if opt[:write_subset]
-  aaseqs_to_prots = {} 
-  ar_of_pephit_ars.flatten(1).each do |pephit|
-    aaseqs_to_prots[pephit.aaseq] = pephit.proteins
-  end
-  outfile = "peptidecentric_subset.yml"
-  puts "writing #{outfile} with #{aaseqs_to_prots.size} aaseq->protids"
-  File.open(outfile,'w') do |out| 
-    aaseqs_to_prots.each do |k,v| 
-      out.puts(%Q{#{k}: #{v.join("\t") }}) 
-    end
-  end
+samplename_to_peptidehits = samplename_to_filename.map do |sample, file|
+ [sample, Ms::Ident::PeptideHit::Qvalue.from_file(file).select {|hit| hit.qvalue <= fdr_cutoff }]
 end
 
-if $VERBOSE
-  samplenames.zip(ar_of_pephit_ars) do |samplename, pep_ar|
-    putsv "#{samplename}: #{pep_ar.size}"
+# update each peptide hit with protein hits and sample name:
+all_protein_hits = Hash.new {|h,id| h[id] = Ms::Ident::Protein.new(id) }
+Ms::Ident::Peptide::Db::IO.open(peptide_centric_db_file) do |peptide_to_proteins|
+  samplename_to_peptidehits.map do |sample, peptide_hits|
+    peptide_hits.each do |hit|
+      # update each peptide with its protein hits
+      protein_hits = peptide_to_proteins[hit.aaseq].map do |id| 
+        protein = all_protein_hits[id]
+        protein.length = id_to_length[id] if id_to_length
+        protein.description = id_to_desc[id] if id_to_desc
+        protein
+      end
+      hit.experiment_name = sample
+      # if there are protein hits, the peptide hit is selected 
+      hit.proteins = protein_hits
+    end
   end
 end
 
-all_peptide_hits = ar_of_pephit_ars.flatten(1)
+write_subset(samplename_to_peptidehits) if opt[:write_subset]
 
-# because peptide_hit#proteins yields id strings (which hash properly),
-# each protein group is an array of 
-protein_groups = Ms::Ident::ProteinGroup.peptide_hits_to_protein_groups(all_peptide_hits)
+samplename_to_peptidehits.each {|samplename, hits| putsv "#{samplename}: #{hits.size}" } if $VERBOSE
 
-pephit_to_protein_groups = Hash.new {|h,k| h[k] = [] }
-protein_groups.each do |protein_group|
-  protein_group.peptide_hits.each {|hit| pephit_to_protein_groups[hit] << protein_group }
-end
+all_peptide_hits = samplename_to_peptidehits.map(&:last).flatten(1)
 
-counts_parallel_to_names_with_counts_per_group = samplenames.map do |name|
-  pep_hit_to_prot_groups = Hash.new {|h,k| h[k] = [] }
-  groups_of_pephits = protein_groups.map do |prot_group|
-    pep_hits = prot_group.peptide_hits.select {|hit| hit.experiment_name == name }
-    pep_hits.each do |pep_hit|
-      pep_hit_to_prot_groups[pep_hit] << prot_group
-    end # returns the group of pep_hits
-  end
-  counts = Ms::Quant::SpectralCounts.counts(groups_of_pephits) do |pephit|
-    pephit_to_protein_groups[pephit].size
-  end
-end
+# this constricts everything down to a minimal set of protein groups that
+# explain the entire set of peptide hits.   
+update_pephits = true  # ensures that each pephit is linked to the array of protein groups it is associated with
+protein_groups = Ms::Ident::ProteinGroup.peptide_hits_to_protein_groups(all_peptide_hits, update_pephits)
 
-if opt[:qspec] || opt[:descriptions]
-  putsv "reading lengths and descriptions from #{opt[:fasta]}"
-  (id_to_length, id_to_desc) = Ms::Fasta.protein_lengths_and_descriptions(opt[:fasta])
+hits_table_hash = {}  # create the table using key => column hash
+samplenames.each do |name|
+  hits_table_hash[name] = protein_groups.map do |prot_group|
+    prot_group.peptide_hits.select {|hit| hit.experiment_name == name }
+  end
 end
 
-samplename_to_condition = condition_to_samplenames.inverse
+# The columns are filled with groups of peptide hits, one group of hits per
+# protein group (protein group order is implicit).  The rows are sample names.
+#
+#  (implied) sample1   sample2   sample3   ...
+#  (group1)  [hit,hit] [hit...]  [hit...]  ...
+#  (group2)  [hit,hit] [hit...]  [hit...]  ...
+#   ...         ...       ...       ...       ...
+hits_table = Ruport::Data::Table.new(:data => hits_table_hash.values.transpose, :column_names => hits_table_hash.keys)
 
-### OUTPUT TABLE
-header_cats = samplenames.map.to_a
+# spectral counts of type opt[:count_type]
+counts_data = hits_table.data.map do |row|
+  row.map do |pephits|
+    Ms::Quant::SpectralCounts.counts(pephits) {|pephit| 1.0 / pephit.protein_groups.size }.send(opt[:count_type])
+  end
+end
 
-ar_of_rows = counts_parallel_to_names_with_counts_per_group.map do |counts_per_group|
-  counts_per_group.map(&opt[:count_type])
-end.transpose
+# each cell holds a SpectralCounts object, which hash 3 types of count data
+counts_table = Ruport::Data::Table.new(:data => counts_data, :column_names => samplenames)
 
+# return a list of ProteinGroupComparisons
 if opt[:qspec]
-  all_conditions = samplenames.map {|sn| samplename_to_condition[sn] }
-  condition_to_count_array = all_conditions.zip(counts_parallel_to_names_with_counts_per_group).map do |condition, counts_par_groups|
-    [condition, counts_par_groups.map(&opt[:count_type])]
-  end
 
+  # prepare data for qspec
+  condition_to_count_array = counts_table.column_names.map {|name| [name, counts_table.column(name)] }
+  # average length of the proteins in the group
   name_length_pairs = protein_groups.map do |pg|
-    # prefer swissprot (sp) proteins over tremble (tr) and shorter protein
-    # lengths over longer lengths
-    best_guess_protein_id = pg.sort_by {|prot_id| [prot_id, -id_to_length[prot_id]] }.first
-    length = id_to_length[best_guess_protein_id]
-    [pg.join(":"), length]
+    [pg.join(":"), pg.map(&:length).reduce(:+)./(pg.size).round]
   end
 
-  putsv "qspec to normalize counts: #{opt[:qspec_normalize]}"
   qspec_results = Ms::Quant::Qspec.new(name_length_pairs, condition_to_count_array).run(opt[:qspec_normalize])
-
-  to_add = [:fdr, :bayes_factor, :fold_change]
-  header_cats.push(*to_add)
-  qspec_results.zip(ar_of_rows) do |zipped|
-    (result, row) = zipped
-    row.push(*to_add.map {|v| result.send(v) })
+  
+  cols_to_add = [:bayes_factor, :fold_change, :fdr]
+  counts_table.add_columns cols_to_add
+  counts_table.data.zip(qspec_results) do |row, qspec_result|
+    cols_to_add.each {|cat| row[cat] = qspec_result[cat] }
   end
 end
 
-header_cats.push( *%w(BestID AllIDs) )
-header_cats.push( 'Description' ) if opt[:descriptions]
+counts_table.add_columns( [:name, :ids, :description] )
+counts_table.data.zip(protein_groups) do |row, pg|
+  best_id = pg.sort_by {|prot| [prot.id, prot.length] }.first
+  row.name = best_id.description.andand.match(/ GN=([^\s]+) ?/).andand[1] || best_id.id
+  row.ids = pg.map(&:id).join(',')
+  row.description = best_id.description
+end
 
-sort_protein_id = 
-  if id_to_length
-    lambda {|prot_id| [prot_id, -id_to_length[prot_id]] }
-  else
-    lambda {|prot_id| prot_id }
-  end
 
-protein_groups.zip(ar_of_rows) do |zipped|
-  (pg, row) = zipped
-  # swiss-prot and then the shortest
-  best_protid = pg.sort_by(&sort_protein_id).first
-  (gene_id, desc) = 
-    if opt[:descriptions] 
-      desc = id_to_desc[best_protid] 
-      gene_id = (md=desc.match(/ GN=(\w+) ?/)) ? md[1] : best_protid
-      [gene_id, desc]
-    else
-      [best_protid, nil]
+if opt[:peptides]
+  hits_table.each do |record|
+    record.each_with_index do |hits,i|
+      new_cell = hits.group_by do |hit| 
+        [hit.aaseq, hit.charge]
+      end.map do |key, hits|
+        [key.reverse.join("_"), hits.map(&:id).join(',')].join(":")
+      end.join('; ')
+      record[i] = new_cell
     end
-  row << gene_id << pg.join(',')
-  row.push(desc) if desc
-end
-
-File.open(opt[:outfile],'w') do |out|
-  out.puts header_cats.join(delimiter) 
-  ar_of_rows.each {|row| out.puts row.join(delimiter) }
-  putsv "wrote: #{opt[:outfile]}"
+  end
+  hits_table.add_column_with_data(:name, counts_table.column(:name), :position=>0)
+  hits_table.to_tsv(pephits_outfile, :footer => ["parallel to #{outfile}"])
 end
 
+intro = ["samples: #{samplename_to_filename}", "options: #{opt}"]
+counts_table.to_tsv(outfile, :footer => intro)

data/lib/hash/inverse.rb

@@ -0,0 +1,15 @@
+
+
+# inverse from Tilo Sloboda (now in facets)
+
+class Hash
+  def inverse
+    i = Hash.new
+    self.each_pair do |k,v|
+      if (Array === v) ; v.each{ |x| i[x] = ( i.has_key?(x) ? [k,i[x]].flatten : k ) }
+      else ; i[v] = ( i.has_key?(v) ? [k,i[v]].flatten : k ) end
+    end ; i  
+  end
+end
+
+

data/lib/ms/quant/cmdline.rb

@@ -0,0 +1,42 @@
+require 'hash/inverse'
+
+module Ms ; module Quant ; end ; end
+
+module Ms::Quant::Cmdline
+
+  # expects arguments in one of two forms.  The first form is grouped by
+  # condition as shown:
+  #
+  #     condition1=file1,file2,file3... condition2=file4,file5...
+  #
+  # The second is where each file is its own condition (1 replicate):
+  #
+  #     file1 file2 file3
+  #
+  # Returns three ordered hashes (only ordered for ruby 1.9): 
+  #
+  #     1) Condition to an array of samplenames
+  #     2) Samplename to the filename  
+  #     3) Samplename to condition
+  def self.args_to_hashes(args, replicate_postfix="-rep")
+    # groupname => files
+    condition_to_samplenames = {}
+    samplename_to_filename = {}
+    args.each do |arg|
+      (condition, files) = 
+        if arg.include?('=')
+          (condition, filestring) = arg.split('=')
+          [condition, filestring.split(',')]
+        else
+          [basename(arg), [arg]]
+        end
+      sample_to_file_pairs = files.each_with_index.map do |file,i| 
+        rep_string = (files.size == 1) ? "" : "#{replicate_postfix}#{i+1}"
+        ["#{condition}#{rep_string}", file] 
+      end
+      sample_to_file_pairs.each {|name,file| samplename_to_filename[name] = file }
+      condition_to_samplenames[condition] = sample_to_file_pairs.map(&:first)
+    end
+    [samplename_to_filename, condition_to_samplenames, condition_to_samplenames.inverse]
+  end
+end

data/lib/ms/quant/peptide.rb

@@ -0,0 +1,2 @@
+
+Peptide

data/lib/ms/quant/protein_group_comparison.rb

@@ -0,0 +1,29 @@
+
+module Ms
+  module Quant
+  end
+end
+
+module Ms::Quant::ProteinGroupComparison
+
+  # a protein group object
+  attr_accessor :protein_group
+
+  # an array of experiment names
+  attr_accessor :experiments
+
+  # parallel array to experiments with the measured values
+  attr_accessor :values
+
+  def initialize(protein_group, experiments, values)
+    (@protein_group, @experiment, @values) = protein_group, experiments, values
+  end
+end
+
+class Ms::Quant::ProteinGroupComparison::SpectralCounts
+  include Ms::Quant::ProteinGroupComparison
+end
+
+class Ms::Quant::ProteinGroupComparison::UniqAAzCounts
+  include Ms::Quant::ProteinGroupComparison
+end

data/lib/ms/quant/qspec/protein_group_comparison.rb

@@ -0,0 +1,22 @@
+require 'ms/quant/protein_group_comparison'
+
+module Ms
+  module Quant
+    module ProteinGroupComparison
+    end
+  end
+end
+
+class Ms::Quant::ProteinGroupComparison::Qspec
+  include Ms::Quant::ProteinGroupComparison
+
+  attr_accessor :qspec_results_struct
+
+  # takes a protein group object, an array of experiment names and a qspec
+  # results struct
+  def initialize(protein_group, experiments, qspec_results_struct)
+    super(protein_group, experiments, qspec_results_struct.counts_array)
+    @qspec_results_struct = qspec_results_struct
+  end
+end
+

data/lib/ms/quant/qspec.rb

@@ -31,6 +31,7 @@ class Ms::Quant::Qspec
     start_bayes = headers.index {|v| v =~ /BayesFactor/i }
     rows.map do |row| 
       data = [row[0]]
+      data.push( row[1...start_bayes].map(&:to_f) )
       data.push( *row[start_bayes,4].map(&:to_f) )
       data.push( row[start_bayes+4] )
       Results.new(*data)
@@ -68,6 +69,8 @@ class Ms::Quant::Qspec
     end
   end
 
+  # returns an array of Qspec::Results objects (each object can be considered
+  # a row of data)
   def run(normalize=true, opts={})
     puts "normalize: #{normalize}" if $VERBOSE
     tfile = Tempfile.new("qspec")
@@ -87,6 +90,7 @@ class Ms::Quant::Qspec
   end
 
   # for version 2 of QSpec
-  Results = Struct.new(:protid, :bayes_factor, :fold_change, :rb_stat, :fdr, :flag)
+  # counts array is parallel to the experiment names passed in originally
+  Results = Struct.new(:protid, :counts_array, :bayes_factor, :fold_change, :rb_stat, :fdr, :flag)
 end
 

data/lib/ms/quant/spectral_counts.rb

@@ -8,28 +8,28 @@ module Ms
 
       # returns a parallel array of Count objects.  If split_hits then counts
       # are split between groups sharing the hit.  peptide_hits must respond
-      # to :charge and :aaseq.  If split_hits, then each peptide_hit must
-      # respond to :linked_to yielding an object with a :size reflective of
-      # the number of shared peptide_hits.
-      def self.counts(groups_of_peptide_hits, &share_the_pephit)
-        groups_of_peptide_hits.map do |peptide_hits|
-          uniq_aaseq = {}
-          uniq_aaseq_charge = {}
-          linked_sizes = peptide_hits.map do |hit|
-            linked_to_size = share_the_pephit ? share_the_pephit.call(hit) : 1
-            # these guys will end up clobbering themselves, but the
-            # linked_to_size should be consistent if the key is the same
-            uniq_aaseq_charge[[hit.aaseq, hit.charge]] = linked_to_size
-            uniq_aaseq[hit.aaseq] = linked_to_size
-            linked_to_size
-          end
-          counts_data = [linked_sizes, uniq_aaseq_charge.values, uniq_aaseq.values].map do |array|
-            share_the_pephit ?  array.inject(0.0) {|sum,size| sum+=(1.0/size) } : array.size
-          end
-          Counts.new(*counts_data)
+      # to :charge and :aaseq.  If a block is given, the weight of a
+      # particular hit can be given (typically this will be 1/#proteins
+      # sharing the hit
+      def self.counts(peptide_hits, &share_the_pephit)
+        uniq_aaseq = {}
+        uniq_aaseq_charge = {}
+        weights = peptide_hits.map do |hit|
+          weight = share_the_pephit ? share_the_pephit.call(hit) : 1
+          # these guys will end up clobbering themselves, but the
+          # linked_to_size should be consistent if the key is the same
+          uniq_aaseq_charge[[hit.aaseq, hit.charge]] = weight
+          uniq_aaseq[hit.aaseq] = weight
+          weight
         end
+        counts_data = [weights, uniq_aaseq_charge.values, uniq_aaseq.values].map do |array|
+          array.reduce(:+)
+        end
+        Counts.new(*counts_data)
       end
-
     end
   end
 end
+
+
+

data/spec/ms/quant/spectral_counts_spec.rb

@@ -2,8 +2,6 @@ require 'spec_helper'
 
 require 'ms/quant/spectral_counts'
 
-
-
 PeptideHit = Struct.new(:aaseq, :charge, :proteins) do
   def initialize(*args)
     super(*args)
@@ -58,7 +56,7 @@ describe 'groups of peptide hits' do
 
   it 'finds spectral counts (splitting counts between shared)' do
     groups_of_pephits = @prot_hits.map(&:peptide_hits)
-    counts = Ms::Quant::SpectralCounts.counts(groups_of_pephits) {|pephit| pephit.proteins.size }
+    counts = Ms::Quant::SpectralCounts.counts(groups_of_pephits) {|pephit| 1.0 / pephit.proteins.size }
     @expected_counts_split.zip(counts) do |exp, act|
       exp.zip(act) {|e,a| a.should.be.close e, 0.0001 }
     end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: ms-quant
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 4
-  version: 0.0.4
+  prerelease: 
+  version: 0.0.6
 platform: ruby
 authors: 
 - John T. Prince
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-04 00:00:00 -06:00
+date: 2011-04-26 00:00:00 -06:00
 default_executable: peptide_hit_qvalues_to_spectral_counts_table.rb
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,11 +21,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 0
-        - 19
-        version: 0.0.19
+        version: 0.1.1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -40,8 +32,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id002
@@ -53,10 +43,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 5
-        - 2
         version: 1.5.2
   type: :development
   version_requirements: *id003
@@ -68,8 +54,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id004
@@ -89,8 +73,13 @@ files:
 - Rakefile
 - VERSION
 - bin/peptide_hit_qvalues_to_spectral_counts_table.rb
+- lib/hash/inverse.rb
 - lib/ms-quant.rb
+- lib/ms/quant/cmdline.rb
+- lib/ms/quant/peptide.rb
+- lib/ms/quant/protein_group_comparison.rb
 - lib/ms/quant/qspec.rb
+- lib/ms/quant/qspec/protein_group_comparison.rb
 - lib/ms/quant/spectral_counts.rb
 - spec/ms/quant/spectral_counts_spec.rb
 - spec/spec_helper.rb
@@ -108,21 +97,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   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: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: quantitation of mass spectrometry datasets (proteomic, metabolomic/lipidomic)