rake 0.7.1 → 0.7.2

data/test/test_pathmap.rb

@@ -13,16 +13,17 @@ class TestPathMap < Test::Unit::TestCase
   def test_s_returns_file_separator
     sep = File::ALT_SEPARATOR || File::SEPARATOR
     assert_equal sep, "abc.rb".pathmap("%s")
+    assert_equal sep, "".pathmap("%s")
     assert_equal "a#{sep}b", "a/b".pathmap("%d%s%f")
   end
 
-  def test_b_returns_basename
+  def test_f_returns_basename
     assert_equal "abc.rb", "abc.rb".pathmap("%f")
     assert_equal "abc.rb", "this/is/a/dir/abc.rb".pathmap("%f")
     assert_equal "abc.rb", "/this/is/a/dir/abc.rb".pathmap("%f")
   end
 
-  def test_B_returns_basename_without_extension
+  def test_n_returns_basename_without_extension
     assert_equal "abc", "abc.rb".pathmap("%n")
     assert_equal "abc", "abc".pathmap("%n") 
     assert_equal "abc", "this/is/a/dir/abc.rb".pathmap("%n")
@@ -37,7 +38,7 @@ class TestPathMap < Test::Unit::TestCase
     assert_equal "/this/is/a/dir", "/this/is/a/dir/abc.rb".pathmap("%d")
   end
 
-  def test_nnnd_returns_partial_dirname
+  def test_9d_returns_partial_dirname
     assert_equal "this/is", "this/is/a/dir/abc.rb".pathmap("%2d")
     assert_equal "this", "this/is/a/dir/abc.rb".pathmap("%1d")
     assert_equal ".", "this/is/a/dir/abc.rb".pathmap("%0d")
@@ -47,6 +48,44 @@ class TestPathMap < Test::Unit::TestCase
     assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%-100d")
   end
 
+  def test_x_returns_extension
+    assert_equal "", "abc".pathmap("%x")
+    assert_equal ".rb", "abc.rb".pathmap("%x")
+    assert_equal ".rb", "abc.xyz.rb".pathmap("%x")
+    assert_equal "", ".depends".pathmap("%x")
+    assert_equal "", "dir/.depends".pathmap("%x")
+  end
+
+  def test_X_returns_everything_but_extension
+    assert_equal "abc", "abc".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X")
+    assert_equal ".depends", ".depends".pathmap("%X")
+    assert_equal "a/dir/.depends", "a/dir/.depends".pathmap("%X")
+    assert_equal "/.depends", "/.depends".pathmap("%X")
+  end
+
+  def test_p_returns_entire_pathname
+    assert_equal "abc.rb", "abc.rb".pathmap("%p")
+    assert_equal "this/is/a/dir/abc.rb", "this/is/a/dir/abc.rb".pathmap("%p")
+    assert_equal "/this/is/a/dir/abc.rb", "/this/is/a/dir/abc.rb".pathmap("%p")
+  end
+
+  def test_dash_returns_empty_string
+    assert_equal "", "abc.rb".pathmap("%-")
+    assert_equal "abc.rb", "abc.rb".pathmap("%X%-%x")
+  end
+
+  def test_percent_percent_returns_percent
+    assert_equal "a%b", "".pathmap("a%%b")
+  end
+
+  def test_undefined_percent_causes_error
+    ex = assert_raise(ArgumentError) {
+      "dir/abc.rb".pathmap("%z")
+    }
+  end
+
   def test_pattern_returns_substitutions
     assert_equal "bin/org/osb",
       "src/org/osb/Xyz.java".pathmap("%{src,bin}d")
@@ -92,39 +131,6 @@ class TestPathMap < Test::Unit::TestCase
     assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)
   end
 
-  def test_x_returns_extension
-    assert_equal "", "abc".pathmap("%x")
-    assert_equal ".rb", "abc.rb".pathmap("%x")
-    assert_equal ".rb", "abc.xyz.rb".pathmap("%x")
-    assert_equal "", ".depends".pathmap("%x")
-    assert_equal "", "dir/.depends".pathmap("%x")
-  end
-
-  def test_X_returns_everything_but_extension
-    assert_equal "abc", "abc".pathmap("%X")
-    assert_equal "abc", "abc.rb".pathmap("%X")
-    assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X")
-    assert_equal ".depends", ".depends".pathmap("%X")
-    assert_equal "a/dir/.depends", "a/dir/.depends".pathmap("%X")
-    assert_equal "/.depends", "/.depends".pathmap("%X")
-  end
-
-  def test_p_returns_entire_pathname
-    assert_equal "abc.rb", "abc.rb".pathmap("%p")
-    assert_equal "this/is/a/dir/abc.rb", "this/is/a/dir/abc.rb".pathmap("%p")
-    assert_equal "/this/is/a/dir/abc.rb", "/this/is/a/dir/abc.rb".pathmap("%p")
-  end
-
-  def test_percent_percent_returns_percent
-    assert_equal "a%b", "".pathmap("a%%b")
-  end
-
-  def test_undefined_percent_causes_error
-    ex = assert_raise(ArgumentError) {
-      "dir/abc.rb".pathmap("%z")
-    }
-  end
-
   def test_works_with_windows_separators
     if File::ALT_SEPARATOR
       assert_equal "abc", 'dir\abc.rb'.pathmap("%n")

data/test/test_rake.rb

@@ -17,5 +17,18 @@ class TestRake < Test::Unit::TestCase
     Rake.each_dir_parent(fn) { |d| result << d }
     result
   end
+
+  def test_can_override_application
+    old_app = Rake.application
+    fake_app = Object.new
+    Rake.application = fake_app
+    assert_equal fake_app, Rake.application
+  ensure
+    Rake.application = old_app
+  end
+
+  def test_original_dir_reports_current_dir
+    assert_equal Dir.pwd, Rake.original_dir
+  end
     
 end

data/test/test_rules.rb

@@ -14,6 +14,8 @@ class TestRules < Test::Unit::TestCase
   SRCFILE2 =  "testdata/xyz.c"
   FTNFILE  = "testdata/abc.f"
   OBJFILE  = "testdata/abc.o"
+  FOOFILE  = "testdata/foo"
+  DOTFOOFILE = "testdata/.foo"
 
   def setup
     Task.clear
@@ -66,7 +68,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [OBJFILE], @runs
   end
 
-  def test_create_by_string
+  def test_rule_can_be_created_by_string
     create_file(SRCFILE)
     rule '.o' => ['.c'] do |t|
       @runs << t.name
@@ -75,7 +77,77 @@ class TestRules < Test::Unit::TestCase
     assert_equal [OBJFILE], @runs
   end
 
-  def test_rule_and_no_action_task
+  def test_rule_prereqs_can_be_created_by_string
+    create_file(SRCFILE)
+    rule '.o' => '.c' do |t|
+      @runs << t.name
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_plain_strings_as_dependents_refer_to_files
+    create_file(SRCFILE)
+    rule '.o' => SRCFILE do |t|
+      @runs << t.name
+    end
+    Task[OBJFILE].invoke
+    assert_equal [OBJFILE], @runs
+  end
+
+  def test_file_names_beginning_with_dot_can_be_tricked_into_refering_to_file
+    verbose(false) do
+      chdir("testdata") do
+        create_file('.foo')
+        rule '.o' => "./.foo" do |t|
+          @runs << t.name
+        end
+        Task[OBJFILE].invoke
+        assert_equal [OBJFILE], @runs
+      end
+    end
+  end
+
+  def test_file_names_beginning_with_dot_can_be_wrapped_in_lambda
+    verbose(false) do
+      chdir("testdata") do
+        create_file(".foo")
+        rule '.o' => lambda{".foo"} do |t|
+          @runs << t.name
+        end
+        Task[OBJFILE].invoke
+        assert_equal [OBJFILE], @runs
+      end
+    end
+  end
+
+  def test_non_extension_rule_name_refers_to_file
+    verbose(false) do
+      chdir("testdata") do
+        create_file("abc.c")
+        rule "abc" => '.c' do |t|
+          @runs << t.name
+        end
+        Task["abc"].invoke
+        assert_equal ["abc"], @runs
+      end
+    end
+  end
+
+  def test_pathmap_automatically_applies_to_name
+    verbose(false) do
+      chdir("testdata") do
+        create_file("abc.c")
+        rule ".o" => '%{x,a}n.c' do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task["xbc.o"].invoke
+        assert_equal ["xbc.o - abc.c"], @runs
+      end
+    end
+  end
+
+  def test_rule_runs_when_explicit_task_has_no_actions
     create_file(SRCFILE)
     create_file(SRCFILE2)
     delete_file(OBJFILE)
@@ -87,7 +159,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [SRCFILE], @runs
   end
 
-  def test_string_close_matches
+  def test_close_matches_on_name_do_not_trigger_rule
     create_file("testdata/x.c")
     rule '.o' => ['.c'] do |t|
       @runs << t.name
@@ -96,7 +168,7 @@ class TestRules < Test::Unit::TestCase
     assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
   end
 
-  def test_precedence_rule_vs_implicit
+  def test_rule_rebuilds_obj_when_source_is_newer
     create_timed_files(OBJFILE, SRCFILE)
     rule(/\.o$/ => ['.c']) do
       @runs << :RULE
@@ -105,7 +177,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [:RULE], @runs
   end
 
-  def test_rule_with_two_sources
+  def test_rule_with_two_sources_runs_if_both_sources_are_present
     create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
     rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
       @runs << :RULE
@@ -114,7 +186,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [:RULE], @runs
   end
 
-  def test_rule_with_two_sources_but_one_missing
+  def test_rule_with_two_sources_but_one_missing_does_not_run
     create_timed_files(OBJFILE, SRCFILE)
     delete_file(SRCFILE2)
     rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
@@ -124,7 +196,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [], @runs
   end
 
-  def test_rule_ordering_finding_second_rule
+  def test_second_rule_runs_when_first_rule_doesnt
     create_timed_files(OBJFILE, SRCFILE)
     delete_file(SRCFILE2)
     rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
@@ -137,7 +209,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [:RULE2], @runs
   end
 
-  def test_rule_ordering_finding_first_rule
+  def test_second_rule_doest_run_if_first_triggers
     create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
     rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
       @runs << :RULE1
@@ -149,7 +221,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [:RULE1], @runs
   end
 
-  def test_rule_ordering_not_finding_second_rule
+  def test_second_rule_doest_run_if_first_triggers_with_reversed_rules
     create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
     rule OBJFILE => [lambda{SRCFILE}] do
       @runs << :RULE1
@@ -161,19 +233,19 @@ class TestRules < Test::Unit::TestCase
     assert_equal [:RULE1], @runs
   end
 
-  def test_proc_dependent
+  def test_rule_with_proc_dependent_will_trigger
     ran = false
     File.makedirs("testdata/src/jw")
     create_file("testdata/src/jw/X.java")
     rule %r(classes/.*\.class) => [
-      proc { |fn| fn.sub(/^classes/, 'testdata/src').sub(/\.class$/, '.java') }
+      proc { |fn| fn.pathmap("%{classes,testdata/src}d/%n.java") }
     ] do |task|
       assert_equal task.name, 'classes/jw/X.class'
       assert_equal task.source, 'testdata/src/jw/X.java'
-      ran = true
+      @runs << :RULE
     end
     Task['classes/jw/X.class'].invoke
-    assert ran, "Should have triggered rule"
+    assert_equal [:RULE], @runs
   ensure
     rm_r("testdata/src", :verbose=>false) rescue nil
   end
@@ -200,7 +272,7 @@ class TestRules < Test::Unit::TestCase
     rm_r("testdata/flatten", :verbose=>false) rescue nil
   end
 
-  def test_recursive_rules
+  def test_recursive_rules_will_work_as_long_as_they_terminate
     actions = []
     create_file("testdata/abc.xml")
     rule '.y' => '.xml' do actions << 'y' end
@@ -211,7 +283,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal ['y', 'c', 'o', 'exe'], actions
   end
 
-  def test_recursive_overflow
+  def test_recursive_rules_that_dont_terminate_will_overflow
     create_file("testdata/a.a")
     prev = 'a'
     ('b'..'z').each do |letter|
@@ -224,5 +296,10 @@ class TestRules < Test::Unit::TestCase
     assert_match(/a\.z => testdata\/a.y/, ex.message)
   end
 
+  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
+  end
+
 end
 

data/test/test_task_manager.rb

@@ -82,18 +82,18 @@ class TestTaskManager < Test::Unit::TestCase
       aa = @tm.define_task(Rake::Task, :aa)
       mid_z = @tm.define_task(Rake::Task, :z)
       @tm.in_namespace("b") do
-	bb = @tm.define_task(Rake::Task, :bb)
-	bot_z = @tm.define_task(Rake::Task, :z)
-
-	assert_equal ["a", "b"], @tm.current_scope
-
-	assert_equal bb, @tm["a:b:bb"]
-	assert_equal aa, @tm["a:aa"]
-	assert_equal xx, @tm["xx"]
-	assert_equal bot_z, @tm["z"]
-	assert_equal mid_z, @tm["^z"]
-	assert_equal top_z, @tm["^^z"]
-	assert_equal top_z, @tm["rake:z"]
+        bb = @tm.define_task(Rake::Task, :bb)
+        bot_z = @tm.define_task(Rake::Task, :z)
+
+        assert_equal ["a", "b"], @tm.current_scope
+
+        assert_equal bb, @tm["a:b:bb"]
+        assert_equal aa, @tm["a:aa"]
+        assert_equal xx, @tm["xx"]
+        assert_equal bot_z, @tm["z"]
+        assert_equal mid_z, @tm["^z"]
+        assert_equal top_z, @tm["^^z"]
+        assert_equal top_z, @tm["rake:z"]
       end
 
       assert_equal ["a"], @tm.current_scope
@@ -122,7 +122,7 @@ class TestTaskManager < Test::Unit::TestCase
       t2 = @tm.define_task(Rake::Task, :t)
       s =  @tm.define_task(Rake::Task, :s)
       @tm.in_namespace("b") do
-	t3 = @tm.define_task(Rake::Task, :t)
+        t3 = @tm.define_task(Rake::Task, :t)
       end
     end
     assert_equal t1, @tm[:t, []]

data/test/test_tasks.rb

@@ -4,9 +4,11 @@ require 'test/unit'
 require 'fileutils'
 require 'rake'
 require 'test/filecreation'
+require 'test/capture_stdout'
 
 ######################################################################
 class TestTask < Test::Unit::TestCase
+  include CaptureStdout
   include Rake
 
   def setup
@@ -23,6 +25,7 @@ class TestTask < Test::Unit::TestCase
     t.execute
     assert_equal t, arg
     assert_nil t.source
+    assert_equal [], t.sources
   end
 
   def test_invoke
@@ -35,8 +38,29 @@ class TestTask < Test::Unit::TestCase
     assert_equal ["t2", "t3", "t1"], runlist
   end
 
-  def intern(name)
-    Rake.application.define_task(Rake::Task,name)
+  def test_dry_run_prevents_actions
+    Rake.application.options.dryrun = true
+    runlist = []
+    t1 = intern(:t1).enhance { |t| runlist << t.name; 3321 }
+    out = capture_stdout { t1.invoke }
+    assert_match(/execute .*t1/i, out)
+    assert_match(/dry run/i, out)
+    assert_no_match(/invoke/i, out)
+    assert_equal [], runlist
+  ensure
+    Rake.application.options.dryrun = false
+  end
+
+  def test_tasks_can_be_traced
+    Rake.application.options.trace = true
+    t1 = intern(:t1) { |t| runlist << t.name; 3321 }
+    out = capture_stdout {
+      t1.invoke
+    }
+    assert_match(/invoke t1/i, out)
+    assert_match(/execute t1/i, out)
+  ensure
+    Rake.application.options.trace = false
   end
 
   def test_no_double_invoke
@@ -102,5 +126,21 @@ class TestTask < Test::Unit::TestCase
     assert_equal ["b", "c"], Task[:a].prerequisites
   end
 
+  def test_investigation_output
+    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    intern(:t2)
+    intern(:t3)
+    out = t1.investigation
+    assert_match(/class:\s*Rake::Task/, out)
+    assert_match(/needed:\s*true/, out)
+    assert_match(/pre-requisites:\s*--t2/, out)
+  end
+
+  private
+
+  def intern(name)
+    Rake.application.define_task(Rake::Task,name)
+  end
+
 end