rake 0.8.0 → 0.8.7

data/test/test_filelist.rb

@@ -4,10 +4,12 @@ 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
@@ -204,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}, fl.to_s
+    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
@@ -275,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")
@@ -287,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
@@ -403,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

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

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestAnEmptyInvocationChain < Test::Unit::TestCase
+  include TestMethods
 
   def setup
     @empty = Rake::InvocationChain::EMPTY
@@ -23,6 +25,8 @@ end
 
 ######################################################################
 class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
+  include TestMethods
+
   def setup
     @empty = Rake::InvocationChain::EMPTY
     @first_member = "A"
@@ -34,7 +38,7 @@ class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
   end
 
   def test_should_fail_when_adding_original_member
-    ex = assert_raise RuntimeError do
+    ex = assert_exception RuntimeError do
       @chain.append(@first_member)
     end
     assert_match(/circular +dependency/i, ex.message)
@@ -49,6 +53,8 @@ end
 
 ######################################################################
 class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
+  include TestMethods
+
   def setup
     @first_member = "A"
     @second_member = "B"
@@ -65,7 +71,7 @@ class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
   end
 
   def test_should_fail_when_adding_original_member
-    ex = assert_raise RuntimeError do
+    ex = assert_exception RuntimeError do
       @chain.append(@first_member)
     end
     assert_match(/A.*=>.*B.*=>.*A/, ex.message)

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

@@ -9,28 +9,47 @@ end
 require 'test/unit'
 require 'flexmock/test_unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 class TestNameSpace < Test::Unit::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

data/test/test_pathmap.rb

@@ -5,6 +5,7 @@ require 'rake'
 
 # ====================================================================
 class TestPathMap < Test::Unit::TestCase
+  include TestMethods
 
   def test_returns_self_with_no_args
     assert_equal "abc.rb", "abc.rb".pathmap
@@ -86,7 +87,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_undefined_percent_causes_error
-    ex = assert_raise(ArgumentError) {
+    ex = assert_exception(ArgumentError) {
       "dir/abc.rb".pathmap("%z")
     }
   end
@@ -130,7 +131,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_pattern_with_invalid_operator
-    ex = assert_raise(ArgumentError) do
+    ex = assert_exception(ArgumentError) do
       "abc.xyz".pathmap("%{src,bin}z")
     end
     assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)

data/test/test_pseudo_status.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+require 'test/capture_stdout'
+require 'test/rake_test_setup'
+
+class PseudoStatusTest < Test::Unit::TestCase
+  def test_with_zero_exit_status
+    s = Rake::PseudoStatus.new
+    assert_equal 0, s.exitstatus
+    assert_equal 0, s.to_i
+    assert_equal 0, s >> 8
+    assert ! s.stopped?
+    assert s.exited?
+  end
+  def test_with_99_exit_status
+    s = Rake::PseudoStatus.new(99)
+    assert_equal 99, s.exitstatus
+    assert_equal 25344, s.to_i
+    assert_equal 99, s >> 8
+    assert ! s.stopped?
+    assert s.exited?
+  end
+end

data/test/test_rake.rb

@@ -8,8 +8,15 @@ class TestRake < Test::Unit::TestCase
     assert_equal ['a'], alldirs('a')
     assert_equal ['a/b', 'a'], alldirs('a/b')
     assert_equal ['/a/b', '/a', '/'], alldirs('/a/b')
-    assert_equal ['c:/a/b', 'c:/a', 'c:'], alldirs('c:/a/b')
-    assert_equal ['c:a/b', 'c:a'], alldirs('c:a/b')
+    if File.dirname("c:/foo") == "c:"
+      # Under Unix
+      assert_equal ['c:/a/b', 'c:/a', 'c:'], alldirs('c:/a/b')
+      assert_equal ['c:a/b', 'c:a'], alldirs('c:a/b')
+    else
+      # Under Windows
+      assert_equal ['c:/a/b', 'c:/a', 'c:/'], alldirs('c:/a/b')
+      assert_equal ['c:a/b', 'c:a'], alldirs('c:a/b')
+    end
   end
 
   def alldirs(fn)

data/test/test_rdoc_task.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/rdoctask'
+require 'test/rake_test_setup'
+
+class TestRDocTask < Test::Unit::TestCase
+  include Rake
+  include TestMethods
+  
+  def setup
+    Task.clear
+  end
+  
+  def test_tasks_creation
+    Rake::RDocTask.new
+    assert Task[:rdoc]
+    assert Task[:clobber_rdoc]
+    assert Task[:rerdoc]
+  end
+  
+  def test_tasks_creation_with_custom_name_symbol
+    rd = Rake::RDocTask.new(:rdoc_dev)
+    assert Task[:rdoc_dev]
+    assert Task[:clobber_rdoc_dev]
+    assert Task[:rerdoc_dev]
+    assert_equal :rdoc_dev, rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_string
+    rd = Rake::RDocTask.new("rdoc_dev")
+    assert Task[:rdoc_dev]
+    assert Task[:clobber_rdoc_dev]
+    assert Task[:rerdoc_dev]
+    assert_equal "rdoc_dev", rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_hash
+    options = { :rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force" }
+    rd = Rake::RDocTask.new(options)
+    assert Task[:"rdoc"]
+    assert Task[:"rdoc:clean"]
+    assert Task[:"rdoc:force"]
+    assert_raises(RuntimeError) { Task[:clobber_rdoc] }
+    assert_equal options, rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
+    rd = Rake::RDocTask.new(:clobber_rdoc => "rdoc:clean")
+    assert Task[:rdoc]
+    assert Task[:"rdoc:clean"]
+    assert Task[:rerdoc]
+  end
+  
+  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
+    assert_raises(ArgumentError) do
+      Rake::RDocTask.new(:foo => "bar")
+    end
+    
+    begin
+      Rake::RDocTask.new(:foo => "bar")
+    rescue ArgumentError => e
+      assert_match(/foo/, e.message)
+    end
+  end
+  
+  def test_inline_source_is_enabled_by_default
+    rd = Rake::RDocTask.new
+    assert rd.option_list.include?('--inline-source')
+  end
+  
+  def test_inline_source_option_is_only_appended_if_option_not_already_given
+    rd = Rake::RDocTask.new
+    rd.options << '--inline-source'
+    assert_equal 1, rd.option_list.grep('--inline-source').size
+    
+    rd = Rake::RDocTask.new
+    rd.options << '-S'
+    assert_equal 1, rd.option_list.grep('-S').size
+    assert_equal 0, rd.option_list.grep('--inline-source').size
+  end
+  
+  def test_inline_source_option_can_be_disabled
+    rd = Rake::RDocTask.new
+    rd.inline_source = false
+    assert !rd.option_list.include?('--inline-source')
+  end
+end

data/test/test_require.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 # ====================================================================
 class TestRequire < Test::Unit::TestCase
+  include TestMethods
 
   def test_can_load_rake_library
     app = Rake::Application.new
@@ -22,7 +24,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_throws_error_if_library_not_found
     app = Rake::Application.new
-    ex = assert_raise(LoadError) {
+    ex = assert_exception(LoadError) {
       assert app.instance_eval {
         rake_require("testx", ['test/data/rakelib'], [])
       }