rake 0.8.1 → 0.8.2

data/test/test_earlytime.rb

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

data/test/test_filelist.rb

@@ -204,12 +204,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
@@ -403,12 +411,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_raise(TypeError, RuntimeError) do
+      c << 'more'
+    end
   end
 
   def test_array_comparisons

data/test/test_fileutils.rb

@@ -119,36 +119,37 @@ class TestFileUtils < Test::Unit::TestCase
   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
     ENV['RAKE_TEST_SH'] = 'someval'
+    expanded = windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
     # This one gets expanded by the shell
-    verbose(false) { sh %{test $RAKE_TEST_SH = someval} }
+    verbose(false) { sh %{ruby test/check_expansion.rb #{expanded} 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', expanded, 'someval' }
     }
   end
 
   def test_sh_failure
     assert_raises(RuntimeError) { 
-      verbose(false) { sh %{test/shellcommand.rb 1} }
+      verbose(false) { sh %{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
@@ -178,7 +179,16 @@ 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 {
+      verbose(false) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
+    }
+    assert_equal '', out
+  end
+
+  def test_sh_default_is_no_verbose
     out = redirect_stderr {
       sh %{test/shellcommand.rb}, :noop=>true
     }
@@ -190,21 +200,26 @@ class TestFileUtils < Test::Unit::TestCase
       ENV['RAKE_TEST_RUBY'] = "123"
       block_run = false
       # This one gets expanded by the shell
-      ruby %{-e "exit $RAKE_TEST_RUBY"} do |ok, status|
+      env_var = windows? ? '%RAKE_TEST_RUBY%' : '$RAKE_TEST_RUBY'
+      ruby %{-e "exit #{env_var}"} do |ok, status| # " (emacs wart)
         assert(!ok)
         assert_equal 123, status.exitstatus
         block_run = true
       end
       assert block_run, "The block must be run"
 
-      # 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
+      if windows?
+        puts "SKIPPING test_ruby/part 2 when in windows"
+      else
+        # This one does not get expanded
+        block_run = false
+        ruby '-e', %{exit "#{env_var}".length} do |ok, status| # " (emacs wart)
+          assert(!ok)
+          assert_equal 15, status.exitstatus
+          block_run = true
+        end
+        assert block_run, "The block must be run"
       end
-      assert block_run, "The block must be run"
     end
   end
 
@@ -227,4 +242,9 @@ class TestFileUtils < Test::Unit::TestCase
   ensure
     $stderr = old_err
   end
+
+  def windows?
+    ! File::ALT_SEPARATOR.nil?
+  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,8 @@ 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 6, Task.tasks.size
   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_rules.rb

@@ -222,6 +222,22 @@ class TestRules < Test::Unit::TestCase
     assert_equal [], @runs
   end
 
+  def test_rule_with_two_sources_builds_both_sources
+    task 'x.aa'
+    task 'x.bb'
+    rule '.a' => '.aa' do
+      @runs << "A"
+    end
+    rule '.b' => '.bb' do
+      @runs << "B"
+    end
+    rule ".c" => ['.a', '.b'] do
+      @runs << "C"
+    end
+    Task["x.c"].invoke
+    assert_equal ["A", "B", "C"], @runs.sort
+  end
+
   def test_second_rule_runs_when_first_rule_doesnt
     create_timed_files(OBJFILE, SRCFILE)
     delete_file(SRCFILE2)

data/test/test_task_arguments.rb

@@ -61,7 +61,7 @@ class TestTaskArguments < Test::Unit::TestCase
   def test_creating_new_argument_scopes
     parent = Rake::TaskArguments.new(['p'], [1])
     child = parent.new_scope(['c', 'p'])
-    assert_equal({:c => nil, :p=>1}, child.to_hash)
+    assert_equal({:p=>1}, child.to_hash)
     assert_equal 1, child.p
     assert_equal 1, child["p"]
     assert_equal 1, child[:p]
@@ -73,4 +73,17 @@ class TestTaskArguments < Test::Unit::TestCase
     child = Rake::TaskArguments.new(['aa'], [2], parent)
     assert_equal 2, child.aa
   end
+  
+  def test_default_arguments_values_can_be_merged
+    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
+    ta.with_defaults({ :aa => 'default_val' })
+    assert_equal 'default_val', ta[:aa]
+    assert_equal 'original_val', ta[:bb]
+  end
+
+  def test_default_arguements_that_dont_match_names_are_ignored
+    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
+    ta.with_defaults({ "cc" => "default_val" })
+    assert_nil ta[:cc]
+  end
 end

data/test/test_task_manager.rb

@@ -53,7 +53,7 @@ class TestTaskManager < Test::Unit::TestCase
     assert_equal ["fn"], @tm.tasks.collect { |t| t.name }
   end
 
-  def testS_namespace_yields_same_namespace_as_returned
+  def test_namespace_yields_same_namespace_as_returned
     yielded_namespace = nil
     returned_namespace = @tm.in_namespace("x") do |ns|
       yielded_namespace = ns
@@ -146,3 +146,25 @@ class TestTaskManager < Test::Unit::TestCase
   end
   
 end
+
+class TestTaskManagerArgumentResolution < Test::Unit::TestCase
+  def test_good_arg_patterns
+    assert_equal [:t, [], []],       task(:t)
+    assert_equal [:t, [], [:x]],     task(:t => :x)
+    assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y])
+
+    assert_equal [:t, [:a, :b], []],       task(:t, :a, :b)
+    assert_equal [:t, [], [:x]],           task(:t, :needs => :x)
+    assert_equal [:t, [:a, :b], [:x]],     task(:t, :a, :b, :needs => :x)
+    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, :a, :b, :needs => [:x, :y])
+
+    assert_equal [:t, [:a, :b], []],       task(:t, [:a, :b])
+    assert_equal [:t, [:a, :b], [:x]],     task(:t, [:a, :b] => :x)
+    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y])
+  end
+
+  def task(*args)
+    tm = TaskManager.new
+    tm.resolve_args(args)
+  end
+end

data/test/test_tasklib.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/tasklib'
+
+
+class TestTaskLib < Test::Unit::TestCase
+  def test_paste
+    tl = Rake::TaskLib.new
+    assert_equal :ab, tl.paste(:a, :b)
+  end
+end

data/test/test_tasks.rb

@@ -6,20 +6,10 @@ require 'rake'
 require 'test/filecreation'
 require 'test/capture_stdout'
 
-
-module Interning
-  private
-
-  def intern(name, *args)
-    Rake.application.define_task(Rake::Task, name, *args)
-  end
-end
-
 ######################################################################
 class TestTask < Test::Unit::TestCase
   include CaptureStdout
   include Rake
-  include Interning
 
   def setup
     Task.clear
@@ -27,10 +17,9 @@ class TestTask < Test::Unit::TestCase
 
   def test_create
     arg = nil
-    t = intern(:name).enhance { |task| arg = task; 1234 }
+    t = task(:name) { |task| arg = task; 1234 }
     assert_equal "name", t.name
     assert_equal [], t.prerequisites
-    assert t.prerequisites.is_a?(FileList)
     assert t.needed?
     t.execute(0)
     assert_equal t, arg
@@ -39,26 +28,26 @@ class TestTask < Test::Unit::TestCase
   end
 
   def test_inspect
-    t = intern(:foo).enhance([:bar, :baz])
+    t = task(:foo, :needs => [:bar, :baz])
     assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
   end
 
   def test_invoke
     runlist = []
-    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
-    t2 = intern(:t2).enhance { |t| runlist << t.name }
-    t3 = intern(:t3).enhance { |t| runlist << t.name }
-    assert_equal [:t2, :t3], t1.prerequisites
+    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = task(:t2) { |t| runlist << t.name }
+    t3 = task(:t3) { |t| runlist << t.name }
+    assert_equal ["t2", "t3"], t1.prerequisites
     t1.invoke
     assert_equal ["t2", "t3", "t1"], runlist
   end
 
   def test_invoke_with_circular_dependencies
     runlist = []
-    t1 = intern(:t1).enhance([:t2]) { |t| runlist << t.name; 3321 }
-    t2 = intern(:t2).enhance([:t1]) { |t| runlist << t.name }
-    assert_equal [:t2], t1.prerequisites
-    assert_equal [:t1], t2.prerequisites
+    t1 = task(:t1 => [:t2]) { |t| runlist << t.name; 3321 }
+    t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
+    assert_equal ["t2"], t1.prerequisites
+    assert_equal ["t1"], t2.prerequisites
     ex = assert_raise RuntimeError do
       t1.invoke
     end
@@ -69,7 +58,7 @@ class TestTask < Test::Unit::TestCase
   def test_dry_run_prevents_actions
     Rake.application.options.dryrun = true
     runlist = []
-    t1 = intern(:t1).enhance { |t| runlist << t.name; 3321 }
+    t1 = task(:t1) { |t| runlist << t.name; 3321 }
     out = capture_stdout { t1.invoke }
     assert_match(/execute .*t1/i, out)
     assert_match(/dry run/i, out)
@@ -81,7 +70,7 @@ class TestTask < Test::Unit::TestCase
 
   def test_tasks_can_be_traced
     Rake.application.options.trace = true
-    t1 = intern(:t1) { |t| runlist << t.name; 3321 }
+    t1 = task(:t1)
     out = capture_stdout {
       t1.invoke
     }
@@ -93,13 +82,42 @@ class TestTask < Test::Unit::TestCase
 
   def test_no_double_invoke
     runlist = []
-    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
-    t2 = intern(:t2).enhance([:t3]) { |t| runlist << t.name }
-    t3 = intern(:t3).enhance { |t| runlist << t.name }
+    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = task(:t2 => [:t3]) { |t| runlist << t.name }
+    t3 = task(:t3) { |t| runlist << t.name }
     t1.invoke
     assert_equal ["t3", "t2", "t1"], runlist
   end
 
+  def test_can_double_invoke_with_reenable
+    runlist = []
+    t1 = task(:t1) { |t| runlist << t.name }
+    t1.invoke
+    t1.reenable
+    t1.invoke
+    assert_equal ["t1", "t1"], runlist
+  end
+
+  def test_clear
+    t = task("t" => "a") { }
+    t.clear
+    assert t.prerequisites.empty?, "prerequisites should be empty"
+    assert t.actions.empty?, "actions should be empty"
+  end
+
+  def test_clear_prerequisites
+    t = task("t" => ["a", "b"])
+    assert_equal ['a', 'b'], t.prerequisites
+    t.clear_prerequisites
+    assert_equal [], t.prerequisites
+  end
+
+  def test_clear_actions
+    t = task("t") { }
+    t.clear_actions
+    assert t.actions.empty?, "actions should be empty"
+  end
+
   def test_find
     task :tfind
     assert_equal "tfind", Task[:tfind].name
@@ -155,9 +173,9 @@ class TestTask < Test::Unit::TestCase
   end
 
   def test_investigation_output
-    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
-    intern(:t2)
-    intern(:t3)
+    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
+    task(:t2)
+    task(:t3)
     out = t1.investigation
     assert_match(/class:\s*Rake::Task/, out)
     assert_match(/needed:\s*true/, out)
@@ -173,7 +191,7 @@ class TestTask < Test::Unit::TestCase
       name -- Name of task to execute.
       rev  -- Software revision to use.
     }
-    t = intern(:t, :name, :rev)
+    t = task(:t, :name, :rev)
     assert_equal "[name,rev]", t.arg_description
     assert_equal "This is a comment.", t.comment
     assert_match(/^\s*name -- Name/, t.full_comment)
@@ -183,14 +201,14 @@ class TestTask < Test::Unit::TestCase
 
   def test_multiple_comments
     desc "line one"
-    t = intern(:t)
+    t = task(:t)
     desc "line two"
-    intern(:t)
+    task(:t)
     assert_equal "line one / line two", t.comment
   end
 
   def test_settable_comments
-    t = intern(:t)
+    t = task(:t)
     t.comment = "HI"
     assert_equal "HI", t.comment
   end
@@ -200,7 +218,6 @@ end
 class TestTaskWithArguments < Test::Unit::TestCase
   include CaptureStdout
   include Rake
-  include Interning
 
   def setup
     Task.clear
@@ -244,9 +261,7 @@ class TestTaskWithArguments < Test::Unit::TestCase
   end
 
   def test_arg_list_is_empty_if_no_args_given
-    t = intern(:t).enhance do |tt, args|
-      assert_equal({}, args.to_hash)
-    end
+    t = task(:t) { |tt, args| assert_equal({}, args.to_hash) }
     t.invoke(1, 2, 3)
   end
 
@@ -265,7 +280,7 @@ class TestTaskWithArguments < Test::Unit::TestCase
 
   def test_actions_of_various_arity_are_ok_with_args
     notes = []
-    t = intern(:t, :x).enhance do
+    t = task(:t, :x) do
       notes << :a
     end
     t.enhance do | |
@@ -285,16 +300,16 @@ class TestTaskWithArguments < Test::Unit::TestCase
   end
 
   def test_arguments_are_passed_to_block
-    t = intern(:t, :a, :b).enhance { |tt, args|
+    t = task(:t, :a, :b) { |tt, args|
       assert_equal( { :a => 1, :b => 2 }, args.to_hash )
     }
     t.invoke(1, 2)
   end
 
   def test_extra_parameters_are_ignored
-    t = intern(:t, :a).enhance { |tt, args|
+    t = task(:t, :a) { |tt, args|
       assert_equal 1, args.a
-      assert_nil args[2]
+      assert_nil args.b
     }
     t.invoke(1, 2)
   end
@@ -315,13 +330,13 @@ class TestTaskWithArguments < Test::Unit::TestCase
   end
 
   def test_block_with_no_parameters_is_ok
-    t = intern(:t).enhance { }
+    t = task(:t) { }
     t.invoke(1, 2)
   end
 
   def test_name_with_args
     desc "T"
-    t = intern(:tt, :a, :b)
+    t = task(:tt, :a, :b)
     assert_equal "tt", t.name
     assert_equal "T", t.comment
     assert_equal "[a,b]", t.arg_description
@@ -331,26 +346,26 @@ class TestTaskWithArguments < Test::Unit::TestCase
 
   def test_named_args_are_passed_to_prereqs
     value = nil
-    pre = intern(:pre, :rev).enhance { |t, args| value = args.rev }
-    t = intern(:t, :name, :rev).enhance([:pre])
+    pre = task(:pre, :rev) { |t, args| value = args.rev }
+    t = task(:t, :name, :rev, :needs => [:pre])
     t.invoke("bill", "1.2")
     assert_equal "1.2", value
   end
 
   def test_args_not_passed_if_no_prereq_names
-    pre = intern(:pre).enhance { |t, args|
+    pre = task(:pre) { |t, args|
       assert_equal({}, args.to_hash)
       assert_equal "bill", args.name
     }
-    t = intern(:t, :name, :rev).enhance([:pre])
+    t = task(:t, :name, :rev, :needs => [:pre])
     t.invoke("bill", "1.2")
   end
 
   def test_args_not_passed_if_no_arg_names
-    pre = intern(:pre, :rev).enhance { |t, args|
-      assert_equal({ :rev => nil }, args.to_hash)
+    pre = task(:pre, :rev) { |t, args|
+      assert_equal({}, args.to_hash)
     }
-    t = intern(:t).enhance([:pre])
+    t = task(:t, :needs => [:pre])
     t.invoke("bill", "1.2")
   end
 end