rant 0.4.0 → 0.4.2

data/lib/rant/rantsys.rb

@@ -51,7 +51,7 @@ module Rant
 	public
 	### Methods having an equivalent in the Array class. #########
 
-	def each &block
+	def each(&block)
 	    resolve if @pending
 	    @files.each(&block)
 	end
@@ -217,17 +217,31 @@ module Rant
 	end
 	private :mk_all_rx
 
-	def select &block
+	def select(&block)
 	    d = dup
-	    d.actions << [:apply_select, block]
+            d.actions << [:apply_select, block]
+            d.pending = true
 	    d
 	end
+        alias find_all select
 
 	def apply_select blk
 	    @files = @files.select(&blk)
 	end
 	private :apply_select
 
+        def map(&block)
+            d = dup
+            d.actions << [:apply_ary_method, :map!, block]
+            d.pending = true
+            d
+        end
+        alias collect map
+
+        def sub_ext(ext, new_ext=nil)
+            map { |f| f.sub_ext ext, new_ext }
+        end
+
 	# Remove all entries which contain a directory with the
 	# given name.
 	# If no argument or +nil+ given, remove all directories.
@@ -268,18 +282,12 @@ module Rant
 
 	# Remove all files which have the given name.
 	def no_file(name)
-	    @actions << [:apply_no_file, name]
+            @actions << [:apply_ary_method, :reject!,
+                lambda { |entry| entry == name and test(?f, entry) }]
 	    @pending = true
 	    self
 	end
 
-	def apply_no_file(name)
-	    @files.reject! { |entry|
-		entry == name and test(?f, entry)
-	    }
-	end
-	private :apply_no_file
-
 	# Remove all entries which contain an element
 	# with the given suffix.
 	def no_suffix(suffix)
@@ -330,6 +338,7 @@ module Rant
 	def arglist
 	    to_ary.arglist
 	end
+        alias to_s arglist
 
         # Same as #uniq! but evaluation is delayed until the next read
         # access (e.g. by calling #each). Always returns self.
@@ -347,12 +356,18 @@ module Rant
             self
         end
 
+        def lazy_map!(&block)
+            @actions << [:apply_ary_method, :map!, block]
+            @pending = true
+            self
+        end
+
         private
-        def apply_ary_method(meth)
-            @files.send meth
+        def apply_ary_method(meth, block=nil)
+            @files.send meth, &block
         end
-        def apply_ary_method_1(meth, arg1)
-            @files.send meth, arg1
+        def apply_ary_method_1(meth, arg1, block=nil)
+            @files.send meth, arg1, &block
         end
     end	# class FileList
 
@@ -395,7 +410,7 @@ module Rant
 	    Dir.chdir(@basedir) { filelist_resolve }
 	end
 
-	def each &block
+	def each(&block)
 	    old_pwd = Dir.pwd
 	    resolve if @pending
 	    Dir.chdir(@basedir)
@@ -427,7 +442,7 @@ module Rant
 	    @lists = [@cur_list]
 	end
 
-	def each_entry &block
+	def each_entry(&block)
 	    @lists.each { |list|
 		list.each(&block)
 	    }

data/lib/rant/rantvar.rb

@@ -16,7 +16,7 @@
 # If you're looking for general info about Rant, read the
 # README[link:files/README.html].
 module Rant
-    VERSION	= '0.4.0'
+    VERSION	= '0.4.2'
 
     # Those are the filenames for rantfiles.
     # Case matters!
@@ -259,7 +259,7 @@ module Rant
 
 	    # Use ENV instead of internal store for given vars.
 	    # Probably useful for vars like CC, CFLAGS, etc.
-	    def env *vars
+	    def env(*vars)
 		vars.flatten.each { |var|
 		    vid = RantVar.valid_vid(var)
 		    cur_val = @store[vid]
@@ -360,19 +360,6 @@ module Rant
 		end
 	    end
 
-	    class ::Range
-		def rant_constraint
-		    case first
-		    when ::Integer
-			IntegerInRange.new(self)
-		    when ::Float
-			FloatInRange.new(self)
-		    else
-			raise NotAConstraintFactoryError.new(self)
-		    end
-		end
-	    end
-
 	    class Integer
 		include Constraint
 
@@ -599,3 +586,16 @@ module Rant
 	module_function :valid_constraint?, :valid_vid
     end	# module RantVar
 end	# module Rant
+
+class Range
+    def rant_constraint
+        case first
+        when ::Integer
+            Rant::RantVar::Constraints::IntegerInRange.new(self)
+        when ::Float
+            Rant::RantVar::Constraints::FloatInRange.new(self)
+        else
+            raise NotAConstraintFactoryError.new(self)
+        end
+    end
+end

data/lib/rant/tempfile.rb

@@ -0,0 +1,12 @@
+
+# tempfile.rb
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+require 'tempfile'
+if Tempfile.superclass == SimpleDelegator
+    require 'rant/archive/rubyzip/tempfile_bugfixed'
+    Rant::Tempfile = Rant::BugFix::Tempfile
+else
+    Rant::Tempfile = Tempfile
+end

data/test/Rantfile

@@ -54,4 +54,37 @@ end
 desc "Make some path (basedir.t/a/b)."
 gen Directory, "basedir.t", "a/b"
 
+gen Action do
+    if var[:make_path]
+        make Directory, "basedir.t"
+        make "basedir.t/a/b"
+    end
+end
+
+task :make_file do |t|
+    make "make_file.t" do |t|
+        sys.touch t.name
+    end
+end
+
+file "make_files_dep.t" do |t|
+    sys.touch t.name
+end
+
+gen Action do
+    if var[:make_files]
+        make "make_files.t" => "make_files_dep.t" do |t|
+            sys.touch t.name
+        end
+    end
+    if var[:make_gen_with_block]
+        import "subfile"
+        make SubFile, "a.t/a.t" do |t|
+            sys.touch t.name
+        end
+    end
+end
+
+task :dep_on_make_files => ["make_files.t"]
+
 # vim: ft=ruby

data/test/import/directedrule/test_directedrule.rb

@@ -34,4 +34,33 @@ class TestDirectedRule < Test::Unit::TestCase
 	assert(test(?d, "build2.t"))
 	assert(test(?f, "build2.t/1.2a"))
     end
+=begin
+    # This would currently be to complex to implement cleanly.
+    def test_invoke_rule_in_subdir
+        FileUtils.mkdir "sub.t"
+        Dir.chdir "sub.t"
+        FileUtils.mkdir "sub.t"
+        open "Rantfile", "w" do |f|
+            f << <<-EOF
+            import "directedrule", "autoclean"
+            gen Directory, "build.t"
+            gen DirectedRule, "build.t" => ["src.t"], :a => :b do |t|
+                sys.touch t.name
+            end
+            gen AutoClean
+            subdirs "sub.t"
+            EOF
+        end
+        open "sub.t/Rantfile", "w" do |f|
+            f << <<-EOF
+            task :a => "build.t/file.a"
+            EOF
+        end
+        assert_rant(:v, "sub.t/a")
+        assert(test(?f, "sub.t/build.t/file.a"))
+    ensure
+        Dir.chdir $testImportDrDir
+        FileUtils.rm_rf "sub.t"
+    end
+=end
 end

data/test/import/package/Rantfile

@@ -46,4 +46,6 @@ gen Archive::Zip, "t7", :files => %w(sub7.t)
 gen Archive::Tgz, "sym", :files => sys["subs.t/**/*"]
 gen Archive::Zip, "sym", :files => sys["subs.t/**/*"]
 
+gen Package::Tgz, "pkg.t/double", :files => %w(./Rantfile Rantfile)
+
 gen AutoClean

data/test/import/package/test_package.rb

@@ -274,6 +274,16 @@ class TestImportPackage < Test::Unit::TestCase
     ensure
         FileUtils.rm_rf %w(subs.t sub6.t)
     end
+    def test_tgz_package_double
+        assert_rant("pkg.t/double.tgz")
+        out, err = assert_rant("pkg.t/double.tgz")
+        assert(out.empty?)
+        assert(err.empty?)
+        mf = %w(Rantfile)
+        dirs = %w()
+        @pkg_dir = "double"
+        check_contents(:tgz, "pkg.t/double.tgz", mf, dirs)
+    end
     def test_zip_follow_symlink
         have_symlinks = true
         FileUtils.mkdir "subs.t"

data/test/import/subfile/test_subfile.rb

@@ -100,4 +100,25 @@ class TestSubFile < Test::Unit::TestCase
 		"#{f} should have been unlinked by AutoClean")
 	}
     end
+    def test_with_slash
+        open "with_slash.t", "w" do |f|
+            f << <<-EOF
+            import "subfile", "autoclean"
+            gen SubFile, "base.t/", "a" do |t|
+                sys.touch t.name
+            end
+            gen AutoClean
+            EOF
+        end
+        assert_rant(:fail, "-fwith_slash.t")
+        FileUtils.mkdir "base.t"
+        assert_rant("-fwith_slash.t")
+        assert(test(?f, "base.t/a"))
+        out, err = assert_rant("-fwith_slash.t")
+        assert(out.empty?)
+        assert(err.empty?)
+        assert_rant("-fwith_slash.t", "autoclean")
+        assert(test(?d, "base.t"))
+        assert(!test(?e, "base.t/a"))
+    end
 end

data/test/project1/test_project.rb

@@ -8,63 +8,43 @@ $testProject1Dir = File.expand_path(File.dirname(__FILE__))
 
 class TestProject1 < Test::Unit::TestCase
     def setup
-	Dir.chdir($testProject1Dir) unless Dir.pwd == $testProject1Dir
-	Rant.reset
+	Dir.chdir($testProject1Dir)
     end
     def teardown
-	capture_std do
-	    assert_equal(Rant.run("force_clean"), 0)
-	end
+        assert_rant("force_clean")
     end
     def test_run
-	out, err = capture_std do
-	    assert_equal(Rant.run("test_touch"), 0,
-		"Exit code of rant should be 0.")
-	end
+	out, err = assert_rant("test_touch")
+            #"Exit code of rant should be 0.")
 	assert(err =~ /\[WARNING\]/,
 	    "rant should print a warning because of enhance on non-existing task")
-	Rant.reset
 	assert(File.exist?("test_touch"),
 	    "file test_touch should have been created")
-	capture_std do
-	    assert_equal(Rant.run("clean"), 0)
-	end
+        assert_rant("clean")
 	assert(!File.exist?("test_touch"))
     end
     def test_timedep
-	capture_std do
-	    assert_equal(Rant.run("create_target"), 0)
-	end
+        assert_rant("create_target")
 	assert(File.exist?("target"))
-	Rant.reset
 	timeout
-	capture_std do
-	    assert_equal(Rant.run("create_dep"), 0)
-	end
+        assert_rant("create_dep")
 	assert(File.exist?("dep"))
 	assert(Rant::Sys.uptodate?("dep", "target"),
 	    "`create_target' was run before `create_dep'")
 	timeout
-	capture_std do
-	    assert_equal(Rant.run("target"), 0)
-	end
+        assert_rant("target")
 	assert(File.exist?("target"))
 	assert(File.exist?("dep"))
 	assert(Rant::Sys.uptodate?("target", "dep"),
 	    "`target' should be newer than `dep'")
 	t1 = File.mtime "target"
-	Rant.reset
 	timeout
-	capture_std do
-	    assert_equal(Rant.run("target"), 0)
-	end
+        assert_rant("target")
 	assert_equal(t1, File.mtime("target"),
 	    "`target' was already up to date")
     end
     def test_two_deps
-	capture_std do
-	    assert_equal(Rant.run("t2"), 0)
-	end
+        assert_rant("t2")
 	assert(File.exist?("t2"),
 	    "file `t2' should have been built")
 	assert(File.exist?("dep1"),

data/test/project2/test_project.rb

@@ -14,7 +14,7 @@ class TestProject2 < Test::Unit::TestCase
     include Rant
     include ::Rant::Sys
 
-    def app *args
+    def app(*args)
 	@app = ::Rant::RantApp.new
 	@app.args.concat(args.flatten)
 	@app

data/test/project_rb1/test_project_rb1.rb

@@ -19,7 +19,8 @@ class TestProjectRb1 < Test::Unit::TestCase
     end
     def check_manifest(msg_prefix = "")
 	manifest = @manifest.dup
-	Dir["**/*"].each { |e|
+        #Dir["**/*"].each { |e|
+        Rant::FileList["**/*"].shun(".svn").each { |e|
 	    assert(manifest.reject! { |mf| mf == e } ,
 		"#{msg_prefix}#{e} shouldn't exist according to manifest")
 	}

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

@@ -9,7 +9,7 @@ $testRantImportDir ||= File.expand_path(File.dirname(__FILE__))
 class TestRantImport < Test::Unit::TestCase
     def setup
 	# Ensure we run in test directory.
-	Dir.chdir($testRantImportDir) unless Dir.pwd == $testRantImportDir
+	Dir.chdir($testRantImportDir)
     end
     def teardown
 	Dir.chdir($testRantImportDir)
@@ -165,4 +165,38 @@ class TestRantImport < Test::Unit::TestCase
 	assert_equal(1, files.size)
 	assert(files.include?("b.t/b.s.t"))
     end
+    def test_loaded_features
+        FileUtils.mkdir "features.t"
+        Dir.chdir "features.t"
+        FileUtils.mkpath "rant/import"
+        open "rant/import/foo.rb", "w" do |f|
+            f << <<-EOF
+            def foo
+                puts "foo"
+            end
+            EOF
+        end
+        open "Rantfile", "w" do |f|
+            f << <<-EOF
+            import "foo"
+            require 'rant/import/foo'
+            task :default do
+                foo
+            end
+            EOF
+        end
+        out, err = assert_rant
+        assert_match(/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)
+        FileUtils.rm_rf "rant"
+        out = run_ruby("make.rb")
+        assert_exit
+        assert_match(/foo/, out)
+    end
 end

data/test/subdirs/test_subdirs.rb

@@ -9,13 +9,12 @@ $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(0, Rant.run("clean"))
 	end
-	created = Dir["**/*t"]
+	created = Rant::FileList["**/*t"].shun(".svn")#Dir["**/*t"]
 	assert(created.empty?)
     end
     def test_load

data/test/test_dirtask.rb

@@ -74,4 +74,46 @@ class TestDirTask < Test::Unit::TestCase
 	assert_match(%r{basedir.t/a/b\s*#.*Make some path}, out)
 	assert_rant("clean")
     end
+    def test_basedir_with_slash
+        open "dir_with_slash.t", "w" do |f|
+            f << <<-EOF
+            import "autoclean"
+            file "a.t/b/c" => "a.t/b" do |t|
+                sys.touch t.name
+            end
+            gen Directory, "a.t/", "b"
+            gen AutoClean
+            EOF
+        end
+        assert_rant(:fail, "-fdir_with_slash.t")
+        assert(!test(?e, "a.t"))
+        FileUtils.mkdir "a.t"
+        assert_rant("-fdir_with_slash.t")
+        assert(test(?f, "a.t/b/c"))
+        out, err = assert_rant("-fdir_with_slash.t")
+        assert(out.empty?)
+        assert(err.empty?)
+        assert_rant("-fdir_with_slash.t", "autoclean")
+        assert(test(?d, "a.t"))
+        assert(!test(?e, "a.t/b"))
+    end
+    def test_with_slash
+        open "dir_with_slash.t", "w" do |f|
+            f << <<-EOF
+            import "autoclean"
+            file "a.t/b" => "a.t" do |t|
+                sys.touch t.name
+            end
+            gen Directory, "a.t/"
+            gen AutoClean
+            EOF
+        end
+        assert_rant("-fdir_with_slash.t")
+        assert(test(?f, "a.t/b"))
+        out, err = assert_rant("-fdir_with_slash.t")
+        assert(out.empty?)
+        assert(err.empty?)
+        assert_rant("-fdir_with_slash.t", "autoclean")
+        assert(!test(?e, "a.t"))
+    end
 end

data/test/test_examples.rb

@@ -66,4 +66,71 @@ class TestExamples < Test::Unit::TestCase
 	assert(!test(?f, "c_dependencies"))
 	assert(!test(?f, "hello"))
     end
+    def test_c_cpp_examples
+        Dir.chdir "c_cpp_examples"
+        proj_pwd = Dir.pwd
+        out, err = assert_rant("--tasks")
+        # TODO: replace with a not-so-strict regex
+op = <<EOF
+rant run                      # Run all C and C++ tests.
+rant build                    # Build all.
+rant autoclean                # Remove all autogenerated files.
+rant pkg/c_cpp_exercises.tgz  # Create source package.
+EOF
+        assert_equal(op, out)
+        assert(err.empty?)
+        gen_files = %w(
+            c/problem_1_1/Rantfile
+            c++/problem_1_1/Rantfile
+            c/problem_1_1/c_dependencies
+            c++/problem_1_1/c_dependencies
+            c/problem_1_1/test
+            c++/problem_1_1/test
+            c/problem_1_1/main.o
+            c++/problem_1_1/main.o
+            c/problem_1_1/test.o
+            c++/problem_1_1/test.o
+            c/problem_1_1/another_test.o
+            c++/problem_1_1/another_test.o
+            pkg
+        )
+        if Rant::Env.find_bin("gcc") && Rant::Env.find_bin("g++")
+            out = run_rant
+            assert_exit
+            assert_equal(2, out.scan("Hello, world!").size)
+            out, err = assert_rant("build")
+            assert(out.empty?)
+            assert(err.empty?)
+        else
+            STDERR.puts "*** gcc and/or g++ not available, less example testing ***"
+        end
+        assert_rant("pkg/c_cpp_exercises.tgz")
+        # TODO: check archive contents
+        assert(test(?f, "pkg/c_cpp_exercises.tgz"))
+        out, err = assert_rant("pkg/c_cpp_exercises.tgz")
+        assert(out.empty?)
+        assert(err.empty?)
+        assert_rant("autoclean")
+        gen_files.each { |f|
+            assert(!test(?e, f),
+                "#{f} should have been removed by autoclean")
+        }
+        if Rant::Env.find_bin("gcc")
+            FileUtils.cp "c/template.rf", "c/problem_1_1/Rantfile"
+            Dir.chdir "c/problem_1_1"
+            out = run_rant
+            assert(out.include?("Hello, world!"))
+            assert_rant("autoclean")
+            FileUtils.rm_f "Rantfile"
+            Dir.chdir proj_pwd
+            gen_files.each { |f|
+                assert(!test(?e, f),
+                    "#{f} should have been removed by autoclean")
+            }
+        end
+    ensure
+        Dir.chdir proj_pwd
+        FileUtils.rm_f "c/problem_1_1/Rantfile"
+        FileUtils.rm_f "c++/problem_1_1/Rantfile"
+    end
 end

data/test/test_filelist.rb

@@ -288,6 +288,19 @@ class TestFileList < Test::Unit::TestCase
 	    assert(l1.include("b.t"))
 	end
     end
+    def test_sys_find_all_resolve
+	cx = Rant::RantApp.new.cx
+	touch_temp %w(a.t b.t) do
+	    l1 = cx.sys["*.t"]
+            l1.resolve
+	    l2 = l1.find_all { |f| f =~ /^b/ }
+	    assert_equal(2, l1.size)
+	    assert(l1.include("a.t"))
+	    assert(l1.include("b.t"))
+	    assert_equal(1, l2.size)
+	    assert(l1.include("b.t"))
+	end
+    end
     def test_sys_glob_flags
 	cx = Rant::RantApp.new.cx
 	touch_temp %w(a.t .a.t b.t .b.t) do
@@ -328,4 +341,43 @@ class TestFileList < Test::Unit::TestCase
             assert(fl.include?("a.t"))
         end
     end
+    def test_map
+        cx = Rant::RantApp.new.cx
+        touch_temp %w(a.t b.t) do
+            fl = cx.sys["*.t"]
+            l2 = fl.map { |f| f + "t" }
+            assert(Rant::FileList === l2)
+            assert_equal(2, l2.size)
+            assert(l2.include?("a.tt"))
+            assert(l2.include?("b.tt"))
+            assert_equal(2, fl.size)
+            assert(fl.include?("a.t"))
+            assert(fl.include?("b.t"))
+        end
+    end
+    def test_no_file
+        cx = Rant::RantApp.new.cx
+        touch_temp %w(a.t b.t) do
+            fl = cx.sys["*.t"]
+            fl.no_file "a.t"
+            assert_equal(1, fl.size)
+            assert(fl.include?("b.t"))
+        end
+    end
+    def test_to_s
+        cx = Rant::RantApp.new.cx
+        assert_equal("a b", cx.sys[].concat(%w(a b)).to_s)
+        assert_equal("", "#{cx.sys[]}")
+    end
+if Rant::Env.on_windows?
+    def test_to_s_quoting_spaces_win
+        cx = Rant::RantApp.new.cx
+        assert_equal('"a a" b', "#{cx.sys[].concat(["a a", "b"])}")
+    end
+else
+    def test_to_s_quoting_spaces
+        cx = Rant::RantApp.new.cx
+        assert_equal("'a a' b", "#{cx.sys[].concat(["a a", "b"])}")
+    end
+end
 end