rant 0.4.2 → 0.4.4

data/test/import/signeddirectory/test_signeddirectory.rb

@@ -0,0 +1,84 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportSignedDirectoryDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestSignedDirectory < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testImportSignedDirectoryDir)
+    end
+    def teardown
+	Dir.chdir($testImportSignedDirectoryDir)
+        assert_rant("autoclean")
+        assert(Dir["*.t"].empty?)
+        assert(!test(?e, ".rant.meta"))
+    end
+    def write(fn, str)
+        open fn, "w" do |f|
+            f.write str
+        end
+    end
+    def test_plain_dir
+        out, err = assert_rant
+        assert(err.empty?)
+        assert(!out.include?("touch"))
+        assert(test(?d, "d1.t"))
+        out, err = assert_rant
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_with_block
+        out, err = assert_rant("d2.t")
+        assert(test(?d, "d2.t"))
+        assert(test(?f, "d2.t/a"))
+        assert(err.empty?)
+        out, err = assert_rant("d2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("d2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_block_and_plain_file_deps
+        write("a.t", "a\n")
+        out, err = assert_rant("d3.t")
+        assert(test(?f, "d3.t/a.t"))
+        assert_equal("a\n", File.read("d3.t/a.t"))
+        assert(err.empty?)
+        out, err = assert_rant("d3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("b.t", "b\n")
+        out, err = assert_rant("d3.t")
+        assert(test(?f, "d3.t/a.t"))
+        assert(test(?f, "d3.t/b.t"))
+        assert_equal("a\n", File.read("d3.t/a.t"))
+        assert_equal("b\n", File.read("d3.t/b.t"))
+        assert(err.empty?)
+        out, err = assert_rant("d3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("b.t", "bb\n")
+        out, err = assert_rant("d3.t")
+        assert(test(?f, "d3.t/a.t"))
+        assert(test(?f, "d3.t/b.t"))
+        assert_equal("a\n", File.read("d3.t/a.t"))
+        assert_equal("bb\n", File.read("d3.t/b.t"))
+        assert(err.empty?)
+        out, err = assert_rant("d3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        FileUtils.rm "a.t"
+        out, err = assert_rant("d3.t")
+        assert(test(?f, "d3.t/b.t"))
+        assert_equal("bb\n", File.read("d3.t/b.t"))
+        assert(err.empty?)
+        out, err = assert_rant("d3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f Dir["{a,b,c}.t"]
+    end
+end

data/test/import/signedfile/Rantfile

@@ -0,0 +1,90 @@
+
+import "signedfile", "autoclean"
+
+var :content => "1\n"
+
+gen SignedFile, "f1.t"
+
+gen SignedFile, "f2.t" do |t|
+    write_content(t.name)
+end
+
+desc "create f3.t"
+gen SignedFile, "f3.t" => "f2.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f4.t" => ["f3.t"] do |t|
+    write_content(t.name)
+end
+
+file "f5.t" => "f2.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f6.t" => "f5.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f7.t" => ["a.t", "f2.t", "b.t"] do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f8.t" => "f1.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f9.t" => "f1.t" do |t|
+    t.fail "need #{t.source}" unless test(?f, t.source)
+    write_content(t.name)
+end
+
+gen SignedFile, "f10.t" do |t|
+    puts "should create f10.t"
+end
+
+gen SignedFile, "f11.t" => ["sub1/s1.t", "f12.t"] do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f12.t" do |t|
+    write_content(t.name)
+end
+
+gen Directory, "d1.t"
+
+gen SignedFile, "d1.t/f13.t" => "d1.t" do |t|
+    write_content(t.name)
+end
+
+var :dn2 => "d2.t"
+gen SignedFile, "#{var :dn2}/f14.t" => var[:dn2] do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f15.t" => "f15.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f16.t" => "f17.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f17.t" => "f16.t" do |t|
+    write_content(t.name)
+end
+
+gen SignedFile, "f18.t" do |t|
+    sys.mkdir t.name
+end
+
+subdirs "sub1"
+
+gen AutoClean
+
+def write_content(fn)
+    puts "writing #{fn}"
+    open fn, "w" do |f|
+        f.write(var[:content])
+    end
+end

data/test/import/signedfile/sub1/Rantfile

@@ -0,0 +1,4 @@
+
+gen SignedFile, "s1.t" => "#f2.t" do |t|
+    write_content(t.name)
+end

data/test/import/signedfile/test_signedfile.rb

@@ -0,0 +1,338 @@
+
+require 'test/unit'
+require 'tutil'
+
+$testImportSignedFileDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestSignedFile < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testImportSignedFileDir)
+    end
+    def teardown
+	Dir.chdir($testImportSignedFileDir)
+        assert_rant("autoclean")
+        assert(Dir["*.t"].empty?)
+        assert(Dir["sub1/*.t"].empty?)
+        assert(!test(?e, ".rant.meta"))
+        assert(!test(?e, "sub1/.rant.meta"))
+    end
+    def write(fn, str)
+        open fn, "w" do |f|
+            f.write str
+        end
+    end
+    def test_no_pre_no_action
+        assert_rant
+        assert(!test(?f, "f1.t"))
+        assert_rant
+        assert(!test(?f, "f1.t"))
+    end
+    def test_no_pre
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert_match(/writing/, out)
+        assert(test(?f, "f2.t"))
+        assert_equal("1\n", File.read("f2.t"))
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("f2.t", "2\n")
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert_match(/writing/, out)
+        assert_equal("1\n", File.read("f2.t"))
+        out, err = assert_rant("f2.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_one_pre
+        out, err = assert_rant("f3.t")
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "f3.t"))
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("f3.t"))
+        assert_match(/writing f2\.t\nwriting f3\.t/, out)
+        assert(err.empty?)
+        FileUtils.rm "f2.t"
+        out, err = assert_rant("f3.t")
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "f3.t"))
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("f3.t"))
+        assert_match(/\Awriting f2\.t\n\Z/, out)
+        assert(!out.include?("f3")) # OK, redundant
+        FileUtils.rm "f2.t"
+        assert_rant("f2.t", "content=2")
+        assert(test(?f, "f2.t"))
+        assert_equal("2", File.read("f2.t"))
+        out, err = assert_rant("f3.t")
+        assert_equal("2", File.read("f2.t"))
+        assert_equal("1\n", File.read("f3.t"))
+        assert(err.empty?)
+        assert_match(/\Awriting f3\.t\n\Z/, out)
+        assert(!out.include?("f2")) # OK, redundant
+        out, err = assert_rant("f3.t")
+        assert(out.empty?)
+    end
+    def test_one_pre_list
+        out, err = assert_rant("f4.t")
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "f3.t"))
+        assert(test(?f, "f4.t"))
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("f3.t"))
+        assert_equal("1\n", File.read("f4.t"))
+        assert(err.empty?)
+        assert_equal("writing f2.t\nwriting f3.t\nwriting f4.t\n", out)
+        out, err = assert_rant("f4.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_rant("autoclean")
+        assert(!test(?e, "f2.t"))
+        assert(!test(?e, "f3.t"))
+        assert(!test(?e, "f4.t"))
+    end
+    def test_opt_tasks
+        out, err = assert_rant("--tasks")
+        assert(err.empty?)
+        lines = out.split(/\n/)
+        assert_equal(2, lines.size)
+        assert_match(/rant\s+#.*f1\.t/, lines[0])
+        assert_match(/rant\s+f3\.t\s+#\s+create f3\.t\b/, lines[1])
+        assert(!test(?e, ".rant.meta"))
+        assert(Dir["*.t"].empty?)
+    end
+    def test_file_mtime_with_signed_dep
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "f5.t"))
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("f5.t"))
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        timeout
+        FileUtils.touch "f2.t"
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert_match(/\Awriting f5\.t\n\Z/, out)
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("f5.t"))
+        out, err = assert_rant("f5.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_with_file_mtime_dep
+        out, err = assert_rant("f6.t")
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "f5.t"))
+        assert(test(?f, "f6.t"))
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("f5.t"))
+        assert_equal("1\n", File.read("f6.t"))
+        out, err = assert_rant("f6.t")
+        assert(err.empty?)
+        assert(out.empty?)
+=begin
+        # could be optimized to work
+        timeout
+        FileUtils.touch "f2.t"
+        out, err = assert_rant("f6.t")
+        assert(err.empty?)
+        lines = out.split(/\n/)
+        p lines
+        assert_equal(1, lines.size)
+        assert_equal("writing f5.t", lines.first)
+=end
+    end
+    def test_file_dep_signed_dep_file_dep
+        out, err = assert_rant(:fail, "f7.t")
+        assert(out.empty?)
+        lines = err.split(/\n/)
+        assert_equal(4, lines.size)
+        assert_match(/\[ERROR\].*Rantfile.*29/, lines[0])
+        assert_match(/no.*a\.t/, lines[1])
+        assert_match(/f7\.t.*fail/, lines[2])
+        write("a.t", "a\n")
+        out, err = assert_rant(:fail, "f7.t")
+        assert_equal("writing f2.t\n", out)
+        lines = err.split(/\n/)
+        assert_equal(4, lines.size)
+        assert_match(/\[ERROR\].*Rantfile.*29/, lines[0])
+        assert_match(/no.*b\.t/, lines[1])
+        assert_match(/f7\.t.*fail/, lines[2])
+        write("b.t", "b\n")
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        lines = out.split(/\n/)
+        assert_equal(1, lines.size)
+        assert_equal("writing f7.t", lines.first)
+        timeout
+        FileUtils.touch "b.t"
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        write("b.t", "c\n")
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        lines = out.split(/\n/)
+        assert_equal(1, lines.size)
+        assert_equal("writing f7.t", lines.first)
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("f7.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_f %w(a.t b.t)
+    end
+    def test_dep_on_no_action
+        out, err = assert_rant("f8.t")
+        assert(err.empty?)
+        assert(test(?f, "f8.t"))
+        assert(!test(?e, "f1.t"))
+        assert_equal("writing f8.t\n", out)
+        assert_equal("1\n", File.read("f8.t"))
+        out, err = assert_rant("f8.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_dep_on_no_action_fail
+        out, err = assert_rant(:fail, "f9.t")
+        assert(out.empty?)
+        assert_match(/need f1\.t/, err)
+        assert_match(/38/, err)
+        out, err = assert_rant(:fail, "f9.t")
+        assert(out.empty?)
+        assert_match(/need f1\.t/, err)
+        assert_match(/38/, err)
+    end
+    def test_action_no_create
+        out, err = assert_rant("f10.t")
+        assert(err.empty?)
+        assert_equal("should create f10.t\n", out)
+        out, err = assert_rant("f10.t")
+        assert(err.empty?)
+        assert_equal("should create f10.t\n", out)
+        out, err = assert_rant("f10.t")
+        assert(err.empty?)
+        assert_equal("should create f10.t\n", out)
+    end
+    def test_sub1_no_task
+        out, err = assert_rant(:fail, "s1.t")
+        assert(out.empty?)
+        assert_match(/ERROR.*s1\.t/, err)
+        assert(!test(?e, ".rant.meta"))
+    end
+    def test_sub1
+        out, err = assert_rant("sub1/s1.t")
+        assert(err.empty?)
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "sub1/s1.t"))
+        out, err = assert_rant("sub1/s1.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("sub1/s1.t"))
+    end
+    def test_rant_import
+        run_import "--auto", "-q", "make.t"
+        assert_exit
+        out = run_ruby("make.t", "sub1/s1.t")
+        assert_exit
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "sub1/s1.t"))
+        out = run_ruby("make.t", "sub1/s1.t")
+        assert(out.empty?)
+        assert_equal("1\n", File.read("f2.t"))
+        assert_equal("1\n", File.read("sub1/s1.t"))
+    ensure
+        FileUtils.rm_f "make.t"
+    end
+    def test_dep_on_mtime_dirnode
+        out, err = assert_rant("d1.t/f13.t")
+        assert(err.empty?)
+        assert(!out.empty?)
+        assert(test(?f, "d1.t/f13.t"))
+        assert_equal("1\n", File.read("d1.t/f13.t"))
+        out, err = assert_rant("d1.t/f13.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_dep_on_dir
+        FileUtils.mkdir "d2.t"
+        FileUtils.mkdir "d3.t"
+        out, err = assert_rant("d2.t/f14.t")
+        assert(err.empty?)
+        assert(!out.empty?)
+        assert(test(?f, "d2.t/f14.t"))
+        assert_equal("1\n", File.read("d2.t/f14.t"))
+        out, err = assert_rant("d2.t/f14.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("d2.t/f14.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("d3.t/f14.t", "dn2=d3.t")
+        assert(err.empty?)
+        assert_equal("writing d3.t/f14.t\n", out)
+        assert(test(?f, "d3.t/f14.t"))
+        assert_equal("1\n", File.read("d3.t/f14.t"))
+        out, err = assert_rant("d3.t/f14.t", "dn2=d3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("d3.t/f14.t", "dn2=d3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    ensure
+        FileUtils.rm_rf %w(d2.t d3.t)
+    end
+    def test_force
+        out, err = assert_rant("f3.t")
+        assert(test(?f, "f2.t"))
+        assert(test(?f, "f3.t"))
+        assert(err.empty?)
+        assert_equal("writing f2.t\nwriting f3.t\n", out)
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+        out, err = assert_rant("-af3.t")
+        assert_equal("writing f2.t\nwriting f3.t\n", out)
+        out, err = assert_rant("f3.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+    def test_dep_on_self
+        out, err = nil, nil
+        th = Thread.new { out, err = assert_rant("f15.t") }
+        assert_equal(th, th.join(0.5))
+        #assert_match(/WARNING/, err)
+        #assert_match(/f15\.t/, err)
+        assert(test(?f, "f15.t"))
+        th = Thread.new { assert_rant("f15.t") }
+        assert_equal(th, th.join(0.5))
+        #assert_match(/WARNING/, err)
+        #assert_match(/f15\.t/, err)
+    end
+    def test_circular_dependency
+        out, err = nil, nil
+        th = Thread.new { out, err = assert_rant("f17.t") }
+        assert_equal(th, th.join(0.5))
+        assert_match(/WARNING/, err)
+        assert_match(/f17\.t/, err)
+        assert(test(?f, "f16.t"))
+        assert(test(?f, "f17.t"))
+    end
+    def test_mkdir
+        out, err = assert_rant("f18.t")
+        assert(err.empty?)
+        assert(!out.empty?)
+        assert(test(?d, "f18.t"))
+        out, err = assert_rant("f18.t")
+        assert(err.empty?)
+        assert(out.empty?)
+    end
+end

data/test/project1/Rantfile

@@ -100,15 +100,6 @@ 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"

data/test/project1/test_project.rb

@@ -176,6 +176,7 @@ class TestProject1 < Test::Unit::TestCase
 	assert(old_mtime < test(?M, "inc"),
 	    "dependency `incdep' is newer, so `inc' should get rebuilt")
     end
+=begin
     def test_lighttask
 	capture_std do
 	    assert_equal(Rant.run("lighttask"), 0)
@@ -183,6 +184,7 @@ class TestProject1 < Test::Unit::TestCase
 	assert(test(?e, "lt_target"),
 	    "lt_target should get `touched' by lighttask")
     end
+=end
     def test_task_gen_one_arg
 	capture_std do
 	    assert_equal(Rant.run("task_one"), 0)

data/test/project_rb1/test_project_rb1.rb

@@ -29,16 +29,33 @@ class TestProjectRb1 < Test::Unit::TestCase
 	}
     end
     def test_doc
-        assert_rant("doc")
-	assert(test(?d, "doc"),
-	    "RDoc task should generate dir `doc'")
-	assert(test(?f, "doc/index.html"),
-	    "doc/index.html should exist after `doc'")
-	fl = Dir["doc/files/**/*"]
-	assert(fl.find { |f| f =~ /wgrep/ },
-	    "lib/wgrep.rb should get documented")
-	assert(fl.find { |f| f =~ /README/ },
-	    "README should be in html docs")
+        have_rdoc = true
+        begin
+            require 'rdoc/rdoc'
+        rescue LoadError
+            have_rdoc = false
+        end
+        if have_rdoc
+            assert_rant("doc")
+            assert(test(?d, "doc"),
+                "RDoc task should generate dir `doc'")
+            assert(test(?f, "doc/index.html"),
+                "doc/index.html should exist after `doc'")
+            fl = Dir["doc/files/**/*"]
+            assert(fl.find { |f| f =~ /wgrep/ },
+                "lib/wgrep.rb should get documented")
+            assert(fl.find { |f| f =~ /README/ },
+                "README should be in html docs")
+        else
+            STDERR.puts "*** rdoc not available ***"
+            out, err = assert_rant(:fail, "doc")
+            lines = err.split(/\n/)
+            lines.reject! { |s| s.strip.empty? }
+            assert_equal(4, lines.size)
+            assert_match(/ERROR.*in file.*line \d+/, lines[0])
+            assert_match(/RDoc not available/, lines[1])
+            assert_match(/doc.*fail/, lines[2])
+        end
     end
     def test_test
         assert_rant("test")

data/test/rant-import/test_rant-import.rb

@@ -169,34 +169,71 @@ class TestRantImport < Test::Unit::TestCase
         FileUtils.mkdir "features.t"
         Dir.chdir "features.t"
         FileUtils.mkpath "rant/import"
-        open "rant/import/foo.rb", "w" do |f|
+        open "rant/import/t_loaded_features_foo.rb", "w" do |f|
             f << <<-EOF
-            def foo
-                puts "foo"
+            def t_loaded_features_foo
+                puts "t_loaded_features_foo"
             end
             EOF
         end
         open "Rantfile", "w" do |f|
             f << <<-EOF
-            import "foo"
-            require 'rant/import/foo'
+            import "t_loaded_features_foo"
+            require 'rant/import/t_loaded_features_foo'
             task :default do
-                foo
+                t_loaded_features_foo
             end
             EOF
         end
         out, err = assert_rant
-        assert_match(/foo/, out)
+        assert_match(/t_loaded_features_foo/, out)
         assert(err.empty?)
         run_import("-q", "--auto", "make.rb")
         assert_exit
         assert(test(?f, "make.rb"))
         out = run_ruby("make.rb")
         assert_exit
-        assert_match(/foo/, out)
+        assert_match(/t_loaded_features_foo/, out)
         FileUtils.rm_rf "rant"
         out = run_ruby("make.rb")
         assert_exit
-        assert_match(/foo/, out)
+        assert_match(/t_loaded_features_foo/, out)
+    end
+    def test_init_import
+        FileUtils.mkdir "init.t"
+        Dir.chdir "init.t"
+        FileUtils.mkpath "rant/import"
+        open "rant/import/t_init_import_foo.rb", "w" do |f|
+            f << <<-EOF
+            module Rant
+                def self.init_import_t_init_import_foo(rac, *rest)
+                    puts "init import t_init_import_foo"
+                    rac.cx.var["t_init_import_foo"] = "t_init_import_foo init"
+                end
+            end
+            EOF
+        end
+        open "Rantfile", "w" do |f|
+            f << <<-EOF
+            import "t_init_import_foo"
+            task :a do |t|
+                puts var[:t_init_import_foo]
+            end
+            import "t_init_import_foo"
+            EOF
+        end
+        out, err = assert_rant
+        assert_match(/\Ainit import t_init_import_foo\nt_init_import_foo init\n\n?\Z/m, out)
+        assert(err.empty?)
+        run_import("-q", "--auto", "make.rb")
+        assert_exit
+        assert(test(?f, "make.rb"))
+        out = run_ruby("make.rb")
+        assert_exit
+        assert_match(/\Ainit import t_init_import_foo\nt_init_import_foo init\n\n?\Z/m, out)
+        FileUtils.rm_rf "rant"
+        out = run_ruby("make.rb")
+        assert_exit
+        assert_match(/\Ainit import t_init_import_foo\nt_init_import_foo init\n\n?\Z/m, out)
     end
 end

data/test/subdirs/sub2/sub/rantfile

@@ -15,11 +15,6 @@ gen Task, "gt" => "dt" do |t|
     t.act { sys.touch t.name }
 end
 
-gen LightTask, "lt" do |lt|
-    lt.needed { !test(?f, lt.name) }
-    lt.act { sys.touch lt.name }
-end
-
 task :create_param do
     sys.touch var[:param]
 end