rio 0.3.8 → 0.3.9

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

data/test/tc/programs_util.rb

@@ -15,9 +15,9 @@ module Test
         'list_dir'    => "ruby #{TEST_BIN_DIR}/list_dir.rb",
       }
       PROG = {
-        'count_lines' => XPROGS['count_lines'],
-        'find_lines'  => XPROGS['find_lines'],
-        'list_dir'    => XPROGS['list_dir'],
+        'count_lines' => ($mswin32 ? RPROGS['count_lines'] : XPROGS['count_lines']),
+        'find_lines' => ($mswin32 ? RPROGS['find_lines'] : XPROGS['find_lines']),
+        'list_dir' => ($mswin32 ? RPROGS['list_dir'] : XPROGS['list_dir']),
       }
     end
   end

data/test/tc/rename.rb

@@ -33,10 +33,9 @@ class TC_rename < Test::RIO::TestCase
   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') + '.txt' }
-
+    expf = oldf.map { |f| f.sub(/f/,'q') }
     indir.rename.files do |ent|
-      nname = ent.filename.to_s.sub(/f/,'q') + '.txt'
+      nname = ent.filename.to_s.sub(/f/,'q')
       ent.filename = nname
     end
     assert_array_equal(expf,rio('tdir').files[])
@@ -45,10 +44,10 @@ class TC_rename < Test::RIO::TestCase
   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') + '.txt' }
+    expf = oldf.map { |f| f.sub(/f/,'q') }
 
     indir.rename.files do |ent|
-      ent.filename = ent.filename.sub(/f/,'q') + '.txt'
+      ent.filename = ent.filename.sub(/f/,'q')
     end
     assert_array_equal(expf,rio('tdir').files[])
 

data/test/tc/riorl.rb

@@ -150,10 +150,12 @@ class TC_riorl < Test::RIO::TestCase
   end
 
   def mkrios_open()
+    require 'tempfile'
+    stdlib_temppath = ::Tempfile.new('rio').path
+    fnre = "#{@tmppath}(\\.)?\\d+\\.\\d+"
     rinfo = {
       ?- => ['stdout',/^$/,nil,nil,/^stdout:$/,/^stdout:$/],
-      ?? => ['file',%r|//#{@tmppath}\d+\.\d+|,%r|#{@tmppath}\d+\.\d+|,%r|#{@tmppath}\d+\.\d+|,
-             /#{@tmppath}\d+\.\d+/,/#{@tmppath}\d+\.\d+/],
+      ?? => ['file',%r|//#{fnre}|,%r|#{fnre}|,%r|#{fnre}|,/#{fnre}/,/#{fnre}/],
     }
     siopq = sprintf("0x%08x",$stdout.object_id)
     rios = {
@@ -169,11 +171,11 @@ class TC_riorl < Test::RIO::TestCase
     rios.each do |k,r|
       #pinfo(fmt,pathinfo(r))
       assert_equal(rinfo[k][0],r.scheme)
-      assert(r.opaque =~ rinfo[k][1])
-      assert(r.to_s =~ rinfo[k][4])
-      assert(r.to_url =~ rinfo[k][5])
+      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(rinfo[??][2] =~ rios[??].path)
-    assert(rinfo[??][3] =~ rios[??].fspath)
+    assert_match(rinfo[??][2],rios[??].path)
+    assert_match(rinfo[??][3],rios[??].fspath)
   end
 end

data/test/tc/skip.rb

@@ -14,8 +14,8 @@ class TC_skip < Test::RIO::TestCase
     rio('d0').rmtree.mkpath.chdir {
       rio('f1') < (0..1).map { |i| "L#{i}:d0/f1\n" }
       rio('f2') < (0..1).map { |i| "L#{i}:d0/f2\n" }
-      rio('g1') < (0..1).map { |i| "L#{i}:d0/g1\n" }
-      rio('g2') < (0..1).map { |i| "L#{i}:d0/g2\n" }
+      rio('g1') < (0..20).map { |i| "L#{i}:d0/g1\n" }
+      rio('g2') < (0..20).map { |i| "L#{i}:d0/g2\n" }
       if $supports_symlink
         rio('x1').symlink('n1')
         rio('x2').symlink('n2')
@@ -30,28 +30,57 @@ class TC_skip < Test::RIO::TestCase
     super
     self.class.once unless @@once
     @d0 = rio('d0')
+    @g1 = @d0/'g1'
+    @g2 = @d0/'g2'
   end
 
-  def test_prefix_files
+  def test_ent_prefix_files
     exprio = rio(@d0).skipfiles(/1/)
     ansrio = rio(@d0).skip.files(/1/)
     assert_equal(smap(exprio[]),smap(ansrio[]))
   end
-  def test_prefix_dirs
+  def test_ent_prefix_dirs
     exprio = rio(@d0).skipdirs(/1/)
     ansrio = rio(@d0).skip.dirs(/1/)
     assert_equal(exprio[],ansrio[])
   end
-  def test_prefix_entries
+  def test_ent_prefix_entries
     exprio = rio(@d0).skipentries(/1/)
     ansrio = rio(@d0).skip.entries(/1/)
     assert_equal(exprio[],ansrio[])
   end
-  def test_prefix_alone
+  def test_ent_alone
     exprio = rio(@d0).skipentries(/1/)
     ansrio = rio(@d0).skip(/1/)
     assert_equal(exprio[],ansrio[])
   end
+  def test_ent_alone_a
+    exp = rio(@d0).skipentries[/1/]
+    ans = rio(@d0).skip[/1/]
+    assert_equal(exp,ans)
+  end
+  def test_ent_postfix_a
+    exp = rio(@d0).files(/1/).skipfiles[:symlink?]
+    ans = rio(@d0).files(/1/).skip[:symlink?]
+    
+    assert_equal(exp,ans)
+  end
+  def test_rec_prefix_a
+    exp = rio(@g2).skiplines[/1/]
+    ans = rio(@g2).skip.lines[/1/]
+    
+    assert_equal(exp,ans)
+  end
+  def test_rec_postfix_a
+    exp = rio(@g1).lines[/2/]
+    #p exp
+    exp = rio(@g1).records(/2/).skip[/L2/]
+    #p exp
+#    ans = rio(@g1).lines(/2/).skip[0..5]
+#    p ans
+    
+#    assert_equal(exp,ans)
+  end
   def test_prefix_atend
 #    exprio = rio(@d0).skipentries(/1/)
     ansrio = rio(@d0).skip[]

data/test/tc/skiplines.rb

@@ -9,20 +9,49 @@ require 'tc/testcase'
 
 class TC_skiplines < Test::RIO::TestCase
   @@once = false
-  N_LINES = 4
+  N_LINES = 25
   def self.once
     @@once = true
-    rio('f1') < (0...N_LINES).map { |i| "L#{i}:f1\n" }
-    rio('f2') < (0...N_LINES).map { |i| "L#{i}:f2\n" }
-    rio('g1') < (0...N_LINES).map { |i| "L#{i}:g1\n" }
-    rio('g2') < (0...N_LINES).map { |i| "L#{i}:g2\n" }
+    #rio('f1') < (0...N_LINES).map { |i| "L#{i}:f1" + $/ }
+    rio('f2') < (0...N_LINES).map { |i| "L#{i}:f2" + $/ }
+    #rio('g1') < (0...N_LINES).map { |i| "L#{i}:g1" + $/ }
+    #rio('g2') < (0...N_LINES).map { |i| "L#{i}:g2" + $/ }
   end
   def setup
     super
     self.class.once unless @@once
     
+    @lines = {}
+    #%w[f1 f2 g1 g2].each do |fname|
+    %w[f2].each do |fname|
+      @lines[fname] = rio(fname).to_a
+    end
   end
 
+  def test_basic
+    fname = 'f2'
+
+    re = /1/
+    exp = @lines[fname].reject{ |l| l =~ re }
+
+    ans = []
+    rio(fname).skiplines(re) { |l| ans << l }
+    assert_equal(exp,ans,"skiplines using #each with regular expression")
+    ans = rio(fname).skiplines[re]
+    assert_equal(exp,ans,"skiplines using array operator with regular expression")
+
+    rng = (2..9)
+
+    exp = @lines[fname][0..rng.first-1] + @lines[fname][rng.last+1...N_LINES]
+
+    ans = []
+    rio(fname).skiplines(rng) { |l| ans << l }
+    assert_equal(exp,ans,"skiplines using #each with line range")
+    ans = rio(fname).skiplines[rng]
+    assert_equal(exp,ans,"skiplines using array operator with line range")
+    
+
+  end
   def test_prefix_lines
 #    exprio = rio(@d0).skipfiles(/1/)
 #    ansrio = rio(@d0).skip.files(/1/)

data/test/tc/split.rb

@@ -16,55 +16,13 @@ class TC_split < Test::RIO::TestCase
     super
     self.class.once unless @@once
   end
-  def test_basic
-    r = rio('b/c/d')
-    ary = r.split
-    assert_equal([rio('b'),rio('c'),rio('d')],ary)
-    assert_equal(r,ary.to_rio)
-  end
-  def test_abs_ne
-    r = rio('/a/b/c/d')
-    ary = r.split
-    assert_equal([rio('/'),rio('a'),rio('b'),rio('c'),rio('d')],ary)
-    assert_equal(r,ary.to_rio)
-    assert_equal(rio('d'),ary[-1])
-    assert_equal(r,ary[-1].abs)
-  end
-
-  def test_abs_drive
-    r = rio('q:/a/b')
-    ary = r.split
-    exp = [rio('q:/'),rio('a'),rio('b')]
-    assert_equal(exp,ary)
-    assert_equal(r,ary.to_rio)
-    assert_equal(rio('b'),ary[-1])
-    assert_equal(r,ary[-1].abs)
-  end
-  def test_abs_host
-    r = rio('//ahost/a/b/c')
-    ary = r.split
-    exp = [rio('file://ahost/'),rio('a'),rio('b'),rio('c')]
-    assert_equal(exp,ary)
-    assert_equal(r,ary.to_rio)
-    assert_equal(rio('c'),ary[-1])
-    assert_equal(r,ary[-1].abs)
-  end
-  def test_abs_url
-    r = rio('file://ahost/a/b/c')
-    ary = r.split
-    exp = [rio('file://ahost/'),rio('a'),rio('b'),rio('c')]
-    assert_equal(exp,ary)
-    assert_equal(r,ary.to_rio)
-    assert_equal(rio('c'),ary[-1])
-    assert_equal(r,ary[-1].abs)
-  end
-  def test_rel
-    r = rio('a/b/c')
-    ary = r.split
-    exp = [rio('a'),rio('b'),rio('c')]
-    assert_equal(exp,ary)
-    assert_equal(r,ary.to_rio)
-    assert_equal(rio('c'),ary[-1])
-    assert_equal(r.abs,ary[-1].abs)
+  def test_type
+    rtn = rio('a/b/c').split
+    assert_kind_of(::Array,rtn)
+    for el in rtn
+      assert_kind_of(RIO::Rio,el)
+    end
+    rtn = rio('hw.txt')
+    assert_kind_of(RIO::Rio,rtn)
   end
 end

data/test/tc/splitlines.rb

@@ -0,0 +1,65 @@
+#!/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_splitlines < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+    @str = "a,b,c,d\n"
+    @infile = rio('infile') < @str * 3
+  end
+  def test_get
+    ans = rio(@infile).split(',').get
+    exp = @str.split(',')
+    assert_equal(exp,ans)
+    ans = rio(@infile).chomp.split(',').get
+    exp = @str.chop
+    exp = exp.split(',')
+    assert(exp,ans)
+  end
+  def test_each
+    exp = @str.chomp.split(',')
+    @infile.chomp.split(',') { |ary|
+      assert_equal(exp,ary)
+    }
+  end
+  def test_copy_array_in
+    expstr = @str.chomp.split(',').join(':')
+    exp = rio(?").puts(expstr).puts(expstr).puts!(expstr)
+    aoa = rio(@infile).split(',')[]
+    rio('ans').split(':') < aoa
+    ans = rio('ans')
+    assert_equal(exp.chomp[],ans.chomp[])
+  end
+  def test_copy_array_out
+    expary = @str.chomp.split(',')
+    exp = [expary,expary,expary]
+    aoa = []
+    rio(@infile).chomp.split(',') > aoa
+    assert_equal(exp,aoa)
+  end
+  def test_copy_left
+    expstr = @str.chomp.split(',').join(':')
+    exp = rio(?").puts(expstr).puts(expstr).puts!(expstr)
+    rio('ans').split(':') < rio(@infile).split(',')
+    ans = rio('ans')
+    assert_equal(exp.chomp[],ans.chomp[])
+  end
+  def test_copy_right
+    expstr = @str.chomp.split(',').join(':')
+    exp = rio(?").puts(expstr).puts(expstr).puts!(expstr)
+    rio(@infile).split(',') > rio('ans').split(':')
+    ans = rio('ans')
+    assert_equal(exp.chomp[],ans.chomp[])
+  end
+end