rant 0.3.6 → 0.3.8

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

@@ -12,6 +12,7 @@ class TestRantImport < Test::Unit::TestCase
 	Dir.chdir($testRantImportDir) unless Dir.pwd == $testRantImportDir
     end
     def teardown
+	Dir.chdir($testRantImportDir)
 	FileUtils.rm_f Dir["ant*"]
 	FileUtils.rm_f Dir["make*"]
 	FileUtils.rm_rf Dir["*.t"]
@@ -47,7 +48,7 @@ class TestRantImport < Test::Unit::TestCase
 	    EOF
 	}
 	out, err = capture_std do
-	    assert_equal(0, Rant::RantApp.new("-fmygen.rf.t").run)
+	    assert_equal(0, Rant::RantApp.new.run("-fmygen.rf.t"))
 	end
 	assert_match(/Greetings.*mygen/, out)
 	assert(test(?f, "mygen"))
@@ -62,4 +63,106 @@ class TestRantImport < Test::Unit::TestCase
     ensure
 	FileUtils.rm_f "mygen"
     end
+    def test_import_subdir
+	old_pwd = Dir.pwd
+	FileUtils.mkdir "sub.t"
+	Dir.chdir "sub.t"
+	FileUtils.mkpath "lib.t/rant/import/sub"
+	open("lib.t/rant/import/sub/t.rb", "w") { |f|
+	    f << <<-EOF
+	    module Rant::Generators
+		module Sub
+		    class T
+			def self.rant_generate(rac, ch, args, &blk)
+			    raise "no ch" unless Hash === ch
+			    rac.cx.task args.first do |t|
+				puts args
+				puts "block_given" if block_given?
+			    end
+			end
+		    end
+		end
+	    end
+	    EOF
+	}
+	open("Rantfile.rb", "w") { |f|
+	    f << <<-EOF
+	    $:.unshift "lib.t"
+	    import "sub/t"
+	    gen Sub::T, "hello", "test" do end
+	    EOF
+	}
+	out, err = assert_rant
+	assert_match(/.*hello.*\n.*test.*\n.*block_given/, out)
+	run_import("--quiet", "--auto", "ant")
+	assert(test(?f, "ant"))
+	FileUtils.rm_r "lib.t"
+	out = run_ruby("ant")
+	assert_match(/.*hello.*\n.*test.*\n.*block_given/, out)
+    ensure
+	Dir.chdir old_pwd
+	FileUtils.rm_rf "sub.t"
+    end
+    def test_import_marked_require
+	old_pwd = Dir.pwd
+	FileUtils.mkdir "sub2.t"
+	Dir.chdir "sub2.t"
+	FileUtils.mkpath "lib.t/rant/import/sub2"
+	FileUtils.mkdir "lib.t/misc"
+	open("lib.t/misc/printer.rb", "w") { |f|
+	    f << <<-EOF
+	    def misc_print(*args)
+		puts args.flatten.join('')
+	    end
+	    EOF
+	}
+	open("lib.t/rant/import/sub2/t.rb", "w") { |f|
+	    f << <<-EOF
+	    require 'misc/printer' # rant-import
+	    module Rant::Generators
+		module Sub2
+		    class T
+			def self.rant_generate(rac, ch, args, &blk)
+			    rac.cx.task args.first do |t|
+				misc_print(args)
+			    end
+			end
+		    end
+		end
+	    end
+	    EOF
+	}
+	open("rantfile.rb", "w") { |f|
+	    f << <<-EOF
+	    $:.unshift "lib.t"
+	    import "sub2/t"
+	    gen Sub2::T, "hello", "test" do end
+	    EOF
+	}
+	out, err = assert_rant
+	assert_match(/hellotest/, out)
+	run_import("--quiet", "--auto", "ant.rb")
+	assert(test(?f, "ant.rb"))
+	FileUtils.rm_r "lib.t"
+	out = run_ruby("ant.rb")
+	assert_match(/hellotest/, out)
+    ensure
+	Dir.chdir old_pwd
+	FileUtils.rm_rf "sub2.t"
+    end
+    def test_sys_shun
+	FileUtils.mkdir "a.t"
+	FileUtils.mkdir "b.t"
+	FileUtils.touch %w(a.t/1.s.t a.t/2.s.t a.t/xy.s.t b.t/b.s.t)
+	out = run_rant("-q", "sys_shun_demo")
+	files = out.strip.split "\n"
+	assert_equal(1, files.size)
+	assert(files.include?("b.t/b.s.t"))
+	run_import("-q", "--auto", "ant")
+	assert(test(?f, "ant"))
+	out = run_ruby("ant", "-q", "sys_shun_demo")
+	files = out.strip.split "\n"
+	assert_equal(1, files.size)
+	assert(files.include?("b.t/b.s.t"))
+    end
 end

data/test/rule.rf

@@ -25,3 +25,9 @@ gen Rule, :rt => src do |t|
     t.source =~ /\.rtt$/ or t.fail
     sys.touch t.name
 end
+
+if var[:enhance_t]
+    enhance "eh.t" do
+	puts "eh.t created"
+    end
+end

data/test/test_autosubfiletask.rb

@@ -0,0 +1,59 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestAutoSubFileTask < Test::Unit::TestCase
+    RG = Rant::Generators
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testDir) unless Dir.pwd == $testDir
+	@rac = Rant::RantApp.new
+    end
+    def teardown
+	FileUtils.rm_rf Dir["*.t"]
+    end
+    def test_create_dir
+	@rac.gen RG::Directory, "dir.t"
+	blk = lambda { |t| FileUtils.touch t.name }
+	@rac.prepare_task("dir.t/file", blk) { |name,pre,blk|
+	    Rant::AutoSubFileTask.new(@rac, name, pre, &blk)
+	}
+	tl = @rac.resolve("dir.t/file")
+	assert_equal(1, tl.size)
+	ft = tl.first
+	assert(ft.prerequisites.empty?)
+	@rac.args.replace %w(dir.t/file)
+	capture_std do
+	    assert_equal(0, @rac.run)
+	end
+	assert(test(?d, "dir.t"))
+	assert(test(?f, "dir.t/file"))
+    end
+    def test_fail_no_dir
+	blk = lambda { |t| FileUtils.touch t.name }
+	@rac.prepare_task("dir.t/file", blk) { |name,pre,blk|
+	    Rant::AutoSubFileTask.new(@rac, name, pre, &blk)
+	}
+	@rac.args.replace %w(dir.t/file)
+	capture_std do
+	    assert_equal(1, @rac.run)
+	end
+	assert(!test(?e, "dir.t"))
+	assert(!test(?e, "dir.t/file"))
+    end
+    def test_dir_exists
+	FileUtils.mkdir "dir.t"
+	blk = lambda { |t| FileUtils.touch t.name }
+	@rac.prepare_task("dir.t/file", blk) { |name,pre,blk|
+	    Rant::AutoSubFileTask.new(@rac, name, pre, &blk)
+	}
+	@rac.args.replace %w(dir.t/file)
+	capture_std do
+	    assert_equal(0, @rac.run)
+	end
+	assert(test(?d, "dir.t"))
+	assert(test(?f, "dir.t/file"))
+    end
+end

data/test/test_clean.rb

@@ -65,7 +65,7 @@ class TestClean < Test::Unit::TestCase
 	files.each { |f| assert(test(?f, f)) }
 	dirs.each { |f| assert(test(?d, f)) }
 	capture_std do
-	    assert_equal(0, Rant::RantApp.new("clean").run)
+	    assert_equal(0, Rant::RantApp.new.run("clean"))
 	end
 	%w(sa.t a1.t a2.t sub1.t/b1.t sub1.t/b2.t).each { |f|
 	    assert(!test(?e, f))
@@ -81,7 +81,7 @@ class TestClean < Test::Unit::TestCase
 	%w(a1.t a2.t b1.t b2.t).each { |f| assert(test(?f, f)) }
 	%w(sa.t sb.t).each { |f| assert(test(?d, f)) }
 	capture_std do
-	    assert_equal(0, Rant::RantApp.new("clean").run)
+	    assert_equal(0, Rant::RantApp.new.run("clean"))
 	end
 	%w(b1.t b2.t sb.t).each { |f| assert(!test(?e, f)) }
 	%w(a1.t a2.t sa.t).each { |f| assert(test(?e, f)) }
@@ -92,6 +92,8 @@ class TestClean < Test::Unit::TestCase
     end
     def layout_project2
 	FileUtils.mkdir "p2.t"
+	FileUtils.mkdir "p2.t/c.t"
+	FileUtils.touch "p2.t/c.t/data"
 	Dir.chdir "p2.t"
 	open("Rantfile", "w") { |f|
 	    f << <<-EOF
@@ -104,6 +106,10 @@ class TestClean < Test::Unit::TestCase
 		sys.touch t.name
 	    end
 	    gen Directory, "b.t/c.t"
+	    gen Directory, "c.t", "a"
+	    file "c.t/a/b" => "c.t/a" do
+		sys.touch t.name
+	    end
 	    file "b.t/c.t/d.t" => "b.t/c.t" do |t|
 		sys.touch t.name
 	    end
@@ -122,13 +128,50 @@ class TestClean < Test::Unit::TestCase
 	end
 	%w(a.t b.t/c.t/d.t mk_junk.t).each { |f| assert(test(?e, f)) }
 	capture_std do
-	    assert_equal(0, Rant::RantApp.new("autoclean").run)
+	    assert_equal(0, Rant::RantApp.new.run("autoclean"))
 	end
-	%w(a.t b.t/c.t/d.t mk_junk.t).each { |f| assert(!test(?e, f)) }
+	%w(a.t b.t/c.t/d.t c.t/a mk_junk.t).each { |f| assert(!test(?e, f)) }
+	assert(test(?d, "c.t"))
+	assert(test(?f, "c.t/data"))
 	capture_std do
-	    assert_equal(1, Rant::RantApp.new("clean").run)
+	    assert_equal(1, Rant::RantApp.new.run("clean"))
 	end
     ensure
 	cleanup_project2
     end
+    def test_clean_rule_target_rx
+	FileUtils.mkdir "t"
+	Dir.chdir "t"
+	FileUtils.mkdir "sub"
+	FileUtils.mkdir "sub/sub"
+	FileUtils.touch "sub/sub/a.t"
+	FileUtils.touch "sub/a.t"
+	FileUtils.touch "a.t"
+	open "Rantfile", "w" do |f|
+	    f << <<-EOF
+	    gen Rule, :tt => :t do |t|
+		sys.touch t.name
+	    end
+	    import "autoclean"
+	    gen AutoClean
+	    EOF
+	end
+	assert_rant("sub/sub/a.tt")
+	assert(test(?f, "sub/sub/a.tt"))
+	assert_rant("sub/a.tt")
+	assert(test(?f, "sub/a.tt"))
+	assert_rant("a.tt")
+	assert(test(?f, "a.tt"))
+	assert_rant("autoclean")
+	%w(a.tt sub/a.tt sub/sub/a.tt).each { |f|
+	    assert(!test(?e, f),
+		"#{f} should get unlinked by AutoClean")
+	}
+	%w(a.t sub/a.t sub/sub/a.t).each { |f|
+	    assert(test(?e, f))
+	}
+    ensure
+	Dir.chdir $testDir
+	FileUtils.rm_rf "t"
+    end
 end

data/test/test_dirtask.rb

@@ -22,7 +22,7 @@ class TestDirTask < Test::Unit::TestCase
     end
     def test_return
 	dt = @cx.gen Directory, "a.t/b.t"
-	assert(Rant::Worker === dt)
+	assert(Rant::Node === dt)
 	assert_equal("a.t/b.t", dt.name,
 	    "`gen Directory' should return task for last directory")
 	args "--quiet", "a.t/b.t"
@@ -30,4 +30,48 @@ class TestDirTask < Test::Unit::TestCase
 	assert(test(?d, "a.t"))
 	assert(test(?d, "a.t/b.t"))
     end
+    def test_4_levels
+	@cx.gen Directory, "1.t/2/3/4"
+	args "-q", "1.t/2/3/4"
+	assert_equal(0, @rac.run)
+	assert(test(?d, "1.t/2/3/4"))
+    end
+    def test_basedir_no_create
+	out, err = capture_std do
+	    assert_equal(1, Rant::RantApp.new.run("basedir.t"))
+	end
+	assert_match(/\[ERROR\].*basedir\.t/, err)
+	assert(!test(?e, "basedir.t"))
+    end
+    def test_basedir_fail_no_basedir
+	out, err = capture_std do
+	    assert_equal(1, Rant::RantApp.new.run("basedir.t/a"))
+	end
+	assert(!test(?e, "basedir.t"))
+	assert(!test(?e, "a"))
+    end
+    def test_basedir_a
+	FileUtils.mkdir "basedir.t"
+	assert_rant("basedir.t/a")
+	assert(test(?d, "basedir.t/a"))
+	assert_rant("clean")
+	assert(!test(?e, "basedir.t"))
+    end
+    def test_basedir_a_b
+	FileUtils.mkdir "basedir.t"
+	assert_rant("basedir.t/a/b")
+	assert(test(?d, "basedir.t/a/b"))
+	assert_rant("clean")
+    end
+    def test_basdir_no_b
+	FileUtils.mkdir "basedir.t"
+	assert_rant(:fail, "basedir.t/b")
+	assert_rant("clean")
+    end
+    def test_description
+	FileUtils.mkdir "basedir.t"
+	out, err = assert_rant("--tasks")
+	assert_match(%r{basedir.t/a/b\s*#.*Make some path}, out)
+	assert_rant("clean")
+    end
 end

data/test/test_examples.rb

@@ -10,9 +10,7 @@ $cc_is_gcc ||= Rant::Env.find_bin("cc") && Rant::Env.find_bin("gcc")
 class TestExamples < Test::Unit::TestCase
     def setup
 	# Ensure we run in test directory.
-	Dir.chdir($examplesDir) unless Dir.pwd == $examplesDir
-    end
-    def teardown
+	Dir.chdir $examplesDir
     end
     def test_myprog
 	Dir.chdir "myprog"
@@ -44,4 +42,28 @@ class TestExamples < Test::Unit::TestCase
 	run_rant("clean")
 	Dir["**/*.o"].each { |f| assert(!test(?e, f)) }
     end
+    def test_c_dependencies
+	Dir.chdir "c_dependencies"
+	assert_match( /\bhello\b.*\n.*\bclean\b.*\n.*\bdistclean\b/,
+	    run_rant("-T"))
+	assert(!test(?f, "hello"))
+	if $cc_is_gcc
+	    run_rant
+	    assert(test(?f, "hello"))
+	else
+	    run_rant("c_dependencies")
+	end
+	run_rant("clean")
+	assert(Dir["**/*.o"].empty?)
+	assert(!test(?f, "hello"))
+	assert(test(?f, "c_dependencies"))
+	if $cc_is_gcc
+	    run_rant
+	    assert(test(?f, "hello"))
+	end
+	run_rant("distclean")
+	assert(Dir["**/*.o"].empty?)
+	assert(!test(?f, "c_dependencies"))
+	assert(!test(?f, "hello"))
+    end
 end

data/test/test_filelist.rb

@@ -255,12 +255,12 @@ class TestFileList < Test::Unit::TestCase
 	    EOF
 	}
 	capture_std do
-	    Rant::RantApp.new("-fsys_cd.rf.t", "sub.t/a.t").run
+	    Rant::RantApp.new.run("-fsys_cd.rf.t", "sub.t/a.t")
 	end
 	assert(test(?f, "sub.t/a.t"))
 	assert(test(?f, "sub.t/b.t"))
 	capture_std do
-	    Rant::RantApp.new("-fsys_cd.rf.t", "clean").run
+	    Rant::RantApp.new.run("-fsys_cd.rf.t", "clean")
 	end
 	assert(!test(?e, "sub.t/a.t"))
 	assert(!test(?e, "sub.t/b.t"))
@@ -279,4 +279,16 @@ class TestFileList < Test::Unit::TestCase
 	    assert(l1.include("b.t"))
 	end
     end
+    def test_sys_glob_flags
+	cx = Rant::RantApp.new.cx
+	touch_temp %w(a.t .a.t b.t .b.t) do
+	    l1 = cx.sys["*.t"]
+	    l1.glob_flags |= File::FNM_DOTMATCH
+	    l2 = cx.sys["*.t"]
+	    assert_equal(4, l1.size)
+	    assert_equal(2, l2.size)
+	    %w(a.t .a.t b.t .b.t).each { |f| l1.include? f }
+	    %w(a.t b.t ).each { |f| l2.include? f }
+	end
+    end
 end

data/test/test_lighttask.rb

@@ -1,11 +1,10 @@
 
 require 'test/unit'
-require 'rant/rantlib'
-
+require 'tutil'
 
 class TestLightTask < Test::Unit::TestCase
     def setup
-	@app = Rant::RantApp.new %w()
+	@app = Rant::RantApp.new
     end
     def teardown
     end
@@ -14,13 +13,12 @@ class TestLightTask < Test::Unit::TestCase
 	Rant::LightTask.new(*[@app, args].flatten, &block)
     end
     def test_init
-	t = lt :tinit
+	t = lt "tinit"
 	assert(t.needed?,
 	    "needed? should be true after creation without " +
 	    "`needed' block")
 	assert(!t.done?)
-	assert_equal(t.name, "tinit",
-	    "task name should always be a string, despite creation with symbol")
+	assert_equal(t.name, "tinit")
     end
     def test_with_blocks
 	run = false

data/test/test_rant_interface.rb

@@ -13,9 +13,9 @@ class TestRantInterface < Test::Unit::TestCase
     def teardown
     end
     def test_cmd_targets
-	@app = Rant::RantApp.new("-f non_existent", "target", "-aforced_target")
+	@app = Rant::RantApp.new
 	op = capture_stderr {
-	    assert_equal(@app.run, 1,
+	    assert_equal(@app.run("-f non_existent", "target", "-aforced_target"), 1,
 		"Rant should fail because there is no such Rantfile.")
 	}
 	assert(op =~ /\[ERROR\]/,
@@ -28,25 +28,25 @@ class TestRantInterface < Test::Unit::TestCase
 	    "forced_target should run first")
     end
     def test_envvar_on_cmdline
-	@app = Rant::RantApp.new("VAR=VAL")
+	@app = Rant::RantApp.new
 	@app.context.var.env "VAR"
-	assert_equal(@app.run, 0)
+	assert_equal(@app.run("VAR=VAL"), 0)
 	assert_equal(ENV["VAR"], "VAL",
 	    "rant should set arguments of form VAR=VAL in var")
     end
     def test_envvar_on_cmdline_lc
-	@app = Rant::RantApp.new("var2=val2")
-	assert_equal(@app.run, 0)
+	@app = Rant::RantApp.new
+	assert_equal(@app.run("var2=val2"), 0)
 	assert_equal(@app.context.var["var2"], "val2",
 	    "rant should set arguments of form var2=val2 in var")
     end
     def test_opt_targets
-	@app = Rant::RantApp.new("--tasks")
+	@app = Rant::RantApp.new
 	@app.desc 'This is a "public" target.'
 	@app.task :public_task
 	@app.task :private_task
 	op = capture_stdout { 
-	    assert_equal(@app.run, 0)
+	    assert_equal(@app.run("--tasks"), 0)
 	}
 	assert(op =~ /\bpublic_task\b/,
 	    "rant -T output should contain name of described task")

data/test/test_rantfile_api.rb

@@ -9,10 +9,11 @@ $testDir ||= File.expand_path(File.dirname(__FILE__))
 class TestRantfileAPI < Test::Unit::TestCase
     def setup
 	# Ensure we run in test directory.
-	Dir.chdir($testDir) unless Dir.pwd == $testDir
+	Dir.chdir $testDir
 	@app = Rant::RantApp.new
     end
     def teardown
+	Dir.chdir $testDir
 	FileUtils.rm_rf Dir["*.t"]
     end
     def test_action
@@ -44,4 +45,39 @@ class TestRantfileAPI < Test::Unit::TestCase
     def test_rac_build_cd
 	assert_rant("tmp.t/Rantfile", "subdir_tmp", "build_test_t")
     end
+    def test_string_sub_ext
+	assert_equal("hello.txt", "hello.sxw".sub_ext(".sxw", ".txt"))
+    end
+    def test_string_sub_ext_2
+	assert_equal("hello.txt", "hello.sxw".sub_ext("sxw", "txt"))
+    end
+    def test_string_sub_ext_one_arg
+	assert_equal("hello.txt", "hello.sxw".sub_ext("txt"))
+    end
+    def test_string_sub_ext_new_ext
+	assert_equal("hello.txt", "hello".sub_ext("txt"))
+    end
+    def test_string_sub_ext_dot
+	assert_equal("hello.txt", "hello.".sub_ext("txt"))
+    end
+    def test_string_sub_ext_empty_str
+	assert_equal("hello.", "hello.txt".sub_ext(""))
+    end
+    def test_string_sub_ext_nil
+	assert_equal("hello.", "hello.txt".sub_ext(nil))
+    end
+    def test_name_error_in_task
+	open "rf.t", "w" do |f|
+	    f << <<-EOF
+	    task :a do
+		n_i_x
+	    end
+	    EOF
+	end
+	out, err = assert_rant(:fail, "-frf.t")
+	assert(out.strip.empty?)
+	assert_match(/rf\.t/, err)
+	assert_match(/2/, err)
+	assert_match(/n_i_x/, err)
+    end
 end

data/test/test_rule.rb

@@ -49,6 +49,12 @@ class TestRule < Test::Unit::TestCase
 	assert(test(?f, "r.tt"))
 	assert(test(?f, "r.lt"))
     end
+    def test_enhance_rule_task
+	out, err = assert_rant("-frule.rf", "enhance_t=1", "eh.t")
+	assert(test(?f, "eh.t"))
+	assert_match(/eh\.t created/, out)
+	assert(err !~ /\[WARNING\]|\[ERROR\]/)
+    end
 if Rant::Env.find_bin("cc") && Rant::Env.find_bin("gcc")
     # Note: we are assuming that "cc" invokes "gcc"!
     def test_cc
@@ -60,8 +66,5 @@ if Rant::Env.find_bin("cc") && Rant::Env.find_bin("gcc")
     end
 else
     $stderr.puts "*** cc/gcc not available, less rule tests ***"
-    def test_dummy
-	assert(true)
-    end
 end
 end

data/test/test_source.rb

@@ -9,7 +9,7 @@ $testDir ||= File.expand_path(File.dirname(__FILE__))
 
 class TestSource < Test::Unit::TestCase
     def setup
-	Dir.chdir($testDir) unless Dir.pwd == $testDir
+	Dir.chdir $testDir
     end
     def teardown
 	capture_std do
@@ -23,4 +23,31 @@ class TestSource < Test::Unit::TestCase
 	assert(test(?f, "auto.rf"))
 	assert(test(?f, "auto.t"))
     end
+    def test_source_now
+	open "rf.t", "w" do |f|
+	    f << <<-EOF
+	    file "source.rf.t" do |t|
+		sys.touch t.name
+	    end
+	    task :source_now do
+		source :n, "source.rf.t"
+	    end
+	    task :source_now2 do
+		sys.touch "source.rf.t"
+		source :n, "source.rf.t"
+	    end
+	    task :mk_source do
+		source "source.rf.t"
+	    end
+	    EOF
+	end
+	assert_rant("-frf.t", "mk_source")
+	assert(test(?f, "source.rf.t"))
+	FileUtils.rm "source.rf.t"
+	out, err = assert_rant(:fail, "-frf.t", "source_now")
+	assert(!test(?f, "source.rf.t"))
+	assert_match(/\[ERROR\].*source.*No such file.*source\.rf\.t/im, err)
+	assert_rant("-frf.t", "source_now2")
+	assert(test(?f, "source.rf.t"))
+    end
 end