rant 0.3.0

data/test/Rantfile

@@ -0,0 +1,2 @@
+
+task :do_nothing

data/test/plugin/configure/Rantfile

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+rd = File.expand_path("../../../lib")
+$:.unshift rd unless $:.include? rd
+
+require 'rant'
+
+task :hello do |t|
+    sys.touch t.name
+end
+
+conf = plugin :Configure do |conf|
+    conf.init_modes = [:default]
+    conf.override_modes = nil
+    conf.task		# define a task named :configure
+    conf.check "a" do |c|
+	c.default "value_a"
+	c.guess { "value_a_guess" }
+	c.react { |val|
+	    p val
+	}
+    end
+    conf.check "b" do |c|
+	c.default "value_b"
+    end
+    conf.check "c" do |c|
+    end
+    conf.check "d" do |c|
+	c.react {
+	}
+    end
+    conf.check "e" do |c|
+	c.guess { false }
+    end
+end
+
+file conf["a"] do |t|
+    sys.touch t.name
+end
+
+task :clean do
+    sys.rm_f %w(config hello value_a value_a_guess)
+end
+
+if $0 == __FILE__
+    Rant.run
+end

data/test/plugin/configure/test_configure.rb

@@ -0,0 +1,58 @@
+
+require 'test/unit'
+require 'rant'
+require 'tutil'
+
+$testPluginConfigureDir = File.expand_path(File.dirname(__FILE__))
+
+class TestPluginConfigure < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testPluginConfigureDir) unless Dir.pwd == $testPluginConfigureDir
+    end
+    def teardown
+	capture_std do
+	    assert_equal(Rant.run("clean"), 0)
+	end
+	assert(!File.exist?("hello"),
+	    "hello should have been removed by `clean'")
+	assert(!File.exist?("config"),
+	    "config should have been removed by `clean'")
+    end
+    def test_startup
+	capture_std do
+	    assert_equal(Rant.run([]), 0)
+	end
+	assert(File.exist?("hello"),
+	    "target `hello' is first, and should have been run")
+	assert(!File.exist?("config"),
+	    "config should have used defaults, no writing")
+    end
+    def test_configure
+	capture_std do
+	    assert_equal(Rant.run("configure"), 0)
+	end
+	assert(File.exist?("config"),
+	    "config should have been created by `configure'")
+	capture_std do
+	    assert_equal(Rant.run("value_a_guess"), 0,
+		"value_a_guess should be choosen based on config")
+	end
+	assert(File.exist?("value_a_guess"))
+    end
+    def test_configure_immediate
+	capture_std do
+	    assert_equal(Rant.run(%w(configure value_a)), 0,
+		"on task creation time, conf['a'] had the value `value_a'")
+	end
+	assert(!File.exist?("value_a_guess"))
+	assert(File.exist?("value_a"))
+    end
+    def test_defaults
+	capture_std do
+	    assert_equal(Rant.run("value_a"), 0)
+	end
+	assert(File.exist?("value_a"))
+	assert(!File.exist?("value_a_guess"))
+    end
+end

data/test/plugin/csharp/Hello.cs

@@ -0,0 +1,10 @@
+
+using System;
+
+class Hello
+{
+    public static void Main(string[] args)
+    {
+	Console.WriteLine("Hello, world!");
+    }
+}

data/test/plugin/csharp/Rantfile

@@ -0,0 +1,30 @@
+
+plugin :Csharp
+
+src_files = FileList["src/*.cs"]
+
+gen Assembly, "hello.exe" do |t|
+    t.sources = %w(Hello.cs)
+end
+
+gen Assembly, "AB.dll" => "hello.exe" do |t|
+    t.sources = src_files
+    t.debug = true
+    t.optimize = true
+    t.warnings = true
+end
+
+=begin
+assembly "hello.exe" => "Hello.cs"
+
+assembly "AB.dll" => src_files + ["hello.exe"] do |t|
+    t.sources = src_files
+    t.debug = true
+    t.optimize = true
+    t.warnings = true
+end
+=end
+
+task :clean do
+    sys.rm_f FileList["*.{exe,dll,obj}"]
+end

data/test/plugin/csharp/src/A.cs

@@ -0,0 +1,8 @@
+
+class A
+{
+    public string MethodA()
+    {
+	return "A";
+    }
+}

data/test/plugin/csharp/src/B.cs

@@ -0,0 +1,8 @@
+
+class B
+{
+    public string MethodB()
+    {
+	return "B";
+    }
+}

data/test/plugin/csharp/test_csharp.rb

@@ -0,0 +1,99 @@
+
+require 'test/unit'
+require 'rant'
+require 'rant/plugin/csharp'
+require 'tutil'
+
+$testPluginCsDir = File.expand_path(File.dirname(__FILE__))
+$have_csc = Env.find_bin("csc") || Env.find_bin("cscc") || Env.find_bin("mcs")
+
+class TestPluginCsharp < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testPluginCsDir) unless Dir.pwd == $testPluginCsDir
+    end
+    def teardown
+	capture_std do
+	    assert(Rant.run("clean"), 0)
+	end
+    end
+if $have_csc
+    # Try to compile the "hello world" program. Requires cscc, csc
+    # or mcs to be on your PATH.
+    def test_hello
+	capture_std do
+	    assert_equal(Rant.run([]), 0,
+		"first target, `hello.exe', should be compiled")
+	end
+	assert(File.exist?("hello.exe"),
+	    "hello.exe is the first target in Rantfile")
+	if Env.on_windows?
+	    assert_equal(`hello.exe`.chomp, "Hello, world!",
+		"hello.exe should print `Hello, world!'")
+	elsif (ilrun = Env.find_bin("ilrun"))
+	    assert_equal(`#{ilrun} hello.exe`.chomp, "Hello, world!",
+		"hello.exe should print `Hello, world!'")
+	elsif (mono = Env.find_bin("mono"))
+	    assert_equal(`#{mono} hello.exe`.chomp, "Hello, world!",
+		"hello.exe should print `Hello, world!'")
+	else
+	    $stderr.puts "Can't run hello.exe for testing."
+	end
+    end
+    def test_opts
+	capture_std do
+	    assert_equal(Rant.run("AB.dll"), 0)
+	end
+	assert(File.exist?("hello.exe"),
+	    "AB.dll depends on hello.exe")
+	assert(File.exist?("AB.dll"))
+    end
+    def test_cscc
+	old_csc = Assembly.csc
+	cscc = Env.find_bin("cscc")
+	unless cscc
+	    $stderr.puts "cscc not on path, will not test cscc"
+	    return
+	end
+	Assembly.csc = cscc
+	test_opts
+	Assembly.csc = old_csc
+    end
+    def test_mcs
+	old_csc = Assembly.csc
+	mcs = Env.find_bin("mcs")
+	unless mcs
+	    $stderr.puts "mcs not on path, will not test mcs"
+	    return
+	end
+	Assembly.csc = mcs
+	test_opts
+	Assembly.csc = old_csc
+    end
+    def test_csc
+	old_csc = Assembly.csc
+	csc = Env.find_bin("csc")
+	unless csc
+	    $stderr.puts "csc not on path, will not test csc"
+	    return
+	end
+	Assembly.csc = csc
+	test_opts
+	Assembly.csc = old_csc
+    end
+else
+    def test_dummy
+	# required to fool test/unit if no C# compiler available,
+	# so we skip all real tests
+	assert(true)
+	# remove this method if a test is added that doesn't depend on
+	# the C# compiler
+    end
+    print <<-EOF
+************************************************************
+* No C# compiler found on your path. Skipping all tests    *
+* depending on a C# compiler.                              *
+************************************************************
+    EOF
+end
+end

data/test/project1/Rantfile

@@ -0,0 +1,127 @@
+
+file "test_touch" do |t|
+    sys.touch t.name
+end
+
+task :clean do
+    sys.rm "test_touch"
+end
+
+task :create_target do
+    sys.touch "target"
+end
+
+task :create_dep do
+    sys.touch "dep"
+end
+
+file "target" => "dep" do |t|
+    sys.touch t.name
+end
+
+file "t2" => ["dep1", "dep2"] do |t|
+    sys.touch t.name
+end
+
+file "dep1" do |t|
+    sys.touch t.name
+end
+
+file "dep2" do |t|
+    sys.touch t.name
+end
+
+file "duplicate" do |t|
+    sys.touch t.name
+    sys.touch t.name + "1"
+end
+
+file "duplicate" do |t|
+    sys.touch t.name
+    sys.touch t.name + "2"
+end
+
+file "fallback" do
+    # doesn't create our target...
+    # so the next task with the same
+    # name should be run
+    sys.touch "fallback_"
+end
+
+file "fallback" do |t|
+    sys.touch t.name
+end
+
+gen Directory, "dir/subdir"
+task :path => "dir/subdir"
+
+gen Directory, "dir/sub2" do |t|
+    # This block should be called after the creation of the directory
+    # `sub2' in `dir'.
+    t.name == "dir/sub2" or t.fail
+    sys.touch "#{t.name}/postprocess"
+end
+
+file "tbe" => :dep1 do |t|
+    sys.touch t.name
+    sleep 2
+end
+
+enhance :tbe => "dep2" do |t|
+    sys.touch "tbe2"
+    sleep 2
+end
+
+# should generate warning because there is no existing task called
+# "nothing" and create the task "nothing"
+enhance :nothing
+
+task :order do |t|
+    sys.touch t.name + "1"
+    sleep 2
+end
+
+task :order do |t|
+    sys.touch t.name + "2"
+    sleep 2
+end
+
+file "incdep" do |t|
+    sys.touch t.name
+end
+
+file "inc" => "incdep" do |t|
+    sys.touch t.name
+end
+
+gen LightTask, :lighttask do |t|
+    t.needed do
+	!test ?f, "lt_target"
+    end
+    t.act do
+	sys.touch "lt_target"
+    end
+end
+
+gen Task, :task_one do |t|
+    t.needed do
+	!test ?f, "one_target"
+    end
+    t.act do
+	sys.touch "one_target"
+    end
+end
+
+gen Task, :task_two => :task_one do |t|
+    t.act { print t.name }
+end
+
+task :force_clean do
+    sys.rm_f %w(
+	test_touch target dep dep1 dep2 t2
+	duplicate duplicate1 duplicate2
+	fallback fallback_ order1 order2
+	tbe tbe2 inc incdep lt_target one_target
+	).find_all { |e| test(?e, e) }
+    sys.rm_rf %w(dir)
+end

data/test/project1/test_project.rb

@@ -0,0 +1,203 @@
+
+require 'test/unit'
+require 'rant'
+require 'tutil'
+
+# Ensure we run in testproject directory.
+$testProject1Dir = File.expand_path(File.dirname(__FILE__))
+
+class TestProject1 < Test::Unit::TestCase
+    def setup
+	Dir.chdir($testProject1Dir) unless Dir.pwd == $testProject1Dir
+	Rant.reset
+    end
+    def teardown
+	capture_std do
+	    assert_equal(Rant.run("force_clean"), 0)
+	end
+    end
+    def test_run
+	out, err = capture_std do
+	    assert_equal(Rant.run("test_touch"), 0,
+		"Exit code of rant should be 0.")
+	end
+	assert(err =~ /\[WARNING\]/,
+	    "rant should print a warning because of enhance on non-existing task")
+	Rant.reset
+	assert(File.exist?("test_touch"),
+	    "file test_touch should have been created")
+	capture_std do
+	    assert_equal(Rant.run("clean"), 0)
+	end
+	assert(!File.exist?("test_touch"))
+    end
+    def test_timedep
+	capture_std do
+	    assert_equal(Rant.run("create_target"), 0)
+	end
+	assert(File.exist?("target"))
+	Rant.reset
+	sleep 2
+	capture_std do
+	    assert_equal(Rant.run("create_dep"), 0)
+	end
+	assert(File.exist?("dep"))
+	assert(sys.uptodate?("dep", "target"),
+	    "`create_target' was run before `create_dep'")
+	sleep 2
+	capture_std do
+	    assert_equal(Rant.run("target"), 0)
+	end
+	assert(File.exist?("target"))
+	assert(File.exist?("dep"))
+	assert(sys.uptodate?("target", "dep"),
+	    "`target' should be newer than `dep'")
+	t1 = File.mtime "target"
+	Rant.reset
+	sleep 2
+	capture_std do
+	    assert_equal(Rant.run("target"), 0)
+	end
+	assert_equal(t1, File.mtime("target"),
+	    "`target' was already up to date")
+    end
+    def test_two_deps
+	capture_std do
+	    assert_equal(Rant.run("t2"), 0)
+	end
+	assert(File.exist?("t2"),
+	    "file `t2' should have been built")
+	assert(File.exist?("dep1"),
+	    "dependancy `dep1' should have been built")
+	assert(File.exist?("dep2"),
+	    "depandancy `dep2' should have been build")
+    end
+    def test_duplicate
+	capture_std do
+	    assert_equal(Rant.run("duplicate"), 0)
+	end
+	assert(File.exist?("duplicate"))
+	assert(File.exist?("duplicate1"),
+	    "duplicate1 should have been created as side effect " +
+	    "of running first task to build duplicate")
+	assert(!File.exist?("duplicate2"),
+	    "the second task to build duplicate should have " +
+	    "been run, duplicate was already built")
+    end
+    def test_fallback
+	capture_std do
+	    assert_equal(Rant.run("fallback"), 0)
+	end
+	assert(File.exist?("fallback_"),
+	    "should have been created as side-effect by fallback")
+	assert(File.exist?("fallback"),
+	    "second task for `fallback' should have been run")
+    end
+    def test_directory
+	capture_std do
+	    assert_equal(Rant.run("path"), 0)
+	end
+	assert(test(?d, "dir"),
+	    "dir should have been created as prerequisite of dir/subdir")
+	assert(test(?d, "dir/subdir"),
+	    "dir/subdir should have been created as prerequisite of path")
+    end
+    def test_directory_postprocess
+	capture_std do
+	    assert_equal(Rant.run("dir/sub2"), 0)
+	end
+	assert(test(?d, "dir/sub2"),
+	    "dir/sub2 should have been created by directory task")
+	assert(test(?f, "dir/sub2/postprocess"),
+	    "dir/sub2/postprocess should have been created by block supplied to directory task")
+    end
+    def test_directory_postprocess_2
+	capture_std do
+	    assert_equal(Rant.run("dir/subdir"), 0)
+	end
+	assert(test(?d, "dir/subdir"))
+	assert(!File.exist?("dir/sub2"))
+	capture_std do
+	    assert_equal(Rant.run("dir/sub2"), 0)
+	end
+	assert(test(?f, "dir/sub2/postprocess"),
+	    "dir/sub2/postprocess should have been created by block supplied to directory task")
+    end
+    def test_order
+	capture_std do
+	    assert_equal(Rant.run("order"), 0)
+	end
+	assert(File.exist?("order1"))
+	assert(File.exist?("order2"))
+	assert(File.mtime("order1") < File.mtime("order2"),
+	    "tasks from same file should be run in definition order")
+    end
+    def test_enhance
+	capture_std do
+	    assert_equal(Rant.run("tbe"), 0)
+	end
+	assert(File.exist?("dep1"))
+	assert(File.exist?("dep2"),
+	    "dep2 was added as prerequisite to tbe by enhance")
+	assert(File.exist?("tbe"))
+	assert(File.exist?("tbe2"),
+	    "tbe2 should be created by enhance for tbe")
+	assert(test(?<, "tbe", "tbe2"),
+	    "block added by enhance should run after \"normal\" block")
+    end
+    def test_enhance_nothing
+	capture_std do
+	    assert_equal(Rant.run("nothing"), 0,
+		"enhance should create new task if no task with given name exists")
+	end
+    end
+    def test_incremental_build
+	capture_std do
+	    assert_equal(Rant.run("inc"), 0)
+	end
+	assert(test(?f, "inc"))
+	assert(test(?f, "incdep"))
+	old_mtime = test(?M, "incdep")
+	sleep 2
+	capture_std do
+	    assert_equal(Rant.run(%w(--force-run incdep)), 0,
+		"--force-run should unconditionally run `incdep'")
+	end
+	assert(old_mtime < test(?M, "incdep"),
+	    "incdep should have been updated by a forced run")
+	capture_std do
+	    assert_equal(Rant.run("inc"), 0)
+	end
+	assert(old_mtime < test(?M, "inc"),
+	    "dependency `incdep' is newer, so `inc' should get rebuilt")
+    end
+    def test_lighttask
+	capture_std do
+	    assert_equal(Rant.run("lighttask"), 0)
+	end
+	assert(test(?e, "lt_target"),
+	    "lt_target should get `touched' by lighttask")
+    end
+    def test_task_gen_one_arg
+	capture_std do
+	    assert_equal(Rant.run("task_one"), 0)
+	end
+	assert(test(?e, "one_target"),
+	    "one_target should get `touched' by task_one")
+	old_mtime = test(?M, "one_target")
+	sleep 2
+	capture_std do
+	    assert_equal(Rant.run("task_one"), 0)
+	end
+	assert_equal(test(?M, "one_target"), old_mtime)
+    end
+    def test_task_gen_with_pre
+	out, err = capture_std do
+	    assert_equal(0, Rant.run("task_two"))
+	end
+	assert(test(?e, "one_target"),
+	    "one_target should be created as prerequisite of task_two")
+	assert_match(/task_two$/, out,
+	    "task_two action prints task name")
+    end
+end