mzml 0.2.2 → 0.3.0

data/.gitignore

@@ -14,9 +14,12 @@ tmtags
 *.swp
 
 ## PROJECT::GENERAL
+Gemfile.lock
 coverage
 rdoc
 doc
 pkg
+.yardoc
 
 ## PROJECT::SPECIFIC
+scratch.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mzml.gemspec
+gemspec

data/Rakefile

@@ -1,44 +1,20 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "mzml"
-    gem.summary = %Q{A non-validating mzML parser}
-    gem.description = %Q{A non-validating mzML parser. MzML is a standard data format for representing mass spectrometry data.}
-    gem.email = "angel@delagoya.com"
-    gem.homepage = "http://github.com/delagoya/mzml"
-    gem.authors = ["Angel Pizarro"]
-    gem.add_development_dependency "rspec", "1.3.0"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-    gem.add_dependency  "nokogiri", "1.4.1"
-
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+# test
+require 'rake'
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
 end
 
-task :spec => :check_dependencies
-
-task :default => :spec
-
+# documentation
 require 'yard'
-YARD::Rake::YardocTask.new do |yardoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-  yardoc.options = ["--title", "mzml #{version}", "-r", "README.rdoc"]
-  yardoc.files = ['README*','lib/**/*.rb']
+require 'yard/rake/yardoc_task'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', '-' , "README.rdoc","LICENSE"]
+  t.options =  ["-r","README.rdoc"]
 end
+

data/bin/{mzML2mgf.rb → mzml2mgf}

@@ -1,23 +1,7 @@
-#!/opt/local/bin/ruby
-
-################################
-####
-##
-#     David Austin - UPENN
-#     converts mzML to MGF format
-#     set up to replicate msconvert but muuchh slower
-#
-
-require 'rubygems'
+#!/usr/bin/env ruby
 require 'mzml'
-
-
-#first load nokogiri document
-
 mzml =  MzML::Doc.new(ARGV[0])
 
-#now loop through each spectrum.. sort first to be the same as msconvert
-
 sorted_keys = mzml.parse_index_list[:spectrum].keys.sort{ |x,y| x.split('=')[3].to_i <=> y.split('=')[3].to_i }
 
 sorted_keys.each do |k|

data/lib/mzml/chromatogram.rb

@@ -0,0 +1,80 @@
+require 'base64'
+require 'zlib'
+
+module MzML
+  class Chromatogram
+    # Canonical ID of the chromatogram
+    attr_reader :id
+
+    attr_reader :default_array_length
+
+    # The positional index of the chromatogram in the mzML document
+    attr_reader :index_position
+    alias_method :index, :index_position
+
+    attr_reader :default_processing_ref
+
+    # Timepoints intensity values
+    attr_reader :timepoint
+
+    # The unit of time that the timepoints are measured in (e.g. seconds, minutes, ...)
+    attr_reader :time_unit
+
+    # Intensity array of values
+    attr_reader :intensity
+
+    # Nokogiri::XML::Node of the document
+    attr_reader :node
+
+    # CV param attributes
+    attr_reader :params
+
+    def initialize(node)
+      @node = node
+      @params = {}
+      parse_element()
+    end
+
+    protected
+    def parse_element
+      @id = @node[:id]
+      @index_position = @node[:index].to_i
+      @default_array_length = @node[:defaultArrayLength].to_i
+      # CV parameters
+      @params = @node.xpath("./cvParam").inject([]) do  |memo,prm|
+        memo << {:name =>  prm[:name],
+          :value =>   prm[:value],
+          :accession =>  prm[:accession],
+          :cv =>  prm[:cvRef]}
+        memo
+      end
+      # binary data
+      parse_binary_data()
+    end
+
+    def parse_binary_data
+      @node.xpath("./binaryDataArrayList/binaryDataArray").each do |bd|
+        if bd.xpath("cvParam/@accession='MS:1000523'")
+          # "64-bit float"
+          decode_type = "E*"
+        else
+          # 32-bit float
+          decode_type = "e*"
+        end
+        data = Base64.decode64(bd.xpath("binary").text)
+        # compressed?
+        if bd.xpath("cvParam/@accession='MS:1000574'")
+           data = Zlib::Inflate.inflate(data)
+        end
+        # time or intensity data?
+        if bd.xpath("cvParam/@accession='MS:1000595'")
+          # parse the time units
+          @time_unit = bd.xpath("cvParam[@accession='MS:1000595']")[0].attributes["unitName"].value
+          @timepoint = data.unpack(decode_type)
+        else
+          @intensity = data.unpack(decode_type)
+        end
+      end
+    end
+  end
+end

data/lib/mzml/doc.rb

@@ -0,0 +1,185 @@
+#--
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Library or "Lesser" General Public
+# License (LGPL) as published by the Free Software Foundation;
+# either version 2 of the License, or (at your option) any later
+# version.
+# Author: Angel Pizarro
+# Date: 12/05/2009
+# Copyright: Angel Pizarro, Copyright (c) University of Pennsylvania.  All rights reserved.
+#
+
+# == MzML
+#
+# A non-validating mzML v 1.1.0 parser. Most annotation is left as XML DOM
+# objects. See the Nokogiri::XML::Node and Nokogiri::XML::NodeSet
+# documentation on how to work with these.
+#
+# ===USAGE:
+#
+#     require 'mzml'
+#     mzml =  MzML::Doc.new("test.mzXML")
+module MzML
+
+  # An internal module containing useful regular expressions
+  module RGX
+    # The file byte offset of the start of the file index
+    INDEX_OFFSET = /<indexListOffset>(\d+)<\/indexListOffset>/
+    # The start of a either a spectrumList or chromatographList
+    DATA_LIST_START =  /<(spectrum|chromatogram)List\s.*count\=["'](\d+)/m
+    # The start spectrum or chromatogram element
+    DATA_START = /<(spectrum|chromatogram)\s.*id=["']([^'"]+)["']/m
+    # The end spectrum or chromatogram element
+    DATA_END = /(<\/(spectrum|chromatogram)>)/
+  end
+
+  class UnsupportedFileFormat < Exception
+  end
+  class BadIdentifier < Exception
+  end
+
+  # The main mzML parser class, it is a subclass of the File class from the
+  # Ruby standard library in that it places a read cursor on the mzML file,
+  # and will skip around using byte-offsets. We utilize the index at the
+  # end of mzML files to facilitate random access of spectra.
+  #
+  # The {#each} method will cycle through all of the spectrum in a file, starting
+  # from the first one each time. If you would rather access the spectra randomly,
+  # the {#spectrum_list} attribute contains the ordered list of specturm identifiers.
+  # You can access the MzML::Spectrum objects by feeding these identifiers to the {#spectrum}
+  # method.
+  class Doc < ::File
+
+    # Open a file handle to a mzML document
+    def initialize(mz_fname)
+      unless mz_fname =~ /\.mzML$/
+        raise MzML::UnsupportedFileFormat.new  "File extension must be .\"mzML\""
+      end
+      super(mz_fname, "r")
+      @fname = mz_fname
+      @index = parse_index_list
+      @spectrum_count = @spectrum_list.length
+      @chromatogram_count = @chromatogram_list.length
+      @current_spectrum_index = 0
+    end
+    attr_reader :index, :fname, :spectrum_list, :spectrum_count, :chromatogram_list, :chromatogram_count
+
+    # Fetch a {MzML::Chromatogram} from the file, given the identifier
+    # @param chromatogram_id String
+    # @return {MzML::Chromatogram}
+    def chromatogram(chromatogram_id)
+      if @index[:chromatogram].has_key? chromatogram_id
+        self.seek @index[:chromatogram][chromatogram_id]
+        return MzML::Chromatogram.new(parse_next)
+      else
+        raise MzML::BadIdentifier.new("Invalid ID '#{chromatogram_id}'")
+      end
+    end
+
+    def spectrum(spectrum_id)
+      if @index[:spectrum].has_key? spectrum_id
+        self.seek @index[:spectrum][spectrum_id]
+        return MzML::Spectrum.new(parse_next())
+      else
+        raise MzML::BadIdentifier.new("Invalid ID '#{spectrum_id}'")
+      end
+    end
+
+    def each &block
+      @spectrum_list.each do |spectrum_id|
+        block.call(self.spectrum(spectrum_id))
+        @current_spectrum_index += 1
+      end
+    end
+    alias_method :each_spectrum, :each
+
+    def next &block
+      if @current_spectrum_index < @spectrum_list.length
+        @current_spectrum_index += 1
+        self.spectrum(@spectrum_list[@current_spectrum_index - 1])
+      else
+        nil
+      end
+    end
+    alias_method :next_spectrum, :next
+
+    def rewind
+      super
+      @current_spectrum_index = 0
+    end
+
+    private
+    # Parses the IndexList
+    def parse_index_list
+      self.seek(self.stat.size - 200)
+      # parse the index offset
+      tmp = self.read
+      tmp  =~  MzML::RGX::INDEX_OFFSET
+      offset = $1
+      # if I didn't match anything, compute the index and return
+      unless (offset)
+        return compute_index_list
+      end
+      @index = {}
+      @spectrum_list = []
+      @chromatogram_list = []
+      self.seek(offset.to_i)
+      tmp = Nokogiri::XML.parse(self.read).root
+      tmp.css("index").each do |idx|
+        index_type = idx[:name].to_sym
+        @index[index_type] = {}
+        idx.css("offset").each do |o|
+          @index[index_type][o[:idRef]] = o.text().to_i
+          if index_type == :spectrum
+            @spectrum_list << o[:idRef]
+          else
+            @chromatogram_list << o[:idRef]
+          end
+        end
+      end
+      self.rewind
+      return @index
+    end
+
+    def compute_index_list
+      @index = Hash.new {|h,k| h[k] = {} }
+      # start at the beginning.
+      self.rewind
+      # fast forward to the first spectrum or chromatograph
+      buffer = ''
+      while !self.eof
+        buffer += self.read(1024)
+        if start_pos = buffer =~ MzML::RGX::DATA_START
+          self.seek start_pos
+          break
+        end
+      end
+
+      # for each particular entity start to fill in the index
+      buffer = ''
+      rgx_start = /<(spectrum|chromatogram)\s.*id=["']([^"']+)["']/
+      while !self.eof
+        buffer += self.read(1024)
+        if start_pos = buffer =~ rgx_start
+          start_pos = self.pos - buffer.length + start_pos
+          @index[$1.to_sym][$2] = start_pos
+          buffer = ''
+        end
+      end
+      return @index
+    end
+
+    def parse_next
+      buffer = ''
+      while(!self.eof)
+        if end_pos = buffer =~ MzML::RGX::DATA_END
+          extra_content = buffer.slice!((end_pos + $1.length)..-1)
+          self.pos -= (extra_content.length)
+          break
+        end
+        buffer += self.read(1024)
+      end
+      return Nokogiri::XML.parse(buffer).root
+    end
+  end
+end

data/lib/mzml/spectrum.rb

@@ -0,0 +1,107 @@
+require 'base64'
+require 'zlib'
+
+module MzML
+  class Spectrum
+    attr_reader :id, :default_array_length, :type,
+    :precursor, :base_peak_mz, :base_peak_intensity, :ms_level,
+    :high_mz, :low_mz, :title, :tic, :polarity, :representation, :mz_node, :intensity_node,
+    :mz, :intensity, :precursor_list, :scan_list, :retention_time, :precursor_mass,
+    :precursor_intensity, :node, :params
+
+    def initialize(node)
+      @node = node
+      @params = {}
+      @precursor_list = []
+      parse_element()
+    end
+
+    protected
+    def parse_element
+
+      # id
+      @id = @node.attributes["id"].value
+      @index = @node.attributes["index"].value.to_i
+      @default_array_length = @node.attributes["defaultArrayLength"].value.to_i
+
+      # now reaching into params
+      @params = @node.xpath("cvParam").inject({}) do  |memo,prm|
+        memo[prm[:name]] = prm[:value]
+        memo
+      end
+
+      @ms_level = @params["ms level"].to_i
+      @low_mz = @params["lowest observed m/z"].to_f if @params.has_key?("lowest observed m/z")
+      @high_mz = @params["highest observed m/z"].to_f if @params.has_key?("highest observed m/z")
+      @tic = @params["total ion current"].to_i if @params.has_key?("total ion current")
+      @base_peak_mz = @params["base peak m/z"].to_f if @params.has_key?("base peak m/z")
+      @base_peak_intensity = @params["base peak intensity"].to_f if @params.has_key?("base peak intensity")
+
+      # precursor list
+      if @node.xpath("precursorList/precursor").length > 0
+        parse_precursor_list()
+        get_parent_info()
+      else
+        @precursor_list = []
+      end
+
+      # scan list
+      if (@node.xpath("scanList/scan").length > 0)
+        @scan_list = parse_scan_list()
+      else
+        @scan_list = nil
+      end
+      # binary data
+      parse_binary_data()
+    end
+
+    def parse_precursor_list
+      @precursor_list = []
+      @node.xpath("precursorList/precursor").each do |p|
+        @precursor_list << [p[:spectrumRef], p]
+      end
+    end
+
+    def get_parent_info
+      unless @precursor_list.empty?
+        if @precursor_list[0][1].xpath("selectedIonList/selectedIon/cvParam/@accession='MS:1000744'")
+          @precursor_mass = @precursor_list[0][1].xpath("selectedIonList/selectedIon/cvParam[@accession='MS:1000744']")[0][:value].to_f
+        end
+        if @precursor_list[0][1].xpath("selectedIonList/selectedIon/cvParam/@accession='MS:1000042'")
+          @precursor_intensity = @precursor_list[0][1].xpath("selectedIonList/selectedIon/cvParam[@accession='MS:1000042']")[0][:value].to_f
+        end
+      end
+    end
+
+    def parse_scan_list
+      @scan_list = @node.xpath("scanList/scan")
+      if @node.xpath("scanList/scan/cvParam/@accession='MS:1000016'")
+        @retention_time = @node.xpath("scanList/scan/cvParam[@accession='MS:1000016']")[0][:value]
+      end
+    end
+
+    def parse_binary_data
+      @node.xpath("binaryDataArrayList/binaryDataArray").each do |bd|
+        if bd.xpath("cvParam/@accession='MS:1000523'")
+          # "64-bit float"
+          decode_type = "E*"
+        else
+          # 32-bit float
+          decode_type = "e*"
+        end
+        data = Base64.decode64(bd.xpath("binary").text)
+        # compressed?
+        if bd.xpath("cvParam/@accession='MS:1000574'")
+           data = Zlib::Inflate.inflate(data)
+        end
+        # m/z or intensity data?
+        if bd.xpath("cvParam/@accession='MS:1000514'")
+          # m/z data
+          @mz = data.unpack(decode_type)
+        else
+          @intensity = data.unpack(decode_type)
+        end
+      end
+    end
+  end
+end

data/lib/mzml/version.rb

@@ -0,0 +1,4 @@
+module MzML
+  VERSION = "0.3.0"
+end
+