rake 0.5.4 → 0.6.0

data/test/{testclean.rb → test_clean.rb}

@@ -4,6 +4,7 @@ require 'test/unit'
 require 'rake/clean'
 
 class TestClean < Test::Unit::TestCase
+  include Rake
   def test_clean
     assert Task['clean'], "Should define clean"
     assert Task['clobber'], "Should define clobber"

data/test/test_definitions.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+
+######################################################################
+class TestDefinitions < Test::Unit::TestCase
+  include Rake
+  EXISTINGFILE = "testdata/existing"
+
+  def setup
+    Task.clear
+  end
+
+  def test_task
+    done = false
+    task :one => [:two] do done = true end
+    task :two
+    task :three => [:one, :two]
+    check_tasks(:one, :two, :three)
+    assert done, "Should be done"
+  end
+
+  def test_file_task
+    done = false
+    file "testdata/one" => "testdata/two" do done = true end
+    file "testdata/two"
+    file "testdata/three" => ["testdata/one", "testdata/two"]
+    check_tasks("testdata/one", "testdata/two", "testdata/three")
+    assert done, "Should be done"
+  end
+
+  def check_tasks(n1, n2, n3)
+    t = Task[n1]
+    assert Task === t, "Should be a Task"
+    assert_equal n1.to_s, t.name
+    assert_equal [n2.to_s], t.prerequisites.collect{|n| n.to_s}
+    t.invoke
+    t2 = Task[n2]
+    assert_equal FileList[], t2.prerequisites
+    t3 = Task[n3]
+    assert_equal [n1.to_s, n2.to_s], t3.prerequisites.collect{|n|n.to_s}
+  end
+
+  def test_incremental_definitions
+    runs = []
+    task :t1 => [:t2] do runs << "A"; 4321 end
+    task :t1 => [:t3] do runs << "B"; 1234 end
+    task :t1 => [:t3]
+    task :t2
+    task :t3
+    Task[:t1].invoke
+    assert_equal ["A", "B"], runs
+    assert_equal ["t2", "t3"], Task[:t1].prerequisites
+  end
+
+  def test_missing_dependencies
+    task :x => ["testdata/missing"]
+    assert_raises(RuntimeError) { Task[:x].invoke }
+  end
+
+  def test_implicit_file_dependencies
+    runs = []
+    create_existing_file
+    task :y => [EXISTINGFILE] do |t| runs << t.name end
+    Task[:y].invoke
+    assert_equal runs, ['y']
+  end
+
+  private # ----------------------------------------------------------
+
+  def create_existing_file
+    Dir.mkdir File.dirname(EXISTINGFILE) unless
+      File.exist?(File.dirname(EXISTINGFILE))
+    open(EXISTINGFILE, "w") do |f| f.puts "HI" end unless
+      File.exist?(EXISTINGFILE)
+  end
+
+end
+  

data/test/test_earlytime.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+class TestEarlyTime < Test::Unit::TestCase
+  def test_create
+    early = Rake::EarlyTime.instance
+    time = Time.mktime(1920, 1, 1, 0, 0, 0)
+    assert early <= Time.now
+    assert early < Time.now
+    assert early != Time.now
+    assert Time.now > early
+    assert Time.now >= early
+    assert Time.now != early
+  end
+
+  def test_equality
+    early = Rake::EarlyTime.instance
+    assert_equal early, early, "two early times should be equal"
+  end
+
+  def test_original_time_compare_is_not_messed_up
+    t1 = Time.mktime(1920, 1, 1, 0, 0, 0)
+    t2 = Time.now
+    assert t1 < t2
+    assert t2 > t1
+    assert t1 == t1
+    assert t2 == t2    
+  end
+end

data/test/test_file_creation_task.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+
+######################################################################
+class TestFileCreationTask < Test::Unit::TestCase
+  include Rake
+  include FileCreation
+
+  DUMMY_DIR = 'testdata/dummy_dir'
+
+  def setup
+    Task.clear
+  end
+
+  def teardown
+    FileUtils.rm_rf DUMMY_DIR
+  end
+
+  def test_file_needed
+    create_dir DUMMY_DIR
+    fc_task = Task[DUMMY_DIR]
+    assert_equal DUMMY_DIR, fc_task.name
+    FileUtils.rm_rf fc_task.name
+    assert fc_task.needed?, "file should be needed"
+    FileUtils.mkdir fc_task.name
+    assert_equal nil, fc_task.prerequisites.collect{|n| Task[n].timestamp}.max
+    assert ! fc_task.needed?, "file should not be needed"
+  end
+
+  def test_directory
+    directory DUMMY_DIR
+    fc_task = Task[DUMMY_DIR]
+    assert_equal DUMMY_DIR, fc_task.name
+    assert FileCreationTask === fc_task
+  end
+
+  def test_no_retriggers_on_filecreate_task
+    create_timed_files(OLDFILE, NEWFILE)
+    t1 = FileCreationTask.lookup(OLDFILE).enhance([NEWFILE])
+    t2 = FileCreationTask.lookup(NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    assert ! t1.needed?, "Should not need to rebuild old file because of new"
+  end
+
+  def test_no_retriggers_on_file_task
+    create_timed_files(OLDFILE, NEWFILE)
+    t1 = FileTask.lookup(OLDFILE).enhance([NEWFILE])
+    t2 = FileCreationTask.lookup(NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    assert ! t1.needed?, "Should not need to rebuild old file because of new"
+  end
+end

data/test/test_file_task.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+
+######################################################################
+class TestFileTask < Test::Unit::TestCase
+  include Rake
+  include FileCreation
+
+  def setup
+    Task.clear
+    @runs = Array.new
+    FileUtils.rm_f NEWFILE
+    FileUtils.rm_f OLDFILE
+  end
+
+  def test_file_need
+    name = "testdata/dummy"
+    file name
+    ftask = Task[name]
+    assert_equal name.to_s, ftask.name
+    File.delete(ftask.name) rescue nil
+    assert ftask.needed?, "file should be needed"
+    open(ftask.name, "w") { |f| f.puts "HI" }
+    assert_equal nil, ftask.prerequisites.collect{|n| Task[n].timestamp}.max
+    assert ! ftask.needed?, "file should not be needed"
+    File.delete(ftask.name) rescue nil
+  end
+
+  def test_file_times_new_depends_on_old
+    create_timed_files(OLDFILE, NEWFILE)
+
+    t1 = FileTask.lookup(NEWFILE).enhance([OLDFILE])
+    t2 = FileTask.lookup(OLDFILE)
+    assert ! t2.needed?, "Should not need to build old file"
+    assert ! t1.needed?, "Should not need to rebuild new file because of old"
+  end
+
+  def test_file_times_old_depends_on_new
+    create_timed_files(OLDFILE, NEWFILE)
+
+    t1 = FileTask.lookup(OLDFILE).enhance([NEWFILE])
+    t2 = FileTask.lookup(NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    preq_stamp = t1.prerequisites.collect{|t| Task[t].timestamp}.max
+    assert_equal t2.timestamp, preq_stamp
+    assert t1.timestamp < preq_stamp, "T1 should be older"
+    assert t1.needed?, "Should need to rebuild old file because of new"
+  end
+
+  def test_file_depends_on_task_depend_on_file
+    create_timed_files(OLDFILE, NEWFILE)
+
+    file NEWFILE => [:obj] do |t| @runs << t.name end
+    task :obj => [OLDFILE] do |t| @runs << t.name end
+    file OLDFILE           do |t| @runs << t.name end
+
+    Task[:obj].invoke
+    Task[NEWFILE].invoke
+    assert ! @runs.include?(NEWFILE)
+  end
+
+  def test_existing_file_depends_on_non_existing_file
+    create_file(OLDFILE)
+    delete_file(NEWFILE)
+    file NEWFILE
+    file OLDFILE => NEWFILE
+    assert_nothing_raised do Task[OLDFILE].invoke end
+  end
+
+  # I have currently disabled this test.  I'm not convinced that
+  # deleting the file target on failure is always the proper thing to
+  # do.  I'm willing to hear input on this topic.
+  def ztest_file_deletes_on_failure
+    task :obj 
+    file NEWFILE => [:obj] do |t|
+      FileUtils.touch NEWFILE
+      fail "Ooops"
+    end
+    assert Task[NEWFILE]
+    begin
+      Task[NEWFILE].invoke
+    rescue Exception
+    end
+    assert( ! File.exist?(NEWFILE), "NEWFILE should be deleted")
+  end
+
+end
+
+######################################################################
+class TestDirectoryTask < Test::Unit::TestCase
+  include Rake
+
+  def setup
+    rm_rf "testdata", :verbose=>false
+  end
+
+  def teardown
+    rm_rf "testdata", :verbose=>false
+  end
+
+  def test_directory
+    desc "DESC"
+    directory "testdata/a/b/c"
+    assert_equal FileCreationTask, Task["testdata"].class
+    assert_equal FileCreationTask, Task["testdata/a"].class
+    assert_equal FileCreationTask, Task["testdata/a/b/c"].class
+    assert_nil             Task["testdata"].comment
+    assert_equal "DESC",   Task["testdata/a/b/c"].comment
+    assert_nil             Task["testdata/a/b"].comment
+    verbose(false) {
+      Task['testdata/a/b'].invoke
+    }
+    assert File.exist?("testdata/a/b")
+    assert ! File.exist?("testdata/a/b/c")
+  end
+
+  def test_directory_win32
+    desc "WIN32 DESC"
+    FileUtils.mkdir_p("testdata")
+    Dir.chdir("testdata") do
+      directory 'c:/testdata/a/b/c'
+      assert_equal FileCreationTask, Task['c:/testdata'].class
+      assert_equal FileCreationTask, Task['c:/testdata/a'].class
+      assert_equal FileCreationTask, Task['c:/testdata/a/b/c'].class
+      assert_nil             Task['c:/testdata'].comment
+      assert_equal "WIN32 DESC",   Task['c:/testdata/a/b/c'].comment
+      assert_nil             Task['c:/testdata/a/b'].comment
+      verbose(false) {
+	Task['c:/testdata/a/b'].invoke
+      }
+      assert File.exist?('c:/testdata/a/b')
+      assert ! File.exist?('c:/testdata/a/b/c')
+    end
+  end
+end
+

data/test/{testfilelist.rb → test_filelist.rb}

@@ -12,6 +12,7 @@ class TestFileList < Test::Unit::TestCase
 
   def teardown
     FileList.select_default_ignore_patterns
+    FileUtils.rm_rf("testdata")
   end
 
   def test_create
@@ -78,7 +79,7 @@ class TestFileList < Test::Unit::TestCase
   def test_match
     fl = FileList.new
     fl.include('test/test*.rb')
-    assert fl.include?("test/testfilelist.rb")
+    assert fl.include?("test/test_filelist.rb")
     assert fl.size > 3
     fl.each { |fn| assert_match(/\.rb$/, fn) }
   end
@@ -89,7 +90,7 @@ class TestFileList < Test::Unit::TestCase
     fl.include("test/*.rb")
     assert_equal "a.java", fl[0]
     assert fl.size > 2
-    assert fl.include?("test/testfilelist.rb")
+    assert fl.include?("test/test_filelist.rb")
   end
 
   def test_multiple_patterns
@@ -241,6 +242,20 @@ class TestFileList < Test::Unit::TestCase
       f2.sort
   end
 
+  def test_egrep
+    files = FileList['test/test*.rb']
+    found = false
+    the_line_number = __LINE__ + 1
+    files.egrep(/XYZZY/) do |fn, ln, line |
+      assert_equal 'test/test_filelist.rb', fn
+      assert_equal the_line_number, ln
+      assert_match(/files\.egrep/, line)
+      found = true
+    end
+    assert found, "should have foudn a matching line"
+  end
+
+
   def test_ignore_special
     f = FileList['testdata/*']
     assert ! f.include?("testdata/CVS"), "Should not contain CVS"

data/test/{testfileutils.rb → test_fileutils.rb}

@@ -8,16 +8,24 @@ require 'fileutils'
 class TestFileUtils < Test::Unit::TestCase
   include FileCreation
 
+  def setup
+    File.chmod(0750,"test/shellcommand.rb")
+  end
+  
+  def teardown
+    FileUtils.rm_rf("testdata")
+  end
+  
   def test_rm_one_file
     create_file("testdata/a")
-    FileUtils.rm_r "testdata/a"
+    FileUtils.rm_rf "testdata/a"
     assert ! File.exist?("testdata/a")
   end
 
   def test_rm_two_files
     create_file("testdata/a")
     create_file("testdata/b")
-    FileUtils.rm_r ["testdata/a", "testdata/b"]
+    FileUtils.rm_rf ["testdata/a", "testdata/b"]
     assert ! File.exist?("testdata/a")
     assert ! File.exist?("testdata/b")
   end

data/test/test_makefile_loader.rb

@@ -5,6 +5,8 @@ require 'rake'
 require 'rake/loaders/makefile'
 
 class TestMakefileLoader < Test::Unit::TestCase
+  include Rake
+
   def test_create
     Task.clear
     loader = Rake::MakefileLoader.new

data/test/{testpackagetask.rb → test_package_task.rb}

@@ -4,6 +4,8 @@ require 'test/unit'
 require 'rake/packagetask'
 
 class TestPackageTask < Test::Unit::TestCase
+  include Rake
+
   def test_create
     pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
       p.package_files << "install.rb"
@@ -80,6 +82,49 @@ else
 	p.package_files << "y"
       end
       assert_equal ["x", "y"], pkg.package_files
+      assert_equal "pkgr-1.2.3.gem", pkg.gem_file
+    end
+
+    def test_gem_package_with_specific_platform
+      gem = Gem::Specification.new do |g|
+	g.name = "pkgr"
+	g.version = "1.2.3"
+	g.files = FileList["x"].resolve
+	g.platform = Gem::Platform::WIN32
+      end
+      pkg = Rake::GemPackageTask.new(gem)  do |p|
+	p.package_files << "y"
+      end
+      assert_equal ["x", "y"], pkg.package_files
+      assert_equal "pkgr-1.2.3-mswin32.gem", pkg.gem_file
+    end
+
+    def test_gem_package_with_current_platform
+      gem = Gem::Specification.new do |g|
+	g.name = "pkgr"
+	g.version = "1.2.3"
+	g.files = FileList["x"].resolve
+	g.platform = Gem::Platform::CURRENT
+      end
+      pkg = Rake::GemPackageTask.new(gem)  do |p|
+	p.package_files << "y"
+      end
+      assert_equal ["x", "y"], pkg.package_files
+      assert_match(/^pkgr-1\.2\.3-(\S+)\.gem$/, pkg.gem_file)
+    end
+
+    def test_gem_package_with_ruby_platform
+      gem = Gem::Specification.new do |g|
+	g.name = "pkgr"
+	g.version = "1.2.3"
+	g.files = FileList["x"].resolve
+	g.platform = Gem::Platform::RUBY
+      end
+      pkg = Rake::GemPackageTask.new(gem)  do |p|
+	p.package_files << "y"
+      end
+      assert_equal ["x", "y"], pkg.package_files
+      assert_equal "pkgr-1.2.3.gem", pkg.gem_file
     end
   end
 end