rio 0.3.1

data/test/tc/copydest.rb

@@ -0,0 +1,50 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'test/unit'
+
+class TC_RIO_copydest < Test::Unit::TestCase
+  def test_copydest
+    qp = RIO.rio('qp')
+    rio(qp,'test_copydest').rmtree.mkpath.chdir {
+      expary = ["Line0\n","Line1\n","Line2\n"]
+      line = expary.to_s
+      src = rio('src').print!(line)
+      
+      ary = Array.new
+      $trace_states = false
+      rio('src') > ary
+      $trace_states = false
+      assert_equal(expary,ary)
+
+      rio('src') > ary
+      assert_equal(expary,ary)
+      rio('src') >> ary
+      assert_equal(expary+expary,ary)
+      
+      a0 = ["Zippy0\n"]
+      rio('dst0') < a0
+      assert_equal(a0,rio('dst0').to_a)
+      
+      a1 = ["Zippy1\n"]
+      rio('dst0') << a1
+      assert_equal(a0+a1,rio('dst0').to_a)
+      a2 = a0 + a1 + [ rio('src') ]
+      rio('dst2') < a2
+      assert_equal(a0+a1+expary,rio('dst2').to_a)
+      a3 = [ "Lastline\n" ]
+      rio('dst2') << a3
+      assert_equal(a0+a1+expary+a3,rio('dst2').to_a)
+      
+      lA,lT,lZ = "lineA\n","ALineOfText\n","lineZ\n"
+      
+      rio('src1').puts!(lT)
+      rio('src1') < [lT]
+      assert_equal([lT],rio('src1').to_a)
+      
+    }
+  end
+end

data/test/tc/copydir.rb

@@ -0,0 +1,192 @@
+#!/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_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_dirs_equal(exp,d,msg="")
+    exp.each do |ent|
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.file?
+        assert(ds.file?,"entry is a file")
+        assert_equal(ent[],ds[],"file has same contents")
+      when ent.dir?
+        assert_dirs_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def assert_rios_equal(exp,ans,msg="")
+    case
+    when exp.file?
+      assert(ans.file?,"entry is a file")
+      assert_equal(exp.readlines,ans.readlines,"file has same contents")
+    when exp.dir?
+      assert(ans.dir?,"entry is a dir")
+      assert_dirs_equal(exp,ans,"directories are the same")
+    end
+  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_basic
+    dst = rio('dst').delete!.mkpath
+    dst < @d0
+    
+    assert_dirs_equal(@d0,rio(dst,@d0.filename),"basic copy")
+  end
+  def test_dirs_only
+    dst = rio('dirs_only').delete!.mkpath
+    dst < @d0.dirs
+    assert_skel_equal(@d0,rio(dst,@d0.filename),"copy dirs only")
+  end
+  def test_files_only
+    dst = rio('files_only').delete!.mkpath
+    src = rio(@d0).files
+    dst < src
+    exp = @d0.files[]
+    dd = rio(dst,@d0.filename)
+    ans = dd.map { |e| e.rel(dst) }
+    assert_array_equal(exp,ans,"copy files only")
+  end
+  def test_files_dirs
+    dst = rio('files_dirs').delete!.mkpath
+    src = rio(@d0).files.dirs
+    dst < src
+    assert_dirs_equal(@d0,rio(dst,@d0.filename),"copy files dirs")
+  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
+  def test_somedirs_somefiles
+    dst = rio('somedirs_somefiles').delete!
+    src = rio(@d0).files(/0/).dirs('d[36]')
+    src > dst
+    ans =  smap(dst.all[].map { |e| e.rel(dst) })
+    exp = %w[d3 d3/d6 d3/d6/f0 f0]
+    assert_array_equal(exp,ans)
+  end
+  def test_nonex_ri
+    dst = rio('nonex_ri').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+    src > dst
+    assert_dirs_equal(src,dst,"nonex ri")
+  end
+  def test_nonex_le
+    dst = rio('nonex_le').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+    dst < src
+    assert_dirs_equal(src,dst,"nonex le")
+  end
+  def test_files_a_dir
+    dst = rio('files_a_di').delete!.mkpath
+    dst < @d0.files[]
+    assert_array_equal(%w[f0 f1],dst.map { |el| el.rel(dst) })
+  end
+  def test_files_a_file
+    dst = rio('files_a_fi').delete!.touch
+    dst < @d0.files[]
+    exp = %w[f0 f1].inject([]) { |lines,f| lines + rio(@d0,f).readlines }
+    assert_equal(exp,dst.readlines)
+  end
+  def test_files_a_nonex
+    dst = rio('files_a_nonex').delete!
+    src = @d0[]
+    assert_kind_of(::Array,src)
+    dst < src
+    assert(dst.dir?)
+    assert_equal(smap(src.map { |el| el.rel(@d0) }),smap(dst.map { |el| el.rel(dst) }))
+    src.each do |el|
+      assert_rios_equal(el,rio(dst,el.filename))
+    end
+    assert_rios_equal(@d0,dst)
+  end
+  def test_files_a_nonex_files
+    dst = rio('files_a_nonex_files').delete!
+    src = @d0.files[]
+    assert_kind_of(::Array,src)
+    dst < src
+    assert(dst.dir?)
+    assert_equal(smap(src.map { |el| el.rel(@d0) }),smap(dst.map { |el| el.rel(dst) }))
+    src.each do |el|
+      assert_rios_equal(el,rio(dst,el.filename))
+    end
+#    assert_dirs_equal(src,dst,"array of files to nonex")
+  end
+  def test_files_a_nonex_lines
+    dst = rio('files_a_nonex_l').delete!
+    src = @d0.lines[]
+    assert_kind_of(::Array,src)
+    dst < src
+    assert(dst.file?)
+    assert_equal(src,dst.readlines)
+  end
+  def test_tofile
+    dst = rio('dst').delete!.touch
+    assert_raise(Errno::ENOTDIR) {
+      @d0 > dst
+    }
+  end
+end

data/test/tc/copydirlines.rb

@@ -0,0 +1,124 @@
+#!/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_copydirlines < 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(3,'d1/f0')
+    make_lines_file(2,'d1/f1')
+    make_lines_file(3,'d0/f0')
+    make_lines_file(2,'d0/f1')
+    make_lines_file(3,'d0/d2/f0')
+    make_lines_file(2,'d0/d2/f1')
+    make_lines_file(3,'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_dirs_equal(exp,d,msg="")
+    exp.each do |ent|
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.file?
+        assert(ds.file?,"entry is a file")
+        assert_equal(ent[],ds[],"file has same contents")
+      when ent.dir?
+        assert_dirs_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def assert_rios_equal(exp,ans,msg="")
+    case
+    when exp.file?
+      assert(ans.file?,"entry is a file")
+      assert_equal(exp.readlines,ans.readlines,"file has same contents")
+    when exp.dir?
+      assert(ans.dir?,"entry is a dir")
+      assert_dirs_equal(exp,ans,"directories are the same")
+    end
+  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 ztest_basic
+    dst = rio('dst').delete!.mkpath
+    dst < @d0
+    
+    assert_dirs_equal(@d0,rio(dst,@d0.filename),"basic copy")
+  end
+  def test_files
+    dst = rio('files').delete!.mkdir
+    src = rio(@d1).files.lines(0)
+    #$trace_states = true
+    src > dst
+    src.dup.files.each do |file|
+      assert_equal(file[0],rio(dst,file).to_a)
+    end
+  end
+  def test_files2
+    dst = rio('files').delete!.mkdir
+    src = rio(@d1).files.lines(0)
+    #$trace_states = true
+    dst < src
+    src.dup.files.each do |file|
+      assert_equal(file[0],rio(dst,file).to_a)
+    end
+  end
+  def test_array
+    src = rio(@d1).files.lines
+    exp = src.to_a
+    dst = []
+    src > dst
+    assert_equal(exp,dst)
+    src >> dst
+    assert_equal(exp+exp,dst)
+  end
+  def ztest_somedirs_somefiles
+    dst = rio('somedirs_somefiles').delete!
+    src = rio(@d0).files(/0/).dirs('d[36]')
+    src > dst
+    ans =  smap(dst.all[].map { |e| e.rel(dst) })
+    exp = %w[d3 d3/d6 d3/d6/f0 f0]
+    assert_array_equal(exp,ans)
+  end
+end

data/test/tc/copylines.rb

@@ -0,0 +1,40 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'test/unit'
+class TC_RIO_copylines < Test::Unit::TestCase
+  def test_copylines
+    qp = RIO.rio('qp')
+    rio(qp,'test_copylines').rmtree.mkpath.chdir {
+      str = 'peter piper picked a peck of pickled peppers'
+      words = str.split(/\s+/)
+      line = words.map { |w| w+"\n" }.join('')
+      src = rio('src').print!(line)
+      
+      #$trace_states = true
+      out = rio('$')
+      rio('src').chomp.lines(/^[^p]/) > out
+      out.close
+      $trace_states = false
+      assert_equal('aof',out.contents)
+      
+      out < rio('src').lines(/^[^p]/)
+      assert_equal("a\nof\n",out.contents)
+      
+      aout = Array.new
+      rio('src').chomp.lines(1,4..6) > aout
+      assert_equal(%w{piper peck of pickled},aout)
+      
+      out < rio('src').chomp.lines(0..1)
+      assert_equal("peterpiper",out.contents)
+      
+      rio('src').chomp.lines(0..1) > aout
+      assert_equal(%w{peter piper},aout)
+      rio('src').chomp.lines(0..1) >> aout
+      assert_equal(%w{peter piper peter piper},aout)
+    }
+  end
+end

data/test/tc/copynonex.rb

@@ -0,0 +1,121 @@
+#!/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_copynonex < 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_dirs_equal(exp,d,msg="")
+    exp.each do |ent|
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.file?
+        assert(ds.file?,"entry is a file")
+        assert_equal(ent[],ds[],"file has same contents")
+      when ent.dir?
+        assert_dirs_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def assert_rios_equal(exp,ans,msg="")
+    case
+    when exp.file?
+      assert(ans.file?,"entry is a file")
+      assert_equal(exp.readlines,ans.readlines,"file has same contents")
+    when exp.dir?
+      assert(ans.dir?,"entry is a dir")
+      assert_dirs_equal(exp,ans,"directories are the same")
+    end
+  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_nonex_right_sel
+    dst = rio('nonex_ri_sel').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+    src.files(/0/) > dst
+    p src,dst
+#    p smap(dst[])
+#    p smap(src.lines[0])
+    #assert_dirs_equal(src,dst,"nonex ri")
+  end
+  def test_nonex_right_dir
+    dst = rio('nonex_ri').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+    src > dst
+    assert_dirs_equal(src,dst,"nonex ri")
+  end
+  def test_nonex_left_dir
+    dst = rio('nonex_le').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+    dst < src
+    assert_dirs_equal(src,dst,"nonex le")
+  end
+  def test_nonex_right_file
+    dst = rio('nonex_ri_f').delete!
+    assert!(dst.exist?)
+    src = rio(@f1)
+    src > dst
+    assert_rios_equal(src,dst,"nonex ri")
+  end
+  def test_nonex_left_file
+    dst = rio('nonex_le_f').delete!
+    assert!(dst.exist?)
+    src = rio(@f1)
+    dst < src
+    assert_rios_equal(src,dst,"nonex le")
+  end
+end