mspire 0.4.9 → 0.5.0

data/lib/ms/parser/mzxml/hpricot.rb

@@ -1,253 +0,0 @@
-
-require 'xml_style_parser'
-require 'ms/spectrum'
-require 'ms/scan'
-
-
-class MS::Parser::MzXML::Hpricot
-  include XMLStyleParser
-  include MS::Parser::MzXML
-
-  @@scan_atts = %w(num msLevel retentionTime startMz endMz precursor spectrum)
-
-  def initialize(parse_type=:msrun, version='1.0')
-    @method = parse_type
-    @version = version
-  end
-
-  def new_scan_from_hash(node)
-    scan = MS::Scan.new  # array class creates one with 9 positions
-    scan[0] = node['num'].to_i
-    scan[1] = node['msLevel'].to_i
-    scan[2] = node['retentionTime'][2...-1].to_f
-    if x = node['startMz']
-      scan[3] = x.to_f
-      scan[4] = node['endMz'].to_f
-    end
-    scan
-  end
-
-  # takes a scan node and creates a scan object
-  # the parent scan is the one directly above it in mslevel
-  # if the 
-  def create_scan(scan_n, scans_by_num, get_spectra=true)
-    if @version < '3.0'
-      scan = new_scan_from_hash(scan_n)
-      precs = []
-      scan_n.each_child do |node|
-        case node.name
-        when 'precursorMz'
-          # should be able to do this!!!
-          #scan[5] = scan_n.find('child::precursorMz').map do |prec_n|
-          prec = MS::Precursor.new
-          prec[1] = node['precursorIntensity'].to_f
-          prec[0] = node.content.to_f
-          if x = node['precursorScanNum']
-            prec[2] = scans_by_num[x.to_i]
-          end
-          precs << prec
-        when 'peaks'
-          next unless get_spectra
-          # SHOULD be able to do this!!
-          #peaks_n = scan_n.find_first('child::peaks')
-          scan[6] = MS::Spectrum.from_base64_peaks(node.content, node['precision'].to_i)
-        end
-      end
-      scan[5] = precs
-      scan
-    else  # for version > 3.0 
-      abort 'not supporting version 3.0 just yet'
-      # note that mzXML version 3.0 *can* have more than one peak...
-      # I'm not sure how to deal with that since I have one spectrum/scan
-    end
-  end
-
-
-  # returns an array of msrun objects
-  def msruns(file)
-    raise NotImplementedError
-  end
-
-  # returns a string with double </scan></scan> tags into single and missing
-  # </scan> tags after peaks added in
-  # we do this in windows style since these are generated off a windows
-  # machine only
-  def fix_bad_scan_tags(file)
-    IO.read(file).gsub(/<\/scan>\s+<\/scan>/m, '</scan>').gsub(/<\/peaks>\s+<scan/m, "</peaks>\r\n  </scan>\r\n  <scan")
-  end
-
-  # right now cannot parse multiple runs out of an mzXML version 2 file since
-  # this is built around a single run per file
-  # OPTIONS:
-  #   :msrun => MSRun    # use this object instead of creating one
-  #   :spectra => *true|false   # if false don't get spectra
-  def msrun(file, opts={})
-    unless opts.key?(:spectra)
-      opts[:spectra] = true
-    end
-
-    msrun_obj = 
-      if x = opts[:msrun]
-        msrun_obj = x
-      else
-        MS::MSRun.new
-      end
-
-    doc = File.open(file) {|fh| ::Hpricot.XML(fh) }
-      #if @version == '2.0'
-      #  # may not be necessary in hpricot!
-      #  #string = fix_bad_scan_tags(file)
-      #  #XML::Parser.string(string).parse
-      #else
-      #  XML::Document.file(file)
-      #end
-    msrun_n = doc.at('msRun')
-
-    ## HEADER
-    scan_count = msrun_n['scanCount'].to_i
-    msrun_obj.scan_count = scan_count
-    scans_by_num = Array.new(scan_count + 1)
-    
-    ## SPECTRUM
-    parent = nil
-    scans = Array.new( scan_count )
-    scn_index = 0
-
-    # we should be able to do this, but it's not working!!!
-    #scan_n = msrun_n.find_first('scan')
-    #while (scn_index < scan_count)
-    get_spectra = opts[:spectra]
-
-    msrun_n.each_child do |scan_n|
-      p scan_n 
-      abort
-
-      next unless scan_n.name == 'scan'
-      scan = create_scan(scan_n, scans_by_num, get_spectra)
-      scans[scn_index] = scan
-      sc = scan_n.next
-      scans_by_num[scan[0]] = scan 
-      scn_index += 1
-    end
-
-
-    ## update the scan's parents
-    MS::MSRun.add_parent_scan(scans)
-
-    # note that startTime and endTime are optional AND in >2.2 are dateTime
-    # instead of duration types!, so we will just use scan times...
-    # Also, note that startTime and endTime are BROKEN on readw -> mzXML 2.0
-    # export.  They give the start and end time in seconds, but they are
-    # really minutes.  All the more reason to use the first and last scans!
-    msrun_obj.start_time = scans.first.time
-    msrun_obj.end_time = scans.last.time
-
-    msrun_obj.scans = scans
-  end
-
-end
-
-
-
-=begin
-## THIS IS THE SAX PARSER VERSION.  IT NEEDS A BIT OF BRUSH UP AND IT WOULD
-## WORK.  I THINK THE default guy is probably faster
-
-  def msrun(file, msrun_obj)
-    # Figure out where the first scan is at in the file:
-    pos_after_first_scan = nil
-    File.open(file) do |fh|
-      fh.each do |line|
-        if line =~ /<scan/
-          pos_after_first_scan = fh.pos
-        end
-      end
-    end
-
-    # Get only the header:
-    header_string = IO.read(file, pos_after_first_scan)
-
-    @msrun_obj = msrun_obj
-    # Parse out the header info:
-    parser = XML::SaxParser.new
-    parser.string = header_string
-    parser.on_start_element do |name, attrs|
-      if name == 'msRun'
-        @msrun_obj.scan_count = attrs['scanCount'].to_i
-        @msrun_obj.start_time = attrs['startTime'][2...-1].to_f
-        @msrun_obj.end_time = attrs['endTime'][2...-1].to_f
-      end
-    end
-    parser.parse
-
-    
-    # Parse the scans out:
-    scan_st = 'scan'
-    prec_st = 'precursorMz'
-    peaks_st = 'peaks'
-    prec_inten_st = 'precursorIntensity'
-    precision_st = 'precision'
-
-    #parser = MS::Parser::MzXML::Hpricot::SaxParser::MSRun.new
-    parser = XML::SaxParser.new
-    parser.filename = file
-    parser.on_start_document do
-      @scans = []
-      @current_scan = nil
-      @get_peaks = false
-      @get_prec_mz = false
-    end
-
-    parser.on_characters do |chars|
-      if @get_peaks
-        @get_peaks << chars
-      elsif @get_prec_mz
-        @get_prec_mz << chars
-      end
-    end
-
-    parser.on_end_element do |el|
-      case el
-      when 'peaks'
-        @current_scan.spectrum = Spectrum.from_base64_peaks(@get_peaks, @precision, true)
-        @get_peaks = false
-      when 'precursorMz'
-        @current_scan[5] = [Precursor.new([@get_prec_mz.to_f])]
-        @get_prec_mz = false
-      end
-    end
-
-    parser.on_start_element do |name, attr_hash|
-      case name
-      when scan_st
-        @current_scan = new_scan_from_hash(attr_hash)
-        sz = @scans.size 
-        @scans << @current_scan
-      when prec_st
-        @current_scan[5].first[1] = attr_hash[prec_inten_st].to_f
-        @get_prec_mz = ''
-      when peaks_st
-        @precision = attr_hash[precision_st].to_i
-        case @version[0,1].to_ip
-        when 3
-          if ch['pairOrder'] != 'm/z-int' # only version 3.0 has others
-            abort "cannot yet read anything but 'm/z-int' pair order"
-          end
-        end
-        @get_peaks = ''
-      end
-    end
-    parser.parse
-
-    @msrun_obj.scans = @scans
-    @msrun_obj.scans.each_with_index do |sc,i|
-      if sc.spectrum.mz == nil
-        abort "INDEX: #{i}"
-      end
-    end
-    @msrun_obj
-  end
-=end
-
-
-

data/lib/ms/parser/mzxml/libxml.rb

@@ -1,19 +0,0 @@
-
-require 'ms/parser/mzxml/dom'
-
-class MS::Parser::MzXML::LibXML < MS::Parser::MzXML::DOM
-  def get_root_node_from_string(string)
-    XML::Parser.string(string).parse.root
-  end
-  def get_root_node_from_file(file)
-    XML::Parser.filename(file).parse.root
-  end
-  def get_root_node_from_io(io)
-    XML::Parser.io(io).parse.root
-  end
-
-end
-
-
-
-

data/lib/ms/parser/mzxml/regexp.rb

@@ -1,122 +0,0 @@
-require 'strscan'
-
-module MS::Parser::MzXML ; end
-
-class MS::Parser::MzXML::Regexp
-  @@first_scan_regexp = /<scan /o
-  include MS::Parser::MzXML
-
-  def initialize(method=:msrun, version='1.0')
-    @method = method
-    @version = version
-  end
-
-  def parse(file)
-    send(@method, file) 
-  end
-
-  # returns a MS::MsRun Object
-  def msrun(file)
-    fh = File.open(file) 
-    get_header(fh)
-
-    fh.close
-  end
-
-  #def msrun(file, opts={})
-  #end
-
-  @@scan_re = /<scan.*?num="(\d+)"(.*?)<\/scan>/mo
-  def self.precursor_mz_and_intensity_by_scan(file)
-    prec_re = /msLevel="2".*?<precursorMz precursorIntensity="([\d\.]+)".*?>([\d\.]+)<\/precursorMz>/mo
-    self.by_scan_num(file, prec_re) {|match_obj| match_obj.captures.reverse}
-  end
-
-  # (array will likely start at 1!)
-  def self.by_scan_num(file, regex)
-    arr = []
-    File.open(file) do |fh|
-      string = fh.read 
-      matches = string.scan(@@scan_re)
-      matches.each do |matched|
-        if inner_match = regex.match(matched[1])
-          index = matched[0].to_i
-          arr[index] = yield(inner_match)
-        end
-      end
-    end
-    arr
-  end
-
-  # Returns array where array[scan_num] = precursorMz
-  # Parent scans armme not arrayed
-  # Values are strings.  Array index likely starts at 1!
-  # @TODO: replace the use of a yield block
-  def self.precursor_mz_by_scan(file)
-    prec_re = /msLevel="2".*?<precursorMz.*?>([\d\.]+)<\/precursorMz>/mo
-    self.by_scan_num(file, prec_re) {|match_obj| match_obj.captures[0]}
-  end
-
-end
-
-
-class MS::Parser::MzXML::Regexp::MsRun
-  @@scan_count_regexp = /scanCount="(\d+)"/o
-  @@start_time_regexp = /startTime="PT([\d\.]+)S"/o
-  @@end_time_regexp = /endTime="PT([\d\.]+)S"/o
-  @@first_scan_regexp = /<scan /
-
-  def initialize(version='1.0')
-    @version = version
-  end
-
-  def parse(io, msrun_object)
-    atts = {}
-    [:scan_count, :start_time, :end_time].zip(get_header_info(io)) {|v,k| atts[k] = v }
-    ###
-    # HERE <------------------------------------
-    abort "NEED TO FINISH WRITING SCANS EXTRACTOR!"
-    get_scans(io)
-    # HERE <------------------------------------
-
-    # set the attributes
-    atts.each do |k,v|
-      msrun_object.send(k,v)
-    end
-    # need to fill in the scan_counts array
-  end
-
-  # assumes the attributes are each on a line
-  def get_scans(io)
-    io.each do |line|
-    end
-  end
-
-  # returns [total_num_scans, start_time, end_time] and positions the handle
-  # so that the next 'gets' will call a scan
-  def get_header_info(io)
-    scan_count = nil
-    start_time = nil
-    end_time = nil
-
-    previous_position = nil
-    io.each do |line|
-      if line =~ @@scan_count_regexp
-        scan_count = $1.dup
-      end
-      if line =~ @@start_time_regexp
-        start_time = $1.dup
-      end
-      if line =~  @@end_time_regexp
-        end_time = $1.dup
-      end
-      if line =~ @@first_scan_regexp
-        io.pos = previous_position
-        break
-      end
-      previous_position = io.pos
-    end
-    [scan_count, start_time, end_time]
-  end
-
-end

data/lib/ms/parser/mzxml/rexml.rb

@@ -1,72 +0,0 @@
-require 'rexml/document'
-require 'rexml/streamlistener'
-
-module MS::Parser::MzXML::REXMLStreamListener; end
-class MS::Parser::MzXML::REXMLStreamListener::PrecMzByNum; end
-
-module REXMLStreamListenerHelper
-  def parse_and_report(file, const, report_method=:report)
-    listener = self.const_get(const).new
-    File.open(file) do |fh|
-      REXML::Document.parse_stream(fh, listener)
-    end
-    listener.send(report_method)
-  end
-end
-
-class MS::Parser::MzXML::REXML 
-  include MS::Parser::MzXML
-
-  def initialize(version='1.0', method=:msrun)
-    @version = version
-    @method = parse_type
-  end
-
-  # returns an array indexed by scan_num that gives the precursor_mz
-  def precursor_mz_by_scan(file, opts={})
-    parse_and_report(file, PrecMzByNum)
-  end
-
-end
-
-
-
-
-# for REXML
-class MS::Parser::MzXML::REXML::PrecMzByNum
-  include REXML::StreamListener
-
-  attr_accessor :prec_mz
-  alias_method :report, :prec_mz
-
-  def initialize
-    @prec_mz = [] 
-    @scan_num = nil
-    @get_data = false
-  end
-
-  def tag_start(name,attrs)
-    if name == "scan"
-      @scan_num = attrs["num"].to_i 
-    elsif name == "precursorMz"
-      @get_data = true
-    end
-  end
-
-  def tag_end(name)
-    if name == "precursorMz"
-      @get_data = false
-    end
-  end
-
-  def text(txt)
-    if @get_data
-      @prec_mz[@scan_num] = txt
-    end
-  end
-
-end
-
-
-
-

data/lib/ms/parser/mzxml/xmlparser.rb

@@ -1,248 +0,0 @@
-require 'xmlparser_wrapper'
-
-# this is the wrapper class
-class MS::Parser::MzXML::XMLParser
-  include XMLStyleParser
-  include MS::Parser::MzXML
-  include XMLParserWrapper
-
-  def initialize(parse_type=:msrun, version='1.0')
-    @method = parse_type
-    @version = version
-  end
-
-  # returns: [times_arr, [m/z,inten,m/z,inten...]]
-  # where times are time strings (in seconds)
-  def times_and_spectra(file, opts={})
-    parse_and_report(file, 'TimesAndSpectra')
-  end
-
-
-  ## IN PROGRESS ...
-  # opts is actually the msrun object that will be fleshed out in the parsing
-  def msrun(file, opts={})
-    p opts
-    fh = File.open(file)
-    reply = parse_and_report_io(fh, 'MsRunHeader')
-    p reply
-    abort
-    fh.close
-  end
-
-  def prec_mz_by_scan_num(file, opts={})
-  end
-
-  # could easily do this for all these guys
-  #def method_missing(*args)
-  #  method = args.shift
-  #  parse_and_report(
-  #end
-
-end
-
-class MS::Parser::MzXML::XMLParser::MsRunHeader < XMLParser
-  def initialize(version='1.0')
-    @version = version
-    @atts = []
-  end
-
-  def startElement(name,attrs)
-    case name
-    when 'msRun'
-      @atts = attrs.values_at(%w(scanCount startTime endTime))
-    end
-  end
-
-  def endElement(name)
-    if name == 'dataProcessing'
-      done
-      reset
-    end
-  end
-end
-
-class MS::Parser::MzXML::XMLParser::Spectrum < XMLParser
-  @@scan_atts = %w(num msLevel retentionTime startMz endMz)
-  @@precursor_mz_atts = %w(precursorIntensity)
-
-
-  def initialize(version='1.0')
-    @version = version
-    @spectrum = []
-    @current_scan = nil
-  end
-
-  def report
-    @spectrum
-  end
-
-  def startElement(name,attrs)
-    if name == 'scan'
-      vals = attrs.values_at(@@scan_atts)
-      vals[2] = vals[2][2...-1].to_f  #remove PT and trailing S
-      [0, 1].each do |i| vals[i] = vals[i].to_i end # num and ms_level
-      [3, 4].each do |i| vals[i] = vals[i].to_f end # start_mz and end_mz
-      @current_scan = MS::Scan.new(vals)
-    elsif name == 'precursorMz'
-      # 5, 6, 7 are the scans indices for prec_mz prec_inten and parent
-      @current_scan[6] = attrs['precursorIntensity'].to_f
-      @current_scan[5] = ''
-      @get_precursor_mz = true
-    elsif name == 'peaks'
-      @precision = attrs['precision'].to_i
-      @get_peaks = true
-      @current_peaks_string = ''
-    end
-  end
-
-  def endElement(name)
-    if name == 'peaks'
-      @get_peaks = false
-      @spectrum << Spectrum.new(@current_peaks_string, @precision)
-      @spectrum.context = @current_scan
-    elsif name == 'precursorMz'
-      @current_scan[5] = @current_scan[5].to_f
-      @get_precursor_mz = false
-    end
-  end
-
-  def character(data)
-    if @get_peaks
-      @current_peaks_string << data 
-    elsif @get_precursor_mz
-      @current_scan[5] << data
-    end
-  end
-
-end
-
-
-
-
-class MS::Parser::MzXML::XMLParser::PrecMzByNum < XMLParser
-  @scan_num = nil
-  @get_data = false
-
-  attr_accessor :prec_mz
-  alias_method :report, :prec_mz
-
-  def initialize
-    @prec_mz = [] 
-  end
-
-  def startElement(name,attrs)
-    if name == "scan"
-      @scan_num = attrs["num"].to_i
-    elsif name == "precursorMz"
-      @current_prec_mz = ""
-      @get_data = true
-    end
-  end
-
-  def endElement(name)
-    if name == "precursorMz"
-      @get_data = false
-      @prec_mz[@scan_num] = @current_prec_mz.to_f
-    end
-  end
-
-  def character(data)
-    if @get_data
-      @current_prec_mz << data
-    end
-  end
-
-end
-
-
-=begin
-
-
-# Returns parallel arrays (times, spectra) where each spectra is an array
-# containing alternating mz and intensity (MS1 scans only)
-# and times are strings with the time in seconds
-class MS::Parser::MzXML::XMLParser::TimesAndSpectra < XMLParser
-  include MS::Parser::MzXML
-  @@get_data = false
-  @@get_peaks = false
-  @@precision = 32 # @TODO: set dynamic
-
-  attr_accessor :times, :spectra
-  def times_and_spectra
-    [@times, @spectra]
-  end
-
-  alias_method :report, :times_and_spectra
-
-  def initialize(ms_level=1)
-    @ms_level = "#{ms_level}"
-    @times = []
-    @spectra = []
-  end
-
-  def startElement(name,attrs)
-    if name == "scan" && attrs["msLevel"] == @ms_level
-      @times << attrs["retentionTime"][2...-1]  # strip PT and S: "PTx.xxxxS"
-      @@get_peaks = true
-    elsif name == "peaks" && @@get_peaks
-      @@get_data = true
-      @data = ""
-    end
-  end
-
-  def character(data)
-    if @@get_data
-      @data << data
-    end
-  end
-
-  def endElement(name)
-    if name == "peaks" && @@get_peaks
-      @spectra << base64_peaks_to_array(@data, @@precision)
-      @@get_data = false
-      @@get_peaks = false
-    end
-  end
-
-end
-
-
-class MS::Parser::MzXML::XMLParser::TimeMzIntenIndexer < XMLParser
-
-  @@scan_num = nil
-  @@get_data = false
-
-  attr_accessor :scans_by_num
-  alias_method :report, :scans_by_num
-
-  def initialize
-    @current_scan = nil
-    @scans_by_num = []
-  end
-
-  def startElement(name,attrs)
-    if name == "scan"
-      num = attrs["num"].to_i
-      @current_scan = MS::Scan.new(num, attrs["msLevel"].to_i, attrs["retentionTime"].gsub(/^PT/,'').gsub(/S$/,'').to_f)
-      scans_by_num[num] = @current_scan
-    elsif name == "precursorMz"
-      @current_scan.prec_inten = attrs["precursorIntensity"].to_f
-      @@get_data = true
-    end
-  end
-
-  def endElement(name)
-    if name == "precursorMz"
-      @@get_data = false
-    end
-  end
-
-  def character(data)
-    if @@get_data
-      @current_scan.prec_mz = data
-    end
-  end
-
-end
-
-=end