rant 0.4.4 → 0.4.6

data/test/test_rant_interface.rb

@@ -63,4 +63,28 @@ class TestRantInterface < Test::Unit::TestCase
 	assert(op.split("\n").size > 15,
 	    "rant --help should print at least 16 lines to STDOUT")
     end
+    def test_opt_version
+        out, err = assert_rant("--version")
+        assert err.empty?
+        lines = out.split(/\n/)
+        assert_equal 1, lines.size
+        assert_match(/^rant \d\.\d\.\d$/i, lines.first)
+        out2, err2 = assert_rant("-V")
+        assert_equal err, err2
+        assert_equal out, out2
+    end
+    def test_no_such_option
+        out, err = assert_rant :fail, "-n"
+        assert out.empty?
+        lines = err.split(/\n/)
+        assert lines.size < 3
+        assert_match(/\[ERROR\].*option.*\bn\b/, lines.first)
+    end
+    def test_no_such_long_option
+        out, err = assert_rant :fail, "--nix"
+        assert out.empty?
+        lines = err.split(/\n/)
+        assert lines.size < 3
+        assert_match(/\[ERROR\].*option.*\bnix\b/, lines.first)
+    end
 end

data/test/test_rantfile_api.rb

@@ -1,12 +1,12 @@
 
 require 'test/unit'
-require 'rant/rantlib'
 require 'tutil'
-require 'fileutils'
 
 $testDir ||= File.expand_path(File.dirname(__FILE__))
 
 class TestRantfileAPI < Test::Unit::TestCase
+    include Rant::TestUtil
+
     def setup
 	# Ensure we run in test directory.
 	Dir.chdir $testDir
@@ -139,4 +139,56 @@ class TestRantfileAPI < Test::Unit::TestCase
         assert_equal("test\n", out)
         assert(err.empty?)
     end
+    def test_task_no_arguments
+        in_local_temp_dir do
+            write_to_file "Rantfile", <<-EOF
+                task
+                task :default do
+                    puts "hello"
+                end
+            EOF
+            out, err = assert_rant :fail
+            assert out.empty?
+            lines = err.split(/\n/)
+            assert lines.size < 4
+            assert_match(/\[ERROR\].*Rantfile\b.*\b1\b/, lines[0])
+            assert_match(/argument/, lines[1])
+        end
+    end
+    def test_file_too_many_hash_elements
+        in_local_temp_dir do
+            write_to_file "root.rant", <<-EOF
+
+                file :a => :b, :c => :d do |t|
+                    sys.touch t.name
+                end
+            EOF
+            out, err = assert_rant :fail
+            assert out.empty?
+            assert !test(?e, "a")
+            assert !test(?e, "c")
+            lines = err.split(/\n/)
+            assert lines.size < 4
+            assert_match(/\[ERROR\].*root\.rant\b.*\b2\b/, lines[0])
+            assert_match(/\btoo many\b.*\bone\b/i, lines[1])
+        end
+    end
+    def test_task_string_or_symbol_required
+        in_local_temp_dir do
+            write_to_file "root.rant", <<-EOF
+                task Object.new
+            EOF
+            out, err = assert_rant :fail
+            assert out.empty?
+            lines = err.split(/\n/)
+            assert lines.size < 4
+            assert_match(/\[ERROR\].*root\.rant\b.*\b1\b/, lines[0])
+            assert_match(/string or symbol/i, lines[1])
+        end
+    end
+    def test_make_plain_task
+        out, err = assert_rant "call-make"
+        assert err.empty?
+        assert_equal "print_name.t\ncall-make\n", out
+    end
 end

data/test/test_sourcenode.rb

@@ -160,4 +160,34 @@ class TestSourceNode < Test::Unit::TestCase
 	    assert_equal(th, th.join(0.5))
 	end
     end
+    def test_file_pre
+        @rf = <<-EOF
+        import "autoclean"
+        file "f.t" => "a.t" do |t|
+            sys.touch t.name
+        end
+        gen SourceNode, "a.t" => ["b.t", "c.t"]
+        file "b.t" do |t|
+            sys.touch t.name
+        end
+        gen AutoClean
+        EOF
+        FileUtils.touch "c.t"
+        FileUtils.touch "a.t"
+        tmp_rf do
+            out, err = assert_rant("-frf.t")
+            assert(err.empty?)
+            assert(!out.empty?)
+            assert(test(?f, "f.t"))
+            assert(test(?f, "b.t"))
+            out, err = assert_rant("-frf.t")
+            assert(err.empty?)
+            assert(out.empty?)
+            assert_rant("-frf.t", "autoclean")
+            assert(!test(?f, "f.t"))
+            assert(!test(?f, "b.t"))
+            assert(test(?f, "a.t"))
+            assert(test(?f, "c.t"))
+        end
+    end
 end

data/test/test_sys.rb

@@ -1,46 +1,145 @@
 
 require 'test/unit'
-require 'rant/rantlib'
 require 'tutil'
 
 $testDir ||= File.expand_path(File.dirname(__FILE__))
 
 class TestSys < Test::Unit::TestCase
     include Rant::Sys
+    include Rant::TestUtil
 
     def setup
 	# Ensure we run in test directory.
-	Dir.chdir($testDir) unless Dir.pwd == $testDir
+	Dir.chdir($testDir)
     end
-    def teardown
-    end
-
     def test_ruby
+        cx = Rant::RantApp.new.cx
+        block_executed = false
 	op = capture_stdout do
-	    ruby('-e ""') { |succ, stat|
-		assert(succ)
-		assert_equal(stat, 0)
+	    cx.sys.ruby('-e ""') { |stat|
+                block_executed = true
+		assert_equal(0, stat)
 	    }
 	end
+        assert(block_executed)
 	assert(op =~ /\-e/i,
-	    "Sys should print command with arguments to $stdout")
+	    "sys should print command with arguments to $stdout")
+    end
+    def test_ruby_no_block
+        assert(!test(?e, "a.t"))
+        out, err = capture_std do
+            assert_nothing_raised { ruby '-e', 'open "a.t", "w" do end' }
+        end
+        assert(test(?f, "a.t"))
+    ensure
+        FileUtils.rm_f "a.t"
+    end
+    def test_ruby_exit_code
+        cx = Rant::RantApp.new.cx
+        block_executed = false
+	out, err = capture_std do
+	    cx.sys.ruby('-e', 'exit 2') { |stat|
+                block_executed = true
+		assert_equal(2, stat.exitstatus)
+	    }
+	end
+        assert(block_executed)
+        assert(err.empty?)
+        assert_match(/. -e exit 2\n\z/m, out)
     end
-    def test_split_path
-	pl = split_path("/home/stefan")
+    def test_ruby_fail
+        out, err = capture_std do
+            assert_raises(Rant::CommandError) { ruby '-e exit 1' }
+        end
+    end
+    def test_split_all
+	pl = split_all("/home/stefan")
 	assert_equal(pl.size, 3,
 	    "/home/stefan should get split into 3 parts")
 	assert_equal(pl[0], "/")
 	assert_equal(pl[1], "home")
 	assert_equal(pl[2], "stefan")
-	pl = split_path("../")
+	pl = split_all("../")
 	assert_equal(pl.size, 1,
 	    '../ should be "split" into one element')
 	assert_equal(pl[0], "..")
     end
+    def test_expand_path
+        in_local_temp_dir do
+            rootdir = Dir.pwd
+            write_to_file "root.rant", <<-EOF
+                task :a do
+                    puts sys.expand_path("@")
+                end
+                subdirs "sub"
+            EOF
+            in_local_temp_dir "sub" do
+                write_to_file "sub.rant", <<-'EOF'
+                    task :a do
+                        puts sys.expand_path("@")
+                    end
+                    task :b do
+                        puts sys.expand_path("@/abc")
+                    end
+                    task :c do
+                        puts sys.expand_path("@abc")
+                    end
+                    task :d do
+                        puts sys.expand_path("../abc")
+                    end
+                    task :e do
+                        puts sys.expand_path(nil)
+                    end
+                    task :f do
+                        puts sys.expand_path("@/../abc")
+                    end
+                    task :g do
+                        puts sys.expand_path("a@b")
+                    end
+                    task :h do
+                        puts sys.expand_path("@a@b")
+                    end
+                    task :i do
+                        puts sys.expand_path('\@a@b')
+                    end
+                    task :j do
+                        puts sys.expand_path(nil)
+                    end
+                EOF
+                Dir.chdir ".."
+                out, err = assert_rant "a"
+                assert_equal rootdir, out.chomp
+                out, err = assert_rant "sub/a"
+                assert_equal rootdir, out.split(/\n/).last
+                Dir.chdir "sub"
+                out, err = assert_rant "a"
+                assert_equal rootdir, out.split(/\n/).last
+                out, err = assert_rant "b"
+                assert_equal "#{rootdir}/abc", out.split(/\n/).last
+                out, err = assert_rant "c"
+                assert_equal "#{rootdir}/abc", out.split(/\n/).last
+                out, err = assert_rant "d"
+                assert_equal "#{rootdir}/abc", out.split(/\n/).last
+                out, err = assert_rant "e"
+                assert_equal "#{rootdir}/sub", out.split(/\n/).last
+                out, err = assert_rant "f"
+                assert_equal "#{File.dirname(rootdir)}/abc", out.split(/\n/).last
+                out, err = assert_rant "g"
+                assert_equal "#{rootdir}/sub/a@b", out.split(/\n/).last
+                out, err = assert_rant "h"
+                assert_equal "#{rootdir}/a@b", out.split(/\n/).last
+                out, err = assert_rant "i"
+                assert_equal "#{rootdir}/sub/@a@b", out.split(/\n/).last
+                out, err = assert_rant "e"
+                assert_equal "#{rootdir}/sub", out.split(/\n/).last
+            end
+        end
+    end
     # perhaps this test should go into a seperate file
     def test_toplevel
-	assert_match(/\btd\b/, run_rant("-ftoplevel.rf"),
-	    "Sys module should print commands to stdout")
+        out = run_rant("-ftoplevel.rf")
+	#assert_match(/\btd\b/, out,
+	#    "Sys module should print commands to stdout")
 	assert_equal(0, $?,
 	    "rant -ftoplevel.rf in test/ should be successfull")
     ensure
@@ -54,7 +153,10 @@ class TestSys < Test::Unit::TestCase
 	out, err = capture_std do
 	    assert_equal(1, Rant.run("-fname_error.rf"))
 	end
-	assert_match(/Name\s*Error/i, err.split("\n").first)
+        lines = err.split(/\n/)
+        assert_equal(3, lines.size)
+        assert_match(/\bname_error\.rf\b.*\b1\b/, lines[0])
+	assert_match(/Name\s*Error/i, lines[1])
     ensure
 	File.delete "name_error.rf" if File.exist? "name_error.rf"
     end
@@ -82,4 +184,30 @@ class TestSys < Test::Unit::TestCase
     ensure
         FileUtils.rm_rf %w(cp.t a.t b.t)
     end
+    def test_sys_with_block
+        open "exit_1.t", "w" do |f|
+            f << <<-EOF
+            exit 1
+            EOF
+        end
+        open "rf.t", "w" do |f|
+            f << <<-EOF
+            task :rbexit1_block do
+                sys Env::RUBY, "exit_1.t" do |status|
+                    puts "no success" if status != 0
+                    puts status.exitstatus
+                end
+            end
+            task :rbexit1 do
+                sys.ruby "exit_1.t"
+            end
+            EOF
+        end
+        out, err = assert_rant("-frf.t")
+        assert(err.empty?)
+        assert_equal(["no success", "1"], out.split(/\n/)[1..-1])
+        out, err = assert_rant(:fail, "-frf.t", "rbexit1")
+    ensure
+        FileUtils.rm_f %w(exit_1.t rf.t)
+    end
 end

data/test/test_task.rb

@@ -1,42 +1,37 @@
 
 require 'test/unit'
-require 'rant/rantlib'
+require 'tutil'
 
 $-w = true
 
 class TestTask < Test::Unit::TestCase
     def setup
+        @rant = Rant::RantApp.new
     end
-    def teardown
-    end
-
     def test_version
 	assert(Rant::VERSION.length >= 5)
     end
-
     def test_needed
 	run = false
-	t = Rant::Task.new(nil, :non_existent) { run = true }
+	t = Rant::Task.new(@rant, :non_existent) { run = true }
 	assert(t.needed?,
 	    "Rant::Task should always be 'needed?' before first invocation")
 	assert(!run,
 	    "Rant::Task shouldn't get run when 'needed?' is called")
     end
-
     def test_invoke
 	run = false
 	block = lambda { run = true }
-	task = Rant::Task.new(nil, :test_run, &block)
+	task = Rant::Task.new(@rant, :test_run, &block)
 	task.invoke
 	assert(run, "block should have been executed")
 	assert(task.done?, "task is done")
 	assert(!task.needed?,
 	    "task is done, so 'needed?' should return false")
     end
-
     def test_fail
 	block = lambda { |t| t.fail "this task abortet itself" }
-	task = Rant::Task.new(nil, :test_fail, &block)
+	task = Rant::Task.new(@rant, :test_fail, &block)
 	assert_raise(Rant::TaskFail,
 	    "run should throw Rant::TaskFail if block raises Exception") {
 	    task.invoke
@@ -44,11 +39,10 @@ class TestTask < Test::Unit::TestCase
 	assert(task.fail?)
 	assert(task.invoked?, "although task failed, it was invoked")
     end
-
     def test_dependent
 	r1 = r2 = false
-	t1 = Rant::Task.new(nil, :t1) { r1 = true }
-	t2 = Rant::Task.new(nil, :t2) { r2 = true }
+	t1 = Rant::Task.new(@rant, :t1) { r1 = true }
+	t2 = Rant::Task.new(@rant, :t2) { r2 = true }
 	t1 << t2
 	t1.invoke
 	assert(r1)
@@ -60,8 +54,8 @@ class TestTask < Test::Unit::TestCase
     end
 
     def test_dependency_fails
-	t1 = Rant::Task.new(nil, :t1) { true }
-	t2 = Rant::Task.new(nil, :t2) { |t| t.fail }
+	t1 = Rant::Task.new(@rant, :t1) { true }
+	t2 = Rant::Task.new(@rant, :t2) { |t| t.fail }
 	t1 << t2
 	assert_raise(Rant::TaskFail,
 	    "dependency t2 failed, so t1 should fail too") {
@@ -75,7 +69,7 @@ class TestTask < Test::Unit::TestCase
 
     def test_task
 	run = false
-	t = Rant.rac.task :t do |t|
+	t = @rant.task :t do |t|
 	    run = true
 	end
 	t.invoke
@@ -84,7 +78,7 @@ class TestTask < Test::Unit::TestCase
 
     def test_dep_on_self
 	run = false
-	t = Rant.rac.task :t => "t" do |t|
+	t = @rant.task :t => "t" do |t|
 	    run = true
 	end
 	th = Thread.new { t.invoke }
@@ -97,11 +91,11 @@ class TestTask < Test::Unit::TestCase
     def test_circular_dependency
 	t1r = false
 	t2r = false
-	t1 = Rant.rac.task :t1 => :t2 do |t|
+	t1 = @rant.task :t1 => :t2 do |t|
 	    assert(t2r)
 	    t1r = true
 	end
-	t2 = Rant.rac.task :t2 => :t1 do |t|
+	t2 = @rant.task :t2 => :t1 do |t|
 	    t2r = true
 	end
 	out, err = capture_std do
@@ -117,13 +111,13 @@ class TestTask < Test::Unit::TestCase
     end
     def test_dep_on_self_in_deplist
 	rl = []
-	t1 = Rant.rac.task :t1 do |t|
+	t1 = @rant.task :t1 do |t|
 	    rl << t.name
 	end
-	t2 = Rant.rac.task :t2 do |t|
+	t2 = @rant.task :t2 do |t|
 	    rl << t.name
 	end
-	t3 = Rant.rac.task :t3 => [:t1, :t3, :t2] do |t|
+	t3 = @rant.task :t3 => [:t1, :t3, :t2] do |t|
 	    rl << t.name
 	end
 	th = Thread.new { t3.invoke }