rant 0.3.6 → 0.3.8

data/rantmethods.rb

@@ -14,7 +14,7 @@ end
 
 desc "Print constants introduced by Rant."
 task :constants do
-    puts ((self.class.constants - Object.constants).sort)
+    puts((self.class.constants - Object.constants).sort)
 end
 
 desc "Print all attribute writers of a Gem::Specification."
@@ -82,49 +82,3 @@ file "bench-depsearch" do |t|
 	EOT
     }
 end
-
-=begin
-class TraceObject < Object
-    ml = public_instance_methods + protected_instance_methods + private_instance_methods
-    ml.each { |m|
-	eval <<-EOM
-	    def #{m}(*args)
-		print "TraceObject##{m}("
-		print args.join(", ")
-		print ")"
-		puts(block_given? ? " block_given" : "")
-		super
-	    end
-	EOM
-    }
-end
-=end
-
-class TraceArray < Array
-    ml = public_instance_methods + protected_instance_methods + private_instance_methods
-    ml.delete "print"
-    ml.delete "block_given?"
-    ml.delete "puts"
-    ml.each { |m|
-	eval <<-EOM
-	    def #{m}(*args)
-		print "TraceArray##{m}("
-		print args.join(", ")
-		print ")"
-		puts(block_given? ? " block_given" : "")
-		super
-	    end
-	EOM
-    }
-end
-
-# list the methods that are sent to an object that is in an array
-# which is flattened.
-#task :flatten do
-    #    to = TraceObject.new
-    #[to].flatten
-    #end
-
-task :flatten_ary do
-    [TraceArray.new].flatten
-end

data/setup.rb

@@ -1143,11 +1143,11 @@ class Installer
     begin
       File.open(path, 'rb') {|r|
         first = r.gets
-        return unless File.basename(config('rubypath')) == 'ruby'
+        return unless File.basename(config('rubypath')) =~ /ruby/
 	### stefan ###
 	# Add <tt>|| ""</tt> which avoids an ArgumentError if first
 	# line doesn't match the regexp.
-        return unless File.basename(first.sub(/\A\#!/, '').split[0] || "") == 'ruby'
+        return unless File.basename((first||"").sub(/\A\#!/, '').split[0] || "") == 'ruby'
         $stderr.puts "adjusting shebang: #{File.basename(path)}" if verbose?
         File.open(tmpfile, 'wb') {|w|
           w.print first.sub(/\A\#!\s*\S+/, '#! ' + config('rubypath'))

data/test/Rantfile

@@ -23,10 +23,12 @@ gen Action do
     rac.build "version.t"
 end
 
-source "auto.rf"
+auto_t_task = source "auto.rf"
+rac.abort unless auto_t_task.name == "auto.t"
 
 task :clean do
     sys.rm_f %w(auto.t auto.rf version.t)
+    sys.rm_rf %w(basedir.t)
 end
 
 gen Directory, "tmp.t"
@@ -49,4 +51,7 @@ task :build_test_t do |t|
     test(?d, "tmp.t") or t.fail
 end
 
+desc "Make some path (basedir.t/a/b)."
+gen Directory, "basedir.t", "a/b"
+
 # vim: ft=ruby

data/test/c/source.c

@@ -0,0 +1,23 @@
+
+#include <stdio.h>
+#include "util.h"
+
+/*
+ * some comment
+ */
+#include "mylib.h"
+
+/*
+#include "xy"
+*/
+
+//
+	#  include <file.h>
+#include   "custom" // custom header
+
+# // include "abc"
+
+#include \
+    "custom2.h"
+
+#include <std>

data/test/c/test_parse_includes.rb

@@ -0,0 +1,41 @@
+
+require 'tutil'
+require 'rant/c/include'
+
+$testCDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestCParseIncludes < Test::Unit::TestCase
+    C = Rant::C
+    def setup
+	Dir.chdir($testCDir)
+    end
+    def test_parse_source
+	src = File.read "source.c"
+	sc, lc = C::Include.parse_includes(src)
+	assert_equal(%w(stdio.h file.h std), sc)
+	assert_equal(
+	    %w(util.h mylib.h custom custom2.h), lc)
+    end
+    def test_parse_empty
+	sc, lc = C::Include.parse_includes("")
+	assert(sc.empty?)
+	assert(lc.empty?)
+    end
+    def test_parse_nil
+	assert_raises(ArgumentError) {
+	    C::Include.parse_includes(nil)
+	}
+    end
+    def test_accepts_to_str
+	obj = Object.new
+	def obj.to_str
+	    "//"
+	end
+	lc, sc = nil, nil
+	assert_nothing_raised {
+	    sc, lc = C::Include.parse_includes(obj)
+	}
+	assert(sc.empty?)
+	assert(lc.empty?)
+    end
+end

data/test/import/c/dependencies/Rantfile

@@ -0,0 +1,34 @@
+
+import "c/dependencies", "autoclean"
+
+var :deps, 1..3
+
+file "a.t" => sys["**/*.{c,cpp}"] do |t|
+    sys.touch t.name
+end
+
+file "hello.t" => "hello.c" do |t|
+    sys.touch t.name
+end
+
+file "bar.t" => "src/bar.c" do |t|
+    sys.touch t.name
+end
+
+desc "Create C source dependency file."
+gen C::Dependencies
+
+gen C::Dependencies, "deps2.t", :search => [".", "include"]
+gen C::Dependencies, "deps3.t", :search => [".", "include", "src"]
+
+gen Action do
+    source case var[:deps]
+    when 2: "deps2.t"
+    when 3: "deps3.t"
+    else    "c_dependencies"
+    end
+end
+
+gen AutoClean
+
+# vim:ft=ruby

data/test/import/c/dependencies/bar.h

@@ -0,0 +1,2 @@
+
+#include "foo.h"

data/test/import/c/dependencies/foo.h

@@ -0,0 +1,5 @@
+
+#ifndef FOO_H
+#define FOO_H
+
+#endif

data/test/import/c/dependencies/hello.c

@@ -0,0 +1,7 @@
+#include "foo.h"
+#include <stdio.h>
+
+int main()
+{
+    printf("Hello, world!");
+}

data/test/import/c/dependencies/include/sub/sub.h

@@ -0,0 +1,8 @@
+#ifndef SUB_SUB_H
+#define SUB_SUB_H
+
+#include "bar.h"
+
+#define SUB_STR "substr"
+
+#endif

data/test/import/c/dependencies/include/with space.h

@@ -0,0 +1,7 @@
+
+#ifndef WITH_SPACE_H
+#define WITH_SPACE_H
+
+#include "foo.h"
+
+#endif

data/test/import/c/dependencies/src/abc

@@ -0,0 +1,5 @@
+
+float abc(float param)
+{
+    return param;
+}

data/test/import/c/dependencies/src/abc.c

@@ -0,0 +1,5 @@
+
+int abc(int param)
+{
+    return param;
+}

data/test/import/c/dependencies/src/bar.c

@@ -0,0 +1,11 @@
+
+#include <abc.c>
+#include "abc"
+#include "with space.h"
+
+void greet()
+{
+    abc(0);
+    abc(0.0);
+    printf("greetings from bar\n");
+}

data/test/import/c/dependencies/test_c_dependencies.rb

@@ -0,0 +1,92 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportCDepDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestImportCDependencies < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir $testImportCDepDir
+	@manifest = %w(
+	    test_c_dependencies.rb Rantfile hello.c foo.h bar.h
+	    include include/foo.h include/sub include/sub/sub.h
+	    src src/abc src/abc.c src/bar.c
+	)
+	@manifest << "include/with space.h"
+    end
+    def teardown
+	Dir.chdir $testImportCDepDir
+	FileUtils.rm_f "c_dependencies"
+	FileUtils.rm_rf Dir["*.t"]
+	@manifest.each { |f|
+	    assert(test(?e, f), "#{f} missing")
+	}
+    end
+    def test_hello_c
+	assert_rant("hello.t")
+	assert(test(?f, "hello.t"))
+	assert(test(?f, "c_dependencies"))
+	out, err = assert_rant("hello.t")
+	assert(out.strip.empty?)
+	assert(err.strip.empty?)
+	timeout
+	FileUtils.touch "foo.h"
+	old_mtime = File.mtime "hello.t"
+	assert_rant("hello.t")
+	assert(File.mtime("hello.t") > old_mtime)
+	old_mtime = File.mtime("hello.t")
+	timeout
+	out, err = assert_rant("hello.t")
+	assert(out.strip.empty?)
+	assert(err.strip.empty?)
+	FileUtils.rm "c_dependencies"
+	out, err = assert_rant("hello.t")
+	assert(!out.strip.empty?)
+	assert(err.strip.empty?)
+	assert_equal(old_mtime, File.mtime("hello.t"))
+    end
+    def test_bar_c
+	assert_rant("deps=2", "bar.t")
+	assert(test(?f, "bar.t"))
+	assert(test(?f, "deps2.t"))
+	cdeps_mtime = File.mtime "deps2.t"
+	FileUtils.rm "bar.t"
+	assert_rant("deps=2", "bar.t")
+	assert(test(?f, "bar.t"))
+	assert_equal(cdeps_mtime, File.mtime("deps2.t"))
+	old_mtime = File.mtime "bar.t"
+	timeout
+	FileUtils.touch "src/abc.c"
+	assert_rant("deps=2", "bar.t")
+	assert_equal(old_mtime, File.mtime("bar.t"))
+	timeout
+	FileUtils.touch "include/with space.h"
+	assert_rant("deps=2", "bar.t")
+	assert(File.mtime("bar.t") > old_mtime)
+    end
+    def test_bar_c_deps3
+	assert_rant("deps=3", "bar.t")
+	assert(test(?f, "bar.t"))
+	assert(test(?f, "deps3.t"))
+	old_mtime = File.mtime("bar.t")
+	timeout
+	FileUtils.touch "src/abc"
+	assert_rant("deps=3", "bar.t")
+	assert(File.mtime("bar.t") > old_mtime)
+	old_mtime = File.mtime "bar.t"
+	timeout
+	FileUtils.touch "src/abc.c"
+	assert_rant("deps=3", "bar.t")
+	assert(File.mtime("bar.t") > old_mtime)
+	old_mtime = File.mtime "bar.t"
+	timeout
+	FileUtils.touch "foo.h"
+	assert_rant("deps=3", "bar.t")
+	assert(File.mtime("bar.t") > old_mtime)
+	assert_rant("autoclean")
+	%w(a.t hello.t bar.t c_dependencies deps2.t deps3.t).each { |f|
+	    assert(!test(?e, f), "#{f} should get unlinked by AutoClean")
+	}
+    end
+end

data/test/import/c/dependencies/test_on_the_fly.rb

@@ -0,0 +1,44 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportCDepDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestImportCDependenciesOnTheFly < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir $testImportCDepDir
+    end
+    def teardown
+	Dir.chdir $testImportCDepDir
+	FileUtils.rm_f "c_dependencies"
+	FileUtils.rm_rf Dir["*.t"]
+    end
+    def test_opts_without_filename
+	open "rf.t", "w" do |f|
+	    f << <<-EOF
+	    file "bar.t" => "src/bar.c" do |t|
+		sys.touch t.name
+	    end
+	    gen C::Dependencies,
+		:sources => sys["src/*.c"],
+		:search => "include"
+	    source "c_dependencies"
+	    EOF
+	end
+	assert_rant("-frf.t")
+	assert(test(?f, "bar.t"))
+	out, err = assert_rant("-frf.t")
+	assert(out.strip.empty?)
+	assert(err.strip.empty?)
+	old_mtime = File.mtime "bar.t"
+	timeout
+	FileUtils.touch "src/abc"
+	assert_rant("-frf.t")
+	assert_equal(old_mtime, File.mtime("bar.t"))
+	timeout
+	FileUtils.touch "include/with space.h"
+	assert_rant("-frf.t")
+	assert(File.mtime("bar.t") > old_mtime)
+    end
+end

data/test/import/directedrule/Rantfile

@@ -1,9 +1,9 @@
 
 import %w(directedrule autoclean)
 
-task :mk_src => %w(src.t/1.b src.t/2.b src.t/3.b)
+task :mk_src => %w(src.t/1.b src.t/2.b src.t/3.b src.t/1.2b)
 gen Directory, "src.t"
-%w(src.t/1.b src.t/2.b src.t/3.b).each { |f|
+%w(src.t/1.b src.t/2.b src.t/3.b src.t/1.2b).each { |f|
     file f => "src.t" do |t| sys.touch t.name end
 }
 
@@ -13,11 +13,16 @@ file "foo.t" => %w(build.t/1.a build.t/2.a) do |t|
 end
 
 gen Directory, "build.t"
+gen Directory, "build2.t"
 
 gen Action do
     rac.build "build.t"
 end
 
+gen DirectedRule, "build2.t" => ["src.t"], '.2a' => '.2b' do |t|
+    sys.touch t.name
+end
+
 ro_tt = gen DirectedRule, "build.t" => ["src.t"], :a => :b do |t|
     sys.touch t.name
 end

data/test/import/directedrule/test_directedrule.rb

@@ -28,4 +28,10 @@ class TestDirectedRule < Test::Unit::TestCase
 	assert_rant("foo.t")
 	assert(test(?f, "foo.t"))
     end
+    def test_build_invoke_dir_task
+	assert_rant
+	assert_rant("build2.t/1.2a")
+	assert(test(?d, "build2.t"))
+	assert(test(?f, "build2.t/1.2a"))
+    end
 end

data/test/import/subfile/Rantfile

@@ -0,0 +1,28 @@
+import "subfile"
+
+gen SubFile, "sub.t/file" do |t|
+    sys.touch t.name
+end
+
+desc "some subfile"
+gen SubFile, "sub2.t/file"
+
+gen SubFile, "sub3.t", "file" do |t|
+    sys.touch t.name
+end
+
+gen SubFile, "sub.t/file2" do |t|
+    sys.touch t.name
+end
+
+gen SubFile, "sub4.t/sub/file" do |t|
+    sys.touch t.name
+end
+
+gen SubFile, "sub5.t", "sub/sub/file" do |t|
+    sys.touch t.name
+end
+
+gen SubFile, "file.t" do |t|
+    sys.touch t.name
+end

data/test/import/subfile/autoclean.rf

@@ -0,0 +1,16 @@
+
+import %w(autoclean subfile)
+
+gen AutoClean
+
+gen SubFile, "sub.t/file" do |t|
+    sys.touch t.name
+end
+
+gen SubFile, "sub2.t", "sub.t/file" do |t|
+    sys.touch t.name
+end
+
+gen SubFile, "sub3.t", "file" do |t|
+    sys.touch t.name
+end

data/test/import/subfile/test_subfile.rb

@@ -0,0 +1,91 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportSubFileDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestSubFile < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testImportSubFileDir)
+    end
+    def teardown
+	FileUtils.rm_rf Dir["*.t"]
+    end
+    def test_run_cmd
+	assert_rant("sub.t/file")
+	assert(test(?d, "sub.t"))
+	assert(test(?f, "sub.t/file"))
+    end
+    def test_desc
+	out, err = assert_rant("--tasks")
+	assert_match(%r{sub2\.t/file\s*#.*some subfile}, out)
+    end
+    def test_no_block
+	assert_rant("sub2.t/file")
+	assert(test(?d, "sub2.t"))
+	assert(!test(?e, "sub2.t/file"))
+    end
+    def test_fail_no_basedir
+	assert_rant(:fail, "sub3.t/file")
+	assert(!test(?e, "sub3.t"))
+	assert(!test(?e, "sub3.t/file"))
+    end
+    def test_basedir
+	FileUtils.mkdir "sub3.t"
+	assert_rant("sub3.t/file")
+	assert(test(?d, "sub3.t"))
+	assert(test(?f, "sub3.t/file"))
+    end
+    def test_dirtask_exists
+	assert_rant("sub.t/file2")
+	assert(test(?d, "sub.t"))
+	assert(test(?f, "sub.t/file2"))
+	assert(!test(?e, "sub.t/file"))
+    end
+    def test_make_two
+	assert_rant("sub.t/file", "sub.t/file2")
+	assert(test(?f, "sub.t/file"))
+	assert(test(?f, "sub.t/file2"))
+    end
+    def test_two_dirs
+	assert_rant("sub4.t/sub/file")
+	assert(test(?f, "sub4.t/sub/file"))
+    end
+    def test_basedir_two_dirs
+	FileUtils.mkdir "sub5.t"
+	out, err = assert_rant("sub5.t/sub/sub/file")
+	assert(!out.strip.empty?)
+	assert(test(?f, "sub5.t/sub/sub/file"))
+	out, err = assert_rant("sub5.t/sub/sub/file")
+	assert(out.strip.empty?)
+    end
+    def test_make_dir
+	assert_rant("sub.t")
+	assert(test(?d, "sub.t"))
+	assert(!test(?e, "sub.t/file"))
+    end
+    def test_only_file
+	assert_rant("file.t")
+	assert(test(?f, "file.t"))
+	out, err = assert_rant("file.t")
+	assert(out.strip.empty?)
+    end
+    def test_autoclean
+	assert_rant("-fautoclean.rf", "sub.t/file")
+	assert(test(?f, "sub.t/file"))
+	FileUtils.mkdir "sub2.t"
+	assert_rant("-fautoclean.rf", "sub2.t/sub.t/file")
+	assert(test(?f, "sub2.t/sub.t/file"))
+	FileUtils.mkdir "sub3.t"
+	assert_rant("-fautoclean.rf", "sub3.t/file")
+	assert(test(?f, "sub3.t/file"))
+	assert_rant("-fautoclean.rf", "autoclean")
+	assert(test(?d, "sub2.t"))
+	assert(test(?d, "sub3.t"))
+	%w(sub.t sub2.t/sub.t sub3.t/file).each { |f|
+	    assert(!test(?e, f),
+		"#{f} should have been unlinked by AutoClean")
+	}
+    end
+end

data/test/import/truth/Rantfile

@@ -11,6 +11,13 @@ file("rm.t") { |t|
 "touch rm.t" %
 "this file is useless"
 
+task :sys_pipe do |t|
+    sys.touch %w(a.t b.t)
+    test(?f, "a.t") && test(?f, "b.t") or t.fail
+    sys["*.t"] % :rm
+    test(?f, "a.t") || test(?f, "b.t") and t.fail
+end
+
 drag :AutoClean, :clean
 
 # vim:ft=ruby

data/test/import/truth/test_truth.rb

@@ -20,4 +20,7 @@ class TestTruth < Test::Unit::TestCase
 	assert_rant("clean")
 	assert(!test(?e, "rm.t"))
     end
+    def test_pipe
+	assert_rant("sys_pipe")
+    end
 end

data/test/project2/buildfile

@@ -12,3 +12,5 @@ task :clean do |t|
 end
 
 subdirs %w(sub1 sub2)
+
+:return_val

data/test/project2/test_project.rb

@@ -15,7 +15,9 @@ class TestProject2 < Test::Unit::TestCase
     include ::Rant::Sys
 
     def app *args
-	@app = ::Rant::RantApp.new(*args)
+	@app = ::Rant::RantApp.new
+	@app.args.concat(args.flatten)
+	@app
     end
     def setup
 	Dir.chdir($testProject2Dir) unless Dir.pwd == $testProject2Dir
@@ -51,8 +53,8 @@ class TestProject2 < Test::Unit::TestCase
 	capture_std do
 	    app("b_f2")
 	    @app.rootdir = $testProject2Dir
-	    assert(@app.source("buildfile"),
-		"source should return a true value on success")
+	    assert_equal(:return_val, @app.source("buildfile"),
+		"source should return value of last expression in Rantfile")
 	    assert_equal(@app.run, 0)
 	end
 	assert(File.exist?("b_f2"))

data/test/rant-import/Rantfile

@@ -12,4 +12,8 @@ task :private do |t|
     puts t.name
 end
 
+task :sys_shun_demo do |t|
+    puts(sys["**/*.s.t"].shun("a.t"))
+end
+
 # vim: ft=ruby