ms-ident 0.0.2

data/lib/ms/ident/pepxml/search_hit/modification_info.rb

@@ -0,0 +1,82 @@
+require 'andand'
+require 'nokogiri'
+
+module Ms ; end
+module Ms::Ident ; end
+class Ms::Ident::Pepxml ; end
+class Ms::Ident::Pepxml::SearchHit ; end
+
+
+# Positions and masses of modifications
+Ms::Ident::Pepxml::SearchHit::ModificationInfo = Struct.new(:modified_peptide, :mod_aminoacid_masses, :mod_nterm_mass, :mod_cterm_mass) do
+  ## Should be something like this:
+  # <modification_info mod_nterm_mass=" " mod_nterm_mass=" " modified_peptide=" ">
+  #   <mod_aminoacid_mass position=" " mass=" "/>
+  # </modification_info>
+  # e.g.:
+  # <modification_info modified_peptide="GC[546]M[147]PSKEVLSAGAHR">
+  #   <mod_aminoacid_mass position="2" mass="545.7160"/>
+  #   <mod_aminoacid_mass position="3" mass="147.1926"/>
+  # </modification_info>
+
+  # Mass of modified N terminus<
+  #attr_accessor :mod_nterm_mass
+  # Mass of modified C terminus<
+  #attr_accessor :mod_cterm_mass
+  # Peptide sequence (with indicated modifications)  I'm assuming that the
+  # native sequest indicators are OK here
+  #attr_accessor :modified_peptide
+
+  # These are objects of type: ...ModAminoacidMass
+  # position ranges from 1 to peptide length
+  #attr_accessor :mod_aminoacid_masses
+
+  class << self
+    alias_method :old_new, :new
+    # takes either a hash or the normal list of values to set.
+    def new(*args)
+      if args.first.is_a?(Hash)
+        args = args.first.values_at(*members)
+      end
+      obj = old_new(*args)
+      obj
+    end
+  end
+
+  # Will escape any xml special chars in modified_peptide
+  def to_xml(builder=nil)
+    xmlb = builder || Nokogiri::XML::Builder.new
+    ## Collect the modifications:
+    ## Create the attribute string:
+    atts = [:mod_nterm_mass, :mod_cterm_mass, :modified_peptide]
+    atts.map! {|at| (v=send(at)) && [at, v] }.compact
+    xmlb.modification_info(Hash[atts]) do
+      mod_aminoacid_masses.andand.each do |mod_aa_mass|
+        mod_aa_mass.to_xml(xmlb)
+      end
+    end
+  end
+
+  def self.from_pepxml_node(node)
+    self.new.from_pepxml_node(node)
+  end
+
+  # returns self
+  def from_pepxml_node(node)
+    self[0] = node['modified_peptide'] 
+    self[2] = node['mod_nterm_mass']
+    self[3] = node['mod_cterm_mass']
+    _masses = []
+    node.children do |mass_n|
+      _masses << Ms::Ident::Pepxml::SearchHit::ModificationInfo::ModAminoacidMass.new([mass_n['position'].to_i, mass_n['mass'].to_f])
+    end
+    self.mod_aminoacid_masses = _masses
+    self 
+  end
+end
+
+Ms::Ident::Pepxml::SearchHit::ModificationInfo::ModAminoacidMass = Struct.new(:position, :mass) do
+  def to_xml(builder)
+    builder.mod_aminoacid_mass(:position => position, :mass => mass)
+  end
+end

data/lib/ms/ident/pepxml/search_hit.rb

@@ -0,0 +1,141 @@
+require 'set'
+require 'merge'
+require 'nokogiri'
+
+module Ms ; end
+module Ms::Ident ; end
+
+
+class Ms::Ident::Pepxml 
+
+  class Ms::Ident::Pepxml::SearchHit 
+    include Merge
+
+    DEFAULT_MEMBERS = [:hit_rank, :peptide, :peptide_prev_aa, :peptide_next_aa, :num_matched_ions, :tot_num_ions, :calc_neutral_pep_mass, :massdiff, :num_tol_term, :num_missed_cleavages, :is_rejected, :protein, :num_tot_proteins, :protein_desc, :calc_pI, :protein_mw, :modification_info, :search_scores, :spectrum_query]
+
+    Required = Set.new([:hit_rank, :peptide, :protein, :num_tot_proteins, :calc_neutral_pep_mass, :massdiff])
+
+    class << self
+      attr_writer :members
+      def members
+        @members || DEFAULT_MEMBERS
+      end
+    end
+
+    members.each {|memb| attr_accessor memb }
+
+    # rank of the peptide hit (required)
+    attr_accessor :hit_rank
+    # Peptide aminoacid sequence (with no indicated modifications) (required)
+    attr_accessor :peptide
+
+    # Aminoacid preceding peptide ('-' if none)
+    attr_accessor :peptide_prev_aa
+
+    # Aminoacid following peptide (- if none)
+    attr_accessor :peptide_next_aa
+
+    # Number of peptide fragment ions found in spectrum (Integer)
+    attr_accessor :num_matched_ions
+
+    # Number of peptide fragment ions predicted for peptide (Integer)
+    attr_accessor :tot_num_ions
+
+    # (required)
+    attr_accessor :calc_neutral_pep_mass
+
+    # Mass(precursor ion) - Mass(peptide) (required)
+    attr_accessor :massdiff
+
+    # Number of peptide termini consistent with cleavage by sample enzyme
+    attr_accessor :num_tol_term
+
+    # Number of sample enzyme cleavage sites internal to peptide<
+    attr_accessor :num_missed_cleavages
+
+    # Potential use in future for user manual validation (true/false)
+    # by default, this will be set to false
+    # (the xml is expressed as a 0 or 1)
+    attr_accessor :is_rejected
+
+    # a protein identifier string (required)
+    attr_accessor :protein
+
+    # Number of unique proteins in search database containing peptide
+    # (required)
+    attr_accessor :num_tot_proteins
+
+    # Extracted from search database
+    attr_accessor :protein_desc
+
+    attr_accessor :calc_pI
+    attr_accessor :protein_mw
+
+    # a ModificationInfo object
+    attr_accessor :modification_info
+
+    # a Hash with keys (the score type) and values
+    # (to_xml calls each_pair to generate the xml, so a Struct would also
+    # work)
+    attr_accessor :search_scores
+
+    # a link back to the spectrum_query object
+    attr_accessor :spectrum_query
+
+
+    Non_standard_amino_acid_char_re = %r{[^A-Z\.\-]}
+
+    alias_method :aaseq, :peptide
+    alias_method :aaseq=, :peptide=
+
+    # takes either a hash or an ordered list of values to set.
+    # yeilds an empty search_scores hash if given a block.
+    # mind that you set the ModificationInfo object as needed.
+    def initialize(*args, &block)
+      @search_scores = {}
+      if args.first.is_a?(Hash)
+        merge!(args.first)
+      else
+        self.class.members.zip(args) do |k,v|
+          send("#{k}=", v)
+        end
+      end
+      block.call(@search_scores) if block
+    end
+
+    def members
+      self.class.members
+    end
+
+    def to_xml(builder=nil)
+      xmlb = builder || Nokogiri::XML::Builder.new
+      attrs = members[0,14].map {|k| v=send(k) ; [k, v] if v }.compact
+      hash_attrs = Hash[attrs]
+      hash_attrs[:massdiff] = hash_attrs[:massdiff].to_plus_minus_string
+      xmlb.search_hit(hash_attrs) do |xmlb|
+        @modification_info.to_xml(xmlb) if @modification_info
+        @search_scores.each_pair {|k,v| xmlb.search_score(:name => k, :value => v) }
+      end
+      builder || xmlb.doc.root.to_xml
+    end
+
+    def from_pepxml_node(node)
+      self[0] = node['hit_rank'].to_i
+      self[1] = node['peptide']
+      self[2] = node['peptide_prev_aa']
+      self[3] = node['peptide_next_aa']
+      self[4] = node['protein']  ## will this be the string?? (yes, for now)
+      self[5] = node['num_tot_proteins'].to_i
+      self[6] = node['num_matched_ions'].to_i
+      self[7] = node['tot_num_ions'].to_i
+      self[8] = node['calc_neutral_pep_mass'].to_f
+      self[9] = node['massdiff'].to_f
+      self[10] = node['num_tol_term'].to_i
+      self[11] = node['num_missed_cleavages'].to_i
+      self[12] = node['is_rejected'].to_i
+      self
+    end
+  end
+
+end
+

data/lib/ms/ident/pepxml/search_result.rb

@@ -0,0 +1,28 @@
+require 'nokogiri'
+
+module Ms ; end
+module Ms::Ident ; end
+class Ms::Ident::Pepxml ; end
+
+class Ms::Ident::Pepxml::SearchResult
+  # an array of search_hits
+  attr_accessor :search_hits
+
+  # if block given, then yields an empty search_hits array
+  def initialize(search_hits = [], &block)
+    @search_hits = search_hits
+    block.call(@search_hits) if block
+  end
+
+  def to_xml(builder=nil)
+    xmlb = builder || Nokogiri::XML::Builder.new
+    builder.search_result do |xmlb|
+      search_hits.each do |sh|
+        sh.to_xml(xmlb)
+      end
+    end
+    builder || xmlb.doc.root.to_xml 
+  end
+
+end
+

data/lib/ms/ident/pepxml/search_summary.rb

@@ -0,0 +1,88 @@
+require 'ms/ident/pepxml/search_database'
+require 'ms/ident/pepxml/modifications'
+require 'ms/ident/pepxml/parameters'
+
+require 'nokogiri'
+require 'merge'
+
+module Ms ; end
+module Ms::Ident ; end
+class Ms::Ident::Pepxml ; end
+
+
+# requires these keys:  
+#
+#    :enzyme => a valid enzyme name
+#    :max_num_internal_cleavages => max number of internal cleavages allowed
+#    :min_number_termini => minimum number of termini??
+class Ms::Ident::Pepxml::EnzymaticSearchConstraint < Hash
+end
+
+class Ms::Ident::Pepxml::SearchSummary
+  include Merge
+
+  DEFAULT_SEARCH_ID = '1'
+
+  attr_accessor :base_name
+  # required in v18-19, optional in later versions
+  attr_accessor :out_data_type
+  # required in v18-19, optional in later versions
+  attr_accessor :out_data
+  # by default, "1"
+  attr_accessor :search_id
+  # a Modifications object
+  attr_accessor :modifications
+  # A SearchDatabase object (responds to :local_path and :type)
+  attr_accessor :search_database
+  # the other search paramaters as a hash
+  attr_accessor :parameters
+  # the search engine used, SEQUEST, Mascot, Comet, etc.
+  attr_accessor :search_engine
+  # required: 'average' or 'monoisotopic'
+  attr_accessor :precursor_mass_type
+  # required: 'average' or 'monoisotopic'
+  attr_accessor :fragment_mass_type
+  # An EnzymaticSearchConstraint object (at the moment this is merely a hash
+  # with a few required keys
+  attr_accessor :enzymatic_search_constraint
+
+  def block_arg
+    [@search_database = Ms::Ident::Pepxml::SearchDatabase.new,
+      @enzymatic_search_constraint = Ms::Ident::Pepxml::EnzymaticSearchConstraint.new,
+      @modifications = Ms::Ident::Pepxml::Modifications.new,
+      @parameters = Ms::Ident::Pepxml::Parameters.new,
+    ]
+  end
+
+  def initialize(hash={}, &block)
+    @search_id = DEFAULT_SEARCH_ID
+    merge!(hash, &block)
+  end
+
+  def to_xml(builder=nil)
+    # TODO: out_data and out_data_type are optional in later pepxml versions...
+    # should work that in...
+    attrs = [:base_name, :search_engine, :precursor_mass_type, :fragment_mass_type, :out_data_type, :out_data, :search_id]
+    hash = Hash[ attrs.map {|at| v=send(at) ; [at, v] if v }.compact ]
+    xmlb = builder || Nokogiri::XML::Builder.new
+    builder.search_summary(hash) do |xmlb|
+      search_database.to_xml(xmlb)
+      xmlb.enzymatic_search_constraint(enzymatic_search_constraint) if enzymatic_search_constraint
+      modifications.to_xml(xmlb) if modifications
+      parameters.to_xml(xmlb) if parameters
+    end
+    builder || xmlb.doc.root.to_xml 
+  end
+
+  def self.from_pepxml_node(node)
+    self.new.from_pepxml_node(node)
+  end
+
+  def from_pepxml_node(node)
+    raise NotImplementedError, "not implemented just yet (just use the raw xml node)"
+  end
+
+end
+
+
+

data/lib/ms/ident/pepxml/spectrum_query.rb

@@ -0,0 +1,83 @@
+require 'nokogiri'
+require 'ms/mass'
+require 'merge'
+
+module Ms ; end
+module Ms::Ident ; end
+class Ms::Ident::Pepxml ; end
+
+# search_specification is a search constraint applied specifically to this query (a String)
+class Ms::Ident::Pepxml::SpectrumQuery
+  include Merge
+  DEFAULT_MEMBERS = [:spectrum, :start_scan, :end_scan, :precursor_neutral_mass, :index, :assumed_charge, :retention_time_sec, :search_specification, :search_results, :pepxml_version]
+  
+  class << self
+    attr_writer :members
+    def members
+      @members || DEFAULT_MEMBERS
+    end
+  end
+
+  members.each {|memb| attr_accessor memb }
+
+  Required = Set.new([:spectrum, :start_scan, :end_scan, :precursor_neutral_mass, :index, :assumed_charge])
+  Optional = [:retention_time_sec, :search_specification]
+  
+  # takes either a hash or an ordered list of values to set
+  # yeilds an empty search_results array if given a block
+  def initialize(*args, &block)
+    @search_results = [] 
+    if args.first.is_a?(Hash)
+      merge!(args.first)
+    else
+      self.class.members.zip(args) do |k,v|
+        send("#{k}=", v)
+      end
+    end
+    block.call(@search_results) if block
+  end
+
+  def members
+    self.class.members
+  end
+
+  ############################################################
+  # FOR PEPXML:
+  ############################################################
+  def to_xml(builder=nil)
+    xmlb = builder || Nokogiri::XML::Builder.new
+    # all through search_specification
+    attrs = members[0, 8].map {|at| v=send(at) ; [at, v] if v }
+    attrs_hash = Hash[attrs]
+    case pepxml_version
+    when 18
+      attrs_hash.delete(:retention_time_sec)
+    end
+    xmlb.spectrum_query(attrs_hash) do |xmlb|
+      search_results.each do |search_result|
+        search_result.to_xml(xmlb) 
+      end
+    end
+    builder || xmlb.doc.root.to_xml
+  end
+
+  def self.from_pepxml_node(node)
+    self.new.from_pepxml_node(node)
+  end
+
+  def from_pepxml_node(node)
+    @spectrum = node['spectrum']
+    @start_scan = node['start_scan'].to_i
+    @end_scan = node['end_scan'].to_i
+    @precursor_neutral_mass = node['precursor_neutral_mass'].to_f
+    @index = node['index'].to_i
+    @assumed_charge = node['assumed_charge'].to_i
+    self
+  end
+
+  def self.calc_precursor_neutral_mass(m_plus_h, deltamass, h_plus=Ms::Mass::H_PLUS)
+    m_plus_h - h_plus + deltamass
+  end
+end
+
+

data/lib/ms/ident/pepxml.rb

@@ -0,0 +1,61 @@
+require 'nokogiri'
+require 'ms/ident'
+require 'ms/ident/pepxml/msms_pipeline_analysis'
+
+module Ms ; module Ident ; end ; end
+
+class Numeric
+  # returns a string with a + or - on the front
+  def to_plus_minus_string
+    if self >= 0
+      '+' << self.to_s
+    else
+      self.to_s
+    end
+  end
+end
+
+class Ms::Ident::Pepxml
+  XML_STYLESHEET_LOCATION = '/tools/bin/TPP/tpp/schema/pepXML_std.xsl'
+  DEFAULT_PEPXML_VERSION = MsmsPipelineAnalysis::PEPXML_VERSION
+
+  attr_accessor :msms_pipeline_analysis
+
+  def pepxml_version
+    msms_pipeline_analysis.pepxml_version
+  end
+
+  # returns an array of spectrum queries
+  def spectrum_queries
+    msms_pipeline_analysis.msms_run_summary.spectrum_queries
+  end
+
+  # yields a new Msms_Pipeline_Analysis object if given a block 
+  def initialize(&block)
+    block.call(@msms_pipeline_analysis=MsmsPipelineAnalysis.new) if block
+  end
+
+  # takes an xml document object and sets it with the xml stylesheet
+  def add_stylesheet(doc, location)
+    xml_stylesheet = Nokogiri::XML::ProcessingInstruction.new(doc, "xml-stylesheet", %Q{type="text/xsl" href="#{location}"})
+    doc.root.add_previous_sibling  xml_stylesheet
+    doc
+  end
+  
+  # writes xml file named msms_pipeline_analysis.summary_xml into the msms_run_summary.base_name directory
+  def to_xml_file
+    to_xml(File.dirname(msms_pipeline_analysis.msms_run_summary.base_name) + '/' + msms_pipeline_analysis.summary_xml)
+  end
+
+  # if no outfile is given, an xml string is returned.  summary_xml should
+  # have already been set and is not influenced by the outfile given here.
+  def to_xml(outfile=nil)
+    builder = Nokogiri::XML::Builder.new
+    msms_pipeline_analysis.to_xml(builder)
+    add_stylesheet(builder.doc, Ms::Ident::Pepxml::XML_STYLESHEET_LOCATION)
+    string = builder.doc.to_xml
+    outfile ? File.open(outfile,'w') {|out| out.print(string) } : string
+  end
+end
+
+

data/lib/ms/ident.rb

@@ -0,0 +1,11 @@
+
+module Ms
+  module Ident
+    # returns the filetype (if possible)
+    def self.filetype(file)
+      if file =~ /\.srf$/i
+        :srf
+      end
+    end
+  end
+end