mspire 0.7.18 → 0.8.0

data/VERSION

@@ -1 +1 @@
-0.7.18
+0.8.0

data/bin/mspire

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'mspire/commandline'
+
+Mspire::Commandline.run(ARGV)

data/lib/core_ext/enumerable.rb

@@ -0,0 +1,8 @@
+
+module Enumerable
+  # File activesupport/lib/active_support/core_ext/enumerable.rb, line 94
+  def index_by
+    return to_enum :index_by unless block_given?
+    Hash[map { |elem| [yield(elem), elem] }]
+  end
+end

data/lib/mspire/commandline.rb

@@ -0,0 +1,39 @@
+require 'trollop'
+require 'mspire/imzml/writer/commandline'
+
+module Mspire
+  module Commandline
+    SUB_COMMANDS = {
+      to_imzml: 'convert mzml to imzml',
+    }
+
+    def self.run(argv)
+
+      parser = Trollop::Parser.new do
+        banner "usage: mspire <subcommand> [OPTIONS]"
+        text ""
+        text "subcommands: "
+        SUB_COMMANDS.each do |k,v|
+          text "  #{k}  #{v}"
+        end
+        text ""
+        stop_on SUB_COMMANDS.keys.map(&:to_s)
+      end
+
+      begin 
+        global_opts = parser.parse(argv)
+      rescue Trollop::HelpNeeded
+        parser.educate && exit 
+      end
+
+      parser.educate && exit unless argv.size > 0
+
+      cmd = argv.shift
+      cmd_parser = 
+        case cmd.to_sym
+        when :to_imzml
+          Mspire::Imzml::Writer::Commandline.run(argv, global_opts)
+        end
+    end
+  end
+end

data/lib/mspire/cv/paramable.rb

@@ -16,6 +16,14 @@ module Mspire
         cv_params + ref_param_groups.flat_map(&:params) + user_params 
       end
 
+      def each_param(&block)
+        return enum_for __method__ unless block
+        cv_params.each(&block)
+        ref_param_groups.flat_map(&:params).each(&block)
+        user_params.each(&block)
+        nil
+      end
+
       def params?
         total_num_params = cv_params.size + 
           ref_param_groups.reduce(0) {|sum,group| sum + 
@@ -23,6 +31,13 @@ module Mspire
         total_num_params > 0
       end
 
+      def each_accessionable_param(&block)
+        return enum_for __method__ unless block
+        cv_params.each(&block)
+        ref_param_groups.flat_map(&:params).each(&block)
+        nil
+      end
+
       def accessionable_params
         cv_params + ref_param_groups.flat_map(&:params)
       end
@@ -38,7 +53,7 @@ module Mspire
       # returns the value if the param exists by that name.  Returns true if
       # the param exists but has no value. returns false if no param
       def fetch(name)
-        param = params.find {|param| param.name == name}
+        param = each_param.find {|param| param.name == name}
         if param
           param.value || true
         else
@@ -60,19 +75,20 @@ module Mspire
         params.any? {|param| param.name == name }
       end
 
-      def initialize(opts={params: []})
+      def initialize
         @cv_params = []
         @user_params = []
         @ref_param_groups = []
-        describe_many!(opts[:params])
       end
+      alias_method :params_init, :initialize
 
       def param_by_accession(acc)
-        accessionable_params.find {|v| v.accession == acc }
+        each_accessionable_param.find {|v| v.accession == acc }
       end
       alias_method :param_by_acc, :param_by_accession
 
       # takes an array of values, each of which is fed into describe!
+      # returns self.
       def describe_many!(array)
         array.each do |arg|
           if arg.is_a?(Array)
@@ -81,10 +97,51 @@ module Mspire
             describe!(arg)
           end
         end
+        self
+      end
+
+      # reads the paramable nodes and returns self.  Use this if your element
+      # does not have anything besides paramable elements.
+      def describe_self_from_xml!(xml_node, ref_hash=nil)
+        describe_from_xml!(xml_node, ref_hash)
+        self
+      end
+
+      # takes a node with children that are cvParam, userParam or
+      # referenceableParamGroupRef and a hash containing
+      # referenceableParamGroup objects indexed by id.  The only time ref_hash
+      # should be left nil is for the referenceableParamGroup itself.
+      #
+      # All param elements are required to appear before other elements, so
+      # the code walks through each child node to see if it is a paramable
+      # element.  The first child node that is not paramable is returned (or
+      # nil if none)
+      #
+      # returns the next child node after the paramable elements or nil if none
+      def describe_from_xml!(xml_node, ref_hash=nil)
+        return nil unless (child_n = xml_node.child) 
+        loop do
+          array = 
+            case child_n.name
+            when 'referenceableParamGroupRef'
+              @ref_param_groups << ref_hash[child_n[:ref]]
+            when 'cvParam'
+              @cv_params << Mspire::CV::Param[ child_n[:accession], child_n[:value] ]
+            when 'userParam'
+              @user_params << Mspire::UserParam.new(child_n[:name], child_n[:value], child_n[:type])
+            else # assumes that the above precede any following children as per the spec
+              break 
+            end
+          if (unit_acc = child_n[:unitAccession])
+            array.last.unit = ::CV::Param.new(child_n[:unitCvRef], unit_acc, child_n[:unitName])
+          end
+          break unless child_n = child_n.next
+        end
+        child_n
       end
 
-      # Expects arguments describing a single CV::Param or Mapire::UserParam.
-      # Will also accept an Nokogiri::XML::Node or Nokogiri::XML::NodeSet
+      # Expects arguments describing a single CV::Param, Mspire::UserParam, or
+      # Mspire::Mzml::ReferenceableParamGroup
       #
       #     obj.describe! 'MS:1000130'  # a positive scan
       #     obj.describe! CV::Param['MS:1000130']  # same behavior
@@ -92,12 +149,6 @@ module Mspire
       #     # base peak intensity, units=number of counts
       #     obj.describe! "MS:1000505", 1524.5865478515625, 'MS:1000131'
       #
-      #     # given an XML::NodeSet
-      #     obj.describe! xml_node.xpath('.//cvParam')
-      #
-      #     # given an XML
-      #     obj.describe! xml_node.xpath('.//cvParam').first
-      #
       # returns self
       def describe!(*args)
         return self if args.first.nil?
@@ -106,40 +157,26 @@ module Mspire
           @cv_params << Mspire::CV::Param[ *args ]
         when Mspire::Mzml::ReferenceableParamGroup
           @ref_param_groups << arg
-        when Nokogiri::XML::Node  # a nokogiri node in particular
-          param = 
-            case arg.name
-            when 'cvParam'
-              Mspire::CV::Param[ arg[:accession], arg[:value] ]
-            when 'userParam'
-              Mspire::UserParam.new(arg[:name], arg[:value], arg[:type])
-            end
-          if (unit_acc = arg[:unitAccession])
-            param.unit = ::CV::Param.new(arg[:unitCvRef], unit_acc, arg[:unitName])
-          end
-          @cv_params << param
-        when Nokogiri::XML::NodeSet
-          arg.each {|node| describe!(node) }
         else
           if arg.is_a?(Mspire::UserParam)
             @user_params << arg
           else
-            (@cv_params << arg) if arg
+            @cv_params << arg
           end
         end
         self
       end
 
-        # iterates over @params and calls .to_xml on each object.
-        def to_xml(xml)
-          [:ref_param_groups, :cv_params, :user_params].each do |kind|
-            self.send(kind).each do |obj|
-              obj.to_xml(xml)
-            end
+      # iterates over @params and calls .to_xml on each object.
+      def to_xml(xml)
+        [:ref_param_groups, :cv_params, :user_params].each do |kind|
+          self.send(kind).each do |obj|
+            obj.to_xml(xml)
           end
-          xml
         end
-
+        xml
       end
+
     end
   end
+end

data/lib/mspire/imzml/writer/commandline.rb

@@ -13,7 +13,9 @@ end
 
 module Mspire::Imzml::Writer::Commandline
 
-  def self.run(argv, progname=$0)
+  # generates the Trollop parser
+  def self.parser
+    return @parser if @parser
 
     default_config = "config.yaml"
     scan_patterns = %w(flyback meandering random)
@@ -24,9 +26,9 @@ module Mspire::Imzml::Writer::Commandline
     default_pixel_size = '1x1'
     matrix_application_types = %w(sprayed precoated printed drieddroplet)
 
-    parser = Trollop::Parser.new do
+    @parser = Trollop::Parser.new do
       banner <<-EOS
-usage: #{File.basename(progname)} [OPTIONS] <file>.mzML ..."
+usage: mspire to_imzml [OPTIONS] <file>.mzML ..."
 output: <file>.imzML and <file>.ibd
 
 * imzML docs: 
@@ -43,6 +45,9 @@ output: <file>.imzML and <file>.ibd
       opt :combine, "combine all files and set the base name of resulting imzML and ibd files", :type => String
       opt :outfile, "use a specific basename for the resulting file. Acts like --combine for multiple files", :type => String
 
+      text "\nediting:"
+      opt :trim_files, "determines the least number of spectra in a file and shortens all spectra to be the same length"
+
       text "\nimaging:"
       opt :continuous, "assumes m/z values are the same for every scan. The 'processed' storage format is used unless this flag is given."
       opt :scan_pattern, scan_patterns.join('|'), :default => scan_patterns.first
@@ -76,8 +81,15 @@ output: <file>.imzML and <file>.ibd
       # filters (cutoff / max # peaks, etc.)
       # ms_level, etc.
     end
+  end
+
+  def self.run(argv, globalopts)
+    begin
+      opts = parser.parse(argv)
+    rescue Trollop::HelpNeeded
+      return parser.educate
+    end
 
-    opts = parser.parse(argv)
     opts = Hash[YAML.load_file(opts[:config]).map {|k,v| [k.to_sym, v]}].merge(opts) if opts[:config]
 
     opts[:combine] ||= opts.delete(:outfile)
@@ -104,6 +116,3 @@ output: <file>.imzML and <file>.ibd
 
   end
 end
-
-
-

data/lib/mspire/imzml/writer.rb

@@ -215,13 +215,13 @@ module Mspire::Imzml
     def create_file_description(source_files, config)
       Mspire::Mzml::FileDescription.new  do |fd|
 
-        fd.file_content = Mspire::Mzml::FileContent.new :params => [
+        fd.file_content = Mspire::Mzml::FileContent.new.describe_many!( [
           'MS:1000579', # MS1 Spectrum
           config[:profile] ? 'MS:1000128' : 'MS:1000127',
           ['IMS:1000080', "{"+config[:uuid_hyphenated]+"}"],
           ['IMS:1000091', config[:ibd_sha1]],
           (config[:data_structure] == :processed) ? 'IMS:1000031' : 'IMS:1000030',
-        ]
+        ] )
 
         fd.source_files.replace(source_files)
         if [:name, :organization, :address, :email].any? {|key| config[key] }
@@ -267,9 +267,9 @@ module Mspire::Imzml
         "MS:1000127",  # centroid spectrum
         "MS:1000130" # <- positive scan
       ]}.map do |id, list|
-        Mspire::Mzml::ReferenceableParamGroup.new id, params: list
+        Mspire::Mzml::ReferenceableParamGroup.new(id).describe_many!(list)
       end
-      Hash[ rparms.map {|parm| [parm.id, parm]} ]
+      Hash[ rparms.map {|prm_group_obj| [prm_group_obj.id, prm_group_obj]} ]
     end
 
     # mzml_filenames can each be a partial or relative path
@@ -286,6 +286,9 @@ module Mspire::Imzml
     #       :solvent_flowrate => flowrate of the solvent (ml/min)
     #       :spray_voltage => spray voltage in kV
     #       :target_material => the material the target is made of
+    #     editing:
+    #       :trim_files => determines min # spectra in file and lops
+    #                      off the ends of other files.
     #     general:
     #       :omit_zeros => remove zero values
     #       :combine => use this outfile base name to combine files
@@ -311,6 +314,10 @@ module Mspire::Imzml
       config[:uuid_hyphenated] = uuid_with_hyphens
       config[:uuid] = uuid_with_hyphens.gsub('-','')
 
+      if config[:trim_files]
+        config[:trim_to] = mzml_filenames.map {|fn| Mspire::Mzml.open(fn, &:size) }.min
+      end
+
       sourcefile_id_parallel_to_spectra = []
       sourcefile_ids = []
       all_spectra_iter = Enumerator.new do |yielder|
@@ -318,7 +325,8 @@ module Mspire::Imzml
           sourcefile_id = "source_file_#{i}"
           sourcefile_ids << sourcefile_id
           Mspire::Mzml.open(mzml_filename) do |mzml|
-            mzml.each do |spec| 
+            mzml.each_with_index do |spec,i| 
+              break if config[:trim_to] && (i >= config[:trim_to])
               sourcefile_id_parallel_to_spectra << sourcefile_id 
               yielder << spec
             end
@@ -359,12 +367,12 @@ module Mspire::Imzml
 
         imzml.referenceable_param_groups = rparms_by_id.values
         # skip sample list for now
-        mspire_software = Mspire::Mzml::Software.new( "mspire", Mspire::VERSION, params: ["MS:1000799"] )
+        mspire_software = Mspire::Mzml::Software.new("mspire", Mspire::VERSION).describe!("MS:1000799")
         imzml.software_list << mspire_software
 
         scan_setting_params = image_hash_to_cvs( config )
         scan_setting_params.push *experiment_hash_to_cvs( config )
-        imzml.scan_settings_list = [Mspire::Mzml::ScanSettings.new("scansettings1", params: scan_setting_params)]
+        imzml.scan_settings_list = [Mspire::Mzml::ScanSettings.new("scansettings1").describe_many!(scan_setting_params)]
 
         warn 'todo: need to borrow instrumentConfiguration from original mzml'
 
@@ -376,20 +384,20 @@ module Mspire::Imzml
         # this is a generic 'file format conversion' but its the closest we
         # have for mzml to imzml (which is really mzml to mzml)
         data_processing_obj = Mspire::Mzml::DataProcessing.new('mzml_to_imzml')
-        data_processing_obj.processing_methods << Mspire::Mzml::ProcessingMethod.new(1, mspire_software, params: ['MS:1000530'] )
+        data_processing_obj.processing_methods << Mspire::Mzml::ProcessingMethod.new(mspire_software).describe!('MS:1000530')
         imzml.data_processing_list << data_processing_obj
 
         warn "not implemented 'omit_zeros' yet"
         # low intensity data point removal: "MS:1000594"
         imzml.run = Mspire::Mzml::Run.new("run1", default_instrument_config) do |run|
-          spec_list = Mspire::Mzml::SpectrumList.new(data_processing_obj)
+          spectra = []
           data_info_pairs.zip(xy_positions_array, sourcefile_id_parallel_to_spectra).each_with_index do |(pair, xy, sourcefile_id),i|
             # TODO: we should probably copy the id from the orig mzml (e.g.
             # scan=1)
-            spectrum = Mspire::Mzml::Spectrum.new("spectrum#{i}", params: [rparms_by_id[:spectrum1]])
+            spectrum = Mspire::Mzml::Spectrum.new("spectrum#{i}").describe!(rparms_by_id[:spectrum1])
             spectrum.source_file = sourcefile_id_to_sourcefile[sourcefile_id]
-            scan_list = Mspire::Mzml::ScanList.new(params: ['MS:1000795'])  # no combination
-            scan = Mspire::Mzml::Scan.new( params: [rparms_by_id[:scan1], ["IMS:1000050", xy[0]], ["IMS:1000051", xy[1]]] )
+            scan_list = Mspire::Mzml::ScanList.new.describe!('MS:1000795')  # no combination
+            scan = Mspire::Mzml::Scan.new.describe_many!([rparms_by_id[:scan1], ["IMS:1000050", xy[0]], ["IMS:1000051", xy[1]]])
             scan.instrument_configuration = default_instrument_config
             spectrum.scan_list = (scan_list << scan)
             
@@ -402,9 +410,9 @@ module Mspire::Imzml
               data_array
             end
             spectrum.data_arrays = data_arrays
-            spec_list << spectrum
+            spectra << spectrum
           end
-          run.spectrum_list = spec_list
+          run.spectrum_list = Mspire::Mzml::SpectrumList.new(data_processing_obj, spectra)
         end # run
       end # imzml
       imzml_obj.to_xml(config[:imzml_filename])

data/lib/mspire/mzml/activation.rb

@@ -28,11 +28,6 @@ module Mspire
     #     et al.
     class Activation
       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/chromatogram.rb

@@ -4,6 +4,7 @@ module Mspire
   class Mzml
     class Chromatogram
       include Mspire::Mzml::DataArrayContainerLike
+      alias_method :params_initialize, :initialize
 
       # (optional) precursor isolations to the chromatogram currently being
       # described
@@ -12,16 +13,50 @@ module Mspire
       # (optional) Description of product isolation to the chromatogram
       attr_accessor :product
 
-      def initialize(*args, &block)
-        super(*args)
-        block.call(self) if block
+      def initialize(id)
+        @id = id
+        params_initialize
+        yield(self) if block_given?
+      end
+
+      def self.from_xml(xml, link)
+        obj = self.new(xml[:id])
+
+        obj.data_processing = link[:data_processing_hash][xml[:dataProcessingRef]] || link[:spectrum_default_data_processing]
+
+        xml_n = obj.describe_from_xml!(xml, link[:ref_hash])
+
+        loop do
+          case xml_n.name
+          when 'precursor'
+            obj.precursor = Mspire::Mzml::Precursor.from_xml(xml_n, link)
+          when 'product'
+            obj.product = Mspire::Mzml::Product.from_xml(xml_n, link)
+          when 'binaryDataArrayList'
+            obj.data_arrays = Mspire::Mzml::DataArray.data_arrays_from_xml(xml_n, link)
+            break
+          end
+          break unless xml_n = xml_n.next
+        end
+        obj
+      end
+
+      def times
+        data_arrays[0]
+      end
+
+      def intensities
+        data_arrays[1]
       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
+        atts = data_array_xml_atts(default_ids)
+        builder.chromatogram(atts) do |chrom_n|
+          super(chrom_n)
+          @precursor.to_xml(chrom_n) if @precursor
+          @product.to_xml(chrom_n) if @product
+          Mspire::Mzml::DataArray.list_xml(@data_arrays, chrom_n) if @data_arrays
         end
       end
     end

data/lib/mspire/mzml/chromatogram_list.rb

@@ -1,26 +1,9 @@
 
+require 'mspire/mzml/io_indexable_list'
 
 module Mspire
   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
-
+    class ChromatogramList < IOIndexableList
     end
   end
 end

data/lib/mspire/mzml/component.rb

@@ -3,19 +3,43 @@ require 'mspire/mzml/list'
 
 module Mspire
   class Mzml
+    # order is not an intrinsic property of this object, so it 
     module Component
       include Mspire::CV::Paramable
+      # using custom list_xml, so no extend Mspire::Mzml::List
 
-      attr_accessor :order
+      def initialize
+        params_init
+        yield(self) if block_given?
+      end
 
-      def to_xml(builder)
-        builder.component(order: @order) do |c_n|
+      def to_xml(builder, order)
+        builder.component(order: order) do |c_n|
           super(c_n)
         end
         builder
       end
 
-      extend(Mspire::Mzml::List)
+      def self.list_xml(components, builder)
+        builder.componentList(count: components.size) do |xml_n|
+          components.each_with_index do |component, order|
+            component.to_xml(xml_n, order)
+          end
+        end
+      end
+    end
+
+    class Source
+      include Component
     end
+
+    class Analyzer
+      include Component
+    end
+
+    class Detector
+      include Component
+    end
+
   end
 end

data/lib/mspire/mzml/cv.rb

@@ -2,6 +2,7 @@
 module Mspire
   class Mzml
     class CV
+      # note: CV is NOT paramable!
 
       # (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