ms-mascot 0.2.0 → 0.2.2

data/History

@@ -1,4 +1,14 @@
-== 0.12.2 / 2009-02-23
+== 0.2.2 / 2009-03-31
+
+* updates to use latest tap
+* ms-mascot now uses tap-mechanize instead of tap-http
+* development of dat support
+
+== 0.2.1 / 2009-02-26
+
+* Further development of .dat support
+
+== 0.2.0 / 2009-02-23
 
 Updated release utilizing Tap.
 

data/lib/ms/mascot.rb

@@ -1,5 +1,8 @@
+require 'ms/mascot/dat'
+require 'ms/mascot/mgf'
+
 module Ms
   module Mascot
     FRAGMENT_TEST_MASS_UNCERTAINTY = 10**-2
   end
-end
+end

data/lib/ms/mascot/dat/archive.rb

@@ -21,6 +21,9 @@ module Ms
       
       # Provides access to a Mascot dat file.
       class Archive < ExternalArchive
+        include Dat
+
+        # Parsing & Archive functions
         module Utils
           module_function
           
@@ -109,6 +112,8 @@ module Ms
           reindex_by_sep(boundary, 
             :entry_follows_sep => true, 
             :exclude_sep => true,
+            # :blksize => 8388608,  # default in ExternalArchive
+            :blksize => 33_554_432,  # quadrupled the blksize
           &block)
 
           # remove the first and last entries, which contain
@@ -124,7 +129,7 @@ module Ms
         # which should be present at the start of the string.
         def str_to_entry(str)
           if ctc = content_type_class(parse_content_type(str))
-            ctc.parse(str)
+            ctc.parse(str, self)
           else
             str
           end
@@ -163,12 +168,19 @@ module Ms
           @section_names[index] ||= parse_section_name(index)
         end
         
-        def each_query(&block)
-          section('index').queries.each do |key|
-            block.call( self.section(key) )
+        # Returns the number of queries registered in self.
+        def nqueries
+          @nqueries ||= section_names.select {|name| name =~ /query/ }.length
+        end
+        
+        # Yields each query to the block.
+        def each_query
+          1.upto(nqueries) do |n|
+            yield(query(n))
           end
         end
 
+        # Returns the specified query. 
         def query(num)
           if si = section_index("query#{num}")
             self[si]
@@ -177,6 +189,70 @@ module Ms
           end
         end
 
+        # by default, yields the top PeptideHit object per query
+        # opts may be:
+        #     :by => :top
+        #       :top     top ranked hit (default)
+        #       :groups  an array of hits
+        #       :all     each peptide hit (all ranks)
+        #
+        #     :yield_nil => true 
+        #       true     returns nil when a query had no peptide hit (default)
+        #       false    this hit (or group) is not yielded
+        #     :with_query => false
+        #       false    just returns peptide hits/groups (default) 
+        #       true     yields the peptide_hit/group and associated query
+        def each_peptide_hit(opts={})
+          defaults = { :by => :top, :yield_nil => true, :with_query => false }
+          (by, yield_nil, with_query) = defaults.merge(opts).values_at(:by, :yield_nil, :with_query)
+
+          peptides = section('peptides')
+          1.upto(nqueries) do |n|
+            case by
+            when :top
+              hit = peptides.peptide_hit(n)
+              unless !yield_nil && hit.nil?
+                if with_query
+                  yield hit, query(n)
+                else
+                  yield hit
+                end
+              end
+            when :groups
+              group = peptides.peptide_hits(n)
+              group.shift # remove the 0 index
+              unless !yield_nil && group.first.nil?
+                if with_query
+                  yield group, query(n)
+                else
+                  yield group
+                end
+              end
+            when :all
+
+              group = peptides.peptide_hits(n)
+              group.shift # remove the 0 index
+              unless !yield_nil && group.first.nil?
+                # need to return the nil hit if we are yielding nils:
+                if group.first.nil?
+                  if with_query
+                    yield nil, query(n)
+                  else
+                    yield nil
+                  end
+                end
+                group.each do |pep_hit|
+                  if with_query
+                    yield pep_hit, query(n)
+                  else
+                    yield pep_hit
+                  end
+                end
+              end
+            end
+          end
+        end
+        
         private
         
         # resolves each section
@@ -192,7 +268,8 @@ module Ms
           io.pos = index[0] + 1
           parse_content_type(io.readline)[:section_name]
         end
-      end
-    end
-  end
-end
+
+      end # Archive
+    end  # Dat
+  end  # Mascot
+end  # Ms

data/lib/ms/mascot/dat/header.rb

@@ -1,4 +1,16 @@
 require 'ms/mascot/dat/section'
 
+# Header contains information describing the search environment, especially
+# features of the search database, but also search statistics, like exec_time.
+#
+#   Content-Type: application/x-Mascot; name="header"
+#   
+#   sequences=257964
+#   sequences_after_tax=257964
+#   residues=93947433
+#   ...
+#
+# Header is a standard Section and simply defines methods for convenient
+# access.  See Section for parsing details.
 class Ms::Mascot::Dat::Header < Ms::Mascot::Dat::Section
 end

data/lib/ms/mascot/dat/index.rb

@@ -1,23 +1,17 @@
 require 'ms/mascot/dat/section'
 
+# Index maps section names to the line at which the multipart break (ex
+# '--gc0p4Jq0M2Yt08jU534c0p') occurs.  Achive creates it's own index and
+# does not make use of this section.
+#
+#   Content-Type: application/x-Mascot; name="index"
+#   
+#   parameters=4
+#   masses=78
+#   unimod=117
+#   ...
+#
+# Index is a standard Section and simply defines methods for convenient
+# access.  See Section for parsing details.
 class Ms::Mascot::Dat::Index < Ms::Mascot::Dat::Section
-  
-  def nqueries
-    @nqueries ||= data.keys.select {|key| key =~ /query/ }.length
-  end
-
-
-  def query(index)
-    query_key = "query#{index}"
-    data.each_pair do |key, value|
-      return value if key == query_key
-    end
-    nil
-  end
-
-  # returns all query sections
-  def queries
-    data.keys.grep( /^query(\d+)$/o ).sort
-  end
-
 end

data/lib/ms/mascot/dat/masses.rb

@@ -1,4 +1,18 @@
 require 'ms/mascot/dat/section'
 
+# Masses contains the masses of elements, residues, particles (like 'Electron')
+# and the delta masses for modifications used in an identification, including
+# the mass of various neutral losses.
+#
+#   Content-Type: application/x-Mascot; name="masses"
+#   
+#   A=71.037114
+#   B=114.534940
+#   C=103.009185
+#   D=115.026943
+#   ...
+#
+# Masses is a standard Section and simply defines methods for convenient
+# access.  See Section for parsing details.
 class Ms::Mascot::Dat::Masses < Ms::Mascot::Dat::Section
 end

data/lib/ms/mascot/dat/parameters.rb

@@ -1,4 +1,18 @@
 require 'ms/mascot/dat/section'
 
+# Parameters represents search parameters in a Dat file.  This section appears
+# to be a direct dump of the multipart data created by a Mascot search form.
+#
+#   Content-Type: application/x-Mascot; name="parameters"
+#
+#   LICENSE=Licensed to: Matrix Science Internal use only - Frill, (4 processors).
+#   MP=
+#   NM=
+#   COM=MS/MS Example
+#   IATOL=
+#   ...
+#
+# Parameters is a standard Section and simply defines methods for convenient
+# access.  See Section for parsing details.
 class Ms::Mascot::Dat::Parameters < Ms::Mascot::Dat::Section
 end

data/lib/ms/mascot/dat/peptides.rb

@@ -1,4 +1,213 @@
 require 'ms/mascot/dat/section'
 
-class Ms::Mascot::Dat::Peptides < Ms::Mascot::Dat::Section
-end
+module Ms::Mascot::Dat
+  
+  # Peptides represent peptide identification information in a dat file.
+  #
+  #   Content-Type: application/x-Mascot; name="peptides"
+  #   
+  #   q1_p1=-1
+  #   q2_p1=0,499.300598,-0.051862,2,LAVPT,10,0000000,3.87,0001002000000000000,0,0;"Y1319_MYCTU":0:531:535:1,"Y1353_MYCBO":0:531:535:1
+  #   q2_p1_terms=R,-:R,-
+  #   q2_p2=0,499.300598,-0.051862,2,LAVTP,10,0000000,3.87,0001002000000000000,0,0;"RLPA_RICCN":0:316:320:1
+  #   q2_p2_terms=K,-
+  #   q2_p3=0,499.336990,-0.088254,2,LAVVV,10,0000000,3.87,0001002000000000000,0,0;"DYNA_NEUCR":0:1296:1300:1
+  #   q2_p3_terms=R,-
+  #
+  # Peptides is a standard Section and simply defines methods for convenient
+  # access.  See Section for parsing details.
+  #
+  # === Interpretation
+  #
+  # Deciphering the peptide information requires some cross-referencing with
+  # online results.  Note that a single query can match multiple peptides.
+  #
+  #   qN_pM=-1                         # no matches
+  #   qN_pM=peptide;protein_maps       # query N peptide hit M
+  #   qN_pM_terms=A,B:C,D              # n and c-termini residues for each protein match
+  #
+  # See the Peptide and ProteinMap structures for interpretation of the
+  # specific query data.
+  class Peptides < Ms::Mascot::Dat::Section
+    
+    # === PeptideHit
+    #
+    # Represents peptide hit data, infered by inspection of the MS/MS sample
+    # results, esp {F981123.dat}[http://www.matrixscience.com/cgi/peptide_view.pl?file=../data/F981123.dat&query=2&hit=1&index=&px=1&section=5&ave_thresh=38].
+    #   
+    #   # str: 0,499.300598,-0.051862,2,LAVPT,10,0000000,3.87,0001002000000000000,0,0
+    # 
+    #   index  example              meaning
+    #   0      0                    n Missed Cleavages
+    #   1      499.300598           Monoisotopic mass of neutral peptide Mr(calc)
+    #   2      -0.051862            actual - theoretical delta mass
+    #   3      2
+    #   4      LAVPT                matched sequence
+    #   5      10
+    #   6      0000000              modification sites (including n,c residues; number indicates mod)
+    #   7      3.87                 peptide score
+    #   8      0001002000000000000
+    #   9      0
+    #   10     0
+    #
+    # The dat file is said to be generate by Mascot version 1.0, but the headers
+    # section records 2.1.119.
+    #
+    # ==== Modification Sequence
+    #
+    # The modification sequence indicates which residues are modified and includes
+    # the n and c-terminal residues. The index at each location indicates the
+    # modification used (0 indicates no modification).
+    #
+    # ==== Unaccounted for data
+    #
+    # Peptide data known to exist in the dat file:
+    #
+    #   Homology threshold
+    #   Identity threshold
+    #   Frame number
+    #   Number of fragment ion matches
+    #   Experimental charge
+    #
+    PeptideHit = Struct.new( 
+      :n_missed_cleavages,
+      :peptide_mass,
+      :delta_mass,
+      :unknown3,
+      :sequence,
+      :unknown5,
+      :modifications,
+      :score,
+      :unknown8,
+      :unknown9,
+      :unknown10,
+      :protein_maps,
+      :hit_num,
+      :query_num
+    )
+
+    # Indicies of PeptideHit terms that will be cast to floats.
+    PeptideHitFloatIndicies = [1,2,7]
+    
+    # Indicies of PeptideHit terms that will be cast to integers.
+    PeptideHitIntIndicies = [0,3,5,9,10]
+    
+    # === ProteinMap
+    #
+    # Represents a protein map, indicating which proteins contain the
+    # identified peptide.  There may be many for a given peptide hit
+    #
+    #   # str:   "Y1319_MYCTU":0:531:535:1,"Y1353_MYCBO":0:531:535:1
+    #   # terms: R,-:R,-
+    #
+    #   index  example              meaning
+    #   0      "Y1319_MYCTU"        matching protein id
+    #   1      0
+    #   2      531                  peptide start index
+    #   3      535                  peptide end index
+    #   4      1
+    #   5      R                    nterm
+    #   6      -                    cterm
+    #
+    ProteinMap = Struct.new(
+      :id,
+      :uknown1,
+      :peptide_start,
+      :peptide_end,
+      :unknown4,
+      :nterm,
+      :cterm
+    )
+    
+    # Indicies of ProteinMap terms that will be cast to integers.
+    ProteinMapIntIndicies = [1,2,3,4]
+    
+    module Utils
+      module_function
+      
+      # Parses a PeptideHit from the query-hit string.
+      def parse_peptide_hit(str, terms)
+        return nil if str == nil || str == "-1"
+        
+        peptide_data, protein_maps = str.split(";", 2)
+        protein_maps = protein_maps.split(",")
+        terms = terms.split(":")
+        
+        # parse peptide data
+        peptide_data = peptide_data.split(",")
+        
+        PeptideHitFloatIndicies.each do |index|
+          peptide_data[index] = peptide_data[index].to_f
+        end
+        
+        PeptideHitIntIndicies.each do |index|
+          peptide_data[index] = peptide_data[index].to_i
+        end
+
+        # parse protein_map data
+        protein_maps = protein_maps.zip(terms).collect do |map_data, terms|
+          data = map_data.split(":") + terms.split(',')
+          
+          # removes quotes from protein id
+          data[0] = data[0][1...-1]
+          
+          ProteinMapIntIndicies.each {|index| data[index] = data[index].to_i }
+          ProteinMap.new(*data)
+        end
+        
+        peptide_data << protein_maps
+        PeptideHit.new(*peptide_data)
+      end
+    end
+    
+    include Utils
+    
+    def initialize(data={}, section_name=self.class.section_name, dat=nil)
+      super(data, section_name, dat)
+      @queries = []
+    end
+    
+    # An array of peptides hits per query.  Specify resolve=false to return
+    # the currently parsed queries.
+    #
+    # Note that the queries array is indexed the same as in Mascot, ie the 
+    # PeptideHit for q1_p1 is located at queries[1][1], meaning there is
+    # always an empty cell at queries[0].
+    def queries(resolve=true)
+      return @queries unless resolve
+      
+      query = 1
+      query += 1 while peptide_hits(query)
+      @queries
+    end
+    
+    # Returns an array of PeptideHits for the specified query, or nil if no
+    # such query exists.
+    def peptide_hits(query)
+      hit = 1
+      hit += 1 while peptide_hit(query, hit)
+      @queries[query]
+    end
+    
+    # Returns the PeptideHit at the query and hit index, or nil if no such hit
+    # exists.
+    def peptide_hit(query, hit=1)
+      key = "q#{query}_p#{hit}"
+      return nil unless data.has_key?(key)
+      
+      hits = @queries[query] ||= []
+      if existing_hit = hits[hit]
+        return existing_hit
+      end
+      
+      if parsed_hit = parse_peptide_hit(data[key], data["#{key}_terms"])
+        parsed_hit.query_num = query
+        parsed_hit.hit_num = hit
+        hits[hit] = parsed_hit
+        return parsed_hit
+      end
+      
+      nil
+    end
+  end
+end