mspire 0.4.9 → 0.5.0

data/lib/ms/parser/mzxml.rb

@@ -1,282 +0,0 @@
-require 'ms/msrun'
-require 'fileutils'
-
-module MS; end
-
-module MS::Parser::MzXML
-  Base_dir_for_parsers = 'ms/parser/mzxml'
-  # inherits XMLStyleParser and version
-  include MS::Parser
-  include XMLStyleParser
-
-  # warning: clobbers file unless a newfilename is provided!
-  # returns the output filename
-  # will fix any size file!
-  def self.fix_bad_scan_tags(filename, newfilename=nil)
-
-    out_io = 
-      if newfilename
-        File.open(newfilename, 'w')
-      else
-        Tempfile.new(File.basename(filename))
-      end
-    File.open(filename) do |fh|
-      self.fix_bad_scan_tags_from_io(fh, out_io)
-    end
-    out_io.close
-    unless newfilename
-      FileUtils.mv out_io.path, filename
-    end
-  end
-
-  # this is a memory efficient method to fix bad scan tags
-  # prints cleaned up file to out_io
-  # no effort is made to rewind the io objects, the user must do this if they
-  # plan to continue using these objects!
-  def self.fix_bad_scan_tags_from_io(io, out_io)
-    regexp = /<\/scan>/ 
-    end_scan_line = false
-
-    io.each("\n") do |line|
-      if end_scan_line && line =~ regexp
-        # two end scan lines! # don't print to out_io
-        end_scan_line = true
-      elsif line =~ regexp
-        out_io.print(line)
-        end_scan_line = true
-      else
-        out_io.print(line)
-        end_scan_line = false
-      end
-    end
-  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 self.fix_bad_scan_tags(string)
-  #  string.gsub(/<\/scan>\s+<\/scan>/m, '</scan>').gsub(/<\/peaks>\s+<scan/m, "</peaks>\r\n  </scan>\r\n  <scan")
-  #end
-
-  # returns true if it has the bad tag
-  def self.has_bad_scan_tag_from_string?(string)
-    if string.match(/<\/scan>\s+<\/scan>/m)
-      true
-    else
-      false
-    end
-  end
-
-  def self.has_bad_scan_tag?(filename)
-    File.open(filename) do |fh|
-      self.has_bad_scan_tag_from_io?(fh)
-    end
-  end
-
-  # very efficient algorithm to check for malformed xml typical of readw
-  # output. The extra closing scan tags come after the last ms/ms scan in a
-  # cycle rewinds the io after looking
-  def self.has_bad_scan_tag_from_io?(io)
-    seen_first_ms_level = false
-    seen_higher_ms_level = false
-    cur_ms_level = 0
-    found_double_end_tag = false
-    found_end_tag = false
-    io.each("\n") do |line|
-      if line =~ /<\/scan>/
-        if found_end_tag  # already found one!
-          found_double_end_tag = true
-          break
-        end
-        found_end_tag = true
-      else
-        found_end_tag = false
-      end
-
-      if line =~ /msLevel="(\d+)"/
-        cur_ms_level = $1.dup
-        if seen_first_ms_level && seen_higher_ms_level && cur_ms_level == '1'
-          break
-        end
-        if cur_ms_level == '1'
-          seen_first_ms_level = true
-        elsif cur_ms_level == '2'
-          seen_higher_ms_level = true
-        end
-      end
-    end
-    io.rewind
-    found_double_end_tag
-  end
-
-  # returns a specific parser MS::Parser::MzXML::#{ParserType}
-  # based on choose_parser from xml_style_parser
-  def self.new(parse_type=:msrun, version='1.0', opts={})
-    special_subclass = 
-      if opts[:lazy] == :io
-      'LazyPeaks'
-      else ; nil
-      end
-    @version = version
-    @method = parse_type
-    XMLStyleParser.require_parse_files(Base_dir_for_parsers)
-    parser_class = XMLStyleParser.choose_parser(self, parse_type, special_subclass)
-    parser = parser_class.new(parse_type, version)
-  end
-
-  # Returns an array of scans indexed by scan number
-  # NOTE that the first scan (zero indexed) will likely be nil!
-  # accepts an optional parse_type = 'xmlparser' | 'rexml'
-  def scans_by_num(mzXML_file, parse_type=nil)
-    unless parse_type
-      parse_type = default_parser
-    end
-    scans = []
-    case parse_type
-    when 'xmlparser' 
-      parser = MS::MzXML::XMLParser::TimeMzIntenIndexer.new
-      parser.parse(IO.read(mzXML_file))
-      scans = parser.scans_by_num
-    when 'rexml' # use REXML
-      # This is really too slow for files of this size
-      doc = REXML::Document.new File.new(mzXML_file)
-      doc.elements.each('msRun/scan') do |scan|
-        rt = scan.attributes['retentionTime']  ## like PT0.154000S"
-        level = scan.attributes['msLevel']
-        to_print = []
-        prec_mz = nil
-        prec_int = nil
-        if level.to_i != 1
-          scan.elements.each("precursorMz") do |prec|
-            prec_mz = prec.text.to_f
-            prec_int = prec.attributes["precursorIntensity"].to_f
-          end
-        end
-        # remove the leading PT and trailing S on the retention time!
-        rt = rt[2...-1]
-
-        num = scan.attributes['num'].to_i
-        scans[num] = MS::Scan.new(num, scan.attributes['msLevel'].to_i, rt.to_f, prec_mz, prec_int) 
-      end #doc.elements
-    else
-      throw ArgumentError, "invalid parse type: #{parse_type}"
-    end
-    ## update the scans for parents
-    MS::Scan.add_parent_scan(scans)
-    scans
-  end
-
-  # Returns a Hash indexed by filename (with no extension) for a given path
-  # extension = glob (string) or regex
-  # The basename is given as: file.split('.').first
-  def precursor_mz_by_scan_for_path(path, extension, parse_type=nil)
-    hash = {}
-    Dir.chdir path do
-      files = []
-      if extension.class == String
-        files = Dir[extension]
-      elsif extension.class == Regexp
-        files = Dir.entries(".").find_all do |dir|
-          dir =~ extension
-        end
-      else
-        puts "extension: #{extension} not a String or Regexp!"
-      end
-      files.each do |file|
-        base = file.split('.').first
-        hash[base] = precursor_mz_by_scan(file, parse_type)
-      end
-    end
-    hash
-  end
-
-  # Returns hash where hash[scan_num] = [precursorMz, precursorIntensity]
-  # Parent scans are not hashed
-  # Keys and values are both strings
-  def precursor_mz_and_inten_by_scan(file)
-    # in progress
-  end
-
-  # Returns array where array[scan_num] = precursorMz
-  # precursorMz are Floats
-  # Array index likely starts at 1!
-  def precursor_mz_by_scan_num(file)
-    ## THIS SHOULD BE CREATED IN specific XML LIBS
-  end
-
-  # Returns a hash of basic info on an mzXML run:
-  #   *mzXML_elemt*   *hash keys (symbols)*
-  #   scanCount       scan_count
-  #   startTime       start_time
-  #   endTime         end_time
-  #   startMz         start_mz
-  #   endMz           end_mz
-  def basic_info(mzxml_file)
-    puts "parsing: #{mzxml_file} #{File.exist?(mzxml_file)}" if $VERBOSE
-    hash = {}
-    scan_count_tmp = []
-    (1..5).to_a.each do |n| scan_count_tmp[n] = 0 end
-    @fh = File.open(mzxml_file)
-    @line = ""
-    scan_count_tmp[0] = _el("scanCount").to_i
-    hash[:start_time] = _el("startTime").sub(/^PT/, "").sub(/S$/,"").to_f
-    hash[:end_time] = _el("endTime").sub(/^PT/, "").sub(/S$/,"").to_f
-    hash[:ms_level] = _el("msLevel").to_i
-    scan_count_tmp[1] = 1
-    if hash[:ms_level] == 1
-      hash[:start_mz] = _el("startMz").to_f
-      hash[:end_mz] = _el("endMz").to_f
-    end
-
-    while !@fh.eof?
-      @line = @fh.readline 
-      ms_level = _el("msLevel")
-      if ms_level
-        scan_count_tmp[ms_level.to_i] += 1
-      else
-        break
-      end
-    end
-    scan_count = []
-    scan_count_tmp.each do |cnt|
-      if cnt != 0
-        scan_count.push cnt
-      else
-        break
-      end
-    end
-    hash[:scan_count] = scan_count
-    @fh.close
-    hash
-  end
-  
-  # returns [start_mz, end_mz] of the first full scan (ms_level == 1)
-  def start_and_end_mz(mzxml_file)
-    @fh = File.open(mzxml_file)
-    ms_level = 0
-    @line = ""
-    while ms_level != 1
-      ms_level = _el("msLevel").to_i
-    end
-    start_mz = _el("startMz").to_f
-    end_mz = _el("endMz").to_f
-    @fh.close
-    [start_mz, end_mz]
-  end
-
-  def _el(name)
-    re = /#{name}="(.*)"/
-    while @line !~ re && !@fh.eof?
-      @line = @fh.readline
-    end
-    if $1
-      return $1.dup
-    else
-      return nil
-    end
-  end
-
-end
-
-

data/lib/ms/parser.rb

@@ -1,108 +0,0 @@
-require 'xml_style_parser'
-
-module MS; end
-
-module MS::Parser
-  # inherits attr_accessor :method, :default_parser, and parse (which should
-  # be overridden)
-  include XMLStyleParser 
-
-  Mzxml_regexp = /http:\/\/sashimi.sourceforge.net\/schema(_revision)?\/([\w\d_\.]+)/o
-  # 'http://sashimi.sourceforge.net/schema/MsXML.xsd' # version 1
-  # 'http://sashimi.sourceforge.net/schema_revision/mzXML_X.X' # others
-  Mzdata_regexp = /<mzData.*version="([\d\.]+)"/m
-
-  attr_accessor :version
-
-  ############################################
-  # POINTERS (to create META MAGIC)
-  ############################################
-  
-  @@filetypes_to_upcase = {
-    :mzxml => 'MzXML',
-    :mzdata => 'MzData',
-    :mzml => 'MzML',
-    :raw => 'Raw',
-  }
-
-  @@filetypes_to_require = {}
-  @@filetypes_to_constant = {}
-
-  abbrevs = Dir.chdir(File.dirname(__FILE__) + "/parser") do
-    Dir["*.rb"].map {|f| f.sub(/\.rb$/,'') }
-  end
-  abbrevs.each do |abbr|
-    abb = abbr.to_sym
-    req = ['ms', 'parser', abbr].join("/")
-    @@filetypes_to_require[abb] = req
-    @@filetypes_to_constant[abb] = ['MS', 'Parser', @@filetypes_to_upcase[abb]].join("::")
-  end
-
-  ############################################
-  # END POINTERS
-  ############################################
-
-  # finds the filetype of a file (expects to be at the beginning) and rewinds
-  # the filehandle to the beginning returns [filetype, version].  nil if
-  # filetype and version could not be determined
-  def self.filetype_and_version(fh_or_filename)
-    if fh_or_filename.is_a? IO
-      fh = fh_or_filename
-      found = nil
-      # Test for RAW file:
-      header = fh.read(18).unpack('@2axaxaxaxaxaxaxa').join
-      if header == 'Finnigan'
-        return [:raw, nil]
-      end
-      fh.rewind
-      while (line = fh.gets)
-        found = 
-          case line
-          when Mzxml_regexp
-            mtch = $2.dup
-            case mtch
-            when /mzXML_([\d\.]+)/
-              [:mzxml, $1.dup]
-            when /MsXML/
-              [:mzxml, '1.0']
-            else
-              abort "Cannot determine mzXML version!"
-            end
-          when Mzdata_regexp
-            [:mzdata, $1.dup]
-          end
-        if found
-          break
-        end
-      end
-      fh.rewind
-      found
-    else
-      File.open(fh_or_filename) do |fh|
-        filetype_and_version(fh)
-      end
-    end
-  end
-
-  # filetype_version is an example file to parse, or it is an array: [type, version].
-  # parse_type is the information to be gleaned (as symbol).
-  def self.new(filetype_version, parse_type, opts={})
-    unless filetype_version.is_a? Array
-      filetype_version = filetype_and_version(filetype_version)
-    end
-    require_and_create_parser(filetype_version, parse_type, opts)
-  end
-
-  private 
-
-  # returns a working parser.
-  def self.require_and_create_parser(filetype_version, parse_type, opts)
-    (filetype, version) = filetype_version
-    #puts "FT: #{filetype} VERSION: #{version}"
-    reply = require @@filetypes_to_require[filetype]
-    @@filetypes_to_require[filetype]
-    parser_class = MS::Parser.const_get(@@filetypes_to_upcase[filetype])
-    parser_class.new(parse_type, version, opts)
-  end
-
-end

data/lib/ms/precursor.rb

@@ -1,25 +0,0 @@
-require 'arrayclass'
-
-module MS; end 
-
-# charge_states are the possible charge states of the precursor
-# parent references a scan
-#                                 0  1         2      3 
-MS::Precursor = Arrayclass.new(%w(mz intensity parent charge_states)) 
-
-class MS::Precursor
-
-  undef :intensity
-  
-  def intensity
-    if self[1].nil?
-      if s = self[2].spectrum
-        self[1] = s.intensity_at_mz(self[0])
-      else
-        nil   # if we didn't read in the spectra, we can't get this value!
-      end
-    end
-    self[1]
-  end
-
-end

data/lib/ms/scan.rb

@@ -1,81 +0,0 @@
-require 'arrayclass'
-require 'ms/precursor'
-
-module MS ; end
-
-#                               0   1        2    3        4      5          6 
-MS::Scan = Arrayclass.new( %w(num ms_level time start_mz end_mz precursor spectrum) )
-
-# time in seconds
-# everything else in float/int
-
-class MS::Scan
-  #@@order = %w(num ms_level time start_mz end_mz prec_mz prec_inten parent spectrum)
-  #attr_accessor :num, :ms_level, :time, :start_mz, :end_mz, :prec_mz, :prec_inten, :parent, :spectrum
-
-  #def initialize(ar=nil)
-  # @@order.zip(ar) do |x,v|
-  #   send((x+'=').to_sym, v)
-  # end
-  #end
-
-  def to_s
-    "<Scan num=#{num} ms_level=#{ms_level} time=#{time}>"
-  end
-
-  undef_method :inspect
-  def inspect
-    atts = %w(num ms_level time start_mz end_mz) 
-    display = atts.map do |att|
-      if val = send(att.to_sym)
-        "#{att}=#{val}"
-      else
-        nil
-      end
-    end
-    display.compact!
-    spec_display = 
-      if spectrum
-        spectrum.mzs.size
-      else
-        'nil'
-      end
-    "<MS::Scan:#{__id__} " + display.join(", ") + " precursor=#{precursor.inspect}" + " spectrum(size)=#{spec_display}" + " >"
-  end
-
-  # returns the string (space delimited): "ms_level num time [prec_mz prec_inten]"
-  def to_index_file_string
-    arr = [ms_level, num, time]
-    if precursor then arr << precursor.mz end
-    if x = precursor.intensity then arr << x end
-    arr.join(" ")
-  end
-
-  # adds the attribute parent to each scan with a parent
-  # (level 1 = no parent; level 2 = prev level 1, etc.
-  def self.add_parent_scan(scans)
-    prev_scan = nil
-    parent_stack = [nil]
-    ## we want to set the level to be the first mslevel we come to
-    prev_level = 1
-    scans.each do |scan|
-      if scan then prev_level = scan.ms_level; break; end
-    end
-    scans.each do |scan|
-      next unless scan  ## the first one is nil, (others?)
-      level = scan.ms_level
-      if prev_level < level
-        parent_stack.unshift prev_scan
-      end
-      if prev_level > level
-        (prev_level - level).times do parent_stack.shift end
-      end
-      scan.parent = parent_stack.first
-      prev_level = level
-      prev_scan = scan
-    end
-  end
-
-end
-
-

data/lib/mspire.rb

@@ -1,4 +0,0 @@
-
-module Mspire
-  Version = '0.4.9'
-end