rake 0.9.2.2 → 0.9.3

data/test/test_rake_application.rb

@@ -385,6 +385,18 @@ class TestRakeApplication < Rake::TestCase
     ARGV.clear
   end
 
+  def test_bad_run_with_backtrace
+    @app.intern(Rake::Task, "default").enhance { fail }
+    ARGV.clear
+    ARGV << '-f' << '-s' << '--backtrace'
+    assert_raises(SystemExit) {
+      _, err = capture_io { @app.run }
+      refute_match(/see full trace/, err)
+    }
+  ensure
+    ARGV.clear
+  end
+
   def test_run_with_bad_options
     @app.intern(Rake::Task, "default").enhance { fail }
     ARGV.clear
@@ -486,4 +498,3 @@ class TestRakeApplication < Rake::TestCase
   end
 
 end
-

data/test/test_rake_application_options.rb

@@ -29,10 +29,12 @@ class TestRakeApplicationOptions < Rake::TestCase
 
   def test_default_options
     opts = command_line
+    assert_nil opts.backtrace
     assert_nil opts.classic_namespace
     assert_nil opts.dryrun
     assert_nil opts.ignore_system
     assert_nil opts.load_system
+    assert_nil opts.always_multitask
     assert_nil opts.nosearch
     assert_equal ['rakelib'], opts.rakelib
     assert_nil opts.show_prereqs
@@ -40,6 +42,7 @@ class TestRakeApplicationOptions < Rake::TestCase
     assert_nil opts.show_tasks
     assert_nil opts.silent
     assert_nil opts.trace
+    assert_nil opts.thread_pool_size
     assert_equal ['rakelib'], opts.rakelib
     assert ! Rake::FileUtilsExt.verbose_flag
     assert ! Rake::FileUtilsExt.nowrite_flag
@@ -110,6 +113,18 @@ class TestRakeApplicationOptions < Rake::TestCase
     assert_equal :exit, @exit
   end
 
+  def test_jobs
+    flags(['--jobs', '4'], ['-j', '4']) do |opts|
+      assert_equal 4, opts.thread_pool_size
+    end
+    flags(['--jobs', 'asdas'], ['-j', 'asdas']) do |opts|
+      assert_equal 2, opts.thread_pool_size
+    end
+    flags('--jobs', '-j') do |opts|
+      assert_equal 2, opts.thread_pool_size
+    end
+  end
+
   def test_libdir
     flags(['--libdir', 'xx'], ['-I', 'xx'], ['-Ixx']) do |opts|
       $:.include?('xx')
@@ -118,6 +133,12 @@ class TestRakeApplicationOptions < Rake::TestCase
     $:.delete('xx')
   end
 
+  def test_multitask
+    flags('--multitask', '-m') do |opts|
+      assert_equal opts.always_multitask, true
+    end
+  end
+
   def test_rakefile
     flags(['--rakefile', 'RF'], ['--rakefile=RF'], ['-f', 'RF'], ['-fRF']) do |opts|
       assert_equal ['RF'], @app.instance_eval { @rakefiles }
@@ -125,7 +146,8 @@ class TestRakeApplicationOptions < Rake::TestCase
   end
 
   def test_rakelib
-    flags(['--rakelibdir', 'A:B:C'], ['--rakelibdir=A:B:C'], ['-R', 'A:B:C'], ['-RA:B:C']) do |opts|
+    dirs = %w(A B C).join(File::PATH_SEPARATOR)
+    flags(['--rakelibdir', dirs], ["--rakelibdir=#{dirs}"], ['-R', dirs], ["-R#{dirs}"]) do |opts|
       assert_equal ['A', 'B', 'C'], opts.rakelib
     end
   end
@@ -197,12 +219,76 @@ class TestRakeApplicationOptions < Rake::TestCase
 
   def test_trace
     flags('--trace', '-t') do |opts|
-      assert opts.trace
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert Rake::FileUtilsExt.verbose_flag
+      assert ! Rake::FileUtilsExt.nowrite_flag
+    end
+  end
+
+  def test_trace_with_stdout
+    flags('--trace=stdout', '-tstdout', '-t stdout') do |opts|
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stdout, opts.trace_output
       assert Rake::FileUtilsExt.verbose_flag
       assert ! Rake::FileUtilsExt.nowrite_flag
     end
   end
 
+  def test_trace_with_stderr
+    flags('--trace=stderr', '-tstderr', '-t stderr') do |opts|
+      assert opts.trace, "should enable trace option"
+      assert opts.backtrace, "should enabled backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert Rake::FileUtilsExt.verbose_flag
+      assert ! Rake::FileUtilsExt.nowrite_flag
+    end
+  end
+
+  def test_trace_with_error
+    ex = assert_raises(Rake::CommandLineOptionError) do
+      flags('--trace=xyzzy') do |opts| end
+    end
+    assert_match(/un(known|recognized).*\btrace\b.*xyzzy/i, ex.message)
+  end
+
+
+  def test_backtrace
+    flags('--backtrace') do |opts|
+      assert opts.backtrace, "should enable backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert ! opts.trace, "should not enable trace option"
+      assert ! Rake::FileUtilsExt.verbose_flag
+    end
+  end
+
+  def test_backtrace_with_stdout
+    flags('--backtrace=stdout') do |opts|
+      assert opts.backtrace, "should enable backtrace option"
+      assert_equal $stdout, opts.trace_output
+      assert ! opts.trace, "should not enable trace option"
+      assert ! Rake::FileUtilsExt.verbose_flag
+    end
+  end
+
+  def test_backtrace_with_stderr
+    flags('--backtrace=stderr') do |opts|
+      assert opts.backtrace, "should enable backtrace option"
+      assert_equal $stderr, opts.trace_output
+      assert ! opts.trace, "should not enable trace option"
+      assert ! Rake::FileUtilsExt.verbose_flag
+    end
+  end
+
+  def test_backtrace_with_error
+    ex = assert_raises(Rake::CommandLineOptionError) do
+      flags('--backtrace=xyzzy') do |opts| end
+    end
+    assert_match(/un(known|recognized).*\bbacktrace\b.*xyzzy/i, ex.message)
+  end
+
   def test_trace_rules
     flags('--rules') do |opts|
       assert opts.trace_rules
@@ -213,10 +299,17 @@ class TestRakeApplicationOptions < Rake::TestCase
     flags('--tasks', '-T') do |opts|
       assert_equal :tasks, opts.show_tasks
       assert_equal(//.to_s, opts.show_task_pattern.to_s)
+      assert_equal nil, opts.show_all_tasks
     end
     flags(['--tasks', 'xyz'], ['-Txyz']) do |opts|
       assert_equal :tasks, opts.show_tasks
       assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal nil, opts.show_all_tasks
+    end
+    flags(['--tasks', 'xyz', '--comments']) do |opts|
+      assert_equal :tasks, opts.show_tasks
+      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal false, opts.show_all_tasks
     end
   end
 
@@ -224,10 +317,17 @@ class TestRakeApplicationOptions < Rake::TestCase
     flags('--where', '-W') do |opts|
       assert_equal :lines, opts.show_tasks
       assert_equal(//.to_s, opts.show_task_pattern.to_s)
+      assert_equal true, opts.show_all_tasks
     end
     flags(['--where', 'xyz'], ['-Wxyz']) do |opts|
       assert_equal :lines, opts.show_tasks
       assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal true, opts.show_all_tasks
+    end
+    flags(['--where', 'xyz', '--comments'], ['-Wxyz', '--comments']) do |opts|
+      assert_equal :lines, opts.show_tasks
+      assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s)
+      assert_equal false, opts.show_all_tasks
     end
   end
 
@@ -268,7 +368,7 @@ class TestRakeApplicationOptions < Rake::TestCase
         assert_equal opts.trace, $trace
         assert_equal opts.dryrun, $dryrun
         assert_equal opts.silent, $silent
-            end
+      end
     end
 
     assert_match(/deprecated/, err)
@@ -308,6 +408,17 @@ class TestRakeApplicationOptions < Rake::TestCase
     assert '12', ENV['TESTKEY']
   end
 
+  def test_rake_explicit_task_library
+    Rake.add_rakelib 'app/task', 'other'
+
+    libs = Rake.application.options.rakelib
+
+    assert libs.include?("app/task")
+    assert libs.include?("other")
+  end
+
+  private
+
   def flags(*sets)
     sets.each do |set|
       ARGV.clear
@@ -332,4 +443,3 @@ class TestRakeApplicationOptions < Rake::TestCase
     @app.options
   end
 end
-

data/test/test_rake_backtrace.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../helper', __FILE__)
+require 'open3'
+
+class TestRakeBacktrace < Rake::TestCase
+  # TODO: factor out similar code in test_rake_functional.rb
+  def rake(*args)
+    lib = File.join(@orig_PWD, "lib")
+    bin_rake = File.join(@orig_PWD, "bin", "rake")
+    Open3.popen3(RUBY, "-I", lib, bin_rake, *args) { |_, _, err, _| err.read }
+  end
+
+  def invoke(task_name)
+    rake task_name.to_s
+  end
+
+  def test_single_collapse
+    rakefile %q{
+      task :foo do
+        raise "foooo!"
+      end
+    }
+
+    lines = invoke(:foo).split("\n")
+
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "foooo!", lines[1]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
+  end
+
+  def test_multi_collapse
+    rakefile %q{
+      task :foo do
+        Rake.application.invoke_task(:bar)
+      end
+      task :bar do
+        raise "barrr!"
+      end
+    }
+
+    lines = invoke(:foo).split("\n")
+
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "barrr!", lines[1]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:6!i, lines
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
+  end
+
+  def test_suppress_option
+    rakefile %q{
+      task :baz do
+        raise "bazzz!"
+      end
+    }
+
+    lines = rake("baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    assert_something_matches %r!Rakefile!i, lines
+
+    lines = rake("--suppress-backtrace", ".ak.file", "baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    refute_match %r!Rakefile!i, lines[2]
+  end
+
+  private
+
+  # Assert that the pattern matches at least one line in +lines+.
+  def assert_something_matches(pattern, lines)
+    lines.each do |ln|
+      if pattern =~ ln
+        assert_match pattern, ln
+        return
+      end
+    end
+    flunk "expected #{pattern.inspect} to match something in:\n    #{lines.join("\n    ")}"
+  end
+
+end

data/test/test_rake_directory_task.rb

@@ -36,11 +36,22 @@ class TestRakeDirectoryTask < Rake::TestCase
       assert_nil             Task['c:/'].comment
       assert_equal "WIN32 DESC",   Task['c:/a/b/c'].comment
       assert_nil             Task['c:/a/b'].comment
-      verbose(false) {
-        Task['c:/a/b'].invoke
-      }
-      assert File.exist?('c:/a/b')
-      refute File.exist?('c:/a/b/c')
     end
   end
+
+  def test_can_use_blocks
+    runlist = []
+
+    t1 = directory("a/b/c" => :t2) { |t| runlist << t.name }
+    t2 = task(:t2) { |t| runlist << t.name }
+
+    verbose(false) {
+      t1.invoke
+    }
+
+    assert_equal Task["a/b/c"], t1
+    assert_equal FileCreationTask, Task["a/b/c"].class
+    assert_equal ["t2", "a/b/c"], runlist
+    assert File.directory?("a/b/c")
+  end
 end

data/test/test_rake_file_task.rb

@@ -1,6 +1,10 @@
 require File.expand_path('../helper', __FILE__)
 require 'fileutils'
 
+def load_phony
+  load File.dirname(__FILE__) + "/../lib/rake/phony.rb"
+end
+
 class TestRakeFileTask < Rake::TestCase
   include Rake
 
@@ -41,6 +45,23 @@ class TestRakeFileTask < Rake::TestCase
     assert ! t1.needed?, "Should not need to rebuild new file because of old"
   end
 
+  def test_file_times_new_depend_on_regular_task_timestamps
+    load_phony
+
+    name = "dummy"
+    task name
+
+    create_timed_files(NEWFILE)
+
+    t1 = Rake.application.intern(FileTask, NEWFILE).enhance([name])
+
+    assert t1.needed?, "depending on non-file task uses Time.now"
+
+    task(name => :phony)
+
+    assert ! t1.needed?, "unless the non-file task has a timestamp"
+  end
+
   def test_file_times_old_depends_on_new
     create_timed_files(OLDFILE, NEWFILE)
 
@@ -99,4 +120,3 @@ class TestRakeFileTask < Rake::TestCase
   end
 
 end
-

data/test/test_rake_functional.rb

@@ -417,6 +417,28 @@ class TestRakeFunctional < Rake::TestCase
     assert_equal "1\n", @out
   end
 
+  def can_detect_signals?
+    system "ruby -e 'Process.kill \"TERM\", $$'"
+    status = $?
+    if @verbose
+      puts "    SIG status = #{$?.inspect}"
+      puts "    SIG status.respond_to?(:signaled?) = #{$?.respond_to?(:signaled?).inspect}"
+      puts "    SIG status.signaled? = #{status.signaled?}" if status.respond_to?(:signaled?)
+    end
+    status.respond_to?(:signaled?) && status.signaled?
+  end
+
+  def test_signal_propagation_in_tests
+    if can_detect_signals?
+      rakefile_test_signal
+      rake
+      assert_match(/ATEST/, @out)
+      refute_match(/BTEST/, @out)
+    else
+      skip "Signal detect seems broken on this system"
+    end
+  end
+
   private
 
   # Run a shell Ruby command with command line options (using the

data/test/test_rake_multi_task.rb

@@ -47,5 +47,13 @@ class TestRakeMultiTask < Rake::TestCase
     assert @runs.index("B0") < @runs.index("B1")
     assert @runs.index("B1") < @runs.index("B2")
   end
+
+  def test_multitasks_with_parameters
+    task :a, [:arg] do |t,args| add_run(args[:arg]) end
+    multitask :b, [:arg] => [:a] do |t,args| add_run(args[:arg]+'mt') end
+    Task[:b].invoke "b"
+    assert @runs[0] == "b"
+    assert @runs[1] == "bmt"
+  end
 end
 

data/test/test_rake_reduce_compat.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../helper', __FILE__)
+require 'open3'
+
+class TestRakeReduceCompat < Rake::TestCase
+  # TODO: factor out similar code in test_rake_functional.rb
+  def rake(*args)
+    lib = File.join(@orig_PWD, "lib")
+    bin_rake = File.join(@orig_PWD, "bin", "rake")
+    Open3.popen3(RUBY, "-I", lib, bin_rake, *args) { |_, out, _, _| out.read }
+  end
+  
+  def invoke_normal(task_name)
+    rake task_name.to_s
+  end
+
+  def invoke_reduce_compat(task_name)
+    rake "--reduce-compat", task_name.to_s
+  end
+
+  def test_no_deprecated_dsl
+    rakefile %q{
+      task :check_task do
+        Module.new { p defined?(task) }
+      end
+
+      task :check_file do
+        Module.new { p defined?(file) }
+      end
+    }
+    
+    assert_equal %{"method"}, invoke_normal(:check_task).chomp
+    assert_equal %{"method"}, invoke_normal(:check_file).chomp
+
+    assert_equal "nil", invoke_reduce_compat(:check_task).chomp
+    assert_equal "nil", invoke_reduce_compat(:check_file).chomp
+  end
+
+  def test_no_classic_namespace
+    rakefile %q{
+      task :check_task do
+        begin
+          Task
+          print "present"
+        rescue NameError
+          print "absent"
+        end
+      end
+
+      task :check_file_task do
+        begin
+          FileTask
+          print "present"
+        rescue NameError
+          print "absent"
+        end
+      end
+    }
+
+    assert_equal "present", invoke_normal(:check_task)
+    assert_equal "present", invoke_normal(:check_file_task)
+
+    assert_equal "absent", invoke_reduce_compat(:check_task)
+    assert_equal "absent", invoke_reduce_compat(:check_file_task)
+  end
+end

data/test/test_rake_task.rb

@@ -104,10 +104,12 @@ class TestRakeTask < Rake::TestCase
   end
 
   def test_clear
+    desc "a task"
     t = task("t" => "a") { }
     t.clear
     assert t.prerequisites.empty?, "prerequisites should be empty"
     assert t.actions.empty?, "actions should be empty"
+    assert_nil t.comment, "comments should be empty"
   end
 
   def test_clear_prerequisites
@@ -123,6 +125,22 @@ class TestRakeTask < Rake::TestCase
     assert t.actions.empty?, "actions should be empty"
   end
 
+  def test_clear_comments
+    desc "the original foo"
+    task :foo => [:x] do
+      # Dummy action
+    end
+
+    task(:foo).clear_comments
+
+    desc "a slightly different foo"
+    task :foo
+
+    assert_equal "a slightly different foo", task(:foo).comment
+    assert_equal ["x"], task(:foo).prerequisites
+    assert_equal 1, task(:foo).actions.size
+  end
+
   def test_find
     task :tfind
     assert_equal "tfind", Task[:tfind].name
@@ -223,6 +241,38 @@ class TestRakeTask < Rake::TestCase
     assert_in_delta now + 10, a.timestamp, 0.1, 'computer too slow?'
   end
 
+  def test_always_multitask
+    mx = Mutex.new
+    result = []
+
+    t_a = task(:a) do |t|
+      sleep 0.02
+      mx.synchronize{ result << t.name }
+    end
+
+    t_b = task(:b) do |t|
+      mx.synchronize{ result << t.name }
+    end
+
+    t_c = task(:c => [:a,:b]) do |t|
+      mx.synchronize{ result << t.name }
+    end
+
+    t_c.invoke
+
+    # task should always run in order
+    assert_equal ['a', 'b', 'c'], result
+
+    [t_a, t_b, t_c].each { |t| t.reenable }
+    result.clear
+
+    Rake.application.options.always_multitask = true
+    t_c.invoke
+
+    # with multitask, task 'b' should grab the mutex first
+    assert_equal ['b', 'a', 'c'], result
+  end
+
   def test_investigation_output
     t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
     task(:t2)
@@ -264,4 +314,3 @@ class TestRakeTask < Rake::TestCase
     assert_equal "HI", t.comment
   end
 end
-

data/test/test_rake_thread_pool.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/thread_pool'
+require 'test/unit/assertions'
+
+class TestRakeTestThreadPool < Rake::TestCase
+  include Rake
+
+  def test_pool_executes_in_current_thread_for_zero_threads
+    pool = ThreadPool.new(0)
+    f = pool.future{Thread.current}
+    pool.join
+    assert_equal Thread.current, f.value
+  end
+
+  def test_pool_executes_in_other_thread_for_pool_of_size_one
+    pool = ThreadPool.new(1)
+    f = pool.future{Thread.current}
+    pool.join
+    refute_equal Thread.current, f.value
+  end
+
+  def test_pool_executes_in_two_other_threads_for_pool_of_size_two
+    pool = ThreadPool.new(2)
+    threads = 2.times.collect{ pool.future{ sleep 0.1; Thread.current } }.each{|f|f.value}
+
+    refute_equal threads[0], threads[1]
+    refute_equal Thread.current, threads[0]
+    refute_equal Thread.current, threads[1]
+  end
+
+  def test_pool_creates_the_correct_number_of_threads
+    pool = ThreadPool.new(2)
+    threads = Set.new
+    t_mutex = Mutex.new
+    10.times.each do
+      pool.future do
+        sleep 0.02
+        t_mutex.synchronize{ threads << Thread.current }
+      end
+    end
+    pool.join
+    assert_equal 2, threads.count
+  end
+
+  def test_pool_future_captures_arguments
+    pool = ThreadPool.new(2)
+    a = 'a'
+    b = 'b'
+    c = 5 # 5 throws an execption with 5.dup. It should be ignored
+    pool.future(a,c){ |a_var,ignore| a_var.capitalize!; b.capitalize! }
+    pool.join
+    assert_equal 'a', a
+    assert_equal 'b'.capitalize, b
+  end
+
+  def test_pool_join_empties_queue
+    pool = ThreadPool.new(2)
+    repeat = 25
+    repeat.times {
+      pool.future do
+        repeat.times {
+          pool.future do
+            repeat.times {
+              pool.future do end
+            }
+          end
+        }
+      end
+    }
+
+    pool.join
+    assert_equal true, pool.__send__(:__queue__).empty?, "queue should be empty"
+  end
+
+  # test that throwing an exception way down in the blocks propagates
+  # to the top
+  def test_exceptions
+    pool = ThreadPool.new(10)
+
+    deep_exception_block = lambda do |count|
+      next raise Exception.new if ( count < 1 )
+      pool.future(count-1, &deep_exception_block).value
+    end
+
+    assert_raises(Exception) do
+      pool.future(2, &deep_exception_block).value
+    end
+
+  end
+
+  def test_pool_prevents_deadlock
+    pool = ThreadPool.new(5)
+
+    common_dependency_a = pool.future { sleep 0.2 }
+    futures_a = 10.times.collect { pool.future{ common_dependency_a.value; sleep(rand() * 0.01) } }
+
+    common_dependency_b = pool.future { futures_a.each { |f| f.value } }
+    futures_b = 10.times.collect { pool.future{ common_dependency_b.value; sleep(rand() * 0.01) } }
+
+    futures_b.each{|f|f.value}
+    pool.join
+  end
+
+  def test_pool_reports_correct_results
+    pool = ThreadPool.new(7)
+
+    a = 18
+    b = 5
+    c = 3
+
+    result = a.times.collect do
+      pool.future do
+        b.times.collect do
+          pool.future { sleep rand * 0.001; c }
+        end.inject(0) { |m,f| m+f.value }
+      end
+    end.inject(0) { |m,f| m+f.value }
+
+    assert_equal( (a*b*c), result )
+    pool.join
+  end
+
+end