mspire 0.8.1 → 0.8.2

data/VERSION

@@ -1 +1 @@
-0.8.1
+0.8.2

data/lib/mspire/cv/paramable.rb

@@ -25,10 +25,9 @@ module Mspire
       end
 
       def params?
-        total_num_params = cv_params.size + 
-          ref_param_groups.reduce(0) {|sum,group| sum + 
-            group.params.size } + user_params.size
-        total_num_params > 0
+        cv_params.size > 0 || 
+          ref_param_groups.any? {|group| group.params.size > 0 } || 
+          user_params.size > 0
       end
 
       def each_accessionable_param(&block)
@@ -42,6 +41,25 @@ module Mspire
         cv_params + ref_param_groups.flat_map(&:params)
       end
 
+      # yields each current param.  If the return value is not false or nil,
+      # it is deleted (i.e., any true value and it is deleted).  Then adds the
+      # given parameter or makes a new one by accession number.
+      def replace!(*describe_args, &block)
+        reject!(&block).describe!(*describe_args)
+      end
+
+      # returns self
+      def reject!(&block)
+        cv_params.reject!(&block)
+        ref_param_groups.each {|group| group.reject!(&block) }
+        user_params.reject!(&block)
+        self
+      end
+
+      def replace_many!(describe_many_arg, &block)
+        reject!(&block).describe_many!(describe_many_arg)
+      end
+
       #def params_by_name
       #  params.index_by &:name
       #end
@@ -61,6 +79,9 @@ module Mspire
         end
       end
 
+      # returns the value if the param exists with that accession.  Returns
+      # true if the param exists but has no value. returns false if no param
+      # with that accession.
       def fetch_by_accession(acc)
         param = accessionable_params.find {|v| v.accession == acc }
         if param

data/lib/mspire/digester.rb

@@ -219,22 +219,6 @@ module Mspire
       :trypsin => 'Trypsin 	C-Term	KR 	P 	no 	no',
       :v8_e_trypsin => 'V8-E+Trypsin 	C-Term 	EKRZ 	P 	no 	no',
       :v8_de_trypsin => 'V8-DE+Trypsin 	C-Term 	BDEKRZ 	P 	no 	no',
-      :arg_c => 'Arg-C 	C-Term 	R 	P 	 no 	 no',
-      :asp_n => 'Asp-N 	N-Term 	BD 	  	no 	no',
-      :asp_n_ambic => 'Asp-N_ambic 	N-Term 	DE 	  	no 	no',
-      :chymotrypsin => 'Chymotrypsin 	C-Term 	FLWY 	P 	no 	no',
-      :cnbr => 'CNBr 	C-Term 	M 	  	no 	no',
-      :lys_c => 'Lys-C 	C-Term 	K 	P 	no 	no',
-      :lys_c_p => 'Lys-C/P 	C-Term 	K 	  	no 	no',
-      :pepsin_a => 'PepsinA 	C-Term 	FL 	  	no 	no',
-      :tryp_cnbr => 'Tryp-CNBr 	C-Term 	KMR 	P 	no 	no',
-      :tryp_chymo => 'TrypChymo 	C-Term 	FKLRWY 	P 	no 	no',
-      :trypsin_p => 'Trypsin/P 	C-Term 	KR 	  	no 	no',
-      :v8_de => 'V8-DE 	C-Term 	BDEZ 	P 	no 	no',
-      :v8_e => 'V8-E 	C-Term 	EZ 	P 	no 	no',
-      :trypsin => 'Trypsin 	C-Term	KR 	P 	no 	no',
-      :v8_e_trypsin => 'V8-E+Trypsin 	C-Term 	EKRZ 	P 	no 	no',
-      :v8_de_trypsin => 'V8-DE+Trypsin 	C-Term 	BDEKRZ 	P 	no 	no',
     }
 
     ENZYMES = MASCOT_ENZYME_CONFIG_STRINGS.inject(Hash.new) do |hash,(k,v)| 

data/lib/mspire/imzml/writer.rb

@@ -422,8 +422,8 @@ module Mspire::Imzml
             
             data_arrays = %w(mz intensity).zip(pair).map do |type, data_array_info|
               rparmgroup = rparms_by_id[(type + "_array").to_sym]
+              # the type is defined in the refparams
               data_array = Mspire::Mzml::DataArray.new
-              data_array.type = type
               data_array.external = true
               data_array.describe_many! [rparmgroup, *%w(IMS:1000103 IMS:1000102 IMS:1000104).zip(data_array_info).map.to_a]
               data_array

data/lib/mspire/mzml/activation.rb

@@ -28,6 +28,10 @@ module Mspire
     #     et al.
     class Activation
       include Mspire::CV::Paramable
+
+      def to_xml(builder)
+        builder.activation {|xml| super(xml) }
+      end
     end
   end
 end

data/lib/mspire/mzml/chromatogram.rb

@@ -49,9 +49,13 @@ module Mspire
         data_arrays[1]
       end
 
-      # see SpectrumList for generating the entire list
-      def to_xml(builder, opts={})
-        atts = data_array_xml_atts(default_ids)
+      # see ChromatogramList for generating the entire list
+      def to_xml(builder, default_ids)
+        atts = data_array_xml_atts
+        if @data_processing && default_ids[:chromatogram_data_processing] != @data_processing.id 
+          atts[:dataProcessingRef] = @data_processing.id 
+        end
+
         builder.chromatogram(atts) do |chrom_n|
           super(chrom_n)
           @precursor.to_xml(chrom_n) if @precursor

data/lib/mspire/mzml/component.rb

@@ -14,7 +14,9 @@ module Mspire
       end
 
       def to_xml(builder, order)
-        builder.component(order: order) do |c_n|
+        klass = self.class.to_s.split('::').last
+        klass[0] = klass[0].downcase
+        builder.tag!(klass, order: order) do |c_n|
           super(c_n)
         end
         builder

data/lib/mspire/mzml/data_array.rb

@@ -8,56 +8,43 @@ module Mspire
 end
 
 
-class Mspire::Mzml::DataArray < Array
+# Mspire::Mzml::DataArray's are currently implemented as a standard Ruby
+# array.  Data may be input or output with less precision, but a standard data
+# array will be accessible from ruby as Float (float64).  Thus, the params
+# merely alter what will be output to xml, so, to alter what is written with
+# to_xml, change the params.  If no params are changed in the data array it
+# will be written with the same precision as it was read in with.
+class Mspire::Mzml::DataArray < Array 
   alias_method :array_init, :initialize
   include Mspire::CV::Paramable
 
-  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
+  DEFAULT_DTYPE_ACC = 'MS:1000523' # float64
+  DEFAULT_COMPRESSION_ACC = 'MS:1000574'
+  COMPRESSION_ACC = 'MS:1000574'
+  NO_COMPRESSION_ACC = 'MS:1000576'
+  ACC_TO_DTYPE = {
+    'MS:1000523' => :float64,
+    'MS:1000521' => :float32,
+    #'MS:1000520' => :float16,  # <- not supported w/o other gems
+    'MS:1000522' => :int64, # signed
+    'MS:1000519' => :int32, # signed
   }
-  TYPE_XML = {
-    mz: '<cvParam cvRef="MS" accession="MS:1000514" name="m/z array"/>',
-    intensity: '<cvParam cvRef="MS" accession="MS:1000515" name="intensity array"/>'
+  ACC_TO_UNPACK_CODE = {
+    'MS:1000523' => 'E*',
+    'MS:1000521' => 'e*',
+    #'MS:1000520' => :float16,  # <- not supported w/o other gems
+    'MS:1000522' => 'q<*',
+    'MS:1000519' => 'l<*',
   }
 
+  DTYPE_ACCS = ACC_TO_DTYPE.keys
+
+  # unless data type (see DTYPE_TO_ACC) or TYPE
   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
 
@@ -65,8 +52,19 @@ class Mspire::Mzml::DataArray < Array
   # file for imzML files)
   attr_accessor :external
 
-  def self.empty_data_arrays
-    [self.new, self.new]
+  # returns a DataArray object. Analogous to [] for creating an array.
+  def self.[](*data)
+    self.new(data)
+  end
+
+  # returns an array of DataArray objects based on the given arrays
+  def self.from_arrays(arrays)
+    arrays.map {|ar| self.new(ar) }
+  end
+
+    # returns an array of DataArray objects (2)
+  def self.empty_data_arrays(num=2)
+    Array.new(num) { self.new }
   end
 
   def self.data_arrays_from_xml(xml, link)
@@ -115,74 +113,66 @@ class Mspire::Mzml::DataArray < Array
     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
-          :float64
+  # creates a base64 binary string based on the objects params.  If no dtype
+  # or compression are specified, then it will be set (i.e., params added to
+  # the object).
+  def to_binary
+    # single pass over params for speed
+    pack_code = nil
+    compression = nil
+    each_accessionable_param do |param|
+      acc = param.accession
+      if !pack_code && (code=ACC_TO_UNPACK_CODE[acc])
+        pack_code = code
+      end
+      if compression.nil?
+        compression = 
+          case acc
+          when COMPRESSION_ACC then true
+          when NO_COMPRESSION_ACC then false
+          end
+      end
+    end
+    # can speed these up:
+    unless pack_code
+      describe! DEFAULT_DTYPE_ACC
+      pack_code = ACC_TO_UNPACK_CODE[DEFAULT_DTYPE_ACC]
+    end
+    if compression.nil?
+      describe! DEFAULT_COMPRESSION_ACC
+      compression = 
+        case DEFAULT_COMPRESSION_ACC
+        when COMPRESSION_ACC then true
+        when NO_COMPRESSION_ACC then false
         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) 
+    # TODO: support faster pack method with nmatrix or narray
+    string = self.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
-
-  def to_xml(builder, dtype=DEFAULT_DTYPE, compression=DEFAULT_COMPRESSION)
+  # will set the data type to DEFAULT_DTYPE and compression if n
+  def to_xml(builder)
     encoded_length = 
       if @external
         0
       else
-        base64 = self.class.to_binary(self, dtype, compression)
+        base64 = to_binary
         base64.bytesize
       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
+      bda_n.binary(base64) unless self.external
     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
+      arrays.each do |ar|
         ar.to_xml(bdal_n)
       end
     end

data/lib/mspire/mzml/data_array_container_like.rb

@@ -38,14 +38,9 @@ module Mspire
         end
       end
 
-      # 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}
-        if @data_processing && default_ids[:data_processing] != @data_processing.id 
-          atts[:dataProcessingRef] = @data_processing.id 
-        end
-        atts
+      # returns a hash with id, index, defaultArrayLength
+      def data_array_xml_atts
+        {index: @index, id: @id, defaultArrayLength: default_array_length}
       end
 
     end

data/lib/mspire/mzml/isolation_window.rb

@@ -16,6 +16,10 @@ module Mspire
     #     e.g.: MS:1000829 (isolation window upper offset)
     class IsolationWindow
       include Mspire::CV::Paramable
+
+      def to_xml(builder)
+        builder.isolationWindow {|xml| super(xml) }
+      end
     end
   end
 end

data/lib/mspire/mzml/precursor.rb

@@ -7,6 +7,7 @@ module Mspire
   class Mzml
     # The method of precursor ion selection and activation
     class Precursor
+      extend Mspire::Mzml::List
 
       # (optional) the id of the Spectrum object, whether internal or
       # externally derived.
@@ -77,7 +78,6 @@ module Mspire
         end
       end
 
-      extend(Mspire::Mzml::List)
 
     end
   end

data/lib/mspire/mzml/reader.rb

@@ -83,6 +83,9 @@ module Mspire::Mzml::Reader
     if mzml_n.name == 'indexedmzML'
       mzml_n = mzml_n.child
     end
+
+    @id = mzml_n[:id]
+
     cv_list_n = mzml_n.child
     self.cvs = cv_list_n.children.map do |cv_n|
       Mspire::Mzml::CV.from_xml(cv_n)

data/lib/mspire/mzml/scan_window.rb

@@ -8,6 +8,13 @@ module Mspire
     #     accession="MS:1000500" name="scan window upper limit" value="1800"
     class ScanWindow
       include Mspire::CV::Paramable
+      extend Mspire::Mzml::List
+
+      def to_xml(builder)
+        builder.scanWindow do |xml|
+          super(xml)
+        end
+      end
     end
   end
 end

data/lib/mspire/mzml/selected_ion.rb

@@ -12,6 +12,10 @@ module Mspire
     class SelectedIon
       include Mspire::CV::Paramable
       extend Mspire::Mzml::List
+
+      def to_xml(builder)
+        builder.selectedIon {|xml| super(xml) }
+      end
     end
   end
 end

data/lib/mspire/mzml/spectrum.rb

@@ -155,8 +155,6 @@ module Mspire
           obj.data_arrays = Mspire::Mzml::DataArray.empty_data_arrays
         end
 
-
-
         obj
       end
 
@@ -172,9 +170,25 @@ module Mspire
         yield(self) if block_given?
       end
 
+      # sets the data_arrays from the given array objects.  Sets the type of
+      # the first array to be an m/z array, and the second to be an intensity
+      # array.
+      def self.from_arrays(id, arrays)
+        spec = self.new(id)
+        arrays.zip(['MS:1000514','MS:1000515']).each do |ar, acc|
+          dar = DataArray.new(ar).describe!(acc)
+        end
+        spec
+      end
+
       # see SpectrumList for generating the entire list
       def to_xml(builder, default_ids)
-        atts = data_array_xml_atts(default_ids)
+        io = builder.target!
+
+        atts = data_array_xml_atts
+        if @data_processing && default_ids[:spectrum_data_processing] != @data_processing.id 
+          atts[:dataProcessingRef] = @data_processing.id 
+        end
         atts[:sourceFileRef] = @source_file.id if @source_file
         atts[:spotID] = @spot_id if @spot_id
 
@@ -185,6 +199,7 @@ module Mspire
           Mspire::Mzml::Product.list_xml(@products, sp_n) if @products
           Mspire::Mzml::DataArray.list_xml(@data_arrays, sp_n) if @data_arrays
         end
+        builder
       end
 
     end

data/lib/mspire/mzml.rb

@@ -85,6 +85,7 @@ module Mspire
         :xmlns => "http://psi.hupo.org/ms/mzml",
         "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance", 
         "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema", 
+        "xsi:schemaLocation" => "http://psi.hupo.org/ms/mzml http://psidev.info/files/ms/mzML/xsd/mzML1.1.0.xsd"
       }
 
       VERSION = '1.1.0'
@@ -255,6 +256,7 @@ module Mspire
         io.string
       end
     end
+    alias_method :write, :to_xml
 
     class ScanNumbersNotUnique < Exception
     end

data/lib/mspire/user_param.rb

@@ -25,5 +25,18 @@ module Mspire
       self.name, self.value, self.type = args
     end
 
+    def to_xml(xml)
+      atts = { name: name, value: value, type: type }
+      if unit
+        atts.merge!( 
+                    { :unitCvRef => unit.cv_ref, 
+                      :unitAccession => unit.accession,
+                      :unitName => unit.name } 
+                   )
+      end
+      xml.userParam(atts)
+      xml
+    end
+
   end
 end

data/spec/mspire/imzml/writer_spec.rb

@@ -54,10 +54,10 @@ describe Mspire::Imzml::Writer do
   end
 
   it 'writes :processed binary file with spectra and returns DataArrayInfo objects' do
-    expected_file = TESTFILES + "/mspire/imzml/processed_binary_check.ibd"
-    write_to = TESTFILES + "/mspire/imzml/processed_binary.tmp.ibd"
+    write_to = TESTFILES + "/mspire/imzml/processed_binary.ibd"
     array = subject.write_binary(write_to, @spectra.each, @config.merge( {:data_structure => :processed} ))
-    IO.read(write_to).should == IO.read(expected_file)
+    file_check(write_to)
+
     array.should be_an(Array)
     length = 3
     offsets = (16..76).step(12)
@@ -71,14 +71,12 @@ describe Mspire::Imzml::Writer do
         obj.offset.should == offsets.next
       end
     end
-    File.unlink(write_to) if File.exist?(write_to)
   end
 
   it 'writes :continuous binary file with spectra and returns DataArrayInfo objects' do
-    expected_file = TESTFILES + "/mspire/imzml/continuous_binary_check.ibd"
-    write_to = TESTFILES + "/mspire/imzml/continuous_binary.tmp.ibd"
+    write_to = TESTFILES + "/mspire/imzml/continuous_binary.ibd"
     array = subject.write_binary(write_to, @spectra.each, @config.merge( {:data_structure => :continuous} ))
-    IO.read(write_to).should == IO.read(expected_file)
+    file_check(write_to)
     array.should be_an(Array)
 
     length = 3
@@ -95,7 +93,6 @@ describe Mspire::Imzml::Writer do
       info_pair.first.offset.should == first_offset
       info_pair.last.offset.should == offsets.next
     end
-    File.unlink(write_to) if File.exist?(write_to)
   end
 
   describe 'full conversion of a file' do
@@ -105,25 +102,24 @@ describe Mspire::Imzml::Writer do
     end
 
     # reads file and removes parts that change run to run
-    def sanitize(file)
+    def sanitize(string)
+      string = sanitize_mspire_version_xml(string)
       reject = ['xmlns="http://psi.hupo.org/ms/mzml', 'universally unique identifier', 'ibd SHA-1']
-      IO.readlines(file).reject do |line| 
+      string.split(/\r?\n/).reject do |line| 
         reject.any? {|fragment| line.include?(fragment) }
-      end.join
+      end.join("\n")
     end
 
     it 'converts sim files' do
-      Mspire::Imzml::Writer::Commandline.run([@file, @file, "--max-dimensions-microns", "72x2", "--max-dimensions-pixels", "72x2"])
-      # checking ibd is hard, reserved for above specs
-      imzml_check = TESTFILES + "/mspire/mzml/1_BB7_SIM_478.5.CHECK.imzML"
-      ibd_check = TESTFILES + "/mspire/mzml/1_BB7_SIM_478.5.CHECK.ibd"
+      outbase = TESTFILES + "/mspire/imzml/1_BB7_SIM_478.5"
+      Mspire::Imzml::Writer::Commandline.run([@file, @file, "--max-dimensions-microns", "72x2", "--max-dimensions-pixels", "72x2", "--outfile", outbase])
       # really just frozen for now until I inspect it more critically
-      imzml = imzml_check.sub('.CHECK','')
-      ibd = ibd_check.sub('.CHECK','')
-      File.exist?(ibd).should be_true
-      File.exist?(imzml).should be_true
-      sanitize(imzml_check).should == sanitize(imzml)
-      File.unlink(ibd) ; File.unlink(imzml)
+      file_check( TESTFILES + "/mspire/imzml/1_BB7_SIM_478.5.imzML" ) do |st|
+        sanitize(st)
+      end
+      file_check( TESTFILES + "/mspire/imzml/1_BB7_SIM_478.5.ibd" ) do |st|
+        st.each_byte.map.to_a[20..-1]
+      end
     end
   end
 

data/spec/mspire/mzml/data_array_spec.rb

@@ -35,11 +35,6 @@ describe Mspire::Mzml::DataArray do
   describe 'an instantiated Mspire::Mzml::DataArray' do
     subject { Mspire::Mzml::DataArray.new [1,2,3] }
 
-    it "can have a 'type'" do
-      subject.type = :mz
-      subject.type.should == :mz
-    end
-
     it 'can be converted to a binary string' do
       string = subject.to_binary
       # frozen