mspire 0.7.18 → 0.8.0

data/lib/mspire/mzml/data_array.rb

@@ -4,177 +4,187 @@ require 'mspire/cv/paramable'
 
 module Mspire
   class Mzml
-    class DataArray < Array
-      alias_method :array_initialize, :initialize
-      include Mspire::CV::Paramable
-      alias_method :params_initialize, :initialize
-      alias_method :params_to_xml, :to_xml
-
-      DEFAULT_DTYPE = :float64
-      DEFAULT_COMPRESSION = true
-      DTYPE_TO_ACC = {
-        float64: 'MS:1000523',
-        float32: 'MS:1000521',
-        # float16: 'MS:1000520',  # <- not supported w/o other gems
-        int64: 'MS:1000522', # signed
-        int32: 'MS:1000519', # signed
-      }
-
-      def type=(arg)
-        all_accs = %w(MS:1000514 MS:1000515)
-        params.delete_if {|param| all_accs.include?(param.accession) } if params
-        case arg
-        when :mz
-          describe! all_accs[0] # , nil, "MS:1000040"
-        when :intensity
-          describe! all_accs[1] # , nil, "MS:1000131"
-        end
-        arg
-      end
+  end
+end
 
-      def type
-        if params
-          if params.any? {|param| param.accession == 'MS:1000514' }
-            :mz
-          elsif params.any? {|param| param.accession == 'MS:1000515' }
-            :intensity
-          end
-        end
-      end
 
-      # set this if the data is written to an external file (such as the ibd
-      # file for imzML files)
-      attr_accessor :external
+class Mspire::Mzml::DataArray < Array
+  alias_method :array_init, :initialize
+  include Mspire::CV::Paramable
 
-      def initialize(*args)
-        array_initialize(*args)
-        params_initialize
-      end
+  DEFAULT_DTYPE = :float64
+  DEFAULT_COMPRESSION = true
+  DTYPE_TO_ACC = {
+    float64: 'MS:1000523',
+    float32: 'MS:1000521',
+    # float16: 'MS:1000520',  # <- not supported w/o other gems
+    int64: 'MS:1000522', # signed
+    int32: 'MS:1000519', # signed
+  }
+  TYPE_XML = {
+    mz: '<cvParam cvRef="MS" accession="MS:1000514" name="m/z array"/>',
+    intensity: '<cvParam cvRef="MS" accession="MS:1000515" name="intensity array"/>'
+  }
 
-      # returns a new Mspire::Mzml::DataArray object (an array)
-      #
-      #     args:
-      #       base64, set-like               # where set-like responds to include?
-      #       base64, type=:float64, compression=true
-      #
-      #     examples:
-      #     Mspire::Mzml::Spectrum.unpack_binary('eJxjYACBD/YMEOAAoTgcABe3Abg=', ['MS:1000574', MS:1000523']).
-      #     Mspire::Mzml::Spectrum.unpack_binary("ADBA/=", :float32, true)
-      #     Mspire::Mzml::Spectrum.unpack_binary("ADBA/=") # uses float64 and compression
-      def self.from_binary(base64, *args)
-        if args.first.respond_to?(:include?)
-          accessions = args.first
-          compressed =
-            if accessions.include?('MS:1000574') then true # zlib compression
-            elsif accessions.include?('MS:1000576') then false # no compression
-            else raise 'no compression info: check your MS accession numbers'
-            end
-          precision_unpack = 
-            if accessions.include?('MS:1000523') then 'E*'
-            elsif accessions.include?('MS:1000521') then 'e*'
-            else raise 'unrecognized precision: check your MS accession numbers'
-            end
-        else
-          compressed = args.last || true
-          precision_unpack =
-            case args.first
-            when :float64
-              'E*'
-            when :float32
-              'e*'
-            when nil
-              'E*'
-            else
-              raise ArgumentError, "#{args.first} must be one of :float64, :float32 or other acceptable type"
-            end
+  def initialize(*args)
+    params_init # paramable
+    array_init(*args)
+  end
+
+  # takes :mz or :intensity and sets the proper param among cvParams.  Does not do
+  # referenceableParamGroup resolution.
+  def type=(symbol)
+    new_cv_params = []
+    already_present = false
+    cvs = ['MS:1000514', 'MS:1000515']
+    cvs.reverse! if symbol == :intensity
+    (keep, remove) = cvs
+
+    @cv_params.each do |param|
+      new_cv_params << param unless param.accession == remove
+      (already_present = true) if (param.accession == keep)
+    end
+    new_cv_params.push(Mspire::CV::Param[keep]) unless already_present
+    @cv_params = new_cv_params
+    symbol
+  end
+
+  # :mz or :intensity (or nil if none found)
+  def type
+    each_accessionable_param do |param|
+      return :mz if (param.accession == 'MS:1000514')
+      return :intensity if (param.accession == 'MS:1000515')
+    end
+    nil
+  end
+
+  # (optional) the DataProcessing object associated with this DataArray
+  attr_accessor :data_processing
+
+  # set this if the data is written to an external file (such as the ibd
+  # file for imzML files)
+  attr_accessor :external
+
+  def self.empty_data_arrays
+    [self.new, self.new]
+  end
+
+  def self.data_arrays_from_xml(xml, link)
+    data_arrays = xml.children.map do |binary_data_array_n|
+      Mspire::Mzml::DataArray.from_xml(binary_data_array_n, link)
+    end
+    (data_arrays.size > 0) ? data_arrays : empty_data_arrays
+  end
+
+  def self.from_xml(xml, link)
+    da = self.new 
+    binary_n = da.describe_from_xml!(xml, link[:ref_hash])
+
+    if (dp_id = xml[:dataProcessingRef])
+      da.data_processing = link[:data_processing_hash][dp_id]
+    end
+
+    zlib_compression = nil
+    precision_unpack = nil
+    # could also implement with set or hash lookup (need to test for
+    # speed)
+    da.each_accessionable_param do |param|
+      acc = param.accession
+      unless zlib_compression || zlib_compression == false
+        case acc
+        when 'MS:1000574' then zlib_compression = true
+        when 'MS:1000576' then zlib_compression = false
         end
-        data = base64.unpack("m*").first
-        # some implementations leave data blank if there aren't peaks
-        # even if they say it is zlib compressed...
-        unzipped = 
-          if data.size > 0  
-            compressed ? Zlib::Inflate.inflate(data) : data
-          else
-            data
-          end
-        self.new( unzipped.unpack(precision_unpack) )
       end
+      unless precision_unpack
+        case acc
+        when 'MS:1000523' then precision_unpack = 'E*'
+        when 'MS:1000521' then precision_unpack = 'e*'
+        end
+      end
+    end
 
-      # returns a base64 string that can be used for xml representations of
-      # the data
-      #
-      #     args:
-      #       array-like  set-like               # where set-like responds to include?
-      #       array-like  dtype=:float64, compression=true
-      def self.to_binary(array_ish, *args)
-        if args.first.respond_to?(:include?)
-          accessions = args.first
-          dtype = 
-            if accessions.include?('MS:1000521') 
-              :float32
-            else
-              :float64
-            end
-          compression = accessions.include?('MS:1000576') ? false : true 
+    data = binary_n.text.unpack("m*").first
+
+    # some implementations leave data blank if there aren't peaks
+    # even if they say it is zlib compressed...
+    unzipped = 
+      if data.size > 0 then ( zlib_compression ? Zlib::Inflate.inflate(data) : data )
+      else data end
+    da.replace( unzipped.unpack(precision_unpack) )
+    da
+  end
+
+  # returns a base64 string that can be used for xml representations of
+  # the data
+  #
+  #     args:
+  #       array-like  set-like               # where set-like responds to include?
+  #       array-like  dtype=:float64, compression=true
+  def self.to_binary(array_ish, *args)
+    if args.first.respond_to?(:include?)
+      accessions = args.first
+      dtype = 
+        if accessions.include?('MS:1000521') 
+          :float32
         else
-          dtype = args[0] || DEFAULT_DTYPE
-          compression = args[1] || DEFAULT_COMPRESSION
+          :float64
         end
+      compression = accessions.include?('MS:1000576') ? false : true 
+    else
+      dtype = args[0] || DEFAULT_DTYPE
+      compression = args[1] || DEFAULT_COMPRESSION
+    end
 
-        pack_code = 
-          case dtype
-          when :float64 ; 'E*'
-          when :float32 ; 'e*'
-          when :int64   ; 'q<*'
-          when :int32   ; 'l<*'
-          else ; raise "unsupported dtype: #{dtype}"
-          end
-        # TODO: support faster pack method for NArray's in future
-        string = array_ish.to_a.pack(pack_code) 
-        string = Zlib::Deflate.deflate(string) if compression
-        Base64.strict_encode64(string)
+    pack_code = 
+      case dtype
+      when :float64 ; 'E*'
+      when :float32 ; 'e*'
+      when :int64   ; 'q<*'
+      when :int32   ; 'l<*'
+      else ; raise "unsupported dtype: #{dtype}"
       end
+    # TODO: support faster pack method for NArray's in future
+    string = array_ish.to_a.pack(pack_code) 
+    string = Zlib::Deflate.deflate(string) if compression
+    Base64.strict_encode64(string)
+  end
 
-      # calls the class to_binary method with self and the given args
-      def to_binary(*args)
-        self.class.to_binary(self, *args)
-      end
+  # calls the class to_binary method with self and the given args
+  def to_binary(*args)
+    self.class.to_binary(self, *args)
+  end
 
-      def to_xml(builder, dtype=DEFAULT_DTYPE, compression=DEFAULT_COMPRESSION)
-        encoded_length = 
-          if @external
-            0
-          else
-            base64 = self.class.to_binary(self, dtype, compression)
-            base64.bytesize
-          end
-
-        builder.binaryDataArray(encodedLength: encoded_length) do |bda_n|
-          params_to_xml(bda_n)
-          unless self.external
-            Mspire::CV::Param[ DTYPE_TO_ACC[dtype] ].to_xml(bda_n)
-            Mspire::CV::Param[ compression ? 'MS:1000574' : 'MS:1000576' ].to_xml(bda_n)
-            bda_n.binary(base64)
-          end
-        end
+  def to_xml(builder, dtype=DEFAULT_DTYPE, compression=DEFAULT_COMPRESSION)
+    encoded_length = 
+      if @external
+        0
+      else
+        base64 = self.class.to_binary(self, dtype, compression)
+        base64.bytesize
       end
 
-      # takes an array of DataArray objects or other kinds of objects
-      def self.list_xml(arrays, builder)
-        builder.binaryDataArrayList(count: arrays.size) do |bdal_n|
-          arrays.zip([:mz, :intensity]) do |data_ar, typ|
-            ar = 
-              if data_ar.is_a?(Mspire::Mzml::DataArray)
-                data_ar
-              else
-                Mspire::Mzml::DataArray.new(data_ar)
-              end
-            ar.type = typ unless ar.type
-            ar.to_xml(bdal_n)
-          end
-        end
+    builder.binaryDataArray(encodedLength: encoded_length) do |bda_n|
+      super(bda_n)
+      unless self.external
+        # can significantly speed up the below 2 lines:
+        Mspire::CV::Param[ DTYPE_TO_ACC[dtype] ].to_xml(bda_n)
+        Mspire::CV::Param[ compression ? 'MS:1000574' : 'MS:1000576' ].to_xml(bda_n)
+        bda_n.binary(base64)
       end
+    end
+  end
 
+  # takes an array of DataArray objects or other kinds of objects
+  def self.list_xml(arrays, builder)
+    builder.binaryDataArrayList(count: arrays.size) do |bdal_n|
+      arrays.zip([:mz, :intensity]) do |data_ar, typ|
+        ar = 
+          if data_ar.is_a?(Mspire::Mzml::DataArray) then data_ar
+          else Mspire::Mzml::DataArray.new(data_ar) end
+        ar.type = typ unless ar.type
+        ar.to_xml(bdal_n)
+      end
     end
   end
 end

data/lib/mspire/mzml/data_array_container_like.rb

@@ -38,21 +38,14 @@ module Mspire
         end
       end
 
-      # see SpectrumList for generating the entire list
-      # the opt key :sub_elements can be used to pass in subelements whose
-      # to_xml methods will be called.
-      def to_xml(builder, opts={}, &block)
+      # returns a hash with id, index, defaultArrayLength and the proper
+      # dataProcessing attributes filled out.
+      def data_array_xml_atts(default_ids)
         atts = {id: @id, index: @index, defaultArrayLength: default_array_length}
-        atts[:dataProcessingRef] = @data_processing.id if @data_processing
-        atts.merge!(opts)
-        raise "#{self.class} object must have index at xml writing time!" unless atts[:index] 
-
-        builder.spectrum(atts) do |sp_n|
-          super(sp_n) # params
-          block.call(sp_n) if block
-          Mspire::Mzml::DataArray.list_xml(@data_arrays, sp_n) if @data_arrays
+        if @data_processing && default_ids[:data_processing] != @data_processing.id 
+          atts[:dataProcessingRef] = @data_processing.id 
         end
-        builder
+        atts
       end
 
     end

data/lib/mspire/mzml/data_processing.rb

@@ -1,27 +1,41 @@
 require 'mspire/mzml/list'
+require 'mspire/mzml/processing_method'
 
 module Mspire
   class Mzml
     class DataProcessing
+      extend Mspire::Mzml::List
 
       attr_accessor :id, :processing_methods
 
       # yields self if given a block
-      def initialize(id, processing_methods=[], &block)
+      def initialize(id, processing_methods=[])
         @id, @processing_methods = id, processing_methods
-        block.call(self) if block
+        yield(self) if block_given?
       end
 
       def to_xml(builder)
         builder.dataProcessing( id: @id ) do |dp_n|
-          processing_methods.each do |proc_method|
-            proc_method.to_xml(dp_n)
+          processing_methods.each_with_index do |processing_method,order|
+            processing_method.to_xml(dp_n, order)
           end
         end
         builder
       end
 
-      extend(Mspire::Mzml::List)
+      # returns the order of the processing method
+      def order(processing_method)
+        processing_methods.index(processing_method)
+      end
+
+      def self.from_xml(xml, link)
+        processing_methods = xml.children.map do |pm_n| 
+          ProcessingMethod.new(link[:software_hash][pm_n[:softwareRef]])
+            .describe_self_from_xml!(pm_n, link[:ref_hash])
+        end
+        self.new(xml[:id], processing_methods)
+      end
+
     end
   end
 end

data/lib/mspire/mzml/file_description.rb

@@ -5,6 +5,7 @@ require 'mspire/mzml/contact'
 module Mspire
   class Mzml
     class FileDescription
+      # note: FileDescription is NOT paramable!
 
       # a summary of the different types of spectra, must be present
       attr_accessor :file_content
@@ -21,14 +22,31 @@ module Mspire
       attr_accessor :contacts
 
       # hands the user the object if given a block
-      def initialize(file_content=nil, source_files=[], contacts=[], &block)
+      def initialize(file_content=nil, source_files=[], contacts=[])
         @file_content, @source_files, @contacts = file_content, source_files, contacts
-        block.call(self) if block
+        yield(self) if block_given?
         #raise ArgumentError, "FileDescription must have file_content" unless @file_content
       end
 
-      def self.from_xml(xml)
-        self.new
+      def self.from_xml(xml, link)
+        ref_hash = link[:ref_hash]
+        file_content_n = xml.child
+        obj = self.new( Mspire::Mzml::FileContent.new.describe_self_from_xml!(file_content_n, ref_hash) )
+
+        return obj unless next_n = file_content_n.next
+
+        if next_n.name == 'sourceFileList'
+          obj.source_files = next_n.children.map do |source_file_n|
+            Mspire::Mzml::SourceFile.from_xml(source_file_n, ref_hash)
+          end
+          return obj unless next_n = next_n.next
+        end
+
+        loop do
+          obj.contacts << Mspire::Mzml::Contact.from_xml(contact_n, ref_hash)
+          break unless contact_n = contact_n.next
+        end
+        obj
       end
 
       def to_xml(builder)

data/lib/mspire/mzml/index.rb

@@ -0,0 +1,53 @@
+
+module Mspire
+  class Mzml
+    # the array holds start bytes
+    class Index < Array
+
+      # the name of the index (as a symbol)
+      attr_accessor :name
+
+      # a parallel array of ids (idRef's)
+      attr_accessor :ids
+
+      # @return [Integer] the start byte of the spectrum
+      # @param [Object] an Integer (the index number) or String (an id string)
+      def start_byte(arg)
+        case arg
+        when Integer
+          self[arg]
+        when String
+          @id_index ||= create_id_index
+          @id_index[arg]
+        end
+      end
+
+      # generates a scan to index hash that points from scan number to the
+      # spectrum index number.  returns the index, nil if the scan ids
+      # are not present and spectra are, or false if they are not unique.
+      def create_scan_to_index
+        scan_re = /scan=(\d+)/
+          scan_to_index = {}
+        ids.each_with_index do |id, index|
+          md = id.match(scan_re)
+          scan_num = md[1].to_i if md
+          if scan_num
+            if scan_to_index.key?(scan_num)
+              return false
+            else
+              scan_to_index[scan_num] = index
+            end
+          end
+        end
+        if scan_to_index.size > 0
+          scan_to_index
+        elsif ids.size > 0
+          nil  # there are scans, but we did not find scan numbers
+        else
+          scan_to_index
+        end
+      end
+    end
+  end
+end
+

data/lib/mspire/mzml/index_list.rb

@@ -1,10 +1,12 @@
+require 'mspire/mzml/index'
+
 module Mspire
   class Mzml
     # A simple array of indices but #[] has been overloaded to find an index
     # by name
     #
     #     index_list[0]  # the first index
-    #     index_list.map(&:names) # -> [:spectrum, :chromatogram] 
+    #     index_list.map(&:name) # -> [:spectrum, :chromatogram] 
     #     index_list[:spectrum]  # the spectrum index
     #     index_list[:chromatogram]  # the chromatogram index
     class IndexList < Array
@@ -20,12 +22,24 @@ module Mspire
           self.find {|index| index.name == int_or_symbol }
         end
       end
-    end
 
-    # the array holds start bytes
-    class Index < Array
+      def keys
+        self.map(&:name)
+      end
+
+      # returns each name and associated index object
+      def each_pair(&block)
+        block or return enum_for __method__
+        each {|index| block.call([index.name, index]) }
+      end
 
       class << self
+
+        # either reads in from file or creates an IndexList
+        def from_io(io)
+          read_index_list(io) || create_index_list(io)
+        end
+
         # returns an Integer or nil if not found
         # does a single jump backwards from the tail of the file looking for
         # an xml element based on tag.  If it is not found, returns nil
@@ -35,64 +49,59 @@ module Mspire
           md = io.readlines("\n").map {|line| line.match(tag_re) }.compact.shift
           md[1].to_i if md
         end
-      end
-
-      # an index indexed by scan number
-      attr_accessor :by_scans
-
-      # the name of the index (as a symbol)
-      attr_accessor :name
-
-      # a parallel array of ids (idRef's)
-      attr_accessor :ids
-
-      def start_byte_and_id(int)
-        [self[int], ids[int]]
-      end
-
-      # returns hash of id to start_byte
-      def create_id_index
-        Hash[self.ids.zip(self)]
-      end
 
-      # @return [Integer] the start byte of the spectrum
-      # @param [Object] an Integer (the index number) or String (an id string)
-      def start_byte(arg)
-        case arg
-        when Integer
-          self[arg]
-        when String
-          @id_index ||= create_id_index
-          @id_index[arg]
+        # @return [Mspire::Mzml::IndexList] or nil if there is no indexList in the
+        # mzML
+        def read_index_list(io)
+          if (offset = index_offset(io))
+            io.seek(offset)
+            xml = Nokogiri::XML.parse(io.read, nil, @encoding, Parser::NOBLANKS)
+            index_list = xml.root
+            num_indices = index_list['count'].to_i
+            array = index_list.children.map do |index_n|
+              #index = Index.new(index_n['name'])
+              index = Index.new
+              index.name = index_n['name'].to_sym
+              ids = []
+              index_n.children.map do |offset_n| 
+                index << offset_n.text.to_i 
+                ids << offset_n['idRef']
+              end
+              index.ids = ids
+              index
+            end
+            IndexList.new(array)
+          end
         end
-      end
 
-      # generates a scan to index hash that points from scan number to the
-      # spectrum index number.  returns the index, nil if the scan ids
-      # are not present and spectra are, or false if they are not unique.
-      def create_scan_to_index
-        scan_re = /scan=(\d+)/
-          scan_to_index = {}
-        ids.each_with_index do |id, index|
-          md = id.match(scan_re)
-          scan_num = md[1].to_i if md
-          if scan_num
-            if scan_to_index.key?(scan_num)
-              return false
-            else
-              scan_to_index[scan_num] = index
+        # Reads through and captures start bytes
+        # @return [Mspire::Mzml::IndexList] 
+        def create_index_list(io)
+          indices_hash = io.bookmark(true) do |inner_io|   # sets to beginning of file
+            indices = {:spectrum => {}, :chromatogram => {}}
+            byte_total = 0
+            io.each do |line|
+              if md=%r{<(spectrum|chromatogram).*?id=['"](.*?)['"][ >]}.match(line)
+                indices[md[1].to_sym][md[2]] = byte_total + md.pre_match.bytesize
+              end
+              byte_total += line.bytesize
             end
+            indices
           end
+
+          indices = indices_hash.map do |sym, hash|
+            indices = Index.new ; ids = []
+            hash.each {|id, startbyte| ids << id ; indices << startbyte }
+            indices.ids = ids ; indices.name = sym
+            indices
+          end
+          # we only return an index if there were some guys there
+          indices.delete_if {|ind| ind.size == 0 }
+          IndexList.new(indices)
         end
-        if scan_to_index.size > 0
-          by_scans = scan_to_index
-        elsif ids.size > 0
-          nil  # there are scans, but we did not find scan numbers
-        else
-          scan_to_index
-        end
+
       end
     end
   end
-end
 
+end