rake 0.8.7 → 0.9.2

data/test/test_rake_path_map_partial.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakePathMapPartial < Rake::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
+

data/test/{test_pseudo_status.rb → test_rake_pseudo_status.rb}

@@ -1,12 +1,6 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'rake'
-
-require 'test/capture_stdout'
-require 'test/rake_test_setup'
-
-class PseudoStatusTest < Test::Unit::TestCase
+class TestRakePseudoStatus < Rake::TestCase
   def test_with_zero_exit_status
     s = Rake::PseudoStatus.new
     assert_equal 0, s.exitstatus

data/test/{test_rdoc_task.rb → test_rake_rdoc_task.rb}

@@ -1,24 +1,28 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'rake/rdoctask'
-require 'test/rake_test_setup'
+require File.expand_path('../helper', __FILE__)
+begin
+  old_verbose = $VERBOSE
+  $VERBOSE = nil
+  require 'rake/rdoctask'
+ensure
+  $VERBOSE = old_verbose
+end
 
-class TestRDocTask < Test::Unit::TestCase
+class TestRakeRDocTask < Rake::TestCase
   include Rake
-  include TestMethods
-  
+
   def setup
+    super
+
     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]
@@ -26,7 +30,7 @@ class TestRDocTask < Test::Unit::TestCase
     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]
@@ -34,7 +38,7 @@ class TestRDocTask < Test::Unit::TestCase
     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)
@@ -44,45 +48,34 @@ class TestRDocTask < Test::Unit::TestCase
     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")
+    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 → test_rake_require.rb}

@@ -1,12 +1,6 @@
-#!/usr/bin/env ruby
+require File.expand_path('../helper', __FILE__)
 
-require 'test/unit'
-require 'rake'
-require 'test/rake_test_setup'
-
-# ====================================================================
-class TestRequire < Test::Unit::TestCase
-  include TestMethods
+class TestRakeRequire < Rake::TestCase
 
   def test_can_load_rake_library
     app = Rake::Application.new
@@ -17,19 +11,25 @@ class TestRequire < Test::Unit::TestCase
 
   def test_wont_reload_rake_library
     app = Rake::Application.new
+
+    paths = ['test/data/rakelib']
+    loaded_files = []
+    app.rake_require("test2", paths, loaded_files)
+
     assert ! app.instance_eval {
-      rake_require("test2", ['test/data/rakelib'], ['test2'])
+      rake_require("test2", paths, loaded_files)
     }
   end
 
   def test_throws_error_if_library_not_found
     app = Rake::Application.new
-    ex = assert_exception(LoadError) {
+    ex = assert_raises(LoadError) {
       assert app.instance_eval {
         rake_require("testx", ['test/data/rakelib'], [])
       }
     }
-    assert_match(/x/, ex.message)
+    assert_match(/(can *not|can't)\s+find/i, ex.message)
+    assert_match(/testx/, ex.message)
   end
 end
 

data/test/{test_rules.rb → test_rake_rules.rb}

@@ -1,16 +1,9 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'fileutils'
-require 'rake'
-require 'test/filecreation'
-require 'test/rake_test_setup'
 
 ######################################################################
-class TestRules < Test::Unit::TestCase
+class TestRakeRules < Rake::TestCase
   include Rake
-  include FileCreation
-  include TestMethods
 
   SRCFILE  = "testdata/abc.c"
   SRCFILE2 =  "testdata/xyz.c"
@@ -20,12 +13,17 @@ class TestRules < Test::Unit::TestCase
   DOTFOOFILE = "testdata/.foo"
 
   def setup
+    super
+
     Task.clear
     @runs = []
+    FileUtils.mkdir_p 'testdata' # HACK use tmpdir
   end
 
   def teardown
     FileList['testdata/*'].uniq.each do |f| rm_r(f, :verbose=>false) end
+
+    super
   end
 
   def test_multiple_rules1
@@ -97,7 +95,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [OBJFILE], @runs
   end
 
-  def test_file_names_beginning_with_dot_can_be_tricked_into_refering_to_file
+  def test_file_names_beginning_with_dot_can_be_tricked_into_referring_to_file
     verbose(false) do
       chdir("testdata") do
         create_file('.foo')
@@ -192,8 +190,8 @@ class TestRules < Test::Unit::TestCase
     rule '.o' => ['.c'] do |t|
       @runs << t.name
     end
-    assert_exception(RuntimeError) { Task['testdata/x.obj'].invoke }
-    assert_exception(RuntimeError) { Task['testdata/x.xyo'].invoke }
+    assert_raises(RuntimeError) { Task['testdata/x.obj'].invoke }
+    assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
   end
 
   def test_rule_rebuilds_obj_when_source_is_newer
@@ -278,7 +276,6 @@ class TestRules < Test::Unit::TestCase
   end
 
   def test_rule_with_proc_dependent_will_trigger
-    ran = false
     mkdir_p("testdata/src/jw")
     create_file("testdata/src/jw/X.java")
     rule %r(classes/.*\.class) => [
@@ -334,7 +331,7 @@ class TestRules < Test::Unit::TestCase
       rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end
       prev = letter
     end
-    ex = assert_exception(Rake::RuleRecursionOverflowError) {
+    ex = assert_raises(Rake::RuleRecursionOverflowError) {
       Task["testdata/a.z"].invoke
     }
     assert_match(/a\.z => testdata\/a.y/, ex.message)
@@ -342,7 +339,7 @@ class TestRules < Test::Unit::TestCase
 
   def test_rules_with_bad_dependents_will_fail
     rule "a" => [ 1 ] do |t| puts t.name end
-    assert_exception(RuntimeError) do Task['a'].invoke end
+    assert_raises(RuntimeError) do Task['a'].invoke end
   end
 
 end

data/test/{test_tasks.rb → test_rake_task.rb}

@@ -1,20 +1,20 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
+require File.expand_path('../helper', __FILE__)
 require 'fileutils'
-require 'rake'
-require 'test/filecreation'
-require 'test/capture_stdout'
-require 'test/rake_test_setup'
-
-######################################################################
-class TestTask < Test::Unit::TestCase
-  include CaptureStdout
+
+class TestRakeTask < Rake::TestCase
   include Rake
-  include TestMethods
 
   def setup
+    super
+
     Task.clear
+    Rake::TaskManager.record_task_metadata = true
+  end
+
+  def teardown
+    Rake::TaskManager.record_task_metadata = false
+
+    super
   end
 
   def test_create
@@ -27,10 +27,13 @@ class TestTask < Test::Unit::TestCase
     assert_equal t, arg
     assert_nil t.source
     assert_equal [], t.sources
+    assert_equal 1, t.locations.size
+    assert_match(/#{Regexp.quote(__FILE__)}/, t.locations.first)
   end
 
   def test_inspect
-    t = task(:foo, :needs => [:bar, :baz])
+#    t = task(:foo, :needs => [:bar, :baz])
+    t = task(:foo => [:bar, :baz])
     assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
   end
 
@@ -50,7 +53,7 @@ class TestTask < Test::Unit::TestCase
     t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
     assert_equal ["t2"], t1.prerequisites
     assert_equal ["t1"], t2.prerequisites
-    ex = assert_exception RuntimeError do
+    ex = assert_raises RuntimeError do
       t1.invoke
     end
     assert_match(/circular dependency/i, ex.message)
@@ -61,10 +64,10 @@ class TestTask < Test::Unit::TestCase
     Rake.application.options.dryrun = true
     runlist = []
     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)
-    assert_no_match(/invoke/i, out)
+    _, err = capture_io { t1.invoke }
+    assert_match(/execute .*t1/i, err)
+    assert_match(/dry run/i, err)
+    refute_match(/invoke/i, err)
     assert_equal [], runlist
   ensure
     Rake.application.options.dryrun = false
@@ -73,11 +76,11 @@ class TestTask < Test::Unit::TestCase
   def test_tasks_can_be_traced
     Rake.application.options.trace = true
     t1 = task(:t1)
-    out = capture_stdout {
+    _, err = capture_io {
       t1.invoke
     }
-    assert_match(/invoke t1/i, out)
-    assert_match(/execute t1/i, out)
+    assert_match(/invoke t1/i, err)
+    assert_match(/execute t1/i, err)
   ensure
     Rake.application.options.trace = false
   end
@@ -123,7 +126,7 @@ class TestTask < Test::Unit::TestCase
   def test_find
     task :tfind
     assert_equal "tfind", Task[:tfind].name
-    ex = assert_exception(RuntimeError) { Task[:leaves] }
+    ex = assert_raises(RuntimeError) { Task[:leaves] }
     assert_equal "Don't know how to build task 'leaves'", ex.message
   end
 
@@ -174,6 +177,56 @@ class TestTask < Test::Unit::TestCase
     assert_equal ["b", "c"], Task[:a].prerequisites
   end
 
+  def test_prerequiste_tasks_returns_tasks_not_strings
+    a = task :a => ["b", "c"]
+    b = task :b
+    c = task :c
+    assert_equal [b, c], a.prerequisite_tasks
+  end
+
+  def test_prerequiste_tasks_fails_if_prerequisites_are_undefined
+    a = task :a => ["b", "c"]
+    b = task :b
+    assert_raises(RuntimeError) do
+      a.prerequisite_tasks
+    end
+  end
+
+  def test_prerequiste_tasks_honors_namespaces
+    a = b = nil
+    namespace "X" do
+      a = task :a => ["b", "c"]
+      b = task :b
+    end
+    c = task :c
+
+    assert_equal [b, c], a.prerequisite_tasks
+  end
+
+  def test_timestamp_returns_now_if_all_prereqs_have_no_times
+    a = task :a => ["b", "c"]
+    b = task :b
+    c = task :c
+
+    faux_stamp = 100
+    flexmock(Time, :now => faux_stamp)
+
+    assert_equal faux_stamp, a.timestamp
+  end
+
+  def test_timestamp_returns_latest_prereq_timestamp
+    a = task :a => ["b", "c"]
+    b = task :b
+    c = task :c
+
+    faux_stamp = 100
+    flexmock(Time, :now => faux_stamp-10)
+    flexmock(b, :timestamp => faux_stamp - 1)
+    flexmock(c, :timestamp => faux_stamp)
+
+    assert_equal faux_stamp, a.timestamp
+  end
+
   def test_investigation_output
     t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
     task(:t2)
@@ -216,159 +269,3 @@ class TestTask < Test::Unit::TestCase
   end
 end
 
-######################################################################
-class TestTaskWithArguments < Test::Unit::TestCase
-  include CaptureStdout
-  include Rake
-  include TestMethods
-
-  def setup
-    Task.clear
-  end
-
-  def test_no_args_given
-    t = task :t
-    assert_equal [], t.arg_names
-  end
-
-  def test_args_given
-    t = task :t, :a, :b
-    assert_equal [:a, :b], t.arg_names
-  end
-
-  def test_name_and_needs
-    t = task(:t => [:pre])
-    assert_equal "t", t.name
-    assert_equal [], t.arg_names
-    assert_equal ["pre"], t.prerequisites
-  end
-
-  def test_name_and_explicit_needs
-    t = task(:t, :needs => [:pre])
-    assert_equal "t", t.name
-    assert_equal [], t.arg_names
-    assert_equal ["pre"], t.prerequisites
-  end
-
-  def test_name_args_and_explicit_needs
-    t = task(:t, :x, :y, :needs => [:pre])
-    assert_equal "t", t.name
-    assert_equal [:x, :y], t.arg_names
-    assert_equal ["pre"], t.prerequisites
-  end
-
-  def test_illegal_keys_in_task_name_hash
-    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 = task(:t) { |tt, args| assert_equal({}, args.to_hash) }
-    t.invoke(1, 2, 3)
-  end
-
-  def test_tasks_can_access_arguments_as_hash
-    t = task :t, :a, :b, :c do |tt, args|
-      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
-      assert_equal 1, args[:a]
-      assert_equal 2, args[:b]
-      assert_equal 3, args[:c]
-      assert_equal 1, args.a
-      assert_equal 2, args.b
-      assert_equal 3, args.c
-    end
-    t.invoke(1, 2, 3)
-  end
-
-  def test_actions_of_various_arity_are_ok_with_args
-    notes = []
-    t = task(:t, :x) do
-      notes << :a
-    end
-    t.enhance do | |
-      notes << :b
-    end
-    t.enhance do |task|
-      notes << :c
-      assert_kind_of Task, task
-    end
-    t.enhance do |t2, args|
-      notes << :d
-      assert_equal t, t2
-      assert_equal({:x => 1}, args.to_hash)
-    end
-    assert_nothing_raised do t.invoke(1) end
-    assert_equal [:a, :b, :c, :d], notes
-  end
-
-  def test_arguments_are_passed_to_block
-    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 = task(:t, :a) { |tt, args|
-      assert_equal 1, args.a
-      assert_nil args.b
-    }
-    t.invoke(1, 2)
-  end
-
-  def test_arguments_are_passed_to_all_blocks
-    counter = 0
-    t = task :t, :a
-    task :t do |tt, args|
-      assert_equal 1, args.a
-      counter += 1
-    end
-    task :t do |tt, args|
-      assert_equal 1, args.a
-      counter += 1
-    end
-    t.invoke(1)
-    assert_equal 2, counter
-  end
-
-  def test_block_with_no_parameters_is_ok
-    t = task(:t) { }
-    t.invoke(1, 2)
-  end
-
-  def test_name_with_args
-    desc "T"
-    t = task(:tt, :a, :b)
-    assert_equal "tt", t.name
-    assert_equal "T", t.comment
-    assert_equal "[a,b]", t.arg_description
-    assert_equal "tt[a,b]", t.name_with_args
-    assert_equal [:a, :b],t.arg_names
-  end
-
-  def test_named_args_are_passed_to_prereqs
-    value = nil
-    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 = task(:pre) { |t, args|
-      assert_equal({}, args.to_hash)
-      assert_equal "bill", args.name
-    }
-    t = task(:t, :name, :rev, :needs => [:pre])
-    t.invoke("bill", "1.2")
-  end
-
-  def test_args_not_passed_if_no_arg_names
-    pre = task(:pre, :rev) { |t, args|
-      assert_equal({}, args.to_hash)
-    }
-    t = task(:t, :needs => [:pre])
-    t.invoke("bill", "1.2")
-  end
-end

data/test/test_rake_task_argument_parsing.rb

@@ -0,0 +1,116 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskArgumentParsing < Rake::TestCase
+  def setup
+    super
+
+    @app = Rake::Application.new
+  end
+
+  def test_name_only
+    name, args = @app.parse_task_string("name")
+    assert_equal "name", name
+    assert_equal [], args
+  end
+
+  def test_empty_args
+    name, args = @app.parse_task_string("name[]")
+    assert_equal "name", name
+    assert_equal [], args
+  end
+
+  def test_one_argument
+    name, args = @app.parse_task_string("name[one]")
+    assert_equal "name", name
+    assert_equal ["one"], args
+  end
+
+  def test_two_arguments
+    name, args = @app.parse_task_string("name[one,two]")
+    assert_equal "name", name
+    assert_equal ["one", "two"], args
+  end
+
+  def test_can_handle_spaces_between_args
+    name, args = @app.parse_task_string("name[one, two,\tthree , \tfour]")
+    assert_equal "name", name
+    assert_equal ["one", "two", "three", "four"], args
+  end
+
+  def test_keeps_embedded_spaces
+    name, args = @app.parse_task_string("name[a one ana, two]")
+    assert_equal "name", name
+    assert_equal ["a one ana", "two"], args
+  end
+
+  def test_terminal_width_using_env
+    app = Rake::Application.new
+    in_environment('RAKE_COLUMNS' => '1234') do
+      assert_equal 1234, app.terminal_width
+    end
+  end
+
+  def test_terminal_width_using_stty
+    app = Rake::Application.new
+    flexmock(app,
+      :unix? => true,
+      :dynamic_width_stty => 1235,
+      :dynamic_width_tput => 0)
+    in_environment('RAKE_COLUMNS' => nil) do
+      assert_equal 1235, app.terminal_width
+    end
+  end
+
+  def test_terminal_width_using_tput
+    app = Rake::Application.new
+    flexmock(app,
+      :unix? => true,
+      :dynamic_width_stty => 0,
+      :dynamic_width_tput => 1236)
+    in_environment('RAKE_COLUMNS' => nil) do
+      assert_equal 1236, app.terminal_width
+    end
+  end
+
+  def test_terminal_width_using_hardcoded_80
+    app = Rake::Application.new
+    flexmock(app, :unix? => false)
+    in_environment('RAKE_COLUMNS' => nil) do
+      assert_equal 80, app.terminal_width
+    end
+  end
+
+  def test_terminal_width_with_failure
+    app = Rake::Application.new
+    flexmock(app).should_receive(:unix?).and_throw(RuntimeError)
+    in_environment('RAKE_COLUMNS' => nil) do
+      assert_equal 80, app.terminal_width
+    end
+  end
+
+  def test_no_rakeopt
+    in_environment do
+      ARGV << '--trace'
+      app = Rake::Application.new
+      app.init
+      assert !app.options.silent
+    end
+  end
+
+  def test_rakeopt_with_blank_options
+    in_environment("RAKEOPT" => "") do
+      ARGV << '--trace'
+      app = Rake::Application.new
+      app.init
+      assert !app.options.silent
+    end
+  end
+
+  def test_rakeopt_with_silent_options
+    in_environment("RAKEOPT" => "-s") do
+      app = Rake::Application.new
+      app.init
+      assert app.options.silent
+    end
+  end
+end