rake 0.8.0 → 0.8.7

data/test/test_rules.rb

@@ -4,11 +4,13 @@ require 'test/unit'
 require 'fileutils'
 require 'rake'
 require 'test/filecreation'
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestRules < Test::Unit::TestCase
   include Rake
   include FileCreation
+  include TestMethods
 
   SRCFILE  = "testdata/abc.c"
   SRCFILE2 =  "testdata/xyz.c"
@@ -23,7 +25,7 @@ class TestRules < Test::Unit::TestCase
   end
 
   def teardown
-    FileList['testdata/*'].each do |f| rm_r(f, :verbose=>false) end
+    FileList['testdata/*'].uniq.each do |f| rm_r(f, :verbose=>false) end
   end
 
   def test_multiple_rules1
@@ -190,8 +192,8 @@ class TestRules < Test::Unit::TestCase
     rule '.o' => ['.c'] do |t|
       @runs << t.name
     end
-    assert_raises(RuntimeError) { Task['testdata/x.obj'].invoke }
-    assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
+    assert_exception(RuntimeError) { Task['testdata/x.obj'].invoke }
+    assert_exception(RuntimeError) { Task['testdata/x.xyo'].invoke }
   end
 
   def test_rule_rebuilds_obj_when_source_is_newer
@@ -222,6 +224,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)
@@ -261,7 +279,7 @@ class TestRules < Test::Unit::TestCase
 
   def test_rule_with_proc_dependent_will_trigger
     ran = false
-    File.makedirs("testdata/src/jw")
+    mkdir_p("testdata/src/jw")
     create_file("testdata/src/jw/X.java")
     rule %r(classes/.*\.class) => [
       proc { |fn| fn.pathmap("%{classes,testdata/src}d/%n.java") }
@@ -278,7 +296,7 @@ class TestRules < Test::Unit::TestCase
 
   def test_proc_returning_lists_are_flattened_into_prereqs
     ran = false
-    File.makedirs("testdata/flatten")
+    mkdir_p("testdata/flatten")
     create_file("testdata/flatten/a.txt")
     task 'testdata/flatten/b.data' do |t|
       ran = true
@@ -316,7 +334,7 @@ class TestRules < Test::Unit::TestCase
       rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end
       prev = letter
     end
-    ex = assert_raises(Rake::RuleRecursionOverflowError) {
+    ex = assert_exception(Rake::RuleRecursionOverflowError) {
       Task["testdata/a.z"].invoke
     }
     assert_match(/a\.z => testdata\/a.y/, ex.message)
@@ -324,7 +342,7 @@ class TestRules < Test::Unit::TestCase
 
   def test_rules_with_bad_dependents_will_fail
     rule "a" => [ 1 ] do |t| puts t.name end
-    assert_raise(RuntimeError) do Task['a'].invoke end
+    assert_exception(RuntimeError) do Task['a'].invoke end
   end
 
 end

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

@@ -2,12 +2,15 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 class TaskManager
   include Rake::TaskManager
 end
 
 class TestTaskManager < Test::Unit::TestCase
+  include TestMethods
+
   def setup
     @tm = TaskManager.new
   end
@@ -53,7 +56,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
@@ -68,7 +71,7 @@ class TestTaskManager < Test::Unit::TestCase
   end
 
   def test_name_lookup_with_nonexistent_task
-    assert_raise(RuntimeError) {
+    assert_exception(RuntimeError) {
       t = @tm["DOES NOT EXIST"]
     }
   end
@@ -146,3 +149,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

@@ -5,21 +5,13 @@ require 'fileutils'
 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
+require 'test/rake_test_setup'
 
 ######################################################################
 class TestTask < Test::Unit::TestCase
   include CaptureStdout
   include Rake
-  include Interning
+  include TestMethods
 
   def setup
     Task.clear
@@ -27,10 +19,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,27 +30,27 @@ 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
-    ex = assert_raise RuntimeError do
+    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_exception RuntimeError do
       t1.invoke
     end
     assert_match(/circular dependency/i, ex.message)
@@ -69,7 +60,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 +72,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,17 +84,46 @@ 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
-    ex = assert_raises(RuntimeError) { Task[:leaves] }
+    ex = assert_exception(RuntimeError) { Task[:leaves] }
     assert_equal "Don't know how to build task 'leaves'", ex.message
   end
 
@@ -155,13 +175,13 @@ 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)
-    assert_match(/pre-requisites:\s*--t2/, out)
+    assert_match(/pre-requisites:\s*--t[23]/, out)
   end
 
 
@@ -173,7 +193,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 +203,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 +220,7 @@ end
 class TestTaskWithArguments < Test::Unit::TestCase
   include CaptureStdout
   include Rake
-  include Interning
+  include TestMethods
 
   def setup
     Task.clear
@@ -238,15 +258,13 @@ class TestTaskWithArguments < Test::Unit::TestCase
   end
 
   def test_illegal_keys_in_task_name_hash
-    assert_raise RuntimeError do
+    assert_exception RuntimeError do
       t = task(:t, :x, :y => 1, :needs => [:pre])
     end
   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 +283,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 +303,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 +333,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 +349,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

data/test/test_test_task.rb

@@ -5,6 +5,8 @@ require 'rake/testtask'
 
 class TestTestTask < Test::Unit::TestCase
   include Rake
+  include TestMethods
+  
   def setup
     Task.clear
     ENV.delete('TEST')

data/test/test_top_level_functions.rb

@@ -7,12 +7,14 @@ rescue LoadError
 end
 
 require 'test/unit'
+require 'flexmock/test_unit'
 require 'test/capture_stdout'
+require 'test/rake_test_setup'
 require 'rake'
-require 'flexmock/test_unit'
 
 class TestTopLevelFunctions < Test::Unit::TestCase
   include CaptureStdout
+  include TestMethods
 
   def setup
     super
@@ -79,6 +81,6 @@ class TestTopLevelFunctions < Test::Unit::TestCase
   end
 
   def test_missing_other_constant
-    assert_raise(NameError) do Object.const_missing(:Xyz) end
+    assert_exception(NameError) do Object.const_missing(:Xyz) end
   end
 end

data/test/test_win32.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'test/rake_test_setup'
+require 'test/in_environment'
+
+require 'rake'
+
+class TestWin32 < Test::Unit::TestCase
+  include InEnvironment
+  include TestMethods
+
+  Win32 = Rake::Win32
+
+  def test_win32_system_dir_uses_home_if_defined
+    in_environment('RAKE_SYSTEM' => nil, 'HOME' => 'C:\\HP') do
+      assert_equal "C:/HP/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_uses_homedrive_homepath_when_no_home_defined
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => "C:",
+      'HOMEPATH' => "\\HP"
+      ) do
+      assert_equal "C:/HP/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_uses_appdata_when_no_home_or_home_combo
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => nil,
+      'HOMEPATH' => nil,
+      'APPDATA' => "C:\\Documents and Settings\\HP\\Application Data"
+      ) do
+      assert_equal "C:/Documents and Settings/HP/Application Data/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_fallback_to_userprofile_otherwise
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => nil,
+      'HOMEPATH' => nil,
+      'APPDATA' => nil,
+      'USERPROFILE' => "C:\\Documents and Settings\\HP"
+      ) do
+      assert_equal "C:/Documents and Settings/HP/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_nil_of_no_env_vars
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => nil,
+      "HOMEPATH" => nil,
+      'APPDATA' => nil,
+      "USERPROFILE" => nil
+      ) do
+      assert_exception(Rake::Win32::Win32HomeError) do
+        Win32.win32_system_dir
+      end
+    end
+  end
+
+end