rio 0.3.8 → 0.3.9

data/test/tc/dir_iter.rb

@@ -260,7 +260,6 @@ class TC_dir_iter < Test::RIO::TestCase
       assert_equal(expa,ans)
     end
 
-    return
     #  $trace_states = true
 
     # iterate twice using #get (no auto close)

data/test/tc/empty.rb

@@ -9,6 +9,10 @@ require 'tc/testcase'
 
 class TC_empty < Test::RIO::TestCase
   @@once = false
+
+  require 'tc/programs_util'
+  include Test::RIO::Programs
+
   def self.once
     @@once = true
 
@@ -36,10 +40,10 @@ class TC_empty < Test::RIO::TestCase
     assert!(rio('f1').empty?)
   end
   def test_ps_empty
-    assert(rio(?-,'ls d0').empty?)
+    assert(rio(?-,PROG['list_dir'] + ' d0').empty?)
   end
   def test_ps_not_empty
-    assert!(rio(?-,'ls d1').empty?)
+    assert!(rio(?-,PROG['list_dir'] + ' d1').empty?)
   end
   def test_dev_null_empty
     assert(rio(nil).empty?)

data/test/tc/expand_path.rb

@@ -5,34 +5,24 @@ if $0 == __FILE__
 end
 
 require 'rio'
-require 'test/unit'
-require 'test/unit/testsuite'
+require 'tc/testcase'
+
+class TC_RIO_expand_path < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
 
-class TC_RIO_expand_path < Test::Unit::TestCase
-  def initialize(*args)
-    super
-    @once = false
-    @tdir = rio('qp/expand_path')
-  end
-  def assert!(a,msg="negative assertion")
-    assert((!(a)),msg)
   end
-  def smap(a) a.map{|el| el.to_s} end
+
   def setup
-    s_dir = ''
-    #$trace_states = true
-    unless @once
-      @once =  true
-      @tdir.rmtree.mkpath
-    end
+    super
+    self.class.once unless @@once
   end
 
   def test_expand_path_from_cwd
     require 'tmpdir'
-    tmp = rio('/tmp')
-    unless tmp.dir?
-      tmp = rio(RIO::RL.fs2url(::Dir.tmpdir))
-    end
+
+    tmp = rio(::Dir.tmpdir)
     tmp.chdir do
       rel = rio('groovy')
       exp = rio(tmp,rel)
@@ -43,45 +33,37 @@ class TC_RIO_expand_path < Test::Unit::TestCase
   end
 
   def test_expand_path_from_base_rio
-    @tdir.chdir do
-      srel = 'groovy'
-      sbase = '/tmp'
-      rel = rio(srel)
-      base = rio(sbase)
-      exp = File.expand_path(srel,sbase)
-      ans = rel.expand_path(base)
-      assert_kind_of(RIO::Rio,ans)
-      assert_equal(exp,ans)
-    end
+    srel = 'groovy'
+    sbase = '/tmp'
+    rel = rio(srel)
+    base = rio(sbase)
+    exp = File.expand_path(srel,sbase)
+    ans = rel.expand_path(base)
+    assert_kind_of(RIO::Rio,ans)
+    assert_equal(exp,ans)
   end
 
   def test_expand_path_from_base_string
-    @tdir.chdir do
-      srel = 'groovy'
-      sbase = '/tmp'
-      rel = rio(srel)
-      base = rio(sbase)
-      exp = File.expand_path(srel,sbase)
-      ans = rel.expand_path(sbase)
-      assert_kind_of(RIO::Rio,ans)
-      assert_equal(exp,ans)
-    end
+    srel = 'groovy'
+    sbase = '/tmp'
+    rel = rio(srel)
+    base = rio(sbase)
+    exp = File.expand_path(srel,sbase)
+    ans = rel.expand_path(sbase)
+    assert_kind_of(RIO::Rio,ans)
+    assert_equal(exp,ans)
   end
 
   def test_expand_path_from_tilde
-    @tdir.chdir do
-      srel = 'groovy'
-      sbase = '~'
-      rel = rio(srel)
-      base = rio(sbase)
-      exp = File.expand_path(srel,sbase)
-      ans = rel.expand_path(sbase)
-      assert_kind_of(RIO::Rio,ans)
-      assert_equal(exp,ans)
-    end
+    return if $mswin32
+    srel = 'groovy'
+    sbase = '~'
+    rel = rio(srel)
+    base = rio(sbase)
+    exp = File.expand_path(srel,sbase)
+    ans = rel.expand_path(sbase)
+    assert_kind_of(RIO::Rio,ans)
+    assert_equal(exp,ans)
   end
 
-
-
-
 end

data/test/tc/ext.rb

@@ -6,26 +6,30 @@ end
 
 require 'rio'
 require 'tc/testcase'
-class TC_ext < Test::Unit::TestCase
+class TC_ext < Test::RIO::TestCase
   @@once = false
-  include RIO_TestCase
-  def setup()
-    super
-    unless @@once
-      @@once = true
-    end
+  def self.once
+    @@once = true
+
   end
-  def test_mvdir
-    rio('a').rmtree.mkpath
-    rio('a/b').mkpath
-    rio('a/c').mkpath
-    rio('a/b/f').touch
-    rio('a/b/f').rename('a/c')
-    rio('a/b/d').mkdir
-    rio('a/b/d').rename('a/c')
-    assert(rio('a/c/f').exist?)
-    assert(rio('a/c/d').exist?)
+
+  def setup
+    super
+    self.class.once unless @@once
+
   end
+
+#  def test_mvdir
+#    rio('a').rmtree.mkpath
+#    rio('a/b').mkpath
+#    rio('a/c').mkpath
+#    rio('a/b/f').touch
+#    rio('a/b/f').rename('a/c')
+#    rio('a/b/d').mkdir
+#    rio('a/b/d').rename('a/c')
+#    assert(rio('a/c/f').exist?)
+#    assert(rio('a/c/d').exist?)
+#  end
   def test_change_ext_in_dir
     rio('ch').rmtree.mkpath
     rio('ch/0.a').touch
@@ -66,7 +70,7 @@ class TC_ext < Test::Unit::TestCase
     assert(rio('tgz/z.tgz').exist?)
   end
   def test_ext
-    ario = mkafile('afile.tar.gz')
+    ario = rio('afile.tar.gz').touch
     $trace_states = false
     ario.rename!('cfile.tgz')
 #    ario.ext('.tar.gz').basename = 'bfile'
@@ -109,4 +113,24 @@ class TC_ext < Test::Unit::TestCase
     abs2 = rio(RIO.cwd,path.dirname,path.basename(path.extname).to_s+path.extname).to_s
     assert_equal(abs0,abs2.to_s)
   end
+  def test_documented_example
+    ario = rio('afile.txt')
+    assert_equal('.txt',ario.ext?)
+    assert_equal('afile',ario.ext('.txt').basename)
+    assert_equal('.txt',ario.ext?)
+    assert_equal('afile.txt',ario.ext('.zip').basename)
+    assert_equal('.zip',ario.ext?)
+    assert_equal('afile.txt',ario.basename('.tar'))
+    assert_equal('.tar',ario.ext?)
+    assert_equal('afile',ario.ext.basename)
+    assert_equal('.txt',ario.ext?)
+    assert_equal('afile.txt',ario.noext.basename)
+    assert_equal('',ario.ext?)
+
+    ario = rio('afile.tar.gz')
+    assert_equal('.gz',ario.ext?)
+    assert_equal('afile.tar',ario.basename)
+    assert_equal('afile',ario.ext('.tar.gz').basename)
+    assert_equal('.tar.gz',ario.ext?)
+  end
 end

data/test/tc/gzip.rb

@@ -49,21 +49,48 @@ class TC_gzip < Test::RIO::TestCase
   end
 
   def test_file
-    str = "Hello World\n"
-    rio('src').print!(str)
+    str = "Hello World"
+    rio('src').puts!(str)
 
     rio('src.gz').delete!
     rio('ans').delete!
     rio('src') > rio('src.gz').gzip
     rio('src.gz').gzip > rio('ans')
-    assert_equal(str,rio('ans').contents)
+    assert_equal(str,rio('ans').chomp.line[0])
     
     rio('src.gz').delete!
     rio('ans').delete!
     rio('src.gz').gzip < rio('src') 
     rio('ans') < rio('src.gz').gzip
+    assert_equal(str,rio('ans').chomp.line[0])
+    
+  end
+
+  def test_file_each
+    str = "Hello World\n"
+    rio('src').print!(str)
+
+    rio('src.gz').delete!
+    rio('ans').delete!
+    dst = rio('src.gz').gzip
+    rio('src').each do |l|
+      dst.print(l)
+    end
+    dst.close
+    ans = rio('ans')
+    rio('src.gz').gzip do |l|
+      ans.print(l)
+    end
+    ans.close
+
     assert_equal(str,rio('ans').contents)
     
+#    rio('src.gz').delete!
+#    rio('ans').delete!
+#    rio('src.gz').gzip < rio('src') 
+#    rio('ans') < rio('src.gz').gzip
+#    assert_equal(str,rio('ans').contents)
+    
   end
 
   def test_tempfile

data/test/tc/likeio.rb

@@ -42,10 +42,14 @@ class TC_likeio < Test::RIO::TestCase
   end
   
   def check_read_method(fruby,frio,n,sym,*args)
+    #$trace_states = true
     n.times {
-      assert_equal(fruby.__send__(sym,*args),frio.__send__(sym,*args))
+      exp = fruby.__send__(sym,*args)
+      ans = frio.__send__(sym,*args)
+      assert_equal(exp,ans)
       assert_equal(fruby.eof?,frio.eof?)
     }
+    #$trace_states = false
   end
 
   def check_read_method_raises_eof(fruby,frio,n,sym,*args)

data/test/tc/line_record_row.rb

@@ -0,0 +1,51 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+
+class TC_line_record_row < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('f0') < ['zero','one','two','three'].map{ |w| w + $/ }
+  end
+  def setup
+    super
+    self.class.once unless @@once
+    @f0 = rio('f0')
+  end
+  def test_line
+    assert_equal(rio(@f0).lines[0][0],rio(@f0).line[0])
+    assert_equal(rio(@f0).lines[1][0],rio(@f0).line[1])
+    assert_equal(rio(@f0).lines[2][0],rio(@f0).line[2])
+    assert_equal(rio(@f0).lines[3][0],rio(@f0).line[3])
+    assert_equal(rio(@f0).lines[4][0],rio(@f0).line[4])
+    assert_equal(rio(@f0).lines[1..2][0],rio(@f0).line[1])
+    assert_equal(rio(@f0).lines[/t/][0],rio(@f0).line[/t/])
+  end
+
+  def test_record
+    assert_equal(rio(@f0).records[0][0],rio(@f0).record[0])
+    assert_equal(rio(@f0).records[1][0],rio(@f0).record[1])
+    assert_equal(rio(@f0).records[2][0],rio(@f0).record[2])
+    assert_equal(rio(@f0).records[3][0],rio(@f0).record[3])
+    assert_equal(rio(@f0).records[4][0],rio(@f0).record[4])
+    assert_equal(rio(@f0).records[1..2][0],rio(@f0).record[1])
+    assert_equal(rio(@f0).records[/t/][0],rio(@f0).record[/t/])
+  end
+
+  def test_row
+    assert_equal(rio(@f0).rows[0][0],rio(@f0).row[0])
+    assert_equal(rio(@f0).rows[1][0],rio(@f0).row[1])
+    assert_equal(rio(@f0).rows[2][0],rio(@f0).row[2])
+    assert_equal(rio(@f0).rows[3][0],rio(@f0).row[3])
+    assert_equal(rio(@f0).rows[4][0],rio(@f0).row[4])
+    assert_equal(rio(@f0).rows[1..2][0],rio(@f0).row[1])
+    assert_equal(rio(@f0).rows[/t/][0],rio(@f0).row[/t/])
+  end
+
+end

data/test/tc/noqae.rb

@@ -193,90 +193,91 @@ class TC_RIO_noqae < Test::Unit::TestCase
   end
 
   def test_noqae_fs_de
-    @@tdir.abs.chdir
-    begin
+    @@tdir.abs.chdir do
       begin
-        ans = []
-        rio('d0').dirs.each { |el| 
-          assert(el.directory?)
-        }
-        rio('d0').skipdirs.each { |el| 
-          assert!(el.directory?)
-        }
-        rio('d0').skipdirs('*').each { |el| 
-          assert(el.directory?)
-        }
-        rio('d0').files.each { |el| 
-          assert(el.file?)
-        }
-        rio('d0').skipfiles.each { |el| 
-          assert!(el.file?)
-        }
-        rio('d0').skipfiles('*').each { |el| 
-          assert(el.file?)
-        }
-        return unless $supports_symlink
         begin
-          exp = all.select { |el| el =~ /[lnc]\d\Z/ }
           ans = []
-          rio('d0').entries(:symlink?).each { |el| 
-            assert(el.symlink?)
-            ans << el
+          rio('d0').dirs.each { |el| 
+            assert(el.directory?)
           }
-          assert_equal(exp.sort,smap(ans).sort)
-        end
-        begin
-          exp = all.select { |el| el =~ /[l]\d\Z/ }
-          ans = []
-          rio('d0').files(:symlink?).each { |el| 
-            assert(el.file?)
-            assert(el.symlink?)
-            ans << el
+          rio('d0').skipdirs.each { |el| 
+            assert!(el.directory?)
           }
-          assert_equal(exp.sort,smap(ans).sort)
-        end
-        begin
-          exp = all.select { |el| el =~ /[c]\d\Z/ }
-          ans = []
-          rio('d0').dirs(:symlink?).each { |el| 
+          rio('d0').skipdirs('*').each { |el| 
             assert(el.directory?)
-            assert(el.symlink?)
-            ans << el
           }
-          assert_equal(exp.sort,smap(ans).sort)
-        end
-        begin
-          exp = all.select { |el| el =~ /[df]\d\Z/ }
-          ans = []
-          rio('d0').skipentries(:symlink?).each { |el| 
-            assert!(el.symlink?)
-            ans << el
+          rio('d0').files.each { |el| 
+            assert(el.file?)
           }
-          assert_equal(exp.sort,smap(ans).sort)
-        end
-        begin
-          exp = all.select { |el| el =~ /[d]\d\Z/ }
-          ans = []
-          rio('d0').skipdirs(:symlink?).each { |el| 
-            assert(el.directory?)
-            assert!(el.symlink?)
-            ans << el
+          rio('d0').skipfiles.each { |el| 
+            assert!(el.file?)
           }
-          assert_equal(exp.sort,smap(ans).sort)
-        end
-        begin
-          exp = all.select { |el| el =~ /[f]\d\Z/ }
-          ans = []
-          rio('d0').skipfiles(:symlink?).each { |el| 
+          rio('d0').skipfiles('*').each { |el| 
             assert(el.file?)
-            assert!(el.symlink?)
-            ans << el
           }
-          assert_equal(exp.sort,smap(ans).sort)
+          return unless $supports_symlink
+          begin
+            exp = all.select { |el| el =~ /[lnc]\d\Z/ }
+            ans = []
+            rio('d0').entries(:symlink?).each { |el| 
+              assert(el.symlink?)
+              ans << el
+            }
+            assert_equal(exp.sort,smap(ans).sort)
+          end
+          begin
+            exp = all.select { |el| el =~ /[l]\d\Z/ }
+            ans = []
+            rio('d0').files(:symlink?).each { |el| 
+              assert(el.file?)
+              assert(el.symlink?)
+              ans << el
+            }
+            assert_equal(exp.sort,smap(ans).sort)
+          end
+          begin
+            exp = all.select { |el| el =~ /[c]\d\Z/ }
+            ans = []
+            rio('d0').dirs(:symlink?).each { |el| 
+              assert(el.directory?)
+              assert(el.symlink?)
+              ans << el
+            }
+            assert_equal(exp.sort,smap(ans).sort)
+          end
+          begin
+            exp = all.select { |el| el =~ /[df]\d\Z/ }
+            ans = []
+            rio('d0').skipentries(:symlink?).each { |el| 
+              assert!(el.symlink?)
+              ans << el
+            }
+            assert_equal(exp.sort,smap(ans).sort)
+          end
+          begin
+            exp = all.select { |el| el =~ /[d]\d\Z/ }
+            ans = []
+            rio('d0').skipdirs(:symlink?).each { |el| 
+              assert(el.directory?)
+              assert!(el.symlink?)
+              ans << el
+            }
+            assert_equal(exp.sort,smap(ans).sort)
+          end
+          begin
+            exp = all.select { |el| el =~ /[f]\d\Z/ }
+            ans = []
+            rio('d0').skipfiles(:symlink?).each { |el| 
+              assert(el.file?)
+              assert!(el.symlink?)
+              ans << el
+            }
+            assert_equal(exp.sort,smap(ans).sort)
+          end
         end
       end
     end
-    #rio(wd).chdir
+      #rio(wd).chdir
   end
   def test_noqae_fs_re