ms-mascot 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008, Regents of the University of Colorado.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,22 @@
+= {Ms-Mascot}[http://mspire.rubyforge.org/projects/ms-mascot]
+
+An {Mspire}[http://mspire.rubyforge.org] library supporting {Mascot}[http://www.matrixscience.com/].
+
+== Description
+
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/16692-mspire/tickets]
+* Github[http://github.com/bahuvrihi/ms-mascot/tree/master]
+* {Google Group}[http://groups.google.com/group/mspire-forum]
+
+== Installation
+
+Ms-Mascot is available as a gem on RubyForge[http://rubyforge.org/projects/mspire].  Use:
+
+  % gem install ms-mascot
+
+== Info 
+
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/cmd/generate_mgf.rb

@@ -0,0 +1,123 @@
+# = Usage
+# tap generate_mgf {options} protein_sequences
+#
+# When specifying the ions to include, alternate charge states can be
+# specified using + and -, for example 'y++' or 'b-'.  The available ion
+# series are [a,b,c,x,y,z].
+#
+# = Description
+# Digests, fragments, then formats the protein sequences into mgf files.
+# Use the options to specify/modify digestion enzymes, as well as the
+# type of ions to generate.  
+#
+# = Information
+#
+# Copyright (c) 2006-2007, Regents of the University of Colorado.
+# Developer:: Simon Chiang, Biomolecular Structure Program
+# Homepage:: http://hsc-proteomics.uchsc.edu/hansen_lab
+# Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+#
+
+require 'tap/script'
+include Constants::Library
+
+app = Tap::App.instance   
+
+#
+# handle options
+#
+
+opts = Prospector::Digest.configurations.to_opts 
+opts += Mascot::Formats::Mgf::Print.configurations.to_opts
+opts += [
+  ['--charge', '-c', GetoptLong::REQUIRED_ARGUMENT, "Parent ion charge for mgf files. (default +1)"],
+  
+  ['--ions', '-i', GetoptLong::REQUIRED_ARGUMENT, "Comma-separated string of ion series to include. (default 'yb')"],
+  #['--enzyme_file', nil, GetoptLong::REQUIRED_ARGUMENT, "Specifes a Prospector-style enzyme config file."],
+  ['--residue_precision', nil, GetoptLong::REQUIRED_ARGUMENT, "The precision of residues, ex 6 for 57.021464"],
+  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."],
+  ['--debug', nil, GetoptLong::NO_ARGUMENT, "Specifes debug mode."]]
+
+digest_config = {}
+print_config = {}
+series = "yb"
+charge = 1
+residue_precision = 6
+
+Tap::Script.handle_options(*opts) do |opt, value| 
+  case opt
+  when '--help'
+    puts Tap::Script.usage(__FILE__, "Usage", "Description", "Information", :keep_headers => false)
+    puts
+    puts Tap::Script.usage_options(opts)
+    exit
+    
+  when '--debug'
+    app.options.debug = true
+    
+  when '--ions'
+    series = value
+    
+  when '--charge'
+    charge = value.to_i
+    
+  when '--residue_precision'
+    residue_precision = value.to_i
+    
+  else
+    key = Prospector::Digest.configurations.opt_map(opt)
+    digest_config[key] = YAML.load(value) if key
+    
+    key = Mascot::Formats::Mgf::Print.configurations.opt_map(opt)
+    print_config[key] = YAML.load(value) if key
+  end
+end
+
+if ARGV.empty?
+  puts "no sequences specified"
+  exit
+end
+
+#
+# add your script code here
+#
+series = series.scan(/\w\-*\+*/)
+
+#loader = Prospector::LoadDigesters.new
+#loader.enq(enzyme_file)
+
+#
+digest = Prospector::Digest.new(nil, digest_config)
+
+#
+n = Molecule[digest.nterm]
+c = Molecule[digest.cterm]
+
+fragment = Tap::Task.new do |task, polypeptides|
+  polypeptides.collect do |polypeptide, start_index, end_index|
+    task.log :fragment, polypeptide.sequence[0..10] + (polypeptide.sequence.length > 10 ? "..." : "")
+    
+    f = Mascot::FragmentSpectrum.new(polypeptide.sequence, n, c, residue_precision)
+  
+    headers = {
+      :title => polypeptide.sequence,
+      :charge => charge,
+      :pepmass => (f.mass(n) + f.ladder.last + f.mass(c) + charge * f.proton_mass)/charge
+    }
+  
+    data = series.collect {|s| f.series(s)}.flatten.delete_if {|mass| mass < 0 }.sort
+    data = [data, Array.new(data.length, 1)].transpose
+  
+    Mascot::Formats::Mgf::Entry.new(headers, data)
+  end
+end
+
+#
+print = Mascot::Formats::Mgf::Print.new('generate_mgf', print_config)
+
+# workflow
+digest.enq(*ARGV)
+ARGV.clear 
+
+app.sequence(digest, fragment, print)
+app.run

data/cmd/generate_prospector_mgf.rb

@@ -0,0 +1,123 @@
+# = Usage
+# tap generate_mgf {options} protein_sequences
+#
+# When specifying the ions to include, alternate charge states can be
+# specified using + and -, for example 'y++' or 'b-'.  The available ion
+# series are [a,b,c,x,y,z].
+#
+# = Description
+# Digests, fragments, then formats the protein sequences into mgf files.
+# Use the options to specify/modify digestion enzymes, as well as the
+# type of ions to generate.  
+#
+# = Information
+#
+# Copyright (c) 2006-2007, Regents of the University of Colorado.
+# Developer:: Simon Chiang, Biomolecular Structure Program
+# Homepage:: http://hsc-proteomics.uchsc.edu/hansen_lab
+# Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+#
+
+require 'tap/script'
+include Constants::Library
+
+app = Tap::App.instance   
+
+#
+# handle options
+#
+
+opts = Prospector::Digest.configurations.to_opts 
+opts += Mascot::Formats::Mgf::Print.configurations.to_opts
+opts += [
+  ['--charge', '-c', GetoptLong::REQUIRED_ARGUMENT, "Parent ion charge for mgf files. (default +1)"],
+  
+  ['--ions', '-i', GetoptLong::REQUIRED_ARGUMENT, "Comma-separated string of ion series to include. (default 'yb')"],
+  #['--enzyme_file', nil, GetoptLong::REQUIRED_ARGUMENT, "Specifes a Prospector-style enzyme config file."],
+  ['--residue_precision', nil, GetoptLong::REQUIRED_ARGUMENT, "The precision of residues, ex 6 for 57.021464"],
+  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."],
+  ['--debug', nil, GetoptLong::NO_ARGUMENT, "Specifes debug mode."]]
+
+digest_config = {}
+print_config = {}
+series = "yb"
+charge = 1
+residue_precision = 6
+
+Tap::Script.handle_options(*opts) do |opt, value| 
+  case opt
+  when '--help'
+    puts Tap::Script.usage(__FILE__, "Usage", "Description", "Information", :keep_headers => false)
+    puts
+    puts Tap::Script.usage_options(opts)
+    exit
+    
+  when '--debug'
+    app.options.debug = true
+    
+  when '--ions'
+    series = value
+    
+  when '--charge'
+    charge = value.to_i
+    
+  when '--residue_precision'
+    residue_precision = value.to_i
+    
+  else
+    key = Prospector::Digest.configurations.opt_map(opt)
+    digest_config[key] = YAML.load(value) if key
+    
+    key = Mascot::Formats::Mgf::Print.configurations.opt_map(opt)
+    print_config[key] = YAML.load(value) if key
+  end
+end
+
+if ARGV.empty?
+  puts "no sequences specified"
+  exit
+end
+
+#
+# add your script code here
+#
+series = series.scan(/\w\-*\+*/)
+
+#loader = Prospector::LoadDigesters.new
+#loader.enq(enzyme_file)
+
+#
+digest = Prospector::Digest.new(nil, digest_config)
+
+#
+n = Molecule[digest.nterm]
+c = Molecule[digest.cterm]
+
+fragment = Tap::Task.new do |task, polypeptides|
+  polypeptides.collect do |polypeptide, start_index, end_index|
+    task.log :fragment, polypeptide.sequence[0..10] + (polypeptide.sequence.length > 10 ? "..." : "")
+    
+    f = Prospector::FragmentSpectrum.new(polypeptide.sequence, n, c)
+  
+    headers = {
+      :title => polypeptide.sequence,
+      :charge => charge,
+      :pepmass => (n.mass + polypeptide.mass + c.mass + charge * (Molecule['H'].mass - Particle['Electron'].mass))/charge
+    }
+  
+    data = series.collect {|s| f.series(s)}.flatten.delete_if {|mass| mass < 0 }.sort
+    data = [data, Array.new(data.length, 1)].transpose
+  
+    Mascot::Formats::Mgf::Entry.new(headers, data)
+  end
+end
+
+#
+print = Mascot::Formats::Mgf::Print.new('generate_mgf', print_config)
+
+# workflow
+digest.enq(*ARGV)
+ARGV.clear 
+
+app.sequence(digest, fragment, print)
+app.run

data/cmd/reformat_mgf.rb

@@ -0,0 +1,90 @@
+# = Usage
+# tap reformat_mgf {options} MGF_FILES
+#
+# = Description
+# Reformats mgf files to a standard output like:
+#
+#   BEGIN IONS
+#   TITLE=7100401blank.190.190.2.dta
+#   CHARGE=2+
+#   PEPMASS=321.571138
+#   100.266 2.0
+#   111.323 2.5
+#   ...
+#   496.110 3.3
+#   601.206 1.3
+#   END IONS
+#
+# = Information
+#
+# Copyright (c) 2006-2007, Regents of the University of Colorado.
+# Developer:: Simon Chiang, Biomolecular Structure Program
+# Homepage:: http://hsc-proteomics.uchsc.edu/hansen_lab
+# Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+#
+require 'tap/script'
+
+app = Tap::App.instance   
+
+#
+# handle options
+#
+
+opts = [
+  ['--target_dir', '-t', GetoptLong::REQUIRED_ARGUMENT, "Specify an output directory."],
+  ['--mz_precision', '-m', GetoptLong::REQUIRED_ARGUMENT, "Specify the mz precision."],
+  ['--intensity_precision', '-i', GetoptLong::REQUIRED_ARGUMENT, "Specify the intensity precision."],
+  ['--pepmass_precision', '-p', GetoptLong::REQUIRED_ARGUMENT, "Specify the peptide mass precision."],
+  ['--headers', nil, GetoptLong::REQUIRED_ARGUMENT, "Specify the headers to include, separated by commas."],
+  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."],
+  ['--debug', nil, GetoptLong::NO_ARGUMENT, "Specifies debug mode."]]
+
+config = {:target_dir => 'reformatted'}
+
+Tap::Script.handle_options(*opts) do |opt, value| 
+  case opt
+  when '--help'
+    puts Tap::Script.usage(__FILE__, "Usage", "Description", "Information", :keep_headers => false)
+    puts
+    puts Tap::Script.usage_options(opts)
+    exit
+    
+  when '--debug'
+    app.options.debug = true
+
+  when '--headers'
+    value = value[1..-2] if value[0] == 34 && value[-1] == 34
+    config[:headers] = value.split(/,/).collect {|header| header.strip}
+  else
+    opt =~ /--(.*)/
+    config[$1.to_sym] = value
+  
+  end
+end
+
+#
+# add your script code here
+#
+
+require 'mascot/formats/mgf'
+
+reformat = Tap::FileTask.new("", config) do |task, input|
+  target = task.filepath(task.config[:target_dir], File.basename(input))
+  task.prepare(target)
+
+  task.log_basename :reformatting, input
+  Mascot::Formats::Mgf::Archive.open(input) do |archive|
+    archive.reindex if archive.length == 0
+    
+    File.open(target, "wb") do |output|
+      archive.each do |mgf|
+        mgf.puts(output, task.config)
+        output.puts
+      end
+    end
+  end
+end
+
+args = ARGV.dup
+ARGV.clear
+app.run(reformat, *args)

data/lib/ms/mascot.rb

@@ -0,0 +1,5 @@
+module Ms
+  module Mascot
+    FRAGMENT_TEST_MASS_UNCERTAINTY = 10**-2
+  end
+end

data/lib/ms/mascot/export.rb

@@ -0,0 +1,20 @@
+require 'tap/http/dispatch'
+
+module Ms
+  module Mascot
+    # :startdoc::manifest exports results from a search
+    # UNDER CONSTRUCTION
+    class Export < Tap::Http::Dispatch
+    
+      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
+
+        super(*requests)
+      end
+    end 
+  end
+end

data/lib/ms/mascot/fragment.rb

@@ -0,0 +1,39 @@
+require 'ms/in_silico/fragment'
+require 'ms/mascot/spectrum'
+
+module Ms
+  module Mascot
+  
+    # Ms::Mascot::Fragment::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.
+    class Fragment < InSilico::Fragment
+
+      def spectrum(peptide)
+        Mascot::Spectrum.new(peptide, nterm, cterm)
+      end
+      
+    end
+  end
+end

data/lib/ms/mascot/mgf.rb

@@ -0,0 +1,2 @@
+require 'mascot/formats/mgf/entry'
+require 'mascot/formats/mgf/archive'

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

@@ -0,0 +1,24 @@
+require 'external'
+require 'ms/mascot/mgf/entry'
+
+module Ms
+  module Mascot
+    module Mgf
+
+      # Provides array-like access to an mgf archival file.
+      class Archive < ExternalArchive
+
+        # Reindexes self to each mgf entry in io
+        def reindex(&block)
+          reindex_by_sep("BEGIN IONS", :entry_follows_sep => true, &block)
+        end
+
+        # Returns an Mgf::Entry initialized using str
+        def str_to_entry(str)
+          Entry.parse(str)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+module Ms
+  module Mascot
+    module Mgf
+
+      # Represents a mascot generic file (mgf) formatted entry. 
+      #
+      #   BEGIN IONS
+      #   TITLE=7100401blank.190.190.2.dta
+      #   CHARGE=2+
+      #   PEPMASS=321.571138
+      #   100.266 2.0
+      #   111.323 2.5
+      #   ...
+      #   496.110 3.3
+      #   601.206 1.3
+      #   END IONS
+      #
+      class Entry
+        class << self
+
+          # Parses the entry string into an Mgf::Entry.  The entry must be
+          # complete and properly formatted, ie it must begin with a 
+          # 'BEGIN IONS' line and end with an 'END IONS' line.
+          def parse(str)
+            entry = Entry.new
+
+            lines = str.strip.split(/\s*\r?\n\s*/)
+
+            unless lines.shift == "BEGIN IONS"
+              raise ArgumentError, "input should begin with 'BEGIN IONS'"
+            end
+
+            unless lines.pop == "END IONS"
+              raise ArgumentError, "input should end with 'END IONS'"
+            end
+
+            lines.each do |line|
+              if line =~ /^(.*?)=(.*)$/
+                entry[$1] = $2
+              else
+                entry.data << line.split(/\s+/, 2).collect {|i| i.to_f }
+              end
+            end
+
+            entry
+          end
+        end
+
+        # A hash of mgf headers, not including CHARGE and PEPMASS
+        attr_reader :headers
+        
+        # The charge of the entry
+        attr_accessor :charge
+        
+        # The peptide mass of the entry
+        attr_accessor :pepmass
+        
+        # The data (mz/intensity) for the entry
+        attr_accessor :data
+        
+        # Initialized a new Entry using the headers and data.  Set charge
+        # and pepmass using the CHARGE and PEPMASS headers.
+        def initialize(headers={}, data=[])
+          @headers = {}
+          @pepmass = nil
+          @charge = nil
+          @data = data
+
+          headers.each_pair do |key, value|
+            self[key] = value
+          end
+        end
+
+        # Retrieve a header using an mgf header string.  CHARGE and PEPMASS 
+        # headers can be retrieved using [], and will reflect the current
+        # values of charge and pepmass.  Keys are stringified and upcased.
+        def [](key)
+          key = key.to_s.upcase
+          case key
+          when "PEPMASS" then pepmass.to_s
+          when "CHARGE" then charge_to_s
+          else headers[key]
+          end
+        end
+
+        # Set a header using an mgf header string.  CHARGE and PEPMASS headers
+        # may be set using using []=, and will modify the current values of
+        # charge and pepmass.  Keys are stringified and upcased.
+        def []=(key, value)
+          key = key.to_s.upcase
+          case key
+          when "PEPMASS" 
+            self.pepmass = value.to_f
+          when "CHARGE" 
+            value = case value
+            when Fixnum then value
+            when /^(\d+)([+-])$/ then $1.to_i * ($2 == "+" ? 1 : -1) 
+            else raise "charge should be an number, or a string formatted like '1+' or '1-'"
+            end
+            
+            self.charge = value
+          else
+            headers[key] = value
+          end
+        end
+
+        # Formats and puts self to the target.  Use the options to modify the
+        # output:
+        #
+        # headers:: an array of headers to include (by default all headers 
+        #           will be included; pepmass and charge will always be 
+        #           included)
+        # pepmass_precision::  integer value specifying precision of pepmass
+        # mz_precision::  integer value specifying precision of mz values
+        # intensity_precision:: integer value specifying precision of intensity
+        #                       values
+        def dump(target="", options={})
+          options = {
+            :mz_precision => nil,
+            :intensity_precision => nil,
+            :pepmass_precision => nil,
+            :headers => nil
+          }.merge(options)
+
+          target << "BEGIN IONS\n"
+          (options[:headers] || headers.keys).each do |key|
+            target << "#{key.upcase}=#{headers[key]}\n"
+          end
+            
+          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"
+          data.each do |data_point|
+            target << (data_format % data_point)
+          end
+          
+          target << "END IONS\n"
+          target
+        end
+
+        # Returns self formatted as a string
+        def to_s
+          dump
+        end
+
+        private
+        
+        # formats the charge as a string
+        def charge_to_s # :nodoc:
+          charge == nil ? "" : "#{charge.abs}#{charge > 0 ? '+' : '-'}"
+        end
+
+        # returns a format string for the specified precision
+        def format(precision) # :nodoc:
+          precision == nil ? "%s" : "%.#{precision}f"
+        end
+        
+      end
+    end
+  end
+end

data/lib/ms/mascot/predict.rb

@@ -0,0 +1,94 @@
+require 'ms/in_silico/digest'
+require 'ms/mascot/fragment'
+require 'ms/mascot/mgf/archive'
+
+module Ms
+  module Mascot
+
+    # Ms::Mascot::Predict::manifest predicts the spectra for a protein sequence
+    #
+    # Fragments a protein sequence and calculates the fragment spectra for
+    # each peptide.  The peptide spectra are formatted as mgf and dumped to
+    # the target. 
+    #
+    #   % rap predict MAEELVLERCDLELETNGRDHHTADLCREKLVVRRGQPFWLTLHFEGRNYEASVDSLTFS
+    #     I[16:30:19]             digest MAEELVLERCD... to 15 peptides
+    #     I[16:30:19]           fragment MAEELVLER
+    #     I[16:30:19]           fragment MAEELVLERCDLELETNGR
+    #     I[16:30:19]           fragment CDLELETNGR
+    #     I[16:30:19]           fragment CDLELETNGRDHHTADLCR
+    #     I[16:30:19]           fragment DHHTADLCR
+    #     I[16:30:19]           fragment DHHTADLCREK
+    #     I[16:30:19]           fragment EKLVVR
+    #     I[16:30:19]           fragment LVVR
+    #     I[16:30:19]           fragment LVVRR
+    #     I[16:30:19]           fragment RGQPFWLTLHFEGR
+    #     I[16:30:19]           fragment GQPFWLTLHFEGR
+    #     I[16:30:19]           fragment GQPFWLTLHFEGRNYEASVDSLTFS
+    #     I[16:30:19]           fragment NYEASVDSLTFS
+    #
+    class Predict < Tap::FileTask
+      define :digest, InSilico::Digest, {:max_misses => 1}
+      define :fragment, Mascot::Fragment, {:intensity => 1, :unmask => true, :sort => true}
+      
+      config :headers, nil, &c.hash_or_nil        # a hash of headers to include
+      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
+      
+      # Sequences digest and fragment.  When fragment completes, it will add
+      # a new mgf entry to the internal entries collection.
+      def workflow
+        digest.on_complete do |_results|
+          _results._iterate.each do |_result|
+            next if min_length && _result._current.length < min_length
+            fragment._execute(_result)
+          end
+        end
+     
+        fragment.on_complete do |_result|
+          parent_ion_mass, data = _result._current
+          next if data.empty?
+          
+          peptide = _result._values[-2]
+          headers = {
+            'TITLE' => "#{peptide} (#{fragment.series.join(', ')})",
+            'CHARGE' => fragment.charge,
+            'PEPMASS' => parent_ion_mass}
+          
+          @entries << Mgf::Entry.new(headers, data) 
+        end
+      end
+      
+      # Infers a default path for the output mgf file from the sequence; the 
+      # path is the sequence if the sequence is less than 10 characters,
+      # otherwise it's like: "<first five>_<last five>.mgf"
+      #
+      def default_path(sequence)
+        sequence = "#{sequence[0,5]}_#{sequence[-5,5]}" if sequence.length > 10
+        "#{sequence}.mgf"
+      end
+      
+      def process(sequence, target=nil)
+        sequence = sequence.gsub(/\s/, "")
+        
+        @entries = []
+        digest.execute(sequence)
+        
+        # prepare and dump the predicted spectra
+        # to the target path.
+        target = default_path(sequence) if target == nil
+        prepare(target)
+        File.open(target, "wb") do |file|
+          @entries.each do |entry|
+            entry.dump(file, config)
+            file.puts 
+          end
+        end
+        
+        target
+      end
+    end 
+  end
+end

data/lib/ms/mascot/spectrum.rb

@@ -0,0 +1,188 @@
+require 'ms/in_silico/spectrum'
+
+module Ms
+  module Mascot
+    
+    # Generates a Mascot-style theoretical spectrum.  When the masses are
+    # set correctly, the theoretical spectrum will have zero error and
+    # full coverage (for whatever series are generated) when identified
+    # using Mascot.
+    #
+    # === Peptide Mass Error
+    #
+    # The peptide mass calculated by Spectrum is inexact wrt to Mascot.
+    # Mascot uses some unknown algorithm to speed up it's calculation
+    # and introduces some rounding/truncation error somewhere along
+    # the line.  For instance, if you calculate the mass of a peptide
+    # by directly using the Unimod masses, it will NOT be the mass used
+    # by Mascot.  For example:
+    #
+    #   def molecule_mass(c, h, n, o, s)
+    #    c * 12 + h * 1.007825035 + n * 14.003074 + o * 15.99491463 + s * 31.9720707
+    #   end  
+    #
+    #   # Formula for MFSFVDLR: C(47)H(69)N(11)O(11)S(0)
+    #   # Formula for water:    C(0) H(2) N(0) O(1) S(0)
+    #
+    #   molecule_mass(47, 69, 11, 11, 1) + molecule_mass(0, 2, 0, 1, 0) 
+    #   # => 1013.500437745
+    #
+    # Now by comparision:
+    #
+    #    mascot: 1013.500443
+    #    unimod: 1013.500437745
+    #    delta:     0.000005255
+    #
+    # Similar or worse errors are typical and cannot be elimited by 
+    # any known permutation (calculating from the residue masses, 
+    # rounding etc). See http://gist.github.com/31241 for tasks that
+    # perform the calculation using various permutations.
+    #
+    # One helpful note if you try to break the code, you can set the 
+    # number of sig figs to 6 in mascot.dat (MassDecimalPlaces) and 
+    # read the exact peptide mass numbers directly from a result page.
+    #
+    # Spectrum calculates peptide mass using the masses in mass_map, 
+    # ie the rounded residue masses.
+    class Spectrum < InSilico::Spectrum
+      Element = Constants::Libraries::Element
+      
+      # A map of the default [monoisotopic, average] masses for a variety
+      # of constants used by Mascot.  The element masses can be traced
+      # back to {Unimod}[http://www.unimod.org/masses.html] and the
+      # residues calculated by using the Unimod masses, then rounding.
+      # 
+      #--
+      # Taken from the configuration pages on the Hansen Lab server:
+      #
+      # - http://hsc-mascot.uchsc.edu/mascot/x-cgi/ms-config.exe?u=1222975681&ELEMENTS_SHOW=1
+      # - http://hsc-mascot.uchsc.edu/mascot/x-cgi/ms-config.exe?u=1222975681&AMINOACIDS_SHOW=1
+      #
+      DEFAULT_MASS_MAP = {}
+      DEFAULT_MASS_MAP.merge!(
+        Residue::A => [71.037114, 71.0779],
+        Residue::R => [156.101111, 156.1857],
+        Residue::N => [114.042927, 114.1026],
+        Residue::D => [115.026943, 115.0874],
+        Residue::C => [103.009185, 103.1429],
+        Residue::E => [129.042593, 129.1140],
+        Residue::Q => [128.058578, 128.1292],
+        Residue::G => [57.021464, 57.0513],
+        Residue::H => [137.058912, 137.1393],
+        Residue::I => [113.084064, 113.1576],
+        Residue::L => [113.084064, 113.1576],
+        Residue::K => [128.094963, 128.1723],
+        Residue::M => [131.040485, 131.1961],
+        Residue::F => [147.068414, 147.1739],
+        Residue::P => [97.052764, 97.1152],
+        Residue::S => [87.032028, 87.0773],
+        Residue::T => [101.047679, 101.1039],
+        Residue::W => [186.079313, 186.2099],
+        Residue::Y => [163.063329, 163.1733],
+        Residue::V => [99.068414, 99.1311],
+
+        Element::Ag => [106.905092, 107.8682],
+        Element::Au => [196.966543, 196.96655],
+        Element::Br => [78.9183361, 79.904],
+        Element::C => [12, 12.0107],
+        Element::Ca => [39.9625906, 40.078],
+        Element::Cl => [34.96885272, 35.453],
+        Element::Cu => [62.9295989, 63.546],
+        Element::F => [18.99840322, 18.9984032],
+        Element::Fe  => [55.9349393, 55.845],
+        Element::H => [1.007825035, 1.00794],
+        Element::Hg => [201.970617, 200.59],
+        Element::I => [126.904473, 126.90447],
+        Element::K => [38.9637074, 39.0983],
+        Element::Li => [7.016003, 6.941],
+        Element::Mo => [97.9054073, 95.94],
+        Element::N => [14.003074, 14.0067],
+        Element::Na => [22.9897677, 22.98977],
+        Element::Ni => [57.9353462, 58.6934],
+        Element::O => [15.99491463, 15.9994],
+        Element::P => [30.973762, 30.973761],
+        Element::S => [31.9720707, 32.065],
+        Element::Se => [79.9165196, 78.96],
+        Element::Zn => [63.9291448, 65.409], 
+
+        #'13C'  => [13.00335483, 13.00335483],
+        #'15N'  => [15.00010897, 15.00010897],
+        #'18O'  => [17.9991603, 17.9991603],
+        #'2H'  => [2.014101779, 2.014101779],
+        
+        HYDROGEN => [1.007825, 1.0079],
+        HYDROXIDE => [17.002740, 17.0073],
+        ELECTRON => [0.000549, 0.000549]
+      )
+      
+      # Mark prolines to be located by the spectrum,
+      # so they may be masked later.
+      locate_residues "P"
+      
+      # A hash of masses to use in place of the Element/Molecule
+      # masses normally used in calculating a spectrum.  By
+      # default mass map contains the monoisotopic masses
+      # specified in DEFAULT_MASS_MAP.
+      #
+      # Note: to generate a zero-error spectrum for Mascot, it
+      # is important that mass_map contains the exact masses
+      # used by the server.  If your server uses non-default
+      # masses, override the values in DEFAULT_MASS_MAP to 
+      # affect all instances, or just mass_map to affect a
+      # single instance. See:
+      #
+      #  http://your.mascot.server/x-cgi/ms-config.exe
+      #
+      # To check the mass values for your server.
+      attr_reader :mass_map
+      
+      def initialize(sequence, nterm=HYDROGEN, cterm=HYDROXIDE)
+        @mass_map = {}
+        DEFAULT_MASS_MAP.each_pair do |const, (mono, avg)|
+          @mass_map[const] = mono  
+        end
+        
+        super do |element|
+          @mass_map[element]
+        end
+
+        [:a, :b, :c, :cladder].each {|key| mask_locations key, [-1] }
+        [:x, :y, :Y, :z, :nladder].each {|key| mask_locations key, [0] }
+      
+        # # mask prolines
+        # mask_locations :c, residue_locations['P'].collect {|i| i-1}
+        # mask_locations :z, residue_locations['P']
+      end
+      
+      protected
+      
+      # looks up a mapped mass from mass_map or reverts to super
+      def mass(molecule) # :nodoc:
+        @mass_map[molecule] || super
+      end
+    
+      # handle_unknown_series maps several Mascot-specific
+      # series annotations to their standard counterparts:
+      #
+      #   series+n   series + Hn
+      #   series*    series - NH3
+      #   series0    series - H2O
+      #   Immon.     immonium
+      #
+      def handle_unknown_series(s)
+        case s
+        when /^([\w\+\-]+)+(\d+)$/
+          self.series("#{$1} +H#{$2.to_i}")
+        when /^(\w+)\*(\+*-*)$/
+          self.series("#{$1}#{$2} -NH3")
+        when /^(\w+)0(\+*-*)$/
+          self.series("#{$1}#{$2} -H2O")
+        when /^Immon\.(.*)$/
+          self.series("immonium#{$1}")
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ms/mascot/submit.rb

@@ -0,0 +1,41 @@
+require 'tap/http/dispatch'
+
+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)}
+        end
+
+        super(*requests)
+      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)
+          $1
+          
+        when ERROR_REGEXP
+          raise ResponseError, "error: #{$1.strip}"
+        when MISTAKE_REGEXP 
+          raise ResponseError, "mistake: #{$1.strip}"
+        else 
+          raise ResponseError, "unknown error:\n#{res.body}"
+        end
+      end
+    end 
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: ms-mascot
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.11"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: tap-http
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: external
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mspire
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ms-in_silico
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ms-testdata
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.1
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- cmd/generate_mgf.rb
+- cmd/generate_prospector_mgf.rb
+- cmd/reformat_mgf.rb
+- lib/ms/mascot.rb
+- lib/ms/mascot/export.rb
+- lib/ms/mascot/fragment.rb
+- lib/ms/mascot/mgf.rb
+- lib/ms/mascot/mgf/archive.rb
+- lib/ms/mascot/mgf/entry.rb
+- lib/ms/mascot/predict.rb
+- lib/ms/mascot/spectrum.rb
+- lib/ms/mascot/submit.rb
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://mspire.rubyforge.org/projects/ms-mascot/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: mspire
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: An Mspire library supporting Mascot.
+test_files: []
+