rant 0.3.0 → 0.3.2

data/test/standalone.rf

@@ -0,0 +1,10 @@
+
+require 'rant'
+
+task :t_standalone do |t|
+    puts t.name
+end
+
+if $0 == __FILE__
+    exit Rant.run
+end

data/test/subdirs/Rantfile

@@ -0,0 +1,26 @@
+
+file "t" => "sub1/t" do |t|
+    sys.touch t.name
+end
+
+file "2t" => "sub2/t" do |t|
+    sys.touch t.name
+end
+
+file "subdep.t" do |t|
+    sys.touch t.name
+end
+
+task :sub_sub => "sub2/sub/rootref.t" do |t|
+    test(?f, "sub2/sub/rootref.t") or t.fail
+    sys.touch "sub_sub.t"
+end
+
+#task :clean => ["sub1/clean", "sub2/clean"] do
+task :clean => ["sub2/clean", "sub1/clean", "sub2/sub/clean"] do
+    sys.rm_f Dir["*t"]
+end
+
+subdirs FileList["sub*"].exclude("*.*")
+
+# vim:ft=ruby

data/test/subdirs/sub1/Rantfile

@@ -0,0 +1,15 @@
+
+file "t" do |t|
+    sys.touch t.name
+end
+
+file "rootdep.t" => "#subdep.t" do |t|
+    test(?f, "../subdep.t") || t.fail
+    sys.touch t.name
+end
+
+task :clean do
+    sys.rm_f Dir["*t"]
+end
+
+# vim:ft=ruby

data/test/subdirs/sub2/rantfile.rb

@@ -0,0 +1,14 @@
+
+subdirs "sub"
+
+file "t" do |t|
+    sys.touch t.name
+end
+
+file "subdep.t" => "sub/rootdep.t" do |t|
+    sys.touch t.name
+end
+
+task :clean do
+    sys.rm_f Dir["*t"]
+end

data/test/subdirs/sub2/sub/rantfile

@@ -0,0 +1,15 @@
+
+file "rootdep.t" do |t|
+    sys.touch t.name
+end
+
+file "rootref.t" => "#t" do |t|
+    test(?f, "../../t") || t.fail
+    sys.touch t.name
+end
+
+task :clean do
+    sys.rm_f Dir["*t"]
+end
+
+# vim:ft=ruby

data/test/subdirs/test_subdirs.rb

@@ -0,0 +1,96 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+require 'tutil'
+
+# Ensure we run in testproject directory.
+$testSubdirsDir = File.expand_path(File.dirname(__FILE__))
+
+class TestSubdirs < Test::Unit::TestCase
+    def setup
+	Dir.chdir($testSubdirsDir) unless Dir.pwd == $testSubdirsDir
+	Rant.reset
+    end
+    def teardown
+	capture_std do
+	    assert_equal(Rant.run("clean"), 0)
+	end
+	created = Dir["**/*t"]
+	assert(created.empty?)
+    end
+    def test_load
+	capture_std do
+	    assert_equal(0, Rant.run("-T"))
+	end
+    end
+    def test_sub_dep
+	capture_std do
+	    assert_equal(0, Rant.run("t"))
+	end
+	assert(test(?f, "sub1/t"),
+	    "t depends on sub1/t")
+	assert(test(?f, "t"))
+    end
+    def test_sub_dep2
+	capture_std do
+	    assert_equal(0, Rant.run("2t"))
+	end
+	assert(test(?f, "sub2/t"))
+	assert(test(?f, "2t"))
+	assert(!test(?e, "sub1/t"))
+    end
+    def test_sub_task_from_commandline
+	capture_std do
+	    assert_equal(0, Rant.run("sub1/t"))
+	end
+	assert(test(?f, "sub1/t"))
+	assert(!test(?e, "t"))
+	capture_std do
+	    assert_equal(0, Rant.run("sub1/clean"))
+	end
+	assert(!test(?f, "sub1/t"))
+    end
+    def test_root_dep
+	capture_std do
+	    assert_equal(0, Rant.run("sub1/rootdep.t"))
+	end
+	assert(test(?f, "subdep.t"))
+	assert(test(?f, "sub1/rootdep.t"))
+    end
+    def test_sub_sub_dep
+	capture_std do
+	    assert_equal(0, Rant.run("sub2/subdep.t"))
+	end
+	assert(test(?f, "sub2/subdep.t"))
+	assert(test(?f, "sub2/sub/rootdep.t"))
+    end
+    def test_sub_sub_rootref
+	capture_std do
+	    assert_equal(0, Rant.run("sub2/sub/rootref.t"))
+	end
+	assert(test(?f, "t"))
+	assert(test(?f, "sub2/sub/rootref.t"))
+    end
+    def test_root_sub_sub_rootref
+	capture_std do
+	    assert_equal(0, Rant.run("sub_sub"))
+	end
+	assert(test(?f, "sub_sub.t"))
+	assert(test(?f, "sub2/sub/rootref.t"))
+	assert(test(?f, "t"))
+    end
+    def test_import
+	run_import %w(--auto ant)
+	assert_equal($?, 0)
+	capture_std do
+	    assert_nothing_raised {
+		Rant::Sys.ruby("ant", "-q", "sub_sub")
+	    }
+	end
+	assert(test(?f, "sub_sub.t"))
+	assert(test(?f, "sub2/sub/rootref.t"))
+	assert(test(?f, "t"))
+    ensure
+	File.delete "ant" if File.exist? "ant"
+    end
+end

data/test/test_env.rb

@@ -30,15 +30,15 @@ class TestRantEnv < Test::Unit::TestCase
 	    have_echo = `echo hello` =~ /hello/
 	rescue Exception
 	end
-	if have_echo
-=begin
+	if have_echo
+=begin
             # seems to be not so on windows...
 	    echo_bin = Rant::Env.find_bin("echo")
 	    assert(echo_bin,
 		"echo can be invoked, so find_bin should find it")
 	    assert(echo_bin =~ /echo/i)
 	    assert(`#{echo_bin} hello` =~ /hello/,
-		"echo should be invokable through `#{echo_bin}'")
+		"echo should be invokable through `#{echo_bin}'")
 =end
 	else
 	    puts "*** echo not available, will not search with find_bin ***"

data/test/test_filelist.rb

@@ -0,0 +1,143 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+require 'fileutils'
+require 'tutil'
+
+$testDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestFileList < Test::Unit::TestCase
+    def fl(*args, &block)
+	Rant::FileList.new(*args, &block)
+    end
+    def touch_temp(*args)
+	files = args.flatten
+	files.each { |f| FileUtils.touch f }
+	yield if block_given?
+    ensure
+	files.each { |f|
+	    File.delete f if File.exist? f
+	}
+    end
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testDir) unless Dir.pwd == $testDir
+    end
+    def teardown
+    end
+    def test_in_flatten
+	touch_temp %w(1.t 2.t) do
+	    assert(test(?f, "1.t"))	# test touch_temp...
+	    assert(test(?f, "2.t"))
+	    assert_equal(2, fl("*.t").size)
+	    # see comments in FileList implementation to understand
+	    # the necessity of this test...
+	    assert_equal(2, [fl("*.t")].flatten.size)
+	end
+    end
+    def test_exclude_all
+	l = fl
+	inc_list = %w(
+	    CVS_ a/b a
+	    ).map! { |f| f.tr "/", File::SEPARATOR }
+	not_inc_list = %w(
+	    CVS a/CVS a/CVS/b CVS/CVS //CVS /CVS/ /a/b/CVS/c
+	    ).map! { |f| f.tr "/", File::SEPARATOR }
+	l.concat(not_inc_list + inc_list)
+	l.exclude_all "CVS"
+	inc_list.each { |f|
+	    assert(l.include?(f))
+	}
+	not_inc_list.each { |f|
+	    assert(!l.include?(f))
+	}
+    end
+    def test_initialize
+	touch_temp %w(1.t 2.tt) do
+	    assert(fl("*.t").include?("1.t"),
+		'FileList["*.t"] should include 1.t')
+	    l = fl("*.t", "*.tt")
+	    assert(l.include?("1.t"))
+	    assert(l.include?("2.tt"))
+	end
+    end
+    def test_initialize_with_yield
+	touch_temp %w(a.t b.t a.tt b.tt) do
+	    list = fl { |l|
+		l.include "*.t", "*.tt"
+		l.exclude "a*"
+	    }
+	    %w(b.t b.tt).each { |f|
+		assert(list.include?(f), "`#{f}' should be included")
+	    }
+	    %w(a.t a.tt).each { |f|
+		assert(!list.include?(f), "`#{f}' shouln't be included")
+	    }
+	end
+    end
+    def test_mix_include_exclude
+	touch_temp %w(a.t b.t c.t d.t) do
+	    list = fl "a*"
+	    list.exclude("a*", "b*").include(*%w(b* c* d*))
+	    assert(list.exclude_all("d.t").equal?(list))
+	    assert(list.include?("b.t"))
+	    assert(list.include?("c.t"))
+	    assert(!list.include?("a.t"))
+	    assert(!list.include?("d.t"))
+	end
+    end
+    def test_exclude_regexp
+	touch_temp %w(aa.t a.t a+.t) do
+	    list = fl "*.t"
+	    list.exclude(/a+\.t/)
+	    assert(list.include?("a+.t"))
+	    assert(!list.include?("a.t"))
+	    assert(!list.include?("aa.t"))
+	    assert_equal(1, list.size)
+
+	    list = fl "*.t"
+	    list.exclude("a+.t")
+	    assert(!list.include?("a+.t"))
+	    assert(list.include?("a.t"))
+	    assert(list.include?("aa.t"))
+	    assert_equal(2, list.size)
+	end
+    end
+    def test_addition
+	touch_temp %w(t.t1 t.t2 t.t3) do
+	    l = (fl("*.t1") << "a") + fl("*.t2", "*.t3")
+	    assert_equal(4, l.size)
+	    %w(t.t1 t.t2 t.t3 a).each { |f|
+		assert(l.include?(f),
+		    "`#{f}' should be included")
+	    }
+	end
+    end
+    def test_2addition
+	touch_temp %w(1.ta 1.tb 2.t) do
+	    l1 = fl "*.ta", "*.t"
+	    l2 = fl "1*"
+	    l2.exclude "*.ta"
+	    l = l1 + l2
+	    assert(l.include?("1.ta"))
+	    assert_equal(3, l.size)
+	end
+    end
+    def test_glob
+	touch_temp %w(t.t1 t.t2) do
+	    l = fl "*.t1"
+	    l.glob "*.t2"
+	    assert_equal(2, l.size)
+	    assert(l.include?("t.t1"))
+	    assert(l.include?("t.t2"))
+	end
+    end
+    def test_shun
+	touch_temp %w(t.t1 t.t2) do
+	    l = fl "t.*"
+	    l.shun "t.t1"
+	    assert_equal(1, l.size)
+	    assert(l.include?("t.t2"))
+	end
+    end
+end

data/test/test_lighttask.rb

@@ -46,4 +46,25 @@ class TestLightTask < Test::Unit::TestCase
 	assert(!t.needed?,
 	    "task shouldn't be needed? after first run")
     end
+    def test_task_with_lighttask_pre
+	lt_run = false
+	lt_nr = false
+	t_run = false
+	@app.args.replace %w(t)
+	t1 = @app.gen Rant::LightTask, :t1 do |t|
+	    t.needed { lt_nr = true }
+	    t.act { lt_run = true }
+	end
+	t = @app.task :t => :t1 do
+	    assert(lt_run,
+		"LightTask prerequisite should run first.")
+	    t_run = true
+	end
+	assert(t.needed?)
+	assert(lt_nr)
+	assert(!lt_run,
+	    "LightTask#needed? shouldn't run 'act' block")
+	assert_equal(0, @app.run)
+	assert(t_run)
+    end
 end

data/test/test_metatask.rb

@@ -12,7 +12,7 @@ class TestMetaTask < Test::Unit::TestCase
     def test_with_single_task
 	run = false
 	t = @app.task :t do run = true end
-	mt = MetaTask.for_task t
+	mt = Rant::MetaTask.for_task t
 	assert_equal(t.name, mt.name,
 	    "MetaTask should have name of contained task(s).")
 	if t.needed?

data/test/test_rant_interface.rb

@@ -1,6 +1,6 @@
 
 require 'test/unit'
-require 'rant'
+require 'rant/rantlib'
 require 'tutil'
 
 $testDir ||= File.expand_path(File.dirname(__FILE__))
@@ -13,7 +13,7 @@ class TestRantInterface < Test::Unit::TestCase
     def teardown
     end
     def test_cmd_targets
-	@app = RantApp.new("-f non_existent", "target", "-aforced_target")
+	@app = Rant::RantApp.new("-f non_existent", "target", "-aforced_target")
 	op = capture_stderr {
 	    assert_equal(@app.run, 1,
 		"Rant should fail because there is no such Rantfile.")
@@ -28,19 +28,19 @@ class TestRantInterface < Test::Unit::TestCase
 	    "forced_target should run first")
     end
     def test_envvar_on_cmdline
-	@app = RantApp.new("VAR=VAL")
+	@app = Rant::RantApp.new("VAR=VAL")
 	assert_equal(@app.run, 0)
 	assert_equal(ENV["VAR"], "VAL",
 	    "rant should set arguments of form VAR=VAL in ENV")
     end
     def test_envvar_on_cmdline_lc
-	@app = RantApp.new("var2=val2")
+	@app = Rant::RantApp.new("var2=val2")
 	assert_equal(@app.run, 0)
 	assert_equal(ENV["var2"], "val2",
 	    "rant should set arguments of form var2=val2 in ENV")
     end
     def test_opt_targets
-	@app = RantApp.new("--tasks")
+	@app = Rant::RantApp.new("--tasks")
 	@app.desc 'This is a "public" target.'
 	@app.task :public_task
 	@app.task :private_task

data/test/test_sys.rb

@@ -5,7 +5,7 @@ require 'tutil'
 
 $testDir ||= File.expand_path(File.dirname(__FILE__))
 
-class TestFileUtils < Test::Unit::TestCase
+class TestSys < Test::Unit::TestCase
     include Rant::Sys
 
     def setup
@@ -58,4 +58,10 @@ class TestFileUtils < Test::Unit::TestCase
     ensure
 	File.delete "name_error.rf" if File.exist? "name_error.rf"
     end
+    # ...
+    def test_standalone
+	out = `#{Rant::Sys.sp(Rant::Env::RUBY)} -I#{Rant::Sys.sp(RANT_DEV_LIB_DIR)} standalone.rf`
+	assert(0, $?)
+	assert_match(/^t_standalone/, out)
+    end
 end

data/test/test_task.rb

@@ -112,4 +112,29 @@ class TestTask < Test::Unit::TestCase
 	assert_equal(rl, %w(t1 t2 t3),
 	    "t3 was run and depends on [t1, t2] => run order: t1 t2 t3")
     end
+    def test_enhance_gen_task
+	app = Rant::RantApp.new
+	enhance_run = false
+	t_run = false
+	t2_run = false
+	app.gen Rant::Task, :t do |t|
+	    t.needed { true }
+	    t.act {
+		assert(t2_run,
+		    "enhance added `t2' as prerequisite")
+		t_run = true
+	    }
+	end
+	app.gen Rant::Task, :t2 do |t|
+	    t.needed { true }
+	    t.act { t2_run = true }
+	end
+	assert_nothing_raised("generated Task should be enhanceable") {
+	    app.enhance :t => :t2 do
+		enhance_run = true
+	    end
+	}
+	assert_equal(0, app.run)
+	assert(t_run)
+    end
 end