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,455 @@
1
+
2
+ require 'test/unit'
3
+ require 'tutil'
4
+
5
+ $testImportNodesSignedDir ||= File.expand_path(File.dirname(__FILE__))
6
+
7
+ class TestNodesSigned < Test::Unit::TestCase
8
+ def setup
9
+ # Ensure we run in test directory.
10
+ Dir.chdir($testImportNodesSignedDir)
11
+ end
12
+ def teardown
13
+ Dir.chdir($testImportNodesSignedDir)
14
+ assert_rant("autoclean")
15
+ assert(Dir["*.t"].empty?)
16
+ assert(Dir["*.tt"].empty?)
17
+ assert(Dir["sub1/*.t"].empty?)
18
+ assert(Dir["sub1/*.tt"].empty?)
19
+ assert(!test(?e, ".rant.meta"))
20
+ end
21
+ def write(fn, str)
22
+ open fn, "w" do |f|
23
+ f.write str
24
+ end
25
+ end
26
+ def test_file
27
+ out, err = assert_rant("f1.t")
28
+ assert(err.empty?)
29
+ assert_equal("writing f1.t\n", out)
30
+ assert(test(?f, "f1.t"))
31
+ assert_equal("1\n", File.read("f1.t"))
32
+ out, err = assert_rant
33
+ assert(out.empty?)
34
+ assert(err.empty?)
35
+ assert(!test(?e, "a"))
36
+ write("f1.t", "2\n")
37
+ out, err = assert_rant
38
+ assert_equal("writing f1.t\n", out)
39
+ assert(test(?f, "f1.t"))
40
+ assert_equal("1\n", File.read("f1.t"))
41
+ out, err = assert_rant
42
+ assert(out.empty?)
43
+ assert(err.empty?)
44
+ end
45
+ def test_directory
46
+ out, err = assert_rant("d1.t")
47
+ assert(test(?d, "d1.t"))
48
+ out, err = assert_rant("d1.t")
49
+ assert(err.empty?)
50
+ assert(out.empty?)
51
+ end
52
+ def test_directory_with_pre_and_block
53
+ write("a.t", "a\n")
54
+ out, err = assert_rant(:fail, "base.t/s/s")
55
+ assert(!test(?e, "base.t"))
56
+ assert_match(/Rantfile[^\n]+14/, err)
57
+ assert_match(/base\.t/, err)
58
+ FileUtils.mkdir "base.t"
59
+ out, err = assert_rant("base.t/s/s")
60
+ assert(test(?f, "base.t/s/s/t"))
61
+ assert_equal("a\n1\n", File.read("base.t/s/s/t"))
62
+ out, err = assert_rant("base.t/s/s")
63
+ assert(out.empty?)
64
+ assert(err.empty?)
65
+ assert_rant("-af1.t", "content=2")
66
+ assert_equal("2", File.read("f1.t"))
67
+ out, err = assert_rant("base.t/s/s")
68
+ assert(test(?f, "base.t/s/s/t"))
69
+ assert_equal("a\n2", File.read("base.t/s/s/t"))
70
+ assert(!out.include?("f1.t"))
71
+ assert(out.include?("copying"))
72
+ out, err = assert_rant("base.t/s/s")
73
+ assert(out.empty?)
74
+ assert(err.empty?)
75
+ ensure
76
+ FileUtils.rm_f "a.t"
77
+ FileUtils.rm_rf "base.t"
78
+ end
79
+ def test_subfile
80
+ out, err = assert_rant("d2.t/f", "subfile=1")
81
+ assert(err.empty?)
82
+ assert(test(?f, "f1.t"))
83
+ assert(test(?f, "d2.t/f"))
84
+ assert_equal("1\n", File.read("f1.t"))
85
+ assert_equal("1\n", File.read("d2.t/f"))
86
+ out, err = assert_rant("d2.t/f", "subfile=1")
87
+ assert(err.empty?)
88
+ assert(out.empty?)
89
+ assert_rant("subfile=1", "autoclean")
90
+ end
91
+ def test_file_with_dep_on_dir_with_pre_and_block
92
+ FileUtils.mkdir "base.t"
93
+ write("a.t", "a\n")
94
+ out, err = assert_rant("f2.t")
95
+ assert(test(?f, "base.t/s/s/t"))
96
+ assert(test(?f, "f2.t"))
97
+ assert_equal(File.read("base.t/s/s/t"), File.read("f2.t"))
98
+ assert(err.empty?)
99
+ out, err = assert_rant("f2.t")
100
+ assert(err.empty?)
101
+ assert(out.empty?)
102
+ FileUtils.rm "f2.t"
103
+ out, err = assert_rant("f2.t")
104
+ assert(err.empty?)
105
+ assert_equal("cp base.t/s/s/t f2.t\n", out)
106
+ out, err = assert_rant("f2.t")
107
+ assert(err.empty?)
108
+ assert(out.empty?)
109
+ write("a.t", "aa\n")
110
+ out, err = assert_rant("f2.t")
111
+ assert_equal(File.read("base.t/s/s/t"), File.read("f2.t"))
112
+ assert(err.empty?)
113
+ assert_match(/\bcp\b/, out)
114
+ out, err = assert_rant("f2.t")
115
+ assert(err.empty?)
116
+ assert(out.empty?)
117
+ ensure
118
+ FileUtils.rm_f "a.t"
119
+ FileUtils.rm_rf "base.t"
120
+ end
121
+ def test_source_node_single_fail
122
+ out, err = assert_rant(:fail, "f3.t")
123
+ assert(out.empty?)
124
+ assert(!test(?e, "f3.t"))
125
+ assert(!test(?e, "c1.t"))
126
+ assert(!test(?e, ".rant.meta"))
127
+ lines = err.split(/\n/)
128
+ assert(lines.size < 5)
129
+ assert_match(/ERROR.*Rantfile.*34/, lines[0])
130
+ assert_match(/SourceNode.*c1\.t/, lines[1])
131
+ assert_match(/Task.*f3\.t.*fail/, lines[2])
132
+ end
133
+ def test_source_node_single
134
+ write("c1.t", "c\n")
135
+ out, err = assert_rant("f3.t")
136
+ assert(err.empty?)
137
+ assert(test(?f, "f3.t"))
138
+ assert_equal("c\n", File.read("f3.t"))
139
+ out, err = assert_rant("f3.t")
140
+ assert(err.empty?)
141
+ assert(out.empty?)
142
+ out, err = assert_rant("f3.t")
143
+ assert(err.empty?)
144
+ assert(out.empty?)
145
+ assert_rant("autoclean")
146
+ assert(!test(?e, "f3.t"))
147
+ assert(test(?f, "c1.t"))
148
+ assert_equal("c\n", File.read("c1.t"))
149
+ out, err = assert_rant("f3.t")
150
+ assert(err.empty?)
151
+ assert(test(?f, "f3.t"))
152
+ assert_equal("c\n", File.read("f3.t"))
153
+ out, err = assert_rant("f3.t")
154
+ assert(err.empty?)
155
+ assert(out.empty?)
156
+ write("c1.t", "c1\n")
157
+ out, err = assert_rant("f3.t")
158
+ assert(err.empty?)
159
+ assert_equal("writing f3.t\n", out)
160
+ assert_equal("c1\n", File.read("f3.t"))
161
+ out, err = assert_rant("f3.t")
162
+ assert(err.empty?)
163
+ assert(out.empty?)
164
+ ensure
165
+ FileUtils.rm_f "c1.t"
166
+ end
167
+ def test_source_node_fail
168
+ write("c1.t", "c\n")
169
+ write("c2.t", "c\n")
170
+ out, err = assert_rant(:fail, "f4.t")
171
+ assert(test(?f, "f3.t"))
172
+ assert_equal("writing f3.t\n", out)
173
+ lines = err.split(/\n/)
174
+ assert(lines.size < 5)
175
+ assert_match(/ERROR.*Rantfile.*36/, lines[0])
176
+ assert_match(/SourceNode.*c3\.t/, lines[1])
177
+ assert_match(/Task.*f4\.t.*fail/, lines[2])
178
+ out, err = assert_rant("f3.t")
179
+ assert(err.empty?)
180
+ assert(out.empty?)
181
+ ensure
182
+ FileUtils.rm_f "c1.t"
183
+ FileUtils.rm_f "c2.t"
184
+ end
185
+ def test_source_node
186
+ write("c1.t", "c\n")
187
+ write("c2.t", "c\n")
188
+ write("c3.t", "c\n")
189
+ out, err = assert_rant("f4.t")
190
+ assert(err.empty?)
191
+ assert(!out.empty?)
192
+ assert(test(?f, "f3.t"))
193
+ assert(test(?f, "f4.t"))
194
+ assert_equal("c\nc\n", File.read("f4.t"))
195
+ out, err = assert_rant("f4.t")
196
+ assert(err.empty?)
197
+ assert(out.empty?)
198
+ write("c3.t", "c3\n")
199
+ out, err = assert_rant("f4.t")
200
+ assert(err.empty?)
201
+ assert_equal("writing f4.t\n", out)
202
+ assert_equal("c\nc\n", File.read("f4.t"))
203
+ out, err = assert_rant("f4.t")
204
+ assert(err.empty?)
205
+ assert(out.empty?)
206
+ assert_rant("autoclean")
207
+ assert(test(?f, "c1.t"))
208
+ assert(test(?f, "c2.t"))
209
+ assert(test(?f, "c3.t"))
210
+ assert(!test(?e, "f3.t"))
211
+ assert(!test(?e, "f4.t"))
212
+ ensure
213
+ FileUtils.rm_f "c1.t"
214
+ FileUtils.rm_f "c2.t"
215
+ FileUtils.rm_f "c3.t"
216
+ end
217
+ def test_2source_node
218
+ write("c1.t", "c\n")
219
+ write("c2.t", "c\n")
220
+ write("c3.t", "c\n")
221
+ write("c4.t", "c\n")
222
+ out, err = assert_rant("f5.t")
223
+ assert(err.empty?)
224
+ assert(test(?f, "f5.t"))
225
+ assert_match(/cp.*c2\.t.*f5\.t/, out)
226
+ assert_equal("c\n", File.read("f5.t"))
227
+ out, err = assert_rant("f5.t")
228
+ assert(err.empty?)
229
+ assert(out.empty?)
230
+ write("c3.t", "c3\n")
231
+ out, err = assert_rant("f5.t")
232
+ assert(err.empty?)
233
+ assert_match(/cp.*c2\.t.*f5\.t/, out)
234
+ assert_equal("c\n", File.read("f5.t"))
235
+ out, err = assert_rant("f5.t")
236
+ assert(err.empty?)
237
+ assert(out.empty?)
238
+ assert_rant("autoclean")
239
+ assert(test(?f, "c1.t"))
240
+ assert(test(?f, "c2.t"))
241
+ assert(test(?f, "c3.t"))
242
+ assert(test(?f, "c4.t"))
243
+ assert(!test(?e, "f5.t"))
244
+ ensure
245
+ FileUtils.rm_f "c1.t"
246
+ FileUtils.rm_f "c2.t"
247
+ FileUtils.rm_f "c3.t"
248
+ FileUtils.rm_f "c4.t"
249
+ end
250
+ def test_source_node_in_subdir
251
+ write("sub1/c1.t", "c\n")
252
+ write("sub1/c2.t", "c\n")
253
+ write("c5.t", "c\n")
254
+ write("c6.t", "c\n")
255
+ out, err = assert_rant("f6.t")
256
+ assert(err.empty?)
257
+ assert_equal("writing f6.t\n", out)
258
+ assert(test(?f, "f6.t"))
259
+ assert_equal("1\n", File.read("f6.t"))
260
+ out, err = assert_rant("f6.t")
261
+ assert(err.empty?)
262
+ assert(out.empty?)
263
+ write("sub1/c2.t", "c2\n")
264
+ out, err = assert_rant("f6.t")
265
+ assert(err.empty?)
266
+ assert_equal("writing f6.t\n", out)
267
+ assert_equal("1\n", File.read("f6.t"))
268
+ out, err = assert_rant("f6.t")
269
+ assert(err.empty?)
270
+ assert(out.empty?)
271
+ assert_rant("autoclean")
272
+ assert(test(?f, "sub1/c1.t"))
273
+ assert(test(?f, "sub1/c2.t"))
274
+ assert(test(?f, "c5.t"))
275
+ assert(test(?f, "c6.t"))
276
+ assert(!test(?e, "f6.t"))
277
+ ensure
278
+ FileUtils.rm_f "sub1/c1.t"
279
+ FileUtils.rm_f "sub1/c2.t"
280
+ FileUtils.rm_f "c5.t"
281
+ FileUtils.rm_f "c6.t"
282
+ end
283
+ def test_rule
284
+ write("sub1/c1.t", "c\n")
285
+ write("sub1/c2.t", "c\n")
286
+ write("c5.t", "c\n")
287
+ write("c6.t", "c\n")
288
+ out, err = assert_rant("c5.r.t")
289
+ assert(err.empty?)
290
+ assert_match(/cp.*c5\.t.*c5\.r\.t\n/, out)
291
+ assert(test(?f, "c5.r.t"))
292
+ assert_equal("c\n", File.read("c5.r.t"))
293
+ out, err = assert_rant("c5.r.t")
294
+ assert(err.empty?)
295
+ assert(out.empty?)
296
+ write("sub1/c2.t", "c2\n")
297
+ out, err = assert_rant("c5.r.t")
298
+ assert(err.empty?)
299
+ assert_match(/cp.*c5\.t.*c5\.r\.t\n/, out)
300
+ assert_equal("c\n", File.read("c5.r.t"))
301
+ out, err = assert_rant("c5.r.t")
302
+ assert(err.empty?)
303
+ assert(out.empty?)
304
+ assert_rant("autoclean")
305
+ assert(test(?f, "sub1/c1.t"))
306
+ assert(test(?f, "sub1/c2.t"))
307
+ assert(test(?f, "c5.t"))
308
+ assert(test(?f, "c6.t"))
309
+ assert(!test(?e, "c5.r.t"))
310
+ ensure
311
+ FileUtils.rm_f "sub1/c1.t"
312
+ FileUtils.rm_f "sub1/c2.t"
313
+ FileUtils.rm_f "c5.t"
314
+ FileUtils.rm_f "c6.t"
315
+ end
316
+ def test_2rule
317
+ write("1.tt", "t\n")
318
+ out, err = assert_rant("1.r.t")
319
+ assert(err.empty?)
320
+ assert_match(/cp.*1\.tt.*1\.r\.t/, out)
321
+ assert(test(?f, "1.r.t"))
322
+ assert_equal("t\n", File.read("1.r.t"))
323
+ out, err = assert_rant("1.r.t")
324
+ assert(err.empty?)
325
+ assert(out.empty?)
326
+ write("1.tt", "r\n")
327
+ out, err = assert_rant("1.r.t")
328
+ assert(err.empty?)
329
+ assert_match(/cp.*1\.tt.*1\.r\.t/, out)
330
+ assert(test(?f, "1.r.t"))
331
+ assert_equal("r\n", File.read("1.r.t"))
332
+ out, err = assert_rant("1.r.t")
333
+ assert(err.empty?)
334
+ assert(out.empty?)
335
+ ensure
336
+ FileUtils.rm_f "1.tt"
337
+ end
338
+ def test_source_node_with_file_pre
339
+ write("c7.t", "c\n")
340
+ write("c8.t", "c\n")
341
+ out, err = assert_rant("f7.t")
342
+ assert(err.empty?)
343
+ assert_match(/cp.*c7\.t.*f7\.t/, out)
344
+ out, err = assert_rant("f7.t")
345
+ assert(err.empty?)
346
+ assert(out.empty?)
347
+ write("c8.t", "c8\n")
348
+ out, err = assert_rant("f7.t")
349
+ assert(err.empty?)
350
+ assert_match(/cp.*c7\.t.*f7\.t/, out)
351
+ out, err = assert_rant("f7.t")
352
+ assert(err.empty?)
353
+ assert(out.empty?)
354
+ assert_rant("-af1.t", "content=2")
355
+ assert_equal("2", File.read("f1.t"))
356
+ out, err = assert_rant("f7.t")
357
+ assert(err.empty?)
358
+ assert_match(/cp.*c7\.t.*f7\.t/, out)
359
+ out, err = assert_rant("f7.t")
360
+ assert(err.empty?)
361
+ assert(out.empty?)
362
+ assert_rant("autoclean")
363
+ assert(test(?f, "c7.t"))
364
+ assert(test(?f, "c8.t"))
365
+ assert(!test(?e, "f7.t"))
366
+ ensure
367
+ FileUtils.rm_f "c7.t"
368
+ FileUtils.rm_f "c8.t"
369
+ end
370
+ def test_source_node_no_invoke_pre
371
+ write("c7.t", "c\n")
372
+ write("c8.t", "c\n")
373
+ out, err = assert_rant("c7.t")
374
+ assert(err.empty?)
375
+ assert(!test(?e, "f1.t"),
376
+ "SourceNode#invoke shouldn't invoke prerequisites")
377
+ assert(out.empty?)
378
+ ensure
379
+ FileUtils.rm_f "c7.t"
380
+ FileUtils.rm_f "c8.t"
381
+ end
382
+ def test_file_last_pre_in_subdir
383
+ out, err = assert_rant("f8.t", "content=8")
384
+ assert(err.empty?)
385
+ assert(test(?f, "sub1/f1.t"))
386
+ assert(test(?f, "f8.t"))
387
+ assert(!test(?e, "f1.t"))
388
+ assert_equal("8", File.read("sub1/f1.t"))
389
+ assert_equal("8", File.read("f8.t"))
390
+ out, err = assert_rant("f8.t")
391
+ assert(err.empty?)
392
+ assert(out.empty?)
393
+ end
394
+ def test_rant_import_auto
395
+ out = run_import("-q", "--auto", "make.t")
396
+ assert_exit
397
+ FileUtils.mkdir "base.t"
398
+ write("a.t", "a\n")
399
+ out = run_ruby("make.t", "--tasks")
400
+ assert_exit
401
+ lines = out.split(/\n/)
402
+ assert_equal(2, lines.size)
403
+ assert_match(/f1\.t/, lines.first)
404
+ assert_match(/f8\.t.*copy f1\.t from sub1 to f8\.t/, lines[1])
405
+ out = run_ruby("make.t", "f2.t")
406
+ assert_exit
407
+ assert(test(?f, "base.t/s/s/t"))
408
+ assert(test(?f, "f2.t"))
409
+ assert_equal(File.read("base.t/s/s/t"), File.read("f2.t"))
410
+ out = run_ruby("make.t", "f2.t")
411
+ assert_exit
412
+ assert(out.empty?)
413
+ run_ruby("make.t", "autoclean")
414
+ assert_exit
415
+ assert(test(?f, "a.t"))
416
+ assert(!test(?e, "base.t/s"))
417
+ assert(!test(?e, "f2.t"))
418
+ ensure
419
+ FileUtils.rm_rf "base.t"
420
+ FileUtils.rm_f "a.t"
421
+ FileUtils.rm_f "make.t"
422
+ end
423
+ def test_rant_import
424
+ run_import("-q", "-imd5,autoclean", "make.t")
425
+ assert_exit
426
+ write("sub1/c1.t", "c\n")
427
+ write("sub1/c2.t", "c\n")
428
+ write("c5.t", "c\n")
429
+ write("c6.t", "c\n")
430
+ out = run_ruby("make.t", "f6.t")
431
+ assert_equal("writing f6.t", out.strip)
432
+ assert(test(?f, "f6.t"))
433
+ assert_equal("1\n", File.read("f6.t"))
434
+ out = run_ruby("make.t", "f6.t")
435
+ assert(out.strip.empty?)
436
+ write("sub1/c2.t", "c2\n")
437
+ out = run_ruby("make.t", "f6.t")
438
+ assert_equal("writing f6.t", out.strip)
439
+ assert_equal("1\n", File.read("f6.t"))
440
+ out = run_ruby("make.t", "f6.t")
441
+ assert(out.empty?)
442
+ run_ruby("make.t", "autoclean")
443
+ assert(test(?f, "sub1/c1.t"))
444
+ assert(test(?f, "sub1/c2.t"))
445
+ assert(test(?f, "c5.t"))
446
+ assert(test(?f, "c6.t"))
447
+ assert(!test(?e, "f6.t"))
448
+ ensure
449
+ FileUtils.rm_f "make.t"
450
+ FileUtils.rm_f "sub1/c1.t"
451
+ FileUtils.rm_f "sub1/c2.t"
452
+ FileUtils.rm_f "c5.t"
453
+ FileUtils.rm_f "c6.t"
454
+ end
455
+ end
@@ -0,0 +1,10 @@
1
+
2
+ import %w(md5 package/zip package/tgz autoclean)
3
+
4
+ gen Package::Zip, "pkg.t/m1", :files => sys["sub*/*"].shun("pkg.t")
5
+
6
+ gen Package::Tgz, "pkg.t/m1", :files => sys["sub*/*"].shun("pkg.t")
7
+
8
+ gen AutoClean, "clean"
9
+
10
+ # vim:ft=ruby
@@ -91,6 +91,32 @@ class TestImportPackage < Test::Unit::TestCase
91
91
  ensure
92
92
  FileUtils.rm_rf "sub/f5"
93
93
  end
94
+ def test_tgz_sync_manifest_md5
95
+ assert_rant("-imd5", "t2.tgz")
96
+ mf = %w(sub/f1 sub2/f1 m2.tgz.t)
97
+ dirs = %w(sub sub2)
98
+ check_manifest("m2.tgz.t", mf)
99
+ check_contents(:tgz, "t2.tgz", mf, dirs, "m2.tgz.t")
100
+ out, err = assert_rant("t2.tgz")
101
+ assert(out.strip.empty?)
102
+ assert(err.strip.empty?)
103
+ FileUtils.touch "sub/f5"
104
+ out, err = assert_rant("-imd5", "t2.tgz")
105
+ assert_match(/writing m2\.tgz\.t.*\n.*tar/m, out)
106
+ check_contents(:tgz, "t2.tgz", mf + %w(sub/f5), dirs, "m2.tgz.t")
107
+ FileUtils.rm "sub/f5"
108
+ out, err = assert_rant("-imd5", "t2.tgz")
109
+ assert_match(/writing m2\.tgz\.t.*\n.*tar/m, out)
110
+ check_contents(:tgz, "t2.tgz", mf, dirs, "m2.tgz.t")
111
+ # test autoclean
112
+ assert_rant("-imd5", "autoclean")
113
+ assert(!test(?e, "m2.tgz.t"))
114
+ # hmm.. the tgz will be removed by check_contents anyway...
115
+ assert(!test(?e, "t2.tgz"))
116
+ assert(!test(?e, ".rant.meta"))
117
+ ensure
118
+ FileUtils.rm_rf "sub/f5"
119
+ end
94
120
  def test_tgz_files_array
95
121
  assert_rant("t3.tgz")
96
122
  mf = %w(Rantfile sub/f1)
@@ -141,7 +167,7 @@ class TestImportPackage < Test::Unit::TestCase
141
167
  out, err = assert_rant("sub.t/pkg.tgz")
142
168
  assert(!out.empty?)
143
169
  out, err = assert_rant("sub.t/pkg.tgz")
144
- assert(out.empty?)
170
+ assert(out.strip.empty?)
145
171
  assert(test(?d, "sub.t/pkg"))
146
172
  @pkg_dir = "pkg"
147
173
  mf = %w(sub/f1)
@@ -411,6 +437,24 @@ class TestImportPackage < Test::Unit::TestCase
411
437
  ensure
412
438
  FileUtils.rm_rf "zip.t"
413
439
  end
440
+ def test_zip_with_basedir_md5
441
+ assert_rant(:fail, "-imd5", "zip.t/t4-1.0.0.zip")
442
+ assert(!test(?d, "zip.t"))
443
+ FileUtils.mkdir "zip.t"
444
+ assert_rant(:x, "-imd5", "zip.t/t4-1.0.0.zip")
445
+ mf = %w(Rantfile sub/f1 sub2/f1 MANIFEST)
446
+ dirs = %w(sub sub2)
447
+ check_contents(:zip, "zip.t/t4-1.0.0.zip", mf, dirs, "MANIFEST")
448
+ out, err = assert_rant("-imd5", "zip.t/t4-1.0.0.zip")
449
+ assert(err.empty?)
450
+ assert(out.empty?)
451
+ assert_rant("-imd5", "autoclean")
452
+ assert(test(?d, "zip.t"))
453
+ assert(!test(?e, ".rant.meta"))
454
+ assert(!test(?e, "zip.t/t4-1.0.0.zip"))
455
+ ensure
456
+ FileUtils.rm_rf "zip.t"
457
+ end
414
458
  def test_zip_from_manifest
415
459
  assert_rant(:x, "t1.zip")
416
460
  mf = %w(Rantfile sub/f1 sub2/f1 MANIFEST)
@@ -432,4 +476,86 @@ class TestImportPackage < Test::Unit::TestCase
432
476
  dirs = %w(sub)
433
477
  check_contents(:zip, "t3.zip", mf, dirs)
434
478
  end
479
+ def write(fn, str)
480
+ open fn, "w" do |f|
481
+ f.write str
482
+ end
483
+ end
484
+ def test_md5_zip_package
485
+ write("sub/pkg.t", "abc\n")
486
+ write("sub2/a.t", "a\n")
487
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
488
+ assert(err.empty?)
489
+ mf = %w(sub/f1 sub2/f1 sub2/a.t)
490
+ dirs = %w(sub sub2)
491
+ @pkg_dir = "m1"
492
+ check_contents(:zip, "pkg.t/m1.zip", mf, dirs)
493
+ FileUtils.rm "sub/pkg.t"
494
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
495
+ assert(err.empty?)
496
+ assert(out.empty?)
497
+ FileUtils.rm "sub2/a.t"
498
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
499
+ assert(err.empty?)
500
+ assert(!out.empty?)
501
+ mf = %w(sub/f1 sub2/f1)
502
+ dirs = %w(sub sub2)
503
+ @pkg_dir = "m1"
504
+ check_contents(:zip, "pkg.t/m1.zip", mf, dirs)
505
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.zip")
506
+ assert(err.empty?)
507
+ assert(out.empty?)
508
+ assert_rant("-fmd5.rf", "clean")
509
+ assert(!test(?e, "pkg.t"))
510
+ assert(!test(?e, ".rant.meta"))
511
+ ensure
512
+ FileUtils.rm_f %w(.rant.meta sub1/pkg.t sub2/a.t)
513
+ end
514
+ def test_md5_tgz_package
515
+ write("sub/pkg.t", "abc\n")
516
+ write("sub2/a.t", "a\n")
517
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
518
+ assert(err.empty?)
519
+ mf = %w(sub/f1 sub2/f1 sub2/a.t)
520
+ dirs = %w(sub sub2)
521
+ @pkg_dir = "m1"
522
+ check_contents(:tgz, "pkg.t/m1.tgz", mf, dirs)
523
+ FileUtils.rm "sub/pkg.t"
524
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
525
+ assert(err.empty?)
526
+ assert(out.empty?)
527
+ FileUtils.rm "sub2/a.t"
528
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
529
+ assert(err.empty?)
530
+ assert(!out.empty?)
531
+ mf = %w(sub/f1 sub2/f1)
532
+ dirs = %w(sub sub2)
533
+ @pkg_dir = "m1"
534
+ check_contents(:tgz, "pkg.t/m1.tgz", mf, dirs)
535
+ out, err = assert_rant("-fmd5.rf", "pkg.t/m1.tgz")
536
+ assert(err.empty?)
537
+ assert(out.empty?)
538
+ assert_rant("-fmd5.rf", "clean")
539
+ assert(!test(?e, "pkg.t"))
540
+ assert(!test(?e, ".rant.meta"))
541
+ ensure
542
+ FileUtils.rm_f %w(.rant.meta sub1/pkg.t sub2/a.t)
543
+ end
544
+ def test_rant_import_md5_empty_archive_tgz
545
+ write("empty.rf", <<-EOF)
546
+ import "md5", "archive/tgz"
547
+ gen Archive::Tgz, "empty.t", :files => []
548
+ EOF
549
+ run_import("-q", "-fempty.rf", "--auto", "make.t")
550
+ assert_exit
551
+ out = run_ruby("make.t", "-fempty.rf", "empty.t.tgz")
552
+ assert_exit
553
+ mf = %w()
554
+ dirs = %w()
555
+ check_contents(:tgz, "empty.t.tgz", mf, dirs)
556
+ out = run_ruby("make.t", "-fempty.rf", "empty.t.tgz")
557
+ assert(out.empty?)
558
+ ensure
559
+ FileUtils.rm_f %w(make.t empty.rf empty.t.tgz)
560
+ end
435
561
  end
@@ -0,0 +1,15 @@
1
+
2
+ import "signedfile", "autoclean"
3
+
4
+ gen SignedDirectory, "d1.t"
5
+
6
+ gen SignedDirectory, "d2.t" do |t|
7
+ sys.touch "#{t.name}/a"
8
+ end
9
+
10
+ gen SignedDirectory, "d3.t" => sys["{a,b,c}.t"] do |t|
11
+ sys.rm_f sys["#{t.name}/*"]
12
+ sys.cp t.prerequisites, t.name
13
+ end
14
+
15
+ gen AutoClean