rio 0.3.1

data/test/tc/cd1.rb

@@ -0,0 +1,116 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+require 'extensions/symbol'
+require 'tc/testcase'
+
+class TC_cd1 < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('d0').rmtree.mkpath
+    rio('d0/d2').rmtree.mkpath
+    rio('d0/d3').rmtree.mkpath
+    rio('d0/d4').rmtree.mkpath
+    rio('d0/d2/d3').rmtree.mkpath
+    rio('d0/d2/d5').rmtree.mkpath
+    rio('d0/d3/d6').rmtree.mkpath
+    rio('d1').rmtree.mkpath
+    rio('d1/d8').rmtree.mkpath
+    make_lines_file(1,'d1/f0')
+    make_lines_file(2,'d1/f1')
+    make_lines_file(1,'d0/f0')
+    make_lines_file(2,'d0/f1')
+    make_lines_file(1,'d0/d2/f0')
+    make_lines_file(2,'d0/d2/f1')
+    make_lines_file(1,'d0/d3/d6/f0')
+    make_lines_file(2,'d0/d3/d6/f1')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @d0 = rio('d0')
+    @d1 = rio('d1')
+    @d2 = rio('d0/d2')
+    @f0 = rio('d0/f0')
+    @f1 = rio('d0/f1')
+    @f2 = rio('d0/d2/f2')
+    @f3 = rio('d0/d2/f3')
+  end
+  def assert_dirs_equal(exp,d,msg="")
+    exp.each do |ent|
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.file?
+        assert(ds.file?,"entry is a file")
+        assert_equal(ent[],ds[],"file has same contents")
+      when ent.dir?
+        assert_dirs_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def assert_skel_equal(exp,d,msg="")
+    exp.each do |ent|
+      next unless ent.dir?
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.dir?
+        assert_skel_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def test_d2a
+    src = rio(@d1)
+    dst = []
+#    dst < src
+    #$trace_states = true
+    src > dst
+    $trace_states = false
+    p smap(src[])
+    p smap(dst.inspect)
+
+  end
+  def test_d2b
+    src = rio(@d1)
+    dst = []
+#    dst < src
+    #$trace_states = true
+    src.each do |e|
+      dst << e
+    end
+    $trace_states = false
+    p smap(src[])
+    p smap(dst.inspect)
+
+  end
+  def a0test_nonex
+    dst = rio('nonex').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+#    dst < src
+    #$trace_states = true
+    src > dst
+    $trace_states = false
+#    p smap(dst.all[].map { |e| e.rel(dst) })
+    #p smap(src.all[])
+    #p smap(dst.all[])
+#    assert_dirs_equal(@d0,rio(dst,@d0.filename),"basic copy")
+#    exp = @d0.files[]
+#    dd = rio(dst,@d0.filename)
+#    ans = dd.map { |e| e.rel(dst) }
+#    p smap(exp)
+#    p smap(ans)
+#    assert_array_equal(exp,ans,"copy files only")
+  end
+end

data/test/tc/clearsel.rb

@@ -0,0 +1,69 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+
+class TC_RIO_clearsel < Test::Unit::TestCase
+  def tdir() rio(%w/qp clearsel/) end
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  require 'extensions/symbol'
+  def smap(a) a.map( &:to_s ) end
+  def mkafile(*args)
+    file = rio(*args)
+    file < (0..1).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def mkalinesfile(n_lines,*args)
+    file = rio(*args)
+    file < (0...n_lines).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def setup
+    #$trace_states = true
+    @cwd = ::Dir.getwd
+    tdir.mkpath.chdir
+  end
+  def teardown
+    ::Dir.chdir @cwd
+  end
+
+  def test_basic
+    rio('a').delete!.mkpath.chdir
+
+    file = mkalinesfile(8,'f1')
+    lines = file[]
+    cmnt_range = (2..4)
+    cmnt_range.each do |n|
+      lines[n] = '#' + lines[n]
+    end
+    (0..3).each do |n|
+      lines[n].sub!(/f1/,'f2')
+    end
+    file < lines
+
+    f0 = file.dup
+    begin
+      exp = lines[cmnt_range]
+      ans = f0.lines[/^\s*#/]
+      assert_equal(exp,ans)
+      ans = f0[0]
+      assert_equal(lines[0..0],f0[0])
+      assert_equal(lines,f0[])
+      assert_equal(lines[1..2],f0[1..2])
+      assert_equal(lines,f0.lines(1..2)[])
+      assert_equal(lines[4..4],f0.lines(1..2)[4])
+
+    end
+
+
+    file.close
+    rio('..').chdir
+  end
+end

data/test/tc/closeoncopy.rb

@@ -0,0 +1,91 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'test/unit'
+require 'tc/testcase'
+
+class TC_closeoncopy < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+
+    make_lines_file(3,'f0')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @f0 = rio('f0')
+  end
+  def atest_method
+    assert(@f1.closeoncopy?)
+    assert!(@f2.closeoncopy?)
+  end
+  def cfrom(dest,src)
+    dest < src
+    assert(dest.closeoncopy?)
+    assert(dest.closed?)
+
+    dest << src
+    assert(dest.closeoncopy?)
+    assert(dest.closed?)
+  end
+  def test_copyfrom
+    #$trace_states = true
+    cfrom(rio('copyfrom').delete,rio(@f0))
+    cfrom(rio('copyfrom'),rio(@f0))
+    cfrom(rio('copyfrom').open('w'),rio(@f0))
+  end
+
+  def orio()
+    d = rio('copyfrom')
+    d.puts("aline\n")
+    assert(d.open?)
+    d
+  end
+  def test_copyfrom_open
+    #$trace_states = true
+    cfrom(orio,"Zipp\n")
+    cfrom(orio,rio(@f0))
+    cfrom(orio,["Zipp\n"])
+  end
+
+  def test_copyfrom_array
+    #$trace_states = true
+    cfrom(rio('copyfrom').delete,["Zipp\n"])
+  end
+
+  def cto(src,dest)
+    src > dest
+    assert(dest.closeoncopy?)
+    assert(dest.closed?)
+  end
+
+  def ato(src,dest)
+    src >> dest
+    assert(dest.closeoncopy?)
+    assert(dest.closed?)
+  end
+  def test_copyto
+    #$trace_states = true
+    cto(rio(@f0),rio('copyto').delete!)
+    cto(rio(@f0),rio('copyto'))
+    cto(rio(@f0),rio('copyto').open('w'))
+    cto(rio(@f0),rio('copyto').open('a'))
+    cto(rio(@f0),orio)
+  end
+  def test_appto
+    #$trace_states = true
+    ato(rio(@f0),rio('copyto').delete!)
+    ato(rio(@f0),rio('copyto'))
+    ato(rio(@f0),rio('copyto').open('w'))
+    ato(rio(@f0),rio('copyto').open('a'))
+    ato(rio(@f0),orio)
+  end
+
+
+end
+__END__

data/test/tc/closeoneof.rb

@@ -0,0 +1,194 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+
+class TC_RIO_closeoneof < Test::Unit::TestCase
+  def test_basic
+    qp = rio('qp')
+    rio(qp,'test_closeoneof').rmtree.mkpath.chdir {
+      exp = []
+      f = rio('lines.txt')
+      1.upto(3) do |n| 
+        s = "Line #{n}\n"
+        f.print(s)
+        exp << s
+      end
+      f.close
+      exp_s = exp.join('')
+      
+      rio('dir').mkdir
+      rio('dir/a1.txt') < rio('lines.txt')
+      rio('dir/a2.txt') < rio('lines.txt')
+      
+      file = rio('lines.txt')
+      lines = file.to_a
+      assert_equal(exp,lines)
+      assert_equal(true,file.closed?)
+      
+      file = rio('lines.txt')
+      lines = file.readlines
+      assert_equal(exp,lines)
+      assert_equal(true,file.closed?)
+      
+      file = rio('lines.txt')
+      str = ""
+      file.each_line { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(true,file.closed?)
+
+      file = rio('lines.txt')
+      str = ""
+      file.each_byte { |el| str += el.chr }
+      assert_equal(exp_s,str)
+      assert_equal(true,file.closed?)
+
+      file = rio('lines.txt')
+      str = ""
+      file.bytes.each { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(true,file.closed?)
+
+      file = rio('lines.txt')
+      str = ""
+      file.bytes(3).each { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(true,file.closed?)
+
+
+
+
+      file = rio('lines.txt').nocloseoneof
+      lines = file.to_a
+      assert_equal(exp,lines)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt').nocloseoneof
+      lines = file.readlines
+      assert_equal(exp,lines)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt').nocloseoneof
+      str = ""
+      file.each_line { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt').nocloseoneof
+      str = ""
+      file.each_byte { |el| str += el.chr }
+      assert_equal(exp_s,str)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt').nocloseoneof
+      str = ""
+      file.bytes.each { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt').nocloseoneof
+      str = ""
+      file.bytes(3).each { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt')
+      str = ""
+      file.each { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(true,file.closed?)
+
+      file = rio('lines.txt')
+      str = ""
+      file.nocloseoneof.each { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt')
+      str = ""
+      file.nocloseoneof { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(false,file.closed?)
+      file.close
+
+      file = rio('lines.txt')
+      str = ""
+      file.closeoneof { |el| str += el }
+      assert_equal(exp_s,str)
+      assert_equal(true,file.closed?)
+
+
+      file = rio('lines.txt')
+      lines = file.nocloseoneof.readlines
+      assert_equal(exp,lines)
+      assert_equal(false,file.closed?)
+      file.close
+      
+      file = rio('lines.txt').nocloseoneof
+      lines = file.to_a
+      assert_equal(false,file.closed?)
+      file.close
+
+      rio('dir').each { |en|
+        lines = en.to_a
+        assert_equal(exp,lines)
+        assert_equal(true,en.closed?)
+      }
+
+      rio('dir').nocloseoneof.each { |en|
+        lines = en.to_a
+        assert_equal(exp,lines)
+        assert_equal(false,en.closed?)
+        en.close
+      }
+
+      rio('dir').nocloseoneof.each { |en|
+        lines = en.closeoneof.to_a
+        assert_equal(exp,lines)
+        assert_equal(true,en.closed?)
+      }
+
+      rio('dir').closeoneof.each { |en|
+        lines = en.nocloseoneof.to_a
+        assert_equal(exp,lines)
+        assert_equal(false,en.closed?)
+        en.close
+      }
+
+
+      rio('dir').nocloseoneof { |en|
+        lines = en.to_a
+        assert_equal(exp,lines)
+        assert_equal(false,en.closed?)
+        en.close
+      }
+
+      rio('dir').nocloseoneof { |en|
+        lines = en.closeoneof.to_a
+        assert_equal(exp,lines)
+        assert_equal(true,en.closed?)
+      }
+
+      rio('dir').closeoneof { |en|
+        lines = en.nocloseoneof.to_a
+        assert_equal(exp,lines)
+        assert_equal(false,en.closed?)
+        en.close
+      }
+
+
+    }
+  end
+    
+end