wishdev-rio 0.4.3.1

data/test/tc/copysymlink.rb

@@ -0,0 +1,39 @@
+#!/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_copysymlink < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('afile').touch.symlink('alink')
+    rio('d0').rmtree.mkpath
+    rio('d0/afile').touch.symlink('d0/alink')
+    rio('d1').rmtree.mkpath
+    rio('d0/afile').touch.symlink('d1/alink')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @d0 = rio('d0/')
+    @d1 = rio('d1/')
+  end
+  def test_basic
+    dst = rio('dst').delete!.mkpath
+    dst < @d0
+    
+    assert_dirs_equal(@d0,rio(dst,@d0.filename),"basic copy")
+  end
+  def test_cross_copy
+    dst = rio('dst2').delete!.mkpath
+    dst < @d1
+    
+    assert_dirs_equal(@d1,rio(dst,@d1.filename),"basic copy")
+  end
+end

data/test/tc/create.rb

@@ -0,0 +1,114 @@
+#!/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.urlpath)
+
+    ario = RIO.cwd
+    assert_kind_of(RIO::Rio,ario)
+    cwd = ::Dir.getwd
+    assert_equal("#{cwd}",ario.path)
+
+    ario = RIO.cwd
+    assert_kind_of(RIO::Rio,ario)
+    cwd = ::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,226 @@
+#!/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_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).contents)
+    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.contents)
+    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/csv2.rb

@@ -0,0 +1,138 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+require 'tc/csvutil'
+
+class TC_csv2 < Test::RIO::TestCase
+  include CSV_Util
+
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup()
+    super
+    @src = rio(?")
+    @dst_name = 'dst.csv'
+    @records,@strings,@lines,@string = create_test_csv_data(@src,3, 3, true)
+  end
+
+  def test_read
+    rio('src1.csv') < @src
+
+
+    rio('src1.csv') > rio('dst.csv')
+    assert_equal(@string,rio('dst.csv').contents)
+    assert_equal(@string,rio('dst.csv').csv.contents)
+    assert_equal(@lines,rio('dst.csv')[])
+    assert_equal(@strings,rio('dst.csv').chomp[])
+    assert_equal(@lines,rio('dst.csv').to_a)
+    assert_equal(@strings,rio('dst.csv').chomp.to_a)
+    assert_equal(@lines,rio('dst.csv').readlines)
+    assert_equal(@strings,rio('dst.csv').chomp.readlines)
+
+    assert_equal(@records,rio('dst.csv').csv[])
+    assert_equal(@records,rio('dst.csv').csv.chomp[])
+    assert_equal(@lines,rio('dst.csv').csv.lines[])
+    assert_equal(@strings,rio('dst.csv').csv.chomp.lines[])
+    assert_equal(@records,rio('dst.csv').csv.records[])
+    assert_equal(@lines,rio('dst.csv').csv.records.readlines)
+    assert_equal(@lines[1..2],rio('dst.csv').csv.lines[1..2])
+    assert_equal(@lines[1..2],rio('dst.csv').csv.lines(1..2).to_a)
+    assert_equal(@lines,rio('dst.csv').csv.lines(1..2).readlines)
+
+    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
+  def test_getrec
+
+    rio('src1.csv') < @src
+
+    assert_equal(@string,rio('src1.csv').contents)
+    assert_equal(@string,rio('src1.csv').csv.contents)
+    assert_equal(@lines[0],rio('src1.csv').getrec)
+    assert_equal(@strings[0],rio('src1.csv').chomp.getrec)
+
+    assert_equal(@lines[1],rio('src1.csv').lines(1).getrec)
+    assert_equal(@lines[1],rio('src1.csv').records(1).getrec)
+    assert_equal(@lines[1],rio('src1.csv').rows(1).getrec)
+
+    assert_equal(@records[1],rio('src1.csv').csv.lines(1).getrec)
+    assert_equal(@records[1],rio('src1.csv').csv.records(1).getrec)
+
+    assert_equal(@records[8000],rio('src1.csv').csv.records(8000).getrec)
+
+    assert_equal(@string[0,23],rio('src1.csv').bytes(23).getrec)
+
+    rec_ary = @records[0]
+    rec_rio = rio('src1.csv').csv.getrec
+    assert_kind_of(::Array,rec_rio)
+    exp = $EXTEND_CSV_RESULTS ? @strings[0] : @records[0].to_s
+    assert_equal(exp,rec_rio.to_s)
+
+    rec_rio = rio('src1.csv').csv.lines.getrec
+    assert_kind_of(::Array,rec_rio)
+    assert_equal(@records[0],rec_rio.to_a)
+
+    ary = rio('src1.csv').csv[]
+    assert_kind_of(::Array,ary[0])
+    exp = $EXTEND_CSV_RESULTS ? @strings[0] : @records[0].to_s
+    assert_equal(exp,ary[0].to_s)
+
+    recs = rio('src1.csv').csv.lines[]
+    assert_kind_of(::String,recs[0])
+    exp = $EXTEND_CSV_RESULTS ? @records[0] : [@strings[0]+$/]
+    assert_equal(exp,recs[0].to_a)
+    return
+  end
+
+
+end