rake 0.8.7 → 0.9.0.beta.0

data/test/{test_clean.rb → lib/clean_test.rb}

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'test/unit'
+require 'rake'
 require 'rake/clean'
 
 class TestClean < Test::Unit::TestCase

data/test/{test_definitions.rb → lib/definitions_test.rb}

@@ -10,7 +10,7 @@ require 'test/rake_test_setup'
 class TestDefinitions < Test::Unit::TestCase
   include Rake
   include TestMethods
-  
+
   EXISTINGFILE = "testdata/existing"
 
   def setup
@@ -82,4 +82,4 @@ class TestDefinitions < Test::Unit::TestCase
   end
 
 end
-  
+

data/test/lib/dsl_test.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # got no gems
+end
+
+require 'test/unit'
+require 'flexmock/test_unit'
+require 'rake'
+require 'test/rake_test_setup'
+
+class DslTest < Test::Unit::TestCase
+
+  def test_namespace_command
+    namespace "n" do
+      task "t"
+    end
+    assert_not_nil Rake::Task["n:t"]
+  end
+
+  def test_namespace_command_with_bad_name
+    ex = assert_raise(ArgumentError) do
+      namespace 1 do end
+    end
+    assert_match(/string/i, ex.message)
+    assert_match(/symbol/i, ex.message)
+  end
+
+  def test_namespace_command_with_a_string_like_object
+    name = Object.new
+    def name.to_str
+      "bob"
+    end
+    namespace name do
+      task "t"
+    end
+    assert_not_nil Rake::Task["bob:t"]
+  end
+
+  def test_dsl_not_toplevel_by_default
+    actual = TOPLEVEL_BINDING.instance_eval { defined?(task) }
+    assert_nil actual
+  end
+
+  def test_dsl_toplevel_when_require_rake_dsl
+    assert_nothing_raised {
+      ruby '-I./lib', '-rrake/dsl', '-e', 'task(:x) { }', :verbose => false
+    }
+  end
+end

data/test/{test_earlytime.rb → lib/earlytime_test.rb}

@@ -6,7 +6,6 @@ require 'rake'
 class TestEarlyTime < Test::Unit::TestCase
   def test_create
     early = Rake::EarlyTime.instance
-    time = Time.mktime(1970, 1, 1, 0, 0, 0)
     assert early <= Time.now
     assert early < Time.now
     assert early != Time.now
@@ -26,7 +25,7 @@ class TestEarlyTime < Test::Unit::TestCase
     assert t1 < t2
     assert t2 > t1
     assert t1 == t1
-    assert t2 == t2    
+    assert t2 == t2
   end
 
   def test_to_s

data/test/lib/environment_test.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'test/test_helper'
+require 'rake/environment'
+
+class TestEnvironment < Test::Unit::TestCase
+  def test_load_string
+    Rake::Task.clear
+    Rake::Environment.load_string("task :xyz")
+    assert Rake::Task[:xyz], "should have a task named xyz"
+  end
+
+  def test_load_rakefile
+    Rake::Task.clear
+    Rake::Environment.load_rakefile("test/data/default/Rakefile")
+    assert Rake::Task[:default], "Should have a default task"
+  end
+end

data/test/{test_extension.rb → lib/extension_test.rb}

@@ -18,14 +18,14 @@ class TestExtension < Test::Unit::TestCase
       $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

data/test/{test_file_task.rb → lib/file_task_test.rb}

@@ -77,7 +77,7 @@ class TestFileTask < Test::Unit::TestCase
   # 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 
+    task :obj
     file NEWFILE => [:obj] do |t|
       FileUtils.touch NEWFILE
       fail "Ooops"
@@ -97,11 +97,11 @@ class TestDirectoryTask < Test::Unit::TestCase
   include Rake
 
   def setup
-    rm_rf "testdata", :verbose=>false
+    Rake.rm_rf "testdata", :verbose=>false
   end
 
   def teardown
-    rm_rf "testdata", :verbose=>false
+    Rake.rm_rf "testdata", :verbose=>false
   end
 
   def test_directory

data/test/{test_filelist.rb → lib/filelist_test.rb}

@@ -20,7 +20,7 @@ class TestFileList < Test::Unit::TestCase
     FileUtils.rm_rf("testdata")
   end
 
-  def test_delgating_methods_do_not_include_to_a_or_to_ary
+  def test_delegating_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"
@@ -87,11 +87,11 @@ class TestFileList < Test::Unit::TestCase
     h = f.include("y")
     assert_equal f.object_id, h.object_id
   end
-  
+
   def test_match
     fl = FileList.new
-    fl.include('test/test*.rb')
-    assert fl.include?("test/test_filelist.rb")
+    fl.include('test/lib/*_test.rb')
+    assert fl.include?("test/lib/filelist_test.rb")
     assert fl.size > 3
     fl.each { |fn| assert_match(/\.rb$/, fn) }
   end
@@ -99,10 +99,10 @@ class TestFileList < Test::Unit::TestCase
   def test_add_matching
     fl = FileList.new
     fl << "a.java"
-    fl.include("test/*.rb")
+    fl.include("test/lib/*.rb")
     assert_equal "a.java", fl[0]
     assert fl.size > 2
-    assert fl.include?("test/test_filelist.rb")
+    assert fl.include?("test/lib/filelist_test.rb")
   end
 
   def test_multiple_patterns
@@ -153,7 +153,7 @@ class TestFileList < Test::Unit::TestCase
     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' }
@@ -233,24 +233,24 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ["testdata/abc.o", "testdata/x.o", "testdata/xyz.o"].sort,
       f3.sort
   end
-  
+
   def test_claim_to_be_a_kind_of_array
     fl = FileList['testdata/*.c']
     assert fl.is_a?(Array)
     assert fl.kind_of?(Array)
   end
-  
+
   def test_claim_to_be_a_kind_of_filelist
     fl = FileList['testdata/*.c']
     assert fl.is_a?(FileList)
     assert fl.kind_of?(FileList)
   end
-  
+
   def test_claim_to_be_a_filelist_instance
     fl = FileList['testdata/*.c']
     assert fl.instance_of?(FileList)
   end
-  
+
   def test_dont_claim_to_be_an_array_instance
     fl = FileList['testdata/*.c']
     assert ! fl.instance_of?(Array)
@@ -323,24 +323,28 @@ class TestFileList < Test::Unit::TestCase
       f.sort
   end
 
+  def test_egrep_returns_0_if_no_matches
+    files = FileList['test/lib/*_test.rb'].exclude("test/lib/filelist_test.rb")
+    assert_equal 0, files.egrep(/XYZZY/) { }
+  end
+
   def test_egrep_with_output
-    files = FileList['test/test*.rb']
+    files = FileList['test/lib/*_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
+    files = FileList['test/lib/*_test.rb']
+    found = nil
     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
+      found = [fn, ln, line]
     end
-    assert found, "should have found a matching line"
+    assert_equal 'test/lib/filelist_test.rb', found[0]
+    assert_equal the_line_number, found[1]
+    assert_match(/files\.egrep/, found[2])
   end
 
   def test_existing
@@ -588,12 +592,12 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ['b', 'd'], r
     assert_equal FileList, r.class
   end
-  
+
   def test_file_utils_can_use_filelists
     cfiles = FileList['testdata/*.c']
-    
+
     cp cfiles, @cdir, :verbose => false
-    
+
     assert File.exist?(File.join(@cdir, 'abc.c'))
     assert File.exist?(File.join(@cdir, 'xyz.c'))
     assert File.exist?(File.join(@cdir, 'x.c'))
@@ -601,7 +605,7 @@ class TestFileList < Test::Unit::TestCase
 
   def create_test_data
     verbose(false) do
-      
+
       mkdir "testdata" unless File.exist? "testdata"
       mkdir "testdata/CVS" rescue nil
       mkdir "testdata/.svn" rescue nil
@@ -619,5 +623,5 @@ class TestFileList < Test::Unit::TestCase
       touch "testdata/existing"
     end
   end
-  
+
 end

data/test/{test_fileutils.rb → lib/fileutils_test.rb}

@@ -10,16 +10,18 @@ require 'test/rake_test_setup'
 class TestFileUtils < Test::Unit::TestCase
   include FileCreation
   include TestMethods
+  include Rake::DSL
 
   def setup
-    File.chmod(0750,"test/shellcommand.rb")
+    File.chmod(0750, "test/shellcommand.rb")
   end
-  
+
   def teardown
+    File.chmod(0755, "test/shellcommand.rb")
     FileUtils.rm_rf("testdata")
     FileUtils::LN_SUPPORTED[0] = true
   end
-  
+
   def test_rm_one_file
     create_file("testdata/a")
     FileUtils.rm_rf "testdata/a"
@@ -45,12 +47,12 @@ class TestFileUtils < Test::Unit::TestCase
   def test_ln
     create_dir("testdata")
     open("testdata/a", "w") { |f| f.puts "TEST_LN" }
-    RakeFileUtils.safe_ln("testdata/a", "testdata/b", :verbose => false)
+    Rake::FileUtilsExt.safe_ln("testdata/a", "testdata/b", :verbose => false)
     assert_equal "TEST_LN\n", open("testdata/b") { |f| f.read }
   end
 
   class BadLink
-    include RakeFileUtils
+    include Rake::FileUtilsExt
     attr_reader :cp_args
     def initialize(klass)
       @failure_class = klass
@@ -117,11 +119,11 @@ class TestFileUtils < Test::Unit::TestCase
   def test_fileutils_methods_dont_leak
     obj = Object.new
     assert_exception(NoMethodError) { obj.copy } # from FileUtils
-    assert_exception(NoMethodError) { obj.ruby } # from RubyFileUtils
+    assert_exception(NoMethodError) { obj.ruby "-v" } # from RubyFileUtils
   end
 
   def test_sh
-    verbose(false) { sh %{ruby test/shellcommand.rb} }
+    verbose(false) { sh %{#{FileUtils::RUBY} test/shellcommand.rb} }
     assert true, "should not fail"
   end
 
@@ -137,37 +139,40 @@ class TestFileUtils < Test::Unit::TestCase
     def self.run(*args)
       new.run(*args)
     end
+    def self.ruby(*args)
+      Sh.run(RUBY, *args)
+    end
   end
 
   def test_sh_with_a_single_string_argument
     ENV['RAKE_TEST_SH'] = 'someval'
     verbose(false) {
-      sh %{ruby test/check_expansion.rb #{env_var} someval}
+      sh %{#{FileUtils::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'
+      Sh.ruby 'test/check_no_expansion.rb', env_var, 'someval'
     }
   end
 
   def test_sh_failure
-    assert_exception(RuntimeError) { 
-      verbose(false) { Sh.run %{ruby test/shellcommand.rb 1} }
+    assert_exception(RuntimeError) {
+      verbose(false) { Sh.run %{#{FileUtils::RUBY} test/shellcommand.rb 1} }
     }
   end
 
   def test_sh_special_handling
     count = 0
     verbose(false) {
-      sh(%{ruby test/shellcommand.rb}) do |ok, res|
+      sh(%{#{FileUtils::RUBY} test/shellcommand.rb}) do |ok, res|
         assert(ok)
         assert_equal 0, res.exitstatus
         count += 1
       end
-      sh(%{ruby test/shellcommand.rb 1}) do |ok, res|
+      sh(%{#{FileUtils::RUBY} test/shellcommand.rb 1}) do |ok, res|
         assert(!ok)
         assert_equal 1, res.exitstatus
         count += 1
@@ -221,16 +226,16 @@ class TestFileUtils < Test::Unit::TestCase
   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')
+    assert_equal ['a'], Rake::FileUtilsExt.split_all('a')
+    assert_equal ['..'], Rake::FileUtilsExt.split_all('..')
+    assert_equal ['/'], Rake::FileUtilsExt.split_all('/')
+    assert_equal ['a', 'b'], Rake::FileUtilsExt.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], Rake::FileUtilsExt.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], Rake::FileUtilsExt.split_all('../a/b')
   end
 
   private
-  
+
   def redirect_stderr
     old_err = $stderr
     $stderr = StringIO.new
@@ -247,5 +252,5 @@ class TestFileUtils < Test::Unit::TestCase
   def env_var
     windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
   end
-  
+
 end

data/test/{test_multitask.rb → lib/multitask_test.rb}

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'test/unit'
+require 'thread'
 require 'rake'
 
 ######################################################################
@@ -10,11 +11,18 @@ class TestMultiTask < Test::Unit::TestCase
   def setup
     Task.clear
     @runs = Array.new
+    @mutex = Mutex.new
+  end
+
+  def add_run(obj)
+    @mutex.synchronize do
+      @runs << obj
+    end
   end
 
   def test_running_multitasks
-    task :a do 3.times do |i| @runs << "A#{i}"; sleep 0.01; end end
-    task :b do 3.times do |i| @runs << "B#{i}"; sleep 0.01;  end end
+    task :a do 3.times do |i| add_run("A#{i}"); sleep 0.01; end end
+    task :b do 3.times do |i| add_run("B#{i}"); sleep 0.01;  end end
     multitask :both => [:a, :b]
     Task[:both].invoke
     assert_equal 6, @runs.size
@@ -25,9 +33,9 @@ class TestMultiTask < Test::Unit::TestCase
   end
 
   def test_all_multitasks_wait_on_slow_prerequisites
-    task :slow do 3.times do |i| @runs << "S#{i}"; sleep 0.05 end end
-    task :a => [:slow] do 3.times do |i| @runs << "A#{i}"; sleep 0.01 end end
-    task :b => [:slow] do 3.times do |i| @runs << "B#{i}"; sleep 0.01 end end
+    task :slow do 3.times do |i| add_run("S#{i}"); sleep 0.05 end end
+    task :a => [:slow] do 3.times do |i| add_run("A#{i}"); sleep 0.01 end end
+    task :b => [:slow] do 3.times do |i| add_run("B#{i}"); sleep 0.01 end end
     multitask :both => [:a, :b]
     Task[:both].invoke
     assert_equal 9, @runs.size
@@ -42,4 +50,4 @@ class TestMultiTask < Test::Unit::TestCase
   end
 end
 
- 
+