mascot-dat 0.2.1 → 0.3.0

data/lib/mascot/dat.rb

@@ -87,7 +87,7 @@ module Mascot
 
     # Parse the enzyme information from the DAT file
     #
-    # @return [[Mascot::DAT::Enzyme]]
+    # @return [Array<Mascot::DAT::Enzyme>]
     def enzyme
       @enzyme ||= Mascot::DAT::Enzyme.new(self.read_section(:enzyme))
     end
@@ -110,13 +110,27 @@ module Mascot
     end
 
     # Puts the IO cursor at the beginning of peptide result section. Returns an iterator/parser for PSM results
-    # @return [Mascot::DAT::Peptides]
+    #
+    # @param cache_psm_index Whether to cache the positions of the PSMs. If you just want to iterate
+    #                        through PSMs, you do not need to cache the index.
+    # @return [Mascot::DAT::Peptides, NilClass]
     def peptides(cache_psm_index=true)
-      Mascot::DAT::Peptides.new(self.dat_file, self.idx[:peptides], cache_psm_index)
+      Mascot::DAT::Peptides.new(self, :peptides, cache_psm_index)
     end
 
+    # If the DAT file has a decoy section, puts the IO cursor at the beginning of decoy_peptide
+    # result section and returns an iterator/parser for the decoy PSM results.
+    # If no decoy section exists, it will return nil.
+    #
+    # @param cache_psm_index Whether to cache the positions of the PSMs. If you just want to iterate
+    #                        through PSMs, you do not need to cache the index.
+    # @return [Mascot::DAT::Peptides, NilClass]
     def decoy_peptides(cache_psm_index=true)
-      Mascot::DAT::Peptides.new(self.dat_file, self.idx[:decoy_peptides], cache_psm_index)
+      if @idx.has_key? :decoy_peptides
+        Mascot::DAT::Peptides.new(self,:decoy_peptides, cache_psm_index)
+      else
+        nil
+      end
     end
 
 

data/lib/mascot/dat/peptides.rb

@@ -1,127 +1,118 @@
 require 'csv'
 module Mascot
   class DAT
-    # A parser for the peptide spectrum match results of a Mascot DAT file.
+    # A iterator for the peptide spectrum match results of a Mascot DAT file.
     # As opposed to the other sections of a DAT file, you don't really want to
-    # access this section as one big chunk in memory. It is often quite large and
-    # needs to be accessed using Enumerable methods.
-    #
-    # From the Mascot documentation, the following represents a reasonably complete PSM
-    #     q1_p1_db=01  # two digit integer of the search DB index, zero filled and retarded.
-    #     q1_p1=missed cleavages, (–1 indicates no match)
-    #           peptide Mr,
-    #           delta,
-    #           number of ions matched,
-    #           peptide string,
-    #           peaks used from Ions1,
-    #           variable modifications string,
-    #           ions score,
-    #           ion series found,
-    #           peaks used from Ions2,
-    #           peaks used from Ions3;
-    #           “accession string”:frame number:start:end:multiplicity, # data for first protein
-    #           “accession string”:frame number:start:end:multiplicity, # data for second protein, etc.
-    #     q1_p1_et_mods=modification mass,
-    #                   neutral loss mass,
-    #                   modification description
-    #     q1_p1_primary_nl=neutral loss string
-    #     q1_p1_drange=startPos:endPos
-    #     q1_p1_terms=residue,residue:residue,residue # flanking AA for each protien, in order
-    #
+    # access this section in memory at once. It is often quite large and
+    # needs to be accessed using the provided Enumerable or random access methods.
     class Peptides
       include Enumerable
-      # A hash of the index positions for the peptide PSM matches.
-      # Keys arr
-      attr_reader :psmidx, :byteoffset, :endbytepos
+      # A nested Hash index of the byte offset positions for the peptide-spectrum-match entries.
+      # The keys of the index are the query and peptide rank (Fixnum), the structure of which is:
+      #    { query_number => { peptide_rank => byte_position } }
+      # To access a particular entry, it is better to use the {#psm} method.
+      # @return [Hash{ Fixnum => Hash{ Fixnum => Fixnum }}] The nested hash of query peptide match byte offsets
+      attr_reader :psmidx
 
-      # To create a peptides enumerable, you need to pass in the dat file handle and
-      # the byte offset of the peptides section.
-      def initialize(dat_file, byteoffset, cache_psm_index=true)
-        @byteoffset = byteoffset
-        @endbytepos = nil
-
-        @file = dat_file
-
-        @file.pos = @byteoffset
+      # @param dat [Mascot::DAT] Source DAT file
+      # @param section_label [Symbol] Section header, one of :peptides or :decoy_peptides
+      # @param cache_psm_index [Boolean] Whether to cache the PSM index
+      def initialize(dat, section_label, cache_psm_index=true)
+        # create our own filehandle, since other operations may interfere with the
+        @dat = Mascot::DAT.open(dat.dat_file.path)
+        @filehandle = @dat.dat_file
+        @section_label = section_label
+        self.rewind
         @curr_psm = [1,1]
-        @psmidx = []
-        @cache_psm_index = cache_psm_index
-        index_psm_positions()
-      end
-
-      def index_psm_positions
-        # create an in-memroy index of PSM byteoffsets
-        q,p  = 0
-        @boundary_line = @file.readline
-        @boundary   = Regexp.new(@boundary_line)
-        @file.each do |line|
-          break if line =~ @boundary
-          if @cache_psm_index
-            line =~ /q(\d+)_p(\d+)/
-            i,j = $1.to_i, $2.to_i
-            next if q == i && p == j
-            unless @psmidx[i].kind_of? Array
-              q = i
-              @psmidx[q] = []
-            end
-            @psmidx[i][j] = @file.pos - line.length
-            q,p = i,j
-          end
+        @psmidx = {}
+        @endbytepos = Float::INFINITY
+        if cache_psm_index
+          index_psm_positions()
         end
-        @endbytepos = @file.pos - @boundary_line.length
-        rewind
       end
 
+      # Rewind the cursor to the start of the peptides section (e.g. q1_p1=...)
       def rewind
-        @file.pos = @byteoffset + @boundary_line.length
+        @dat.goto(@section_label)
+        1.upto(2) { @filehandle.readline }
       end
 
       # Return a specific {Mascot::DAT::PSM} identified for query <code>q</code> and peptide number <code>p</code>
-      # @param q Fixnum
-      # @param p Fixnum
-      # @return Mascot::DAT::PSM
-      def psm q,p
-        @file.pos  =  @psmidx[q][p]
-        next_psm
+      # @param query_number [Fixnum]
+      # @param rank [Fixnum]
+      # @return [Mascot::DAT::PSM]
+      # @raise [Exception] if given an invalid q,p coordinate
+      # @example my_dat.peptides.psm(1,1) # => Mascot::DAT::PSM for query 1 peptide 1
+      def psm query_number,rank
+        if @psmidx[query_number] and @psmidx[query_number][rank]
+          @filehandle.pos  =  @psmidx[query_number][rank]
+          next_psm
+        else
+          raise Exception.new "Invalid PSM specification (#{q},#{p})"
+        end
       end
 
       # Returns the next {Mascot::DAT::PSM} from the DAT file. If there is no other PSM, then it returns nil.
-      # @return Mascot::DAT::PSM
+      # @return [Mascot::DAT::PSM, NilClass]
       def next_psm
-        return nil if @file.pos >= @endbytepos
+        if @filehandle.pos >= @endbytepos
+          return nil
+        end
         # get the initial values for query & rank
-        tmp = []
-        tmp << @file.readline.chomp
-        k,v = tmp[0].split "="
-        # skip when there are no peptides (value equals -1)
-        return nil if v == "-1"
-
-        tmp[0] =~ /q(\d+)_p(\d+)/
-        q = $1
-        p = $2
-
-        tmp_pos = @file.pos
-        @file.each do |l|
-          break if l =~ @boundary
+        buffer = [@filehandle.readline.chomp]
+        buffer[0] =~ /q(\d+)_p(\d+)/
+        q,p = $1, $2
+        @curr_psm = [q,p]
+        prev_pos = @filehandle.pos
+        @filehandle.each do |l|
+          l.chomp!
+          # break if we have reached the boundary
+          if l =~ @boundary
+            @endbytepos = @filehandle.pos - @dat.boundary_string.length
+            break
+          end
+          # break if we are on another PSM
           break unless l =~ /^q#{q}_p#{p}/
-          tmp << l.chomp
-          tmp_pos = @file.pos
+          buffer << l
+          prev_pos = @filehandle.pos
         end
-        @file.pos = tmp_pos
-
-        Mascot::DAT::PSM.parse(tmp)
+        # rewind the cursor to the last hit
+        @filehandle.pos = prev_pos
+        # return the new PSM
+        Mascot::DAT::PSM.new(buffer)
       end
 
       # Iterate through all of the {Mascot::DAT::PSM} entries in the DAT file.
-      # @return Enumerator
+      # @yield [Mascot::DAT::PSM]
       def each
-        @file.pos = @byteoffset
-        while @file.pos < @endbytepos
-          psm = next_psm()
-          next if psm.nil?
+        self.rewind
+        while psm = self.next_psm
           yield psm
         end
       end
+
+      private
+      # Index the byte offsets of the PSMs
+      # @private
+      def index_psm_positions
+        # create an in-memroy index of PSM byteoffsets
+        q,p  = 0,0
+        # move the cursor past the boundary line
+        @filehandle.readline
+        @filehandle.each do |line|
+          break if line =~ @dat.boundary
+          line =~ /q(\d+)_p(\d+)/
+          qq,pp= $1.to_i, $2.to_i
+          next if q == qq && p == pp
+          q,p = qq,pp
+          unless @psmidx.has_key?(q)
+            @psmidx[q] = {}
+          end
+          @psmidx[q][p] = @filehandle.pos - line.length
+        end
+        @endbytepos = @filehandle.pos - @dat.boundary_string.length
+        self.rewind
+      end
     end
   end
 end

data/lib/mascot/dat/psm.rb

@@ -1,81 +1,97 @@
 module Mascot
   class DAT
+    # A single Peptide Spectrum Match (PSM) result. In Mascot parlance, this is a
+    # match from a query (e.g. a single MS2 spectrum from a MGF file) to a given peptide. A query may match more than one
+    # peptide at a given score, and Mascot will report these in order of descending significance, or "rank".
+    #
+    # From the Mascot documentation, the following represents a reasonably complete PSM entry
+    #     q1_p1_db=01  # two digit integer of the search DB index, zero filled and retarded.
+    #     q1_p1=missed cleavages, (-1 indicates no match)
+    #           peptide Mr,
+    #           delta,
+    #           number of ions matched,
+    #           peptide string,
+    #           peaks used from Ions1,
+    #           variable modifications string,
+    #           ions score,
+    #           ion series found,
+    #           peaks used from Ions2,
+    #           peaks used from Ions3;
+    #           "accession string":frame number:start:end:multiplicity, # data for first protein
+    #           "accession string":frame number:start:end:multiplicity, # data for second protein, etc.
+    #     q1_p1_et_mods=modification mass,
+    #                   neutral loss mass,
+    #                   modification description
+    #     q1_p1_primary_nl=neutral loss string
+    #     q1_p1_drange=startPos:endPos
+    #     q1_p1_terms=residue,residue:residue,residue # flanking AA for each protien, in order
+    #
     class PSM
 
-      ATTRS = [:query,:rank,:missed_cleavages,:mr, :delta,
-        :num_ions_matched,:pep,:ions1,:var_mods_str,:score,
-        :ion_series_str,:ions2,:ions3,:proteins,:dbs,:terms,:attrs]
+      attr_accessor :query
+      attr_accessor :rank
+      attr_accessor :missed_cleavages
+      attr_accessor :mr
+      attr_accessor :delta
+      attr_accessor :num_ions_matched
+      attr_accessor :pep
+      attr_accessor :ions1
+      attr_accessor :var_mods_str
+      attr_accessor :score
+      attr_accessor :ion_series_str
+      attr_accessor :ions2
+      attr_accessor :ions3
+      attr_accessor :proteins
+      attr_accessor :dbs
+      attr_accessor :terms
+      attr_accessor :attrs
 
-      ATTRS.each do |a|
-        attr_accessor a
+      # @param psm_entry [Array] The multi-line string entry from the Mascot DAT file
+      # @return [Mascot::DAT::PSM]
+      def initialize(psm_entry)
+        parse_entry(psm_entry)
       end
 
-      def initialize(*opts)
-        @attrs = {}
-
-        if opts.kind_of? Hash
-          opts.keys.each do |k|
-            if ATTRS.index(k.to_sym)
-              eval "@#{k} = #{opts[k]}"
-            end
-          end
-        end
-      end
-
-      def ==(other)
-        is_eql = true
-        ATTRS.each do |a|
-          if self.send(a) != other.send(a)
-            is_eql = false
-            break
-          end
-        end
-        is_eql
-      end
-      def self.parse psm_arr
-        psm_result =  self.new()
-        psm_arr.each do |l|
-          next unless l =~ /^q/
-
+      private
+      # Parses the query entry multi-line string from the Mascot DAT file
+      # @private
+      # @param psm_entry [Array]
+      # @return [Mascot::DAT::PSM]
+      def parse_entry psm_entry
+        psm_entry.each do |l|
           k,v = l.split "="
           case k
           when /^q(\d+)_p(\d+)$/
-            psm_result.query = $1.to_i
-            psm_result.rank = $2.to_i
+            @query = $1.to_i
+            @rank = $2.to_i
             psm_vals, prots  = v.split(";")
             psm_vals = psm_vals.split(',')
-            psm_result.missed_cleavages= psm_vals[0].to_i
-            psm_result.mr              = psm_vals[1].to_f
-            psm_result.delta           = psm_vals[2].to_f
-            psm_result.num_ions_matched = psm_vals[3].to_i
-            psm_result.pep             = psm_vals[4]
-            psm_result.ions1           = psm_vals[5].to_i
-            psm_result.var_mods_str    = psm_vals[6]
-            psm_result.score           = psm_vals[7].to_f
-            psm_result.ion_series_str  = psm_vals[8]
-            psm_result.ions2           = psm_vals[9].to_i
-            psm_result.ions3           = psm_vals[10].to_i
+            @missed_cleavages= psm_vals[0].to_i
+            @mr              = psm_vals[1].to_f
+            @delta           = psm_vals[2].to_f
+            @num_ions_matched = psm_vals[3].to_i
+            @pep             = psm_vals[4]
+            @ions1           = psm_vals[5].to_i
+            @var_mods_str    = psm_vals[6]
+            @score           = psm_vals[7].to_f
+            @ion_series_str  = psm_vals[8]
+            @ions2           = psm_vals[9].to_i
+            @ions3           = psm_vals[10].to_i
 
-            # assign proteins
-            psm_result.proteins = prots.split(",").map do |pe|
+            # assign protein  s
+            @proteins = prots.split(",").map do |pe|
               acc,*other_vals =  pe.split(":")
               acc.gsub!(/\"/,'')
               [acc] + other_vals.map {|e| e.to_i }
             end
           when /db$/
             # split on 2 chars, call to_i
-            psm_result.dbs = v.split(/(\d{2})/).grep(/^\d+$/) { |e| e.to_i }
+            @dbs = v.split(/(\d{2})/).grep(/^\d+$/).collect { |e| e.to_i }
           when /terms$/
             # for each protein, I have to add the term AA
-            psm_result.terms = v.split(":").collect {|t| t.split(",") }
-          else
-            # returns the smaller key
-            puts "****#{k}***"
-            k_sym = k.slice(/q\d+_p\d+_?(.+)/,1).to_sym
-            psm_result.attrs[k_sym] = v
+            @terms = v.split(":").collect {|t| t.split(",") }
           end
         end
-        psm_result
       end
     end
   end

data/lib/mascot/dat/query.rb

@@ -77,7 +77,7 @@ module Mascot
           when "index"
             @index = v.to_i
           when "rtinseconds"
-            @rtinseconds = v.to_f
+            @rtinseconds = v.to_i
           when "charge"
             @charge = v
           when "mass_min"

data/lib/mascot/dat/version.rb

@@ -1,6 +1,6 @@
 module Mascot
   class DAT
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end
 

data/test/test_mascot-dat-peptides.rb

@@ -52,4 +52,25 @@ class TestMascotDatPeptides < TestMascotDatHelper
     assert_equal([2], q1p1_psm.dbs)
     assert_equal([["R","Y"]], q1p1_psm.terms)
   end
+
+  def test_second_psm_from_next_psm
+    q1p1_psm  = @peptides.psm(1,1)
+    q1p2_psm = @peptides.next_psm()
+    assert_equal(1, q1p2_psm.query)
+    assert_equal(2, q1p2_psm.rank)
+    assert_equal(0, q1p2_psm.missed_cleavages)
+    assert_equal(476.223068, q1p2_psm.mr)
+    assert_equal(-0.940226, q1p2_psm.delta)
+    assert_equal(4, q1p2_psm.num_ions_matched)
+    assert_equal("GGESK", q1p2_psm.pep)
+    assert_equal(9, q1p2_psm.ions1)
+    assert_equal("0000000", q1p2_psm.var_mods_str)
+    assert_equal(13.29, q1p2_psm.score)
+    assert_equal("0000002020000000000", q1p2_psm.ion_series_str)
+    assert_equal(0, q1p2_psm.ions2)
+    assert_equal(0, q1p2_psm.ions3)
+    assert_equal([["P70298", 0, 605, 609, 1]], q1p2_psm.proteins)
+    assert_equal([2], q1p2_psm.dbs)
+    assert_equal([["K","N"]], q1p2_psm.terms)
+  end
 end

data/test/test_mascot-dat-query.rb

@@ -12,7 +12,7 @@ class TestMascotDatQuery < TestMascotDatHelper
     assert_equal("281.832701459371_513",@query.title)
   end
   def test_rtinseconds
-    assert_equal(513.0, @query.rtinseconds)
+    assert_equal(513, @query.rtinseconds)
   end
   def test_index
     assert_equal(30,@query.index)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mascot-dat
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70341777412840 !ruby/object:Gem::Requirement
+  requirement: &70273728840180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70341777412840
+  version_requirements: *70273728840180
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70341777410100 !ruby/object:Gem::Requirement
+  requirement: &70273728839140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70341777410100
+  version_requirements: *70273728839140
 description: Mascot DAT file format parser
 email:
 - angel@upenn.edu
@@ -88,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4478337334591189647
+      hash: 3863437592712259051
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -97,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4478337334591189647
+      hash: 3863437592712259051
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11