rake 0.9.2.2 → 0.9.3

data/lib/rake/ext/module.rb

@@ -36,4 +36,4 @@ class Module
       rake_original_const_missing(const_name)
     end
   end
-end
+end unless defined? Rake::REDUCE_COMPAT

data/lib/rake/ext/string.rb

@@ -4,6 +4,7 @@ require 'rake/ext/core'
 # Rake extension methods for String.
 #
 class String
+
   rake_extension("ext") do
     # Replace the file extension with +newext+.  If there is no extension on
     # the string, append the new extension to the end.  If the new extension
@@ -163,5 +164,5 @@ class String
       result
     end
   end
-end # class String
 
+end

data/lib/rake/ext/time.rb

@@ -1,6 +1,8 @@
 #--
 # Extensions to time to allow comparisons with an early time class.
 
+require 'rake/early_time'
+
 class Time
   alias rake_original_time_compare :<=>
   def <=>(other)
@@ -11,4 +13,3 @@ class Time
     end
   end
 end
-

data/lib/rake/file_list.rb

@@ -286,7 +286,7 @@ module Rake
       matched = 0
       each do |fn|
         begin
-          open(fn, "rb", *options) do |inf|
+          open(fn, "r", *options) do |inf|
             count = 0
             inf.each do |line|
               count += 1
@@ -340,7 +340,7 @@ module Rake
 
     # Add matching glob patterns.
     def add_matching(pattern)
-      Dir[pattern].each do |fn|
+      Rake.glob(pattern).each do |fn|
         self << fn unless exclude?(fn)
       end
     end

data/lib/rake/file_utils_ext.rb

@@ -21,12 +21,13 @@ module Rake
     $fileutils_verbose = true
     $fileutils_nowrite = false
 
-    FileUtils::OPT_TABLE.each do |name, opts|
+    FileUtils.commands.each do |name|
+      opts = FileUtils.options_of name
       default_options = []
-      if opts.include?(:verbose) || opts.include?("verbose")
+      if opts.include?("verbose")
         default_options << ':verbose => FileUtilsExt.verbose_flag'
       end
-      if opts.include?(:noop) || opts.include?("noop")
+      if opts.include?("noop")
         default_options << ':noop => FileUtilsExt.nowrite_flag'
       end
 

data/lib/rake/multi_task.rb

@@ -5,11 +5,8 @@ module Rake
   #
   class MultiTask < Task
     private
-    def invoke_prerequisites(args, invocation_chain)
-      threads = @prerequisites.collect { |p|
-        Thread.new(p) { |r| application[r, @scope].invoke_with_call_chain(args, invocation_chain) }
-      }
-      threads.each { |t| t.join }
+    def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
+      invoke_prerequisites_concurrently(task_args, invocation_chain)
     end
   end
 

data/lib/rake/phony.rb

@@ -0,0 +1,13 @@
+# Defines a :phony task that you can use as a dependency. This allows
+# file-based tasks to use non-file-based tasks as prerequisites
+# without forcing them to rebuild.
+#
+# See FileTask#out_of_date? and Task#timestamp for more info.
+
+require 'rake'
+
+task :phony
+
+def (Rake::Task[:phony]).timestamp
+  Time.at 0
+end

data/lib/rake/private_reader.rb

@@ -0,0 +1,20 @@
+module Rake
+
+  # Include PrivateReader to use +private_reader+.
+  module PrivateReader           # :nodoc: all
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Declare a list of private accessors
+      def private_reader(*names)
+        attr_reader(*names)
+        private(*names)
+      end
+    end
+
+  end
+end

data/lib/rake/promise.rb

@@ -0,0 +1,99 @@
+module Rake
+
+  # A Promise object represents a promise to do work (a chore) in the
+  # future. The promise is created with a block and a list of
+  # arguments for the block. Calling value will return the value of
+  # the promised chore.
+  #
+  # Used by ThreadPool.
+  #
+  class Promise               # :nodoc: all
+    NOT_SET = Object.new.freeze # :nodoc:
+
+    attr_accessor :recorder
+
+    # Create a promise to do the chore specified by the block.
+    def initialize(args, &block)
+      @mutex = Mutex.new
+      @result = NOT_SET
+      @error = NOT_SET
+      @args = args.collect { |a| begin; a.dup; rescue; a; end }
+      @block = block
+    end
+
+    # Return the value of this promise.
+    #
+    # If the promised chore is not yet complete, then do the work
+    # synchronously. We will wait.
+    def value
+      unless complete?
+        stat :sleeping_on, :item_id => object_id
+        @mutex.synchronize do
+          stat :has_lock_on, :item_id => object_id
+          chore
+          stat :releasing_lock_on, :item_id => object_id
+        end
+      end
+      error? ? raise(@error) : @result
+    end
+
+    # If no one else is working this promise, go ahead and do the chore.
+    def work
+      stat :attempting_lock_on, :item_id => object_id
+      if @mutex.try_lock
+        stat :has_lock_on, :item_id => object_id
+        chore
+        stat :releasing_lock_on, :item_id => object_id
+        @mutex.unlock
+      else
+        stat :bailed_on, :item_id => object_id
+      end
+    end
+
+    private
+
+    # Perform the chore promised
+    def chore
+      if complete?
+        stat :found_completed, :item_id => object_id
+        return
+      end
+      stat :will_execute, :item_id => object_id
+      begin
+        @result = @block.call(*@args)
+      rescue Exception => e
+        @error = e
+      end
+      stat :did_execute, :item_id => object_id
+      discard
+    end
+
+    # Do we have a result for the promise
+    def result?
+      ! @result.equal?(NOT_SET)
+    end
+
+    # Did the promise throw an error
+    def error?
+      ! @error.equal?(NOT_SET)
+    end
+
+    # Are we done with the promise
+    def complete?
+      result? || error?
+    end
+
+    # free up these items for the GC
+    def discard
+      @args = nil
+      @block = nil
+    end
+
+    # Record execution statistics if there is a recorder
+    def stat(*args)
+      @recorder.call(*args) if @recorder
+    end
+
+  end
+
+end

data/lib/rake/rake_module.rb

@@ -24,6 +24,21 @@ module Rake
     def load_rakefile(path)
       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.
+    def glob(pattern, *args)
+      Dir.glob(pattern, *args).sort
+    end
   end
 
 end

data/lib/rake/rdoctask.rb

@@ -1,7 +1,7 @@
 # rake/rdoctask is deprecated in favor of rdoc/task
 
 if Rake.application
-  Rake.application.deprecate('require \'rake/rdoctask\'', 'require \'rdoc/task\' (in RDoc 2.4.2+)', __FILE__)
+  Rake.application.deprecate('require \'rake/rdoctask\'', 'require \'rdoc/task\' (in RDoc 2.4.2+)', caller.first)
 end
 
 require 'rubygems'

data/lib/rake/runtest.rb

@@ -5,7 +5,7 @@ module Rake
   include Test::Unit::Assertions
 
   def run_tests(pattern='test/test*.rb', log_enabled=false)
-    Dir["#{pattern}"].each { |fn|
+    Rake.glob(pattern).each { |fn|
       $stderr.puts fn if log_enabled
       begin
         require fn

data/lib/rake/task.rb

@@ -123,6 +123,7 @@ module Rake
     def clear
       clear_prerequisites
       clear_actions
+      clear_comments
       self
     end
 
@@ -138,6 +139,13 @@ module Rake
       self
     end
 
+    # Clear the existing comments on a rake task.
+    def clear_comments
+      @full_comment = nil
+      @comment = nil
+      self
+    end
+
     # Invoke the task if it is needed.  Prerequisites are invoked first.
     def invoke(*args)
       task_args = TaskArguments.new(arg_names, args)
@@ -150,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
@@ -171,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.value }
     end
 
     # Format the trace flags for display.
@@ -190,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_arguments.rb

@@ -47,7 +47,7 @@ module Rake
       keys.map { |k| lookup(k) }
     end
 
-    def method_missing(sym, *args, &block)
+    def method_missing(sym, *args)
       lookup(sym.to_sym)
     end
 

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/testtask.rb

@@ -96,7 +96,11 @@ module Rake
       desc "Run tests" + (@name==:test ? "" : " for #{@name}")
       task @name do
         FileUtilsExt.verbose(@verbose) do
-          ruby "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}"
+          ruby "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}" do |ok, status|
+            if !ok && status.respond_to?(:signaled?) && status.signaled?
+              raise SignalException.new(status.termsig)
+            end
+          end
         end
       end
       self

data/lib/rake/thread_history_display.rb

@@ -0,0 +1,48 @@
+require 'rake/private_reader'
+
+module Rake
+
+  class ThreadHistoryDisplay    # :nodoc: all
+    include Rake::PrivateReader
+
+    private_reader :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

@@ -0,0 +1,155 @@
+require 'thread'
+require 'set'
+
+require 'rake/promise'
+
+module Rake
+
+  class ThreadPool              # :nodoc: all
+
+    # Creates a ThreadPool object.
+    # 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 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)
+      promise = Promise.new(args, &block)
+      promise.recorder = lambda { |*stats| stat(*stats) }
+
+      @queue.enq promise
+      stat :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
+          stat :joining
+          @join_cond.wait unless @threads.empty?
+          stat :joined
+        rescue Exception => e
+          stat :joined
+          $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"
+            # 1.8 doesn't support Thread#backtrace
+            $stderr.puts t.backtrace.join("\n") if t.respond_to? :backtrace
+          end
+          raise e
+        end
+      end
+    end
+
+    # 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 }.
+        sort_by { |i| i[:time] }.
+        each { |i| i[:time] -= @history_start_time }
+    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
+
+    # processes one item on the queue. Returns true if there was an
+    # item to process, false if there was no item
+    def process_queue_item      #:nodoc:
+      return false if @queue.empty?
+
+      # 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.
+      promise = @queue.deq(true)
+      stat :dequeued, :item_id => promise.object_id
+      promise.work
+      return true
+
+      rescue ThreadError # this means the queue is empty
+      false
+    end
+
+    def start_thread # :nodoc:
+      @threads_mon.synchronize do
+        next unless @threads.count < @max_active_threads
+
+        t = Thread.new do
+          begin
+            while @threads.count <= @max_active_threads
+              break unless process_queue_item
+            end
+          ensure
+            @threads_mon.synchronize do
+              @threads.delete Thread.current
+              stat :ended, :thread_count => @threads.count
+              @join_cond.broadcast if @threads.empty?
+            end
+          end
+        end
+        @threads << t
+        stat :spawned, :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,
+        :thread => Thread.current.object_id,
+      }
+      @history_mon.synchronize { @history << info }
+    end
+
+    # for testing only
+
+    def __queue__ # :nodoc:
+      @queue
+    end
+
+    def __threads__ # :nodoc:
+      @threads.dup
+    end
+  end
+
+end

data/lib/rake/version.rb

@@ -1,8 +1,10 @@
 module Rake
-  VERSION = '0.9.2.2'
-
   module Version # :nodoc: all
-    MAJOR, MINOR, BUILD, PATCH = VERSION.split('.')
-    NUMBERS = [ MAJOR, MINOR, BUILD, PATCH ]
+    NUMBERS = [
+      MAJOR = 0,
+      MINOR = 9,
+      BUILD = 3,
+    ]
   end
+  VERSION = Version::NUMBERS.join('.')
 end

data/lib/rake.rb

@@ -58,6 +58,7 @@ require 'rake/early_time'
 require 'rake/name_space'
 require 'rake/task_manager'
 require 'rake/application'
+require 'rake/backtrace'
 
 $trace = false
 

data/test/helper.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+$:.unshift File.expand_path('../../lib', __FILE__)
 
 begin
   gem 'minitest'
@@ -488,5 +489,34 @@ end
     VERBOSE
   end
 
+  def rakefile_test_signal
+    rakefile <<-TEST_SIGNAL
+require 'rake/testtask'
+
+Rake::TestTask.new(:a) do |t|
+  t.test_files = ['a_test.rb']
+end
+
+Rake::TestTask.new(:b) do |t|
+  t.test_files = ['b_test.rb']
+end
+
+task :test do
+  Rake::Task[:a].invoke rescue nil
+  Rake::Task[:b].invoke rescue nil
 end
 
+task :default => :test
+    TEST_SIGNAL
+    open 'a_test.rb', 'w' do |io|
+      io << 'puts "ATEST"' << "\n"
+      io << '$stdout.flush' << "\n"
+      io << 'Process.kill("TERM", $$)' << "\n"
+    end
+    open 'b_test.rb', 'w' do |io|
+      io << 'puts "BTEST"' << "\n"
+      io << '$stdout.flush' << "\n"
+    end
+  end
+
+end

data/test/test_private_reader.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/private_reader'
+
+class TestPrivateAttrs < Rake::TestCase
+
+  class Sample
+    include Rake::PrivateReader
+
+    private_reader :reader, :a
+
+    def initialize
+      @reader = :RVALUE
+    end
+
+    def get_reader
+      reader
+    end
+
+  end
+
+  def setup
+    super
+    @sample = Sample.new
+  end
+
+  def test_private_reader_is_private
+    assert_private do @sample.reader end
+    assert_private do @sample.a end
+  end
+
+  def test_private_reader_returns_data
+    assert_equal :RVALUE, @sample.get_reader
+  end
+
+  private
+
+  def assert_private
+    ex = assert_raises(NoMethodError) do yield end
+    assert_match(/private/, ex.message)
+  end
+
+end