rio 0.3.3 → 0.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (88) hide show
  1. data/ChangeLog +225 -0
  2. data/README +12 -0
  3. data/Rakefile +1 -1
  4. data/VERSION +1 -1
  5. data/doc/ANNOUNCE +160 -71
  6. data/doc/RELEASE_NOTES +71 -2
  7. data/ex/colx.rb +1 -1
  8. data/ex/passwd_report.rb +4 -8
  9. data/ex/riocat +5 -5
  10. data/ex/riogunzip +1 -1
  11. data/ex/riogzip +6 -6
  12. data/ex/rioprompt.rb +6 -0
  13. data/lib/rio.rb +3 -13
  14. data/lib/rio/arycopy.rb +1 -1
  15. data/lib/rio/base.rb +1 -5
  16. data/lib/rio/construct.rb +75 -0
  17. data/lib/rio/constructor.rb +42 -11
  18. data/lib/rio/context.rb +1 -1
  19. data/lib/rio/context/dir.rb +50 -23
  20. data/lib/rio/context/methods.rb +5 -3
  21. data/lib/rio/{cxdir.rb → context/skip.rb} +24 -36
  22. data/lib/rio/context/stream.rb +38 -16
  23. data/lib/rio/cp.rb +24 -5
  24. data/lib/rio/dir.rb +8 -7
  25. data/lib/rio/doc/HOWTO.rb +33 -33
  26. data/lib/rio/doc/INTRO.rb +416 -256
  27. data/lib/rio/doc/MISC.rb +3 -1
  28. data/lib/rio/doc/SYNOPSIS.rb +28 -33
  29. data/lib/rio/entrysel.rb +76 -9
  30. data/lib/rio/file.rb +2 -1
  31. data/lib/rio/filter.rb +95 -0
  32. data/lib/rio/filter/closeoneof.rb +1 -1
  33. data/lib/rio/grande.rb +0 -74
  34. data/lib/rio/if.rb +2 -1
  35. data/lib/rio/if/basic.rb +1 -1
  36. data/lib/rio/if/csv.rb +1 -1
  37. data/lib/rio/if/dir.rb +1 -220
  38. data/lib/rio/if/fileordir.rb +26 -12
  39. data/lib/rio/if/grande.rb +55 -6
  40. data/lib/rio/if/grande_entry.rb +355 -0
  41. data/lib/rio/if/{methods.rb → grande_stream.rb} +69 -88
  42. data/lib/rio/if/path.rb +25 -3
  43. data/lib/rio/if/stream.rb +62 -37
  44. data/lib/rio/if/temp.rb +2 -2
  45. data/lib/rio/if/test.rb +23 -0
  46. data/lib/rio/impl/path.rb +5 -0
  47. data/lib/rio/match.rb +6 -3
  48. data/lib/rio/matchrecord.rb +50 -46
  49. data/lib/rio/{filter/chomp.rb → ops/construct.rb} +12 -20
  50. data/lib/rio/ops/create.rb +3 -0
  51. data/lib/rio/ops/dir.rb +12 -6
  52. data/lib/rio/ops/either.rb +17 -3
  53. data/lib/rio/ops/path.rb +4 -1
  54. data/lib/rio/ops/stream/input.rb +6 -1
  55. data/lib/rio/ops/stream/read.rb +1 -3
  56. data/lib/rio/{context/chomp.rb → prompt.rb} +17 -13
  57. data/lib/rio/rl/base.rb +1 -1
  58. data/lib/rio/rl/builder.rb +3 -1
  59. data/lib/rio/state.rb +7 -13
  60. data/lib/rio/stream.rb +8 -5
  61. data/lib/rio/stream/open.rb +1 -1
  62. data/lib/rio/version.rb +1 -1
  63. data/test/mswin32.rb +1 -1
  64. data/test/runtests_gem.rb +1 -1
  65. data/test/tc/all.rb +3 -0
  66. data/test/tc/copy-from.rb +13 -13
  67. data/test/tc/copy-to.rb +1 -1
  68. data/test/tc/copy.rb +1 -1
  69. data/test/tc/copydir.rb +0 -24
  70. data/test/tc/copysymlink.rb +39 -0
  71. data/test/tc/csv.rb +2 -2
  72. data/test/tc/csv2.rb +4 -4
  73. data/test/tc/misc.rb +16 -16
  74. data/test/tc/nolines.rb +26 -26
  75. data/test/tc/noqae.rb +74 -74
  76. data/test/tc/overload.rb +28 -28
  77. data/test/tc/riorl.rb +36 -0
  78. data/test/tc/selnosel.rb +36 -0
  79. data/test/tc/skip.rb +58 -0
  80. data/test/tc/skiplines.rb +42 -0
  81. data/test/tc/symlink.rb +1 -1
  82. data/test/tc/symlink0.rb +1 -1
  83. data/test/tc/temp.rb +1 -1
  84. data/test/tc/tempdir.rb +1 -1
  85. data/test/tc/testcase.rb +7 -1
  86. metadata +14 -8
  87. data/lib/rio/matchcolumns.rb +0 -266
  88. data/lib/rio/rangemath.rb +0 -44
data/test/tc/copy-to.rb CHANGED
@@ -35,7 +35,7 @@ class TC_copy_to < Test::RIO::TestCase
35
35
  end
36
36
  def test_string
37
37
  ario = rio('d0/f1')
38
- exp = ario.slurp
38
+ exp = ario.contents
39
39
  ans = "If you are seeing this, rio > string is broken"
40
40
  ario > ans
41
41
  assert_equal(exp,ans)
data/test/tc/copy.rb CHANGED
@@ -38,7 +38,7 @@ class TC_RIO_copy < Test::Unit::TestCase
38
38
  oline = rio(datadir,'dir1/sd1/f1.txt').readline
39
39
 
40
40
  dir2 = rio(datadir,'dir2').rmtree.mkpath
41
- sd1.copy(dir2)
41
+ sd1.copy_to(dir2)
42
42
  nline = rio(datadir,'dir2/sd1/f1.txt').readline
43
43
  assert_equal(oline,nline)
44
44
 
data/test/tc/copydir.rb CHANGED
@@ -45,30 +45,6 @@ class TC_copydir < Test::RIO::TestCase
45
45
  @f2 = rio('d0/d2/f2')
46
46
  @f3 = rio('d0/d2/f3')
47
47
  end
48
- def assert_dirs_equal(exp,d,msg="")
49
- exp.each do |ent|
50
- ds = rio(d,ent.filename)
51
- assert(ds.exist?,"entry '#{ds}' exists")
52
- assert_equal(ent.ftype,ds.ftype,"same ftype")
53
- case
54
- when ent.file?
55
- assert(ds.file?,"entry is a file")
56
- assert_equal(ent[],ds[],"file has same contents")
57
- when ent.dir?
58
- assert_dirs_equal(ent,ds,"subdirectories are the same")
59
- end
60
- end
61
- end
62
- def assert_rios_equal(exp,ans,msg="")
63
- case
64
- when exp.file?
65
- assert(ans.file?,"entry is a file")
66
- assert_equal(exp.readlines,ans.readlines,"file has same contents")
67
- when exp.dir?
68
- assert(ans.dir?,"entry is a dir")
69
- assert_dirs_equal(exp,ans,"directories are the same")
70
- end
71
- end
72
48
  def assert_skel_equal(exp,d,msg="")
73
49
  exp.each do |ent|
74
50
  next unless ent.dir?
data/test/tc/copysymlink.rb ADDED
@@ -0,0 +1,39 @@
1
+ #!/usr/local/bin/ruby
2
+ if $0 == __FILE__
3
+ Dir.chdir File.dirname(__FILE__)+'/../'
4
+ $:.unshift File.expand_path('../lib/')
5
+ end
6
+
7
+ require 'rio'
8
+ require 'tc/testcase'
9
+
10
+ class TC_copysymlink < Test::RIO::TestCase
11
+ @@once = false
12
+ def self.once
13
+ @@once = true
14
+ rio('afile').touch.symlink('alink')
15
+ rio('d0').rmtree.mkpath
16
+ rio('d0/afile').touch.symlink('d0/alink')
17
+ rio('d1').rmtree.mkpath
18
+ rio('d0/afile').touch.symlink('d1/alink')
19
+ end
20
+ def setup
21
+ super
22
+ self.class.once unless @@once
23
+
24
+ @d0 = rio('d0/')
25
+ @d1 = rio('d1/')
26
+ end
27
+ def test_basic
28
+ dst = rio('dst').delete!.mkpath
29
+ dst < @d0
30
+
31
+ assert_dirs_equal(@d0,rio(dst,@d0.filename),"basic copy")
32
+ end
33
+ def test_cross_copy
34
+ dst = rio('dst2').delete!.mkpath
35
+ dst < @d1
36
+
37
+ assert_dirs_equal(@d1,rio(dst,@d1.filename),"basic copy")
38
+ end
39
+ end
data/test/tc/csv.rb CHANGED
@@ -63,7 +63,7 @@ class TC_csv < Test::Unit::TestCase
63
63
  end
64
64
  def test_nocsv_lines
65
65
  rio(@src_name) > rio(@dst_name)
66
- assert_equal(@string,rio(@dst_name).slurp)
66
+ assert_equal(@string,rio(@dst_name).contents)
67
67
  assert_equal(@lines,rio(@dst_name)[])
68
68
  assert_equal(@strings,rio(@dst_name).chomp[])
69
69
  assert_equal(@lines,rio(@dst_name).to_a)
@@ -72,7 +72,7 @@ class TC_csv < Test::Unit::TestCase
72
72
  assert_equal(@strings,rio(@dst_name).chomp.readlines)
73
73
  end
74
74
  def test_csv_lines
75
- assert_equal(@string,rio(@dst_name).csv.slurp)
75
+ assert_equal(@string,rio(@dst_name).csv.contents)
76
76
  assert_equal(@records,rio(@dst_name).csv[])
77
77
  assert_equal(@records,rio(@dst_name).csv.chomp[])
78
78
  assert_equal(@lines,rio(@dst_name).csv.lines[])
data/test/tc/csv2.rb CHANGED
@@ -27,8 +27,8 @@ class TC_csv2 < Test::RIO::TestCase
27
27
 
28
28
 
29
29
  rio('src1.csv') > rio('dst.csv')
30
- assert_equal(@string,rio('dst.csv').slurp)
31
- assert_equal(@string,rio('dst.csv').csv.slurp)
30
+ assert_equal(@string,rio('dst.csv').contents)
31
+ assert_equal(@string,rio('dst.csv').csv.contents)
32
32
  assert_equal(@lines,rio('dst.csv')[])
33
33
  assert_equal(@strings,rio('dst.csv').chomp[])
34
34
  assert_equal(@lines,rio('dst.csv').to_a)
@@ -96,8 +96,8 @@ class TC_csv2 < Test::RIO::TestCase
96
96
 
97
97
  rio('src1.csv') < @src
98
98
 
99
- assert_equal(@string,rio('src1.csv').slurp)
100
- assert_equal(@string,rio('src1.csv').csv.slurp)
99
+ assert_equal(@string,rio('src1.csv').contents)
100
+ assert_equal(@string,rio('src1.csv').csv.contents)
101
101
  assert_equal(@lines[0],rio('src1.csv').getrec)
102
102
  assert_equal(@strings[0],rio('src1.csv').chomp.getrec)
103
103
 
data/test/tc/misc.rb CHANGED
@@ -200,28 +200,28 @@ class TC_RIO_misc < Test::Unit::TestCase
200
200
  tdir.rmtree.mkpath.chdir {
201
201
  txt = "Hello f1.txt"
202
202
  o = rio('o').puts(txt).close
203
- oslurp = o.slurp
203
+ oslurp = o.contents
204
204
 
205
205
  n = rio('n')
206
- o.copy(n)
207
- assert_equal(oslurp,n.slurp)
206
+ o.copy_to(n)
207
+ assert_equal(oslurp,n.contents)
208
208
 
209
209
  d = rio('d1').rmtree.mkpath
210
210
  n = rio(d,'o')
211
- o.copy(d)
212
- assert_equal(oslurp,n.slurp)
211
+ o.copy_to(d)
212
+ assert_equal(oslurp,n.contents)
213
213
 
214
214
  # d = rio('d2').rmtree
215
215
  # n = rio(d,'o')
216
216
  # assert_raise(::RIO::Exception::Copy) {
217
- # o.copy(n)
217
+ # o.copy_to(n)
218
218
  # }
219
219
 
220
220
 
221
221
  d = rio('d3').rmtree.mkpath
222
222
  n = rio(d,'o').touch
223
- o.copy(d)
224
- assert_equal(oslurp,n.slurp)
223
+ o.copy_to(d)
224
+ assert_equal(oslurp,n.contents)
225
225
 
226
226
 
227
227
  return unless $supports_symlink
@@ -231,8 +231,8 @@ class TC_RIO_misc < Test::Unit::TestCase
231
231
  rio('qf').symlink('o')
232
232
  }
233
233
  n = rio(d,'o')
234
- o.copy(d)
235
- assert_equal(oslurp,n.slurp)
234
+ o.copy_to(d)
235
+ assert_equal(oslurp,n.contents)
236
236
 
237
237
  d = rio('d6').rmtree.mkpath
238
238
  q = rio(d,'qd').mkdir
@@ -349,9 +349,9 @@ class TC_RIO_misc < Test::Unit::TestCase
349
349
  src.close
350
350
  src = rio(datadir,'src')
351
351
  dst1 = rio(datadir,'dst1')
352
- src.copy(dst1)
352
+ src.copy_to(dst1)
353
353
  dst2 = rio(datadir,'dst2').mkdir
354
- src.copy(dst2)
354
+ src.copy_to(dst2)
355
355
  sline = rio(datadir,'src').readline
356
356
  l1 = rio(datadir,'dst1').readline
357
357
  l2 = rio(datadir,'dst2/src').readline
@@ -366,14 +366,14 @@ class TC_RIO_misc < Test::Unit::TestCase
366
366
  oline = rio(datadir,'dir1/sd1/f1.txt').readline
367
367
 
368
368
  dir2 = rio(datadir,'dir2').rmtree.mkpath
369
- sd1.copy(dir2)
369
+ sd1.copy_to(dir2)
370
370
  nline = rio(datadir,'dir2/sd1/f1.txt').readline
371
371
  assert_equal(oline,nline)
372
372
 
373
373
  end
374
374
  def cmpfiles(z1,z2)
375
- o = rio(z1).slurp
376
- n = rio(z2).slurp
375
+ o = rio(z1).contents
376
+ n = rio(z2).contents
377
377
  o == n
378
378
  end
379
379
 
@@ -436,7 +436,7 @@ end
436
436
  # :chdir,
437
437
  # :each_entry,:each_line,:each,:each_byte,
438
438
  # :each_tested,:each_file,:each_directory,:each_symlink,
439
- # :to_str,:to_a,:slurp,
439
+ # :to_str,:to_a,:contents,
440
440
  # :length,:size,:zero?,
441
441
  # :eof?,
442
442
  # :read,:readchar,:readline,:readlines,
data/test/tc/nolines.rb CHANGED
@@ -8,8 +8,8 @@ require 'rio'
8
8
  require 'test/unit'
9
9
  require 'test/unit/testsuite'
10
10
 
11
- class TC_RIO_nolines < Test::Unit::TestCase
12
- def tdir() rio(%w/qp nolines/) end
11
+ class TC_RIO_skiplines < Test::Unit::TestCase
12
+ def tdir() rio(%w/qp skiplines/) end
13
13
  def assert!(a,msg="negative assertion")
14
14
  assert((!(a)),msg)
15
15
  end
@@ -44,10 +44,10 @@ class TC_RIO_nolines < Test::Unit::TestCase
44
44
  file < lines
45
45
 
46
46
  exp = lines[0..0] + lines[2..5] + lines[7...8]
47
- ans = file.chomp.nolines[:empty?]
47
+ ans = file.chomp.skiplines[:empty?]
48
48
  assert_equal(exp.map(&:chomp),ans)
49
49
 
50
- ans = file.nolines(:empty?).chomp.to_a
50
+ ans = file.skiplines(:empty?).chomp.to_a
51
51
  assert_equal(exp.map(&:chomp),ans)
52
52
 
53
53
  file.close
@@ -73,13 +73,13 @@ class TC_RIO_nolines < Test::Unit::TestCase
73
73
  # iterate over the first line and comment lines
74
74
  begin
75
75
  f0 = file.dup
76
- ans = f0.nolines[0,/^\s*#/]
76
+ ans = f0.skiplines[0,/^\s*#/]
77
77
  assert_equal(exp,ans)
78
78
  end
79
79
 
80
80
  begin
81
81
  f0 = file.dup
82
- ans = f0.nolines[proc { |rec,rnum,rio| rnum == 0 || rec =~ /^\s*#/ }]
82
+ ans = f0.skiplines[proc { |rec,rnum,rio| rnum == 0 || rec =~ /^\s*#/ }]
83
83
  assert_equal(exp,ans)
84
84
  end
85
85
  begin
@@ -87,7 +87,7 @@ class TC_RIO_nolines < Test::Unit::TestCase
87
87
 
88
88
  #$trace_states = true
89
89
  exp0 = lines[0..1] + lines[5...8]
90
- ans = f0.nolines[/^\s*#/]
90
+ ans = f0.skiplines[/^\s*#/]
91
91
  #p f0.cx
92
92
  #$trace_states = false
93
93
  assert_equal(exp0,ans)
@@ -102,10 +102,10 @@ class TC_RIO_nolines < Test::Unit::TestCase
102
102
 
103
103
  exp2 = lines[2..4]
104
104
  exp = exp1 - exp2
105
- ans = file.lines(proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }).nolines[/^\s*#/]
105
+ ans = file.lines(proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }).skiplines[/^\s*#/]
106
106
  assert_equal(exp,ans)
107
107
 
108
- ans = file.nolines(/^\s*#/).lines[proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }]
108
+ ans = file.skiplines(/^\s*#/).lines[proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }]
109
109
  assert_equal(exp,ans)
110
110
  end
111
111
 
@@ -113,30 +113,30 @@ class TC_RIO_nolines < Test::Unit::TestCase
113
113
  # $trace_states = true
114
114
  lfile,lines = file_lines()
115
115
 
116
- ans = rio('f1').nolines(2..4).lines[0..2]
116
+ ans = rio('f1').skiplines(2..4).lines[0..2]
117
117
  exp = lines[6..6]
118
118
 
119
- ans = rio('f1').norecords(0).records(0..2).norecords(2..4).records[6]
119
+ ans = rio('f1').skiprecords(0).records(0..2).skiprecords(2..4).records[6]
120
120
  assert_equal(exp,ans)
121
121
 
122
- ans = rio('f1').lines(0..2).nolines(0,2..4).lines[6]
122
+ ans = rio('f1').lines(0..2).skiplines(0,2..4).lines[6]
123
123
  assert_equal(exp,ans)
124
- ans = rio('f1').nolines(0,2..4).lines[0..2,6]
124
+ ans = rio('f1').skiplines(0,2..4).lines[0..2,6]
125
125
 
126
126
  assert_equal(lines[1..1]+lines[6..6],ans)
127
127
 
128
128
 
129
- ans = rio('f1').nolines(0).lines(0..2).nolines(2..4).lines[6]
129
+ ans = rio('f1').skiplines(0).lines(0..2).skiplines(2..4).lines[6]
130
130
  assert_equal(exp,ans)
131
- ans = rio('f1').nolines(0).lines(0..2).nolines(2..4).lines[6]
131
+ ans = rio('f1').skiplines(0).lines(0..2).skiplines(2..4).lines[6]
132
132
  assert_equal(exp,ans)
133
- ans = rio('f1').records(0..2).norecords(0,2..4).records[6]
133
+ ans = rio('f1').records(0..2).skiprecords(0,2..4).records[6]
134
134
  assert_equal(exp,ans)
135
- ans = rio('f1').norecords(0,2..4).records[0..2,6]
135
+ ans = rio('f1').skiprecords(0,2..4).records[0..2,6]
136
136
  assert_equal(lines[1..1]+lines[6..6],ans)
137
137
 
138
138
  exp = lines[1..1] + lines[5..7]
139
- ans = rio('f1').nolines(0,2..4).lines[0..2,6,/f1/]
139
+ ans = rio('f1').skiplines(0,2..4).lines[0..2,6,/f1/]
140
140
  assert_equal(exp,ans)
141
141
 
142
142
 
@@ -169,33 +169,33 @@ class TC_RIO_nolines < Test::Unit::TestCase
169
169
  # $trace_states = true
170
170
  lfile,lines = file_lines()
171
171
 
172
- file = lfile.dup.nolines(2..4).lines(0..2)
172
+ file = lfile.dup.skiplines(2..4).lines(0..2)
173
173
  exp = lines[0..1]
174
174
  #p "HEE"
175
175
  # breakpoint
176
176
  iter_tests(file,exp)
177
177
 
178
- file = lfile.dup.norecords(0).records(0..2).norecords(2..4).records(6)
178
+ file = lfile.dup.skiprecords(0).records(0..2).skiprecords(2..4).records(6)
179
179
  exp = lines[6..6]
180
180
  iter_tests(file,exp)
181
181
 
182
- file = lfile.dup.lines(0..2).nolines(0,2..4).lines(6)
182
+ file = lfile.dup.lines(0..2).skiplines(0,2..4).lines(6)
183
183
  iter_tests(file,exp)
184
184
 
185
- file = lfile.dup.nolines(0,2..4).lines(0..2,6)
185
+ file = lfile.dup.skiplines(0,2..4).lines(0..2,6)
186
186
  iter_tests(file,lines[1..1]+lines[6..6])
187
187
 
188
- file = lfile.dup.nolines(0).lines(0..2).nolines(2..4).lines(6)
188
+ file = lfile.dup.skiplines(0).lines(0..2).skiplines(2..4).lines(6)
189
189
  iter_tests(file,exp)
190
190
 
191
- file = lfile.dup.records(0..2).norecords(0,2..4).records(6)
191
+ file = lfile.dup.records(0..2).skiprecords(0,2..4).records(6)
192
192
  iter_tests(file,exp)
193
193
 
194
- file = lfile.dup.norecords(0,2..4).records(0..2,6)
194
+ file = lfile.dup.skiprecords(0,2..4).records(0..2,6)
195
195
  iter_tests(file,lines[1..1]+lines[6..6])
196
196
 
197
197
  exp = lines[1..1] + lines[5..7]
198
- file = lfile.dup.nolines(0,2..4).lines(0..2,6,/f1/)
198
+ file = lfile.dup.skiplines(0,2..4).lines(0..2,6,/f1/)
199
199
  iter_tests(file,exp)
200
200
 
201
201
 
data/test/tc/noqae.rb CHANGED
@@ -95,28 +95,28 @@ class TC_RIO_noqae < Test::Unit::TestCase
95
95
  begin
96
96
  begin
97
97
  ans = []
98
- rio('d0').nodirs.each { |el| ans << el }
98
+ rio('d0').skipdirs.each { |el| ans << el }
99
99
  exp = all.reject { |el| el =~ /[cd]\d$/ }
100
100
  assert_equal(exp.sort,smap(ans).sort)
101
- ans = rio('d0').nodirs[]
101
+ ans = rio('d0').skipdirs[]
102
102
  assert_equal(exp.sort,smap(ans).sort)
103
103
  end
104
104
 
105
105
  begin
106
106
  ans = []
107
- rio('d0').nofiles.each { |el| ans << el }
107
+ rio('d0').skipfiles.each { |el| ans << el }
108
108
  exp = all.reject { |el| el =~ /[fl]\d$/ }
109
109
  assert_equal(exp.sort,smap(ans).sort)
110
- ans = rio('d0').nofiles[]
110
+ ans = rio('d0').skipfiles[]
111
111
  assert_equal(exp.sort,smap(ans).sort)
112
112
  end
113
113
 
114
114
  begin
115
115
  ans = []
116
- rio('d0').noentries.each { |el| ans << el }
116
+ rio('d0').skipentries.each { |el| ans << el }
117
117
  exp = []
118
118
  assert_equal(exp.sort,smap(ans).sort)
119
- ans = rio('d0').noentries[]
119
+ ans = rio('d0').skipentries[]
120
120
  assert_equal(exp.sort,smap(ans).sort)
121
121
  end
122
122
  end
@@ -124,62 +124,62 @@ class TC_RIO_noqae < Test::Unit::TestCase
124
124
  begin
125
125
  begin
126
126
  ans = []
127
- rio('d0').nodirs.nofiles.each { |el| ans << el }
127
+ rio('d0').skipdirs.skipfiles.each { |el| ans << el }
128
128
  exp = all.reject { |el| el =~ /[cdfl]\d$/ }
129
129
  assert_equal(exp.sort,smap(ans).sort)
130
- ans = rio('d0').nofiles.nodirs[]
130
+ ans = rio('d0').skipfiles.skipdirs[]
131
131
  assert_equal(exp.sort,smap(ans).sort)
132
- ans = rio('d0').nodirs.nofiles[]
132
+ ans = rio('d0').skipdirs.skipfiles[]
133
133
  assert_equal(exp.sort,smap(ans).sort)
134
134
  end
135
135
 
136
136
  begin
137
137
  ans = []
138
- rio('d0').nodirs.files.each { |el| ans << el }
138
+ rio('d0').skipdirs.files.each { |el| ans << el }
139
139
  exp = all.select { |el| el =~ /[fl]\d$/ }
140
140
  assert_equal(exp.sort,smap(ans).sort)
141
- ans = rio('d0').nodirs.files[]
141
+ ans = rio('d0').skipdirs.files[]
142
142
  assert_equal(exp.sort,smap(ans).sort)
143
- ans = rio('d0').files.nodirs[]
143
+ ans = rio('d0').files.skipdirs[]
144
144
  assert_equal(exp.sort,smap(ans).sort)
145
145
  end
146
146
 
147
147
  begin
148
148
  exp = all.select { |el| el =~ /[n]\d$/ }
149
149
  ans = []
150
- rio('d0').entries.nofiles.nodirs.each { |el| ans << el }
150
+ rio('d0').entries.skipfiles.skipdirs.each { |el| ans << el }
151
151
  assert_equal(exp.sort,smap(ans).sort)
152
152
 
153
- ans = rio('d0').entries.nofiles.nodirs[]
153
+ ans = rio('d0').entries.skipfiles.skipdirs[]
154
154
  assert_equal(exp.sort,smap(ans).sort)
155
- ans = rio('d0').entries.nodirs.nofiles[]
155
+ ans = rio('d0').entries.skipdirs.skipfiles[]
156
156
  assert_equal(exp.sort,smap(ans).sort)
157
- ans = rio('d0').nofiles.nodirs.entries[]
157
+ ans = rio('d0').skipfiles.skipdirs.entries[]
158
158
  assert_equal(exp.sort,smap(ans).sort)
159
- ans = rio('d0').nofiles.nodirs[]
159
+ ans = rio('d0').skipfiles.skipdirs[]
160
160
  assert_equal(exp.sort,smap(ans).sort)
161
161
  end
162
162
 
163
163
  begin
164
164
  exp = []
165
165
  ans = []
166
- rio('d0').noentries.dirs.each { |el| ans << el }
166
+ rio('d0').skipentries.dirs.each { |el| ans << el }
167
167
  assert_equal(exp.sort,smap(ans).sort)
168
- rio('d0').noentries.files.each { |el| ans << el }
168
+ rio('d0').skipentries.files.each { |el| ans << el }
169
169
  assert_equal(exp.sort,smap(ans).sort)
170
170
 
171
- ans = rio('d0').noentries.files[]
171
+ ans = rio('d0').skipentries.files[]
172
172
  assert_equal(exp.sort,smap(ans).sort)
173
- ans = rio('d0').noentries.dirs[]
173
+ ans = rio('d0').skipentries.dirs[]
174
174
  assert_equal(exp.sort,smap(ans).sort)
175
175
  end
176
176
 
177
177
  begin
178
178
  exp = []
179
179
  ans = []
180
- rio('d0').noentries.each { |el| ans << el }
180
+ rio('d0').skipentries.each { |el| ans << el }
181
181
  assert_equal(exp.sort,smap(ans).sort)
182
- ans = rio('d0').noentries[]
182
+ ans = rio('d0').skipentries[]
183
183
  assert_equal(exp.sort,smap(ans).sort)
184
184
  end
185
185
  end
@@ -197,19 +197,19 @@ class TC_RIO_noqae < Test::Unit::TestCase
197
197
  rio('d0').dirs.each { |el|
198
198
  assert(el.directory?)
199
199
  }
200
- rio('d0').nodirs.each { |el|
200
+ rio('d0').skipdirs.each { |el|
201
201
  assert!(el.directory?)
202
202
  }
203
- rio('d0').nodirs('*').each { |el|
203
+ rio('d0').skipdirs('*').each { |el|
204
204
  assert(el.directory?)
205
205
  }
206
206
  rio('d0').files.each { |el|
207
207
  assert(el.file?)
208
208
  }
209
- rio('d0').nofiles.each { |el|
209
+ rio('d0').skipfiles.each { |el|
210
210
  assert!(el.file?)
211
211
  }
212
- rio('d0').nofiles('*').each { |el|
212
+ rio('d0').skipfiles('*').each { |el|
213
213
  assert(el.file?)
214
214
  }
215
215
  begin
@@ -244,7 +244,7 @@ class TC_RIO_noqae < Test::Unit::TestCase
244
244
  begin
245
245
  exp = all.select { |el| el =~ /[df]\d\Z/ }
246
246
  ans = []
247
- rio('d0').noentries(:symlink?).each { |el|
247
+ rio('d0').skipentries(:symlink?).each { |el|
248
248
  assert!(el.symlink?)
249
249
  ans << el
250
250
  }
@@ -253,7 +253,7 @@ class TC_RIO_noqae < Test::Unit::TestCase
253
253
  begin
254
254
  exp = all.select { |el| el =~ /[d]\d\Z/ }
255
255
  ans = []
256
- rio('d0').nodirs(:symlink?).each { |el|
256
+ rio('d0').skipdirs(:symlink?).each { |el|
257
257
  assert(el.directory?)
258
258
  assert!(el.symlink?)
259
259
  ans << el
@@ -263,7 +263,7 @@ class TC_RIO_noqae < Test::Unit::TestCase
263
263
  begin
264
264
  exp = all.select { |el| el =~ /[f]\d\Z/ }
265
265
  ans = []
266
- rio('d0').nofiles(:symlink?).each { |el|
266
+ rio('d0').skipfiles(:symlink?).each { |el|
267
267
  assert(el.file?)
268
268
  assert!(el.symlink?)
269
269
  ans << el
@@ -284,11 +284,11 @@ class TC_RIO_noqae < Test::Unit::TestCase
284
284
  ere = /1/
285
285
  exp = all.reject { |el| el =~ ere }
286
286
  ans = []
287
- rio('d0').noentries(ere).each { |el| ans << el }
287
+ rio('d0').skipentries(ere).each { |el| ans << el }
288
288
  assert_equal(exp.sort,smap(ans).sort)
289
- ans = rio('d0').noentries(ere).to_a
289
+ ans = rio('d0').skipentries(ere).to_a
290
290
  assert_equal(exp.sort,smap(ans).sort)
291
- ans = rio('d0').noentries[ere]
291
+ ans = rio('d0').skipentries[ere]
292
292
  assert_equal(exp.sort,smap(ans).sort)
293
293
  end
294
294
 
@@ -299,9 +299,9 @@ class TC_RIO_noqae < Test::Unit::TestCase
299
299
  dre = /1/
300
300
  exp = all.select { |el| el =~ /[cd]2$/ }
301
301
  ans = []
302
- rio('d0').nodirs(dre).each { |el| ans << el }
302
+ rio('d0').skipdirs(dre).each { |el| ans << el }
303
303
  assert_equal(exp.sort,smap(ans).sort)
304
- ans = rio('d0').nodirs[dre]
304
+ ans = rio('d0').skipdirs[dre]
305
305
  assert_equal(exp.sort,smap(ans).sort)
306
306
  end
307
307
 
@@ -309,9 +309,9 @@ class TC_RIO_noqae < Test::Unit::TestCase
309
309
  dre = /1/
310
310
  exp = all.select { |el| el =~ /[d]2$/ }
311
311
  ans = []
312
- rio('d0').nodirs(dre,:symlink?).each { |el| ans << el }
312
+ rio('d0').skipdirs(dre,:symlink?).each { |el| ans << el }
313
313
  assert_equal(exp.sort,smap(ans).sort)
314
- ans = rio('d0').nodirs[dre,:symlink?]
314
+ ans = rio('d0').skipdirs[dre,:symlink?]
315
315
  assert_equal(exp.sort,smap(ans).sort)
316
316
  end
317
317
 
@@ -319,9 +319,9 @@ class TC_RIO_noqae < Test::Unit::TestCase
319
319
  fre = /2/
320
320
  exp = all.select { |el| el =~ /[fl]1$/ }
321
321
  ans = []
322
- rio('d0').nofiles(fre).each { |el| ans << el }
322
+ rio('d0').skipfiles(fre).each { |el| ans << el }
323
323
  assert_equal(exp.sort,smap(ans).sort)
324
- ans = rio('d0').nofiles[fre]
324
+ ans = rio('d0').skipfiles[fre]
325
325
  assert_equal(exp.sort,smap(ans).sort)
326
326
  end
327
327
 
@@ -329,9 +329,9 @@ class TC_RIO_noqae < Test::Unit::TestCase
329
329
  ere = /1/
330
330
  exp = all.select { |el| el =~ /2$/ }
331
331
  ans = []
332
- rio('d0').noentries(ere).each { |el| ans << el }
332
+ rio('d0').skipentries(ere).each { |el| ans << el }
333
333
  assert_equal(exp.sort,smap(ans).sort)
334
- ans = rio('d0').noentries[ere]
334
+ ans = rio('d0').skipentries[ere]
335
335
  assert_equal(exp.sort,smap(ans).sort)
336
336
  end
337
337
  end
@@ -342,36 +342,36 @@ class TC_RIO_noqae < Test::Unit::TestCase
342
342
  begin
343
343
  exp = all.select { |el| el =~ /([cd]2|[fl]1)$/ }
344
344
  ans = []
345
- rio('d0').nodirs(dre).nofiles(fre).each { |el| ans << el }
345
+ rio('d0').skipdirs(dre).skipfiles(fre).each { |el| ans << el }
346
346
  assert_equal(exp.sort,smap(ans).sort)
347
- ans = rio('d0').nofiles(fre).nodirs[dre]
347
+ ans = rio('d0').skipfiles(fre).skipdirs[dre]
348
348
  assert_equal(exp.sort,smap(ans).sort)
349
- ans = rio('d0').nodirs(dre).nofiles[fre]
349
+ ans = rio('d0').skipdirs(dre).skipfiles[fre]
350
350
  assert_equal(exp.sort,smap(ans).sort)
351
351
  end
352
352
 
353
353
  begin
354
354
  exp = all.select { |el| el =~ /([cd]2|[fl]2)$/ }
355
355
  ans = []
356
- rio('d0').nodirs(dre).files(fre).each { |el| ans << el }
356
+ rio('d0').skipdirs(dre).files(fre).each { |el| ans << el }
357
357
  assert_equal(exp.sort,smap(ans).sort)
358
- ans = rio('d0').nodirs(dre).files[fre]
358
+ ans = rio('d0').skipdirs(dre).files[fre]
359
359
  assert_equal(exp.sort,smap(ans).sort)
360
- ans = rio('d0').files(fre).nodirs[dre]
360
+ ans = rio('d0').files(fre).skipdirs[dre]
361
361
  assert_equal(exp.sort,smap(ans).sort)
362
362
  end
363
363
 
364
364
  begin
365
365
  exp = all.select { |el| el =~ /([cd]2|[fl]1|n[12])$/ }
366
366
  ans = []
367
- rio('d0').entries.nofiles(fre).nodirs(dre).each { |el| ans << el }
367
+ rio('d0').entries.skipfiles(fre).skipdirs(dre).each { |el| ans << el }
368
368
  assert_equal(exp.sort,smap(ans).sort)
369
369
 
370
- ans = rio('d0').entries.nofiles(fre).nodirs[dre]
370
+ ans = rio('d0').entries.skipfiles(fre).skipdirs[dre]
371
371
  assert_equal(exp.sort,smap(ans).sort)
372
- ans = rio('d0').entries.nodirs(dre).nofiles[fre]
372
+ ans = rio('d0').entries.skipdirs(dre).skipfiles[fre]
373
373
  assert_equal(exp.sort,smap(ans).sort)
374
- ans = rio('d0').nofiles(fre).nodirs(dre).entries[]
374
+ ans = rio('d0').skipfiles(fre).skipdirs(dre).entries[]
375
375
  assert_equal(exp.sort,smap(ans).sort)
376
376
  end
377
377
 
@@ -379,14 +379,14 @@ class TC_RIO_noqae < Test::Unit::TestCase
379
379
  ere = /1/
380
380
  exp = all.select { |el| el =~ /([cd]2|[fl]1|n1)$/ }
381
381
  ans = []
382
- rio('d0').entries(ere).nofiles(fre).nodirs(dre).each { |el| ans << el }
382
+ rio('d0').entries(ere).skipfiles(fre).skipdirs(dre).each { |el| ans << el }
383
383
  assert_equal(exp.sort,smap(ans).sort)
384
384
 
385
- ans = rio('d0').entries(ere).nofiles(fre).nodirs[dre]
385
+ ans = rio('d0').entries(ere).skipfiles(fre).skipdirs[dre]
386
386
  assert_equal(exp.sort,smap(ans).sort)
387
- ans = rio('d0').entries(ere).nodirs(dre).nofiles[fre]
387
+ ans = rio('d0').entries(ere).skipdirs(dre).skipfiles[fre]
388
388
  assert_equal(exp.sort,smap(ans).sort)
389
- ans = rio('d0').nofiles(fre).nodirs(dre).entries[ere]
389
+ ans = rio('d0').skipfiles(fre).skipdirs(dre).entries[ere]
390
390
  assert_equal(exp.sort,smap(ans).sort)
391
391
  end
392
392
 
@@ -396,28 +396,28 @@ class TC_RIO_noqae < Test::Unit::TestCase
396
396
  fre = /f/
397
397
  exp = all.select { |el| el =~ /(d2|l2)$/ }
398
398
  ans = []
399
- rio('d0').noentries(ere).nofiles(fre).nodirs(dre).each { |el| ans << el }
399
+ rio('d0').skipentries(ere).skipfiles(fre).skipdirs(dre).each { |el| ans << el }
400
400
  assert_equal(exp.sort,smap(ans).sort)
401
401
 
402
- ans = rio('d0').noentries(ere).nofiles(fre).nodirs[dre]
402
+ ans = rio('d0').skipentries(ere).skipfiles(fre).skipdirs[dre]
403
403
  assert_equal(exp.sort,smap(ans).sort)
404
- ans = rio('d0').noentries(ere).nodirs(dre).nofiles[fre]
404
+ ans = rio('d0').skipentries(ere).skipdirs(dre).skipfiles[fre]
405
405
  assert_equal(exp.sort,smap(ans).sort)
406
- ans = rio('d0').nofiles(fre).nodirs(dre).noentries[ere]
406
+ ans = rio('d0').skipfiles(fre).skipdirs(dre).skipentries[ere]
407
407
  assert_equal(exp.sort,smap(ans).sort)
408
408
  end
409
409
 
410
410
  begin
411
411
  exp = []
412
412
  ans = []
413
- rio('d0').noentries.dirs.each { |el| ans << el }
413
+ rio('d0').skipentries.dirs.each { |el| ans << el }
414
414
  assert_equal(exp.sort,smap(ans).sort)
415
- rio('d0').noentries.files.each { |el| ans << el }
415
+ rio('d0').skipentries.files.each { |el| ans << el }
416
416
  assert_equal(exp.sort,smap(ans).sort)
417
417
 
418
- ans = rio('d0').noentries.files[]
418
+ ans = rio('d0').skipentries.files[]
419
419
  assert_equal(exp.sort,smap(ans).sort)
420
- ans = rio('d0').noentries.dirs[]
420
+ ans = rio('d0').skipentries.dirs[]
421
421
  assert_equal(exp.sort,smap(ans).sort)
422
422
  end
423
423
 
@@ -425,9 +425,9 @@ class TC_RIO_noqae < Test::Unit::TestCase
425
425
  ere = /1/
426
426
  exp = all.select { |el| el =~ /2$/ }
427
427
  ans = []
428
- rio('d0').noentries(ere).each { |el| ans << el }
428
+ rio('d0').skipentries(ere).each { |el| ans << el }
429
429
  assert_equal(exp.sort,smap(ans).sort)
430
- ans = rio('d0').noentries[ere]
430
+ ans = rio('d0').skipentries[ere]
431
431
  assert_equal(exp.sort,smap(ans).sort)
432
432
  end
433
433
  end
@@ -440,14 +440,14 @@ class TC_RIO_noqae < Test::Unit::TestCase
440
440
  begin
441
441
  begin
442
442
  ans = []
443
- rio('d0').nofiles(/2/).each { |el| ans << el }
443
+ rio('d0').skipfiles(/2/).each { |el| ans << el }
444
444
  exp = all.reject { |el| el =~ /[fl]\d$/ }
445
445
  assert_equal(exp.sort,smap(ans).sort)
446
446
  end
447
447
 
448
448
  begin
449
449
  ans = []
450
- rio('d0').nofiles('*2').each { |el| ans << el }
450
+ rio('d0').skipfiles('*2').each { |el| ans << el }
451
451
  exp = ['d0/f1']
452
452
  assert_equal(exp.sort,smap(ans).sort)
453
453
  end
@@ -457,21 +457,21 @@ class TC_RIO_noqae < Test::Unit::TestCase
457
457
  begin
458
458
  begin
459
459
  ans = []
460
- rio('d0').nofiles.each { |el| ans << el }
460
+ rio('d0').skipfiles.each { |el| ans << el }
461
461
  exp = ['d0/d1','d0/d2']
462
462
  assert_equal(exp.sort,smap(ans).sort)
463
463
  end
464
464
 
465
465
  begin
466
466
  ans = []
467
- rio('d0').nodirs(/2/).each { |el| ans << el }
467
+ rio('d0').skipdirs(/2/).each { |el| ans << el }
468
468
  exp = ['d0/d1']
469
469
  assert_equal(exp.sort,smap(ans).sort)
470
470
  end
471
471
 
472
472
  begin
473
473
  ans = []
474
- rio('d0').nodirs('*2').each { |el| ans << el }
474
+ rio('d0').skipdirs('*2').each { |el| ans << el }
475
475
  exp = ['d0/d1']
476
476
  assert_equal(exp.sort,smap(ans).sort)
477
477
  end
@@ -479,25 +479,25 @@ class TC_RIO_noqae < Test::Unit::TestCase
479
479
  begin
480
480
  begin
481
481
  ans = []
482
- rio('d0').nofiles.dirs.each { |el| ans << el }
482
+ rio('d0').skipfiles.dirs.each { |el| ans << el }
483
483
  exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
484
484
  assert_equal(exp.sort,smap(ans).sort)
485
485
  end
486
486
  begin
487
487
  ans = []
488
- rio('d0').nofiles.dirs.each { |el| ans << el }
488
+ rio('d0').skipfiles.dirs.each { |el| ans << el }
489
489
  exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
490
490
  assert_equal(exp.sort,smap(ans).sort)
491
491
  end
492
492
  begin
493
493
  ans = []
494
- rio('d0').nofiles.dirs.each { |el| ans << el }
494
+ rio('d0').skipfiles.dirs.each { |el| ans << el }
495
495
  exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
496
496
  assert_equal(exp.sort,smap(ans).sort)
497
497
  end
498
498
  begin
499
499
  ans = []
500
- rio('d0').nofiles.dirs.each { |el| ans << el }
500
+ rio('d0').skipfiles.dirs.each { |el| ans << el }
501
501
  exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
502
502
  assert_equal(exp.sort,smap(ans).sort)
503
503
  end