rio 0.3.1

data/test/tc/create.rb

@@ -0,0 +1,104 @@
+#!/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_create < Test::Unit::TestCase
+  def rio(*args) RIO.rio(*args) end
+  def rootrio(*args) RIO.root(*args) end
+  def ttdir() RIO.rio('qp').mkpath end
+  def assert_equal_s(a,b) assert_equal(a.to_s,b.to_s) end
+
+  def test_create
+    ario = RIO.root
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/',ario.to_s)
+
+    ario = RIO.cwd
+    assert_kind_of(RIO::Rio,ario)
+    cwd = RIO::RL.fs2url(::Dir.getwd)
+    assert_equal(cwd,ario.to_s)
+
+    ario = RIO.root.join('tmp')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp',ario.to_s)
+
+    tmp = RIO.root('tmp')
+    assert_kind_of(RIO::Rio,tmp)
+    assert_equal('/tmp',tmp.to_s)
+    
+    ario = tmp/'goofy'
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    ario = RIO.rio('/tmp/goofy')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+    
+    ario = RIO.rio(tmp,'goofy')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    ario = RIO.rio(RIO.root,%w/tmp goofy/)
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    ario = RIO.rio(tmp).join('goofy')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    ario = rio('/tmp/goofy')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+    
+    ario = rio(tmp,'goofy')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    ario = rio(RIO.root,%w/tmp goofy/)
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    ario = rio(tmp).join('goofy')
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy',ario.to_s)
+
+    require 'rio/uri/file'
+    ario = rio(URI('goofy/f.html'))
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('goofy/f.html',ario.to_s)
+
+    ario = rio(URI("file:///tmp/goofy/f.html"))
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy/f.html',ario.to_s)
+
+    ario = rio("file:///tmp/goofy/f.html")
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy/f.html',ario.to_s)
+
+    ario = rio("file:///tmp/","goofy/f.html")
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy/f.html',ario.to_s)
+
+    u = URI('goofy/f.html')
+
+    ario = rio("file:///tmp/",u)
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy/f.html',ario.to_s)
+
+    ario = rio("file:///tmp/",rio(u))
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy/f.html',ario.to_s)
+
+    ario = rio("/tmp",rio(u))
+    assert_kind_of(RIO::Rio,ario)
+    assert_equal('/tmp/goofy/f.html',ario.to_s)
+
+
+  end
+
+end

data/test/tc/csv.rb

@@ -0,0 +1,229 @@
+#!/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_csv < Test::Unit::TestCase
+  include RIO_TestCase
+  def records_to_rows(records)
+    n_records = records.size
+    rows = []
+    head = records[0]
+    (1...n_records).each do |n|
+      record = records[n]
+      row = {}
+      (0...record.size).each do |ncol|
+        row[head[ncol]] = row[ncol]
+      end
+      rows << row
+    end
+    rows
+  end
+  def records_to_strings(records)
+    records.map { |values| values.join(',') }
+  end
+  def records_to_string(records)
+    records_to_strings(records).join("\n") + "\n"
+  end
+  def strings_to_string(strings)
+    strings.join("\n") + "\n"
+  end
+  def strings_to_lines(strings)
+    strings.map { |s| s + "\n" }
+  end
+  def create_test_csv_records(n_rows,n_cols,header=true)
+    records = []
+    
+    records << (0...n_cols).map { |n| "Head#{n}" } if header
+    
+    (0...n_rows).each do |nrow|
+      records << (0...n_cols).map { |n| "Dat#{nrow}#{n}" }
+    end
+    records
+  end
+  def create_test_csv_data(fname,n_rows,n_cols,header=true)
+    records = create_test_csv_records(n_rows,n_cols,header)
+    strings = records_to_strings(records)
+    lines = strings_to_lines(strings)
+    string = strings_to_string(strings)
+    rio(fname) < string
+    [records,strings,lines,string]
+  end
+  def setup()
+    super
+    @src_name = 'src1.csv'
+    @dst_name = 'dst.csv'
+    @records,@strings,@lines,@string = create_test_csv_data(@src_name,3, 3, true)
+  end
+  def test_nocsv_lines
+    rio(@src_name) > rio(@dst_name)
+    assert_equal(@string,rio(@dst_name).slurp)
+    assert_equal(@lines,rio(@dst_name)[])
+    assert_equal(@strings,rio(@dst_name).chomp[])
+    assert_equal(@lines,rio(@dst_name).to_a)
+    assert_equal(@strings,rio(@dst_name).chomp.to_a)
+    assert_equal(@lines,rio(@dst_name).readlines)
+    assert_equal(@strings,rio(@dst_name).chomp.readlines)
+  end
+  def test_csv_lines
+    assert_equal(@string,rio(@dst_name).csv.slurp)
+    assert_equal(@records,rio(@dst_name).csv[])
+    assert_equal(@records,rio(@dst_name).csv.chomp[])
+    assert_equal(@lines,rio(@dst_name).csv.lines[])
+    assert_equal(@strings,rio(@dst_name).csv.chomp.lines[])
+    assert_equal(@records,rio(@dst_name).csv.records[])
+    assert_equal(@lines,rio(@dst_name).csv.records.readlines)
+    assert_equal(@lines[1..2],rio(@dst_name).csv.lines[1..2])
+    assert_equal(@lines[1..2],rio(@dst_name).csv.lines(1..2).to_a)
+    assert_equal(@lines,rio(@dst_name).csv.lines(1..2).readlines)
+  end
+  def test_kind_new
+    mkrio = proc { rio(@src_name).csv }
+    each_kind_csv(mkrio)
+  end
+  def test_kind_reuse
+    src = rio(@src_name).csv
+    mkrio = proc { src }
+    each_kind_csv(mkrio)
+
+  end
+  def test_each_break
+    each_break
+  end
+  def test_each_kind
+    each_kind
+  end
+  def each_break()
+    
+    recs2 = create_test_csv_records(2, 2, true)
+    ary = records_to_strings(recs2)
+    rio('src2.csv') < records_to_string(recs2)
+    
+    
+    ario = rio('src2.csv').chomp
+    ario.each { |el| assert_equal(ary[0],el); break }
+    ario.each { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each { |el| assert_equal(ary[0],el); break }
+    ario.each_record { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each { |el| assert_equal(ary[0],el); break }
+    ario.each_row { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each_record { |el| assert_equal(ary[0],el); break }
+    ario.each { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each_record { |el| assert_equal(ary[0],el); break }
+    ario.each_record { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each_record { |el| assert_equal(ary[0],el); break }
+    ario.each_row { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each_row { |el| assert_equal(ary[0],el); break }
+    ario.each { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each_row { |el| assert_equal(ary[0],el); break }
+    ario.each_record { |el| assert_equal(ary[1],el); break }
+    
+    ario = rio('src2.csv').chomp
+    ario.each_row { |el| assert_equal(ary[0],el); break }
+    ario.each_row { |el| assert_equal(ary[1],el); break }
+    
+  end
+  def each_kind()
+    mkrio = proc { rio('src1.csv') }
+    
+    rio('src1.csv').each                 { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').each_record          { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').each_row             { |el| assert_kind_of(::String,el); break }
+    
+    rio('src1.csv').lines.each           { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').lines.each_record    { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').lines.each_row       { |el| assert_kind_of(::String,el); break }
+    
+    rio('src1.csv').records.each         { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').records.each_record  { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').records.each_row     { |el| assert_kind_of(::String,el); break }
+    
+    rio('src1.csv').rows.each            { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').rows.each_record     { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').rows.each_row        { |el| assert_kind_of(::String,el); break }
+  end
+  def each_kind_csv(mkrio)
+    
+    mkrio.call.each         { |el| assert_kind_of(::Array,el); break }
+    mkrio.call.each_record  { |el| assert_kind_of(::Array,el); break }
+    mkrio.call.each_row     { |el| assert_kind_of(::Hash,el); break }
+    
+    mkrio.call.lines.each         { |el| assert_kind_of(::String,el); break }
+    mkrio.call.lines.each_record  { |el| assert_kind_of(::String,el); break }
+    mkrio.call.lines.each_row     { |el| assert_kind_of(::Hash,el); break }
+    
+    mkrio.call.records.each         { |el| assert_kind_of(::Array,el); break }
+    mkrio.call.records.each_record  { |el| assert_kind_of(::Array,el); break }
+    mkrio.call.records.each_row     { |el| assert_kind_of(::Hash,el); break }
+    
+    mkrio.call.rows.each         { |el| assert_kind_of(::Hash,el); break }
+    mkrio.call.rows.each_record  { |el| assert_kind_of(::Hash,el); break }
+    mkrio.call.rows.each_row     { |el| assert_kind_of(::Hash,el); break }
+  end
+  def test_copy
+    rio('dst.csv') < @string
+    assert_equal(@lines,::File.open('dst.csv').readlines)
+    
+    rio('dst.csv').csv < @string
+    assert_equal(@lines,::File.open('dst.csv').readlines)
+    
+    rio('dst.csv') < @lines
+    assert_equal(@lines,::File.open('dst.csv').readlines)
+    
+    rio('dst.csv').csv < @records
+    assert_equal(@lines,::File.open('dst.csv').readlines)
+
+    src_str = @string.dup
+
+    rio(?$,src_str) >  rio(?$,dst_str='')
+    assert_equal(src_str,dst_str)
+
+    rio(?$,src_str).csv >  rio(?$,dst_str='')
+    assert_equal(@records.to_s,dst_str)
+
+    rio(?$,dst_str='') < rio(?$,src_str).csv
+    assert_equal(@records.to_s,dst_str)
+
+    dst = rio(?$)
+    rio(?$,src_str) > dst.csv
+    assert_equal(@records,dst[])
+
+    dst = rio(?$)
+    dst.csv < rio(?$,src_str)
+    assert_equal(@records,dst[])
+
+    dst = rio(?$)
+    rio(?$,src_str) > dst.csv
+    assert_equal(@records,dst[])
+
+    dst = rio(?$).csv < rio(?$,src_str)
+    assert_equal(@records,dst[])
+
+    dst = rio(?$).csv(';') < rio(?$,src_str).csv
+    assert_equal(src_str.gsub(/,/,';'),dst.contents)
+
+    rio(?$,src_str).csv > (dst = rio(?$).csv(';'))
+    assert_equal(src_str.gsub(/,/,';'),dst.contents)
+
+  end
+end

data/test/tc/dir.rb

@@ -0,0 +1,79 @@
+#!/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_dir < Test::Unit::TestCase
+  include RIO_TestCase
+  def setup()
+    super
+    rio('a').rmtree.mkpath
+    rio('a/d').mkpath
+    rio('a/f').touch
+    @ents = %w[. .. d f]
+    @rents = @ents.map { |ds| rio(ds) }
+  end
+  def test_read
+    d = rio('a')
+    ans = []
+    while ent = d.read
+      ans << ent
+    end
+    assert_equal(@rents,ans)
+    assert(d.closed?)
+  end
+  def test_rewind
+    d = rio('a').nocloseoneof
+    ans = []
+    while ent = d.read
+      ans << ent
+    end
+    assert_equal(@rents,ans)
+    assert!(d.closed?)
+    d.rewind
+    while ent = d.read
+      ans << ent
+    end
+    assert_equal(@rents+@rents,ans)
+    d.close
+  end
+  def test_seek
+    d = rio('a').nocloseoneof
+    ans = []
+    poss = {}
+    while true
+      ps = d.tell
+      ent = d.read
+      break if ent.nil?
+      poss[ent] = ps
+    end
+    poss.each do |e,ps|
+      ent = d.seek(ps).read
+      assert_equal(e,ent)
+    end
+    d.close
+  end
+  def test_pos
+    d = rio('a').nocloseoneof
+    ans = []
+    poss = {}
+    while true
+      ps = d.pos
+      ent = d.read
+      break if ent.nil?
+      poss[ent] = ps
+    end
+    poss.each do |e,ps|
+      d.pos = ps
+      ent = d.read
+      assert_equal(e,ent)
+    end
+    d.close
+  end
+end

data/test/tc/dirautoclose.rb

@@ -0,0 +1,70 @@
+#!/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_dirss < Test::Unit::TestCase
+  include RIO_TestCase
+  def setup()
+    super
+    unless @once
+      @once = true
+      @l = []; @f = []; @d = []
+      @d[0] = rio('a').rmtree.mkpath
+      @d[1] = rio('b').rmtree.mkpath
+      #$trace_states = false
+      #$trace_states = true
+      @l[0],@f[0] = lines_file(3,'a/f0')
+      @l[1],@f[1] = lines_file(2,'a/f1')
+      @d[1] < @d[0]
+      @d[1] < @d[0].files[]
+    end
+  end
+  def test_rename_add_ext_check_
+#  p 'test_copyto_dir'
+    assert_equal(@l[0],rio(@d[1],@f[0].basename).lines[])
+    assert_equal(@l[1],rio(@d[1],@f[1].basename).lines[])
+    rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    indir = rio('tdir')
+    #indir = @d[1]
+    $trace_states = true
+    p indir.map(&:to_s)
+    ary = indir[]
+    #p ary.map(&:to_s)
+    p indir,indir.ioh
+    newext = '.txt'
+    indir.files.rename.each { |ent|
+      ent.extname = newext
+    }
+    $trace_states = false
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename.to_s + newext).lines[])
+  end
+  def atest_rename_add_ext_check_
+#  p 'test_copyto_dir'
+    assert_equal(@l[0],rio(@d[1],@f[0].basename).lines[])
+    assert_equal(@l[1],rio(@d[1],@f[1].basename).lines[])
+    rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    indir = rio('tdir')
+    #indir = @d[1]
+    $trace_states = true
+    p indir.map(&:to_s)
+    ary = indir[]
+    #p ary.map(&:to_s)
+    p indir,indir.ioh
+    newext = '.txt'
+    indir.files.rename.each { |ent|
+      ent.extname = newext
+    }
+    $trace_states = false
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename.to_s + newext).lines[])
+  end
+end