rake 0.9.3.beta.2 → 0.9.3.beta.3

data/README.rdoc

@@ -129,6 +129,7 @@ Issues and bug reports can also be tracked here:
 * Rake Source Code Repo:  http://github.com/jimweirich/rake
 * Rake Git Repo Clone URL: git://github.com/jimweirich/rake.git
 * Rake Bug Reports: https://github.com/jimweirich/rake/issues
+* Rake Continuous Build Server: https://travis-ci.org/#!/jimweirich/rake
 
 === Presentations and Articles about Rake
 

data/doc/command_line_usage.rdoc

@@ -31,7 +31,7 @@ Options are:
 [<tt>--execute-print</tt> _code_ (-p)]
     Execute some Ruby code, print the result, and exit.
 
-[<tt>--execute-continue</tt> _code_ (-p)]
+[<tt>--execute-continue</tt> _code_ (-E)]
     Execute some Ruby code, then continue with normal task processing.
 
 [<tt>--help</tt>  (-H)]
@@ -49,6 +49,9 @@ Options are:
 [<tt>--libdir</tt> _directory_  (-I)]
     Add _directory_ to the list of directories searched for require.
 
+[<tt>--multitask</tt> (-m)]
+    Treat all tasks as multitasks. ('make/drake' semantics)
+
 [<tt>--nosearch</tt>  (-N)]
     Do not search for a Rakefile in parent directories.
 

data/lib/rake/application.rb

@@ -3,10 +3,13 @@ require 'optparse'
 
 require 'rake/task_manager'
 require 'rake/thread_pool'
+require 'rake/thread_history_display'
 require 'rake/win32'
 
 module Rake
 
+  CommandLineOptionError = Class.new(StandardError)
+
   ######################################################################
   # Rake main application object.  When invoking +rake+ from the
   # command line, a Rake::Application object is created and run.
@@ -64,8 +67,15 @@ module Rake
       standard_exception_handling do
         init
         load_rakefile
+        thread_pool.gather_history if options.job_stats == :history
         top_level
         thread_pool.join
+        if options.job_stats
+          stats = thread_pool.statistics
+          puts "Maximum active threads: #{stats[:max_active_threads]}"
+          puts "Total threads in play:  #{stats[:total_threads_in_play]}"
+        end
+        ThreadHistoryDisplay.new(thread_pool.history).show if options.job_stats == :history
       end
     end
 
@@ -108,8 +118,9 @@ module Rake
       @options ||= OpenStruct.new
     end
 
-    def thread_pool
-      @thread_pool ||= ThreadPool.new options.thread_pool_size
+    # Return the thread pool used for multithreaded processing.
+    def thread_pool             # :nodoc:
+      @thread_pool ||= ThreadPool.new(options.thread_pool_size||FIXNUM_MAX)
     end
 
     # private ----------------------------------------------------------------
@@ -150,15 +161,15 @@ module Rake
 
     # Display the error message that caused the exception.
     def display_error_message(ex)
-      $stderr.puts "#{name} aborted!"
-      $stderr.puts ex.message
+      trace "#{name} aborted!"
+      trace ex.message
       if options.backtrace
-        $stderr.puts ex.backtrace.join("\n")
+        trace ex.backtrace.join("\n")
       else
-        $stderr.puts Backtrace.collapse(ex.backtrace)
+        trace Backtrace.collapse(ex.backtrace)
       end
-      $stderr.puts "Tasks: #{ex.chain}" if has_chain?(ex)
-      $stderr.puts "(See full trace by running task with --trace)" unless options.backtrace
+      trace "Tasks: #{ex.chain}" if has_chain?(ex)
+      trace "(See full trace by running task with --trace)" unless options.backtrace
     end
 
     # Warn about deprecated usage.
@@ -293,6 +304,11 @@ module Rake
       end
     end
 
+    def trace(*str)
+      options.trace_output ||= $stderr
+      options.trace_output.puts(*str)
+    end
+
     def sort_options(options)
       options.sort_by { |opt|
         opt.select { |o| o =~ /^-/ }.map { |o| o.downcase }.sort.reverse
@@ -310,9 +326,10 @@ module Rake
               options.show_all_tasks = value
             }
           ],
-          ['--backtrace', "Enable full backtrace.",
+          ['--backtrace [OUT]', "Enable full backtrace.  OUT can be stderr (default) or stdout.",
             lambda { |value|
-              options.backtrace = value
+              options.backtrace = true
+              select_trace_output(options, 'backtrace', value)
             }
           ],
           ['--classic-namespace', '-C', "Put Task and FileTask in the top level namespace",
@@ -328,7 +345,7 @@ module Rake
           ],
           ['--describe', '-D [PATTERN]', "Describe the tasks (matching optional PATTERN), then exit.",
             lambda { |value|
-              select_tasks_to_show :describe, value, options
+              select_tasks_to_show(options, :describe, value)
             }
           ],
           ['--dry-run', '-n', "Do a dry run without executing actions.",
@@ -359,9 +376,22 @@ module Rake
             "Specifies the maximum number of tasks to execute in parallel. (default:2)",
             lambda { |value| options.thread_pool_size = [(value || 2).to_i,2].max }
           ],
+          ['--job-stats [LEVEL]',
+            "Display job statistics. LEVEL=history displays a complete job list",
+            lambda { |value|
+              if value =~ /^history/i
+                options.job_stats = :history
+              else
+                options.job_stats = true
+              end
+            }
+          ],
           ['--libdir', '-I LIBDIR', "Include LIBDIR in the search path for required modules.",
             lambda { |value| $:.push(value) }
           ],
+          ['--multitask', '-m', "Treat all tasks as multitasks.",
+            lambda { |value| options.always_multitask = true }
+          ],
           ['--no-search', '--nosearch', '-N', "Do not search parent directories for the Rakefile.",
             lambda { |value| options.nosearch = true }
           ],
@@ -409,6 +439,11 @@ module Rake
               options.silent = true
             }
           ],
+          ['--suppress-backtrace PATTERN', "Suppress backtrace lines matching regexp PATTERN. Ignored if --trace is on.",
+            lambda { |value|
+              options.suppress_backtrace_pattern = Regexp.new(value)
+            }
+          ],
           ['--system',  '-g',
             "Using system wide (global) rakefiles (usually '~/.rake/*.rake').",
             lambda { |value| options.load_system = true }
@@ -419,13 +454,14 @@ module Rake
           ],
           ['--tasks', '-T [PATTERN]', "Display the tasks (matching optional PATTERN) with descriptions, then exit.",
             lambda { |value|
-              select_tasks_to_show :tasks, value, options
+              select_tasks_to_show(options, :tasks, value)
             }
           ],
-          ['--trace', '-t', "Turn on invoke/execute tracing, enable full backtrace.",
+          ['--trace', '-t [OUT]', "Turn on invoke/execute tracing, enable full backtrace. OUT can be stderr (default) or stdout.",
             lambda { |value|
               options.trace = true
               options.backtrace = true
+              select_trace_output(options, 'trace', value)
               Rake.verbose(true)
             }
           ],
@@ -440,7 +476,7 @@ module Rake
           ],
           ['--where', '-W [PATTERN]', "Describe the tasks (matching optional PATTERN), then exit.",
             lambda { |value|
-              select_tasks_to_show :lines, value, options
+              select_tasks_to_show(options, :lines, value)
               options.show_all_tasks = true
             }
           ],
@@ -452,16 +488,30 @@ module Rake
         ])
     end
 
-    def select_tasks_to_show(show_tasks, value, options)
+    def select_tasks_to_show(options, show_tasks, value)
       options.show_tasks = show_tasks
       options.show_task_pattern = Regexp.new(value || '')
       Rake::TaskManager.record_task_metadata = true
     end
     private :select_tasks_to_show
 
+    def select_trace_output(options, trace_option, value)
+      value = value.strip unless value.nil?
+      case value
+      when 'stdout'
+        options.trace_output = $stdout
+      when 'stderr', nil
+        options.trace_output = $stderr
+      else
+        fail CommandLineOptionError, "Unrecognized --#{trace_option} option '#{value}'"
+      end
+    end
+    private :select_trace_output
+
     # Read and handle the command line options.
     def handle_options
       options.rakelib = ['rakelib']
+      options.trace_output = $stderr
 
       OptionParser.new do |opts|
         opts.banner = "rake [-f rakefile] {options} targets..."
@@ -632,5 +682,9 @@ module Rake
 
       backtrace.find { |str| str =~ re } || ''
     end
+
+  private
+    FIXNUM_MAX = (2**(0.size * 8 - 2) - 1) # :nodoc:
+
   end
 end

data/lib/rake/backtrace.rb

@@ -1,15 +1,17 @@
 module Rake
   module Backtrace
-    SUPPRESSED_PATHS = [
-      RbConfig::CONFIG["prefix"],
-      File.join(File.dirname(__FILE__), ".."),
-    ].map { |f| Regexp.quote(File.expand_path(f)) }
+    SUPPRESSED_PATHS =
+      RbConfig::CONFIG.values_at(*RbConfig::CONFIG.
+                                 keys.grep(/(prefix|libdir)/)) + [
+        File.join(File.dirname(__FILE__), ".."),
+      ].map { |f| Regexp.quote(File.expand_path(f)) }
 
     SUPPRESS_PATTERN = %r!(\A#{SUPPRESSED_PATHS.join('|')}|bin/rake:\d+)!
 
-    # Elide backtrace elements which match one of SUPPRESS_PATHS.
     def self.collapse(backtrace)
-      backtrace.reject { |elem| elem =~ SUPPRESS_PATTERN }
+      pattern = Rake.application.options.suppress_backtrace_pattern ||
+                SUPPRESS_PATTERN
+      backtrace.reject { |elem| elem =~ pattern }
     end
   end
 end

data/lib/rake/dsl_definition.rb

@@ -52,8 +52,8 @@ module Rake
 
     # Declare a file creation task.
     # (Mainly used for the directory command).
-    def file_create(args, &block)
-      Rake::FileCreationTask.define_task(args, &block)
+    def file_create(*args, &block)
+      Rake::FileCreationTask.define_task(*args, &block)
     end
 
     # Declare a set of files tasks to create the given directories on
@@ -62,12 +62,15 @@ module Rake
     # Example:
     #   directory "testdata/doc"
     #
-    def directory(dir)
+    def directory(*args, &block)
+      result = file_create(*args, &block)
+      dir, _ = *Rake.application.resolve_args(args)
       Rake.each_dir_parent(dir) do |d|
         file_create d do |t|
           mkdir_p t.name if ! File.exist?(t.name)
         end
       end
+      result
     end
 
     # Declare a task that performs its prerequisites in
@@ -172,5 +175,8 @@ module Rake
   extend FileUtilsExt
 end
 
+# Extend the main object with the DSL commands. This allows top-level
+# calls to task, etc. to work from a Rakefile without polluting the
+# object inheritance tree.
 self.extend Rake::DSL
 include Rake::DeprecatedObjectDSL unless defined? Rake::REDUCE_COMPAT

data/lib/rake/multi_task.rb

@@ -5,13 +5,8 @@ module Rake
   #
   class MultiTask < Task
     private
-    def invoke_prerequisites(args, invocation_chain)
-      futures = @prerequisites.collect do |p|
-        application.thread_pool.future(p) do |r|
-          application[r, @scope].invoke_with_call_chain(args, invocation_chain)
-        end
-      end
-      futures.each { |f| f.call }
+    def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
+      invoke_prerequisites_concurrently(task_args, invocation_chain)
     end
   end
 

data/lib/rake/rake_module.rb

@@ -25,6 +25,14 @@ module Rake
       load(path)
     end
 
+    # Add files to the rakelib list
+    def add_rakelib(*files)
+      application.options.rakelib ||= []
+      files.each do |file|
+        application.options.rakelib << file
+      end
+    end
+
     # Get a sorted list of files matching the pattern. This method
     # should be prefered to Dir[pattern] and Dir.glob[pattern] because
     # the files returned are guaranteed to be sorted.

data/lib/rake/task.rb

@@ -158,7 +158,7 @@ module Rake
       new_chain = InvocationChain.append(self, invocation_chain)
       @lock.synchronize do
         if application.options.trace
-          $stderr.puts "** Invoke #{name} #{format_trace_flags}"
+          application.trace "** Invoke #{name} #{format_trace_flags}"
         end
         return if @already_invoked
         @already_invoked = true
@@ -179,10 +179,24 @@ module Rake
 
     # Invoke all the prerequisites of a task.
     def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
-      prerequisite_tasks.each { |prereq|
-        prereq_args = task_args.new_scope(prereq.arg_names)
-        prereq.invoke_with_call_chain(prereq_args, invocation_chain)
-      }
+      if application.options.always_multitask
+        invoke_prerequisites_concurrently(task_args, invocation_chain)
+      else
+        prerequisite_tasks.each { |prereq|
+          prereq_args = task_args.new_scope(prereq.arg_names)
+          prereq.invoke_with_call_chain(prereq_args, invocation_chain)
+        }
+      end
+    end
+
+    # Invoke all the prerequisites of a task in parallel.
+    def invoke_prerequisites_concurrently(args, invocation_chain) # :nodoc:
+      futures = @prerequisites.collect do |p|
+        application.thread_pool.future(p) do |r|
+          application[r, @scope].invoke_with_call_chain(args, invocation_chain)
+        end
+      end
+      futures.each { |f| f.call }
     end
 
     # Format the trace flags for display.
@@ -198,11 +212,11 @@ module Rake
     def execute(args=nil)
       args ||= EMPTY_TASK_ARGS
       if application.options.dryrun
-        $stderr.puts "** Execute (dry run) #{name}"
+        application.trace "** Execute (dry run) #{name}"
         return
       end
       if application.options.trace
-        $stderr.puts "** Execute #{name}"
+        application.trace "** Execute #{name}"
       end
       application.enhance_with_matching_rule(name) if @actions.empty?
       @actions.each do |act|

data/lib/rake/task_manager.rb

@@ -238,7 +238,7 @@ module Rake
     end
 
     def trace_rule(level, message)
-      $stderr.puts "#{"    "*level}#{message}" if Rake.application.options.trace_rules
+      options.trace_output.puts "#{"    "*level}#{message}" if Rake.application.options.trace_rules
     end
 
     # Attempt to create a rule given the list of prerequisites.

data/lib/rake/thread_history_display.rb

@@ -0,0 +1,45 @@
+module Rake
+
+  class ThreadHistoryDisplay
+    attr_reader :stats, :items, :threads
+    private :stats, :items, :threads
+
+    def initialize(stats)
+      @stats   = stats
+      @items   = { :_seq_ =>  1  }
+      @threads = { :_seq_ => "A" }
+    end
+
+    def show
+      puts "Job History:"
+      stats.each do |stat|
+        stat[:data] ||= []
+        rename(stat, :thread, threads)
+        rename(stat[:data], :item_id, items)
+        rename(stat[:data], :new_thread, threads)
+        rename(stat[:data], :deleted_thread, threads)
+        printf("%8d %2s %-20s %s\n",
+          (stat[:time] * 1_000_000).round,
+          stat[:thread],
+          stat[:event],
+          stat[:data].map { |k,v| "#{k}:#{v}" }.join(" "))
+      end
+    end
+
+    private
+
+    def rename(hash, key, renames)
+      if hash && hash[key]
+        original = hash[key]
+        value = renames[original]
+        unless value
+          value = renames[:_seq_]
+          renames[:_seq_] = renames[:_seq_].succ
+          renames[original] = value
+        end
+        hash[key] = value
+      end
+    end
+  end
+
+end

data/lib/rake/thread_pool.rb

@@ -3,24 +3,31 @@ require 'set'
 
 module Rake
 
-  class ThreadPool
+  class ThreadPool              # :nodoc: all
 
     # Creates a ThreadPool object.
-    # The parameter is the size of the pool. By default, the pool uses unlimited threads.
-    def initialize(thread_count=nil)
-      @max_thread_count = [(thread_count||FIXNUM_MAX), 0].max
+    # The parameter is the size of the pool.
+    def initialize(thread_count)
+      @max_active_threads = [thread_count, 0].max
       @threads = Set.new
       @threads_mon = Monitor.new
       @queue = Queue.new
       @join_cond = @threads_mon.new_cond
+
+      @history_start_time = nil
+      @history = []
+      @history_mon = Monitor.new
+      @total_threads_in_play = 0
     end
-    
-    # Creates a future to be executed in the ThreadPool.
-    # The args are passed to the block when executing (similarly to Thread#new)
-    # The return value is a Proc which may or may not be already executing in
-    # another thread. Calling Proc#call will sleep the current thread until
-    # the future is finished and will return the result (or raise an Exception
-    # thrown from the future)
+
+    # Creates a future executed by the +ThreadPool+.
+    #
+    # The args are passed to the block when executing (similarly to
+    # <tt>Thread#new</tt>) The return value is an object representing
+    # a future which has been created and added to the queue in the
+    # pool. Sending <tt>#value</tt> to the object will sleep the
+    # current thread until the future is finished and will return the
+    # result (or raise an exception thrown from the future)
     def future(*args,&block)
       # capture the local args for the block (like Thread#start)
       local_args = args.collect { |a| begin; a.dup; rescue; a; end }
@@ -34,7 +41,7 @@ module Rake
         unless promise_result.equal?(NOT_SET) && promise_error.equal?(NOT_SET)
           return promise_error.equal?(NOT_SET) ? promise_result : raise(promise_error)
         end
-        
+
         # try to get the lock and execute the promise, otherwise, sleep.
         if promise_mutex.try_lock
           if promise_result.equal?(NOT_SET) && promise_error.equal?(NOT_SET)
@@ -48,86 +55,135 @@ module Rake
           end
           promise_mutex.unlock
         else
-          # Even if we didn't get the lock, we need to sleep until the promise has
-          # finished executing. If, however, the current thread is part of the thread
-          # pool, we need to free up a new thread in the pool so there will
-          # always be a thread doing work.
+          # Even if we didn't get the lock, we need to sleep until the
+          # promise has finished executing. If, however, the current
+          # thread is part of the thread pool, we need to free up a
+          # new thread in the pool so there will always be a thread
+          # doing work.
 
-          wait_for_promise = lambda { promise_mutex.synchronize{} }
+          wait_for_promise = lambda {
+            stat :waiting, item_id: promise.object_id
+            promise_mutex.synchronize {}
+            stat :continue, item_id: promise.object_id
+          }
 
           unless @threads_mon.synchronize { @threads.include? Thread.current }
             wait_for_promise.call
           else
-            @threads_mon.synchronize { @max_thread_count += 1 }
+            @threads_mon.synchronize { @max_active_threads += 1 }
             start_thread
             wait_for_promise.call
-            @threads_mon.synchronize { @max_thread_count -= 1 }
+            @threads_mon.synchronize { @max_active_threads -= 1 }
           end
         end
         promise_error.equal?(NOT_SET) ? promise_result : raise(promise_error)
       end
 
+      def promise.value
+        call
+      end
+
       @queue.enq promise
+      stat :item_queued, item_id: promise.object_id
       start_thread
       promise
     end
-    
+
     # Waits until the queue of futures is empty and all threads have exited.
     def join
       @threads_mon.synchronize do
         begin
             @join_cond.wait unless @threads.empty?
         rescue Exception => e
-          STDERR.puts e
-          STDERR.print "Queue contains #{@queue.size} items. Thread pool contains #{@threads.count} threads\n"
-          STDERR.print "Current Thread #{Thread.current} status = #{Thread.current.status}\n"
-          STDERR.puts e.backtrace.join("\n")
+          $stderr.puts e
+          $stderr.print "Queue contains #{@queue.size} items. Thread pool contains #{@threads.count} threads\n"
+          $stderr.print "Current Thread #{Thread.current} status = #{Thread.current.status}\n"
+          $stderr.puts e.backtrace.join("\n")
           @threads.each do |t|
-            STDERR.print "Thread #{t} status = #{t.status}\n"
-            STDERR.puts t.backtrace.join("\n") if t.respond_to? :backtrace
+            $stderr.print "Thread #{t} status = #{t.status}\n"
+            $stderr.puts t.backtrace.join("\n") if t.respond_to? :backtrace
           end
           raise e
         end
       end
     end
 
-  private
-    def start_thread
+    # Enable the gathering of history events.
+    def gather_history          #:nodoc:
+      @history_start_time = Time.now if @history_start_time.nil?
+    end
+
+    # Return a array of history events for the thread pool.
+    #
+    # History gathering must be enabled to be able to see the events
+    # (see #gather_history). Best to call this when the job is
+    # complete (i.e. after ThreadPool#join is called).
+    def history                 # :nodoc:
+      @history_mon.synchronize { @history.dup }
+    end
+
+    # Return a hash of always collected statistics for the thread pool.
+    def statistics              #  :nodoc:
+      {
+        total_threads_in_play: @total_threads_in_play,
+        max_active_threads: @max_active_threads,
+      }
+    end
+
+    private
+
+    def start_thread # :nodoc:
       @threads_mon.synchronize do
-        next unless @threads.count < @max_thread_count
+        next unless @threads.count < @max_active_threads
 
-        @threads << Thread.new do
+        t = Thread.new do
           begin
-            while @threads.count <= @max_thread_count && !@queue.empty? do
-              # Even though we just asked if the queue was empty,
-              # it still could have had an item which by this statement is now gone.
-              # For this reason we pass true to Queue#deq because we will sleep
-              # indefinitely if it is empty.
-              @queue.deq(true).call
+            while @threads.count <= @max_active_threads && !@queue.empty? do
+              # Even though we just asked if the queue was empty, it
+              # still could have had an item which by this statement
+              # is now gone. For this reason we pass true to Queue#deq
+              # because we will sleep indefinitely if it is empty.
+              block = @queue.deq(true)
+              stat :item_dequeued, item_id: block.object_id
+              block.call
             end
           rescue ThreadError # this means the queue is empty
           ensure
             @threads_mon.synchronize do
               @threads.delete Thread.current
+              stat :thread_deleted, deleted_thread: Thread.current.object_id, thread_count: @threads.count
               @join_cond.broadcast if @threads.empty?
             end
           end
         end
+        @threads << t
+        stat :thread_created, new_thread: t.object_id, thread_count: @threads.count
+        @total_threads_in_play = @threads.count if @threads.count > @total_threads_in_play
       end
     end
-    
+
+    def stat(event, data=nil) # :nodoc:
+      return if @history_start_time.nil?
+      info = {
+        event: event,
+        data: data,
+        time: (Time.now-@history_start_time),
+        thread: Thread.current.object_id,
+      }
+      @history_mon.synchronize { @history << info }
+    end
+
     # for testing only
-    
-    def __queue__
+
+    def __queue__ # :nodoc:
       @queue
     end
-    
-    def __threads__
+
+    def __threads__ # :nodoc:
       @threads.dup
     end
-    
-    NOT_SET = Object.new.freeze
-    FIXNUM_MAX = (2**(0.size * 8 - 2) - 1) # FIXNUM_MAX
+
+    NOT_SET = Object.new.freeze # :nodoc:
   end
-  
+
 end

data/lib/rake/version.rb

@@ -5,7 +5,7 @@ module Rake
       MINOR = 9,
       BUILD = 3,
       'beta',
-      BETA = 2,
+      BETA = 3,
     ]
   end
   VERSION = Version::NUMBERS.join('.')

data/test/helper.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+$:.unshift File.expand_path('../../lib', __FILE__)
 
 begin
   gem 'minitest'

data/test/test_rake_application_options.rb

@@ -34,6 +34,7 @@ class TestRakeApplicationOptions < Rake::TestCase
     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
@@ -132,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 }
@@ -213,19 +220,74 @@ class TestRakeApplicationOptions < Rake::TestCase
     flags('--trace', '-t') 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_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
@@ -345,6 +407,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

data/test/test_rake_backtrace.rb

@@ -46,4 +46,22 @@ class TestRakeBacktrace < Rake::TestCase
     assert_match %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!, lines[3]
     assert_match %r!\ATasks:!, lines[4]
   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_match %r!Rakefile!, lines[2]
+
+    lines = rake("--suppress-backtrace", "R.k.file", "baz").split("\n")
+    assert_equal "rake aborted!", lines[0]
+    assert_equal "bazzz!", lines[1]
+    refute_match %r!Rakefile!, lines[2]
+  end
 end

data/test/test_rake_directory_task.rb

@@ -38,4 +38,20 @@ class TestRakeDirectoryTask < Rake::TestCase
       assert_nil             Task['c:/a/b'].comment
     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_task.rb

@@ -241,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)

data/test/test_rake_thread_pool.rb

@@ -9,19 +9,19 @@ class TestRakeTestThreadPool < Rake::TestCase
     pool = ThreadPool.new(0)
     f = pool.future{Thread.current}
     pool.join
-    assert_equal Thread.current, f.call
+    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.call
+    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.call}
+    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]
@@ -79,11 +79,11 @@ class TestRakeTestThreadPool < Rake::TestCase
 
     deep_exception_block = lambda do |count|
       next raise Exception.new if ( count < 1 )
-      pool.future(count-1, &deep_exception_block).call
+      pool.future(count-1, &deep_exception_block).value
     end
 
     assert_raises(Exception) do
-      pool.future(2, &deep_exception_block).call
+      pool.future(2, &deep_exception_block).value
     end
 
   end
@@ -94,7 +94,7 @@ class TestRakeTestThreadPool < Rake::TestCase
     pool = ThreadPool.new(2)
     initial_sleep_time = 0.2
     future1 = pool.future { sleep initial_sleep_time }
-    dependent_futures = 5.times.collect { pool.future{ future1.call } }
+    dependent_futures = 5.times.collect { pool.future{ future1.value } }
     future2 = pool.future { sleep initial_sleep_time }
     future3 = pool.future { sleep 0.01 }
 
@@ -107,7 +107,7 @@ class TestRakeTestThreadPool < Rake::TestCase
     # future 3 is in the queue because there aren't enough active threads to work on it.
     assert_equal pool.__send__(:__queue__).size, 1
 
-    [future1, dependent_futures, future2, future3].flatten.each { |f| f.call }
+    [future1, dependent_futures, future2, future3].flatten.each { |f| f.value }
     pool.join
   end
 
@@ -115,12 +115,12 @@ class TestRakeTestThreadPool < Rake::TestCase
     pool = ThreadPool.new(5)
 
     common_dependency_a = pool.future { sleep 0.2 }
-    futures_a = 10.times.collect { pool.future{ common_dependency_a.call; sleep(rand() * 0.01) } }
+    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.call } }
-    futures_b = 10.times.collect { pool.future{ common_dependency_b.call; 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.call}
+    futures_b.each{|f|f.value}
     pool.join
   end
 
@@ -135,9 +135,9 @@ class TestRakeTestThreadPool < Rake::TestCase
       pool.future do
         b.times.collect do
           pool.future { sleep rand * 0.001; c }
-        end.inject(0) { |m,f| m+f.call }
+        end.inject(0) { |m,f| m+f.value }
       end
-    end.inject(0) { |m,f| m+f.call }
+    end.inject(0) { |m,f| m+f.value }
 
     assert_equal( (a*b*c), result )
     pool.join

data/test/test_thread_history_display.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../helper', __FILE__)
+
+require 'rake/thread_history_display'
+
+class TestThreadHistoryDisplay < Rake::TestCase
+  def setup
+    super
+    @time = 1000000
+    @stats = []
+    @display = Rake::ThreadHistoryDisplay.new(@stats)
+  end
+
+  def test_banner
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/Job History/i, out)
+  end
+
+  def test_item_queued
+    @stats << event(:item_queued,  item_id: 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
+  end
+
+  def test_item_dequeued
+    @stats << event(:item_dequeued,  item_id: 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_dequeued +item_id:1$/, out)
+  end
+
+  def test_multiple_items
+    @stats << event(:item_queued,  item_id: 123)
+    @stats << event(:item_queued,  item_id: 124)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out)
+    assert_match(/^ *1000001 +A +item_queued +item_id:2$/, out)
+  end
+
+  def test_waiting
+    @stats << event(:waiting, item_id: 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +waiting +item_id:1$/, out)
+  end
+
+  def test_continue
+    @stats << event(:continue, item_id: 123)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +continue +item_id:1$/, out)
+  end
+
+  def test_thread_deleted
+    @stats << event(:thread_deleted, deleted_thread: 123456, thread_count: 12)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +thread_deleted +deleted_thread:B +thread_count:12$/, out)
+  end
+
+  def test_thread_created
+    @stats << event(:thread_created, new_thread: 123456, thread_count: 13)
+    out, _ = capture_io do
+      @display.show
+    end
+    assert_match(/^ *1000000 +A +thread_created +new_thread:B +thread_count:13$/, out)
+  end
+
+  private
+
+  def event(type, data={})
+    result = {
+      event: type,
+      time: @time / 1_000_000.0,
+      data: data,
+      thread: Thread.current.object_id
+    }
+    @time += 1
+    result
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rake
 version: !ruby/object:Gem::Version
-  version: 0.9.3.beta.2
+  version: 0.9.3.beta.3
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-22 00:00:00.000000000 Z
+date: 2012-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -120,6 +120,7 @@ files:
 - lib/rake/task_manager.rb
 - lib/rake/tasklib.rb
 - lib/rake/testtask.rb
+- lib/rake/thread_history_display.rb
 - lib/rake/thread_pool.rb
 - lib/rake/version.rb
 - lib/rake/win32.rb
@@ -168,6 +169,7 @@ files:
 - test/test_rake_top_level_functions.rb
 - test/test_rake_win32.rb
 - test/test_sys.rb
+- test/test_thread_history_display.rb
 - doc/command_line_usage.rdoc
 - doc/example/Rakefile1
 - doc/example/Rakefile2