mspire 0.6.7 → 0.6.9

data/Rakefile

@@ -51,3 +51,8 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+# need to write updaters to get latest obo
+#task 'update-obo' do
+#  "http://psidev.cvs.sourceforge.net/*checkout*/psidev/psi/psi-ms/mzML/controlledVocabulary/psi-ms.obo"
+#end

data/VERSION

@@ -1 +1 @@
-0.6.7
+0.6.9

data/lib/cv/param.rb

@@ -1,24 +1,44 @@
+=begin
+# if you want to use Nokogiri as the builder, you need something like this
+# code:
+class XML::Nokogiri::Builder
+  def tag!(name, *data)
+    send(name, *data)
+  end
+end
+=end
+
 
 module CV
+  # the xml writer is written with the assumption that the object is a
+  # Builder::XmlMarkup object.  You can get away with using Nokogiri
   class Param
+
     attr_accessor :cv_ref, :accession, :name, :value
+
     # A valueless CV::Param object that describes the units being used
     attr_accessor :unit
 
-    def initialize(cv_ref, accession, name, value=nil)
-      (@cv_ref, @accession, @name, @value) = [cv_ref, accession, name, value]
+    def initialize(cv_ref, accession, name, value=nil, unit=nil)
+      @cv_ref, @accession, @name, @value, @unit = cv_ref, accession, name, value, unit
     end
 
-    # for now, assumes this is a Nokogiri::XML::Builder object
+    # for now, assumes this is a Builder::XmlMarkup object.  
+    # returns the xml builder object
     def to_xml(xml, name=:cvParam)
-      hash_to_send = {:cvRef => @cvref, :accession => @accession, :name => @name}
+      hash_to_send = {:cvRef => @cv_ref, :accession => @accession, :name => @name}
       hash_to_send[:value] = @value if @value
       if unit
         hash_to_send.merge!( { :unitCvRef => unit.cv_ref, 
                             :unitAccession => unit.accession,
                             :unitName => unit.name } )
       end
-      xml.send(name, hash_to_send)
+
+      # xml.send for builder results in tags with 'send' in the front
+      xml.tag!(name, hash_to_send)
+      # for nokogiri builder
+      #xml.send(name, hash_to_send)
+      xml
     end
 
     def ==(other)

data/lib/cv/referenceable_param_group_ref.rb

@@ -0,0 +1,13 @@
+
+module CV
+  class ReferenceableParamGroupRef
+    def initialize(ref)
+      @ref = ref
+    end
+
+    def to_xml(builder)
+      builder.referenceableParamGroupRef(ref: @ref)
+      builder
+    end
+  end
+end

data/lib/cv.rb

@@ -1,3 +1,5 @@
 
-require 'cv/description'
+module CV
+end
+
 require 'cv/param'

data/lib/ms/cv/param.rb

@@ -1,37 +1,32 @@
-
+require 'cv/param'
 require 'ms/cv'
 
 module MS
   module CV
 
-    # a mass spec related CVParam.  It initializes with a variety of obo
-    # accession numbers or objects to make writing CV's as easy as possible.
+    # a mass spec related CVParam.  
     class Param < ::CV::Param
 
-      # takes a variety of arguments (acc = accession):
+      # Takes one of these invocations:
       #
-      #     acc#
-      #     acc#, value
-      #     acc#, unit_acc# or CV::Param object
-      #     acc#, value, unit_acc# or CV::Param object
-      #     cvref, acc#, name
-      #     cvref, acc#, name, value
-      #     cvref, acc#, name, unit_acc# or CV::Param object
-      #     cvref, acc#, name, value, unit_acc# or CV::Param object
-      def initialize(*args)
-        @unit = 
-          if args.size > 1 && ((args.last.is_a?(::CV::Param) || args.last =~ /[A-Za-z]+:\d+/))
-            unit_arg = args.pop
-            unit_arg.is_a?(::CV::Param) ? unit_arg : self.class.new(unit_arg)
-          end
-        (@cv_ref, @accession, @name, @value) = 
+      #     acc_num[, unit_acc_num]
+      #     acc_num, value[, unit_acc_num]
+      #
+      # Where acc_num and unit_acc_num are strings containing valid accession
+      # numbers (e.g., 'MS:1000514' or 'UO:0000108')
+      def self.[](*args)
+        #puts "param args #{args.inspect}"
+        unit = 
           case args.size
-          when 1..2  # accession number (maybe with value)
-            (obo_type, accnum) = args.first.split(':')
-            [obo_type, args.first, MS::CV::Obo[obo_type][args.first], args[1]]
-          when 3..4  # they have fully specified the object
-            args
+          when 1
+            nil
+          when 2
+            MS::CV::Param[args.pop] if args.last.to_s[0,3] == 'UO:'
+          when 3
+            MS::CV::Param[args.pop]
           end
+        obo_type = args[0][/([A-Za-z]+):/,1]
+        self.new(obo_type, args[0], MS::CV::Obo[obo_type][args.first], args[1], unit)
       end
     end
   end

data/lib/ms/cv/paramable.rb

@@ -0,0 +1,42 @@
+require 'ms/cv/param'
+
+module MS
+  module CV
+    module Paramable
+
+      attr_accessor :params
+
+      def initialize(opts={params: []})
+        describe!(*opts[:params])
+      end
+
+      # casts each string or array as a Param object (using MS::CV::Param[]),
+      # pushes it onto the params attribute and returns the growing params object
+      def describe!(*args)
+        @params ||= []
+        as_params = args.map do |arg|
+          if arg.is_a?(Array)
+            MS::CV::Param[ *arg ]
+          elsif arg.is_a?(String)
+            MS::CV::Param[ arg ]
+          else
+            arg
+          end
+        end
+        @params.push(*as_params)
+      end
+
+      # if params respond_to?(:to_xml) then will call that, otherwise
+      # iterates over @params and calls .to_xml on each object.
+      def to_xml(xml)
+        if @params
+          @params.each do |el|
+            el.to_xml(xml)
+          end
+        end
+        xml
+      end
+
+    end
+  end
+end

data/lib/ms/mzml/activation.rb

@@ -0,0 +1,33 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+
+    # MAY supply a *child* term of MS:1000510 (precursor activation attribute) one or more times
+    #
+    #     e.g.: MS:1000045 (collision energy)
+    #     e.g.: MS:1000138 (percent collision energy)
+    #     e.g.: MS:1000245 (charge stripping)
+    #     e.g.: MS:1000412 (buffer gas)
+    #     e.g.: MS:1000419 (collision gas)
+    #     e.g.: MS:1000509 (activation energy)
+    #     e.g.: MS:1000869 (collision gas pressure)
+    #
+    # MUST supply term MS:1000044 (dissociation method) or any of its children one or more times
+    #
+    #     e.g.: MS:1000133 (collision-induced dissociation)
+    #     e.g.: MS:1000134 (plasma desorption)
+    #     e.g.: MS:1000135 (post-source decay)
+    #     e.g.: MS:1000136 (surface-induced dissociation)
+    #     e.g.: MS:1000242 (blackbody infrared radiative dissociation)
+    #     e.g.: MS:1000250 (electron capture dissociation)
+    #     e.g.: MS:1000262 (infrared multiphoton dissociation)
+    #     e.g.: MS:1000282 (sustained off-resonance irradiation)
+    #     e.g.: MS:1000422 (high-energy collision-induced dissociation)
+    #     e.g.: MS:1000433 (low-energy collision-induced dissociation)
+    #     et al.
+    class Activation
+      include MS::CV::Paramable
+    end
+  end
+end

data/lib/ms/mzml/chromatogram.rb

@@ -0,0 +1,29 @@
+require 'ms/mzml/data_array_container_like'
+
+module MS
+  class Mzml
+    class Chromatogram
+      include MS::Mzml::DataArrayContainerLike
+
+      # (optional) precursor isolations to the chromatogram currently being
+      # described
+      attr_accessor :precursor
+
+      # (optional) Description of product isolation to the chromatogram
+      attr_accessor :product
+
+      def initialize(*args, &block)
+        super(*args)
+        block.call(self) if block
+      end
+
+      # see SpectrumList for generating the entire list
+      def to_xml(builder, opts={})
+        super(builder) do |node|
+          @precursor.to_xml(node) if @precursor
+          @product.to_xml(node) if @product
+        end
+      end
+    end
+  end
+end

data/lib/ms/mzml/chromatogram_list.rb

@@ -0,0 +1,26 @@
+
+
+module MS
+  class Mzml
+    class ChromatogramList < Array
+
+      # a DataProcessing object
+      attr_reader :default_data_processing
+
+      def initialize(default_data_processing, chromatograms=[])
+        @default_data_processing = default_data_processing
+        super(chromatograms)
+      end
+
+      def to_xml(builder)
+        builder.chromatogramList(count: self.size, defaultDataProcessingRef: @default_data_processing.id) do |chrl_n|
+          self.each do |chromatogram|
+            chromatogram.to_xml(chrl_n)
+          end
+        end
+        builder
+      end
+
+    end
+  end
+end

data/lib/ms/mzml/component.rb

@@ -0,0 +1,21 @@
+require 'ms/cv/paramable'
+require 'ms/mzml/list'
+
+module MS
+  class Mzml
+    module Component
+      include MS::CV::Paramable
+
+      attr_accessor :order
+
+      def to_xml(builder)
+        builder.component(order: @order) do |c_n|
+          super(c_n)
+        end
+        builder
+      end
+
+      extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/contact.rb

@@ -0,0 +1,23 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    class Contact
+
+      COMMON_PARAMS = {
+        name: 'MS:1000586',
+        organization: 'MS:1000590',
+        address: 'MS:1000587',
+        email: 'MS:1000589'
+      }
+
+      include MS::CV::Paramable
+
+      def to_xml(builder)
+        builder.contact do |fc_n|
+          super(fc_n)
+        end
+      end
+    end
+  end
+end

data/lib/ms/mzml/cv.rb

@@ -0,0 +1,46 @@
+
+module MS
+  class Mzml
+    class CV
+
+      # (required) The short label to be used as a reference tag with which to refer to
+      # this particular Controlled Vocabulary source description (e.g., from
+      # the cvLabel attribute, in CVParamType elements).
+      attr_accessor :id
+      # (required) The usual name for the resource (e.g. The PSI-MS Controlled Vocabulary).
+      attr_accessor :full_name
+      # (required) The URI for the resource.
+      attr_accessor :uri
+      # (optional) The version of the CV from which the referred-to terms are drawn.
+      attr_accessor :version
+
+      def initialize(id, full_name, uri, version=nil)
+        @id, @full_name, @uri, @version = id, full_name, uri, version
+      end
+
+      def to_xml(builder)
+        atts = {id: @id, fullName: @full_name, :URI => @uri}
+        atts[:version] = @version if @version
+        builder.cv( atts )
+        builder
+      end
+
+      def self.list_xml(objs, builder)
+        builder.cvList(count: objs.size) do |cvl_n|
+          objs.each {|obj| obj.to_xml(cvl_n) }
+        end
+        builder
+      end
+
+      # These are derived by looking in the obo folder at the top of mspire
+      IMS = self.new("IMS",  "Imaging MS Ontology", "http://www.maldi-msi.org/download/imzml/imagingMS.obo", "0.9.1")
+      MS = self.new('MS', "Proteomics Standards Initiative Mass Spectrometry Ontology", "http://psidev.cvs.sourceforge.net/*checkout*/psidev/psi/psi-ms/mzML/controlledVocabulary/psi-ms.obo", "3.18.0")
+      # the version for UO doesn't really exist: seen files where they use the
+      # download date: DD:MM:YYY
+      UO = self.new("UO", "Unit Ontology", "http://obo.cvs.sourceforge.net/*checkout*/obo/obo/ontology/phenotype/unit.obo", "16:02:2012")
+
+      DEFAULT_CVS = [MS, UO, IMS]
+
+    end
+  end
+end

data/lib/ms/mzml/data_array.rb

@@ -0,0 +1,65 @@
+require 'base64'
+require 'zlib'
+
+module MS
+  class Mzml
+    class DataArray < Array
+
+      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
+      }
+
+      # the type of data array (:mz or :intensity)
+      attr_accessor :type
+
+      # requires a type, :mz or :intensity
+      def initialize(_type, ar=[])
+        @type = _type
+        super(ar)
+      end
+
+      def self.to_mzml_string(array_ish, dtype=DEFAULT_DTYPE, compression=DEFAULT_COMPRESSION)
+        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
+
+      def to_xml(builder, dtype=DEFAULT_DTYPE, compression=DEFAULT_COMPRESSION)
+        base64 = self.class.to_mzml_string(self, dtype, compression)
+        builder.binaryDataArray(encodedLength: base64.bytesize) do |bda_n|
+          MS::CV::Param[ DTYPE_TO_ACC[dtype] ].to_xml(bda_n)
+          MS::CV::Param[ compression ? 'MS:1000574' : 'MS:1000576' ].to_xml(bda_n)
+          MS::CV::Param[ (@type == :mz) ? 'MS:1000514' : 'MS:1000515' ].to_xml(bda_n) # must be m/z or intensity 
+          bda_n.binary(base64)
+        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 = data_ar.is_a?(MS::Mzml::DataArray) ? data_ar : MS::Mzml::DataArray.new(typ, data_ar)
+            ar.type = typ unless ar.type
+            ar.to_xml(bdal_n)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ms/mzml/data_array_container_like.rb

@@ -0,0 +1,57 @@
+require 'ms/cv/paramable'
+require 'ms/mzml/data_array'
+
+module MS
+  class Mzml
+    module DataArrayContainerLike
+      include MS::CV::Paramable
+
+      ###########################################
+      # ATTRIBUTES
+      ###########################################
+
+      # (required) the spectrum id matching this general pattern: \S+=\S+( \S+=\S+)*)
+      attr_accessor :id
+
+      # (required [at xml write time]) the index in the spectrum list
+      attr_accessor :index
+
+      # (optional) an MS::Mzml::DataProcessing object
+      attr_accessor :data_processing
+
+      ###########################################
+      # SUBELEMENTS
+      ###########################################
+
+      # (optional) an array of MS::Mzml::DataArray
+      attr_accessor :data_arrays
+
+      def initialize(id, opts={params: []})
+        @id = id
+        describe!(*opts[:params])
+      end
+
+      def default_array_length
+        @data_arrays ? @data_arrays.first.size : 0
+      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)
+        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
+          MS::Mzml::DataArray.list_xml(@data_arrays, sp_n) if @data_arrays
+        end
+        builder
+      end
+
+    end
+  end
+end

data/lib/ms/mzml/data_processing.rb

@@ -0,0 +1,27 @@
+require 'ms/mzml/list'
+
+module MS
+  class Mzml
+    class DataProcessing
+
+      attr_accessor :id, :processing_methods
+
+      # yields self if given a block
+      def initialize(id, processing_methods=[], &block)
+        @id, @processing_methods = id, processing_methods
+        block.call(self) if block
+      end
+
+      def to_xml(builder)
+        builder.dataProcessing( id: @id ) do |dp_n|
+          processing_methods.each do |proc_method|
+            proc_method.to_xml(dp_n)
+          end
+        end
+        builder
+      end
+
+      extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/file_content.rb

@@ -0,0 +1,21 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+    # This summarizes the different types of spectra that can be expected in
+    # the file. This is expected to aid processing software in skipping files
+    # that do not contain appropriate spectrum types for it. It should also
+    # describe the nativeID format used in the file by referring to an
+    # appropriate CV term.
+    class FileContent
+      include MS::CV::Paramable
+
+      def to_xml(builder, &block)
+        builder.fileContent do |fc_n|
+          super(fc_n, &block)
+        end
+        builder
+      end
+    end
+  end
+end

data/lib/ms/mzml/file_description.rb

@@ -0,0 +1,47 @@
+require 'ms/mzml/file_content'
+require 'ms/mzml/source_file'
+require 'ms/mzml/contact'
+
+module MS
+  class Mzml
+    class FileDescription
+
+      # a summary of the different types of spectra, must be present
+      attr_accessor :file_content
+
+      # may or may not be present
+      attr_accessor :source_files
+
+      # zero to many (just listed in the singular, not enclosed in a list)
+      #
+      #     <contact>
+      #     </contact>
+      #     <contact>
+      #     </contact>
+      attr_accessor :contacts
+
+      # hands the user the object if given a block
+      def initialize(file_content=nil, source_files=[], contacts=[], &block)
+        @file_content, @source_files, @contacts = file_content, source_files, contacts
+        block.call(self) if block
+        raise ArgumentError, "FileDescription must have file_content" unless @file_content
+      end
+
+      def to_xml(builder)
+        builder.fileDescription do |fd_n|
+          @file_content.to_xml(fd_n)
+          if source_files.size > 0
+            fd_n.sourceFileList(count: source_files.size) do |sf_n|
+              source_files.each do |sf|
+                sf.to_xml(sf_n)
+              end
+            end
+          end
+          contacts.each do |contact|
+            contact.to_xml(fd_n)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ms/mzml/instrument_configuration.rb

@@ -0,0 +1,37 @@
+require 'ms/cv/paramable'
+require 'ms/mzml/component'
+require 'ms/mzml/list'
+
+module MS
+  class Mzml
+    class InstrumentConfiguration
+      include MS::CV::Paramable
+
+      # (required) the id that this guy can be referenced from
+      attr_accessor :id
+
+      # a list of Source, Analyzer, Detector objects
+      attr_accessor :components
+
+      # a single software object associated with the instrument
+      attr_accessor :software
+
+      def initialize(id, components=[], opts={params: []})
+        describe!(*opts[:params])
+        @id = id
+        @components = components
+      end
+
+      def to_xml(builder)
+        builder.instrumentConfiguration(id: @id) do |inst_conf_n|
+          super(builder)
+          MS::Mzml::Component.list_xml(components, inst_conf_n)
+          inst_conf_n.softwareRef(ref: @software.id) if @software
+        end
+        builder
+      end
+
+      self.extend(MS::Mzml::List)
+    end
+  end
+end

data/lib/ms/mzml/isolation_window.rb

@@ -0,0 +1,21 @@
+require 'ms/cv/paramable'
+
+module MS
+  class Mzml
+
+    # MUST supply a *child* term of MS:1000792 (isolation window attribute) one or more times
+    #
+    #     e.g.: MS:1000827 (isolation window target m/z)
+    #     e.g.: MS:1000828 (isolation window lower offset)
+    #     e.g.: MS:1000829 (isolation window upper offset)
+    #
+    # MUST supply a *child* term of MS:1000792 (isolation window attribute) one or more times
+    #
+    #     e.g.: MS:1000827 (isolation window target m/z)
+    #     e.g.: MS:1000828 (isolation window lower offset)
+    #     e.g.: MS:1000829 (isolation window upper offset)
+    class IsolationWindow
+      include MS::CV::Paramable
+    end
+  end
+end

data/lib/ms/mzml/list.rb

@@ -0,0 +1,23 @@
+
+module MS
+  class Mzml
+    # Methods for simple List objects (scanList, instrumentConfigurationList,
+    # etc.)
+    module List
+      def list_xml_element
+        return @list_xml_element if @list_xml_element
+        @list_xml_element = self.to_s.split('::').last << "List"
+        @list_xml_element[0] = @list_xml_element[0].downcase
+        @list_xml_element
+      end
+
+      def list_xml(objects, builder, tagname=nil)
+        # InstrumentConfiguration -> instrumentConfigurationList
+        builder.tag!(tagname || list_xml_element, count: objects.size) do |n|
+          objects.each {|obj| obj.to_xml(n) }
+        end
+        builder
+      end
+    end
+  end
+end