ms-mascot 0.1.0 → 0.2.0

data/lib/ms/mascot/export.rb

@@ -1,19 +1,84 @@
-require 'tap/http/dispatch'
+require 'tap/http/submit'
 
 module Ms
   module Mascot
     # :startdoc::manifest exports results from a search
-    # UNDER CONSTRUCTION
-    class Export < Tap::Http::Dispatch
+    class Export < Tap::Http::Submit
     
-      def process(*mascot_files)
-        # generate request hashes for the mgf files using the
-        # configured parameters
-        requests = mascot_files.collect do |mascot_file| 
-          {:params => params.merge("file" => mascot_file)}
-        end
+      # The MatrixScience public search site
+      DEFAULT_URI = "http://www.matrixscience.com/cgi/export_dat_2.pl"
+
+      # Parameters for a typical export
+      DEFAULT_PARAMS = {
+        "pep_expect"=>"1",
+        "prot_mass"=>"1",
+        "protein_master"=>"1",
+        "_server_mudpit_switch"=>"0.000000001",
+        "pep_exp_mz"=>"1",
+        "do_export"=>"1",
+        "pep_delta"=>"1",
+        "export_format"=>"XML",
+        "prot_acc"=>"1",
+        "pep_score"=>"1",
+        "show_format"=>"1",
+        "_showsubsets"=>"0",
+        "_show_decoy_report"=>"",
+        "pep_scan_title"=>"1",
+        "pep_miss"=>"1",
+        "pep_calc_mr"=>"1",
+        "pep_exp_mr"=>"1",
+        "prot_score"=>"1",
+        "pep_query"=>"1",
+        "peptide_master"=>"1",
+        "prot_matches"=>"1",
+        "_onlyerrortolerant"=>"",
+        "_showallfromerrortolerant"=>"",
+        "prot_hit_num"=>"1",
+        "search_master"=>"1",
+        "_sigthreshold"=>"0.05",
+        "show_params"=>"1",
+        "show_mods"=>"1",
+        "show_header"=>"1",
+        "pep_isbold"=>"1",
+        "pep_seq"=>"1",
+        "pep_exp_z"=>"1",
+        "prot_desc"=>"1",
+        "_ignoreionsscorebelow"=>"0",
+        "REPORT"=>"AUTO",
+        "pep_rank"=>"1",
+        "pep_var_mod"=>"1",
+        "_noerrortolerant"=>""
+      }
 
-        super(*requests)
+      # Typical headers for an export
+      DEFAULT_HEADERS = {
+        "Keep-Alive"=>"300",
+        "Accept-Encoding"=>"gzip,deflate",
+        "Accept-Language"=>"en-us,en;q=0.5",
+        "Content-Type"=> "multipart/form-data; boundary=---------------------------168072824752491622650073",
+        "Accept-Charset"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+        "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Connection"=>"keep-alive"
+      }
+      
+      config :uri, DEFAULT_URI                           # The uri of the mascot search site
+      config :headers, DEFAULT_HEADERS, &c.hash          # a hash of request headers
+      config :params, DEFAULT_PARAMS, &c.hash            # a hash of query parameters
+      config :request_method, 'GET'                      # the request method (get or post)
+      config :version, 1.1                               # the HTTP version
+      config :redirection_limit, nil, &c.integer_or_nil  # the redirection limit for the request
+      
+      def process(result_filepath)
+        # duplicate the configurations
+        request = {}
+        config.each_pair do |key, value|
+          request[key] = value.kind_of?(Hash) ? value.dup : value
+        end
+        
+        # set filename for export
+        request[:params]['file'] = result_filepath
+        
+        super(request)
       end
     end 
   end

data/lib/ms/mascot/format_mgf.rb

@@ -0,0 +1,54 @@
+require 'ms/mascot/mgf/entry'
+
+module Ms
+  module Mascot
+    # :startdoc::manifest formats an fragment spectrum as mgf
+    #
+    # Formats the data produced by an Ms::Mascot::Fragment task as an mgf. The
+    # configurations specify various details of the dump, including the
+    # precision and default headers.
+    #
+    #   % rap fragment TVQQEL --:s format_mgf
+    #
+    # (note: be sure to use the splat option on the join)
+    #
+    class FormatMgf < Tap::Task
+      
+      config :default_headers, {}, &c.hash        # a hash of default headers
+      config :min_length, 3, &c.integer_or_nil    # the minimum peptide length
+      config :mz_precision, 6, &c.integer         # the precision of mzs
+      config :intensity_precision, 0, &c.integer  # the precision of intensities
+      config :pepmass_precision, 6, &c.integer    # the precision of peptide mass
+      
+      config :prefix, nil, &c.string_or_nil       # an optional prefix
+      config :suffix, "\n", &c.string_or_nil      # an optional suffix
+      
+      # Maps header keys (typically output by a fragment task)
+      # to Mgf::Entry header strings.
+      HEADER_MAP = {:parent_ion_mass => 'PEPMASS'}
+      
+      def process(data, headers)
+        lines = []
+        lines << prefix if prefix
+        
+        mgf_headers = format_headers(headers)
+        Ms::Mascot::Mgf::Entry.new(mgf_headers, data).dump(lines, config)
+        
+        lines << suffix if suffix
+        lines.join("")
+      end
+      
+      protected
+      
+      # helper to format the headers properly for an mgf entry
+      def format_headers(headers) # :nodoc:
+        mgf_headers = {}
+        default_headers.merge(headers).each_pair do |key, value|
+          key = HEADER_MAP[key] || key.to_s.upcase
+          mgf_headers[key] = value
+        end
+        mgf_headers
+      end
+    end
+  end
+end

data/lib/ms/mascot/fragment.rb

@@ -4,36 +4,40 @@ require 'ms/mascot/spectrum'
 module Ms
   module Mascot
   
-    # Ms::Mascot::Fragment::manifest calculates a theoretical Mascot ms/ms spectrum
+    # :startdoc::manifest calculates a theoretical Mascot ms/ms spectrum
     #
-    # Calculates the parent ion mass and theoretical ms/ms spectrum for a peptide
-    # sequence.  Configurations allow the specification of one or more
-    # fragmentation series to include, as well as charge, and intensity.
-    # 
-    #   % rap fragment TVQQEL --+ dump --no-audit
-    #   # date: 2008-09-15 14:37:55
-    #   ---
-    #   ms/mascot/fragment (:...:):
-    #   - - 717.3777467
-    #     - - 102.054955
-    #       - 132.1019047
-    #       - 201.123369
-    #       - 261.1444977
-    #       - 329.181947
-    #       - 389.2030757
-    #       - 457.240525
-    #       - 517.2616537
-    #       - 586.283118
-    #       - 616.3300677
-    # 
-    # In the output, the parent ion mass is given first, followed by an array of
-    # the sorted fragmentation data.
+    # Calculates the theoretical Mascot ms/ms spectrum for a peptide sequence.
+    # A Mascot spectrum differs from the standard in-silico spectrum only in
+    # the masses that get used.  By default Mascot::Fragment uses masses with
+    # 6 significant digits, the same masses that Mascot uses by default, and
+    # generates spectra with an intensity of 1.
+    #
+    # In addition, Mascot::Fragment supports several alternative series notations.
+    #
+    #   Notation     Translation    Example
+    #   series+<n>   series + Hn    a++, y0++
+    #   series*      series - NH3   b*
+    #   series0      series - H2O   y0
+    #   Immon.       immonium       Immon.
+    #
+    # See Ms::Mascot::Spectrum for more details.
     class Fragment < InSilico::Fragment
-
+      
+      config :intensity, 1, &c.num_or_nil  # a uniform intensity value
+      
+      # Generates some MGF-specific headers.
+      def headers(spec)
+        {
+          :charge => charge,
+          :parent_ion_mass => spec.parent_ion_mass(charge),
+          :title => "#{spec.sequence} (#{series.join(', ')})"
+        }
+      end
+      
+      # Returns a Mascot::Spectrum for the peptide.
       def spectrum(peptide)
         Mascot::Spectrum.new(peptide, nterm, cterm)
       end
-      
     end
   end
 end

data/lib/ms/mascot/mgf.rb

@@ -1,2 +1,35 @@
-require 'mascot/formats/mgf/entry'
-require 'mascot/formats/mgf/archive'
+require 'ms/mascot/mgf/entry'
+require 'ms/mascot/mgf/archive'
+
+module Ms
+  module Mascot
+    module Mgf
+      class << self
+        # Opens the file and yields an array of entries (well, the array is
+        # actually an Ms::Mascot::Mgf::Archive object that acts like an array
+        # but leaves data on disk until needed)
+        #
+        #   Ms::Mascot::Mgf.open("file.mgf") do |ar|
+        #     entry5 = ar[4]  # -> 5th entry
+        #     entry5.pepmass  # -> peptide mass
+        #     entry5.data     # -> array of arrays
+        #   end
+        def open(file, &block)
+          File.open(file) do |io|
+            a = Archive.new(io)
+            a.reindex
+            block.call(a)
+            a.close
+          end
+        end
+
+        # returns each entry in the mgf file, like IO.foreach
+        def foreach(file, &block)
+          open(file) do |ar|
+            ar.each &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ms/mascot/mgf/entry.rb

@@ -54,7 +54,17 @@ module Ms
         
         # The peptide mass of the entry
         attr_accessor :pepmass
-        
+
+        # returns the title of the entry (or nil if none)
+        def title
+          @headers['TITLE']
+        end
+
+        # sets the title
+        def title=(string)
+          @headers['TITLE'] = string
+        end
+
         # The data (mz/intensity) for the entry
         attr_accessor :data
         
@@ -129,8 +139,16 @@ module Ms
             
           target << "CHARGE=#{charge_to_s}\n"
           target << "PEPMASS=#{format options[:pepmass_precision]}\n" % pepmass
-
-          data_format = "#{format options[:mz_precision]} #{format options[:intensity_precision]}\n"
+          
+          entry = data[0]
+          data_format = case
+          when entry == nil then nil
+          when entry.kind_of?(Array) && entry.length == 2
+            "#{format options[:mz_precision]} #{format options[:intensity_precision]}\n"
+          else
+            "#{format options[:mz_precision]}\n"
+          end
+          
           data.each do |data_point|
             target << (data_format % data_point)
           end
@@ -153,10 +171,10 @@ module Ms
 
         # returns a format string for the specified precision
         def format(precision) # :nodoc:
-          precision == nil ? "%s" : "%.#{precision}f"
+          (precision == nil || precision == 0) ? "%s" : "%.#{precision}f"
         end
         
       end
     end
   end
-end
+end

data/lib/ms/mascot/spectrum.rb

@@ -44,6 +44,21 @@ module Ms
     #
     # Spectrum calculates peptide mass using the masses in mass_map, 
     # ie the rounded residue masses.
+    #
+    # === Mascot-Specific Series Notation
+    #
+    # Mascot::Spectrum adds support for a few mascot-specific notations.
+    #
+    #   Notation     Translation    Example
+    #   series+<n>   series + Hn    a++, y0++
+    #   series*      series - NH3   y*
+    #   series0      series - H2O   a0
+    #   Immon.       immonium       Immon.
+    #
+    # It should be noted that Mascot applies unknown masks to these values;
+    # when using these types of series, Spectrum will often predict peaks
+    # that do not appear in a Mascot search result.
+    #
     class Spectrum < InSilico::Spectrum
       Element = Constants::Libraries::Element
       
@@ -171,11 +186,11 @@ module Ms
       #
       def handle_unknown_series(s)
         case s
-        when /^([\w\+\-]+)+(\d+)$/
+        when /^([abcxyYz][\+\-]+)+(\d+)$/
           self.series("#{$1} +H#{$2.to_i}")
-        when /^(\w+)\*(\+*-*)$/
+        when /^([abcxyYz])\*(\+*-*)$/
           self.series("#{$1}#{$2} -NH3")
-        when /^(\w+)0(\+*-*)$/
+        when /^([abcxyYz])0(\+*-*)$/
           self.series("#{$1}#{$2} -H2O")
         when /^Immon\.(.*)$/
           self.series("immonium#{$1}")

data/lib/ms/mascot/submit.rb

@@ -1,41 +1,132 @@
-require 'tap/http/dispatch'
+require 'tap/http/submit'
 
 module Ms
   module Mascot
-    # :startdoc::manifest submits an mgf file
-    # UNDER CONSTRUCTION
-    class Submit < Tap::Http::Dispatch
-      RESULT_REGEXP = /<A HREF="..\/cgi\/master_results.pl\?file=(.*?\.dat)">/im
-      ERROR_REGEXP = /<BR>The following error has occured getting your search details:<BR>(.*?)<BR>/im
-      MISTAKE_REGEXP = /<BR>Sorry, your search could not be performed due to the following mistake entering data.<BR>(.*?)<BR>/im
-      
-      def process(*mgf_files)
-        # generate request hashes for the mgf files using the
-        # configured parameters
-        requests = mgf_files.collect do |mgf_file|
-          file = {'Content-Type' => 'application/octet-stream', 'Filename' => mgf_file}  
-          {:params => params.merge("FILE" => file)}
+    # :startdoc::manifest submits a PMF or MS/MS search to Mascot
+    #
+    # Submits a search request to Mascot using the mgf file and the search
+    # parameters in a static config file.  Correctly formatting search
+    # config file is technical since it must contain the correct fields for
+    # Submit to recreate a Mascot HTTP search request.
+    #
+    # The easiest way to capture search parameters in the correct format is
+    # to use TapHttpFrom the command line, invoke:
+    #
+    #   % tap server
+    #
+    # Then visit 'http://localhost:8080/capture/tutorial' in a browser and
+    # apply the capture procedure to the Mascot search page.  Once you have
+    # the .yml config file, use this command to submit a search.
+    #
+    #   % rap submit <mgf_file> --config <config_file> --: dump
+    #
+    # A convenient aspect of this setup is that you can capure parameters
+    # once, then re-use them for a number of mgf files.
+    #
+    # Note that the default Submit configuration uses parameters are typical
+    # for MS/MS searching of a human sample digested with trypsin.  These
+    # values MUST be overridden and are only provided as a template (for
+    # those that want the adventure of manually making a config file).
+    #
+    class Submit < Tap::Http::Submit
+      
+      # The MatrixScience public search site
+      DEFAULT_URI = "http://www.matrixscience.com/cgi/nph-mascot.exe?1"
+      
+      # Parameters for MS/MS searching of a human sample digested with trypsin.
+      DEFAULT_PARAMS = {
+        "ErrTolRepeat"=>"0",
+        "PFA"=>"1",
+        "INSTRUMENT"=>"Default",
+        "REPTYPE"=>"peptide",
+        "COM"=>"Search Title",
+        "FORMAT"=>"Mascot generic",
+        "PEAK"=>"AUTO",
+        "CHARGE"=>"2+",
+        "INTERMEDIATE"=>"",
+        "SHOWALLMODS"=>"",
+        "PRECURSOR"=>"",
+        "USERNAME"=>"Name",
+        "TOLU"=>"ppm",
+        "USEREMAIL"=>"email@email.com",
+        "CLE"=>"Trypsin",
+        "TOL"=>"100",
+        "ITOLU"=>"Da",
+        "QUANTITATION"=>"None",
+        "SEARCH"=>"MIS",
+        "DB"=>"SwissProt",
+        "PEP_ISOTOPE_ERROR"=>"0",
+        "ITOL"=>"0.6",
+        "FORMVER"=>"1.01",
+        "IT_MODS"=> [
+          "Acetyl (Protein N-term)",
+          "Gln->pyro-Glu (N-term Q)",
+          "Oxidation (M)"],
+        "MASS"=>"Monoisotopic",
+        "REPORT"=>"AUTO",
+        "TAXONOMY"=>". . . . . . . . . . . . . . . . Homo sapiens (human)"
+      }
+      
+      # Typical headers for an MS/MS search.
+      DEFAULT_HEADERS = {
+       "Keep-Alive"=>"300",
+       "Accept-Encoding"=>"gzip,deflate",
+       "Accept-Language"=>"en-us,en;q=0.5",
+       "Content-Type"=> "multipart/form-data; boundary=---------------------------168072824752491622650073",
+       "Accept-Charset"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+       "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+       "Connection"=>"keep-alive"
+      }
+      
+      # Matches a successful search response.  After the match:
+      #
+      #  $1:: the result file
+      SUCCESS_REGEXP = /<A HREF="\.\.\/cgi\/master_results\.pl\?file=(.*?)">Click here to see Search Report<\/A>/
+      
+      # Matches a failure response.  After the match:
+      #
+      #  $1:: the failure message
+      FAILURE_REGEXP = /<BR>(.*)/m
+      
+      config :uri, DEFAULT_URI                           # The uri of the mascot search site
+      config :headers, DEFAULT_HEADERS, &c.hash          # a hash of request headers
+      config :params, DEFAULT_PARAMS, &c.hash            # a hash of query parameters
+      config :request_method, 'POST'                     # the request method (get or post)
+      config :version, 1.1                               # the HTTP version
+      config :redirection_limit, nil, &c.integer_or_nil  # the redirection limit for the request
+      
+      def process(mgf_file)
+        
+        # duplicate the configurations
+        request = {}
+        config.each_pair do |key, value|
+          request[key] = value.kind_of?(Hash) ? value.dup : value
         end
-
-        super(*requests)
+        
+        # set filename for upload
+        file = request[:params]['FILE'] ||= {}
+        file['Filename'] = mgf_file
+        file['Content-Type'] = 'application/octet-stream'
+        file.delete('Content')
+        
+        # submit request
+        parse_response_body super(request)
       end
       
-      # Hook for processing a response.  By default process_response 
-      # simply logs the response message and returns the response. 
-      def process_response(res)
-        case res.body
-        when RESULT_REGEXP 
-          log(res.message, $1)
+      # Processes the response body.  Returns the result file if the body
+      # indicates a success, or nil if the body indicates a failure.
+      def parse_response_body(body)
+        case body
+        when SUCCESS_REGEXP
+          log :success, $1
           $1
-          
-        when ERROR_REGEXP
-          raise ResponseError, "error: #{$1.strip}"
-        when MISTAKE_REGEXP 
-          raise ResponseError, "mistake: #{$1.strip}"
+        when FAILURE_REGEXP 
+          log :failure, $1.gsub("<BR>", "\n")
+          nil
         else 
-          raise ResponseError, "unknown error:\n#{res.body}"
+          raise "unparseable response: #{body}"
         end
       end
-    end 
+    end
   end
 end