cdo 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dcb1d6e5d4eb860ecac4dff8836cf77acb2edbe4
-  data.tar.gz: f20b0fbc63fdaab0f46cda08612d1551cc6b640b
+  metadata.gz: 0405bd1a58c7c4342a4f921157849396a67d4c56
+  data.tar.gz: '09fe64c812dad7b1b63ff25abeee1d2a9de5a8cc'
 SHA512:
-  metadata.gz: d4aed663d81cbc14d38e742648a1817fcb3ee63c539a19994305a880e2b5d09d9723f195b30da93f49117b2b99441f4d28f2ff8ed96653550377bce3972757d7
-  data.tar.gz: ed6543a9bc4bfc88eb152fefab720a76192daeea1a3413e76d1929de207e1a3750de62deea3596bc85f5494a0cf0d5fc1037124ce34736d3a39fc62ee111a11b
+  metadata.gz: 45d2c037d3956bb1da49ebbc53e9be594af2d206fa85a268e20e5a03d0df3aa0deb168af00f9776c96f815222f11f71320e84366e58cdb33e3c9542e7ef79a8c
+  data.tar.gz: 528faea8e6188b8908ae7d7b4327da8d1cd130f893cd86aa8c6e6b99afd1cbf55e72597d5d50b7d5cdc195e2daf8ebab04e924d7d049d3b708c678b5a0905196

data/gemspec

@@ -3,7 +3,7 @@ $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
 spec = Gem::Specification.new do |s|
   s.name              = "cdo"
-  s.version           = '1.3.2'
+  s.version           = '1.3.3'
   s.platform          = Gem::Platform::RUBY
   s.files             = ["lib/cdo.rb","lib/cdo_lib.rb"] + ["gemspec","LICENSE"]
   s.test_file         = "test/test_cdo.rb"
@@ -15,6 +15,8 @@ spec = Gem::Specification.new do |s|
   s.license           = "GPLv2"
   s.required_ruby_version = ">= 1.9"
   s.add_development_dependency('unifiedPlot')
+  s.add_development_dependency('minitest')
+  s.add_development_dependency('rake')
 end
 
 # vim:ft=ruby

data/lib/cdo.rb

@@ -4,9 +4,10 @@ require 'logger'
 require 'stringio'
 
 class Cdo
-  OutputOperatorsPattern = /(diff|info|output|griddes|zaxisdes|show|ncode|ndate|nlevel|nmon|nvar|nyear|ntime|npar|gradsdes|pardes)/
 
-  OutputOperators = %w[cdiread cmor codetab conv_cmor_table diff diffc diffn diffp
+  # hardcoded fallback list of output operators - from 1.8.0 there is an
+  # options for this: --operators_no_output
+  NoOutputOperators = %w[cdiread cmor codetab conv_cmor_table diff diffc diffn diffp
   diffv dump_cmor_table dumpmap filedes ggstat ggstats gmtcells gmtxyz gradsdes
   griddes griddes2 gridverify info infoc infon infop infos infov map ncode
   ncode ndate ngridpoints ngrids nlevel nmon npar ntime nvar nyear output
@@ -16,7 +17,7 @@ class Cdo
   partab2 seinfo seinfoc seinfon seinfop showcode showdate showformat showlevel
   showltype showmon showname showparam showstdname showtime showtimestamp
   showunit showvar showyear sinfo sinfoc sinfon sinfop sinfov
-spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
+  spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
 
   attr_accessor :cdo, :returnCdf, :forceOutput, :env, :debug, :logging, :logFile
   attr_reader   :operators, :filetypes
@@ -34,11 +35,12 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
     # setup path to cdo executable
     @cdo = ENV.has_key?('CDO') ? ENV['CDO'] : cdo
 
-    @operators              = getOperators(binary=@cdo)
+    @operators              = getOperators(@cdo)
     @returnCdf              = returnCdf
     @forceOutput            = forceOutput
     @env                    = env
     @debug                  = ENV.has_key?('DEBUG') ? true : debug
+    @noOutputOperators      = getNoOuputOperators(@cdo)
     @returnNilOnError       = returnNilOnError
 
     @filetypes              = getFiletypes
@@ -76,7 +78,7 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
         exit
       end
 
-      @operators = help[(help.index("Operators:")+1)..help.index(help.find {|v| v =~ /CDO version/}) - 2].join(' ').split
+      @operators = help[(help.index("Operators:")+1)..help.index(help.find {|v| v =~ /CDO version/ }) - 2].join(' ').split
     else
       cmd = "#{path2cdo} --operators"
 
@@ -84,6 +86,15 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
     end
   end
 
+  def getNoOuputOperators(path2cdo)
+    if version > '1.8.0' then
+      puts 'CMD:'+path2cdo+' --operators_no_output' if @debug
+      IO.popen(path2cdo+' --operators_no_output').readlines.map{|line| line.split(' ')[0]}.flatten
+    else
+      NoOutputOperators
+    end
+  end
+
   # get supported IO filetypes form the binary
   def getFiletypes
     _, _, stderr, _ = Open3.popen3(@cdo + " -V")
@@ -92,7 +103,6 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
     supported.grep(/(Filetypes)/)[0].split(':')[1].split.map(&:downcase)
   end
 
-
   # Execute the given cdo call and return all outputs
   def _call(cmd,env={})
     @logger.info(cmd+"\n") if @logging
@@ -136,7 +146,17 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
   end
 
   # command execution wrapper, which handles the possible return types
-  def _run(cmd,ofile='',options=nil,returnCdf=false,force=nil,returnArray=nil,returnMaArray=nil,env=nil)
+  def _run(operatorName,
+           operatorParameters,
+           input:         nil,
+           output:        nil,
+           options:       nil,
+           returnCdf:     false,
+           force:         nil,
+           returnArray:   nil,
+           returnMaArray: nil,
+           env:           nil,
+           autoSplit:     nil)
     options = options.to_s
 
     options << '-f nc' if options.empty? and ( \
@@ -144,16 +164,23 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
                                               ( not returnArray.nil? ) or \
                                               ( not returnMaArray.nil?) \
                                              )
-    cmd = "#{@cdo} -O #{options} #{cmd} "
+    #
+    # setup basic operator execution command
+    cmd = "#{@cdo} -O #{options} -#{operatorName}#{operatorParameters} #{input} "
 
     # use an empty hash for non-given environment
     env = {} if env.nil?
 
-    case ofile
+    case output
     when $stdout
       retvals = _call(cmd,env)
       unless _hasError(cmd,retvals)
-        return retvals[:stdout].split($/).map {|l| l.chomp.strip}
+        _output = retvals[:stdout].split($/).map {|l| l.chomp.strip}
+        unless autoSplit.nil?
+          _output.map! {|line| line.split(autoSplit)}
+          _output = _output[0] if 1 == _output.size
+        end
+        return _output
       else
         if @returnNilOnError then
           return nil
@@ -163,10 +190,15 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
       end
     else
       force = @forceOutput if force.nil?
-      if force or not File.exists?(ofile.to_s)
-        ofile = MyTempfile.path if ofile.nil?
-        cmd << "#{ofile}"
+      if force or not File.exists?(output.to_s)
+        # create a tempfile if output is not given
+        output = MyTempfile.path if output.nil?
+
+        #finalize the execution command
+        cmd << "#{output}"
+
         retvals = _call(cmd,env)
+
         if _hasError(cmd,retvals)
           if @returnNilOnError then
             return nil
@@ -175,18 +207,20 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
           end
         end
       else
-        warn "Use existing file '#{ofile}'" if @debug
+        warn "Use existing file '#{output}'" if @debug
       end
     end
 
     if not returnArray.nil?
-      readArray(ofile,returnArray)
+      readArray(output,returnArray)
     elsif not returnMaArray.nil?
-      readMaArray(ofile,returnMaArray)
+      readMaArray(output,returnMaArray)
     elsif returnCdf or @returnCdf
-      readCdf(ofile)
+      readCdf(output)
+    elsif /^split/.match(operatorName)
+      Dir.glob("#{output}*")
     else
-      ofile
+      output
     end
   end
 
@@ -196,19 +230,21 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
   #   [opt1,...,optN,:input => iStream,:output => oStream, :options => ' ']
   #   where iStream could be another CDO call (timmax(selname(Temp,U,V,ifile.nc))
   def method_missing(sym, *args, &block)
-    puts "Operator #{sym.to_s} is called" if @debug
+    operatorName = sym.to_s
+    puts "Operator #{operatorName} is called" if @debug
 
-    if @operators.include?(sym.to_s)
-      io, opts = Cdo.parseArgs(args)
-      if OutputOperators.include?(sym.to_s)
-        _run(" -#{sym.to_s}#{opts} #{io[:input]} ",$stdout,nil,nil,nil,nil,nil,env)
-      else
-        _run(" -#{sym.to_s}#{opts} #{io[:input]} ",io[:output],io[:options],io[:returnCdf],io[:force],io[:returnArray],io[:returnMaArray],io[:env])
-      end
-    else
+    # exit eary on missing operator
+    unless @operators.include?(operatorName)
       return false if @returnFalseOnError
-      raise ArgumentError,"Operator #{sym.to_s} not found"
+      raise ArgumentError,"Operator #{operatorName} not found"
     end
+
+    io, operatorParameters = Cdo.parseArgs(args)
+
+    # mark calls for operators without output files
+    io[:output] = $stdout if @noOutputOperators.include?(operatorName)
+
+    _run(operatorName,operatorParameters,io)
   end
 
   # load the netcdf bindings
@@ -297,6 +333,9 @@ spartab specinfo tinfo vardes vct vct2 verifygrid vlist zaxisdes]
     end
   end
 
+  def noOutputOps
+    getNoOuputOperators(@cdo)
+  end
   # }}}
 
   # Addional operators: {{{

data/test/test_cdo.rb

@@ -2,7 +2,6 @@ $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
 require 'minitest/autorun'
 require 'cdo'
-require 'unifiedPlot'
 require 'pp'
 
 
@@ -30,7 +29,8 @@ class TestCdo < Minitest::Test
     end
     newCDO="#{ENV['HOME']}/local/bin/cdo-dev"
     if File.exist?(newCDO) then
-      cdo = Cdo.new(:cdo => newCDO)
+      cdo = Cdo.new
+      cdo.cdo = newCDO
       assert_equal(true,cdo.check)
       assert_equal(newCDO,cdo.cdo)
     end
@@ -69,7 +69,7 @@ class TestCdo < Minitest::Test
   end
   def test_CDO_version
     assert("1.4.3.1" < @cdo.version,"Version too low: #{@cdo.version}")
-    assert("1.8.0" > @cdo.version,"Version too high: #{@cdo.version}")
+    assert("1.8.1" > @cdo.version,"Version too high: #{@cdo.version}")
   end
   def test_args
     ofile0 = @cdo.stdatm(0,20,40,80,200,230,400,600,1100)
@@ -112,50 +112,6 @@ class TestCdo < Minitest::Test
                  @cdo.thicknessOfLevels(:input => ofile))
   end
 
-  def test_combine
-    ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-    @cdo.fldsum(:input => @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:output => ofile0)
-    @cdo.fldsum(:input => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:output => ofile1)
-    @cdo.returnCdf = true
-    MyTempfile.showFiles
-    diff = @cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
-    assert_equal(0.0,diff.min)
-    assert_equal(0.0,diff.max)
-    @cdo.returnCdf = false
-  end
-
-  def test_tempfile
-    ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-    assert(ofile0 != ofile1, "Found equal tempfiles!")
-    # Tempfile should not disappeare even if the GC was started
-    puts ofile0
-    assert(File.exist?(ofile0))
-    GC.start
-    assert(File.exist?(ofile0))
-  end
-
-  def test_returnCdf
-    ofile = rand(0xfffff).to_s + '_test_returnCdf.nc'
-    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
-    assert_equal(ofile,vals)
-    @cdo.returnCdf = true
-    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
-    assert_equal(["lon","lat","level","P","T"],vals.var_names)
-    assert_equal(276,vals.var("T").get.flatten.mean.floor)
-    @cdo.returnCdf = false
-    vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
-    assert_equal(ofile,vals)
-    FileUtils.rm(ofile)
-  end
-  def test_simple_returnCdf
-    ofile0, ofile1 = MyTempfile.path, MyTempfile.path
-    sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),
-               :returnCdf => true).var("P").get
-    assert_equal(1013.25,sum.min)
-    sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),:output => ofile0)
-    assert_equal(ofile0,sum)
-    test_returnCdf
-  end
   def test_force
     outs = []
     # tempfiles
@@ -204,10 +160,33 @@ class TestCdo < Minitest::Test
     assert_equal(targetThicknesses, @cdo.thicknessOfLevels(:input => "-selname,T -stdatm,#{levels.join(',')}"))
   end
 
-  def test_showlevels
+  def test_outputOperators
     sourceLevels = %W{25 100 250 500 875 1400 2100 3000 4000 5000}
     assert_equal(sourceLevels,
                  @cdo.showlevel(:input => "-selname,T #{@cdo.stdatm(*sourceLevels,:options => '-f nc')}")[0].split)
+    
+   # test autoSplit usage
+   levels = @cdo.showlevel(input: "-stdatm,0,10,20",autoSplit: ' ')
+   assert_equal([['0','10','20'],['0','10','20']],levels)
+   assert_equal(sourceLevels,
+                @cdo.showlevel(:input => "-selname,T #{@cdo.stdatm(*sourceLevels,:options => '-f nc')}",
+                               :autoSplit => ' '))
+
+   timesExpected = ['2001-01-01T12:00:00',
+                    '2001-01-01T13:00:00',
+                    '2001-01-01T14:00:00',
+                    '2001-01-01T15:00:00',
+                    '2001-01-01T16:00:00',
+                    '2001-01-01T17:00:00',
+                    '2001-01-01T18:00:00',
+                    '2001-01-01T19:00:00',
+                    '2001-01-01T20:00:00',
+                    '2001-01-01T21:00:00']
+   assert_equal(timesExpected,
+                    @cdo.showtimestamp(input: "-settaxis,2001-01-01,12:00,1hour -for,1,10", autoSplit: '  '))
+
+   assert_equal(['P T'],@cdo.showname(input: "-stdatm,0"))
+   assert_equal(['P','T'],@cdo.showname(input: "-stdatm,0",autoSplit: ' '))
   end
 
   def test_verticalLevels
@@ -219,44 +198,13 @@ class TestCdo < Minitest::Test
   end
 
   def test_parseArgs
-    io,opts = Cdo.parseArgs([1,2,3,:input => '1',:output => '2',:force => true,:returnCdf => "T"])
+    io,opts = Cdo.parseArgs([1,2,3,:input => '1',:output => '2',:force => true,:returnCdf => "T",:autoSplit => '  '])
     assert_equal("1",io[:input])
     assert_equal("2",io[:output])
     assert_equal(true,io[:force])
     assert_equal("T",io[:returnCdf])
+    assert_equal("  ",io[:autoSplit])
     pp [io,opts]
-  end 
-
-  def test_returnArray
-    temperature = @cdo.stdatm(0,:options => '-f nc',:returnCdf => true).var('T').get.flatten[0]
-    assert_raises ArgumentError do
-      @cdo.stdatm(0,:options => '-f nc',:returnArray => 'TT')
-    end
-    temperature = @cdo.stdatm(0,:options => '-f nc',:returnArray => 'T')
-    assert_equal(288.0,temperature.flatten[0])
-    pressure = @cdo.stdatm(0,1000,:options => '-f nc -b F64',:returnArray => 'P')
-    assert_equal("1013.25 898.543456035875",pressure.flatten.to_a.join(' '))
-  end
-  def test_returnMaArray
-    @cdo.debug = true
-    topo = @cdo.topo(:options => '-f nc',:returnMaArray => 'topo')
-    assert_equal(-1890.0,topo.mean.round)
-    bathy = @cdo.setrtomiss(0,10000,
-        :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
-    assert_equal(-3386.0,bathy.mean.round)
-    oro = @cdo.setrtomiss(-10000,0,
-        :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
-    assert_equal(1142.0,oro.mean.round)
-    bathy = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'), :returnMaArray => 'topo')
-    assert_equal(-4298.0,bathy[0,0])
-    assert_equal(-2669.0,bathy[1,0])
-    ta = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'))
-    tb = @cdo.subc(-2669.0,:input => ta)
-    withMask = @cdo.div(:input => ta+" "+tb,:returnMaArray => 'topo')
-    assert(-8.0e+33 > withMask[1,0])
-    assert(0 < withMask[0,0])
-    assert(0 < withMask[0,1])
-    assert(0 < withMask[1,1])
   end
 
   def test_errorException
@@ -302,7 +250,7 @@ class TestCdo < Minitest::Test
   end
 
   def test_filetypes
-    assert(@cdo.filetypes.include?("grb"),"GRIB support missing")
+    assert(@cdo.filetypes.find{|ft| /^grb/.match(ft)},"GRIB support missing")
     assert(@cdo.filetypes.include?("nc4"),"NETCDF4 support missing")
     assert(@cdo.filetypes.include?("ext"),"EXTRA support missing")
     assert_raises ArgumentError do
@@ -310,12 +258,121 @@ class TestCdo < Minitest::Test
     end
   end
 
+  def test_noOutputOps
+    case
+    when "1.8.0" == @cdo.version then
+      assert_equal(Cdo::NoOutputOperators,@cdo.noOutputOps)
+    when "1.8.0" < @cdo.version
+      assert((Cdo::NoOutputOperators - @cdo.noOutputOps).empty?)
+    end
+  end
+
   def test_output_set_to_nil
     assert_equal(String,@cdo.topo(:output => nil).class)
     assert_equal("File format: GRIB".tr(' ',''),@cdo.sinfov(:input => "-topo", :output => nil)[0].tr(' ',''))
   end
 
+  def test_splitOps
+    pattern = 'stdAtm'
+    resultsFiles = @cdo.splitname(input: '-stdatm,0',output: pattern)
+    assert_equal(2,resultsFiles.size)
+    %w[T P].each {|var|
+      assert(resultsFiles.include?("#{pattern}#{var}.grb"))
+    }
+
+    pattern = 'sel'
+    resultsFiles = @cdo.splitsel(1,input: '-for,0,9',output: pattern)
+    assert_equal(10,resultsFiles.size)
+    (0..9).each {|var|
+      assert(resultsFiles.include?("#{pattern}00000#{var}.grb"))
+    }
+
+    pattern = 'lev'
+    resultsFiles = @cdo.splitlevel(input: '-stdatm,100,2000,5000',output: pattern)
+    assert_equal(3,resultsFiles.size)
+    %w[0100 2000 5000].each {|var|
+      assert(resultsFiles.include?("#{pattern}00#{var}.grb"))
+    }
+  end
+
   if @@maintainermode  then
+    require 'unifiedPlot'
+
+    def test_returnArray
+      temperature = @cdo.stdatm(0,:options => '-f nc',:returnCdf => true).var('T').get.flatten[0]
+      assert_raises ArgumentError do
+        @cdo.stdatm(0,:options => '-f nc',:returnArray => 'TT')
+      end
+      temperature = @cdo.stdatm(0,:options => '-f nc',:returnArray => 'T')
+      assert_equal(288.0,temperature.flatten[0])
+      pressure = @cdo.stdatm(0,1000,:options => '-f nc -b F64',:returnArray => 'P')
+      assert_equal("1013.25 898.543456035875",pressure.flatten.to_a.join(' '))
+    end
+    def test_returnMaArray
+      @cdo.debug = true
+      topo = @cdo.topo(:options => '-f nc',:returnMaArray => 'topo')
+      assert_equal(-1890.0,topo.mean.round)
+      bathy = @cdo.setrtomiss(0,10000,
+          :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
+      assert_equal(-3386.0,bathy.mean.round)
+      oro = @cdo.setrtomiss(-10000,0,
+          :input => @cdo.topo(:options => '-f nc'),:returnMaArray => 'topo')
+      assert_equal(1142.0,oro.mean.round)
+      bathy = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'), :returnMaArray => 'topo')
+      assert_equal(-4298.0,bathy[0,0])
+      assert_equal(-2669.0,bathy[1,0])
+      ta = @cdo.remapnn('r2x2',:input => @cdo.topo(:options => '-f nc'))
+      tb = @cdo.subc(-2669.0,:input => ta)
+      withMask = @cdo.div(:input => ta+" "+tb,:returnMaArray => 'topo')
+      assert(-8.0e+33 > withMask[1,0])
+      assert(0 < withMask[0,0])
+      assert(0 < withMask[0,1])
+      assert(0 < withMask[1,1])
+    end
+    def test_combine
+      ofile0, ofile1 = MyTempfile.path, MyTempfile.path
+      @cdo.fldsum(:input => @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:options => "-f nc"),:output => ofile0)
+      @cdo.fldsum(:input => "-stdatm,25,100,250,500,875,1400,2100,3000,4000,5000",:options => "-f nc",:output => ofile1)
+      @cdo.returnCdf = true
+      MyTempfile.showFiles
+      diff = @cdo.sub(:input => [ofile0,ofile1].join(' ')).var('T').get
+      assert_equal(0.0,diff.min)
+      assert_equal(0.0,diff.max)
+      @cdo.returnCdf = false
+    end
+
+    def test_tempfile
+      ofile0, ofile1 = MyTempfile.path, MyTempfile.path
+      assert(ofile0 != ofile1, "Found equal tempfiles!")
+      # Tempfile should not disappeare even if the GC was started
+      puts ofile0
+      assert(File.exist?(ofile0))
+      GC.start
+      assert(File.exist?(ofile0))
+    end
+
+    def test_returnCdf
+      ofile = rand(0xfffff).to_s + '_test_returnCdf.nc'
+      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+      assert_equal(ofile,vals)
+      @cdo.returnCdf = true
+      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+      assert_equal(["lon","lat","level","P","T"],vals.var_names)
+      assert_equal(276,vals.var("T").get.flatten.mean.floor)
+      @cdo.returnCdf = false
+      vals = @cdo.stdatm(25,100,250,500,875,1400,2100,3000,4000,5000,:output => ofile,:options => "-f nc")
+      assert_equal(ofile,vals)
+      FileUtils.rm(ofile)
+    end
+    def test_simple_returnCdf
+      ofile0, ofile1 = MyTempfile.path, MyTempfile.path
+      sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),
+                 :returnCdf => true).var("P").get
+      assert_equal(1013.25,sum.min)
+      sum = @cdo.fldsum(:input => @cdo.stdatm(0,:options => "-f nc"),:output => ofile0)
+      assert_equal(ofile0,sum)
+      test_returnCdf
+    end
     def test_readCdf
       input = "-settunits,days  -setyear,2000 -for,1,4"
       cdfFile = @cdo.copy(:options =>"-f nc",:input=>input)
@@ -464,7 +521,7 @@ end
 #  ths.each {|th| th.join}
 #  # another example with sub:
 #  @cdo.sub(:input => [oldfile,newfile].join(' '), :output => diff)
-#  
+#
 #  # It is possible too use the 'send' method
 #  operator  = /grb/.match(File.extname(ifile)) ? :showcode : :showname
 #  inputVars = @cdo.send(operator,:input => ifile)
@@ -478,7 +535,7 @@ end
 #               warn "Wrong usage of variable identifier for '#{var}' (class #{var.class})!"
 #             end
 #  @cdo.send(operator,var,:input => @ifile, :output => varfile)
-#  
+#
 #  # Pass an array for operators with multiple options:
 #  #   Perform conservative remapping with pregenerated weights
 #  @cdo.remap([gridfile,weightfile],:input => copyfile,:output => outfile)
@@ -486,7 +543,7 @@ end
 #  @cdo.ml2hl([0,20,50,100,200,400,800,1200].join(','),:input => hybridlayerfile, :output => reallayerfile)
 #  # or use multiple arguments directly
 #  @cdo.remapeta(vctfile,orofile,:input => ifile,:output => hybridlayerfile)
-#  
+#
 #  # the powerfull expr operator:
 #  # taken from the tutorial in https://code.zmaw.de/projects/cdo/wiki/Tutorial#The-_expr_-Operator
 #  SCALEHEIGHT  = 10000.0
@@ -494,12 +551,12 @@ end
 #  # function for later computation of hydrostatic atmosphere pressure
 #  PRES_EXPR    = lambda {|height| "101325.0*exp((-1)*(1.602769777072154)*log((exp(#{height}/#{SCALEHEIGHT})*213.15+75.0)/288.15))"}
 #  TEMP_EXPR    = lambda {|height| "213.0+75.0*exp(-#{height}/#{SCALEHEIGHT})"}
-#  
+#
 #  # Create Pressure and Temperature out of a height field 'geopotheight' from ifile
 #  @cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :input => ifile, :output => presFile)
 #  @cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :input => ifile, :output => tempFile)
-#  
-#  
+#
+#
 #  # TIPS: I often work with temporary files and for getting rid of handling them manually the MyTempfile module can be used:
 #  #       Simply include the following methods into you scripts and use tfile for any temporary variable
 #  def tfile
@@ -510,8 +567,8 @@ end
 #  @cdo.expr("'p=#{PRES_EXPR['geopotheight']}'", :input => ifile, :output => presFile)
 #  @cdo.expr("'t=#{TEMP_EXPR['geopotheight']}'", :input => ifile, :output => tempFile)
 #  @cdo.chainCall("setname,#{rho} -divc,#{C_R} -div",in: [presFile,tempFile].join(' '), out: densityFile)
-#  
+#
 #  # For debugging, it is helpfull, to avoid the automatic cleanup at the end of the scripts:
 #  MyTempfile.setPersist(true)
-#  # creates randomly names files. Switch on debugging with 
+#  # creates randomly names files. Switch on debugging with
 #  @cdo.Debug = true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cdo
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - Ralf Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-24 00:00:00.000000000 Z
+date: 2017-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: unifiedPlot
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Easy access to the Climate Data operators
 email: stark.dreamdetective@gmail.com
 executables: []
@@ -55,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Easy access to the Climate Data operators