mspire 0.7.18 → 0.8.0

data/lib/mspire/mzml/instrument_configuration.rb

@@ -6,20 +6,21 @@ module Mspire
   class Mzml
     class InstrumentConfiguration
       include Mspire::CV::Paramable
+      extend Mspire::Mzml::List
 
       # (required) the id that this guy can be referenced from
       attr_accessor :id
 
-      # a list of Source, Analyzer, Detector objects
+      # a list of Source, Analyzer, Detector objects (optional)
       attr_accessor :components
 
-      # a single software object associated with the instrument
+      # a single software object associated with the instrument (optional)
       attr_accessor :software
 
-      def initialize(id, components=[], opts={params: []})
-        super(opts)
-        @id = id
-        @components = components
+      def initialize(id, components=[])
+        @id, @components = id, components
+        params_init
+        yield(self) if block_given?
       end
 
       def to_xml(builder)
@@ -31,7 +32,21 @@ module Mspire
         builder
       end
 
-      self.extend(Mspire::Mzml::List)
+      def self.from_xml(xml, link)
+        obj = self.new(xml[:id])
+        next_n = obj.describe_from_xml!(xml, link[:ref_hash])
+        if next_n && next_n.name == 'componentList'
+          obj.components = next_n.children.map do |component_n|
+            Mspire::Mzml.const_get(component_n.name.capitalize).new.describe_self_from_xml!(component_n, link[:ref_hash])
+          end
+          next_n = next_n.next
+        end
+        if next_n && next_n.name == 'softwareRef'
+          obj.software = link[:software_hash][next_n[:ref]]
+        end
+        obj
+      end
+
     end
   end
 end

data/lib/mspire/mzml/io_index.rb

@@ -0,0 +1,79 @@
+require 'mspire/mzml/parser'
+require 'mspire/mzml/spectrum'
+require 'mspire/mzml/chromatogram'
+
+module Mspire
+  class Mzml
+
+    # an index that retrieves its objects on the fly by index from the IO object.
+    class IOIndex
+      include Enumerable
+
+      attr_reader :io
+
+      attr_reader :byte_index
+
+      # hash of relevant hashes and objects for linking
+      attr_accessor :link
+
+      # byte_index will typically be an Mspire::Mzml::Index object.
+      #
+      # link will have the following keys:
+      #
+      #     :ref_hash
+      #     :data_processing_hash
+      #     :(<sample>|<chromatogram>)_default_data_processing
+      #
+      # may have:
+      #
+      #     :source_file_hash
+      #
+      def initialize(io, byte_index, link)
+        @io, @byte_index, @link = io, byte_index, link
+        @object_class = Mspire::Mzml.const_get(@byte_index.name.to_s.capitalize)
+        @closetag_regexp = %r{</#{name}>}
+      end
+
+      def name
+        @byte_index.name
+      end
+
+      def each(&block)
+        return enum_for(__method__) unless block
+        (0...byte_index.size).each do |int|
+          block.call(self[int])
+        end
+      end
+
+      def [](index)
+        @object_class.from_xml(fetch_xml_node(index), @link)
+      end
+
+      def length
+        @byte_index.length
+      end
+      alias_method :size, :length
+
+      # gets the data string through to last element
+      def get_xml_string(start_byte)
+        @io.seek(start_byte)
+        data = ""
+        @io.each_line do |line|
+          data << line 
+          break if @closetag_regexp.match(line)
+        end
+        data
+      end
+
+      def xml_node_from_start_byte(start_byte)
+        xml = get_xml_string(start_byte)
+        Nokogiri::XML.parse(xml, nil, @encoding, Parser::NOBLANKS).root
+      end
+
+      def fetch_xml_node(index)
+        xml_node_from_start_byte(byte_index[index])
+      end
+
+    end
+  end
+end

data/lib/mspire/mzml/io_indexable_list.rb

@@ -0,0 +1,71 @@
+require 'core_ext/enumerable'
+require 'delegate'
+
+module Mspire
+  class Mzml
+
+    # An IOIndexableList is the base object for SpectrumList and
+    # ChromatogramList.  It's main feature is that it delegates all of its
+    # duties to the array like object.
+    class IOIndexableList < SimpleDelegator
+      alias_method :get_delegate, :__getobj__
+
+      attr_accessor :default_data_processing
+
+      # a hash linking an id to the Integer index
+      attr_accessor :id_to_index
+
+      # array_like must implement #[] (with an Integer index), #each, size and length.  For example, it may be an
+      # actual Array object, or it may be an IOIndex, something that behaves
+      # similar to an array but is really pulling objects by reading an io
+      # object.  Sets the spectrum_list attribute of array_like if it can be
+      # set.
+      def initialize(default_data_processing, array_like, id_to_index=nil)
+        if array_like.respond_to?(:spectrum_list=)
+          array_like.spectrum_list = self
+        end
+        @id_to_index = id_to_index
+        @default_data_processing = default_data_processing
+        __setobj__(array_like)
+      end
+
+      # for a class like <Object>List, returns :object.  So a SpectrumList
+      # will return :spectrum.
+      def list_type
+        base = self.class.to_s.split('::').last.sub(/List$/,'')
+        base[0] = base[0].downcase
+        base.to_sym
+      end
+
+
+      # method to generate the id_to_index hash from the underlying delegated
+      # object.
+      def create_id_to_index!
+        @id_to_index = {}
+        get_delegate.each_with_index do |obj, i|
+          @id_to_index[obj.id] = i
+        end
+        @id_to_index
+      end
+
+      # arg may be an Integer or a String (an id)
+      def [](arg)
+        arg.is_a?(Integer) ? get_delegate[arg] : get_delegate[ @id_to_index[arg] ]
+      end
+
+      def to_xml(builder, default_ids)
+        default_ids["#{list_type}_data_processing".to_sym] = @default_data_processing.id
+        xml_name = self.class.to_s.split('::').last
+        xml_name[0] = xml_name[0].downcase
+        builder.tag!(xml_name.to_sym, count: self.size, defaultDataProcessingRef: @default_data_processing.id) do |iol_n|
+          self.each_with_index do |obj,i|
+            obj.index = i unless obj.index
+            obj.to_xml(iol_n, default_ids)
+          end
+        end
+        builder
+      end
+
+    end
+  end
+end

data/lib/mspire/mzml/isolation_window.rb

@@ -16,11 +16,6 @@ module Mspire
     #     e.g.: MS:1000829 (isolation window upper offset)
     class IsolationWindow
       include Mspire::CV::Paramable
-      def self.from_xml(xml)
-        obj = self.new
-        [:cvParam, :userParam].each {|v| obj.describe! xml.xpath("./#{v}") }
-        obj
-      end
     end
   end
 end

data/lib/mspire/mzml/parser.rb

@@ -0,0 +1,10 @@
+require 'nokogiri'
+
+module Mspire
+  class Mzml
+    module Parser
+      NOBLANKS = ::Nokogiri::XML::ParseOptions::DEFAULT_XML | ::Nokogiri::XML::ParseOptions::NOBLANKS
+    end
+  end
+end
+

data/lib/mspire/mzml/plms1.rb

@@ -3,32 +3,22 @@ require 'mspire/plms1'
 
 module Mspire
   class Mzml
-    # will use scan numbers if use_scan_nums is true, otherwise it will use index
-    # numbers in place of scan nums
+    # will use scan numbers if use_scan_nums is true (typically start with
+    # one), otherwise it will use index numbers (starts with zero)
     def to_plms1(use_scan_nums=true)
-      spectrum_index_list = self.index_list[:spectrum]
-      scan_nums = 
-        if use_scan_nums 
-          spectrum_index_list.create_scan_to_index.keys
-        else
-          (0...spectrum_index_list.size).to_a
-        end
-      retention_times = self.enum_for(:each_spectrum_node).map do |xml_node|
-        rt_xml_node=xml_node.xpath("scanList/scan/cvParam[@accession='MS:1000016']")[0]
-        raise 'no retention time xml node' unless rt_xml_node
-        retention_time = rt_xml_node['value'].to_f
-        case rt_xml_node['unitName']
-        when 'minute'
-          retention_time * 60
-        when 'second'
-          retention_time
-        else
-          raise 'retention time must be in minutes or seconds (or add some code to handle)'
-        end
+      spectrum_index = self.index_list[:spectrum]
+
+      scan_nums = spectrum_index.create_scan_to_index.keys if use_scan_nums
+
+      nums = [] ; rts = [] ; spectra = []
+
+      self.each_with_index do |spec, index|
+        next unless spec.ms_level == 1
+        nums << (use_scan_nums ? scan_nums[index] : index)
+        spectra << spec
+        rts << spec.retention_time
       end
-      # plms1 only requires that the obect respond to :each, giving a spectrum
-      # object, so an Mzml object will work.
-      Mspire::Plms1.new(scan_nums, retention_times, self)
+      Mspire::Plms1.new(nums, rts, spectra)
     end
   end
 end

data/lib/mspire/mzml/precursor.rb

@@ -7,9 +7,10 @@ module Mspire
   class Mzml
     # The method of precursor ion selection and activation
     class Precursor
-      # (optional) the Mspire::Mzml::Spectrum object from which the precursor is
-      # derived
-      attr_accessor :spectrum
+
+      # (optional) the id of the Spectrum object, whether internal or
+      # externally derived.
+      attr_accessor :spectrum_id
 
       # (optional)
       attr_accessor :isolation_window 
@@ -20,34 +21,55 @@ module Mspire
       # (required) The type and energy level used for activation.
       attr_accessor :activation
 
-      # a boolean indicating the spectrum is from an external source file
-      attr_accessor :from_external_source_file
+      # This is an *EXTERNAL* source file *ONLY*.  It should NOT be set if the
+      # spectrum is internal.
+      attr_accessor :source_file
+
+      # the spectrum list object which enables the spectrum to be accessed directly
+      attr_accessor :spectrum_list
+
+      # provide the SpectrumList object for #spectrum access
+      def initialize(spectrum_id=nil, spectrum_list=nil)
+        @spectrum_id, @spectrum_list = spectrum_id, spectrum_list
+      end
 
-      def initialize(spectrum_derived_from=nil)
-        @spectrum=spectrum_derived_from
+      def spectrum
+        @spectrum_list[@spectrum_id]
       end
 
-      def self.from_xml(xml)
+      def self.from_xml(xml, link)
+        ref_hash = link[:ref_hash]
         obj = self.new
-        %w(isolationWindow activation).each do |el|
-          sub_node = xml.xpath("./#{el}").first
-          el[0] = el[0].capitalize
-          Mspire::Mzml.const_get(el).from_xml(sub_node) if sub_node
+        obj.spectrum_id = xml[:spectrumRef] || xml[:externalSpectrumID]
+        if source_file_ref = xml[:sourceFileRef]
+          obj.source_file = link[:source_file_hash][ source_file_ref ]
         end
-        obj.selected_ions = xml.xpath('./selectedIonList/selectedIon').map do |si_n|
-          Mspire::Mzml::SelectedIon.from_xml(si_n)
+
+        xml.children.each do |child_n|
+          case child_n.name
+          when 'activation' # the only one required
+            obj.activation = Mspire::Mzml::Activation.new.describe_self_from_xml!(child_n, ref_hash)
+          when 'isolationWindow'
+            obj.isolation_window = Mspire::Mzml::IsolationWindow.new.describe_self_from_xml!(child_n, ref_hash)
+          when 'selectedIonList'
+            obj.selected_ions = child_n.children.map do |si_n|
+              Mspire::Mzml::SelectedIon.new.describe_self_from_xml!(si_n, ref_hash)
+            end
+          end
         end
+        
         obj
       end
 
       def to_xml(builder)
         atts = {}
-        if @from_external_source_file
-          atts[:sourceFileRef] = @spectrum.source_file.id
-          atts[:externalSpectrumRef] = @spectrum.id
-        else
-          atts[:spectrumRef] = @spectrum.id if @spectrum
+        if @source_file
+          atts[:sourceFileRef] = @source_file.id
+          atts[:externalSpectrumRef] = @spectrum_id
+        elsif @spectrum_id
+          atts[:spectrumRef] = @spectrum_id
         end
+
         builder.precursor(atts) do |prec_n|
           @isolation_window.to_xml(prec_n) if @isolation_window
           Mspire::Mzml::SelectedIon.list_xml(@selected_ions, prec_n) if @selected_ions

data/lib/mspire/mzml/processing_method.rb

@@ -2,19 +2,40 @@ require 'mspire/cv/paramable'
 
 module Mspire
   class Mzml
+
+    # MAY supply a *child* term of MS:1000630 (data processing parameter) one or more times
+    #     e.g.: MS:1000629 (low intensity threshold)
+    #     e.g.: MS:1000631 (high intensity threshold)
+    #     e.g.: MS:1000747 (completion time)
+    #     e.g.: MS:1000787 (inclusive low intensity threshold)
+    #     e.g.: MS:1000788 (inclusive high intensity threshold)
+    #
+    # MUST supply a *child* term of MS:1000452 (data transformation) one or more times
+    #     e.g.: MS:1000033 (deisotoping)
+    #     e.g.: MS:1000034 (charge deconvolution)
+    #     e.g.: MS:1000544 (Conversion to mzML)
+    #     e.g.: MS:1000545 (Conversion to mzXML)
+    #     e.g.: MS:1000546 (Conversion to mzData)
+    #     e.g.: MS:1000593 (baseline reduction)
+    #     e.g.: MS:1000594 (low intensity data point removal)
+    #     e.g.: MS:1000741 (Conversion to dta)
+    #     e.g.: MS:1000745 (retention time alignment)
+    #     e.g.: MS:1000746 (high intensity data point removal)
     class ProcessingMethod
       include Mspire::CV::Paramable
 
-      attr_accessor :order, :software
+      attr_accessor :software
 
-      def initialize(order, software, opts={params: []}, &block)
-        @order, @software = order, software
-        super(opts)
-        block.call(self) if block
+      def initialize(software)
+        @software = software
+        params_init
+        if block_given?
+          yield self 
+        end
       end
 
-      def to_xml(builder)
-        builder.processingMethod(order: @order, softwareRef: software.id) do |pm_n|
+      def to_xml(builder, order)
+        builder.processingMethod(order: order, softwareRef: software.id) do |pm_n|
           super(pm_n) # params
         end
         builder
@@ -22,3 +43,9 @@ module Mspire
     end
   end
 end
+
+# The order attribute is *not* intrinsic to the ProcessingMethod (and thus
+# cannot be queried from within the object.  It can be determined easily
+# by asking for the index of the method in the array of processing
+# methods.  (zero based indexing is fine)
+

data/lib/mspire/mzml/product.rb

@@ -2,7 +2,13 @@ require 'mspire/mzml/list'
 
 module Mspire
   class Mzml
+    # The method of product ion selection and activation in a precursor ion scan
+    #
+    # this object is NOT paramable, it just contains a single IsolationWindow
     class Product
+      
+      extend Mspire::Mzml::List
+
       attr_accessor :isolation_window
 
       def initialize(isolation_window=nil)
@@ -15,7 +21,14 @@ module Mspire
         end
       end
 
-      extend(Mspire::Mzml::List)
+      def self.from_xml(xml, ref_hash)
+        isolation_window_n = xml.child
+        if isolation_window_n
+          iw = Mspire::Mzml::IsolationWindow.from_xml(isolation_window_n, ref_hash)
+        end
+        self.new(iw)
+      end
+
     end
   end
 end

data/lib/mspire/mzml/reader.rb

@@ -0,0 +1,154 @@
+require 'io/bookmark'
+
+%w(
+  parser
+
+  index_list
+
+  cv
+  referenceable_param_group
+  file_description
+
+  sample
+  software
+  instrument_configuration
+  data_processing
+  run
+).each do |file|
+  require "mspire/mzml/#{file}"
+end
+
+module Mspire
+  class Mzml
+  end
+end
+
+module Mspire::Mzml::Reader
+
+  attr_accessor :link
+
+  def set_from_xml_io!(xml_io)
+    @io = xml_io
+    begin
+      @encoding = @io.bookmark(true) {|io| io.readline.match(/encoding=["'](.*?)["']/)[1] }
+    rescue EOFError
+      raise RuntimeError, "no encoding present in XML!  (Is this even an xml file?)"
+    end
+    @index_list = Mspire::Mzml::IndexList.from_io(@io)
+    read_header!( get_default_data_processing_ids(@io, @index_list) )
+  end
+
+  # returns a hash keyed by :spectrum or :chromatogram that gives the id
+  # (aka ref) as a string.
+  def get_default_data_processing_ids(io, index_list, lookback=200)
+    hash = {}
+    index_list.each_pair do |name, index|
+      io.bookmark do |io|
+        io.pos = index[0] - lookback 
+        hash[name] = io.read(lookback)[/<#{name}List.*defaultDataProcessingRef=['"](.*?)['"]/m, 1]
+      end
+    end
+    hash
+  end
+
+  # saves ~ 3 seconds when reading a 83M mzML file to scrape off the
+  # header string (even though we're just handing in an IO object to
+  # Nokogiri::XML::Document.parse and we are very careful to not parse too
+  # far).
+  def get_header_string(io)
+    chunk_size = 2**12
+    loc = 0
+    string = ''
+    while chunk = @io.read(chunk_size)
+      string << chunk
+      start_looking = ((loc-20) < 0) ? 0 : (loc-20)
+      break if string[start_looking..-1] =~ /<(spectrum|chromatogram)/
+        loc += chunk_size
+    end
+    string
+  end
+
+  # list_type_to_default_data_processing_id is a hash keyed by :spectrum or
+  # :chromatogram that gives the default data_processing_object for the
+  # SpectrumList and/or the ChromatogramList.  This information is not
+  # obtainable from the header string, so must be pre-obtained.
+  def read_header!(list_type_to_default_data_processing_id)
+    @io.rewind
+
+    string = get_header_string(@io)
+    doc = Nokogiri::XML.parse(string, nil, @encoding, Mspire::Mzml::Parser::NOBLANKS)
+
+    doc.remove_namespaces!
+    mzml_n = doc.root
+    if mzml_n.name == 'indexedmzML'
+      mzml_n = mzml_n.child
+    end
+    cv_list_n = mzml_n.child
+    self.cvs = cv_list_n.children.map do |cv_n|
+      Mspire::Mzml::CV.from_xml(cv_n)
+    end
+
+    # get the file description node but deal with it after getting ref_hash
+    file_description_n = cv_list_n.next
+
+    xml_n = file_description_n.next
+
+    # a hash of referenceable_param_groups indexed by id
+    @link = {}
+
+    if xml_n.name == 'referenceableParamGroupList'
+      self.referenceable_param_groups = xml_n.children.map do |rpg_n|
+        Mspire::Mzml::ReferenceableParamGroup.from_xml(rpg_n) # <- no ref_hash (not made yet)
+      end
+      @link[:ref_hash] = self.referenceable_param_groups.index_by(&:id)
+      xml_n = xml_n.next
+    end
+
+    # now we can set the file description because we have the ref_hash
+    self.file_description = Mspire::Mzml::FileDescription.from_xml(file_description_n, @link)
+    @link[:source_file_hash] = self.file_description.source_files.index_by(&:id)
+
+
+    loop do
+      case xml_n.name
+      when 'sampleList'
+        self.samples = xml_n.children.map do |sample_n|
+          Mspire::Mzml::Sample.from_xml(sample_n, @link)
+        end
+        @link[:sample_hash] = self.samples.index_by(&:id)
+      when 'softwareList'  # required
+        self.software_list = xml_n.children.map do |software_n|
+          Mspire::Mzml::Software.from_xml(software_n, @link)
+        end
+        @link[:software_hash] = self.software_list.index_by(&:id)
+      when 'instrumentConfigurationList'
+        self.instrument_configurations = xml_n.children.map do |inst_config_n|
+          Mspire::Mzml::InstrumentConfiguration.from_xml(inst_config_n, @link)
+        end
+        @link[:instrument_configuration_hash] = self.instrument_configurations.index_by(&:id)
+      when 'dataProcessingList'
+        self.data_processing_list = xml_n.children.map do |data_processing_n|
+          Mspire::Mzml::DataProcessing.from_xml(data_processing_n, @link)
+        end
+        @link[:data_processing_hash] = self.data_processing_list.index_by(&:id)
+      when 'run'
+        @link[:index_list] = @index_list
+        list_type_to_default_data_processing_id.each do |type, process_id|
+          @link["#{type}_default_data_processing".to_sym] = @link[:data_processing_hash][process_id]
+        end
+        self.run = Mspire::Mzml::Run.from_xml(@io, xml_n, @link)
+        break
+      end
+      xml_n = xml_n.next
+    end
+  end
+end
+
+module Mspire
+  class Mzml
+    include Reader
+  end
+end
+
+
+

data/lib/mspire/mzml/referenceable_param_group.rb

@@ -12,9 +12,10 @@ module Mspire
 
       attr_accessor :id
 
-      def initialize(id, opts={params: []} )
+      def initialize(id)
         @id = id
-        super(opts)
+        params_init
+        yield(self) if block_given?
       end
 
       def to_xml(builder)
@@ -29,6 +30,12 @@ module Mspire
         builder
       end
 
+      def self.from_xml(xml)
+        obj = self.new(xml[:id])
+        obj.describe_from_xml!(xml)
+        obj
+      end
+
       def self.list_xml(objs, builder)
         builder.referenceableParamGroupList(count: objs.size) do |rpgl_n|
           objs.each {|obj| obj.to_xml_definition(rpgl_n) }