rant 0.4.2 → 0.4.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 (56) hide show
  1. data/NEWS +14 -0
  2. data/README +13 -7
  3. data/Rantfile +11 -0
  4. data/doc/md5.rdoc +49 -0
  5. data/doc/rantfile.rdoc +1 -1
  6. data/lib/rant/coregen.rb +193 -0
  7. data/lib/rant/import/archive/zip.rb +2 -0
  8. data/lib/rant/import/archive.rb +10 -2
  9. data/lib/rant/import/autoclean.rb +16 -7
  10. data/lib/rant/import/c/dependencies.rb +1 -1
  11. data/lib/rant/import/directedrule.rb +2 -2
  12. data/lib/rant/import/md5.rb +16 -0
  13. data/lib/rant/import/metadata.rb +162 -0
  14. data/lib/rant/import/nodes/default.rb +490 -0
  15. data/lib/rant/import/nodes/signed.rb +84 -0
  16. data/lib/rant/import/package/zip.rb +2 -0
  17. data/lib/rant/import/rubydoc.rb +5 -1
  18. data/lib/rant/import/rubypackage.rb +2 -1
  19. data/lib/rant/import/signature/md5.rb +38 -0
  20. data/lib/rant/import/signedfile.rb +235 -0
  21. data/lib/rant/import/subfile.rb +1 -1
  22. data/lib/rant/import.rb +5 -1
  23. data/lib/rant/node.rb +165 -0
  24. data/lib/rant/plugin/csharp.rb +2 -0
  25. data/lib/rant/rantlib.rb +64 -9
  26. data/lib/rant/rantsys.rb +39 -27
  27. data/lib/rant/rantvar.rb +32 -2
  28. data/misc/TODO +66 -0
  29. data/test/import/c/dependencies/test_on_the_fly.rb +52 -0
  30. data/test/import/metadata/Rantfile +16 -0
  31. data/test/import/metadata/sub/Rantfile +17 -0
  32. data/test/import/metadata/test_metadata.rb +126 -0
  33. data/test/import/nodes/signed/Rantfile +89 -0
  34. data/test/import/nodes/signed/sub1/Rantfile +6 -0
  35. data/test/import/nodes/signed/test_signed.rb +455 -0
  36. data/test/import/package/md5.rf +10 -0
  37. data/test/import/package/test_package.rb +127 -1
  38. data/test/import/signeddirectory/Rantfile +15 -0
  39. data/test/import/signeddirectory/test_signeddirectory.rb +84 -0
  40. data/test/import/signedfile/Rantfile +90 -0
  41. data/test/import/signedfile/sub1/Rantfile +4 -0
  42. data/test/import/signedfile/test_signedfile.rb +338 -0
  43. data/test/project1/Rantfile +0 -9
  44. data/test/project1/test_project.rb +2 -0
  45. data/test/project_rb1/test_project_rb1.rb +27 -10
  46. data/test/rant-import/test_rant-import.rb +46 -9
  47. data/test/subdirs/sub2/sub/rantfile +0 -5
  48. data/test/subdirs/test_subdirs.rb +0 -9
  49. data/test/test_examples.rb +131 -3
  50. data/test/test_filelist.rb +44 -0
  51. data/test/test_sys.rb +19 -1
  52. data/test/test_task.rb +2 -2
  53. data/test/tutil.rb +9 -3
  54. metadata +34 -4
  55. data/lib/rant/rantfile.rb +0 -897
  56. data/test/test_lighttask.rb +0 -68
@@ -0,0 +1,84 @@
1
+
2
+ require 'test/unit'
3
+ require 'tutil'
4
+
5
+ $testImportSignedDirectoryDir ||= File.expand_path(File.dirname(__FILE__))
6
+
7
+ class TestSignedDirectory < Test::Unit::TestCase
8
+ def setup
9
+ # Ensure we run in test directory.
10
+ Dir.chdir($testImportSignedDirectoryDir)
11
+ end
12
+ def teardown
13
+ Dir.chdir($testImportSignedDirectoryDir)
14
+ assert_rant("autoclean")
15
+ assert(Dir["*.t"].empty?)
16
+ assert(!test(?e, ".rant.meta"))
17
+ end
18
+ def write(fn, str)
19
+ open fn, "w" do |f|
20
+ f.write str
21
+ end
22
+ end
23
+ def test_plain_dir
24
+ out, err = assert_rant
25
+ assert(err.empty?)
26
+ assert(!out.include?("touch"))
27
+ assert(test(?d, "d1.t"))
28
+ out, err = assert_rant
29
+ assert(err.empty?)
30
+ assert(out.empty?)
31
+ end
32
+ def test_with_block
33
+ out, err = assert_rant("d2.t")
34
+ assert(test(?d, "d2.t"))
35
+ assert(test(?f, "d2.t/a"))
36
+ assert(err.empty?)
37
+ out, err = assert_rant("d2.t")
38
+ assert(err.empty?)
39
+ assert(out.empty?)
40
+ out, err = assert_rant("d2.t")
41
+ assert(err.empty?)
42
+ assert(out.empty?)
43
+ end
44
+ def test_block_and_plain_file_deps
45
+ write("a.t", "a\n")
46
+ out, err = assert_rant("d3.t")
47
+ assert(test(?f, "d3.t/a.t"))
48
+ assert_equal("a\n", File.read("d3.t/a.t"))
49
+ assert(err.empty?)
50
+ out, err = assert_rant("d3.t")
51
+ assert(err.empty?)
52
+ assert(out.empty?)
53
+ write("b.t", "b\n")
54
+ out, err = assert_rant("d3.t")
55
+ assert(test(?f, "d3.t/a.t"))
56
+ assert(test(?f, "d3.t/b.t"))
57
+ assert_equal("a\n", File.read("d3.t/a.t"))
58
+ assert_equal("b\n", File.read("d3.t/b.t"))
59
+ assert(err.empty?)
60
+ out, err = assert_rant("d3.t")
61
+ assert(err.empty?)
62
+ assert(out.empty?)
63
+ write("b.t", "bb\n")
64
+ out, err = assert_rant("d3.t")
65
+ assert(test(?f, "d3.t/a.t"))
66
+ assert(test(?f, "d3.t/b.t"))
67
+ assert_equal("a\n", File.read("d3.t/a.t"))
68
+ assert_equal("bb\n", File.read("d3.t/b.t"))
69
+ assert(err.empty?)
70
+ out, err = assert_rant("d3.t")
71
+ assert(err.empty?)
72
+ assert(out.empty?)
73
+ FileUtils.rm "a.t"
74
+ out, err = assert_rant("d3.t")
75
+ assert(test(?f, "d3.t/b.t"))
76
+ assert_equal("bb\n", File.read("d3.t/b.t"))
77
+ assert(err.empty?)
78
+ out, err = assert_rant("d3.t")
79
+ assert(err.empty?)
80
+ assert(out.empty?)
81
+ ensure
82
+ FileUtils.rm_f Dir["{a,b,c}.t"]
83
+ end
84
+ end
@@ -0,0 +1,90 @@
1
+
2
+ import "signedfile", "autoclean"
3
+
4
+ var :content => "1\n"
5
+
6
+ gen SignedFile, "f1.t"
7
+
8
+ gen SignedFile, "f2.t" do |t|
9
+ write_content(t.name)
10
+ end
11
+
12
+ desc "create f3.t"
13
+ gen SignedFile, "f3.t" => "f2.t" do |t|
14
+ write_content(t.name)
15
+ end
16
+
17
+ gen SignedFile, "f4.t" => ["f3.t"] do |t|
18
+ write_content(t.name)
19
+ end
20
+
21
+ file "f5.t" => "f2.t" do |t|
22
+ write_content(t.name)
23
+ end
24
+
25
+ gen SignedFile, "f6.t" => "f5.t" do |t|
26
+ write_content(t.name)
27
+ end
28
+
29
+ gen SignedFile, "f7.t" => ["a.t", "f2.t", "b.t"] do |t|
30
+ write_content(t.name)
31
+ end
32
+
33
+ gen SignedFile, "f8.t" => "f1.t" do |t|
34
+ write_content(t.name)
35
+ end
36
+
37
+ gen SignedFile, "f9.t" => "f1.t" do |t|
38
+ t.fail "need #{t.source}" unless test(?f, t.source)
39
+ write_content(t.name)
40
+ end
41
+
42
+ gen SignedFile, "f10.t" do |t|
43
+ puts "should create f10.t"
44
+ end
45
+
46
+ gen SignedFile, "f11.t" => ["sub1/s1.t", "f12.t"] do |t|
47
+ write_content(t.name)
48
+ end
49
+
50
+ gen SignedFile, "f12.t" do |t|
51
+ write_content(t.name)
52
+ end
53
+
54
+ gen Directory, "d1.t"
55
+
56
+ gen SignedFile, "d1.t/f13.t" => "d1.t" do |t|
57
+ write_content(t.name)
58
+ end
59
+
60
+ var :dn2 => "d2.t"
61
+ gen SignedFile, "#{var :dn2}/f14.t" => var[:dn2] do |t|
62
+ write_content(t.name)
63
+ end
64
+
65
+ gen SignedFile, "f15.t" => "f15.t" do |t|
66
+ write_content(t.name)
67
+ end
68
+
69
+ gen SignedFile, "f16.t" => "f17.t" do |t|
70
+ write_content(t.name)
71
+ end
72
+
73
+ gen SignedFile, "f17.t" => "f16.t" do |t|
74
+ write_content(t.name)
75
+ end
76
+
77
+ gen SignedFile, "f18.t" do |t|
78
+ sys.mkdir t.name
79
+ end
80
+
81
+ subdirs "sub1"
82
+
83
+ gen AutoClean
84
+
85
+ def write_content(fn)
86
+ puts "writing #{fn}"
87
+ open fn, "w" do |f|
88
+ f.write(var[:content])
89
+ end
90
+ end
@@ -0,0 +1,4 @@
1
+
2
+ gen SignedFile, "s1.t" => "#f2.t" do |t|
3
+ write_content(t.name)
4
+ end
@@ -0,0 +1,338 @@
1
+
2
+ require 'test/unit'
3
+ require 'tutil'
4
+
5
+ $testImportSignedFileDir ||= File.expand_path(File.dirname(__FILE__))
6
+
7
+ class TestSignedFile < Test::Unit::TestCase
8
+ def setup
9
+ # Ensure we run in test directory.
10
+ Dir.chdir($testImportSignedFileDir)
11
+ end
12
+ def teardown
13
+ Dir.chdir($testImportSignedFileDir)
14
+ assert_rant("autoclean")
15
+ assert(Dir["*.t"].empty?)
16
+ assert(Dir["sub1/*.t"].empty?)
17
+ assert(!test(?e, ".rant.meta"))
18
+ assert(!test(?e, "sub1/.rant.meta"))
19
+ end
20
+ def write(fn, str)
21
+ open fn, "w" do |f|
22
+ f.write str
23
+ end
24
+ end
25
+ def test_no_pre_no_action
26
+ assert_rant
27
+ assert(!test(?f, "f1.t"))
28
+ assert_rant
29
+ assert(!test(?f, "f1.t"))
30
+ end
31
+ def test_no_pre
32
+ out, err = assert_rant("f2.t")
33
+ assert(err.empty?)
34
+ assert_match(/writing/, out)
35
+ assert(test(?f, "f2.t"))
36
+ assert_equal("1\n", File.read("f2.t"))
37
+ out, err = assert_rant("f2.t")
38
+ assert(err.empty?)
39
+ assert(out.empty?)
40
+ write("f2.t", "2\n")
41
+ out, err = assert_rant("f2.t")
42
+ assert(err.empty?)
43
+ assert_match(/writing/, out)
44
+ assert_equal("1\n", File.read("f2.t"))
45
+ out, err = assert_rant("f2.t")
46
+ assert(err.empty?)
47
+ assert(out.empty?)
48
+ end
49
+ def test_one_pre
50
+ out, err = assert_rant("f3.t")
51
+ assert(test(?f, "f2.t"))
52
+ assert(test(?f, "f3.t"))
53
+ assert_equal("1\n", File.read("f2.t"))
54
+ assert_equal("1\n", File.read("f3.t"))
55
+ assert_match(/writing f2\.t\nwriting f3\.t/, out)
56
+ assert(err.empty?)
57
+ FileUtils.rm "f2.t"
58
+ out, err = assert_rant("f3.t")
59
+ assert(test(?f, "f2.t"))
60
+ assert(test(?f, "f3.t"))
61
+ assert_equal("1\n", File.read("f2.t"))
62
+ assert_equal("1\n", File.read("f3.t"))
63
+ assert_match(/\Awriting f2\.t\n\Z/, out)
64
+ assert(!out.include?("f3")) # OK, redundant
65
+ FileUtils.rm "f2.t"
66
+ assert_rant("f2.t", "content=2")
67
+ assert(test(?f, "f2.t"))
68
+ assert_equal("2", File.read("f2.t"))
69
+ out, err = assert_rant("f3.t")
70
+ assert_equal("2", File.read("f2.t"))
71
+ assert_equal("1\n", File.read("f3.t"))
72
+ assert(err.empty?)
73
+ assert_match(/\Awriting f3\.t\n\Z/, out)
74
+ assert(!out.include?("f2")) # OK, redundant
75
+ out, err = assert_rant("f3.t")
76
+ assert(out.empty?)
77
+ end
78
+ def test_one_pre_list
79
+ out, err = assert_rant("f4.t")
80
+ assert(test(?f, "f2.t"))
81
+ assert(test(?f, "f3.t"))
82
+ assert(test(?f, "f4.t"))
83
+ assert_equal("1\n", File.read("f2.t"))
84
+ assert_equal("1\n", File.read("f3.t"))
85
+ assert_equal("1\n", File.read("f4.t"))
86
+ assert(err.empty?)
87
+ assert_equal("writing f2.t\nwriting f3.t\nwriting f4.t\n", out)
88
+ out, err = assert_rant("f4.t")
89
+ assert(err.empty?)
90
+ assert(out.empty?)
91
+ assert_rant("autoclean")
92
+ assert(!test(?e, "f2.t"))
93
+ assert(!test(?e, "f3.t"))
94
+ assert(!test(?e, "f4.t"))
95
+ end
96
+ def test_opt_tasks
97
+ out, err = assert_rant("--tasks")
98
+ assert(err.empty?)
99
+ lines = out.split(/\n/)
100
+ assert_equal(2, lines.size)
101
+ assert_match(/rant\s+#.*f1\.t/, lines[0])
102
+ assert_match(/rant\s+f3\.t\s+#\s+create f3\.t\b/, lines[1])
103
+ assert(!test(?e, ".rant.meta"))
104
+ assert(Dir["*.t"].empty?)
105
+ end
106
+ def test_file_mtime_with_signed_dep
107
+ out, err = assert_rant("f5.t")
108
+ assert(err.empty?)
109
+ assert(test(?f, "f2.t"))
110
+ assert(test(?f, "f5.t"))
111
+ assert_equal("1\n", File.read("f2.t"))
112
+ assert_equal("1\n", File.read("f5.t"))
113
+ out, err = assert_rant("f5.t")
114
+ assert(err.empty?)
115
+ assert(out.empty?)
116
+ timeout
117
+ FileUtils.touch "f2.t"
118
+ out, err = assert_rant("f5.t")
119
+ assert(err.empty?)
120
+ assert_match(/\Awriting f5\.t\n\Z/, out)
121
+ assert_equal("1\n", File.read("f2.t"))
122
+ assert_equal("1\n", File.read("f5.t"))
123
+ out, err = assert_rant("f5.t")
124
+ assert(err.empty?)
125
+ assert(out.empty?)
126
+ end
127
+ def test_with_file_mtime_dep
128
+ out, err = assert_rant("f6.t")
129
+ assert(test(?f, "f2.t"))
130
+ assert(test(?f, "f5.t"))
131
+ assert(test(?f, "f6.t"))
132
+ assert_equal("1\n", File.read("f2.t"))
133
+ assert_equal("1\n", File.read("f5.t"))
134
+ assert_equal("1\n", File.read("f6.t"))
135
+ out, err = assert_rant("f6.t")
136
+ assert(err.empty?)
137
+ assert(out.empty?)
138
+ =begin
139
+ # could be optimized to work
140
+ timeout
141
+ FileUtils.touch "f2.t"
142
+ out, err = assert_rant("f6.t")
143
+ assert(err.empty?)
144
+ lines = out.split(/\n/)
145
+ p lines
146
+ assert_equal(1, lines.size)
147
+ assert_equal("writing f5.t", lines.first)
148
+ =end
149
+ end
150
+ def test_file_dep_signed_dep_file_dep
151
+ out, err = assert_rant(:fail, "f7.t")
152
+ assert(out.empty?)
153
+ lines = err.split(/\n/)
154
+ assert_equal(4, lines.size)
155
+ assert_match(/\[ERROR\].*Rantfile.*29/, lines[0])
156
+ assert_match(/no.*a\.t/, lines[1])
157
+ assert_match(/f7\.t.*fail/, lines[2])
158
+ write("a.t", "a\n")
159
+ out, err = assert_rant(:fail, "f7.t")
160
+ assert_equal("writing f2.t\n", out)
161
+ lines = err.split(/\n/)
162
+ assert_equal(4, lines.size)
163
+ assert_match(/\[ERROR\].*Rantfile.*29/, lines[0])
164
+ assert_match(/no.*b\.t/, lines[1])
165
+ assert_match(/f7\.t.*fail/, lines[2])
166
+ write("b.t", "b\n")
167
+ out, err = assert_rant("f7.t")
168
+ assert(err.empty?)
169
+ lines = out.split(/\n/)
170
+ assert_equal(1, lines.size)
171
+ assert_equal("writing f7.t", lines.first)
172
+ timeout
173
+ FileUtils.touch "b.t"
174
+ out, err = assert_rant("f7.t")
175
+ assert(err.empty?)
176
+ assert(out.empty?)
177
+ write("b.t", "c\n")
178
+ out, err = assert_rant("f7.t")
179
+ assert(err.empty?)
180
+ lines = out.split(/\n/)
181
+ assert_equal(1, lines.size)
182
+ assert_equal("writing f7.t", lines.first)
183
+ out, err = assert_rant("f7.t")
184
+ assert(err.empty?)
185
+ assert(out.empty?)
186
+ out, err = assert_rant("f7.t")
187
+ assert(err.empty?)
188
+ assert(out.empty?)
189
+ ensure
190
+ FileUtils.rm_f %w(a.t b.t)
191
+ end
192
+ def test_dep_on_no_action
193
+ out, err = assert_rant("f8.t")
194
+ assert(err.empty?)
195
+ assert(test(?f, "f8.t"))
196
+ assert(!test(?e, "f1.t"))
197
+ assert_equal("writing f8.t\n", out)
198
+ assert_equal("1\n", File.read("f8.t"))
199
+ out, err = assert_rant("f8.t")
200
+ assert(err.empty?)
201
+ assert(out.empty?)
202
+ end
203
+ def test_dep_on_no_action_fail
204
+ out, err = assert_rant(:fail, "f9.t")
205
+ assert(out.empty?)
206
+ assert_match(/need f1\.t/, err)
207
+ assert_match(/38/, err)
208
+ out, err = assert_rant(:fail, "f9.t")
209
+ assert(out.empty?)
210
+ assert_match(/need f1\.t/, err)
211
+ assert_match(/38/, err)
212
+ end
213
+ def test_action_no_create
214
+ out, err = assert_rant("f10.t")
215
+ assert(err.empty?)
216
+ assert_equal("should create f10.t\n", out)
217
+ out, err = assert_rant("f10.t")
218
+ assert(err.empty?)
219
+ assert_equal("should create f10.t\n", out)
220
+ out, err = assert_rant("f10.t")
221
+ assert(err.empty?)
222
+ assert_equal("should create f10.t\n", out)
223
+ end
224
+ def test_sub1_no_task
225
+ out, err = assert_rant(:fail, "s1.t")
226
+ assert(out.empty?)
227
+ assert_match(/ERROR.*s1\.t/, err)
228
+ assert(!test(?e, ".rant.meta"))
229
+ end
230
+ def test_sub1
231
+ out, err = assert_rant("sub1/s1.t")
232
+ assert(err.empty?)
233
+ assert(test(?f, "f2.t"))
234
+ assert(test(?f, "sub1/s1.t"))
235
+ out, err = assert_rant("sub1/s1.t")
236
+ assert(err.empty?)
237
+ assert(out.empty?)
238
+ assert_equal("1\n", File.read("f2.t"))
239
+ assert_equal("1\n", File.read("sub1/s1.t"))
240
+ end
241
+ def test_rant_import
242
+ run_import "--auto", "-q", "make.t"
243
+ assert_exit
244
+ out = run_ruby("make.t", "sub1/s1.t")
245
+ assert_exit
246
+ assert(test(?f, "f2.t"))
247
+ assert(test(?f, "sub1/s1.t"))
248
+ out = run_ruby("make.t", "sub1/s1.t")
249
+ assert(out.empty?)
250
+ assert_equal("1\n", File.read("f2.t"))
251
+ assert_equal("1\n", File.read("sub1/s1.t"))
252
+ ensure
253
+ FileUtils.rm_f "make.t"
254
+ end
255
+ def test_dep_on_mtime_dirnode
256
+ out, err = assert_rant("d1.t/f13.t")
257
+ assert(err.empty?)
258
+ assert(!out.empty?)
259
+ assert(test(?f, "d1.t/f13.t"))
260
+ assert_equal("1\n", File.read("d1.t/f13.t"))
261
+ out, err = assert_rant("d1.t/f13.t")
262
+ assert(err.empty?)
263
+ assert(out.empty?)
264
+ end
265
+ def test_dep_on_dir
266
+ FileUtils.mkdir "d2.t"
267
+ FileUtils.mkdir "d3.t"
268
+ out, err = assert_rant("d2.t/f14.t")
269
+ assert(err.empty?)
270
+ assert(!out.empty?)
271
+ assert(test(?f, "d2.t/f14.t"))
272
+ assert_equal("1\n", File.read("d2.t/f14.t"))
273
+ out, err = assert_rant("d2.t/f14.t")
274
+ assert(err.empty?)
275
+ assert(out.empty?)
276
+ out, err = assert_rant("d2.t/f14.t")
277
+ assert(err.empty?)
278
+ assert(out.empty?)
279
+ out, err = assert_rant("d3.t/f14.t", "dn2=d3.t")
280
+ assert(err.empty?)
281
+ assert_equal("writing d3.t/f14.t\n", out)
282
+ assert(test(?f, "d3.t/f14.t"))
283
+ assert_equal("1\n", File.read("d3.t/f14.t"))
284
+ out, err = assert_rant("d3.t/f14.t", "dn2=d3.t")
285
+ assert(err.empty?)
286
+ assert(out.empty?)
287
+ out, err = assert_rant("d3.t/f14.t", "dn2=d3.t")
288
+ assert(err.empty?)
289
+ assert(out.empty?)
290
+ ensure
291
+ FileUtils.rm_rf %w(d2.t d3.t)
292
+ end
293
+ def test_force
294
+ out, err = assert_rant("f3.t")
295
+ assert(test(?f, "f2.t"))
296
+ assert(test(?f, "f3.t"))
297
+ assert(err.empty?)
298
+ assert_equal("writing f2.t\nwriting f3.t\n", out)
299
+ out, err = assert_rant("f3.t")
300
+ assert(err.empty?)
301
+ assert(out.empty?)
302
+ out, err = assert_rant("-af3.t")
303
+ assert_equal("writing f2.t\nwriting f3.t\n", out)
304
+ out, err = assert_rant("f3.t")
305
+ assert(err.empty?)
306
+ assert(out.empty?)
307
+ end
308
+ def test_dep_on_self
309
+ out, err = nil, nil
310
+ th = Thread.new { out, err = assert_rant("f15.t") }
311
+ assert_equal(th, th.join(0.5))
312
+ #assert_match(/WARNING/, err)
313
+ #assert_match(/f15\.t/, err)
314
+ assert(test(?f, "f15.t"))
315
+ th = Thread.new { assert_rant("f15.t") }
316
+ assert_equal(th, th.join(0.5))
317
+ #assert_match(/WARNING/, err)
318
+ #assert_match(/f15\.t/, err)
319
+ end
320
+ def test_circular_dependency
321
+ out, err = nil, nil
322
+ th = Thread.new { out, err = assert_rant("f17.t") }
323
+ assert_equal(th, th.join(0.5))
324
+ assert_match(/WARNING/, err)
325
+ assert_match(/f17\.t/, err)
326
+ assert(test(?f, "f16.t"))
327
+ assert(test(?f, "f17.t"))
328
+ end
329
+ def test_mkdir
330
+ out, err = assert_rant("f18.t")
331
+ assert(err.empty?)
332
+ assert(!out.empty?)
333
+ assert(test(?d, "f18.t"))
334
+ out, err = assert_rant("f18.t")
335
+ assert(err.empty?)
336
+ assert(out.empty?)
337
+ end
338
+ end
@@ -100,15 +100,6 @@ file "inc" => "incdep" do |t|
100
100
  sys.touch t.name
101
101
  end
102
102
 
103
- gen LightTask, :lighttask do |t|
104
- t.needed do
105
- !test ?f, "lt_target"
106
- end
107
- t.act do
108
- sys.touch "lt_target"
109
- end
110
- end
111
-
112
103
  gen Task, :task_one do |t|
113
104
  t.needed do
114
105
  !test ?f, "one_target"
@@ -176,6 +176,7 @@ class TestProject1 < Test::Unit::TestCase
176
176
  assert(old_mtime < test(?M, "inc"),
177
177
  "dependency `incdep' is newer, so `inc' should get rebuilt")
178
178
  end
179
+ =begin
179
180
  def test_lighttask
180
181
  capture_std do
181
182
  assert_equal(Rant.run("lighttask"), 0)
@@ -183,6 +184,7 @@ class TestProject1 < Test::Unit::TestCase
183
184
  assert(test(?e, "lt_target"),
184
185
  "lt_target should get `touched' by lighttask")
185
186
  end
187
+ =end
186
188
  def test_task_gen_one_arg
187
189
  capture_std do
188
190
  assert_equal(Rant.run("task_one"), 0)
@@ -29,16 +29,33 @@ class TestProjectRb1 < Test::Unit::TestCase
29
29
  }
30
30
  end
31
31
  def test_doc
32
- assert_rant("doc")
33
- assert(test(?d, "doc"),
34
- "RDoc task should generate dir `doc'")
35
- assert(test(?f, "doc/index.html"),
36
- "doc/index.html should exist after `doc'")
37
- fl = Dir["doc/files/**/*"]
38
- assert(fl.find { |f| f =~ /wgrep/ },
39
- "lib/wgrep.rb should get documented")
40
- assert(fl.find { |f| f =~ /README/ },
41
- "README should be in html docs")
32
+ have_rdoc = true
33
+ begin
34
+ require 'rdoc/rdoc'
35
+ rescue LoadError
36
+ have_rdoc = false
37
+ end
38
+ if have_rdoc
39
+ assert_rant("doc")
40
+ assert(test(?d, "doc"),
41
+ "RDoc task should generate dir `doc'")
42
+ assert(test(?f, "doc/index.html"),
43
+ "doc/index.html should exist after `doc'")
44
+ fl = Dir["doc/files/**/*"]
45
+ assert(fl.find { |f| f =~ /wgrep/ },
46
+ "lib/wgrep.rb should get documented")
47
+ assert(fl.find { |f| f =~ /README/ },
48
+ "README should be in html docs")
49
+ else
50
+ STDERR.puts "*** rdoc not available ***"
51
+ out, err = assert_rant(:fail, "doc")
52
+ lines = err.split(/\n/)
53
+ lines.reject! { |s| s.strip.empty? }
54
+ assert_equal(4, lines.size)
55
+ assert_match(/ERROR.*in file.*line \d+/, lines[0])
56
+ assert_match(/RDoc not available/, lines[1])
57
+ assert_match(/doc.*fail/, lines[2])
58
+ end
42
59
  end
43
60
  def test_test
44
61
  assert_rant("test")
@@ -169,34 +169,71 @@ class TestRantImport < Test::Unit::TestCase
169
169
  FileUtils.mkdir "features.t"
170
170
  Dir.chdir "features.t"
171
171
  FileUtils.mkpath "rant/import"
172
- open "rant/import/foo.rb", "w" do |f|
172
+ open "rant/import/t_loaded_features_foo.rb", "w" do |f|
173
173
  f << <<-EOF
174
- def foo
175
- puts "foo"
174
+ def t_loaded_features_foo
175
+ puts "t_loaded_features_foo"
176
176
  end
177
177
  EOF
178
178
  end
179
179
  open "Rantfile", "w" do |f|
180
180
  f << <<-EOF
181
- import "foo"
182
- require 'rant/import/foo'
181
+ import "t_loaded_features_foo"
182
+ require 'rant/import/t_loaded_features_foo'
183
183
  task :default do
184
- foo
184
+ t_loaded_features_foo
185
185
  end
186
186
  EOF
187
187
  end
188
188
  out, err = assert_rant
189
- assert_match(/foo/, out)
189
+ assert_match(/t_loaded_features_foo/, out)
190
190
  assert(err.empty?)
191
191
  run_import("-q", "--auto", "make.rb")
192
192
  assert_exit
193
193
  assert(test(?f, "make.rb"))
194
194
  out = run_ruby("make.rb")
195
195
  assert_exit
196
- assert_match(/foo/, out)
196
+ assert_match(/t_loaded_features_foo/, out)
197
197
  FileUtils.rm_rf "rant"
198
198
  out = run_ruby("make.rb")
199
199
  assert_exit
200
- assert_match(/foo/, out)
200
+ assert_match(/t_loaded_features_foo/, out)
201
+ end
202
+ def test_init_import
203
+ FileUtils.mkdir "init.t"
204
+ Dir.chdir "init.t"
205
+ FileUtils.mkpath "rant/import"
206
+ open "rant/import/t_init_import_foo.rb", "w" do |f|
207
+ f << <<-EOF
208
+ module Rant
209
+ def self.init_import_t_init_import_foo(rac, *rest)
210
+ puts "init import t_init_import_foo"
211
+ rac.cx.var["t_init_import_foo"] = "t_init_import_foo init"
212
+ end
213
+ end
214
+ EOF
215
+ end
216
+ open "Rantfile", "w" do |f|
217
+ f << <<-EOF
218
+ import "t_init_import_foo"
219
+ task :a do |t|
220
+ puts var[:t_init_import_foo]
221
+ end
222
+ import "t_init_import_foo"
223
+ EOF
224
+ end
225
+ out, err = assert_rant
226
+ assert_match(/\Ainit import t_init_import_foo\nt_init_import_foo init\n\n?\Z/m, out)
227
+ assert(err.empty?)
228
+ run_import("-q", "--auto", "make.rb")
229
+ assert_exit
230
+ assert(test(?f, "make.rb"))
231
+ out = run_ruby("make.rb")
232
+ assert_exit
233
+ assert_match(/\Ainit import t_init_import_foo\nt_init_import_foo init\n\n?\Z/m, out)
234
+ FileUtils.rm_rf "rant"
235
+ out = run_ruby("make.rb")
236
+ assert_exit
237
+ assert_match(/\Ainit import t_init_import_foo\nt_init_import_foo init\n\n?\Z/m, out)
201
238
  end
202
239
  end
@@ -15,11 +15,6 @@ gen Task, "gt" => "dt" do |t|
15
15
  t.act { sys.touch t.name }
16
16
  end
17
17
 
18
- gen LightTask, "lt" do |lt|
19
- lt.needed { !test(?f, lt.name) }
20
- lt.act { sys.touch lt.name }
21
- end
22
-
23
18
  task :create_param do
24
19
  sys.touch var[:param]
25
20
  end