ms-mascot 0.1.0 → 0.2.0

data/History

@@ -0,0 +1,9 @@
+== 0.12.2 / 2009-02-23
+
+Updated release utilizing Tap.
+
+* Added/Updated tasks for predicting spectra
+* Added Submit/Export tasks
+* Added preliminary .dat support
+* Fixed bugs for series like y0, b*
+* Converted tests to MiniTest specs

data/lib/ms/mascot/dat.rb

@@ -0,0 +1,16 @@
+require 'ms/mascot/dat/archive'
+
+module Ms
+  module Mascot
+    module Dat
+      class << self
+        # gives the block the opened Ms::Mascot::Dat::Archive object
+        def open(filename, &block)
+          Archive.open(filename, &block)
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,198 @@
+require 'external'
+
+module Ms
+  module Mascot
+    module Dat
+      
+      # A hash of (section_name, SectionClass) pairs mapping section names
+      # to section class.  Initially SectionClass may be a require path; if
+      # so the path is required and the class looked up like:
+      #
+      #   Ms::Mascot::Dat.const_get(section_name.capitalize)
+      #
+      # Such that 'header' is mapped to Ms::Mascot::Dat::Header.
+      CONTENT_TYPE_CLASSES = {}
+      
+      # currently unimplemented: unimod enzyme taxonomy mixture quantitation
+      %w{header index masses parameters peptides proteins summary query
+      }.each do |section_name|
+        CONTENT_TYPE_CLASSES[section_name] = "ms/mascot/dat/#{section_name}"
+      end 
+      
+      # Provides access to a Mascot dat file.
+      class Archive < ExternalArchive
+        module Utils
+          module_function
+          
+          # Parses a hash of metadata (content_type, boundary, etc) from io.
+          # parse_metadata does not reposition io.
+          def parse_metadata(io)
+            current_pos = io.pos
+            io.rewind
+            
+            metadata = {}
+            line = io.readline
+            unless line =~ /MIME-Version: (\d+\.\d+) \(Generated by Mascot version (\d+\.\d+)\)/
+              raise "could not parse mime-version or mascot-version: #{line}"
+            end
+            metadata[:mime_version] = $1
+            metadata[:mascot_version] = $2
+            
+            line = io.readline
+            unless line =~ /Content-Type: (.*?); boundary=(.*)/
+              raise "could not parse content-type: #{line}"
+            end
+            metadata[:content_type] = $1
+            metadata[:boundary] = $2
+            
+            io.pos = current_pos
+            metadata
+          end
+          
+          # Parses a mascot-style content type declaration.  This method uses
+          # a simple regexp and is very brittle, but it works for all known
+          # dat files.
+          def parse_content_type(str)
+            unless str =~ /^Content-Type: (.*?); name=\"(.*)\"/
+              raise "unparseable content-type declaration: #{str.inspect}"
+            end
+            
+            {:content_type => $1, :section_name => $2}
+          end
+          
+          # Resolves a content type class from a hash of metadata like:
+          #
+          #   metadata = {
+          #     :content_type => 'application/x-Mascot',
+          #     :section_name => 'header'
+          #   }
+          #   Dat.content_type_class(metadata)   # => Ms::Mascot::Dat::Header
+          #
+          # Raises an error if the content type is not 'application/x-Mascot'
+          # or if the name is not registered in CONTENT_TYPE_CLASSES.
+          def content_type_class(metadata)
+            unless metadata[:content_type] == 'application/x-Mascot'
+              raise "unknown content_type: #{metadata.inspect}"
+            end
+            
+            name = metadata[:section_name]
+            name = 'query' if name =~ /^query(\d+)$/
+            case const = CONTENT_TYPE_CLASSES[name]
+            when String
+              require const
+              CONTENT_TYPE_CLASSES[name] = Dat.const_get(name.capitalize)
+            else
+              const
+            end
+          end
+        end
+        
+        include Utils
+        
+        # A hash of metadata associated with this dat file.
+        attr_reader :metadata
+        
+        def initialize(io=nil, io_index=nil)
+          super(io)
+          @metadata = parse_metadata(io)
+          @section_names = []
+        end
+        
+        # The boundary separating sections, typically '--gc0p4Jq0M2Yt08jU534c0p'.
+        def boundary
+          "--#{metadata[:boundary]}"
+        end
+        
+        # Reindexes self.
+        def reindex(&block)
+          @section_names.clear
+          reindex_by_sep(boundary, 
+            :entry_follows_sep => true, 
+            :exclude_sep => true,
+          &block)
+
+          # remove the first and last entries, which contain
+          # the metadata and indicate the end of the multipart 
+          # form data.
+          io_index.shift
+          io_index.pop
+
+          self
+        end
+
+        # Converts str into an entry according to the content type header
+        # 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)
+          else
+            str
+          end
+        end
+        
+        # The section names corresponding to each entry in self.
+        #
+        # Normally section names are lazily parsed from the Content-Type header
+        # of an entry as needed.  If resolve is true, all section names are
+        # parsed and then returned; otherwise section_names may return a
+        # partially-filled array.
+        def section_names(resolve=true)
+          resolve_sections if resolve
+          @section_names
+        end
+        
+        # Returns the entry for the named section.
+        def section(name)
+          self[section_index(name)]
+        end
+
+        # Returns the index of the named section.
+        def section_index(name)
+          0.upto(length - 1) do |index|
+            return index if section_name(index) == name
+          end
+          nil
+        end
+
+        # Returns the section name for the entry at index.
+        def section_name(index)
+          # all sections must be resolved for negative indicies to
+          # work correctly (since otherwise @section_names may not
+          # have the same length as self)
+          resolve_sections if index < 0
+          @section_names[index] ||= parse_section_name(index)
+        end
+        
+        def each_query(&block)
+          section('index').queries.each do |key|
+            block.call( self.section(key) )
+          end
+        end
+
+        def query(num)
+          if si = section_index("query#{num}")
+            self[si]
+          else
+            nil
+          end
+        end
+
+        private
+        
+        # resolves each section
+        def resolve_sections # :nodoc:
+          (@section_names.length).upto(length - 1) do |index| 
+            section_name(index)
+          end
+        end
+        
+        # helper to go to the entry at index and parse the section name
+        def parse_section_name(index) # :nodoc:
+          return nil unless index = io_index[index]
+          io.pos = index[0] + 1
+          parse_content_type(io.readline)[:section_name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+require 'ms/mascot/dat/section'
+
+class Ms::Mascot::Dat::Header < Ms::Mascot::Dat::Section
+end

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

@@ -0,0 +1,23 @@
+require 'ms/mascot/dat/section'
+
+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

@@ -0,0 +1,4 @@
+require 'ms/mascot/dat/section'
+
+class Ms::Mascot::Dat::Masses < Ms::Mascot::Dat::Section
+end

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

@@ -0,0 +1,4 @@
+require 'ms/mascot/dat/section'
+
+class Ms::Mascot::Dat::Parameters < Ms::Mascot::Dat::Section
+end

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

@@ -0,0 +1,4 @@
+require 'ms/mascot/dat/section'
+
+class Ms::Mascot::Dat::Peptides < Ms::Mascot::Dat::Section
+end

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

@@ -0,0 +1,4 @@
+require 'ms/mascot/dat/section'
+
+class Ms::Mascot::Dat::Proteins < Ms::Mascot::Dat::Section
+end

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

@@ -0,0 +1,12 @@
+require 'ms/mascot/dat/section'
+
+class Ms::Mascot::Dat::Query < Ms::Mascot::Dat::Section
+  
+  attr_reader :index
+  
+  def initialize(data={}, section_name=self.class.section_name)
+    super(data, section_name)
+    @index = section_name.strip[5..-1].to_i
+  end
+
+end

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

@@ -0,0 +1,86 @@
+require 'strscan'
+
+module Ms
+  module Mascot
+    module Dat
+      
+      # Represents a 'section' section of a dat file, formatted like this:
+      #
+      #   Content-Type: application/x-Mascot; name="parameters"
+      #   
+      #   LICENSE=Licensed to: Matrix Science Internal use only - Frill, (4 processors).
+      #   MP=
+      #   NM=
+      #   COM=Peptide Mass Fingerprint Example
+      #   IATOL=
+      #   ...
+      #
+      # Example from mascot data F981122.dat
+      class Section
+        
+        # Matches a content-type declaration plus any preceding/following
+        # whitespace.  The section name is matched in slot 0.
+        CONTENT_TYPE_REGEXP = /\s*Content-Type: application\/x-Mascot; name=\"(.*?)\"\n\s*/
+        
+        # A format string used to format parameters as a string.
+        TO_S_FORMAT = "%s=%s\n"
+              
+        class << self
+          
+          # Parses a new instance from str.  Section after then content-type
+          # declaration are parsed into the parameters hash.  Section follow
+          # a simple "key=value\n" pattern.
+          def parse(str)
+            params = {}
+            scanner = StringScanner.new(str)
+            
+            # skip whitespace and content type declaration
+            unless scanner.scan(CONTENT_TYPE_REGEXP)
+              raise "unknown content type: #{content_type}"
+            end
+            section_name = scanner[1]
+            
+            # scan each pair.
+            while key = scanner.scan(/[^=]+/)
+              scanner.skip(/=/)
+              params[key] = scanner.scan(/[^\n]*/)
+              scanner.skip(/\n/)
+            end
+            
+            new(params, section_name)
+          end
+          
+          # Returns the name of the section represented by this class.  Section
+          # names are by default the downcase, unnested class name, for
+          # example:
+          #
+          #   Ms::Mascot::Dat::Section.section_name  # => "parameters"
+          #
+          def section_name
+            @section_name ||= to_s.split('::').last.downcase
+          end
+        end
+        
+        # A hash of data in self.
+        attr_reader :data
+        
+        # The class section_name.
+        attr_reader :section_name
+        
+        def initialize(data={}, section_name=self.class.section_name)
+          @data = data
+          @section_name = section_name
+        end
+        
+        # Formats self as a string with the content-type header.
+        def to_s
+          %Q{
+
+Content-Type: application/x-Mascot; name="#{section_name}"
+
+#{data.to_a.collect {|entry| TO_S_FORMAT % entry}.join}}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'ms/mascot/dat/section'
+
+# Summaries differ in their meaning depending on the type of search but the
+# content is in the same format.  The best way to add a sensible api and to
+# keep the basic archive lookup structure is to define modules that extend
+# a summary with, say an MS/MS ion search api.
+class Ms::Mascot::Dat::Summary < Ms::Mascot::Dat::Section
+end

data/lib/ms/mascot/dat/summary/id.rb

@@ -0,0 +1,54 @@
+require 'ms/mascot/dat/summary'
+
+module Ms
+  module Mascot
+    module Dat
+      class Summary
+        class Id < Ms::Mascot::Dat::Summary
+          class Peptide
+
+            class << self 
+              def from_strs(hit_string, hit_terms_string)
+                vals = hit_string.split(',')
+                vals.push( *(hit_terms_string.split(',')) )
+                self.new(*vals)
+              end
+
+              def from_hash(hash)
+                obj = self.new
+                hash.each do |k,v|
+                  obj[k.to_sym] = v
+                end
+              end
+            end
+            
+            PEPTIDE_ATTS = %w{
+              ui0 calc_mr delta start end num_match seq rank ui8 score ui11 ui12 ui13 ui14 ui15 res_before res_after
+            }.map {|v| v.to_sym }
+            
+            CASTING = {
+              :calc_mr => 'to_f', 
+              :delta => 'to_f', 
+              :start => 'to_i', 
+              :end => 'to_i', 
+              :num_match => 'to_i', 
+              :rank => 'to_i', 
+              :score => 'to_f'}
+            
+            PEPTIDE_ATTS.each do |attribute|
+              if cast_method = CASTING[attribute]
+                attr_writer attribute
+                define_method(attribute) do
+                  instance_variable_get("@#{attribute}").send(cast_method)
+                end
+              else
+                attr_accessor attribute
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end