rant 0.4.4 → 0.4.6

data/test/import/metadata/test_metadata.rb

@@ -24,7 +24,7 @@ class TestMetaData < Test::Unit::TestCase
     def test_subdir
         out, err = assert_rant("subdir=true", "sub/b")
         assert(err.empty?)
-        assert_equal("nil\nnil\ntouch b\n", out)
+        assert_equal("nil\nnil\n(in sub)\ntouch b\n", out)
         assert(test(?f, ".rant.meta"))
         assert(test(?f, "sub/.rant.meta"))
         out, err = assert_rant("subdir=true", "sub/b")
@@ -37,7 +37,7 @@ class TestMetaData < Test::Unit::TestCase
         FileUtils.rm ".rant.meta"
         out = run_ruby("make.t", "subdir=true", "sub/b")
         assert_exit
-        assert_equal("nil\nnil\ntouch b\n", out)
+        assert_equal("nil\nnil\n(in sub)\ntouch b\n", out)
         assert(test(?f, ".rant.meta"))
         assert(test(?f, "sub/.rant.meta"))
         out = run_ruby("make.t", "subdir=true", "sub/b")

data/test/import/package/test_package.rb

@@ -1,10 +1,12 @@
 
 require 'test/unit'
 require 'tutil'
+require 'rant/import/sys/tgz'
 
 $testIPackageDir ||= File.expand_path(File.dirname(__FILE__))
 
 class TestImportPackage < Test::Unit::TestCase
+    include Rant::TestUtil
     def setup
 	# Ensure we run in test directory.
 	Dir.chdir $testIPackageDir
@@ -23,7 +25,12 @@ class TestImportPackage < Test::Unit::TestCase
 	FileUtils.cp archive, "u.t"
 	FileUtils.cd "u.t"
 	archive = File.basename archive
-	unpack_archive atype, archive
+        case atype
+        when :tgz: Rant::Sys.unpack_tgz(archive)
+        when :zip: Rant::Sys.unpack_zip(archive)
+        else
+            raise "unknown archive type -- #{atype}"
+        end
 	if @pkg_dir
 	    assert(test(?d, @pkg_dir))
 	    FileUtils.cd @pkg_dir
@@ -558,4 +565,36 @@ class TestImportPackage < Test::Unit::TestCase
     ensure
         FileUtils.rm_f %w(make.t empty.rf empty.t.tgz)
     end
+    def test_package_tgz_flag_manifest_opt_files
+        in_local_temp_dir do
+            write_to_file "root.rant", <<-EOF
+            import "md5", "package/tgz", "autoclean"
+            gen Package::Tgz, "a-b", :manifest, :files => sys["*"].exclude("u")
+            gen AutoClean
+            EOF
+            write_to_file "a", "a\n"
+            out, err = assert_rant "a-b.tgz"
+            assert err.empty?
+            assert !out.empty?
+            assert(test(?f, "a-b.tgz"))
+            assert(test(?f, "MANIFEST"))
+            Rant::Sys.unpack_tgz "a-b.tgz", :in => "u"
+            assert_nothing_raised do
+                assert Rant::Sys.compare_file("root.rant", "u/a-b/root.rant")
+                assert_equal "a\n", File.read("u/a-b/a")
+                entries =  File.read("u/a-b/MANIFEST").split(/\n/)
+                assert_equal 3, entries.size
+                assert entries.include?("MANIFEST")
+                assert entries.include?("a")
+                assert entries.include?("root.rant")
+            end
+            out, err = assert_rant "a-b.tgz"
+            assert err.empty?
+            assert out.empty?
+            assert_rant "autoclean"
+            assert !test(?e, "a-b.tgz")
+            assert !test(?e, "a-b")
+            assert !test(?e, ".rant.meta")
+        end
+    end
 end

data/test/import/signedfile/sub1/Rantfile

@@ -1,4 +1,4 @@
 
-gen SignedFile, "s1.t" => "#f2.t" do |t|
+gen SignedFile, "s1.t" => "@f2.t" do |t|
     write_content(t.name)
 end

data/test/import/sys/data/pkg/test.c

@@ -0,0 +1,6 @@
+
+#include "test.h"
+
+void test()
+{
+}

data/test/import/sys/data/pkg/test.h

@@ -0,0 +1,7 @@
+
+#ifndef TEST_H
+#define TEST_H
+
+void test(void);
+
+#endif

data/test/import/sys/test_tgz.rb

@@ -0,0 +1,38 @@
+
+require 'test/unit'
+require 'tutil'
+
+$test_import_sys_dir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestImportSysTgz < Test::Unit::TestCase
+    include Rant::TestUtil
+
+    def setup
+        # Ensure we run in test directory.
+        Dir.chdir($test_import_sys_dir)
+    end
+    def test_unpack_tgz
+        assert !test(?e, "pkg")
+        begin
+            out, err = assert_rant "-ftgz.rf"
+            assert err.empty?
+            assert !out.empty?
+            assert out.split(/\n/).size < 3
+            dirs = %w(pkg pkg/bin)
+            files = %w(pkg/test.c pkg/test.h pkg/bin/test pkg/bin/test.o)
+            dirs.each { |dir|
+                assert test(?d, dir), "dir `#{dir}' missing"
+            }
+            files.each { |fn|
+                src_fn = File.join "data", fn
+                assert test(?f, fn), "file `#{fn}' missing"
+                assert Rant::Sys.compare_file(fn, src_fn), "#{fn} corrupted"
+            }
+            actual = Rant::FileList["pkg", "pkg/**/*", "pkg/**/.*"]
+            actual.shun ".", ".."
+            assert_equal((files + dirs).sort, actual.sort)
+        ensure
+            Rant::Sys.rm_rf "pkg"
+        end
+    end
+end

data/test/import/sys/test_zip.rb

@@ -0,0 +1,68 @@
+
+require 'test/unit'
+require 'tutil'
+
+$test_import_sys_dir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestImportSysZip < Test::Unit::TestCase
+    include Rant::TestUtil
+
+    def setup
+        # Ensure we run in test directory.
+        Dir.chdir($test_import_sys_dir)
+    end
+    def test_unpack_zip_in_dir
+        assert !test(?e, "dir.t")
+        out, err = assert_rant "-fzip.rf"
+        assert err.empty?
+        assert !out.empty?
+        assert test(?f, "t.zip")
+        assert out.split(/\n/).size < 6
+        dirs = %w(pkg pkg/bin)
+        files = %w(pkg/test.c pkg/test.h pkg/bin/test pkg/bin/test.o)
+        dirs.each { |dir|
+            dir = File.join("dir.t", dir)
+            assert test(?d, dir), "dir `#{dir}' missing"
+        }
+        files.each { |fn|
+            src_fn = File.join "data", fn
+            fn = File.join("dir.t", fn)
+            assert test(?f, fn), "file `#{fn}' missing"
+            assert Rant::Sys.compare_file(fn, src_fn), "#{fn} corrupted"
+        }
+        actual = Rant::FileList["dir.t/**/*", "dir.t/**/.*"]
+        actual.shun ".", ".."
+        actual.map! { |e| e.sub(/^dir\.t\//, '') }
+        assert_equal((files + dirs).sort, actual.sort)
+        out, err = assert_rant "-fzip.rf"
+        assert err.empty?
+        assert out.empty?
+        out, err = assert_rant "-fzip.rf", "src=data/pkg2.zip"
+        assert err.empty?
+        assert !out.empty?
+        assert out.split(/\n/).size < 6
+        dirs = %w(pkg pkg/bin)
+        files = %w(pkg/test.c pkg/test.h pkg/bin/test)
+        dirs.each { |dir|
+            dir = File.join("dir.t", dir)
+            assert test(?d, dir), "dir `#{dir}' missing"
+        }
+        files.each { |fn|
+            src_fn = File.join "data", fn
+            fn = File.join("dir.t", fn)
+            assert test(?f, fn), "file `#{fn}' missing"
+            assert Rant::Sys.compare_file(fn, src_fn), "#{fn} corrupted"
+        }
+        actual = Rant::FileList["dir.t/**/*", "dir.t/**/.*"]
+        actual.shun ".", ".."
+        actual.map! { |e| e.sub(/^dir\.t\//, '') }
+        assert_equal((files + dirs).sort, actual.sort)
+        out, err = assert_rant "-fzip.rf", "src=data/pkg2.zip"
+        assert err.empty?
+        assert out.empty?
+        assert_rant "-fzip.rf", "autoclean"
+        assert !test(?e, "dir.t")
+        assert !test(?e, "t.zip")
+        assert Dir["**/*.rant.meta"].empty?
+    end
+end

data/test/import/sys/tgz.rf

@@ -0,0 +1,6 @@
+
+import "sys/tgz"
+
+task :unpack do
+    sys.unpack_tgz "data/pkg.tgz"
+end

data/test/import/sys/zip.rf

@@ -0,0 +1,15 @@
+
+import "md5", "sys/zip", "autoclean"
+
+var :src => "data/pkg.zip"
+
+gen Directory, "dir.t" => "t.zip" do
+    sys.rm_rf "dir.t/pkg"
+    sys.unpack_zip "t.zip", :in => "dir.t"
+end
+
+file "t.zip" => var[:src] do |t|
+    sys.cp t.source, t.name
+end
+
+gen AutoClean

data/test/project2/test_project.rb

@@ -23,9 +23,7 @@ class TestProject2 < Test::Unit::TestCase
 	Dir.chdir($testProject2Dir) unless Dir.pwd == $testProject2Dir
     end
     def teardown
-	capture_std do
-	    assert_equal(app(%w(-f rantfile.rb -f buildfile clean sub1/clean)).run, 0)
-	end
+        assert_rant(%w(-f root.rant -f buildfile clean sub1/clean))
 	assert(Dir["r_f*"].empty?,
 	    "r_f* files should have been removed by `clean'")
 	assert(Dir["b_f*"].empty?,
@@ -51,8 +49,7 @@ class TestProject2 < Test::Unit::TestCase
     end
     def test_load_rantfile
 	capture_std do
-	    app("b_f2")
-	    @app.rootdir = $testProject2Dir
+	    app("b_f2", "-C", $testProject2Dir)
 	    assert_equal(:return_val, @app.source("buildfile"),
 		"source should return value of last expression in Rantfile")
 	    assert_equal(@app.run, 0)
@@ -77,11 +74,9 @@ class TestProject2 < Test::Unit::TestCase
     end
     def test_opth_directory
 	app %w(insub1_s1f1)
-	#Rant[:directory] = "sub1"
 	@app[:verbose] = 2
-	@app[:directory] = "sub1"
 	capture_std do
-	    assert_equal(@app.run, 0)
+	    assert_equal(@app.run("-Csub1"), 0)
 	end
 	assert(Dir.pwd !~ /sub1$/,
 	    "rant should cd to original dir before returning from `run'")

data/test/project_rb1/{rantfile.rb → rantfile}

@@ -1,7 +1,7 @@
 import %w(rubytest rubydoc rubypackage clean)
 
 lib_files = Dir["lib/**/*.rb"]
-dist_files = lib_files + %w(rantfile.rb README test_project_rb1.rb) + Dir["{test,bin}/*"]
+dist_files = lib_files + %w(rantfile README test_project_rb1.rb) + Dir["{test,bin}/*"]
 
 desc "Run unit tests."
 gen RubyTest do |t|

data/test/project_rb1/test_project_rb1.rb

@@ -8,7 +8,7 @@ class TestProjectRb1 < Test::Unit::TestCase
     def setup
 	@manifest = %w(bin lib test bin/wgrep lib/wgrep.rb
 	    test/text test/tc_wgrep.rb README test_project_rb1.rb
-	    rantfile.rb)
+	    rantfile)
 	# Ensure we run in test directory.
 	Dir.chdir($testProjectRb1Dir)
     end
@@ -94,8 +94,7 @@ class TestProjectRb1 < Test::Unit::TestCase
 	FileUtils.mkdir tmp_dir
 	FileUtils.cp tar_fn, tmp_dir
 	FileUtils.cd tmp_dir do
-            #`tar xzf #{tar_fn}`
-            unpack_archive :tgz, tar_fn
+            Rant::Sys.unpack_tgz tar_fn
 	    assert(test(?d, pkg_base),
 		"`#{pkg_base}' should be root directory of all files in tar")
 	    FileUtils.cd pkg_base do
@@ -115,8 +114,7 @@ class TestProjectRb1 < Test::Unit::TestCase
 	FileUtils.mkdir tmp_dir
 	FileUtils.cp zip_fn, tmp_dir
 	FileUtils.cd tmp_dir do
-            #`unzip -q #{zip_fn}`
-            unpack_archive :zip, zip_fn
+            Rant::Sys.unpack_zip zip_fn
 	    assert(test(?d, pkg_base),
 		"`#{pkg_base}' should be root directory of all files in zip")
 	    FileUtils.cd pkg_base do

data/test/rant-import/test_rant-import.rb

@@ -1,12 +1,13 @@
 
 require 'test/unit'
-require 'rant/rantlib'
 require 'tutil'
-require 'fileutils'
+require 'rant/import'
 
 $testRantImportDir ||= File.expand_path(File.dirname(__FILE__))
 
 class TestRantImport < Test::Unit::TestCase
+    include Rant::TestUtil
+
     def setup
 	# Ensure we run in test directory.
 	Dir.chdir($testRantImportDir)
@@ -17,12 +18,27 @@ class TestRantImport < Test::Unit::TestCase
 	FileUtils.rm_f Dir["make*"]
 	FileUtils.rm_rf Dir["*.t"]
     end
+    def test_option_help
+        out, err = capture_std do
+            assert_equal(0, Rant::RantImport.new("--help").run)
+        end
+        assert err.empty?
+        assert out.include?("rant-import")
+        assert out.include?("Options are")
+        assert out.include?("--help")
+    end
     def test_no_import
 	run_import("--quiet", "make.rb")
 	assert(test(?f, "make.rb"))
+        content = File.read("make.rb")
 	assert(!test(?f, "action.t"))
 	assert_equal(run_rant("hello"), run_ruby("make.rb", "hello"))
 	assert(test(?f, "action.t"))
+        out, err = capture_std do
+            assert_equal(1, Rant::RantImport.new("-iclean", "make.rb").run)
+        end
+        assert_equal(content, File.read("make.rb"))
+        assert_match(/\[ERROR\].*\bmake\.rb\b.*\bexists\b.*--force/m, err)
     end
     def test_import_from_custom_lib
 	FileUtils.mkpath "mylib.t/rant/import"
@@ -85,13 +101,11 @@ class TestRantImport < Test::Unit::TestCase
 	    end
 	    EOF
 	}
-	open("Rantfile.rb", "w") { |f|
-	    f << <<-EOF
+        write_to_file "rantfile", <<-EOF
 	    $:.unshift "lib.t"
 	    import "sub/t"
 	    gen Sub::T, "hello", "test" do end
-	    EOF
-	}
+        EOF
 	out, err = assert_rant
 	assert_match(/.*hello.*\n.*test.*\n.*block_given/, out)
 	run_import("--quiet", "--auto", "ant")
@@ -132,13 +146,11 @@ class TestRantImport < Test::Unit::TestCase
 	    end
 	    EOF
 	}
-	open("rantfile.rb", "w") { |f|
-	    f << <<-EOF
+        write_to_file "root.rant", <<-EOF
 	    $:.unshift "lib.t"
 	    import "sub2/t"
 	    gen Sub2::T, "hello", "test" do end
-	    EOF
-	}
+        EOF
 	out, err = assert_rant
 	assert_match(/hellotest/, out)
 	run_import("--quiet", "--auto", "ant.rb")

data/test/subdirs/sub1/Rantfile

@@ -3,7 +3,7 @@ file "t" do |t|
     sys.touch t.name
 end
 
-file "rootdep.t" => "#subdep.t" do |t|
+file "rootdep.t" => "@subdep.t" do |t|
     test(?f, "../subdep.t") || t.fail
     sys.touch t.name
 end

data/test/subdirs/sub2/sub/rantfile

@@ -3,7 +3,7 @@ file "rootdep.t" do |t|
     sys.touch t.name
 end
 
-file "rootref.t" => "#t" do |t|
+file "rootref.t" => "@t" do |t|
     test(?f, "../../t") || t.fail
     sys.touch t.name
 end

data/test/subdirs2/root.rant

@@ -0,0 +1,36 @@
+
+import "autoclean", "subfile"
+
+def define_print_task(name)
+    task name do |t|
+        puts t.full_name
+    end
+end
+
+desc "show full task name"
+task :a do |t|
+    puts t.full_name
+end
+
+file "a.t" do |t|
+    write t.name
+end
+
+file "b.t" do |t|
+    write t.name
+end
+
+gen SubFile, "t/t", "a.t" => "b.t" do |t|
+    write(t.name, "abc")
+end
+
+gen AutoClean
+
+subdirs sys["sub?"] # doesn't cover sub00, per intent
+
+def self.write(fn, content=nil)
+    puts "writing to #{fn}"
+    open fn, "w" do |f|
+        f.write(content || "#{fn}\n")
+    end
+end