mspire-mascot-dat 0.0.1 → 0.1.0

data/README.md

@@ -1,45 +1,120 @@
 # mspire-mascot-dat
 
-Reads the mascot search engine .dat results file.
+Access mascot search engine .dat results file.
 
-## Examples
+* Simple interface
+* Lazy reading from IO object
+* Object access of key data types
+* Data casts where appropriate
+
+Pull requests (or requests for features) gladly accepted.
+
+[API of latest version](http://rubydoc.info/gems/mspire-mascot-dat)
+
+## Synposis
+
+A Dat object reads information off an open IO object as lazily as possible.
+The sections can be accessed like a hash.
 
 ```ruby
 require 'mspire-mascot-dat'
 
 Mspire::Mascot::Dat.open(file.dat) do |dat|
-  dat.sections  # => [:parameters, :masses, :unimod, :enzyme ...]
+  dat.keys # (or dat.sections) => [:parameters, :masses, ...]
+  
+  dat[:peptides].each do |peptide|
+    # or:    dat.each_peptide {|peptide| ... }
+    # data is properly cast
+    peptide.delta             # => a Float
+    peptide.missed_cleavages  # => an Integer
+  end
+
+  dat[:queries].each do |query|
+    query.title   # => a String (unescaped)
+  end
+
+  dat[:proteins].each do |protein|
+    protein.accession
+  end
+
+  # or random query access
+  dat.query(22)   # returns query #22
+
+  # sections with uppercase params are typically accessed by string
+  params = dat[:parameters]
+  params['CHARGE'] # => an Integer
+
+  # sections with lowercase params are accessed by symbol
+  header = dat[:header]
+  header[:sequences] # => an Integer
+
+  # sections that aren't normal key/value pairs returned as a String
+  dat[:unimod]   # => a String containing lots of XML
+  dat[:enzyme]   # => a String with enzyme data
 end
+```
+
+Note that no support is given for accessing the 'summary' sections because they are often incomplete for large files anyway and the information can all be found by accessing the 
 
+### Enumerable information
+
+Sections with enumerable objects may be accessed as each_<whatever> or with
+Dat#[], which returns an enumerable.  So, these are equivalent:
+
+```ruby
+dat.each_peptide {|pep| ... }
+dat[:peptides].each {|pep| ... }
+
+# these also are equivalent (return an enumerator)
+enumerator = dat.each_peptide
+enumerator = dat[:peptides]
 ```
-### each peptide
 
-#### every peptide hit
+Enumerators for some objects will have additional parameters that may be passed in (to either method style).  For instance, the user may retrieve the top **n** peptide hits:
 
 ```ruby
-dat.each_peptide do |pephit|
-  pephit.missed_cleavages # => an Integer
-  pephit.ions_score # => a Float
-  ...
+dat.each_peptide(1) {|peptide| ... } # only top peptide hits
+```
+
+### Queries
+
+In a dat file, each query is its own section, but this makes them fairly
+awkward to access.  We treat them as if they were grouped into a single
+section.
+
+```ruby
+dat[:queries].each do |query|
+  # hash or method access
+  query[:charge] # => a positive or negative Integer
+  query.charge 
+  query.Ions1 # or query.peaks
 end
 ```
 
-#### every decoy peptide hit
+But they can also be accessed by query number:
 
 ```ruby
-dat.each_peptide(false) {|pephit| ... }
+dat.query(23)  # return query23
 ```
 
-#### each top peptide hit
+### Decoys
+
+Decoy peptides may be accessed a few different ways, all of which are equivalent:
 
 ```ruby
-dat.each_peptide(true, 1) {|pephit| ... }
+dat.each_peptide(false)    {|peptide| ... }
+dat[:peptides, false].each {|peptide| ... }
+dat.each_decoy_peptide     {|peptide| ... }
+dat[:decoy_peptides].each  {|peptide| ... }
 ```
 
 ## Further Info
 
-See Mascot's Installation & Setup Manual' for detailed information about the
-.dat format itself.
+See the specs for additonal examples. 
+
+Also, see Mascot's "Installation & Setup Manual" for detailed information
+about the .dat format itself (can be accessed from the mascot main page
+of whichever mascot you are using).
 
 ## Copyright
 

data/Rakefile

@@ -13,7 +13,6 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{Reads mascot dat files with gusto for mspire library.}
   gem.email = "jtprince@gmail.com"
   gem.authors = ["John T. Prince"]
-  gem.add_dependency "elif", "~> 0.1.0"
   gem.add_development_dependency "rspec", "~> 2.8.0"
   gem.add_development_dependency "rdoc", "~> 3.12"
   gem.add_development_dependency "jeweler", "~> 1.8.4"

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/mspire/mascot/dat.rb

@@ -1,25 +1,169 @@
-require 'mspire/mascot/dat/index'
-require 'mspire/mascot/dat/peptide'
-require 'mspire/mascot/dat/query'
+
+%w(
+  index 
+  peptide 
+  query 
+  protein
+  parameters 
+  header masses
+).each do |subsection|
+  require "mspire/mascot/dat/#{subsection}"
+end
 
 module Mspire
   module Mascot
     class Dat
+
+      class << self
+
+        # reads each line from a section until reaching the end of the section
+        def each_line(io, &block)
+          return to_enum(__method__, io) unless block
+          io.each_line do |line|
+            break if line[0,2] == '--'
+            block.call(line)
+          end
+        end
+
+        # returns the key and value for KEY=VAL sections
+        def each_key_val(io, &block)
+          return to_enum(__method__, io) unless block
+          each_line(io) do |line|
+            line.chomp!
+            (key, val) = line.split('=',2)
+            block.call( [key, (val=='' ? nil : val)] )
+          end
+        end
+
+        def string(io, &block)
+          each_line(io).to_a.join
+        end
+
+        # returns the string after stripping off leading and trailing double
+        # quotation marks
+        def strip_quotes(string)
+          string.gsub(/\A"|"\Z/, '')
+        end
+        
+      
+        def open(file, index_file=false, &block)
+          io = File.open(file)
+          response = block.call(self.new(io, index_file))
+          io.close
+          response
+        end
+
+      end
+
+
       # the io object which is the open dat file
       attr_accessor :io
 
       # the index object which points to the start byte for each section
       attr_accessor :index
 
-      def initialize(io)
+      # if index_file is true, will attempt to use a written index file
+      # based on naming conventions; if one doesn't yet exist it will create
+      # one for the next usage.  If handed a String, will consider it the
+      # index filename for reading or writing depending on whether it exists.
+      def initialize(io, index_file=false)
         @io = io
-        @index = Index.new(@io)
+        index_filename = 
+          case index_file
+          when String then index_file
+          when TrueClass then Dat::Index.index_filename(io.path)
+          else
+            nil
+          end
+        @index = Index.new
+        if index_filename && File.exist?(index_filename)
+          @index.from_byteindex!(index_filename)
+        else
+          @index.from_io!(@io)
+        end
+
+        if index_filename && !File.exist?(index_filename)
+          @index.write(index_filename)
+        end
       end
 
-      def self.open(file, &block)
-        io = File.open(file)
-        block.call(self.new(io))
-        io.close
+      # the univeral way to access information
+      # returns the section with appropriate cast (if available) or as a
+      # String object with the information. nil if it doesn't exist.  Also
+      # responds to :query by calling Query::each.  An enumerator is called
+      # for enumerable objects.
+      #
+      #     dat.section(:header)  # => a Dat::Header object (hash-like)
+      #     dat.section(:peptides)  # => an Enumerator for peptides
+      #     dat.section(:peptides, 1)  # => an Enumerator for top peptides
+      #     dat[:peptides, 1].each {|peptide| ... <top peptide> }
+      #     # the equivalent each_<whatever> method:
+      #     dat.each_peptide(1) {|peptide| ... <top peptide> }
+      #
+      #     # aliased with #[] for bracket access:
+      #     dat[:header]
+      #     dat[:peptides, 1]
+      #     ...
+      #
+      def section(*args)
+        # If the name exists as a class, then try to call the from_io method
+        # on the class (e.g., Parameters.from_io(io)). If the name is a
+        # plural, try the singular and the ::each method on the singular class
+        # (e.g., Peptide::each).
+        name = args.first.to_sym
+        capitalized = name.to_s.capitalize
+        maybe_singular = 
+          case capitalized
+          when 'Queries'
+            'query'
+          else
+            start_section!(name)
+            capitalized[0...-1]
+          end
+        maybe_iterator = "each_#{maybe_singular.downcase}".to_sym
+        if self.respond_to?(maybe_iterator)
+          self.send(maybe_iterator, *args[1..-1])
+        elsif Mspire::Mascot::Dat.const_defined?(capitalized)
+          klass = Mspire::Mascot::Dat.const_get(capitalized)
+          obj = klass.new
+          if obj.respond_to?(:from_io!)
+            case name
+            when :parameters, :masses
+              obj.send(:from_io!, @io, false)
+            else
+              obj.send(:from_io!, @io)
+            end
+          else
+            nil
+          end
+          #elsif Mspire::Mascot::Dat.const_defined?(maybe_singular)
+          #  klass = Mspire::Mascot::Dat.const_get(maybe_singular)
+          #  klass.send(:each, @io, &block)
+        elsif @index.byte_num.key?(name)
+          Mspire::Mascot::Dat.string(@io)
+        else
+          nil
+        end
+      end
+
+      alias_method :[], :section
+
+      def each_protein(&block)
+        return to_enum(__method__) unless block
+        start_section!(:proteins)
+        Dat.each_key_val(@io) do |key, val|
+          (mw_s, desc) = val.split(',', 2)
+          block.call(Dat::Protein.new(Dat.strip_quotes(key), mw_s.to_f, Dat.strip_quotes(desc)))
+        end
+      end
+
+      def each_query(&block)
+        return to_enum(__method__) unless block
+        @index.query_nums.each do |query_num| 
+          byte = @index.query_num_to_byte[query_num]
+          @io.pos = byte
+          block.call( Mspire::Mascot::Dat::Query.new.from_io!(@io) )
+        end
       end
 
       # positions io at the beginning of the section data (past the Content
@@ -30,19 +174,40 @@ module Mspire
         self
       end
 
+      # returns query number n (these are NOT zero indexed)
       def query(n)
         start_section!(n)
-        Query.from_io(@io)
+        Query.new.from_io!(@io)
       end
 
-      def each_peptide(non_decoy=true, top_n=Float::INFINITY, &block)
-        block or return enum_for(__method__, non_decoy, top_n)
+      # optional parameters, passed in any order: 
+      #
+      #     top_n: [Float::INFINITY] a Numeric (top N hits)
+      #     non_decoy: [true] a Boolean 
+      #
+      # Returns the top_n hits.  If non_decoy is false or nil, returns the
+      # decoy hits.
+      #
+      #     each_peptide(false, 1) # top decoy peptide hit
+      #     each_peptide(2, true)  # top 2 peptide hits per query
+      #     each_peptide(1)        # top peptide hit per query
+      def each_peptide(*args, &block)
+        return to_enum(__method__, *args) unless block
+        (numeric, boolean) = args.partition {|arg| arg.is_a?(Numeric) }
+        top_n = numeric.first || Float::INFINITY
+        non_decoy = ((boolean.size > 0) ? boolean.first : true)
         start_section!(non_decoy ? :peptides : :decoy_peptides)
-        while peptide = Peptide.from_io(@io)
-          block.call(peptide) if peptide.peptide_num <= top_n
+        Mspire::Mascot::Dat::Peptide.each(@io) do |peptide|
+          if peptide.peptide_num <= top_n
+            block.call(peptide) 
+          end
         end
       end
 
+      def each_decoy_peptide(top_n=Float::INFINITY, &block)
+        each_peptide(false, top_n, &block)
+      end
+
       # returns a list of all sections as symbols. The symbol :queries is
       # returned rather than each query individually if their is 1 or more
       # queries.
@@ -54,6 +219,8 @@ module Mspire
         reply.map(&:to_sym)
       end
 
+      alias_method :keys, :sections
+
     end
   end
 end

data/lib/mspire/mascot/dat/cast.rb

@@ -0,0 +1,31 @@
+
+module Mspire
+  module Mascot
+    class Dat
+      module Cast
+        TO_INT_ARRAY = ->(val) { val.split(',').map(&:to_i) }
+        FROM_CHARGE_STRING = ->(st) { (st[-1] << st[0...-1]).to_i }
+        CGI_UNESCAPE = ->(st) { CGI.unescape(st) }
+        FLOAT_PAIRS = ->(st) { st.split(',').map {|pair_s| pair_s.split(':').map(&:to_f) } }
+      end
+
+      module Castable
+        # expects a hash with the parameter and the way to cast it as a symbol
+        # (e.g., :to_f or a lambda).  If no hash given, will attempt to
+        # retrieve a class constant 'CAST' which defines the casts.
+        def cast!(cast_hash=nil)
+          hash = cast_hash || self.class.const_get('CAST')
+          self.each_pair do |k,v|
+            if cast=hash[k]
+              apply = cast.is_a?(Symbol) ? cast.to_proc : cast
+              self[k] = apply[v] if apply
+            end
+          end
+          self
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,26 @@
+require 'mspire/mascot/dat/section/key_val'
+require 'mspire/mascot/dat/cast'
+
+module Mspire
+  module Mascot
+    class Dat
+      # The parameters is a hash with some casting (see CAST) and is
+      # accessible with upper case String keys.
+      class Header < Hash
+        include Section::KeyVal
+        include Castable
+
+        CAST = {
+          sequences: :to_i,
+          sequences_after_tax: :to_i,
+          residues: :to_i,
+          distribution: Cast::TO_INT_ARRAY,
+          distribution_decoy: Cast::TO_INT_ARRAY,
+          queries: :to_i,
+          max_hits: :to_i,
+        }
+
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'elif'
+require 'json'
 
 module Mspire
   module Mascot
@@ -6,8 +6,16 @@ module Mspire
       # makes a byte index (not line index) 
       class Index
 
+        INDEX_EXT = '.byteindex'
+
+        class << self
+          def index_filename(file)
+            file + Dat::INDEX_EXT
+          end
+        end
+
         # the hash holding the start byte for each section (besides the
-        # queries)
+        # queries).  Keyed by symbol.
         attr_accessor :byte_num
 
         # the array holding the start byte for each query.  It is indexed by
@@ -17,11 +25,13 @@ module Mspire
         # an array of the query nums
         attr_accessor :query_nums
 
-        def initialize(io=nil)
+
+        # if handed an index_bytefile it will open the filename and use that
+        # for the index
+        def initialize
           @byte_num = {}
           @query_num_to_byte = []
           @query_nums = []
-          from_io(io) if io
         end
 
         def has_queries?
@@ -29,7 +39,32 @@ module Mspire
         end
 
         # returns self
-        def from_io(io)
+        def from_byteindex!(filename)
+          hash = JSON.parse!( IO.read(filename) )
+          [:byte_num, :query_num_to_byte, :query_nums].each do |key|
+            self.send("#{key}=", hash[key.to_s])
+          end
+          @byte_num.keys.each {|k| @byte_num[k.to_sym] = @byte_num.delete(k) }
+          self
+        end
+
+        def write(filename)
+          File.open(filename,'w') do |io|
+            JSON.dump(
+              {
+              byte_num: byte_num,
+              query_num_to_byte: query_num_to_byte,
+              query_nums: query_nums,
+            }, io)
+          end
+        end
+
+        def from_file!(filename)
+          File.open(filename) {|io| from_io!(io) }
+        end
+
+        # returns self
+        def from_io!(io)
           io.rewind
           while line=io.gets
             io.each_line do |line|
@@ -43,7 +78,7 @@ module Mspire
                   @query_nums << query_num                
                   @query_num_to_byte[query_num] = pos
                 else
-                  @byte_num[head] = pos
+                  @byte_num[head.to_sym] = pos
                 end
               end
             end
@@ -63,7 +98,7 @@ module Mspire
           if key.is_a?(Integer) 
             @query_num_to_byte[key]
           else
-            @byte_num[key.to_s]
+            @byte_num[key.to_sym]
           end
         end
 

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

@@ -0,0 +1,22 @@
+
+require 'mspire/mascot/dat/section/key_val'
+#require 'mspire/mascot/dat/cast'
+
+module Mspire
+  module Mascot
+    class Dat
+      class Masses < Hash
+        include Section::KeyVal
+        #include Castable
+
+        #CAST = {
+        #  'TOL' => :to_f,
+        #  'ITOL' => :to_f,
+        #  'PFA' => :to_i,
+        #  'CHARGE' => Cast::FROM_CHARGE_STRING,
+        #}
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'mspire/mascot/dat/section/key_val'
+require 'mspire/mascot/dat/cast'
+
+module Mspire
+  module Mascot
+    class Dat
+      class Parameters < Hash
+        include Section::KeyVal
+        include Castable
+
+        CAST = {
+          'TOL' => :to_f,
+          'ITOL' => :to_f,
+          'PFA' => :to_i,
+          'CHARGE' => Cast::FROM_CHARGE_STRING,
+        }
+
+      end
+    end
+  end
+end

data/lib/mspire/mascot/dat/peptide.rb

@@ -1,55 +1,87 @@
+require 'mspire/mascot/dat/cast'
 
 module Mspire
   module Mascot
     class Dat
       # mr = relative molecular mass; data contains keys of relative
       Peptide = Struct.new(:missed_cleavages, :mr, :delta, :num_ions_matched, :seq, :peaks_from_ions_1, :var_mods_string, :ions_score, :ion_series_found, :peaks_from_ions_2, :peaks_from_ions_3, :query_num, :peptide_num, :proteins, :data) do
-        CAST = [:int, :float, :float, :int, :string, :int, :string, :float, :string, :int, :int]
+        include Castable
 
-        # h49_q2 => [49, 2]; q2_p4_primary_nl => [2, 4, 'primary_nl] 
-        def self.qnum_pnum(string)
-          (qns, pns, other) = string.split('_', 3)
-          [ *[qns, pns].map {|ns| ns[1..-1].to_i }, other ]
-        end
-        # takes an io object (positioned at the beginning of a peptide hit)
-        # and reads off the next peptide hit "q1_p1=0,798.23...". Returns nil
-        # if it reaches the end of the section or it is a blank line
-        def self.from_io(io, proteins=false, data=false)
-          finished = ->(line) { line.size < 2 || line[0,2] == '--' }
+
+        # reads the next line.  If it contains valid query information returns
+        # an array [query_num, peptide_num, info_tag, value].  If it no valid
+        # query information, resets the io position to the beginning of the
+        # string and returns nil.
+        def self.next_qp_data(io)
+          before = io.pos
           line = io.readline("\n")
-          if finished[line]
+          if line[0,2] == '--'
+            io.pos = before
             nil
           else
-            (qp, core, protein_info) = line.split(/[=;]/)
-            (qnum, pnum, _) = qnum_pnum(qp)
-            vals = core.split(',').zip(CAST).map do |val, cast| 
-              case cast
-              when :int then val.to_i
-              when :float then val.to_f
-              else 
-                val
-              end
-            end
-            pephit = self.new(*vals, qnum, pnum)
-            raise NotImplementedError, "not reading proteins or data yet" if proteins || data
-            loop do
-              before = io.pos
-              line = io.readline("\n")
-              if finished[line]
-                io.pos = before
-                break
-              end
-              (qp, string) = line.split('=')
-              (qnum, pnum, other) = qnum_pnum(qp)
-              if pephit.peptide_num != pnum || pephit.query_num != qnum
-                io.pos = before
-                break
-              end
+            line.chomp!
+            (qpstring, value) = line.split('=',2)
+            (qns, pns, info_tag) = qpstring.split('_', 3)
+            (qnum, pnum) = [qns, pns].map {|ns| ns[1..-1].to_i }
+            [qnum, pnum, info_tag, value]
+          end
+        end
+
+        # given the value part of the initial peptide data (q1_p1=<value>),
+        # sets the object's properties. returns the pephit
+        def self.from_value_string(value, qnum, pnum)
+          (core, prots) = value.split(';', 2)
+          pephit = self.new(*core.split(','), qnum, pnum)
+          pephit.cast!
+          pephit
+        end
+
+        # returns the query num and peptide num and info_tag and string.  nil if they don't exist.
+        def self.dissect_line(line)
+          if md=/q(\d+)_p_?(\d+)(\w*)=(.*)/.match(line)
+            [md[1].to_i, md[2].to_i, md[3], md[4]]
+          end
+        end
+
+   
+        # returns each peptide hit.  Some queries will not have *any* hits,
+        # and these are *not* yielded.
+        def self.each(io, &block)
+          return to_enum(__method__, io) unless block
+          before = io.pos
+          peptide = nil
+          while reply=dissect_line(io.readline("\n"))
+            (qnum, pnum, info_tag, value) = reply
+            if info_tag == ''
+              track_pos = io.pos
+              block.call(peptide) if peptide # yield the previous peptide
+              io.pos = track_pos
+              peptide = 
+                (value == "-1") ? nil : self.from_value_string(value, qnum, pnum)
+            else
+              # implement reading in future
             end
-            pephit
+            before = io.pos
           end
+          # yield that last peptide
+
+          track_pos = io.pos
+          block.call(peptide) if peptide
+          io.pos = track_pos
         end
       end
+      class Peptide
+        CAST = {
+          missed_cleavages: :to_i, 
+          mr: :to_f, 
+          delta: :to_f, 
+          num_ions_matched: :to_i,
+          ions: :string, 
+          ions_score: :to_f, 
+          peaks_from_ions_2: :to_i,
+          peaks_from_ions_3: :to_i,
+        }
+      end
     end
   end
 end

data/lib/mspire/mascot/dat/protein.rb

@@ -0,0 +1,8 @@
+
+module Mspire
+  module Mascot
+    class Dat
+      Protein = Struct.new(:accession, :mw, :description)
+    end
+  end
+end

data/lib/mspire/mascot/dat/query.rb

@@ -2,14 +2,17 @@ require 'ostruct'
 require 'delegate'
 require 'cgi'
 
+require 'mspire/mascot/dat/cast'
+
 module Mspire
   module Mascot
     class Dat
       class Query < Hash
+        include Castable
 
         CAST = {
-          charge: ->(st) { (st[-1] << st[0...-1]).to_i },
-          title: ->(st) { CGI.unescape(st) },
+          charge: Cast::FROM_CHARGE_STRING,
+          title: Cast::CGI_UNESCAPE,
           mass_min: :to_f,
           mass_max: :to_f,
           int_min: :to_f,
@@ -17,27 +20,19 @@ module Mspire
           num_vals: :to_i,
           num_used1: :to_i,
           index: :to_i,
-          Ions1: ->(st) { st.split(',').map {|pair_s| pair_s.split(':').map(&:to_f) } },
+          Ions1: Cast::FLOAT_PAIRS,
         }
 
         # returns self
-        def self.from_io(io)
-          query = self.new
-          while line = io.gets
-            break if line[0,2] == '--'
-            line.chomp!
-            (key, val) = line.split('=')
-            query[key.to_sym] = val
-          end
-          query.each do |k,v|
-            if cast=CAST[k]
-              apply = cast.is_a?(Symbol) ? cast.to_proc : cast
-              query[k] = apply[v] if apply
-            end
+        def from_io!(io)
+          Dat.each_key_val(io) do |key,val|
+            self[key.to_sym] = val
           end
-          query
+          cast!
         end
 
+        def peaks() self[:Ions1] end
+
         def method_missing(*args, &block)
           if args[0].to_s[-1] == '='
             if self.key?(args[0...-1])

data/lib/mspire/mascot/dat/section/key_val.rb

@@ -0,0 +1,18 @@
+
+module Mspire
+  module Mascot
+    class Dat
+      module Section
+        module KeyVal
+          def from_io!(io, as_symbols=true)
+            Dat.each_key_val(io) do |key,val| 
+              self[ as_symbols ? key.to_sym : key ] = val
+            end
+            self.send(:cast!) if self.respond_to?(:cast!)
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mspire/mascot/dat/index_spec.rb

@@ -2,16 +2,18 @@ require 'spec_helper'
 
 require 'mspire/mascot/dat/index'
 
+require 'fileutils'
+
 describe 'Mspire::Mascot::Dat::Index being initialized from file' do
 
   let(:io) { File.open(TESTFILES + "/F004128.dat") }
 
   specify '#initialize(io) creates the index object' do
-    Mspire::Mascot::Dat::Index.new(io).should be_a(Mspire::Mascot::Dat::Index)
+    Mspire::Mascot::Dat::Index.new.from_io!(io).should be_a(Mspire::Mascot::Dat::Index)
   end
 
   describe Mspire::Mascot::Dat::Index do
-    subject { Mspire::Mascot::Dat::Index.new(io) }
+    subject { Mspire::Mascot::Dat::Index.new.from_io!(io) }
 
     it 'can access the header start byte nums' do
 
@@ -40,5 +42,18 @@ describe 'Mspire::Mascot::Dat::Index being initialized from file' do
       subject['peptides'].should == 41624
     end
 
+    it 'can write the index info and create an identical object from the file' do
+      spec_tmpdir do |tmpdir|
+        bytefile = tmpdir + "/index_bytefile.tmp"
+        subject.write( bytefile )
+        File.exist?( bytefile ).should be_true
+        File.size( bytefile ).should be > 0
+        fromfile = Mspire::Mascot::Dat::Index.new.from_byteindex!( bytefile )
+        [:byte_num, :query_num_to_byte, :query_nums].each do |methd|
+          fromfile.send(methd).should == subject.send(methd)
+        end
+      end
+    end
+
   end
 end

data/spec/mspire/mascot/dat/peptide_spec.rb

@@ -1,24 +1,59 @@
 require 'spec_helper'
 
+require 'mspire/mascot/dat'
 require 'mspire/mascot/dat/peptide'
 
-describe 'reading off a Peptide' do
+describe 'reading off the peptides' do
 
-  before(:all) do
-    info = <<STRING
-q2_p1=0,2978.269196,1.195840,5,MDSSSGSQGNGSFMDQNSLGILNMDNLK,17,000000000000001000000000100000,4.11,0002000020000000000,0,0;"Q9VV79":0:1:28:1
-q2_p1_terms=-,V
-q2_p1_primary_nl=000000000000002000000000200000
-q2_p2=1,2979.449478,0.015558,5,STGAESSEEXLREAYIMASVEHVNLLK,45,00000000000000000100000000000,2.84,0000000020000000000,0,0;"Q6SAG3":0:875:901:1 
-STRING
-    @io = StringIO.new(info)
+  before(:each) do
+    file = TESTFILES + '/F004129.dat'
+    @io = File.open(file)
+    @io.pos = 62743
+  end
+
+  after(:each) do
+    @io.close
   end
 
-  it 'works' do
-    peptide = Mspire::Mascot::Dat::Peptide.from_io(@io)
-    { missed_cleavages: 0, mr: 2978.269196, delta: 1.19584, num_ions_matched: 5, seq: 'MDSSSGSQGNGSFMDQNSLGILNMDNLK', peaks_from_ions_1: 17, var_mods_string: '000000000000001000000000100000', ions_score: 4.11, ion_series_found: '0002000020000000000', peaks_from_ions_2: 0, peaks_from_ions_3: 0, query_num: 2, peptide_num: 1, proteins: nil, data: nil }.each do |k,v|
-      peptide.send(k).should == v
+  it 'has an iterator' do
+    info = Mspire::Mascot::Dat::Peptide.each(@io).map do |pep|
+      [pep.ions_score, pep.query_num, pep.peptide_num]
     end
+    info.should == [[0.22, 1, 1], [4.11, 2, 1], [2.84, 2, 2], [2.83, 2, 3], [2.65, 2, 4], [2.28, 2, 5], [1.07, 2, 6], [0.99, 2, 7], [0.96, 2, 8], [0.65, 2, 9], [0.63, 2, 10]]
   end
 
 end
+
+=begin
+q1_p1=0,2113.999008,-0.998912,4,VMLSDADPSLEQYYVNVR,17,00100000000000000000,0.22,0002002000000000000,0,0;"Q23985":0:79:96:1
+q1_p1_terms=R,T
+q1_p1_primary_nl=00100000000000000000
+q2_p1=0,2978.269196,1.195840,5,MDSSSGSQGNGSFMDQNSLGILNMDNLK,17,000000000000001000000000100000,4.11,0002000020000000000,0,0;"Q9VV79":0:1:28:1
+q2_p1_terms=-,V
+q2_p1_primary_nl=000000000000002000000000200000
+q2_p2=1,2979.449478,0.015558,5,STGAESSEEXLREAYIMASVEHVNLLK,45,00000000000000000100000000000,2.84,0000000020000000000,0,0;"Q6SAG3":0:875:901:1
+q2_p2_terms=K,L
+q2_p2_primary_nl=00000000000000000200000000000
+q2_p2_subst=10,X,T
+q2_p3=1,2980.525406,-1.060370,5,LSSPPSTSHTYEGKLLTKPTHTNTDLR,45,00000000000000000000000000000,2.83,0000000020000000000,0,0;"Q6KEU5":0:82:108:1,"Q6KEU6":0:82:108:1
+q2_p3_terms=K,G:K,G
+q2_p4=0,2978.269196,1.195840,4,MDSSSGSQGNGSFMDQNSLGILNMDNLK,31,010000000000000000000000100000,2.65,0000000020000000000,0,0;"Q9VV79":0:1:28:1
+q2_p4_terms=-,V
+q2_p4_primary_nl=020000000000000000000000200000
+q2_p5=1,2980.380035,-0.914999,4,FGDMFSKESEQVALAVYEAYDPNVGSK,17,00000000000000000000000000000,2.28,0000002020000000000,0,0;"P82982":0:340:366:1
+q2_p5_terms=K,S
+q2_p6=0,2978.688492,0.776544,8,GAEFSSFSVVLLVIILIIVFLSNAYHK,118,00000000000000000000000000000,1.07,0000020000000000000,0,0;"A8DYF1":0:2:28:1
+q2_p6_terms=M,A
+q2_p7=1,2979.588989,-0.123953,4,KLQSNATVLSDGYAAHLAGLQAVGGSRPAK,45,00000000000000000000000000000000,0.99,0000020010000000000,0,0;"P43125":0:1187:1216:1,"P43125-2":0:1187:1216:1,"D2NUF3":0:172:201:1
+q2_p7_terms=K,G:K,G:K,G
+q2_p8=0,2980.229141,-0.764105,3,LMFGDEEGNLPSLDQEDEQVPETEED,31,0010000000000000000000000000,0.96,0002000000000000000,0,0;"Q9VVZ8":0:703:728:1
+q2_p8_terms=R,-
+q2_p8_primary_nl=0020000000000000000000000000
+q2_p9=1,2978.364624,1.100412,2,LCPRCFQELSDYDTIMVNLMTTQK,17,00000000000000000000100000,0.65,0000002000000000000,0,0;"P07664":0:60:83:1
+q2_p9_terms=R,R
+q2_p9_primary_nl=00000000000000000000100000
+q2_p10=0,2978.672592,0.792444,5,NGSSVAGTSVLSPSIPLTLVVLPALMIAQK,70,00000000000000000000000000100000,0.63,0000000020000000000,0,0;"B8A406":0:72:101:1,"C6SUW4":0:177:206:1,"A1Z9D9":0:246:275:1
+q2_p10_terms=K,S:K,S:K,S
+q2_p10_primary_nl=00000000000000000000000000100000
+=end
+

data/spec/mspire/mascot/dat/query_spec.rb

@@ -24,8 +24,8 @@ END
     @io = StringIO.new(data)
   end
 
-  it 'parses' do
-    query = Mspire::Mascot::Dat::Query.from_io(@io)
+  specify '#from_io(io) returns a query object with appropriate casts' do
+    query = Mspire::Mascot::Dat::Query.new.from_io!(@io)
     query.title.should == '1.2746.2746.2'
     query.charge.should == -2
   end

data/spec/mspire/mascot/dat_spec.rb

@@ -23,72 +23,172 @@ describe 'reading a dat file' do
     @io.close
   end
 
-  it 'knows all the sections, with queries grouped' do
-    @dat.sections.should == [:parameters, :masses, :unimod, :enzyme, :header, :summary, :decoy_summary, :peptides, :decoy_peptides, :proteins, :index, :queries]
+  specify '#sections() returns all the sections (with queries considered a single group)' do
+    (sections=@dat.sections).should == [:parameters, :masses, :unimod, :enzyme, :header, :summary, :decoy_summary, :peptides, :decoy_peptides, :proteins, :index, :queries]
+    @dat.keys.should == sections
   end
 
-  it 'can retrieve queries at random' do
+  specify '#query(n) can retrieve queries at random' do
     @dat.query(1).title.should == '1.2746.2746.2'
     @dat.query(2).title.should == '1.2745.2745.4'
   end
 
-  it 'can retrieve every peptide' do
-    start = [ [1,1,'VMLSDADPSLEQYYVNVR'], 
-      [2,1,'MDSSSGSQGNGSFMDQNSLGILNMDNLK'],
-      [2,2,'STGAESSEEXLREAYIMASVEHVNLLK'],
-      [2,3,'LSSPPSTSHTYEGKLLTKPTHTNTDLR'],
-      [2,4,'MDSSSGSQGNGSFMDQNSLGILNMDNLK']]
+  describe '#Dat[:<name>]' do
 
-    last = [2,10,'NGSSVAGTSVLSPSIPLTLVVLPALMIAQK']
+    specify "#[:parameters] returns a hash-like object with proper casts" do
+      params = @dat[:parameters]
+      params.should be_a(Mspire::Mascot::Dat::Parameters)
+      params['LICENSE'].should == 'Licensed to: Brigham Young University, Provo, United States RCCZ-D4GH-S53W-2G5F-NG5L, (1 processor).'
+      params['IATOL'].should be_nil
+      params.key?('IATOL').should be_true
+      params.key?('silliness').should be_false
+      params['IT_MODS'].should == 'Oxidation (M)'
+      params['TOL'].should == 1.2
+      params['CHARGE'].should == 2
+      params['INTERNALS'].should == "0.0,700.0"
+    end
 
-    last_pep = nil
-    @dat.each_peptide do |peptide|
-      last_pep = peptide
-      (qnum, pnum, aa) = start.shift
-      if qnum
-        peptide.query_num.should == qnum
-        peptide.peptide_num.should == pnum
-        peptide.seq.should == aa
-      end
+    specify "#[:header] returns hash-like object with casts" do
+      header = @dat[:header]
+      header.should be_a(Mspire::Mascot::Dat::Header)
+      header[:sequences].should == 34724
+      header[:residues].should == 17622530
+      header[:distribution].should == [30914, 38, 61, 154, 203, 295, 417, 447, 500, 442, 360, 239, 168, 167, 98, 60, 39, 24, 15, 16, 14, 8, 7, 8, 5, 4, 7, 3, 3, 1, 1, 3, 1, 0, 1, 0, 1]
+      header[:release].should == 'GbetaCCT_drome.fasta'
     end
-    (qnum, pnum, aa) = last
-    peptide = last_pep
-    peptide.query_num.should == qnum
-    peptide.peptide_num.should == pnum
-    peptide.seq.should == aa
-
-    # this proves that each_peptide can also return an enumerator if asked
-    cnts = @dat.each_peptide.with_index.map do |peptide,i|
-      peptide.should(be_a(Mspire::Mascot::Dat::Peptide)) && i
+
+    specify '#[:masses] returns key val pairs (uncast)' do
+      masses = @dat[:masses]
+      masses.should be_an(Mspire::Mascot::Dat::Masses)
+      masses['A'].should == '71.037114'
+      masses['FixedModResidues1'].should == 'C'
     end
-    cnts.should == (0..10).to_a
-  end
 
-  it 'can retrieve decoy peptides' do
-    ions_score_target = @dat.each_peptide(true, 1).map do |peptide|
-      peptide.should(be_a(Mspire::Mascot::Dat::Peptide))
-      peptide.peptide_num.should == 1
-      peptide.ions_score
+    specify '#[:unimod] returns as a string the entire section' do
+      unimod_string = @dat[:unimod]
+      lines = unimod_string.each_line.to_a
+      lines.first.chomp.should == '<?xml version="1.0" encoding="UTF-8" ?>'
+      lines[-2].chomp.should == '</umod:unimod>'
     end
-    ions_score_target.should == [0.22, 4.11] 
 
-    ions_score_decoy = @dat.each_peptide(false, 1).map do |peptide|
-      peptide.should(be_a(Mspire::Mascot::Dat::Peptide))
-      peptide.peptide_num.should == 1
-      peptide.ions_score
+    specify '#[:enzyme] returns as a string the entire section' do
+      enzyme_string = @dat[:enzyme]
+      lines = enzyme_string.each_line.to_a
+      lines.first.chomp.should == 'Title:Trypsin'
+      lines.last.chomp.should == '*'
     end
-    ions_score_decoy.should == [3.52, 4.58]
   end
 
-  it 'can retrieve just the n peptides' do
-    n = 1
-    cnt = 0
-    @dat.each_peptide(true, n) do |peptide|
-      cnt += 1
-      peptide.should(be_a(Mspire::Mascot::Dat::Peptide))
-      peptide.query_num.should == cnt
-      peptide.peptide_num.should == 1
+  describe 'iterators' do
+
+    describe 'each_<name>' do
+
+      specify '#each_query retrieves every query' do
+        queries = @dat.each_query.to_a
+        queries.size.should == 2
+        queries.first.title.should == '1.2746.2746.2'
+        queries.last.title.should == '1.2745.2745.4'
+      end
+
+      specify '#each_peptide can retrieve every peptide' do
+        start = [ [1,1,'VMLSDADPSLEQYYVNVR'], 
+          [2,1,'MDSSSGSQGNGSFMDQNSLGILNMDNLK'],
+          [2,2,'STGAESSEEXLREAYIMASVEHVNLLK'],
+          [2,3,'LSSPPSTSHTYEGKLLTKPTHTNTDLR'],
+          [2,4,'MDSSSGSQGNGSFMDQNSLGILNMDNLK']]
+
+        last = [2,10,'NGSSVAGTSVLSPSIPLTLVVLPALMIAQK']
+
+        last_pep = nil
+        @dat.each_peptide do |peptide|
+          last_pep = peptide
+          (qnum, pnum, aa) = start.shift
+          if qnum
+            peptide.query_num.should == qnum
+            peptide.peptide_num.should == pnum
+            peptide.seq.should == aa
+          end
+        end
+        (qnum, pnum, aa) = last
+        peptide = last_pep
+        peptide.query_num.should == qnum
+        peptide.peptide_num.should == pnum
+        peptide.seq.should == aa
+
+        # this proves that each_peptide can also return an enumerator if asked
+        cnts = @dat.each_peptide.with_index.map do |peptide,i|
+          peptide.should(be_a(Mspire::Mascot::Dat::Peptide)) && i
+        end
+        cnts.should == (0..10).to_a
+      end
+
+      specify '#each_peptide(true/false) can retrieve normal/decoy peptides' do
+        ions_score_target = @dat.each_peptide(true, 1).map do |peptide|
+          peptide.should(be_a(Mspire::Mascot::Dat::Peptide))
+          peptide.peptide_num.should == 1
+          peptide.ions_score
+        end
+        ions_score_target.should == [0.22, 4.11] 
+
+        [:to_a, :reverse].each do |ar_order|
+          args = [1, false].send(ar_order)
+          ions_score_decoy = @dat.each_peptide(*args).map do |peptide|
+            peptide.should(be_a(Mspire::Mascot::Dat::Peptide))
+            peptide.peptide_num.should == 1
+            peptide.ions_score
+          end
+          ions_score_decoy.should == [3.52, 4.58]
+        end
+      end
+
+      specify '#each_peptide(n) can retrieve just the top n peptides' do
+        n = 1
+        cnt = 0
+        @dat.each_peptide(n) do |peptide|
+          cnt += 1
+          peptide.should(be_a(Mspire::Mascot::Dat::Peptide))
+          peptide.query_num.should == cnt
+          peptide.peptide_num.should == 1
+        end
+      end
     end
-  end
 
+    describe '#[:<name>] iterators' do
+
+      specify '#[:peptides] returns an enumerator' do
+        @dat[:peptides].should be_an(Enumerator)
+        @dat[:peptides].map(&:peptide_num).should == [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        @dat[:peptides].map(&:query_num).should == [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+        @dat[:peptides].map(&:ions_score).should == [0.22, 4.11, 2.84, 2.83, 2.65, 2.28, 1.07, 0.99, 0.96, 0.65, 0.63]
+        @dat[:peptides, true, 1].map(&:peptide_num).should == [1,1]
+      end
+
+      specify '#[:decoy_peptides] returns an enumerator (or takes a block)' do
+        @dat[:decoy_peptides].should be_an(Enumerator)
+        @dat[:decoy_peptides].map(&:peptide_num).should == [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        @dat[:decoy_peptides].map(&:query_num).should == [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+        @dat[:decoy_peptides].map(&:ions_score).should == [3.52, 4.58, 3.46, 3.3, 3.05, 3.05, 2.99, 2.97, 2.97, 2.87, 2.87] 
+        @dat[:decoy_peptides, 1].map(&:peptide_num).should == [1,1]
+      end
+
+      specify '#[:queries] returns an enumerator (or takes a block)' do
+        @dat[:queries].should be_an(Enumerator)
+        @dat[:queries].map(&:title).should == ["1.2746.2746.2", "1.2745.2745.4"]
+      end
+
+      specify '#[:proteins] returns an enumerator (or takes a block)' do
+        data = [
+          ["Q9VV79", 125605.17, "BcDNA.LD24702 OS=Drosophila melanogaster GN=spd-2 PE=1 SV=2"],
+          ["Q23985", 82989.73, "Protein deltex OS=Drosophila melanogaster GN=dx PE=1 SV=2"]
+        ]
+
+        @dat[:proteins].each do |protein|
+          exp = data.shift
+          protein.accession.should == exp.shift
+          protein.mw.should == exp.shift
+          protein.description.should == exp.shift
+        end
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,27 @@
 require 'rspec'
 
+require 'fileutils'
+
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 #Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
+SPEC_DIR = File.dirname(__FILE__)
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.formatter = :documentation
 end
 
-TESTFILES = __dir__ + "/testfiles"
+TESTFILES = SPEC_DIR + "/testfiles"
+
+# creates a tmpdir, passes it into the block as a full path, then destroys at
+# close of block.  Returns whatever was returned by the block.
+def spec_tmpdir(&block)
+  dir = File.expand_path(SPEC_DIR + "/tmp")
+  FileUtils.rm_rf( dir )
+  FileUtils.mkdir( dir )
+  reply = block.call(dir)
+  FileUtils.rm_rf( dir )
+  reply
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mspire-mascot-dat
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2013-04-11 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: elif
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -90,10 +74,15 @@ files:
 - Rakefile
 - VERSION
 - lib/mspire/mascot/dat.rb
+- lib/mspire/mascot/dat/cast.rb
+- lib/mspire/mascot/dat/header.rb
 - lib/mspire/mascot/dat/index.rb
+- lib/mspire/mascot/dat/masses.rb
+- lib/mspire/mascot/dat/parameters.rb
 - lib/mspire/mascot/dat/peptide.rb
+- lib/mspire/mascot/dat/protein.rb
 - lib/mspire/mascot/dat/query.rb
-- mspire-mascot-dat.gemspec
+- lib/mspire/mascot/dat/section/key_val.rb
 - spec/mspire/mascot/dat/index_spec.rb
 - spec/mspire/mascot/dat/peptide_spec.rb
 - spec/mspire/mascot/dat/query_spec.rb

data/mspire-mascot-dat.gemspec

@@ -1,70 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "mspire-mascot-dat"
-  s.version = "0.0.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["John T. Prince"]
-  s.date = "2013-03-28"
-  s.description = "Reads mascot dat files with gusto for mspire library."
-  s.email = "jtprince@gmail.com"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    ".rspec",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/mspire/mascot/dat.rb",
-    "lib/mspire/mascot/dat/index.rb",
-    "lib/mspire/mascot/dat/peptide.rb",
-    "lib/mspire/mascot/dat/query.rb",
-    "mspire-mascot-dat.gemspec",
-    "spec/mspire/mascot/dat/index_spec.rb",
-    "spec/mspire/mascot/dat/peptide_spec.rb",
-    "spec/mspire/mascot/dat/query_spec.rb",
-    "spec/mspire/mascot/dat_spec.rb",
-    "spec/reference/dat_format_reference.md",
-    "spec/reference/two_spectra_decoy_F004129.png",
-    "spec/reference/two_spectra_no_decoy_F004128.png",
-    "spec/spec_helper.rb",
-    "spec/testfiles/F004128.dat",
-    "spec/testfiles/F004129.dat",
-    "spec/testfiles/two_spectra.mgf"
-  ]
-  s.homepage = "http://github.com/princelab/mspire-mascot-dat"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
-  s.summary = "Reads mascot dat files for mspire library."
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<elif>, ["~> 0.1.0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
-    else
-      s.add_dependency(%q<elif>, ["~> 0.1.0"])
-      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
-    end
-  else
-    s.add_dependency(%q<elif>, ["~> 0.1.0"])
-    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
-  end
-end
-