wishdev-rio 0.4.3.1

data/test/tc/readline.rb

@@ -0,0 +1,30 @@
+#!/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_readline < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+  end
+  def test_readline_like_IO
+    frio = rio('frio') < (0..1).map{ |i| "Line #{i}\n" }
+    rio('fruby') < frio
+    fruby = File.open('fruby');
+    assert_equal(fruby.readline,frio.readline)
+    assert_equal(fruby.readline,frio.readline)
+    assert_raise(EOFError) { fruby.readline }
+    assert_raise(EOFError) { frio.readline  }
+
+    
+  end
+end

data/test/tc/records.rb

@@ -0,0 +1,68 @@
+#!/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_records < Test::Unit::TestCase
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map { |el| el.to_s } end
+  def tdir() rio(%w/qp records/) 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_procs
+    rio('lineno').delete!.mkpath.chdir
+
+    file = mkalinesfile(8,'f1')
+    lines = file[]
+    (2..4).each do |n|
+      lines[n] = '#' + lines[n]
+    end
+    (0..3).each do |n|
+      lines[n].sub!(/f1/,'f2')
+    end
+    file < lines
+    exp = lines[0..0] + lines[2..4]
+
+    # iterate over the first line and comment lines
+    ans = file.lines[0,/^\s*#/]
+    assert_equal(exp,ans)
+                       
+    ans = file.lines[proc { |rec,rnum,rio| rnum == 0 || rec =~ /^\s*#/ }]
+    assert_equal(exp,ans)
+
+    exp = lines[0..0] + lines[2...8]
+    ans = file.lines[0,/^\s*#/,proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }]
+    assert_equal(exp,ans)
+    
+#    $trace_states = true
+
+
+
+    file.close
+    rio('..').chdir
+  end
+end

data/test/tc/rename.rb

@@ -0,0 +1,233 @@
+#!/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_rename < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('a').rmtree.mkpath
+    rio('b').rmtree.mkpath
+    make_lines_file(3,'a/f0')
+    make_lines_file(2,'a/f1')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @l = []; @f = []; @d = []
+    @d[0] = rio('a')
+    @d[1] = rio('b')
+    @f[0] = rio('a/f0')
+    @f[1] = rio('a/f1')
+    @l[0] = @f[0].readlines
+    @l[1] = @f[1].readlines
+    @d[1] < @d[0]
+    @d[1] < @d[0].files[]
+  end
+  def test_rename_filename
+    indir = rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    oldf = indir.files[].map { |f| f.to_s }
+    expf = oldf.map { |f| f.sub(/f/,'q') }
+    indir.rename.files do |ent|
+      nname = ent.filename.to_s.sub(/f/,'q')
+      ent.filename = nname
+    end
+    assert_array_equal(expf,rio('tdir').files[])
+
+  end
+  def test_rename_filename_sub
+    indir = rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    oldf = indir.files[].map { |f| f.to_s }
+    expf = oldf.map { |f| f.sub(/f/,'q') }
+
+    indir.rename.files do |ent|
+      ent.filename = ent.filename.sub(/f/,'q')
+    end
+    assert_array_equal(expf,rio('tdir').files[])
+
+  end
+  def test_rename_basename
+    indir = rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    oldf = indir.files[].map { |f| f.to_s }
+    expf = oldf.map { |f| f.sub(/f/,'q') }
+
+    indir.rename.files do |ent|
+      ent.basename = ent.basename.to_s.sub(/f/,'q')
+    end
+    assert_array_equal(expf,indir.files[])
+
+  end
+  def test_rename
+    lines,ario = self.class.make_lines_file(1,'afile')
+    assert(ario.file?)
+    
+    brio = rio('bfile').delete!
+    assert!(brio.exist?)
+    ario.rename('bfile')
+    assert!(ario.exist?)
+    assert(brio.file?)
+    assert_equal(lines,brio[])
+    
+  end
+  def test_rename!
+    lines,ario = self.class.make_lines_file(1,'afile')
+    assert(ario.file?)
+    
+    brio = rio('bfile').delete!
+    assert!(brio.exist?)
+
+    crio = ario.rename!('bfile')
+    assert(ario.exist?)
+    assert_same(ario,crio)
+    assert_equal(brio,ario)
+    assert_equal(lines,brio[])
+    
+  end
+  def test_rename_assign
+    adir = rio('adir').delete!.mkpath
+    lines,ario = self.class.make_lines_file(1,adir,'afile.txt')
+    assert(ario.file?)
+    apath = 'adir/afile.txt'
+
+    ario.rename.extname = '.asc'
+    assert_equal(apath.sub!(/\.txt/,'.asc'),ario.to_s)
+    assert(ario.file?)
+    assert_equal(lines,ario[])
+
+    ario.rename.basename = 'bfile'
+    assert_equal(apath.sub!(/afile/,'bfile'),ario.to_s)
+    assert(ario.file?)
+    assert_equal(lines,ario[])
+
+    bdir = rio('bdir').delete!.mkpath
+    ario.rename.dirname = 'bdir'
+    assert_equal(apath.sub!(/adir/,'bdir'),ario.to_s)
+    assert(ario.file?)
+    assert_equal(lines,ario[])
+
+    ario.rename.filename = 'cfile.dat'
+    assert_equal(apath.sub!(/bfile\.asc/,'cfile.dat'),ario.to_s)
+    assert(ario.file?)
+    assert_equal(lines,ario[])
+
+  end
+  def test_rename_basename_sub
+    indir = rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    oldf = indir.files[].map { |f| f.to_s }
+    expf = oldf.map { |f| f.sub(/f/,'q') }
+
+    indir.rename.files do |ent|
+      ent.basename = ent.basename.sub(/f/,'q')
+    end
+    assert_array_equal(expf,indir.files[])
+
+  end
+  def test_rename_dirname
+    indir = rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    oldf = indir.files[].map { |f| f.to_s }
+    expf = oldf.map { |f| f.sub(/tdir/,'qdir') }
+    rio('qdir').delete!.mkpath
+    indir.rename.files do |ent|
+      ent.dirname = 'qdir'
+    end
+
+    assert_array_equal(expf,rio('qdir').files[])
+    assert_array_equal([],rio('tdir').files[])
+
+  end
+  def test_rename_dirname_deep
+    indir = rio('dir1/dir2/dir3/tdir').delete!.mkpath < rio(@d[1]).to_a
+    oldf = indir.files[].map { |f| f.to_s }
+    expf = oldf.map { |f| f.sub(indir.to_s,'shallow') }
+    rio('shallow').delete!.mkpath
+    indir.rename.files do |ent|
+      ent.dirname = 'shallow'
+    end
+    assert_array_equal(expf,rio('shallow').files[])
+    assert_array_equal([],rio(indir.to_s).files[])
+
+  end
+  def test_rename_basename_wext
+    indir = rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+
+    newext = '.txt'
+    indir.files.rename.each { |ent|
+      ent.extname = newext
+    }
+    expf = @f.map { |file| rio(indir,file.basename.to_s + newext) }
+    expf.each_with_index do |ef,i|
+      assert(ef.file?)
+      assert_equal(@l[i],ef.lines[])
+    end
+
+    indir = rio('tdir')
+    newnames = []
+    indir.files.each do |ent|
+      ent.basename = ent.basename.sub(/f/,'q')
+      newnames << ent
+    end
+    expnames = @f.map { |file| rio(indir,file.basename.to_s.sub(/f/,'q') + newext) }
+    assert_equal(expnames,newnames)
+    newf = rio('tdir').files.to_a
+    assert_equal(expf,newf)
+
+    indir = rio('tdir')
+    indir.rename.files { |ent| ent.basename = ent.basename.to_s.sub(/f/,'q') }
+
+    newf = rio('tdir').files.to_a
+    assert_equal(expnames,newf)
+
+
+    
+  end
+    
+  def test_rename_add_ext
+    rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    indir = rio('tdir')
+    newext = '.txt'
+    rio('tdir').files.rename.each { |ent|
+      ent.extname = newext
+    }
+    assert_equal(@l[0],rio(rio('tdir'),@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(rio('tdir'),@f[1].basename.to_s + newext).lines[])
+  end
+  def test_rename_add_ext_oreq
+    indir = (rio('tdir').delete!.mkpath < rio(@d[1]).to_a)
+
+    newext = '.txt'
+    indir.files(/0/).rename { |ent| ent.extname = newext }
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename).lines[])
+
+    newerext = '.asc'
+    indir = rio(indir)
+    indir.files.rename { |ent| ent.extname ||= newerext }
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename.to_s + newerext).lines[])
+  end
+
+  def test_rename_add_ext_andeq
+    indir = (rio('tdir').delete!.mkpath < rio(@d[1]).to_a)
+    newext = '.txt'
+    indir.files(/0/).rename { |ent|
+      ent.extname = newext
+    }
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename).lines[])
+
+    newerext = '.asc'
+    indir = rio(indir)
+    indir.files.rename { |ent|
+      ent.extname &&= newerext
+    }
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newerext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename).lines[])
+  end
+end
+__END__

data/test/tc/rename_assign.rb

@@ -0,0 +1,45 @@
+#!/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_rename_assign < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('a').rmtree.mkpath
+    rio('b').rmtree.mkpath
+    make_lines_file(3,'a/f0')
+    make_lines_file(2,'a/f1')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @l = []; @f = []; @d = []
+    @d[0] = rio('a')
+    @d[1] = rio('b')
+    @f[0] = rio('a/f0')
+    @f[1] = rio('a/f1')
+    @l[0] = @f[0].readlines
+    @l[1] = @f[1].readlines
+    @d[1] < @d[0]
+    @d[1] < @d[0].files[]
+  end
+  def test_rename_filename_shorter
+    adir = rio('adir').delete!.mkdir
+    rio(adir,'abcd').touch.rename.filename = 'xyz'
+    p adir[]
+  end
+  def test_rename_filename_shorterd
+    rio('tc').delete!.mkdir
+    newdir = rio('tc2').delete!.mkdir
+    rio('tc').rename('tc_old')
+    newdir.rename.filename = 'tc'
+    p smap(rio('.').to_a)
+  end
+end
+__END__

data/test/tc/riorl.rb

@@ -0,0 +1,181 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+require 'tmpdir'
+
+class TC_riorl < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+    @tmpdir = "#{::Dir::tmpdir}"
+    #p @tmpdir
+    @tmppath = "#{@tmpdir}/rio"
+  end
+
+  def pathinfo(ario)
+    h = {}
+    [:scheme,:opaque,:path,:fspath,:to_s,:to_url,:to_uri].each do |sym|
+      begin
+        h[sym] = ario.__send__(sym)
+      rescue
+       h[sym] = 'error'
+      end
+    end
+    h
+  end
+  def pinfo(fmt,pi)
+    printf(fmt, pi[:scheme].inspect,pi[:opaque].inspect,pi[:path].inspect,
+           pi[:fspath].inspect,pi[:to_s].inspect,pi[:to_url].inspect)
+  end
+  def mkrioinfo(astring)
+    rinfo = mksyminfo(astring)
+    rinfo[?-] = rinfo[:stdio]
+    rinfo[?=] = rinfo[:stderr]
+    rinfo[??] = rinfo[:temp]
+    rinfo[?"] = rinfo[:strio]
+    rinfo[?_] = rinfo[:sysio]
+    rinfo[?`] = rinfo[:cmdio]
+    rinfo[?#] = rinfo[:fd]
+    rinfo
+  end
+
+  def mksyminfo(astring)
+    rinfo = {
+      :stdio  => ['stdio',"",nil,nil,"stdio:","stdio:"],
+      :stderr => ['stderr',"",nil,nil,"stderr:","stderr:"],
+      :temp => ['temp',@tmppath,nil,nil,"temp:#{@tmppath}","temp:#{@tmppath}"],
+    }
+    strpq = sprintf("0x%08x",astring.object_id)
+    rinfo[:strio] = ['strio',strpq,nil,nil,"strio:#{strpq}","strio:#{strpq}"]
+
+    siopq = sprintf("0x%08x",$stdout.object_id)
+    rinfo[:sysio] = ['sysio',siopq,nil,nil,"sysio:#{siopq}","sysio:#{siopq}"]
+    rinfo[:cmdio] = ['cmdio','echo%20x',nil,nil,'echo x','cmdio:echo%20x']
+    rinfo[:fd] = ['fd','1',nil,nil,'fd:1','fd:1']
+    rinfo
+  end
+
+  def mkrios1()
+    rinfo = mkrioinfo(astring="")
+    rios = {
+      ?- => rio(?-),
+      ?= => rio(?=),
+      ?" => rio(?",astring),
+      ?? => rio(??),
+      ?_ => rio($stdout),
+      ?` => rio(?`,'echo x'),
+      ?# => rio(?#,1),
+    }
+    [rios,rinfo]
+  end
+
+  def mkrios_sym
+    rinfo = mksyminfo(astring="")
+
+    rios = {
+      :stdio => rio(:stdio),
+      :stderr => rio(:stderr),
+      :strio => rio(:strio,astring),
+      :temp => rio(:temp),
+      :sysio => rio(:sysio,$stdout),
+      :cmdio => rio(:cmdio,'echo x'),
+      :fd => rio(:fd,1),
+    }
+
+    [rios,rinfo]
+  end
+  def mkrios_modfunc
+    rinfo = mksyminfo(astring="")
+    rios = {
+      :stdio => RIO.stdio,
+      :stderr => RIO.stderr,
+      :strio => RIO.strio(astring),
+      :temp => RIO.temp,
+      :sysio => RIO.sysio($stdout),
+      :cmdio => RIO.cmdio('echo x'),
+      :fd => RIO.fd(1),
+    }
+    [rios,rinfo]
+  end
+  def mkrios_classmeth
+    rinfo = mksyminfo(astring="")
+    rios = {
+      :stdio => RIO::Rio.stdio,
+      :stderr => RIO::Rio.stderr,
+      :strio => RIO::Rio.strio(astring),
+      :temp => RIO::Rio.temp,
+      :sysio => RIO::Rio.sysio($stdout),
+      :cmdio => RIO::Rio.cmdio('echo x'),
+      :fd => RIO::Rio.fd(1),
+    }
+    [rios,rinfo]
+  end
+  def check_rios(rios,rinfo,fmt="%-12s %-12s %-8s %-8s %-20s %-20s\n")
+    #printf(fmt,'scheme','opaque','path','fspath','to_s','url')
+    rios.each do |k,r|
+      #pinfo(fmt,pathinfo(r))
+      assert_equal(rinfo[k][0],r.scheme)
+      assert_equal(rinfo[k][1],r.opaque)
+      assert_equal(rinfo[k][2],r.path)
+      assert_equal(rinfo[k][3],r.fspath)
+      assert_equal(rinfo[k][4],r.to_s)
+      assert_equal(rinfo[k][5],r.to_url)
+    end
+  end
+  def test_specialpaths
+    rios,rinfo = mkrios1()
+    check_rios(rios,rinfo)
+  end
+
+  def test_specialpaths_sym
+    rios,rinfo = mkrios_sym()
+    check_rios(rios,rinfo)
+  end
+  def test_specialpaths_modfunc
+    rios,rinfo = mkrios_modfunc()
+    check_rios(rios,rinfo)
+  end
+  def test_specialpaths_classmeth
+    rios,rinfo = mkrios_classmeth()
+    check_rios(rios,rinfo)
+  end
+
+  def mkrios_open()
+    require 'tempfile'
+    stdlib_temppath = ::Tempfile.new('rio').path
+    fnre = "#{@tmppath}(\\.)?\\d+\\.\\d+"
+    rinfo = {
+      ?- => ['stdout',/^$/,nil,nil,/^stdout:$/,/^stdout:$/],
+      ?? => ['file',%r|//#{fnre}|,%r|#{fnre}|,%r|#{fnre}|,/#{fnre}/,/#{fnre}/],
+    }
+    siopq = sprintf("0x%08x",$stdout.object_id)
+    rios = {
+      ?- => rio(?-).print("."),
+      ?? => rio(??).puts("hw"),
+    }
+    [rios,rinfo]
+  end
+  def test_specialpaths_open
+    fmt = "%-12s %-12s %-8s %-8s %-20s %-20s\n"
+    #printf(fmt,'scheme','opaque','path','fspath','to_s','url')
+    rios,rinfo = mkrios_open()
+    rios.each do |k,r|
+      #pinfo(fmt,pathinfo(r))
+      assert_equal(rinfo[k][0],r.scheme)
+      assert_match(rinfo[k][1],r.opaque)
+      assert_match(rinfo[k][4],r.to_s)
+      assert_match(rinfo[k][5],r.to_url)
+    end
+    assert_match(rinfo[??][2],rios[??].path)
+    assert_match(rinfo[??][3],rios[??].fspath)
+  end
+end