wishdev-rio 0.4.3.1

data/test/tc/null.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_null < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+  end
+  def compare_rtn(sym,*args)
+    r1 = rio('/dev/null')
+    r2 = rio(nil)
+    rtn1 = r1.__send__(sym,*args)
+    rtn2 = r2.__send__(sym,*args)
+    assert_equal(rtn1,rtn2)
+  end
+  
+  def compare_raiseeof(sym,*args)
+    r1 = rio('/dev/null')
+    r2 = rio(nil)
+    assert_raise(EOFError) { r1.__send__(sym,*args) }
+    assert_raise(EOFError) { r2.__send__(sym,*args) }
+  end
+  
+  def test_gets() compare_rtn(:gets) end
+  def test_lineno() compare_rtn(:lineno) end
+  def test_lineno_assign() compare_rtn(:lineno=,20) end
+  def test_pos() compare_rtn(:pos) end
+  def test_pos_assign() compare_rtn(:pos=,20) end
+  def test_read() compare_rtn(:read) end
+  def test_readl() compare_rtn(:read,1) end
+  def test_readline() compare_raiseeof(:readline) end
+  def test_readlines() compare_rtn(:readlines) end
+  def test_readchar() compare_raiseeof(:readchar) end
+  
+end

data/test/tc/once.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'tc/testcase'
+require 'rio/tc/copydir'
+require 'rio/tc/rename'
+
+

data/test/tc/overload.rb

@@ -0,0 +1,140 @@
+#!/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_RIO_overload < Test::Unit::TestCase
+  def test_overload
+    qp = RIO.rio('qp')
+    rio(qp,'test_overload').rmtree.mkpath.chdir {
+      line0 = "Line 0\n"
+      src = rio('src').print!(line0)
+
+      rio('src') > rio('dst1')
+      assert_equal(line0,rio('dst1').contents)
+#      $trace_states = true
+      rio('dst2') < rio('src') 
+      $trace_states = false
+      assert_equal(line0,rio('dst2').contents)
+      rio('dst2') << rio('src') 
+      assert_equal(line0+line0,rio('dst2').contents)
+
+      rio('dst3') << rio('src') 
+      assert_equal(line0,rio('dst3').contents)
+      rio('dst3') << rio('src') 
+      assert_equal(line0+line0,rio('dst3').contents)
+
+      rio('dst4') < rio('src') 
+      assert_equal(line0,rio('dst4').contents)
+
+      rio('dst5') < line0
+      assert_equal(line0,rio('dst5').contents)
+      rio('dst5') << line0
+      assert_equal(line0+line0,rio('dst5').contents)
+      
+      rio('dst6') < ::File.new('src','r')
+      assert_equal(line0,rio('dst6').contents)
+      rio('dst6') << ::File.new('src','r')
+      assert_equal(line0+line0,rio('dst6').contents)
+      
+      rio('dst7') < "Line 0\n"
+      assert_equal(line0,rio('dst7').contents)
+      rio('dst7') << "Line 0\n"
+      assert_equal(line0+line0,rio('dst7').contents)
+      
+      rio('dst8').puts!("Zippy DO\n")
+      rio('dst8') < rio('src') 
+      assert_equal(line0,rio('dst8').contents)
+      
+      rio('src') > rio('dst10')
+      assert_equal(line0,rio('dst10').contents)
+      rio('src') >> rio('dst10')
+      assert_equal(line0+line0,rio('dst10').contents)
+      
+      rio('src') > rio('dst1')
+      assert_equal(line0,rio('dst1').contents)
+      
+      rio('src') >> rio('dst1a')
+      rio('src') >> rio('dst1a')
+      assert_equal(line0+line0,rio('dst1a').contents)
+      
+      str = 'Hello World'
+      rio('src') > str
+      assert_equal(line0,str)
+      rio('src') >> str
+      assert_equal(line0+line0,str)
+      
+      fh = ::File.new('dst2','w')
+      rio('src') > fh
+      fh.close
+      assert_equal(line0,rio('dst2').contents)
+      
+      unless $mswin32
+        rio('src.gz').gzip < rio('src')
+        rio('dst3') < rio('src.gz').gzip
+        assert_equal(line0,rio('dst3').contents)
+
+        str = 'Hello World'
+        rio('src.gz').gzip > str
+        assert_equal(line0,str)
+
+        rio('src') > rio('src.gz').gzip 
+        rio('src.gz').gzip > str
+        assert_equal(line0,str)
+        rio('src.gz').gzip >> str
+        assert_equal(line0+line0,str)
+      end
+      
+    }
+
+
+#     dst2 = rio(datadir,'dst2').mkdir
+#     src > dst2
+#     sline = rio(datadir,'src').contents
+#     l2 = rio(datadir,'dst2/src').contents
+#     assert_equal(line0,sline,'a message in a assertion')
+#     assert_equal(line0,l2)
+
+#     # copy directories
+#     sd1 = rio(datadir,'dir1/sd1').rmtree.mkpath
+#     txt = "Hello f1.txt"
+#     sd1.catpath('f1.txt').puts(txt).close
+#     oline = rio(datadir,'dir1/sd1/f1.txt').contents
+
+#     dir2 = rio(datadir,'dir2').rmtree.mkpath
+#     sd1.copy_to(dir2)
+#     nline = rio(datadir,'dir2/sd1/f1.txt').contents
+#     assert_equal(oline,nline)
+    
+#     dir2 = rio(datadir,'dir2').rmtree.mkpath
+#     sd1 > dir2
+#     nline = rio(datadir,'dir2/sd1/f1.txt').contents
+#     assert_equal(oline,nline)
+    
+#     dir2 = rio(datadir,'dir2').rmtree.mkpath
+#     dir2 < rio(datadir,'dir1/sd1')
+#     nline = rio(datadir,'dir2/sd1/f1.txt').contents
+#     assert_equal(oline,nline)
+    
+#     dir2 = rio(datadir,'dir2').rmtree.mkpath
+#     sd1 > dir2.to_s
+#     nline = rio(datadir,'dir2/sd1/f1.txt').contents
+#     assert_equal(oline,nline)
+    
+#     dir2 = rio(datadir,'dir2').rmtree.mkpath
+#     dir2 < rio(datadir,'dir1/sd1').to_s
+#     nline = rio(datadir,'dir2/sd1/f1.txt').contents
+#     assert_equal(oline,nline)
+    
+  end
+end
+__END__
+require 'test/unit/ui/console/testrunner'
+#Test::Unit::UI::Console::TestRunner.run(TC_RIO,Test::Unit::UI::SILENT)
+#Test::Unit::UI::Console::TestRunner.run(TC_RIO,Test::Unit::UI::PROGRESS_ONLY)
+#Test::Unit::UI::Console::TestRunner.run(TC_RIO_copy,Test::Unit::UI::NORMAL)
+Test::Unit::UI::Console::TestRunner.run(TC_RIO_copy,Test::Unit::UI::VERBOSE)

data/test/tc/pa.rb

@@ -0,0 +1,158 @@
+#!/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'
+
+def smap(a) a.map { |el| el.to_s } end
+
+class TC_RIO_pa < Test::Unit::TestCase
+  def test_pa
+    s_dir = ''
+    #$trace_states = true
+    tdir = rio(%w/qp pa/)
+    tdir.rmtree.mkpath.chdir {
+      rio(%w/d0 d00 d000/).mkpath
+      rio(%w/d1 d10 d000/).mkpath
+      rio(%w/d1 d10 d100/).mkpath
+      rio(%w/d1 d11/).mkpath
+      %w[d1/f0.txt d1/d10/f0.txt d1/d10/f1.txt d1/d10/f2.emp f0.txt d1/d10/d000/f100.txt].each do |e|
+        rio(e) << (0..2).map { |n| "L#{n}:#{e}\n" }
+      end
+    }
+    
+    tdir.chdir do
+      ario = rio('d1')
+      exp = ["d1/f0.txt"]
+      assert_equal(exp,smap(ario[/x/]))
+
+      ario = rio('f0.txt')
+      exp = ["L0:f0.txt\n", "L1:f0.txt\n", "L2:f0.txt\n"]
+      assert_equal(exp,smap(ario[/x/]))
+
+      ario = rio('d1')
+      ans = []
+      #$trace_states = true
+      ario.each do |ent|
+        ent.files { |el| ans << el }
+      end
+      exp = ["d1/d10/f0.txt","d1/d10/f1.txt","d1/d10/f2.emp","d1/f0.txt"]
+      assert_equal(exp,smap(ans))
+      ario = rio('d1')
+      ans = []
+      ario.each do |ent|
+        ent.files(/x/) { |el| ans << el }
+      end
+      exp = ["d1/d10/f0.txt", "d1/d10/f1.txt", "d1/f0.txt"]
+      assert_equal(exp,smap(ans))
+
+      ario = rio('d1')
+      ans = ario[/x/]
+      exp = ["d1/f0.txt"]
+      assert_equal(exp,smap(ans))
+
+      ans = []
+      rio('d1').all.files('*.emp').lines(/L2/) { |el| ans << el }
+      exp = ["L2:d1/d10/f2.emp\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = []
+      rio('d1').all.files('*.?x?').lines(/L2/) { |el| ans << el }
+      exp = ["L2:d1/d10/d000/f100.txt\n", "L2:d1/d10/f0.txt\n", "L2:d1/d10/f1.txt\n", "L2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = []
+      rio('d1').all.files('*.?x?').lines(2) { |el| ans << el }
+      exp = ["L2:d1/d10/d000/f100.txt\n", "L2:d1/d10/f0.txt\n", "L2:d1/d10/f1.txt\n", "L2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = []
+
+      rio('d1').all.files('*.?x?').lines(2...3) { |el| ans << el }
+      exp = ["L2:d1/d10/d000/f100.txt\n", "L2:d1/d10/f0.txt\n", "L2:d1/d10/f1.txt\n", "L2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+      
+      ans = rio('d1').all.files('*.?x?').lines(/L1/).to_a
+      exp = ["L1:d1/d10/d000/f100.txt\n", "L1:d1/d10/f0.txt\n", "L1:d1/d10/f1.txt\n", "L1:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files('*.?x?').lines[/L1/]
+      exp = ["L1:d1/d10/d000/f100.txt\n", "L1:d1/d10/f0.txt\n", "L1:d1/d10/f1.txt\n", "L1:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.lines(/L1/).files['*.?x?']
+      exp = ["L1:d1/d10/d000/f100.txt\n", "L1:d1/d10/f0.txt\n", "L1:d1/d10/f1.txt\n", "L1:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files('*.?x?').lines[1]
+      exp = ["L1:d1/d10/d000/f100.txt\n", "L1:d1/d10/f0.txt\n", "L1:d1/d10/f1.txt\n", "L1:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files('*.?x?').lines[1...2]
+      exp = ["L1:d1/d10/d000/f100.txt\n", "L1:d1/d10/f0.txt\n", "L1:d1/d10/f1.txt\n", "L1:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.lines(/L0/).files[/f0/]
+      exp = ["L0:d1/d10/f0.txt\n", "L0:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.lines(/L0/).files[]
+      exp = ["L0:d1/d10/d000/f100.txt\n", "L0:d1/d10/f0.txt\n", "L0:d1/d10/f1.txt\n", "L0:d1/d10/f2.emp\n", "L0:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files(/f0/).lines[/L0/]
+      exp = ["L0:d1/d10/f0.txt\n", "L0:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files(/f0/).lines[]
+      exp = ["L0:d1/d10/f0.txt\n", "L1:d1/d10/f0.txt\n", "L2:d1/d10/f0.txt\n", "L0:d1/f0.txt\n", "L1:d1/f0.txt\n", "L2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.bytes(8).records(0..1).files[/f0/]
+      exp = ["L0:d1/d10/f0.txt\nL1:d1/d10/f0.txt\nL2:d1/d10/f0.txt\n", "L0:d1/f0.txt\nL1:d1/f0.txt\nL2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.bytes(8).files(/f0/).records[0..1]
+      exp = ["L0:d1/d10/f0.txt\nL1:d1/d10/f0.txt\nL2:d1/d10/f0.txt\n", "L0:d1/f0.txt\nL1:d1/f0.txt\nL2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+
+      ans = rio('d1').all.bytes(32).files(/f0/).records[]
+      exp = ["L0:d1/d10/f0.txt\nL1:d1/d10/f0.txt\nL2:d1/d10/f0.txt\n", "L0:d1/f0.txt\nL1:d1/f0.txt\nL2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.bytes(32).files[/f0/]
+      exp = ["L0:d1/d10/f0.txt\nL1:d1/d10/f0.txt\nL2:d1/d10/f0.txt\n", "L0:d1/f0.txt\nL1:d1/f0.txt\nL2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.bytes.files['*.emp']
+      exp = ["L0:d1/d10/f2.emp\nL1:d1/d10/f2.emp\nL2:d1/d10/f2.emp\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files('*.emp').bytes[]
+      exp = ["L0:d1/d10/f2.emp\nL1:d1/d10/f2.emp\nL2:d1/d10/f2.emp\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.lines[]
+      exp = ["L0:d1/d10/d000/f100.txt\n", "L1:d1/d10/d000/f100.txt\n", "L2:d1/d10/d000/f100.txt\n", 
+             "L0:d1/d10/f0.txt\n", "L1:d1/d10/f0.txt\n", "L2:d1/d10/f0.txt\n", 
+             "L0:d1/d10/f1.txt\n", "L1:d1/d10/f1.txt\n", "L2:d1/d10/f1.txt\n", 
+             "L0:d1/d10/f2.emp\n", "L1:d1/d10/f2.emp\n", "L2:d1/d10/f2.emp\n", 
+             "L0:d1/f0.txt\n", "L1:d1/f0.txt\n", "L2:d1/f0.txt\n"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all[]
+      exp = ["d1/d10", "d1/d10/d000", "d1/d10/d000/f100.txt", "d1/d10/d100", 
+             "d1/d10/f0.txt", "d1/d10/f1.txt", "d1/d10/f2.emp", "d1/d11", "d1/f0.txt"]
+      assert_equal(exp,smap(ans))
+
+      ans = rio('d1').all.files('*.emp').lines[]
+      exp = ["L0:d1/d10/f2.emp\n", "L1:d1/d10/f2.emp\n", "L2:d1/d10/f2.emp\n"]
+      assert_equal(exp,smap(ans))
+    end
+  end
+end

data/test/tc/path_parts.rb

@@ -0,0 +1,175 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'tc/testcase'
+require 'pp'
+
+class PathGenerator
+  ROOTS = ['r1','r 1']
+  DIRS = ['d1','d 1']
+  FILES = ['f1','f 1','f1.txt','f 1.txt']
+  UROOTS = ROOTS.map{|z| z.gsub(/ /,'%20')}
+  UDIRS = DIRS.map{|z| z.gsub(/ /,'%20')}
+  UFILES = FILES.map{|z| z.gsub(/ /,'%20')}
+
+  attr_reader :fs_basic_paths,:fs_url_paths,:fs_drive_paths,
+      :fs_unc_paths,:fs_paths,:http_paths,:ftp_paths, :uri_paths,:all_paths
+
+  def initialize()
+    @fs_basic_paths = self.class.fs_basic_paths()
+    @fs_url_paths = self.class.fs_url_paths()
+    @fs_drive_paths = self.class.fs_drive_paths()
+    @fs_unc_paths = self.class.fs_unc_paths()
+    @fs_paths = @fs_basic_paths + @fs_url_paths + @fs_drive_paths + @fs_unc_paths
+    @http_paths = self.class.http_paths()
+    @ftp_paths = self.class.ftp_paths()
+    @uri_paths = @http_paths + @ftp_paths
+
+    @all_paths = @fs_paths + @uri_paths
+  end
+  def self.fs_basic_paths()
+    tops = %w{/}
+    build_paths(tops,ROOTS,DIRS,FILES)
+  end
+  def self.fs_url_paths()
+    #tops = %w{file:/// file:///x:/ file://h/}
+    # tops = %w{file:/// file:///x:/ file://h/}
+    tops = %w{file:/// file://h/}
+    tops << 'file:///x:/' if $mswin32 
+    build_paths(tops,ROOTS,DIRS,FILES)
+  end
+  def self.fs_drive_paths()
+    return [] unless $mswin32
+    tops = %w{x:/}
+    build_paths(tops,ROOTS,DIRS,FILES)
+  end
+  def self.fs_unc_paths()
+    tops = %w{//h/}
+    build_paths(tops,ROOTS,DIRS,FILES)
+  end
+  def self.http_paths()
+    htops = %w{http://h/}
+    build_paths(htops,UROOTS,UDIRS,UFILES)
+  end
+  def self.ftp_paths()
+    ftops = %w{ftp://h/}
+    build_paths(ftops,UROOTS,UDIRS,UFILES)
+  end
+  def self.build_paths(tops,roots,dirs,files)
+    paths = []
+    tops.each { |t|
+      paths << t
+      roots.each{|r| paths << t+r }
+      roots.map{|r| t + r + '/'}.each { |r|
+        paths << r
+        dirs.each{|d| paths << r+d}
+        dirs.map{|d| r+d+'/'}.each{|d|
+          paths << d
+          files.each{|f| paths << d+f}
+          files.map{|f| d+f}.each{|f|
+            paths << f
+          }
+        }
+      }
+    }      
+    paths
+  end
+end
+
+
+class TC_path_parts < Test::RIO::TestCase
+  @@once = false
+  @@exp = nil
+  @@gen = PathGenerator.new
+
+  def self.once
+    @@once = true
+    expfile = RIO.cwd('../../tc/rlparts.ans.yml')
+    @@exp = expfile.yaml.get
+  end
+
+  def setup
+    super
+    self.class.once unless @@once
+  end
+
+  def run_path_tests_exp(paths,sym)
+    paths.each do |pstr|
+      #p pstr
+      r = rio(pstr)
+      assert_equal(@@exp[r.to_s][sym],r.__send__(sym).to_s,"rio('#{pstr}').#{sym} failed")
+    end
+  end
+  def run_path_tests_native(paths,sym,*args)
+    paths.each do |pstr|
+      r = rio(pstr)
+      exp = File.__send__(sym,pstr,*args)
+      ans = r.__send__(sym,*args).to_s
+      #puts "#{sym}[#{r}]: #{exp} <=> #{ans}"
+      assert_equal(exp,ans,"rio('#{pstr}').#{sym} failed")
+    end
+  end
+  def run_path_tests_native_fspath(paths,sym,*args)
+    paths.each do |pstr|
+      r = rio(pstr)
+      fpth = r.fspath
+      assert_equal(File.__send__(sym,fpth,*args),r.__send__(sym,*args).to_s,"rio('#{pstr}').#{sym} failed")
+    end
+  end
+  def test_filename()
+    @@gen.all_paths.each do |pstr|
+      assert_equal(rio(pstr).basename(''),rio(pstr).filename)
+      assert_equal(rio(pstr).noext.basename,rio(pstr).filename)
+    end
+  end
+  def test_uri_dirname
+    run_path_tests_exp(@@gen.uri_paths,:dirname)
+  end
+  def test_uri_basename
+    run_path_tests_exp(@@gen.uri_paths,:basename)
+  end
+
+  def test_fs_dirname
+    run_path_tests_native(@@gen.fs_basic_paths,:dirname)
+    run_path_tests_native(@@gen.fs_drive_paths,:dirname)
+    run_path_tests_exp(@@gen.fs_unc_paths,:dirname)
+  end
+  def test_fs_url_dirname
+    run_path_tests_exp(@@gen.fs_url_paths,:dirname)
+  end
+  def test_fs_url_basename
+    run_path_tests_native_fspath(@@gen.fs_url_paths,:basename,'')
+    run_path_tests_native_fspath(@@gen.fs_url_paths,:basename,'.txt')
+  end
+  def test_fs_basename
+    run_path_tests_native(@@gen.fs_basic_paths,:basename,'')
+    run_path_tests_native(@@gen.fs_drive_paths,:basename,'')
+    run_path_tests_native(@@gen.fs_unc_paths,:basename,'')
+    run_path_tests_native(@@gen.fs_basic_paths,:basename,'.txt')
+    run_path_tests_native(@@gen.fs_drive_paths,:basename,'.txt')
+    run_path_tests_native(@@gen.fs_unc_paths,:basename,'.txt')
+  end
+
+  def test_fs_path
+    run_path_tests_exp(@@gen.fs_paths,:path)
+  end
+  def test_uri_path
+    run_path_tests_exp(@@gen.uri_paths,:path)
+  end
+  def test_fs_fspath
+    run_path_tests_exp(@@gen.fs_paths,:fspath)
+  end
+  def test_uri_fspath
+    run_path_tests_exp(@@gen.uri_paths,:fspath)
+  end
+  def test_fs_urlpath
+    run_path_tests_exp(@@gen.fs_paths,:urlpath)
+  end
+  def test_uri_urlpath
+    run_path_tests_exp(@@gen.uri_paths,:urlpath)
+  end
+
+end