rake 0.7.1 → 0.7.2

data/test/test_earlytime.rb

@@ -28,4 +28,8 @@ class TestEarlyTime < Test::Unit::TestCase
     assert t1 == t1
     assert t2 == t2    
   end
+
+  def test_to_s
+    assert_equal "<EARLY TIME>", Rake::EARLY.to_s
+  end
 end

data/test/test_file_creation_task.rb

@@ -53,4 +53,10 @@ class TestFileCreationTask < Test::Unit::TestCase
     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_very_early_timestamp
+    t1 = Rake.application.intern(FileCreationTask, OLDFILE)
+    assert t1.timestamp < Time.now
+    assert t1.timestamp < Time.now - 1000000
+  end
 end

data/test/test_file_task.rb

@@ -130,11 +130,10 @@ class TestDirectoryTask < Test::Unit::TestCase
       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
+        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/test_filelist.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/capture_stdout'
 
 class TestFileList < Test::Unit::TestCase
   FileList = Rake::FileList
+  include CaptureStdout
 
   def setup
     create_test_data
@@ -104,6 +106,22 @@ class TestFileList < Test::Unit::TestCase
     ].sort, fl.sort
   end
 
+  def test_square_bracket_pattern
+    fl = FileList.new
+    fl.include("testdata/abc.[ch]")
+    assert fl.size == 2
+    assert fl.include?("testdata/abc.c")
+    assert fl.include?("testdata/abc.h")
+  end
+
+  def test_curly_bracket_pattern
+    fl = FileList.new
+    fl.include("testdata/abc.{c,h}")
+    assert fl.size == 2
+    assert fl.include?("testdata/abc.c")
+    assert fl.include?("testdata/abc.h")
+  end
+
   def test_reject
     fl = FileList.new
     fl.include %w(testdata/x.c testdata/abc.c testdata/xyz.c testdata/existing)
@@ -118,18 +136,30 @@ class TestFileList < Test::Unit::TestCase
     fl.each { |fn| touch fn, :verbose => false }
     x = fl.exclude(%r{/x.+\.})
     assert_equal FileList, x.class
-    assert_equal [
-      'testdata/x.c', 'testdata/abc.c', 'testdata/existing'
-    ], fl
+    assert_equal %w(testdata/x.c testdata/abc.c testdata/existing), fl
     assert_equal fl.object_id, x.object_id
     fl.exclude('testdata/*.c')
     assert_equal ['testdata/existing'], fl
     fl.exclude('testdata/existing')
     assert_equal [], fl
   end
+  
+  def test_excluding_via_block
+    fl = FileList['testdata/a.c', 'testdata/b.c', 'testdata/xyz.c']
+    fl.exclude { |fn| fn.pathmap('%n') == 'xyz' }
+    assert fl.exclude?("xyz.c"), "Should exclude xyz.c"
+    assert_equal ['testdata/a.c', 'testdata/b.c'], fl
+  end
 
   def test_exclude_return_on_create
-    fl = FileList['testdata/*'].exclude(/.*\.c$/)
+    fl = FileList['testdata/*'].exclude(/.*\.[hcx]$/)
+    assert_equal ['testdata/existing'], fl
+    assert_equal FileList, fl.class
+  end
+
+  def test_exclude_with_string_return_on_create
+    fl = FileList['testdata/*'].exclude('testdata/abc.c')
+    assert_equal %w(testdata/existing testdata/x.c testdata/abc.h testdata/abc.x testdata/xyz.c).sort, fl.sort
     assert_equal FileList, fl.class
   end
 
@@ -166,12 +196,12 @@ class TestFileList < Test::Unit::TestCase
 
   def test_to_s_pending
     fl = FileList['testdata/abc.*']
-    assert_equal  %{testdata/abc.c}, fl.to_s
+    assert_equal  %{testdata/abc.c testdata/abc.h testdata/abc.x}.sort, fl.to_s.sort
   end
 
   def test_inspect_pending
     fl = FileList['testdata/abc.*']
-    assert_equal  %{["testdata/abc.c"]}, fl.inspect
+    assert_equal  %{["testdata/abc.c", "testdata/abc.h", "testdata/abc.x"]}, fl.inspect
   end
 
   def test_sub
@@ -242,7 +272,22 @@ class TestFileList < Test::Unit::TestCase
       f2.sort
   end
 
-  def test_egrep
+  def test_gsub!
+    create_test_data
+    f = FileList["testdata/*.c"]
+    f.gsub!(/a/, "A")
+    assert_equal ["testdAtA/Abc.c", "testdAtA/x.c", "testdAtA/xyz.c"].sort,
+      f.sort
+  end
+
+  def test_egrep_with_output
+    files = FileList['test/test*.rb']
+    the_line_number = __LINE__ + 1
+    out = capture_stdout do files.egrep(/PUGH/) end
+    assert_match(/:#{the_line_number}:/, out)
+  end
+
+  def test_egrep_with_block
     files = FileList['test/test*.rb']
     found = false
     the_line_number = __LINE__ + 1
@@ -342,7 +387,7 @@ class TestFileList < Test::Unit::TestCase
     b = ['a', 'b']
     assert a == b
     assert b == a
-#    assert a.eql?(b)
+#   assert a.eql?(b)
 #    assert b.eql?(a)
     assert ! a.equal?(b)
     assert ! b.equal?(a)
@@ -473,6 +518,8 @@ class TestFileList < Test::Unit::TestCase
       touch "testdata/x.c"
       touch "testdata/xyz.c"
       touch "testdata/abc.c"
+      touch "testdata/abc.h"
+      touch "testdata/abc.x"
       touch "testdata/existing"
     end
   end

data/test/test_fileutils.rb

@@ -4,6 +4,7 @@ require 'rake'
 require 'test/unit'
 require 'test/filecreation'
 require 'fileutils'
+require 'stringio'
 
 class TestFileUtils < Test::Unit::TestCase
   include FileCreation
@@ -14,6 +15,7 @@ class TestFileUtils < Test::Unit::TestCase
   
   def teardown
     FileUtils.rm_rf("testdata")
+    FileUtils::LN_SUPPORTED[0] = true
   end
   
   def test_rm_one_file
@@ -45,12 +47,49 @@ class TestFileUtils < Test::Unit::TestCase
     assert_equal "TEST_LN\n", open("testdata/b") { |f| f.read }
   end
 
+  class BadLink
+    include RakeFileUtils
+    attr_reader :cp_args
+    def initialize(klass)
+      @failure_class = klass
+    end
+    def cp(*args)
+      @cp_args = args
+    end
+    def ln(*args)
+      fail @failure_class, "ln not supported"
+    end
+    public :safe_ln
+  end
+
+  def test_safe_ln_failover_to_cp_on_standard_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(StandardError)
+    c.safe_ln "a", "b"
+    assert_equal ['a', 'b'], c.cp_args
+    c.safe_ln "x", "y"
+    assert_equal ['x', 'y'], c.cp_args
+  end
+
+  def test_safe_ln_failover_to_cp_on_not_implemented_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(NotImplementedError)
+    c.safe_ln "a", "b"
+    assert_equal ['a', 'b'], c.cp_args
+  end
+
+  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
+  end
+
   def test_verbose
     verbose true
     assert_equal true, verbose
     verbose false
     assert_equal false, verbose
-    verbose(true){
+    verbose(true) {
       assert_equal true, verbose
     }
     assert_equal false, verbose
@@ -67,6 +106,18 @@ class TestFileUtils < Test::Unit::TestCase
     assert_equal false, nowrite
   end
 
+  def test_file_utils_methods_are_available_at_top_level
+    create_file("testdata/a")
+    rm_rf "testdata/a"
+    assert ! File.exist?("testdata/a")
+  end
+
+  def test_fileutils_methods_dont_leak
+    obj = Object.new
+    assert_raise(NoMethodError) { obj.copy } # from FileUtils
+    assert_raise(NoMethodError) { obj.ruby } # from RubyFileUtils
+  end
+
   def test_sh
     verbose(false) { sh %{test/shellcommand.rb} }
     assert true, "should not fail"
@@ -93,19 +144,47 @@ class TestFileUtils < Test::Unit::TestCase
     count = 0
     verbose(false) {
       sh(%{test/shellcommand.rb}) do |ok, res|
-	assert(ok)
-	assert_equal 0, res.exitstatus
-	count += 1
+        assert(ok)
+        assert_equal 0, res.exitstatus
+        count += 1
       end
       sh(%{test/shellcommand.rb 1}) do |ok, res|
-	assert(!ok)
-	assert_equal 1, res.exitstatus
-	count += 1
+        assert(!ok)
+        assert_equal 1, res.exitstatus
+        count += 1
       end
     }
     assert_equal 2, count, "Block count should be 2"
   end
 
+  def test_sh_noop
+    verbose(false) { sh %{test/shellcommand.rb 1}, :noop=>true }
+    assert true, "should not fail"
+  end
+
+  def test_sh_bad_option
+    ex = assert_raise(ArgumentError) {
+      verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
+    }
+    assert_match(/bad_option/, ex.message)
+  end
+
+  def test_sh_verbose
+    out = redirect_stderr {
+      verbose(true) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
+    }
+    assert_match(/^test\/shellcommand\.rb$/, out)
+  end
+
+  def test_sh_default_verbosity_is_false
+    out = redirect_stderr {
+      sh %{test/shellcommand.rb}, :noop=>true
+    }
+    assert_equal '', out
+  end
+
   def test_ruby
     verbose(false) do
       ENV['RAKE_TEST_RUBY'] = "123"
@@ -114,7 +193,7 @@ class TestFileUtils < Test::Unit::TestCase
       ruby %{-e "exit $RAKE_TEST_RUBY"} do |ok, status|
         assert(!ok)
         assert_equal 123, status.exitstatus
-	block_run = true
+        block_run = true
       end
       assert block_run, "The block must be run"
 
@@ -123,10 +202,29 @@ class TestFileUtils < Test::Unit::TestCase
       ruby '-e', 'exit "$RAKE_TEST_RUBY".length' do |ok, status|
         assert(!ok)
         assert_equal 15, status.exitstatus
-	block_run = true
+        block_run = true
       end
       assert block_run, "The block must be run"
     end
   end
 
+  def test_split_all
+    assert_equal ['a'], RakeFileUtils.split_all('a')
+    assert_equal ['..'], RakeFileUtils.split_all('..')
+    assert_equal ['/'], RakeFileUtils.split_all('/')
+    assert_equal ['a', 'b'], RakeFileUtils.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], RakeFileUtils.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], RakeFileUtils.split_all('../a/b')
+  end
+
+  private
+  
+  def redirect_stderr
+    old_err = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = old_err
+  end
 end

data/test/test_namespace.rb

@@ -6,19 +6,27 @@ require 'flexmock'
 require 'rake'
 
 class TestNameSpace < Test::Unit::TestCase
+  include FlexMock::TestCase
+
   def test_namespace_creation
-    FlexMock.use("TaskManager") do |mgr|
-      ns = Rake::NameSpace.new(mgr, [])
-      assert_not_nil ns
-    end
+    mgr = flexmock("TaskManager")
+    ns = Rake::NameSpace.new(mgr, [])
+    assert_not_nil ns
   end
 
   def test_namespace_lookup
-    FlexMock.use("TaskManager") do |mgr|
-      mgr.should_receive(:lookup).with(:t, ["a"]).
-	and_return(nil).once
-      ns = Rake::NameSpace.new(mgr, ["a"])
-      ns[:t]
-    end
+    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]
+  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
   end
 end

data/test/test_package_task.rb

@@ -10,13 +10,13 @@ class TestPackageTask < Test::Unit::TestCase
     pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
       p.package_files << "install.rb"
       p.package_files.include(
-	'[A-Z]*',
-	'bin/**/*',
-	'lib/**/*.rb',
-	'test/**/*.rb',
-	'doc/**/*',
-	'build/rubyapp.rb',
-	'*.blurb')
+        '[A-Z]*',
+        'bin/**/*',
+        'lib/**/*.rb',
+        'test/**/*.rb',
+        'doc/**/*',
+        'build/rubyapp.rb',
+        '*.blurb')
       p.package_files.exclude(/\bCVS\b/)
       p.package_files.exclude(/~$/)
       p.package_dir = 'pkg'
@@ -74,12 +74,12 @@ else
   class TestGemPackageTask < Test::Unit::TestCase
     def test_gem_package
       gem = Gem::Specification.new do |g|
-	g.name = "pkgr"
-	g.version = "1.2.3"
-	g.files = FileList["x"].resolve
+        g.name = "pkgr"
+        g.version = "1.2.3"
+        g.files = FileList["x"].resolve
       end
       pkg = Rake::GemPackageTask.new(gem)  do |p|
-	p.package_files << "y"
+        p.package_files << "y"
       end
       assert_equal ["x", "y"], pkg.package_files
       assert_equal "pkgr-1.2.3.gem", pkg.gem_file
@@ -87,13 +87,13 @@ else
 
     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
+        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"
+        p.package_files << "y"
       end
       assert_equal ["x", "y"], pkg.package_files
       assert_equal "pkgr-1.2.3-mswin32.gem", pkg.gem_file
@@ -101,13 +101,13 @@ else
 
     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
+        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"
+        p.package_files << "y"
       end
       assert_equal ["x", "y"], pkg.package_files
       assert_match(/^pkgr-1\.2\.3-(\S+)\.gem$/, pkg.gem_file)
@@ -115,13 +115,13 @@ else
 
     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
+        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"
+        p.package_files << "y"
       end
       assert_equal ["x", "y"], pkg.package_files
       assert_equal "pkgr-1.2.3.gem", pkg.gem_file