rake 0.7.3 → 0.8.7

data/test/test_pathmap.rb

@@ -5,6 +5,7 @@ require 'rake'
 
 # ====================================================================
 class TestPathMap < Test::Unit::TestCase
+  include TestMethods
 
   def test_returns_self_with_no_args
     assert_equal "abc.rb", "abc.rb".pathmap
@@ -60,6 +61,11 @@ class TestPathMap < Test::Unit::TestCase
     assert_equal "abc", "abc".pathmap("%X")
     assert_equal "abc", "abc.rb".pathmap("%X")
     assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X")
+    assert_equal "ab.xyz", "ab.xyz.rb".pathmap("%X")
+    assert_equal "a.xyz", "a.xyz.rb".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "ab", "ab.rb".pathmap("%X")
+    assert_equal "a", "a.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")
@@ -81,7 +87,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_undefined_percent_causes_error
-    ex = assert_raise(ArgumentError) {
+    ex = assert_exception(ArgumentError) {
       "dir/abc.rb".pathmap("%z")
     }
   end
@@ -125,7 +131,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_pattern_with_invalid_operator
-    ex = assert_raise(ArgumentError) do
+    ex = assert_exception(ArgumentError) do
       "abc.xyz".pathmap("%{src,bin}z")
     end
     assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)
@@ -181,6 +187,22 @@ class TestPathMapExplode < Test::Unit::TestCase
   end
 end
 
+class TestPathMapPartial < Test::Unit::TestCase
+  def test_pathmap_partial
+    @path = "1/2/file"
+    def @path.call(n)
+      pathmap_partial(n)
+    end
+    assert_equal("1", @path.call(1))
+    assert_equal("1/2", @path.call(2))
+    assert_equal("1/2", @path.call(3))
+    assert_equal(".", @path.call(0))
+    assert_equal("2", @path.call(-1))
+    assert_equal("1/2", @path.call(-2))
+    assert_equal("1/2", @path.call(-3))
+  end
+end
+
 class TestFileListPathMap < Test::Unit::TestCase
   def test_file_list_supports_pathmap
     assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n")

data/test/test_pseudo_status.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+require 'test/capture_stdout'
+require 'test/rake_test_setup'
+
+class PseudoStatusTest < Test::Unit::TestCase
+  def test_with_zero_exit_status
+    s = Rake::PseudoStatus.new
+    assert_equal 0, s.exitstatus
+    assert_equal 0, s.to_i
+    assert_equal 0, s >> 8
+    assert ! s.stopped?
+    assert s.exited?
+  end
+  def test_with_99_exit_status
+    s = Rake::PseudoStatus.new(99)
+    assert_equal 99, s.exitstatus
+    assert_equal 25344, s.to_i
+    assert_equal 99, s >> 8
+    assert ! s.stopped?
+    assert s.exited?
+  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_rdoc_task.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/rdoctask'
+require 'test/rake_test_setup'
+
+class TestRDocTask < Test::Unit::TestCase
+  include Rake
+  include TestMethods
+  
+  def setup
+    Task.clear
+  end
+  
+  def test_tasks_creation
+    Rake::RDocTask.new
+    assert Task[:rdoc]
+    assert Task[:clobber_rdoc]
+    assert Task[:rerdoc]
+  end
+  
+  def test_tasks_creation_with_custom_name_symbol
+    rd = Rake::RDocTask.new(:rdoc_dev)
+    assert Task[:rdoc_dev]
+    assert Task[:clobber_rdoc_dev]
+    assert Task[:rerdoc_dev]
+    assert_equal :rdoc_dev, rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_string
+    rd = Rake::RDocTask.new("rdoc_dev")
+    assert Task[:rdoc_dev]
+    assert Task[:clobber_rdoc_dev]
+    assert Task[:rerdoc_dev]
+    assert_equal "rdoc_dev", rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_hash
+    options = { :rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force" }
+    rd = Rake::RDocTask.new(options)
+    assert Task[:"rdoc"]
+    assert Task[:"rdoc:clean"]
+    assert Task[:"rdoc:force"]
+    assert_raises(RuntimeError) { Task[:clobber_rdoc] }
+    assert_equal options, rd.name
+  end
+  
+  def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
+    rd = Rake::RDocTask.new(:clobber_rdoc => "rdoc:clean")
+    assert Task[:rdoc]
+    assert Task[:"rdoc:clean"]
+    assert Task[:rerdoc]
+  end
+  
+  def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
+    assert_raises(ArgumentError) do
+      Rake::RDocTask.new(:foo => "bar")
+    end
+    
+    begin
+      Rake::RDocTask.new(:foo => "bar")
+    rescue ArgumentError => e
+      assert_match(/foo/, e.message)
+    end
+  end
+  
+  def test_inline_source_is_enabled_by_default
+    rd = Rake::RDocTask.new
+    assert rd.option_list.include?('--inline-source')
+  end
+  
+  def test_inline_source_option_is_only_appended_if_option_not_already_given
+    rd = Rake::RDocTask.new
+    rd.options << '--inline-source'
+    assert_equal 1, rd.option_list.grep('--inline-source').size
+    
+    rd = Rake::RDocTask.new
+    rd.options << '-S'
+    assert_equal 1, rd.option_list.grep('-S').size
+    assert_equal 0, rd.option_list.grep('--inline-source').size
+  end
+  
+  def test_inline_source_option_can_be_disabled
+    rd = Rake::RDocTask.new
+    rd.inline_source = false
+    assert !rd.option_list.include?('--inline-source')
+  end
+end

data/test/test_require.rb

@@ -2,9 +2,11 @@
 
 require 'test/unit'
 require 'rake'
+require 'test/rake_test_setup'
 
 # ====================================================================
 class TestRequire < Test::Unit::TestCase
+  include TestMethods
 
   def test_can_load_rake_library
     app = Rake::Application.new
@@ -22,7 +24,7 @@ class TestRequire < Test::Unit::TestCase
 
   def test_throws_error_if_library_not_found
     app = Rake::Application.new
-    ex = assert_raise(LoadError) {
+    ex = assert_exception(LoadError) {
       assert app.instance_eval {
         rake_require("testx", ['test/data/rakelib'], [])
       }

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
@@ -113,10 +115,23 @@ class TestRules < Test::Unit::TestCase
       chdir("testdata") do
         create_file(".foo")
         rule '.o' => lambda{".foo"} do |t|
-          @runs << t.name
+          @runs << "#{t.name} - #{t.source}"
         end
         Task[OBJFILE].invoke
-        assert_equal [OBJFILE], @runs
+        assert_equal ["#{OBJFILE} - .foo"], @runs
+      end
+    end
+  end
+
+  def test_file_names_containing_percent_can_be_wrapped_in_lambda
+    verbose(false) do
+      chdir("testdata") do
+        create_file("foo%x")
+        rule '.o' => lambda{"foo%x"} do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task[OBJFILE].invoke
+        assert_equal ["#{OBJFILE} - foo%x"], @runs
       end
     end
   end
@@ -137,12 +152,25 @@ class TestRules < Test::Unit::TestCase
   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|
+        create_file("zzabc.c")
+        rule ".o" => 'zz%{x,a}n.c' do |t|
           @runs << "#{t.name} - #{t.source}"
         end
         Task["xbc.o"].invoke
-        assert_equal ["xbc.o - abc.c"], @runs
+        assert_equal ["xbc.o - zzabc.c"], @runs
+      end
+    end
+  end
+
+  def test_plain_strings_are_just_filenames
+    verbose(false) do
+      chdir("testdata") do
+        create_file("plainname")
+        rule ".o" => 'plainname' do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task["xbc.o"].invoke
+        assert_equal ["xbc.o - plainname"], @runs
       end
     end
   end
@@ -164,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
@@ -196,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)
@@ -235,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") }
@@ -252,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
@@ -290,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)
@@ -298,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

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+######################################################################
+class TestTaskArguments < Test::Unit::TestCase
+  def teardown
+    ENV.delete('rev')
+    ENV.delete('VER')
+  end
+
+  def test_empty_arg_list_is_empty
+    ta = Rake::TaskArguments.new([], [])
+    assert_equal({}, ta.to_hash)
+  end
+
+  def test_multiple_values_in_args
+    ta = Rake::TaskArguments.new([:a, :b, :c], [:one, :two, :three])
+    assert_equal({:a => :one, :b => :two, :c => :three}, ta.to_hash)
+  end
+
+  def test_to_s
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
+    assert_equal ta.to_hash.inspect, ta.to_s
+    assert_equal ta.to_hash.inspect, ta.inspect
+  end
+
+  def test_enumerable_behavior
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2 ,3])
+    assert_equal [10, 20, 30], ta.collect { |k,v| v * 10 }.sort
+  end
+
+  def test_named_args
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal 1, ta.aa
+    assert_equal 1, ta[:aa]
+    assert_equal 1, ta["aa"]
+    assert_equal 2, ta.bb
+    assert_nil ta.cc
+  end
+
+  def test_args_knows_its_names
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal ["aa", "bb"], ta.names
+  end
+
+  def test_extra_names_are_nil
+    ta = Rake::TaskArguments.new(["aa", "bb", "cc"], [1, 2])
+    assert_nil ta.cc
+  end
+
+  def test_args_can_reference_env_values
+    ta = Rake::TaskArguments.new(["aa"], [1])
+    ENV['rev'] = "1.2"
+    ENV['VER'] = "2.3"
+    assert_equal "1.2", ta.rev
+    assert_equal "2.3", ta.ver
+  end
+
+  def test_creating_new_argument_scopes
+    parent = Rake::TaskArguments.new(['p'], [1])
+    child = parent.new_scope(['c', 'p'])
+    assert_equal({:p=>1}, child.to_hash)
+    assert_equal 1, child.p
+    assert_equal 1, child["p"]
+    assert_equal 1, child[:p]
+    assert_nil child.c
+  end
+
+  def test_child_hides_parent_arg_names
+    parent = Rake::TaskArguments.new(['aa'], [1])
+    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