rant 0.3.0

data/test/project2/buildfile

@@ -0,0 +1,14 @@
+
+file "b_f1" => ["r_f4", "b_f2"] do |t|
+    touch t.name
+end
+
+file "b_f2" do |t|
+    touch t.name
+end
+
+task :clean do |t|
+    rm_f Dir["b_f*"]
+end
+
+subdirs %w(sub1 sub2)

data/test/project2/rantfile.rb

@@ -0,0 +1,20 @@
+
+file "r_f1" do |t|
+    sys.touch t.name
+end
+
+file "r_f2" => "r_f1" do |t|
+    sys.touch t.name
+end
+
+file "r_f3" => ["r_f2", :r_f4] do |t|
+    sys.touch t.name
+end
+
+file "r_f4" => "r_f2" do |t|
+    sys.touch t.name
+end
+
+task :clean do
+    sys.rm_f Dir["r_f*"]
+end

data/test/project2/sub1/Rantfile

@@ -0,0 +1,12 @@
+
+task :create_s1f1 do
+    touch "sub1/s1f1"
+end
+
+task :insub1_s1f1 do
+    touch "s1f1"
+end
+
+task :clean do
+    rm_f %w(sub1/s1f1 s1f1)
+end

data/test/project2/test_project.rb

@@ -0,0 +1,87 @@
+
+require 'test/unit'
+require 'tutil'
+
+# We require 'rant/rantlib' instead of 'rant',
+# which would cause the rant.rb (which is ment as a Rantfile)
+# to be loaded!
+require 'rant/rantlib'
+include Rant
+include ::Rant::Sys
+
+# Ensure we run in testproject directory.
+$testProject2Dir = File.expand_path(File.dirname(__FILE__))
+
+class TestProject2 < Test::Unit::TestCase
+    def app *args
+	@app = ::Rant::RantApp.new(*args)
+    end
+    def setup
+	Dir.chdir($testProject2Dir) unless Dir.pwd == $testProject2Dir
+    end
+    def teardown
+	capture_std do
+	    assert_equal(app(%w(-f rantfile.rb -f buildfile clean)).run, 0)
+	end
+	assert(Dir["r_f*"].empty?,
+	    "r_f* files should have been removed by `clean'")
+	assert(Dir["b_f*"].empty?,
+	    "b_f* files should have been removed by `clean'")
+	assert(Dir["sub1/s*f*"].empty?,
+	    "sub1/s*f* files should have been removed by `clean'")
+    end
+    def test_use_first_task
+	capture_std do
+	    assert_equal(app.run, 0,
+		"run method of RantApp should return 0 on success")
+	end
+	assert(File.exist?("r_f1"))
+    end
+    def test_deps
+	capture_std do
+	    assert_equal(app("r_f4").run, 0)
+	end
+	assert(File.exist?("r_f4"))
+	assert(File.exist?("r_f2"))
+	assert(File.exist?("r_f1"))
+	assert(!File.exist?("r_f3"))
+    end
+    def test_load_rantfile
+	capture_std do
+	    app("b_f2")
+	    assert(@app.source("buildfile"),
+		"source should return a true value on success")
+	    assert_equal(@app.run, 0)
+	end
+	assert(File.exist?("b_f2"))
+    end
+    def test_subdirs
+	capture_std do
+	    assert_equal(app(%w(-f buildfile create_s1f1)).run, 0)
+	end
+	assert(File.exist?("sub1/s1f1"))
+    end
+    def test_opt_directory
+	app %w(insub1_s1f1 -C sub1)
+	capture_std do
+	    assert_equal(@app.run, 0)
+	end
+	assert(Dir.pwd !~ /sub1$/,
+	    "rant should cd to original dir before returning from `run'")
+	assert(test(?f, "sub1/s1f1"),
+	    "rant should cd to sub1 and run task insub1_s1f1")
+    end
+    def test_opth_directory
+	app %w(insub1_s1f1)
+	#Rant[:directory] = "sub1"
+	@app[:verbose] = 2
+	@app[:directory] = "sub1"
+	capture_std do
+	    assert_equal(@app.run, 0)
+	end
+	assert(Dir.pwd !~ /sub1$/,
+	    "rant should cd to original dir before returning from `run'")
+	assert(test(?f, "sub1/s1f1"),
+	    "rant should cd to sub1 and run task insub1_s1f1")
+    end
+end

data/test/project_rb1/README

@@ -0,0 +1,14 @@
+
+= wgrep
+
+wgrep is a simple grep utility written in Ruby. It searches for
+one word in one or more files or in standard input and prints each
+line which contains the word.
+
+== Usage
+
+wgrep WORD [FILE(s)]
+
+== Running the tests
+
+Type `rant test' to run the unit tests.

data/test/project_rb1/bin/wgrep

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby
+
+require 'wgrep'
+
+exit WGrep::WGrep.new.run

data/test/project_rb1/lib/wgrep.rb

@@ -0,0 +1,56 @@
+
+module WGrep
+
+    class CommandError < StandardError
+    end
+
+    class WGrep
+	attr_reader :word
+	attr_reader :files
+	attr_reader :count
+	def initialize
+	    @word = nil
+	    @files = []
+	    @count = 0
+	end
+
+	def run(args = ARGV)
+	    process_args args
+	    @count = 0
+	    if @files.empty?
+		self.grep(@word, $stdin) { |line|
+		    print line
+		    @count += 1
+		}
+	    else
+		@files.each { |fn|
+		    File.open(fn) { |file|
+			self.grep(@word, file) { |line|
+			    print line
+			    @count += 1
+			}
+		    }
+		}
+	    end
+	    $stderr.puts "Found `#@word' in #{@count} lines."
+	    0
+	rescue CommandError => e
+	    $stderr.puts "Invalid commandline: #{e.message}"
+	    1
+	end
+
+	def process_args(args)
+	    if args.nil? || args.empty?
+		raise CommandError, "No word given."
+	    end
+	    args = [args] unless Array === args
+	    @word, @files = args[0], args[1..-1]
+	end
+
+	def grep(word, stream)
+	    stream.each { |rec|
+		yield(rec) if rec =~ /\b#{Regexp.escape(word)}\b/
+	    }
+	end
+    end
+end

data/test/project_rb1/rantfile.rb

@@ -0,0 +1,30 @@
+import %w(rubytest rubydoc rubypackage)
+
+lib_files = Dir["lib/**/*.rb"]
+dist_files = lib_files + %w(rantfile.rb README test_project_rb1.rb) + Dir["{test,bin}/*"]
+
+desc "Run unit tests."
+gen RubyTest do |t|
+    t.test_dir = "test"
+    t.pattern = "tc_*.rb"
+end
+
+desc "Generate html documentation."
+gen RubyDoc do |t|
+    t.opts = %w(--title wgrep --main README README)
+end
+
+desc "Create packages."
+gen RubyPackage, :wgrep do |t|
+    t.version = "1.0.0"
+    t.summary = "Simple grep program."
+    t.files = dist_files
+    t.bindir = "bin"
+    t.executable = "wgrep"
+    t.pkg_dir = "packages"
+    t.package_task "pkg"
+end
+
+task :clean do
+    sys.rm_rf %w(doc packages)
+end

data/test/project_rb1/test/tc_wgrep.rb

@@ -0,0 +1,21 @@
+
+require 'test/unit'
+require 'wgrep'
+require 'fileutils'
+
+class TestWGrep < Test::Unit::TestCase
+    def test_run
+	stdout = $stdout
+	output = File.new "wgrep_out", "w"
+	$stdout = output
+	assert_equal(WGrep::WGrep.new.run(%w(Hello text)), 0,
+		"Input to wgrep is ok, so `run' should return 0.")
+	output.close
+	$stdout = stdout
+	lines = File.read("wgrep_out").split("\n")
+	assert_equal(lines.size, 1)
+    ensure
+	FileUtils.rm_f "wgrep_out"
+	$stdout = stdout
+    end
+end

data/test/project_rb1/test/text

@@ -0,0 +1,3 @@
+
+This is a sample text for wgrep testing.
+Hello, you!

data/test/project_rb1/test_project_rb1.rb

@@ -0,0 +1,153 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+require 'tutil'
+
+$testProjectRb1Dir = File.expand_path(File.dirname(__FILE__))
+
+class TestProjectRb1 < Test::Unit::TestCase
+    def setup
+	@manifest = %w(bin lib test bin/wgrep lib/wgrep.rb
+	    test/text test/tc_wgrep.rb README test_project_rb1.rb
+	    rantfile.rb)
+	# Ensure we run in test directory.
+	Dir.chdir($testProjectRb1Dir) unless Dir.pwd == $testProjectRb1Dir
+    end
+    def teardown
+	capture_std do
+	    assert_equal(Rant.run(%w(clean)), 0)
+	end
+	manifest = @manifest.dup
+	check_manifest "after clean: "
+    end
+    def check_manifest(msg_prefix = "")
+	manifest = @manifest.dup
+	Dir["**/*"].each { |e|
+	    assert(manifest.reject! { |mf| mf == e } ,
+		"#{msg_prefix}#{e} shouldn't exist according to manifest")
+	}
+	manifest.each { |e|
+	    assert(false, "#{msg_prefix}#{e} missing according to manifest")
+	}
+    end
+    def test_doc
+	capture_std do
+	    assert_equal(Rant.run(%w(doc)), 0)
+	end
+	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")
+    end
+    def test_test
+	capture_std do
+	    assert_equal(Rant.run(%w(test)), 0)
+	end
+    end
+    def test_package
+	capture_std do
+	    assert_equal(Rant.run(%w(pkg)), 0)
+	end
+	assert(test(?d, "packages"),
+	    "task `pkg' should create dir `packages'")
+	begin
+	    have_tar = !`tar --help`.empty?
+	rescue
+	    have_tar = false
+	end
+	begin
+	    have_zip = !`zip -help`.empty?
+	rescue
+	    have_zip = false
+	end
+	have_gem = false
+	pkg_base = "packages/wgrep-1.0.0"
+	begin
+	    require 'rubygems'
+	    have_gem = true
+	rescue LoadError
+	end
+	if have_tar
+	    tar_fn = pkg_base + ".tar.gz"
+	    assert(test(?f, tar_fn),
+		"tar is available, so a tar.gz should have been built")
+	    verify_tar "packages", "wgrep-1.0.0", ".tar.gz"
+	else
+	    puts "*** tar not available ***"
+	end
+	if have_zip
+	    assert(test(?f, pkg_base + ".zip"),
+		"zip is available, so a zip should have been built")
+	    verify_zip "packages", "wgrep-1.0.0", ".zip"
+	else
+	    puts "*** zip not available ***"
+	end
+	if have_gem
+	    assert(test(?f, pkg_base + ".gem"),
+		"gem is available, so a gem should have been built")
+	else
+	    puts "*** gem not available ***"
+	end
+    end
+    def verify_tar(dir, pkg_base, ext)
+	tar_fn = pkg_base + ext
+	old_pwd = Dir.pwd
+	FileUtils.cd dir
+	tmp_dir = "_tmp_tar"
+	tmp_dir.freeze
+	FileUtils.mkdir tmp_dir
+	FileUtils.cp tar_fn, tmp_dir
+	FileUtils.cd tmp_dir do
+	    `tar xzf #{tar_fn}`
+	    assert(test(?d, pkg_base),
+		"`#{pkg_base}' should be root directory of all files in tar")
+	    FileUtils.cd pkg_base do
+		check_manifest "tar content: "
+	    end
+	end
+    ensure
+	FileUtils.cd old_pwd unless Dir.pwd == old_pwd
+	FileUtils.rm_rf tmp_dir
+    end
+    def verify_zip(dir, pkg_base, ext)
+	zip_fn = pkg_base + ext
+	old_pwd = Dir.pwd
+	FileUtils.cd dir
+	tmp_dir = "_tmp_zip"
+	tmp_dir.freeze
+	FileUtils.mkdir tmp_dir
+	FileUtils.cp zip_fn, tmp_dir
+	FileUtils.cd tmp_dir do
+	    `unzip -q #{zip_fn}`
+	    assert(test(?d, pkg_base),
+		"`#{pkg_base}' should be root directory of all files in zip")
+	    FileUtils.cd pkg_base do
+		check_manifest "zip content: "
+	    end
+	end
+    ensure
+	FileUtils.cd old_pwd unless Dir.pwd == old_pwd
+	FileUtils.rm_rf tmp_dir
+    end
+    def test_rant_import
+	require 'rant/import'
+	out, err = capture_std do
+	    assert_equal(0, Rant::RantImport.run(%w(--auto make)))
+	end
+	# TODO: some out, err checking
+	
+	# run the monolithic rant script
+	out = `#{Rant::Env::RUBY} make -T`
+	assert_equal(0, $?,
+	    "imported `rant -T' should return 0")
+	assert_match(/\bpkg\b/, out,
+	    "imported `rant -T' should list described task `pkg'")
+    ensure
+	File.delete "make" if File.exist? "make"
+    end
+end

data/test/test_env.rb

@@ -0,0 +1,47 @@
+
+require 'test/unit'
+require 'rant/rantlib'
+
+$testDir ||= File.expand_path(File.dirname(__FILE__))
+
+class TestRantEnv < Test::Unit::TestCase
+    def setup
+	# Ensure we run in test directory.
+	Dir.chdir($testDir) unless Dir.pwd == $testDir
+    end
+    def teardown
+    end
+    def test_on_windows
+	# rather primitive test, but should catch obvious programming
+	# errors when making changes in when in hurry ;)
+	if Rant::Env.on_windows?
+	    assert(File::ALT_SEPARATOR,
+		"Env says we're on windows, but there is no ALT_SEPARATOR")
+	end
+    end
+    def test_find_bin
+	assert(Rant::Env.find_bin(Rant::Env::RUBY),
+	    "RUBY_INSTALL_NAME should be found by Env.find_bin, " +
+	    "doesn't need to be a bug of Rant")
+	# let's check for the `echo' command which should be on most
+	# systems:
+	have_echo = false
+	begin
+	    have_echo = `echo hello` =~ /hello/
+	rescue Exception
+	end
+	if have_echo
+=begin
+            # seems to be not so on windows...
+	    echo_bin = Rant::Env.find_bin("echo")
+	    assert(echo_bin,
+		"echo can be invoked, so find_bin should find it")
+	    assert(echo_bin =~ /echo/i)
+	    assert(`#{echo_bin} hello` =~ /hello/,
+		"echo should be invokable through `#{echo_bin}'")
+=end
+	else
+	    puts "*** echo not available, will not search with find_bin ***"
+	end
+    end
+end