rio 0.4.2 → 0.5.1

data/test/tc/copy.rb

@@ -5,7 +5,8 @@ if $0 == __FILE__
 end
 require 'rio'
 require 'test/unit'
-require 'test/unit/testsuite'
+require 'qpdir'
+#require 'test/unit/testsuite'
 
 #require 'tc_myfirsttests'
 #require 'tc_moretestsbyme'
@@ -14,7 +15,7 @@ require 'test/unit/testsuite'
 class TC_RIO_copy < Test::Unit::TestCase
   def test_copy
     require 'rio'
-    datadir = rio('qp/test_copy').rmtree.mkpath
+    datadir = rio($QPDIR,'test_copy').rmtree.mkpath
     inline = "Source Stuff\n"
     src = rio(datadir,'src')
     src.print(inline)

data/test/tc/copyarray.rb

@@ -131,8 +131,6 @@ class TC_copyarray < Test::Unit::TestCase
 
     out = rio('out').delete!
     assert!(out.exist?)
-    out < rio(@d[1]).all.lines[1]
-    assert_equal([@l[0][1],@l[1][1]] * 2,out[])
 
   end
   def test_copyto_file_array_lines
@@ -152,8 +150,6 @@ class TC_copyarray < Test::Unit::TestCase
 
     out = rio('out').delete!.touch
     assert(out.exist?)
-    out < rio(@d[1]).all.lines[1]
-    assert_equal([@l[0][1],@l[1][1]] * 2,out[])
 
   end
   def test_copyto_nonex

data/test/tc/copydest.rb

@@ -8,10 +8,9 @@ require 'test/unit'
 
 class TC_RIO_copydest < Test::Unit::TestCase
   def test_copydest
-    qp = RIO.rio('qp')
-    rio(qp,'test_copydest').rmtree.mkpath.chdir {
+    rio($QPDIR,'test_copydest').rmtree.mkpath.chdir {
       expary = ["Line0\n","Line1\n","Line2\n"]
-      line = expary.to_s
+      line = expary.join
       src = rio('src').print!(line)
       
       ary = Array.new

data/test/tc/copydir.rb

@@ -156,11 +156,15 @@ class TC_copydir < Test::RIO::TestCase
     assert(dst.file?)
     assert_equal(src,dst.readlines)
   end
+  unless $jruby
   def test_tofile
     dst = rio('dst').delete!.touch
-    exp = ($mswin32 ? Errno::ENOENT : Errno::ENOTDIR)
+    exp = ( ($mswin32 || $mingw32) ? Errno::ENOENT : Errno::ENOTDIR)
+    #exp = Errno::ENOTDIR
+    #exp = Errno::ENOENT
     assert_raise(exp) {
       @d0 > dst
     }
   end
+  end
 end

data/test/tc/copydir2.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 'tc/testcase'
+
+class TC_copydir < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+
+    rio('d0').rmtree.mkpath
+    rio('d0/d2').rmtree.mkpath
+    rio('d0/d3').rmtree.mkpath
+    rio('d0/d4').rmtree.mkpath
+    rio('d0/d2/d3').rmtree.mkpath
+    rio('d0/d2/d5').rmtree.mkpath
+    rio('d0/d3/d6').rmtree.mkpath
+    rio('d1').rmtree.mkpath
+    rio('d1/d8').rmtree.mkpath
+    make_lines_file(1,'d1/f0')
+    make_lines_file(2,'d1/f1')
+    make_lines_file(1,'d0/f0')
+    make_lines_file(2,'d0/f1')
+    make_lines_file(1,'d0/d2/f0')
+    make_lines_file(2,'d0/d2/f1')
+    make_lines_file(1,'d0/d3/d6/f0')
+    make_lines_file(2,'d0/d3/d6/f1')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @d0 = rio('d0/')
+    @d1 = rio('d1/')
+    @d2 = rio('d0/d2/')
+    @f0 = rio('d0/f0')
+    @f1 = rio('d0/f1')
+    @f2 = rio('d0/d2/f2')
+    @f3 = rio('d0/d2/f3')
+  end
+  def assert_skel_equal(exp,d,msg="")
+    exp.each do |ent|
+      next unless ent.dir?
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.dir?
+        assert_skel_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def test_dirs_somefiles
+    dst = rio('dirs_somefiles').delete!
+    src = rio(@d0).files(/0/).dirs
+    #$trace_states = true
+    src > dst
+    $trace_states = false
+    ans = dst.all.map { |e| e.rel(dst) }
+    exp = rio(@d0).all.map { |e| e.rel(@d0) }.select { |e| e !~ /f[^0]$/ }
+    assert_array_equal(exp,ans,"dirs somefiles")
+    
+  end
+end

data/test/tc/create.rb

@@ -5,7 +5,7 @@ if $0 == __FILE__
 end
 require 'rio'
 require 'test/unit'
-require 'test/unit/testsuite'
+#require 'test/unit/testsuite'
 
 class TC_RIO_create < Test::Unit::TestCase
   def rio(*args) RIO.rio(*args) end
@@ -18,10 +18,6 @@ class TC_RIO_create < Test::Unit::TestCase
     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)
@@ -77,12 +73,11 @@ class TC_RIO_create < Test::Unit::TestCase
     assert_kind_of(RIO::Rio,ario)
     assert_equal('/tmp/goofy',ario.to_s)
 
-    require 'rio/uri/file'
-    ario = rio(URI('goofy/f.html'))
+    ario = rio(::Alt::URI.parse('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"))
+    ario = rio(::Alt::URI.parse("file:///tmp/goofy/f.html"))
     assert_kind_of(RIO::Rio,ario)
     assert_equal('/tmp/goofy/f.html',ario.to_s)
 
@@ -94,7 +89,7 @@ class TC_RIO_create < Test::Unit::TestCase
     assert_kind_of(RIO::Rio,ario)
     assert_equal('/tmp/goofy/f.html',ario.to_s)
 
-    u = URI('goofy/f.html')
+    u = ::Alt::URI.parse('goofy/f.html')
 
     ario = rio("file:///tmp/",u)
     assert_kind_of(RIO::Rio,ario)

data/test/tc/csv.rb

@@ -6,57 +6,22 @@ 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]
+require 'tc/csvutil'
+
+class TC_csv < Test::RIO::TestCase
+  include CSV_Util
+
+  @@once = false
+  def self.once
+    @@once = true
   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)
+    @records,@strings,@lines,@string = 
+      create_test_csv_file(@src_name,3, 3, ',',"\n" ,'"', true) 
+    rio(@src_name).puts!(@string)
   end
   def test_nocsv_lines
     rio(@src_name) > rio(@dst_name)
@@ -69,27 +34,28 @@ class TC_csv < Test::Unit::TestCase
     assert_equal(@strings,rio(@dst_name).chomp.readlines)
   end
   def test_csv_lines
-    assert_equal(@string,rio(@dst_name).csv.contents)
+    # $trace_states = true
     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(@string,rio(@dst_name).csv.contents)
+    exp = ($USE_FASTER_CSV ? @records : @lines)
+    assert_equal(exp,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)
+    assert_equal(exp,rio(@dst_name).csv.lines(1..2).readlines)
+    # $trace_states = false
   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_kind_reuse
+#    src = rio(@src_name).csv
+#    mkrio = proc { src }
+#    each_kind_csv(mkrio)
+#
+#  end
   def test_each_break
     each_break
   end
@@ -109,79 +75,37 @@ class TC_csv < Test::Unit::TestCase
     
     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 }
+    rio('src1.csv').each          { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').lines.each    { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').records.each  { |el| assert_kind_of(::String,el); break }
+    rio('src1.csv').rows.each     { |el| assert_kind_of(::String,el); break }
   end
   def each_kind_csv(mkrio)
+    rowsrtn = ($USE_FASTER_CSV ? CSV::Row : Hash)
+    mkrio.call.rows.each         { |el| assert_kind_of(rowsrtn,el); break }
     
+    rowsrtn = ($USE_FASTER_CSV ? CSV::Row : Array)
     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
+    #p @string
     assert_equal(@lines,::File.open('dst.csv').readlines)
     
     rio('dst.csv') < @lines
@@ -196,10 +120,10 @@ class TC_csv < Test::Unit::TestCase
     assert_equal(src_str,dst_str)
 
     rio(?",src_str).csv >  rio(?",dst_str='')
-    assert_equal(@records.to_s,dst_str)
+    assert_equal(@records.map{|ar| ar.to_s}.join,dst_str)
 
     rio(?",dst_str='') < rio(?",src_str).csv
-    assert_equal(@records.to_s,dst_str)
+    assert_equal(@records.map{|ar| ar.to_s}.join,dst_str)
 
     dst = rio(?")
     rio(?",src_str) > dst.csv
@@ -209,18 +133,13 @@ class TC_csv < Test::Unit::TestCase
     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
+    csv_arg = ($USE_FASTER_CSV ? {:col_sep => ';'} : ';')
+    dst = rio(?").csv(csv_arg) < rio(?",src_str).csv
     assert_equal(src_str.gsub(/,/,';'),dst.contents)
-
-    rio(?",src_str).csv > (dst = rio(?").csv(';'))
+    $trace_states = false
+    rio(?",src_str).csv > (dst = rio(?").csv(csv_arg))
     assert_equal(src_str.gsub(/,/,';'),dst.contents)
+    $trace_states = false
 
   end
 end

data/test/tc/csv2.rb

@@ -19,16 +19,44 @@ class TC_csv2 < Test::RIO::TestCase
     super
     @src = rio(?")
     @dst_name = 'dst.csv'
-    @records,@strings,@lines,@string = create_test_csv_data(@src,3, 3, true)
+    @records,@strings,@lines,@string = create_test_csv_data(@src,3, 3, ',', $/, true)
+    if $USE_FASTER_CSV
+      opts = {:headers => true, :return_headers => true}
+      @rows = []
+      ::CSV.parse(@string, opts) do |row|
+        @rows << row
+      end
+    else
+      @rows = []
+      @records.each do |rec|
+        h = {}
+        (0...rec.size).each do |n|
+          h["Col#{n}"] = rec[n]
+        end
+        @rows << h
+      end
+    end
+      
   end
 
+  def test_rows
+    rio('src1.csv') < @src
+
+    rio('src1.csv') > rio('dst.csv')
+    first_row = ($USE_FASTER_CSV ? 1 : 0)
+    assert_equal(@rows[first_row,@rows.size-first_row],rio('dst.csv').csv.rows[])
+    ans = []
+    rio('dst.csv').csv.rows do |row|
+      ans << row
+    end
+    assert_equal(@rows[first_row,@rows.size-first_row],ans)
+  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)
@@ -37,59 +65,15 @@ class TC_csv2 < Test::RIO::TestCase
     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)
+    exp  = ($USE_FASTER_CSV ? @records : @lines)
+    assert_equal(exp,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)
-
-    
+    exp  = ($USE_FASTER_CSV ? @records : @lines)
+    assert_equal(exp,rio('dst.csv').csv.lines(1..2).readlines)
 
   end
   def test_getrec
@@ -97,7 +81,6 @@ class TC_csv2 < Test::RIO::TestCase
     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)
 
@@ -110,8 +93,6 @@ class TC_csv2 < Test::RIO::TestCase
 
     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)
@@ -124,13 +105,13 @@ class TC_csv2 < Test::RIO::TestCase
 
     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)
+    exp = $EXTEND_CSV_RESULTS ? @strings[0] : @records[0].join
+    assert_equal(exp,ary[0].join)
 
     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)
+    exp = $EXTEND_CSV_RESULTS ? @records[0] : @strings[0]+$/
+    assert_equal(exp,recs[0])
     return
   end