rio 0.3.1

data/test/tc/edf.rb

@@ -0,0 +1,82 @@
+#!/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_edf < Test::Unit::TestCase
+  def tdir() rio(%w/qp edf/) end
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  require 'extensions/symbol'
+  def smap(a) a.map( &:to_s ) end
+  def mkafile(*args)
+    file = rio(*args)
+    file < (0..1).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def mkalinesfile(n_lines,*args)
+    file = rio(*args)
+    file < (0...n_lines).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def setup
+    #$trace_states = true
+    unless @once
+      @once = true
+      tdir.delete!.mkpath.chdir do
+        mkafile('f1.txt')
+        mkafile('f2.asc')
+        rio('d0').mkdir
+        rio('d1').mkdir.chdir do
+          mkafile('f0.txt')
+        end
+        rio('d2').mkdir.chdir do
+          mkafile('f1.asc')
+          mkafile('f1.txt')
+          mkafile('f2.txt')
+          rio('d3').mkdir.chdir do
+            mkafile('f0.txt')
+            mkafile('f2.txt')
+            mkafile('f1.txt')
+          end
+        end
+      end
+    end
+    @cwd = ::Dir.getwd
+    tdir.mkpath.chdir
+  end
+  def teardown
+    ::Dir.chdir @cwd
+  end
+
+  def test_basic
+
+    ans = rio('d2').files[]
+    p smap(ans)
+    ans.clear
+    $trace_states = false
+    rio('d2').files(/\.txt$/).each { |ent| ans << ent }
+    $trace_states = false
+
+    p smap(ans)
+
+    ans = rio('d2').files(/\.txt$/)[]
+    p smap(ans)
+
+    ans = rio('d2').files[/\.txt$/]
+    p smap(ans)
+
+    ans = rio('d2').files('*.txt')[]
+    p smap(ans)
+
+    ans = rio('d2').files['*.txt']
+    p smap(ans)
+
+  end
+end

data/test/tc/entary.rb

@@ -0,0 +1,230 @@
+#!/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 'tc/testcase'
+
+class TC_RIO_entary < Test::Unit::TestCase
+  require 'extensions/symbol'
+  def smap(a) a.map( &:to_s ) end
+  def tdir() rio(%w/qp entary/) end
+  def mkafile(*args)
+    file = rio(*args)
+    file < (0..1).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def setup() 
+    $trace_states = false
+    rio('qp/entary').delete!.mkpath.chdir do
+      rio('d0').mkpath.chdir do
+        rio('q1') < (0..1).map { |i| "L#{i}:d0/q1\n" }
+        rio('q2') < (0..1).map { |i| "L#{i}:d0/q2\n" }
+        rio('d1').mkdir.chdir do
+          rio('q1') < (0..1).map { |i| "L#{i}:d0/d1/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d0/d1/q2\n" }
+          rio('d1').mkdir.chdir do
+            rio('q1') < (0..1).map { |i| "L#{i}:d0/d1/d1/q1\n" }
+            rio('q2') < (0..1).map { |i| "L#{i}:d0/d1/d1/q2\n" }
+          end
+          rio('d2').mkdir
+        end
+        rio('d2').mkdir
+      end
+    end
+  end
+  def test_entary_nofile
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d1/q1 d0/d1/d1/q2]
+    return unless $supports_symlink
+    rio('qp/entary').chdir do
+      begin
+        rio('d1').delete!.mkpath.chdir do
+          rio('q1') < (0..1).map { |i| "L#{i}:d1/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d1/q2\n" }
+          rio('q1').symlink('lq1')
+          rio('d1').mkdir
+          rio('d1').symlink('ld1')
+          rio('d2').mkdir
+        end
+        ds = %w[d1/q1 d1/q2 d1/d1 d1/d2 d1/lq1 d1/ld1]
+        begin
+          ans = rio('d1').files[]
+          exp = ds.select { |el| el =~ /q\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[]
+          exp = ds.select { |el| el =~ /d\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[]
+          exp = ds.select { |el| el =~ /(l)?[qd]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          rio('d1/q1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/q1$| }
+
+          ans = rio('d1').files[]
+          exp = ds.select { |el| el =~ /q2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[]
+          exp = ds.select { |el| el =~ /d\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[]
+          exp = ds.select { |el| el =~ /(l)?[qd]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          rio('d1/d1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/d11$| }
+          
+          ans = rio('d1').files[]
+          exp = ds.select { |el| el =~ /q2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[]
+          exp = ds.select { |el| el =~ /d2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[]
+          exp = ds.select { |el| el =~ /l[qd]1$/ or el =~ /[qd]2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+      end
+    end
+  end
+  def test_entary_nofile_symlink
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d1/q1 d0/d1/d1/q2]
+    return unless $supports_symlink
+    rio('qp/entary').chdir do
+      begin
+        rio('d1').delete!.mkpath.chdir do
+          rio('q1') < (0..1).map { |i| "L#{i}:d1/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d1/q2\n" }
+          rio('q1').symlink('lq1')
+          rio('d1').mkdir
+          rio('d1').symlink('ld1')
+          rio('d2').mkdir
+        end
+        ds = %w[d1/q1 d1/q2 d1/d1 d1/d2 d1/lq1 d1/ld1]
+
+        begin
+          ans = rio('d1').files[/1/]
+          exp = ds.select { |el| el =~ /q1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[/1/]
+          exp = ds.select { |el| el =~ /d1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[/1/]
+          exp = ds.select { |el| el =~ /(l)?[qd]1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          rio('d1/q1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/q1$| }
+
+          ans = rio('d1').files[/1/]
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[/1/]
+          exp = ds.select { |el| el =~ /d1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d1').entries[/1/]
+          exp = ds.select { |el| el =~ /(l)?[qd]1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          rio('d1/d1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/d11$| }
+          
+          ans = rio('d1').files[/1/]
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[/1/]
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[/1/]
+          exp = ds.select { |el| el =~ /l[qd]1$/  }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+      end
+    end
+  end
+  def test_entary
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d1/q1 d0/d1/d1/q2]
+    rio('qp/entary').chdir do
+      begin
+        ans = []
+        exp = []
+        rio('d0').dirs.files.each { |ent| exp << ent }
+
+        ans.clear
+        rio('d0').entries.each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans.clear
+        rio('d0').entries { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans = rio('d0').entries[]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+      end
+
+      begin
+        ans = []
+        exp = []
+        rio('d0').dirs(/1/).files(/1/).each { |ent| exp << ent }
+
+        ans.clear
+        rio('d0').entries(/1/).each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans.clear
+        rio('d0').entries(/1/) { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans = rio('d0').entries[/1/]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans = rio('d0')[/1/]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+      end
+
+      begin
+        ans = []
+        exp = []
+        rio('d0').entries(/1/).each { |ent| exp << ent }
+        rio('d0').files.each { |ent| exp << ent unless exp.include?(ent)}
+        
+        ans.clear
+        rio('d0').entries(/1/).files.each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+        
+        ans = rio('d0').files.entries[/1/]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+        
+        ans = rio('d0').entries(/1/).files[]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+        
+      end
+      
+    end
+  end
+end

data/test/tc/eq.rb

@@ -0,0 +1,101 @@
+#!/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_eq < Test::Unit::TestCase
+  def assert_case_equal(q,p,msg=nil)
+    begin
+      assert_block { 
+        q === p
+      }
+    rescue Test::Unit::AssertionFailedError => e
+      raise e.exception("#{q.inspect}\n ===\n#{p.inspect}")
+    end
+  end
+  def assert_eq(q,p,msg=nil)
+    begin
+      assert_block { 
+        q == p
+      }
+    rescue Test::Unit::AssertionFailedError => e
+      raise e.exception("#{q.inspect}\n ==\n(#{p.inspect})")
+    end
+  end
+  def assert_eql(q,p,msg=nil)
+    begin
+      assert_block { 
+        q.eql?(p)
+      }
+    rescue Test::Unit::AssertionFailedError => e
+      raise e.exception("#{q.inspect}\n.eql?\n(#{p.inspect})")
+    end
+  end
+  def assert_not_eql(q,p,msg=nil)
+    begin
+      assert_block { 
+        !q.eql?(p)
+      }
+    rescue Test::Unit::AssertionFailedError => e
+      raise e.exception("#{q.inspect}\n NOT eql?\n(#{p.inspect})")
+    end
+  end
+  def all_eq(q1,q2)
+    q = rio(q1)
+    z = rio(q2)
+
+    assert_eq(q,z)
+    assert_case_equal(q,z,"===")
+    assert_case_equal(q,q2,"===")
+  end
+  
+  def test_eq
+    s_dir = ''
+    #$trace_states = true
+    rio(%w/qp eq/).rmtree.mkpath.chdir do
+      q1 = 'q'
+      q2 = 'q'
+      all_eq(q1,q2)
+      #$trace_states = true
+      all_eq(?-,'stdio:')
+      
+      
+      dir = rio('dir')
+      all_eq(rio('dir'),dir)
+      all_eq(dir,rio('dir'))
+      all_eq(rio('dir'),'dir')
+      all_eq(dir,'dir')
+
+#       p rio('dir') == 'dir'
+
+#       f = ::File.open('dir/f1')
+#       p rio(f).to_s
+#       r2 = rio(?_,f)
+#       p dir.to_s,dir.to_rl
+#       p rio(f) == r2
+
+#       p rio(?-).to_s
+#       p rio(?-).to_rl
+#       p rio(??).to_s
+#       p rio(??,'rio','/tmp').to_s
+#       p rio(?$).to_s
+#       p rio(?=).to_s
+#       p rio('tcp://localhost:systime').to_s
+#       p rio('rio:tcp://:systime').to_s
+#       p rio('rio:tcp://:systime').rl.rl
+#       p rio('http://ruby-doc.org/').to_s
+#       require 'uri'
+#       u = URI('http://ruby-doc.org/')
+#       p rio(u).to_s
+#       p rio(u).rl.rl
+#       p rio('file:///tmp/zippy.tmp').to_s
+#       p rio('file:///tmp/zippy.tmp').rl.rl
+#       p rio('./-').to_s
+#       p rio('-').to_s
+    end
+  end
+end

data/test/tc/expand_path.rb

@@ -0,0 +1,94 @@
+#!/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_expand_path < Test::Unit::TestCase
+  require 'extensions/symbol'
+  def initialize(*args)
+    super
+    @once = false
+    @tdir = rio('qp/expand_path')
+  end
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map( &:to_s ) end
+  def setup
+    s_dir = ''
+    #$trace_states = true
+    unless @once
+      @once =  true
+      @tdir.rmtree.mkpath
+    end
+  end
+
+  def test_expand_path_from_cwd
+    require 'tmpdir'
+    tmp = rio('/tmp')
+    unless tmp.dir?
+      tmp = rio(RIO::RL.fs2url(::Dir.tmpdir))
+    end
+    tmp.chdir do
+      rel = rio('groovy')
+      exp = rio(tmp,rel)
+      ans = rel.expand_path
+      assert_kind_of(RIO::Rio,ans)
+      assert_equal(exp,ans)
+    end
+  end
+
+  def test_expand_path_from_base_rio
+    @tdir.chdir do
+      rel = rio('groovy')
+      base = rio('/tmp')
+      exp = rio(base,rel)
+      ans = rel.expand_path(base)
+      assert_kind_of(RIO::Rio,ans)
+      assert_equal(exp,ans)
+    end
+  end
+
+  def test_expand_path_from_base_string
+    @tdir.chdir do
+      rel = rio('groovy')
+      base = rio('/tmp')
+      exp = rio(base,rel)
+      ans = rel.expand_path(base.to_s)
+      assert_kind_of(RIO::Rio,ans)
+      assert_equal(exp.to_s,ans.to_s)
+    end
+  end
+
+  def test_expand_path_from_tilde
+    return unless $supports_symlink
+    @tdir.chdir do
+      file = rio('groovy')
+      rel = rio('~/' + file.to_s)
+      home =  rio(RIO::RL.fs2url(ENV['HOME'].dup))
+      exp = rio(home,file)
+      ans = rel.expand_path
+      assert_equal(exp.to_s,ans.to_s)
+    end
+  end
+
+  def test_expand_path_from_tilde_user
+    return unless $supports_symlink
+    @tdir.chdir do
+      home =  rio(RIO::RL.fs2url(ENV['HOME'].dup))
+      user =  RIO::RL.fs2url(ENV['USER'].dup)
+      file = rio('groovy')
+      rel = rio('~' + user)
+      exp = rio(home)
+      ans = rel.expand_path
+      assert_equal(exp.to_s,ans.to_s)
+    end
+  end
+
+
+end