rake 0.7.3 → 0.8.7

data/test/test_extension.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'stringio'
+
+######################################################################
+class TestExtension < Test::Unit::TestCase
+
+  module Redirect
+    def error_redirect
+      old_err = $stderr
+      result = StringIO.new
+      $stderr = result
+      yield
+      result
+    ensure
+      $stderr = old_err
+    end
+  end
+  
+  class Sample
+    extend Redirect
+
+    def duplicate_method
+      :original
+    end
+    
+    OK_ERRS = error_redirect do
+      rake_extension("a") do
+        def ok_method
+        end
+      end
+    end
+
+
+    DUP_ERRS = error_redirect do
+      rake_extension("duplicate_method") do
+        def duplicate_method
+          :override
+        end
+      end
+    end
+  end
+
+  def test_methods_actually_exist
+    sample = Sample.new
+    sample.ok_method
+    sample.duplicate_method
+  end
+
+  def test_no_warning_when_defining_ok_method
+    assert_equal "", Sample::OK_ERRS.string
+  end
+
+  def test_extension_complains_when_a_method_that_is_present
+    assert_match(/warning:/i, Sample::DUP_ERRS.string)
+    assert_match(/already exists/i, Sample::DUP_ERRS.string)
+    assert_match(/duplicate_method/i, Sample::DUP_ERRS.string)
+    assert_equal :original, Sample.new.duplicate_method
+  end
+
+end

data/test/test_file_task.rb

@@ -4,11 +4,13 @@ require 'test/unit'
 require 'fileutils'
 require 'rake'
 require 'test/filecreation'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestFileTask < Test::Unit::TestCase
   include Rake
   include FileCreation
+  include TestMethods
 
   def setup
     Task.clear
@@ -118,22 +120,24 @@ class TestDirectoryTask < Test::Unit::TestCase
     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')
+  if Rake::Win32.windows?
+    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
 end

data/test/test_filelist.rb

@@ -2,21 +2,31 @@
 
 require 'test/unit'
 require 'rake'
+
 require 'test/capture_stdout'
+require 'test/rake_test_setup'
 
 class TestFileList < Test::Unit::TestCase
   FileList = Rake::FileList
   include CaptureStdout
+  include TestMethods
 
   def setup
     create_test_data
   end
 
   def teardown
-    FileList.select_default_ignore_patterns
+#    FileList.select_default_ignore_patterns
     FileUtils.rm_rf("testdata")
   end
 
+  def test_delgating_methods_do_not_include_to_a_or_to_ary
+    assert ! FileList::DELEGATING_METHODS.include?("to_a"), "should not include to_a"
+    assert ! FileList::DELEGATING_METHODS.include?(:to_a), "should not include to_a"
+    assert ! FileList::DELEGATING_METHODS.include?("to_ary"), "should not include to_ary"
+    assert ! FileList::DELEGATING_METHODS.include?(:to_ary), "should not include to_ary"
+  end
+
   def test_create
     fl = FileList.new
     assert_equal 0, fl.size
@@ -196,12 +206,20 @@ class TestFileList < Test::Unit::TestCase
 
   def test_to_s_pending
     fl = FileList['testdata/abc.*']
-    assert_equal  %{testdata/abc.c testdata/abc.h testdata/abc.x}.sort, fl.to_s.sort
+    result = fl.to_s
+    assert_match(%r{testdata/abc\.c}, result)
+    assert_match(%r{testdata/abc\.h}, result)
+    assert_match(%r{testdata/abc\.x}, result)
+    assert_match(%r{(testdata/abc\..\b ?){2}}, result)
   end
 
   def test_inspect_pending
     fl = FileList['testdata/abc.*']
-    assert_equal  %{["testdata/abc.c", "testdata/abc.h", "testdata/abc.x"]}, fl.inspect
+    result = fl.inspect
+    assert_match(%r{"testdata/abc\.c"}, result)
+    assert_match(%r{"testdata/abc\.h"}, result)
+    assert_match(%r{"testdata/abc\.x"}, result)
+    assert_match(%r|^\[("testdata/abc\..", ){2}"testdata/abc\.."\]$|, result)
   end
 
   def test_sub
@@ -267,9 +285,7 @@ class TestFileList < Test::Unit::TestCase
     assert_equal "one.two.net", "one.two.c".ext(".net")
     assert_equal "one/two.net", "one/two.c".ext(".net")
     assert_equal "one.x/two.net", "one.x/two.c".ext(".net")
-    assert_equal "one.x\\two.net", "one.x\\two.c".ext(".net")
     assert_equal "one.x/two.net", "one.x/two".ext(".net")
-    assert_equal "one.x\\two.net", "one.x\\two".ext(".net")
     assert_equal ".onerc.net", ".onerc.dot".ext("net")
     assert_equal ".onerc.net", ".onerc".ext("net")
     assert_equal ".a/.onerc.net", ".a/.onerc".ext("net")
@@ -279,6 +295,11 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ".one", ".one".ext
     assert_equal ".", ".".ext("c")
     assert_equal "..", "..".ext("c")
+    # These only need to work in windows
+    if Rake::Win32.windows?
+      assert_equal "one.x\\two.net", "one.x\\two.c".ext(".net")
+      assert_equal "one.x\\two.net", "one.x\\two".ext(".net")
+    end
   end
 
   def test_filelist_ext
@@ -395,12 +416,40 @@ class TestFileList < Test::Unit::TestCase
       ['a', FileList['testdata/*.c']].flatten.sort
   end
 
-  def test_clone
+  def test_clone_and_dup
     a = FileList['a', 'b', 'c']
-    b = a.clone
+    c = a.clone
+    d = a.dup
     a << 'd'
     assert_equal ['a', 'b', 'c', 'd'], a
-    assert_equal ['a', 'b', 'c'], b
+    assert_equal ['a', 'b', 'c'], c
+    assert_equal ['a', 'b', 'c'], d
+  end
+
+  def test_dup_and_clone_replicate_taint
+    a = FileList['a', 'b', 'c']
+    a.taint
+    c = a.clone
+    d = a.dup
+    assert c.tainted?, "Clone should be tainted"
+    assert d.tainted?, "Dup should be tainted"
+  end
+
+  def test_duped_items_will_thaw
+    a = FileList['a', 'b', 'c']
+    a.freeze
+    d = a.dup
+    d << 'more'
+    assert_equal ['a', 'b', 'c', 'more'], d
+  end
+
+  def test_cloned_items_stay_frozen
+    a = FileList['a', 'b', 'c']
+    a.freeze
+    c = a.clone
+    assert_exception(TypeError, RuntimeError) do
+      c << 'more'
+    end
   end
 
   def test_array_comparisons
@@ -467,7 +516,7 @@ class TestFileList < Test::Unit::TestCase
     assert_equal FileList,  b[0].class
     assert_equal FileList,  b[1].class
 
-    b = a.zip(['x', 'y'])
+    b = a.zip(['x', 'y']).to_a
     assert_equal [['a', 'x'], ['b', 'y']], b
     assert_equal Array, b.class
     assert_equal Array, b[0].class
@@ -543,7 +592,7 @@ class TestFileList < Test::Unit::TestCase
   def test_file_utils_can_use_filelists
     cfiles = FileList['testdata/*.c']
     
-    cp cfiles, @cdir
+    cp cfiles, @cdir, :verbose => false
     
     assert File.exist?(File.join(@cdir, 'abc.c'))
     assert File.exist?(File.join(@cdir, 'xyz.c'))

data/test/test_fileutils.rb

@@ -5,9 +5,11 @@ require 'test/unit'
 require 'test/filecreation'
 require 'fileutils'
 require 'stringio'
+require 'test/rake_test_setup'
 
 class TestFileUtils < Test::Unit::TestCase
   include FileCreation
+  include TestMethods
 
   def setup
     File.chmod(0750,"test/shellcommand.rb")
@@ -81,7 +83,7 @@ class TestFileUtils < Test::Unit::TestCase
   def test_safe_ln_fails_on_script_error
     FileUtils::LN_SUPPORTED[0] = true
     c = BadLink.new(ScriptError)
-    assert_raise(ScriptError) do c.safe_ln "a", "b" end
+    assert_exception(ScriptError) do c.safe_ln "a", "b" end
   end
 
   def test_verbose
@@ -114,41 +116,58 @@ class TestFileUtils < Test::Unit::TestCase
 
   def test_fileutils_methods_dont_leak
     obj = Object.new
-    assert_raise(NoMethodError) { obj.copy } # from FileUtils
-    assert_raise(NoMethodError) { obj.ruby } # from RubyFileUtils
+    assert_exception(NoMethodError) { obj.copy } # from FileUtils
+    assert_exception(NoMethodError) { obj.ruby } # from RubyFileUtils
   end
 
   def test_sh
-    verbose(false) { sh %{test/shellcommand.rb} }
+    verbose(false) { sh %{ruby test/shellcommand.rb} }
     assert true, "should not fail"
   end
 
-  def test_sh_multiple_arguments
+  # If the :sh method is invoked directly from a test unit instance
+  # (under mini/test), the mini/test version of fail is invoked rather
+  # than the kernel version of fail. So we run :sh from within a
+  # non-test class to avoid the problem.
+  class Sh
+    include FileUtils
+    def run(*args)
+      sh(*args)
+    end
+    def self.run(*args)
+      new.run(*args)
+    end
+  end
+
+  def test_sh_with_a_single_string_argument
     ENV['RAKE_TEST_SH'] = 'someval'
-    # This one gets expanded by the shell
-    verbose(false) { sh %{test $RAKE_TEST_SH = someval} }
-    assert true, "should not fail"
-    assert_raises(RuntimeError) {
-      # This one does not get expanded
-      verbose(false) { sh 'test','$RAKE_TEST_SH', '=', 'someval' }
+    verbose(false) {
+      sh %{ruby test/check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_sh_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      Sh.run 'ruby', 'test/check_no_expansion.rb', env_var, 'someval'
     }
   end
 
   def test_sh_failure
-    assert_raises(RuntimeError) { 
-      verbose(false) { sh %{test/shellcommand.rb 1} }
+    assert_exception(RuntimeError) { 
+      verbose(false) { Sh.run %{ruby test/shellcommand.rb 1} }
     }
   end
 
   def test_sh_special_handling
     count = 0
     verbose(false) {
-      sh(%{test/shellcommand.rb}) do |ok, res|
+      sh(%{ruby test/shellcommand.rb}) do |ok, res|
         assert(ok)
         assert_equal 0, res.exitstatus
         count += 1
       end
-      sh(%{test/shellcommand.rb 1}) do |ok, res|
+      sh(%{ruby test/shellcommand.rb 1}) do |ok, res|
         assert(!ok)
         assert_equal 1, res.exitstatus
         count += 1
@@ -163,7 +182,7 @@ class TestFileUtils < Test::Unit::TestCase
   end
 
   def test_sh_bad_option
-    ex = assert_raise(ArgumentError) {
+    ex = assert_exception(ArgumentError) {
       verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
     }
     assert_match(/bad_option/, ex.message)
@@ -178,34 +197,27 @@ class TestFileUtils < Test::Unit::TestCase
     assert_match(/^test\/shellcommand\.rb$/, out)
   end
 
-  def test_sh_default_verbosity_is_false
+  def test_sh_no_verbose
     out = redirect_stderr {
-      sh %{test/shellcommand.rb}, :noop=>true
+      verbose(false) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
     }
     assert_equal '', out
   end
 
-  def test_ruby
-    verbose(false) do
-      ENV['RAKE_TEST_RUBY'] = "123"
-      block_run = false
-      # This one gets expanded by the shell
-      ruby %{-e "exit $RAKE_TEST_RUBY"} do |ok, status|
-        assert(!ok)
-        assert_equal 123, status.exitstatus
-        block_run = true
-      end
-      assert block_run, "The block must be run"
+  def test_ruby_with_a_single_string_argument
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby %{test/check_expansion.rb #{env_var} someval}
+    }
+  end
 
-      # This one does not get expanded
-      block_run = false
-      ruby '-e', 'exit "$RAKE_TEST_RUBY".length' do |ok, status|
-        assert(!ok)
-        assert_equal 15, status.exitstatus
-        block_run = true
-      end
-      assert block_run, "The block must be run"
-    end
+  def test_ruby_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby 'test/check_no_expansion.rb', env_var, 'someval'
+    }
   end
 
   def test_split_all
@@ -227,4 +239,13 @@ class TestFileUtils < Test::Unit::TestCase
   ensure
     $stderr = old_err
   end
+
+  def windows?
+    ! File::ALT_SEPARATOR.nil?
+  end
+
+  def env_var
+    windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
+  end
+  
 end

data/test/test_ftp.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'date'
+require 'time'
 require 'test/unit'
 require 'rake/contrib/ftptools'
 
@@ -8,13 +9,16 @@ class FakeDate
   def self.today
     Date.new(2003,10,3)
   end
+  def self.now
+    Time.local(2003,10,3,12,00,00)
+  end
 end
 
 
 class TestFtpFile < Test::Unit::TestCase
 
   def setup
-    Rake::FtpFile.class_eval { @date_class = FakeDate }
+    Rake::FtpFile.class_eval { @date_class = FakeDate; @time_class = FakeDate }
   end
 
   def test_general

data/test/test_invocation_chain.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'test/rake_test_setup'
+
+######################################################################
+class TestAnEmptyInvocationChain < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @empty = Rake::InvocationChain::EMPTY
+  end
+
+  def test_should_be_able_to_add_members
+    assert_nothing_raised do
+      @empty.append("A")
+    end
+  end
+
+  def test_to_s
+    assert_equal "TOP", @empty.to_s
+  end
+end
+
+######################################################################
+class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @empty = Rake::InvocationChain::EMPTY
+    @first_member = "A"
+    @chain = @empty.append(@first_member)
+  end
+
+  def test_should_report_first_member_as_a_member
+    assert @chain.member?(@first_member)
+  end
+
+  def test_should_fail_when_adding_original_member
+    ex = assert_exception RuntimeError do
+      @chain.append(@first_member)
+    end
+    assert_match(/circular +dependency/i, ex.message)
+    assert_match(/A.*=>.*A/, ex.message)
+  end
+
+  def test_to_s
+    assert_equal "TOP => A", @chain.to_s
+  end
+
+end
+
+######################################################################
+class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @first_member = "A"
+    @second_member = "B"
+    ch = Rake::InvocationChain::EMPTY.append(@first_member)
+    @chain = ch.append(@second_member)
+  end
+
+  def test_should_report_first_member_as_a_member
+    assert @chain.member?(@first_member)
+  end
+
+  def test_should_report_second_member_as_a_member
+    assert @chain.member?(@second_member)
+  end
+
+  def test_should_fail_when_adding_original_member
+    ex = assert_exception RuntimeError do
+      @chain.append(@first_member)
+    end
+    assert_match(/A.*=>.*B.*=>.*A/, ex.message)
+  end
+end
+
+

data/test/test_makefile_loader.rb

@@ -7,7 +7,7 @@ require 'rake/loaders/makefile'
 class TestMakefileLoader < Test::Unit::TestCase
   include Rake
 
-  def test_create
+  def test_parse
     Task.clear
     loader = Rake::MakefileLoader.new
     loader.load("test/data/sample.mf")
@@ -18,6 +18,9 @@ class TestMakefileLoader < Test::Unit::TestCase
     assert_equal %w(b1 b2 b3 b4 b5 b6 b7).sort, Task['b'].prerequisites.sort
     assert_equal %w(c1).sort, Task['c'].prerequisites.sort
     assert_equal %w(d1 d2).sort, Task['d'].prerequisites.sort
-    assert_equal 4, Task.tasks.size
+    assert_equal %w(e1 f1).sort, Task['e'].prerequisites.sort
+    assert_equal %w(e1 f1).sort, Task['f'].prerequisites.sort
+    assert_equal ["g1", "g 2", "g 3", "g4"].sort, Task['g 0'].prerequisites.sort
+    assert_equal 7, Task.tasks.size
   end
 end

data/test/test_namespace.rb

@@ -1,32 +1,55 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
+begin
+  require 'rubygems'
+rescue LoadError
+  # got no gems
+end
+
 require 'test/unit'
-require 'flexmock'
+require 'flexmock/test_unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 class TestNameSpace < Test::Unit::TestCase
-  include FlexMock::TestCase
+  include TestMethods
+
+  class TM
+    include Rake::TaskManager
+  end
 
   def test_namespace_creation
-    mgr = flexmock("TaskManager")
+    mgr = TM.new
     ns = Rake::NameSpace.new(mgr, [])
     assert_not_nil ns
   end
 
   def test_namespace_lookup
-    mgr = flexmock("TaskManager")
-    mgr.should_receive(:lookup).with(:t, ["a"]).
-      and_return(:dummy).once
-    ns = Rake::NameSpace.new(mgr, ["a"])
-    assert_equal :dummy, ns[:t]
+    mgr = TM.new
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, "t")
+    end
+
+    assert_not_nil ns["t"]
+    assert_equal mgr["n:t"], ns["t"]
   end
 
   def test_namespace_reports_tasks_it_owns
-    mgr = flexmock("TaskManager")
-    mgr.should_receive(:tasks).with().
-      and_return([:x, :y, :z]).once
-    ns = Rake::NameSpace.new(mgr, ["a"])
-    assert_equal [:x, :y, :z], ns.tasks
+    mgr = TM.new
+    nns = nil
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, :x)
+      mgr.define_task(Rake::Task, :y)
+      nns = mgr.in_namespace("nn") do
+        mgr.define_task(Rake::Task, :z)
+      end
+    end
+    mgr.in_namespace("m") do
+      mgr.define_task(Rake::Task, :x)
+    end
+
+    assert_equal ["n:nn:z", "n:x", "n:y"],
+      ns.tasks.map { |tsk| tsk.name }
+    assert_equal ["n:nn:z"], nns.tasks.map {|t| t.name}
   end
 end

data/test/test_package_task.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake/packagetask'
+require 'test/rake_test_setup'
 
 class TestPackageTask < Test::Unit::TestCase
   include Rake
+  include TestMethods
 
   def test_create
     pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
@@ -40,7 +42,7 @@ class TestPackageTask < Test::Unit::TestCase
   end
 
   def test_missing_version
-    assert_raises(RuntimeError) {
+    assert_exception(RuntimeError) {
       pkg = Rake::PackageTask.new("pkgr") { |p| }
     }
   end
@@ -85,20 +87,6 @@ else
       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"