rant 0.4.8 → 0.5.0

data/test/deprecated/test_0_5_4.rb

@@ -0,0 +1,53 @@
+
+require 'test/unit'
+require 'tutil'
+require 'rant/import/sys/more'
+
+$test_deprecated_dir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestDeprecated_0_5_4 < Test::Unit::TestCase
+    include Rant::TestUtil
+
+    def setup
+        Dir.chdir $test_deprecated_dir
+    end
+    def test_autoimport_var_constraints
+        Rant::Sys.write_to_file "var.t", <<-EOF
+            var :a, :Integer
+            var :b, :String
+            var :c, :List
+            var :d, :Bool
+            task :default do
+                p var[:a].kind_of?(Integer)
+                p var[:b].kind_of?(String)
+                p var[:c].kind_of?(Array)
+                p(var[:d] == true || var[:d] == false)
+            end
+        EOF
+        out, err = assert_rant "-fvar.t", "a=2", "d=1"
+        assert_match(/import 'var\/numbers'/, err)
+        assert_match(/import 'var\/strings'/, err)
+        assert_match(/import 'var\/lists'/, err)
+        assert_match(/import 'var\/booleans'/, err)
+        lines = out.split(/\n/)
+        assert_equal %w(true true true true), lines
+    ensure
+        Rant::Sys.rm_f "var.t"
+    end
+    def test_var_is
+        Rant::Sys.write_to_file "var.t", <<-EOF
+            import "var/booleans"
+            var(:b => true).is :Bool
+            task :default do
+                p var[:b]
+                var[:b] = "off"
+                p var[:b]
+            end
+        EOF
+        out, err = assert_rant("-fvar.t")
+        assert_match(/\bvar\.t\b.*\b2\b.*var\.is.*deprecated.*0\.5\.4/m, err)
+        assert_equal %w(true false), out.split(/\n/)
+    ensure
+        Rant::Sys.rm_f "var.t"
+    end
+end

data/test/deprecated/test_0_6_0.rb

@@ -15,7 +15,7 @@ class TestDeprecated_0_6_0 < Test::Unit::TestCase
             assert_equal(0, Rant::RantImport.new("-v").run)
         end
         if Rant::VERSION > "0.4.8"
-            assert_match(/-v\bdeprecated\b.*-V.*--version\b/, err)
+            assert_match(/-v.*\bdeprecated\b.*-V.*--version\b/m, err)
         else
             assert err.empty?
         end

data/test/dryrun/Rantfile

@@ -0,0 +1,10 @@
+
+import "command"
+
+task :install => "foo.t" do
+    puts "installing foo"
+end
+
+gen Command, "foo.t", "foo.c", "$[sh_echo] $(>) $(<) > $(>)"
+
+@sh_echo = "#{sys.sp Env::RUBY_EXE} -e \"puts ARGV.join(' ')\""

data/test/dryrun/foo.c

@@ -0,0 +1,8 @@
+
+#include <stdio.h>
+
+int main(int argc, char** argv)
+{
+    printf("Hello!\n");
+    return 0;
+}

data/test/dryrun/test_dryrun.rb

@@ -0,0 +1,31 @@
+
+require 'test/unit'
+require 'tutil'
+
+# Ensure we run in testproject directory.
+$testDryRunDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestDryRun < Test::Unit::TestCase
+    include Rant::TestUtil
+    def setup
+	Dir.chdir($testDryRunDir)
+    end
+    def teardown
+    end
+    def test_default
+        cmd = "#{Rant::Sys.sp Rant::Env::RUBY_EXE} -e \"puts ARGV.join(' ')\" foo.t foo.c > foo.t"
+        out, err = assert_rant "-n"
+        assert err.empty?
+        assert !test(?e, "foo.t")
+        assert out !~ /installing foo/
+        lines = out.split(/\n/)
+        assert_match(/Executing.*\bfoo\.t\b/i, lines[0])
+        assert_match(/\s+-\s+SHELL\b/i, lines[1])
+        assert_match(/\s+#{Regexp.escape cmd}/, lines[2])
+        assert_match(/Executing.*\binstall\b/i, lines[3])
+        assert_match(/\s+-\s+Ruby Proc\b.*\bRantfile\b.*\b4\b/i, lines[4])
+        out2, err2 = assert_rant "--dry-run"
+        assert_equal out, out2
+        assert_equal err, err2
+    end
+end

data/test/import/c/dependencies/Rantfile

@@ -1,5 +1,5 @@
 
-import "c/dependencies", "autoclean"
+import "var/numbers", "c/dependencies", "autoclean"
 
 var :deps, 1..3
 

data/test/import/command/Rantfile

@@ -1,5 +1,5 @@
 
-import "command", "autoclean"
+import "var/strings", "var/booleans", "command", "autoclean"
 
 @ruby = Env::RUBY_EXE
 @sh_echo = "#{sys.sp Env::RUBY_EXE} -e \"puts ARGV.join(' ')\""

data/test/import/sys/test_tgz.rb

@@ -1,6 +1,7 @@
 
 require 'test/unit'
 require 'tutil'
+require 'rant/import/sys/more'
 
 $test_import_sys_dir ||= File.expand_path(File.dirname(__FILE__))
 
@@ -31,6 +32,27 @@ class TestImportSysTgz < Test::Unit::TestCase
             actual = Rant::FileList["pkg", "pkg/**/*", "pkg/**/.*"]
             actual.shun ".", ".."
             assert_equal((files + dirs).sort, actual.sort)
+
+            # test overwriting of existing files
+            Rant::Sys.write_to_file "pkg/test.c", "changed!\n"
+
+            out, err = assert_rant "-ftgz.rf"
+            assert err.empty?
+            assert !out.empty?
+            assert out.split(/\n/).size < 3
+            dirs = %w(pkg pkg/bin)
+            files = %w(pkg/test.c pkg/test.h pkg/bin/test pkg/bin/test.o)
+            dirs.each { |dir|
+                assert test(?d, dir), "dir `#{dir}' missing"
+            }
+            files.each { |fn|
+                src_fn = File.join "data", fn
+                assert test(?f, fn), "file `#{fn}' missing"
+                assert Rant::Sys.compare_file(fn, src_fn), "#{fn} corrupted"
+            }
+            actual = Rant::FileList["pkg", "pkg/**/*", "pkg/**/.*"]
+            actual.shun ".", ".."
+            assert_equal((files + dirs).sort, actual.sort)
         ensure
             Rant::Sys.rm_rf "pkg"
         end

data/test/subdirs2/root.rant

@@ -1,5 +1,8 @@
 
-import "autoclean", "subfile"
+import "autoclean", "subfile", "command"
+
+@sh_cat = "#{sys.sp Env::RUBY_EXE} -e \"print ARGF.read\""
+@sh_puts = "#{sys.sp Env::RUBY_EXE} -e \"puts ARGV\""
 
 def define_print_task(name)
     task name do |t|
@@ -20,6 +23,13 @@ file "b.t" do |t|
     write t.name
 end
 
+file "config.t" do |t|
+    var :config => "config\n"
+    write(t.name, var[:config])
+end
+
+gen Command, "c1.t", ["sub1/c1.t"], "$[sh_puts] ${<} > $(>)"
+
 gen SubFile, "t/t", "a.t" => "b.t" do |t|
     write(t.name, "abc")
 end

data/test/subdirs2/sub1/sub.rant

@@ -10,4 +10,7 @@ file "sub.t" => "@a.t" do |t|
     sys.cp sys.expand_path(t.source), t.name
 end
 
+gen Command, "c1.t", "@config.t", "$[sh_cat] ${<} > $(>)"
+gen Command, "c2.t", "@config.t", "$[sh_cat] ${prerequisites} > $(name)"
+
 gen Directory, "dir.t"

data/test/subdirs2/test_subdirs2.rb

@@ -236,4 +236,23 @@ EOF
         assert err.empty?
         assert_equal "sub00/a", out.split(/\n/).last
     end
+    def test_command
+        out, err = assert_rant "c1.t"
+        assert err.empty?
+        assert_file_content "config.t", "config\n"
+        assert_file_content "sub1/c1.t", "config\n"
+        assert_file_content "c1.t", "sub1/c1.t\n"
+        out, err = assert_rant "c1.t"
+        assert err.empty?
+        assert out.empty?
+    end
+    def test_command_in_sub
+        Dir.chdir "sub1"
+        out, err = assert_rant "c2.t"
+        assert_file_content "../config.t", "config\n"
+        assert_file_content "c2.t", "config\n"
+        out, err = assert_rant "c2.t"
+        assert err.empty?
+        assert out.split(/\n/).size < 2
+    end
 end

data/test/test_action.rb

@@ -0,0 +1,75 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestAction < Test::Unit::TestCase
+    include Rant::TestUtil
+    def setup
+        # Ensure we run in test directory.
+        Dir.chdir($testDir)
+    end
+    def teardown
+        Rant::Sys.rm_f Rant::FileList["*.t", "*.tt", "action.t.rant"]
+    end
+    def test_one_arg_regex
+        out, err = assert_rant "-faction.rant", "a.t", "b.t"
+        assert err.empty?
+        lines = out.split(/\n/)
+        assert_equal 4, lines.size
+        assert_equal 'executing action: rx /\.t$/', lines[0]
+        assert_match(/action\.t\.rant/, lines[1])
+        assert_match(/touch\s+a\.t/, lines[2])
+        assert_match(/touch\s+b\.t/, lines[3])
+    end
+    def test_one_arg_regex_remove_action
+        out, err = assert_rant :tmax_1, :fail, "-faction.rant", "a.t", "b.t", "c.t"
+        #assert err.empty?
+        lines = out.split(/\n/)
+        assert_equal 4, lines.size
+        assert_equal 'executing action: rx /\.t$/', lines[0]
+        assert_match(/action\.t\.rant/, lines[1])
+        assert_match(/touch\s+a\.t/, lines[2])
+        assert_match(/touch\s+b\.t/, lines[3])
+    end
+    def test_no_execute
+        out, err = assert_rant "-faction.rant", "b.tt"
+        assert err.empty?
+        lines = out.split(/\n/)
+        assert_equal 1, lines.size
+        assert_match(/touch\s+b\.tt/, lines[0])
+        out, err = assert_rant "-faction.rant", "b.tt"
+        assert err.empty?
+        assert out.empty?
+    end
+    def test_pwd
+        Rant::Sys.mkdir "sub.t"
+        Rant::Sys.write_to_file "sub.t/sub.rant", <<-EOF
+            task :a do
+                puts Dir.pwd
+                make "a.t" rescue nil
+                puts Dir.pwd
+                make "@a.t"
+            end
+        EOF
+        out, err = assert_rant "-faction.rant", "sub.t/a"
+        assert err !~ /ERROR/i
+        lines = out.split(/\n/)
+        assert_equal 7, lines.size
+        assert_match(/\bin\b/, lines[0])
+        subdir = File.join($testDir, "sub.t")
+        assert_equal(subdir, lines[1])
+        assert_match(/executing action: rx/, lines[2])
+        assert_match(/\bin\b/, lines[3])
+        assert_match(/action\.t\.rant/, lines[4])
+        assert_equal(subdir, lines[5])
+        assert_match(/touch\s+a\.t/, lines[6])
+        assert_file_content "a.t", ""
+        assert test(?f, "action.t.rant")
+        assert !test(?e, "sub.t/action.t.rant")
+    ensure
+        Dir.chdir($testDir)
+        Rant::Sys.rm_rf "sub.t"
+    end
+end

data/test/test_filelist.rb

@@ -160,16 +160,18 @@ class TestFileList < Test::Unit::TestCase
     end
     def test_3addition
         cx = Rant::RantApp.new.cx
-        touch_temp %w(a.t1 a.t2 b.t2) do
-            l1 = cx.sys["a*"]
-            l1.exclude "*.t2"
-            l2 = cx.sys["*.t2"]
-            l3 = l1 + l2
-            %w(a.t1 a.t2 b.t2).each { |fn|
-                assert(l3.include(fn), "#{fn} missing")
-            }
-            l3.lazy_uniq!
-            assert_equal(3, l3.size)
+        in_local_temp_dir do
+            touch_temp %w(a.t1 a.t2 b.t2) do
+                l1 = cx.sys["a*"]
+                l1.exclude "*.t2"
+                l2 = cx.sys["*.t2"]
+                l3 = l1 + l2
+                %w(a.t1 a.t2 b.t2).each { |fn|
+                    assert(l3.include(fn), "#{fn} missing")
+                }
+                l3.lazy_uniq!
+                assert_equal(3, l3.size)
+            end
         end
     end
     def test_add_array
@@ -390,6 +392,7 @@ class TestFileList < Test::Unit::TestCase
         end
     end
     def test_no_file
+        require 'rant/import/filelist/more'
         cx = Rant::RantApp.new.cx
         touch_temp %w(a.t b.t) do
             fl = cx.sys["*.t"]

data/test/test_rant_interface.rb

@@ -74,11 +74,11 @@ class TestRantInterface < Test::Unit::TestCase
         assert_equal out, out2
     end
     def test_no_such_option
-        out, err = assert_rant :fail, "-n"
+        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)
+        assert_match(/\[ERROR\].*option.*\bN\b/, lines.first)
     end
     def test_no_such_long_option
         out, err = assert_rant :fail, "--nix"

data/test/test_rule.rb

@@ -1,13 +1,13 @@
 
-require 'test/unit'
-require 'rant/rantlib'
 require 'tutil'
-require 'fileutils'
+require 'test/unit'
+require 'rant/import/sys/more'
 
 # Ensure we run in testproject directory.
 $testDir ||= File.expand_path(File.dirname(__FILE__))
 
 class TestRule < Test::Unit::TestCase
+    include Rant::TestUtil
     def setup
 	Dir.chdir($testDir) unless Dir.pwd == $testDir
     end
@@ -55,6 +55,124 @@ class TestRule < Test::Unit::TestCase
 	assert_match(/eh\.t created/, out)
 	assert(err !~ /\[WARNING\]|\[ERROR\]/)
     end
+    def test_rule_no_block_error
+        in_local_temp_dir do
+            write_to_file "Rantfile", <<-EOF
+            task :a do
+                puts "a"
+            end
+            gen Rule, :o => :c
+            EOF
+            out, err = assert_rant :fail
+            assert out.empty?
+            lines = err.split(/\n/)
+            assert lines.size < 4
+            assert_match(/\[ERROR\].*Rantfile\b.*\b4\b/, lines.first)
+            assert_match(/Rule\b.*block required\b/, lines[1])
+        end
+    end
+    def test_empty_extension_target
+        in_local_temp_dir do
+            Rant::Sys.write_to_file "root.rant", <<-EOF
+                gen Rule, "" => ".t" do |t|
+                    sys.cp t.source, t.name
+                end
+            EOF
+            Rant::Sys.write_to_file "a.t", "abc\n"
+            out, err = assert_rant :tmax_1, "a"
+            assert err.empty?
+            assert !out.empty?
+            assert_file_content "a", "abc\n"
+            out, err = assert_rant :tmax_1, "a"
+            assert err.empty?
+            assert out.empty?
+        end
+    end
+=begin
+    # TODO: needs change in prerequisite handling of file tasks
+    def test_file_hook_only_file_source
+        in_local_temp_dir do
+            Rant::Sys.write_to_file "Rantfile", <<-EOF
+                gen Rule, :o => :c do |t|
+                    sys.cp t.source, t.name
+                end
+                task "a.c" do |t|
+                    puts t.name
+                end
+                file "b.c" do |t|
+                    sys.write_to_file t.name, "ok\n"
+                end
+                task "d.c" do |t|
+                    puts "task for d.c"
+                end
+                file "d.c" do |t|
+                    sys.write_to_file t.name, "ok 2\n"
+                end
+            EOF
+            out, err = assert_rant :fail, "a.o"
+            assert out.empty?
+            assert_match(/ERROR\b.*\ba\.o/, err)
+            assert !test(?e, "a.o")
+            out, err = assert_rant "b.o"
+            assert err.empty?
+            assert !out.empty?
+            assert_file_content "b.o", "ok\n"
+            out, err = assert_rant "d.o"
+            assert err.empty?
+            lines = out.split(/\n/)
+            assert_equal 1, lines.size
+            assert_match(/writing to file/, lines[0])
+            assert lines[0] =~ /task for/
+            out, err = assert_rant "b.o"
+            assert err.empty?
+            assert out.empty?
+            out, err = assert_rant "d.o"
+            assert err.empty?
+            assert out.empty?
+        end
+    end
+    def test_file_hook_only_file_source_md5
+        in_local_temp_dir do
+            Rant::Sys.write_to_file "Rantfile", <<-EOF
+                gen Rule, :o => :c do |t|
+                    sys.cp t.source, t.name
+                end
+                task "a.c" do |t|
+                    puts t.name
+                end
+                file "b.c" do |t|
+                    sys.write_to_file t.name, "ok\n"
+                end
+                task "d.c" do |t|
+                    puts "task for d.c"
+                end
+                file "d.c" do |t|
+                    sys.write_to_file t.name, "ok 2\n"
+                end
+            EOF
+            out, err = assert_rant :fail, "-imd5", "a.o"
+            assert out.empty?
+            assert_match(/ERROR\b.*\ba\.o/, err)
+            assert !test(?e, "a.o")
+            out, err = assert_rant "-imd5", "b.o"
+            assert err.empty?
+            assert !out.empty?
+            assert_file_content "b.o", "ok\n"
+            out, err = assert_rant "-imd5", "d.o"
+            assert err.empty?
+            lines = out.split(/\n/)
+            assert_equal 1, lines.size
+            assert_match(/writing to file/, lines[0])
+            assert lines[0] =~ /task for/
+            out, err = assert_rant "-imd5", "b.o"
+            assert err.empty?
+            assert out.empty?
+            out, err = assert_rant "-imd5", "d.o"
+            assert err.empty?
+            assert out.empty?
+        end
+    end
+=end
 if Rant::Env.find_bin("cc") && Rant::Env.find_bin("gcc")
     # Note: we are assuming that "cc" invokes "gcc"!
     def test_cc