rant 0.4.4 → 0.4.6

data/test/subdirs2/sub00/sub.rant

@@ -0,0 +1,8 @@
+
+define_print_task :a
+
+file "a.t" => "@a.t" do |t|
+    sys.cp "../a.t", t.name
+end
+
+task :default => "a.t"

data/test/subdirs2/sub1/sub.rant

@@ -0,0 +1,13 @@
+
+task :a do |t|
+    puts t.full_name
+end
+
+desc "noop"
+task :b
+
+file "sub.t" => "@a.t" do |t|
+    sys.cp sys.expand_path(t.source), t.name
+end
+
+gen Directory, "dir.t"

data/test/subdirs2/test_subdirs2.rb

@@ -0,0 +1,239 @@
+
+require 'test/unit'
+require 'tutil'
+
+$test_subdirs2_dir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestSubdirs2 < Test::Unit::TestCase
+    include Rant::TestUtil
+
+    def rootdir_rx(subdir=@subdir)
+        /^\(root is #$test_subdirs2_dir, in #{subdir}\)$/
+    end
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($test_subdirs2_dir)
+    end
+    def teardown
+	Dir.chdir($test_subdirs2_dir)
+        assert_rant "autoclean"
+        assert Rant::FileList["**/*.t*"].shun(".svn").empty?
+        assert Rant::FileList["**/.rant.meta"].shun(".svn").empty?
+    end
+    def test_first
+        out, err = assert_rant
+        assert err.empty?
+        assert_equal "a\n", out
+    end
+    def test_subdir_task_from_commandline
+        out, err = assert_rant "sub1/a"
+        assert err.empty?
+        assert_equal "(in sub1)\nsub1/a\n", out
+    end
+    def test_first_in_subdir
+        Dir.chdir "sub1"
+        out, err = assert_rant
+        assert err.empty?
+        assert_equal "(root is #$test_subdirs2_dir, in sub1)\nsub1/a\n", out
+    end
+    def test_directory_in_subdir
+        Dir.chdir "sub1"
+        out, err = assert_rant "dir.t"
+        assert err.empty?
+        assert out.include?("mkdir")
+        assert test(?d, "dir.t")
+        out, err = assert_rant "dir.t"
+        assert err.empty?
+        assert !out.include?("mkdir")
+    end
+    def test_root_dir_task_in_subdir_from_commandline
+        Dir.chdir "sub1"
+        out, err = assert_rant "@a"
+        assert err.empty?
+        lines = out.split(/\n/)
+        assert_match(/^\(root is .*\)$/, lines[0])
+        assert lines.size < 4
+        assert_equal "a", lines.last
+    end
+    def test_root_dir_task_from_commandline
+        out, err = assert_rant "@a"
+        assert err.empty?
+        assert_equal "a\n", out
+    end
+    def test_fail_no_subdir_task
+        out, err = assert_rant :fail, "sub00/a.t"
+        assert out.empty?
+        assert_match(/\[ERROR\]/, err)
+        assert_match(/\bsub00\/a\.t\b/, err)
+    end
+    def test_ensure_read_sub_rant
+        Dir.chdir "sub00"
+        out, err = assert_rant
+        assert test(?f, "a.t")
+        assert test(?f, "../a.t")
+
+        out, err = assert_rant :fail, "autoclean"
+        assert_equal "(root is #$test_subdirs2_dir, in sub00)\n", out
+        assert_rant "@autoclean"
+        assert Dir["*.t"].empty?
+    end
+    def test_show_descriptions
+        out, err = assert_rant "-T"
+        assert err.empty?
+        assert_equal <<EOF, out
+rant a        # show full task name
+rant sub1/b   # noop
+EOF
+    end
+    def test_show_descriptions_in_subdir
+        Dir.chdir "sub1"
+        out, err = assert_rant "-T"
+        assert err.empty?
+        lines = out.split(/\n/)
+        assert_equal 4, lines.size
+        assert_match(rootdir_rx("sub1"), lines[0])
+        assert_match(/^rant\s+#\s+=>\s+a$/, lines[1])
+        assert_match(/^rant b\s+#\s+noop$/, lines[2])
+        assert_match(/^rant @a\s+#\s+show full task name$/, lines[3])
+    end
+    def test_opt_look_up
+        in_local_temp_dir "t" do
+            out, err = assert_rant :fail
+            assert out.empty?
+            assert_match(/\[ERROR\].*no rantfile/i, err)
+            out, err = assert_rant "--look-up"
+            assert err.empty?
+            assert_equal "a", out.split(/\n/)[2]
+            in_local_temp_dir "t" do
+                out, err = assert_rant "--look-up", "a.t"
+                assert err.empty?
+                lines = out.split(/\n/)
+                assert_equal 4, lines.size
+                assert_match(rootdir_rx("t/t"), lines[0])
+                assert_equal "(in #$test_subdirs2_dir)", lines[1]
+                assert_equal "writing to b.t", lines[2]
+                assert_equal "writing to t/t/a.t", lines[3]
+                assert !test(?e, "../../a.t")
+                assert test(?f, "a.t")
+                assert test(?f, "../../b.t")
+                out, err = assert_rant "--look-up", "a.t"
+                assert err.empty?
+                lines = out.split(/\n/)
+                assert_equal 1, lines.size
+                assert_match rootdir_rx("t/t"), lines.first
+                out, err = assert_rant "-u", "@autoclean"
+                assert !test(?e, "../../b.t")
+                assert !test(?e, "a.t")
+            end
+        end
+    end
+    def test_opt_look_up_from_subdir
+        Dir.chdir "sub1"
+        out, err = assert_rant "-u", "dir.t"
+        assert err.empty?
+        assert out.include?("mkdir")
+        assert test(?d, "dir.t")
+        out, err = assert_rant "-u", "dir.t"
+        assert err.empty?
+        assert !out.include?("mkdir")
+    end
+    def test_opt_cd_parent
+        in_local_temp_dir "with space.t" do
+            out, err = assert_rant "--cd-parent"
+            assert err.empty?
+            lines = out.split(/\n/)
+            assert_equal 2, lines.size
+            assert_equal "(in #$test_subdirs2_dir)", lines[0]
+            assert_equal "a", lines[1]
+            in_local_temp_dir "a" do
+                orig_pwd = Dir.pwd
+                out, err = assert_rant "-c", "a.t"
+                assert_equal orig_pwd, Dir.pwd
+                assert err.empty?
+                lines = out.split(/\n/)
+                assert_equal 2, lines.size
+                assert_equal "(in #$test_subdirs2_dir)", lines[0]
+                assert_equal "writing to a.t", lines[1]
+                assert test(?f, "../../a.t")
+                assert_equal "a.t\n", File.read("../../a.t")
+            end
+        end
+    end
+    def test_opt_cd_parent_from_dir_with_rantfile
+        out, err = assert_rant "-c"
+        assert err.empty?
+        assert_equal "a\n", out
+    end
+    def test_opt_cd_parent_from_subdir
+        Dir.chdir "sub1"
+        out, err = assert_rant "-c"
+        assert err.empty?
+        lines = out.split(/\n/)
+        assert_equal 2, lines.size
+        assert_equal "(in #$test_subdirs2_dir)", lines[0]
+        assert_equal "a", lines[1]
+    end
+    def test_opt_cd_parent_from_subdir_sub
+        Dir.chdir "sub1"
+        in_local_temp_dir do
+            out, err = assert_rant "-c"
+            assert err.empty?
+            lines = out.split(/\n/)
+            assert_equal 2, lines.size
+            assert_equal "(in #$test_subdirs2_dir)", lines[0]
+            assert_equal "a", lines[1]
+        end
+    end
+    def test_rant_import
+        run_import("-q", "--auto", "rant.t")
+        assert_exit
+        out = run_ruby("rant.t", "a.t")
+        assert_exit
+        assert test(?f, "a.t")
+        out = run_ruby("rant.t", "a.t")
+        assert_exit
+        assert out.empty?
+        Rant::Sys.safe_ln "rant.t", "sub1"
+        Dir.chdir "sub1"
+        out = run_ruby("rant.t", "dir.t")
+        assert_exit
+        assert test(?d, "dir.t")
+        out = run_ruby("rant.t", "@autoclean")
+        assert !test(?e, "dir.t")
+    ensure
+        Dir.chdir $test_subdirs2_dir
+        Rant::Sys.rm_f Dir["**/rant.t"]
+    end
+    def test_expand_path_md5_in_sub1
+        Dir.chdir "sub1"
+        out, err = assert_rant "-imd5", "sub.t"
+        assert err.empty?
+        assert !out.empty?
+        assert test(?f, "sub.t")
+        assert_equal "a.t\n", File.read("sub.t")
+        out, err = assert_rant "-imd5", "sub.t"
+        assert err.empty?
+        assert out !~ /writing to/
+        assert out !~ /\bcp\b/
+        Dir.chdir ".."
+        out, err = assert_rant "-imd5", "sub1/sub.t"
+        assert err.empty?
+        assert out.empty?
+        assert_rant "-imd5", "autoclean"
+    end
+    def test_expand_path
+        out, err = assert_rant "sub1/sub.t"
+        assert err.empty?
+        assert test(?f, "sub1/sub.t")
+        assert_equal "a.t\n", File.read("sub1/sub.t")
+        out, err = assert_rant "sub1/sub.t"
+        assert err.empty?
+        assert out.empty?
+    end
+    def test_define_in_current_subdir
+        Dir.chdir "sub00"
+        out, err = assert_rant "a"
+        assert err.empty?
+        assert_equal "sub00/a", out.split(/\n/).last
+    end
+end

data/test/test_examples.rb

@@ -261,4 +261,95 @@ EOF
         FileUtils.rm_f "c/problem_1_1/Rantfile"
         FileUtils.rm_f "c++/problem_1_1/Rantfile"
     end
+    def test_c_cpp
+        Dir.chdir "c_cpp"
+        proj_pwd = Dir.pwd
+        out, err = assert_rant("--tasks")
+        # TODO: replace with a not-so-strict regex
+op = <<EOF
+rant run            # Run all C and C++ tests.
+rant build          # Build all.
+rant autoclean      # Remove all autogenerated files.
+rant pkg/c_cpp.tgz  # Create source package.
+EOF
+        assert_equal(op, out)
+        assert(err.empty?)
+        gen_files = %w(
+            .rant.meta
+            c/problem_1_1/.rant.meta
+            c++/problem_1_1/.rant.meta
+            c/problem_1_1/sub.rant
+            c++/problem_1_1/sub.rant
+            c/problem_1_1/c_dependencies
+            c++/problem_1_1/c_dependencies
+            c/problem_1_1/test
+            c++/problem_1_1/test
+            c/problem_1_1/main.o
+            c++/problem_1_1/main.o
+            c/problem_1_1/test.o
+            c++/problem_1_1/test.o
+            c/problem_1_1/another_test.o
+            c++/problem_1_1/another_test.o
+            pkg
+        )
+        if Rant::Env.find_bin("gcc") && Rant::Env.find_bin("g++")
+            out = run_rant
+            assert_exit
+            assert_equal(2, out.scan(/Hello\, world\!/).size)
+            out, err = assert_rant("build")
+            assert(out.empty?)
+            assert(err.empty?)
+        else
+            STDERR.puts "*** gcc and/or g++ not available, less example testing ***"
+        end
+        assert_rant("pkg/c_cpp.tgz")
+        assert(test(?f, "pkg/c_cpp.tgz"))
+        # checking archive contents
+        sources = Rant::FileList["root.rant", "**/*.{c,cpp,h,rf}"]
+        sources.no_dir("pkg").resolve
+        assert sources.size > 10
+        Rant::Sys.unpack_tgz "pkg/c_cpp.tgz"
+        assert test(?d, "c_cpp")
+        sources.each { |fn|
+            pkg_fn = File.join("c_cpp", fn)
+            if test ?d, fn
+                assert test(?d, pkg_fn)
+            else
+                assert Rant::Sys.compare_file(fn, pkg_fn)
+            end
+        }
+        Rant::Sys.rm_rf "c_cpp"
+        out, err = assert_rant("pkg/c_cpp.tgz")
+        assert(out.empty?)
+        assert(err.empty?)
+        assert_rant("autoclean")
+        gen_files.each { |f|
+            assert(!test(?e, f),
+                "#{f} should have been removed by autoclean")
+        }
+        if Rant::Env.find_bin("gcc")
+            FileUtils.cp "c/template.rf", "c/problem_1_1/sub.rant"
+            Dir.chdir "c/problem_1_1"
+            out = run_rant
+            assert(out.include?("Hello, world!"))
+            
+            # TODO
+            #assert_rant("autoclean")
+
+            FileUtils.rm_f "sub.rant"
+            Dir.chdir proj_pwd
+
+            # TODO: remove next line if TODO above is fixed
+            assert_rant("autoclean")
+
+            gen_files.each { |f|
+                assert(!test(?e, f),
+                    "#{f} should have been removed by autoclean")
+            }
+        end
+    ensure
+        Dir.chdir proj_pwd
+        FileUtils.rm_f "c/problem_1_1/sub.rant"
+        FileUtils.rm_f "c++/problem_1_1/sub.rant"
+    end
 end

data/test/test_filetask.rb

@@ -1,18 +1,20 @@
 
 require 'test/unit'
-require 'rant/rantlib'
+require 'tutil'
 
 $test_filetask_file = File.expand_path(__FILE__)
+$test_dir ||= File.dirname($test_filetask_file)
 
 class TestFileTask < Test::Unit::TestCase
+    include Rant::TestUtil
+
     def setup
+        Dir.chdir $test_dir
+        @rant = Rant::RantApp.new
     end
-    def teardown
-    end
-
     def test_needed_non_existent
 	run = false
-	t = Rant::FileTask.new(nil, "non_existent") { run = true }
+	t = Rant::FileTask.new(@rant, "non_existent") { run = true }
 	assert(t.needed?,
 	    "`non_existent' doesn't exist, so filetask is needed")
 	assert(!run,
@@ -20,38 +22,76 @@ class TestFileTask < Test::Unit::TestCase
     end
     def test_needed_no_dep
 	run = false
-	t = Rant.rac.file $test_filetask_file do
+	t = @rant.file $test_filetask_file do
 	    run = true
 	end
 	assert(!t.needed?,
 	    "file exists and has no prerequisite, so needed? should return false")
 	assert(!run)
     end
+=begin
+    commented out due to a semantics change in 0.4.5
     def test_single_dep
 	tr = false
-	t = Rant.rac.task :t do
+	t = @rant.task :t do
 	    tr = true
 	end
 	run = false
-	f = Rant.rac.file "testfile" => :t do
+	f = @rant.file "testfile" => :t do
 	    run = true
 	end
 	f.invoke
 	assert(tr)
 	assert(run)
     end
+=end
     def test_prerequisites
-	Rant.rac.file "a" do
+	@rant.file "a" do
 	    true
 	end
-	Rant.rac.file "b" do
+	@rant.file "b" do
 	    true
 	end
-	f = Rant.rac.file "c" => %w(a b) do |t|
+	f = @rant.file "c" => %w(a b) do |t|
 	    assert_equal(t.prerequisites, %w(a b),
 		"prerequisites should always be an array of _strings_")
 	    true
 	end
 	f.invoke
     end
+    def test_no_invoke_task_dep
+        write_to_file "print_name.t", "b\n"
+        out, err = assert_rant "depends_name.t"
+        assert err.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+        assert_match(/writing.*depends_name\.t/, out)
+        assert !out.include?("print_name.t"),
+            "file task mustn't invoke task as prerequisite"
+        out, err = assert_rant "depends_name.t"
+        assert err.empty?
+        assert out.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+    ensure
+        Rant::Sys.rm_f %w(print_name.t depends_name.t)
+    end
+    def test_no_invoke_task_dep_md5
+        write_to_file "print_name.t", "b\n"
+        out, err = assert_rant "-imd5", "depends_name.t"
+        assert err.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+        assert_match(/writing.*depends_name\.t/, out)
+        assert !out.include?("print_name.t"),
+            "file task mustn't invoke task as prerequisite"
+        out, err = assert_rant "-imd5", "depends_name.t"
+        assert err.empty?
+        assert out.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+    ensure
+        Rant::Sys.rm_f %w(auto.rf .rant.meta print_name.t depends_name.t)
+        Rant::Sys.rm_f Dir["*.t"]
+    end
 end