rake 10.0.0.beta.2 → 10.0.0

data/Rakefile

@@ -60,6 +60,7 @@ task :default => :test
 
 Rake::TestTask.new do |t|
   files = FileList['test/helper.rb', 'test/test_*.rb']
+  t.loader = :testrb
   t.test_files = files
   t.libs << "."
   t.warning = true

data/doc/release_notes/rake-10.0.0.rdoc

@@ -152,8 +152,8 @@ GitHub::    git://github.com/jimweirich/rake.git
 
 == Thanks
 
-As usual, it was input from users that drove a alot of these changes. The
-following people either contributed patches, made suggestions or made
+As usual, it was input from users that drove a lot of these changes. The
+following people contributed patches, made suggestions or made
 otherwise helpful comments.  Thanks to ...
 
 * Aaron Patterson

data/lib/rake/application.rb

@@ -58,7 +58,7 @@ module Rake
     #
     # * Initialize the command line options (+init+).
     # * Define the tasks (+load_rakefile+).
-    # * Run the top level tasks (+run_tasks+).
+    # * Run the top level tasks (+top_level+).
     #
     # If you wish to build a custom rake command, you should call
     # +init+ on your application.  Then define any tasks.  Finally,
@@ -67,15 +67,7 @@ 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
 
@@ -97,13 +89,30 @@ module Rake
 
     # Run the top level tasks of a Rake application.
     def top_level
-      if options.show_tasks
-        display_tasks_and_comments
-      elsif options.show_prereqs
-        display_prerequisites
-      else
-        top_level_tasks.each { |task_name| invoke_task(task_name) }
+      run_with_threads do
+        if options.show_tasks
+          display_tasks_and_comments
+        elsif options.show_prereqs
+          display_prerequisites
+        else
+          top_level_tasks.each { |task_name| invoke_task(task_name) }
+        end
+      end
+    end
+
+    # Run the given block with the thread startup and shutdown.
+    def run_with_threads
+      thread_pool.gather_history if options.job_stats == :history
+
+      yield
+
+      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
 
     # Add a loader to handle imported files ending in the extension

data/lib/rake/backtrace.rb

@@ -5,8 +5,9 @@ module Rake
                                  keys.grep(/(prefix|libdir)/)) + [
         File.join(File.dirname(__FILE__), ".."),
       ].map { |f| Regexp.quote(File.expand_path(f)) }
+    SUPPRESSED_PATHS.reject! { |s| s.nil? || s =~ /^ *$/ }
 
-    SUPPRESS_PATTERN = %r!(\A#{SUPPRESSED_PATHS.join('|')}|bin/rake:\d+)!
+    SUPPRESS_PATTERN = %r!(\A#{SUPPRESSED_PATHS.join('|')}|bin/rake:\d+)!i
 
     def self.collapse(backtrace)
       pattern = Rake.application.options.suppress_backtrace_pattern ||

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

@@ -196,7 +196,7 @@ module Rake
           application[r, @scope].invoke_with_call_chain(args, invocation_chain)
         end
       end
-      futures.each { |f| f.call }
+      futures.each { |f| f.value }
     end
 
     # Format the trace flags for display.

data/lib/rake/thread_history_display.rb

@@ -1,8 +1,11 @@
+require 'rake/private_reader'
+
 module Rake
 
   class ThreadHistoryDisplay    # :nodoc: all
-    attr_reader :stats, :items, :threads
-    private :stats, :items, :threads
+    include Rake::PrivateReader
+
+    private_reader :stats, :items, :threads
 
     def initialize(stats)
       @stats   = stats
@@ -13,7 +16,7 @@ module Rake
     def show
       puts "Job History:"
       stats.each do |stat|
-        stat[:data] ||= []
+        stat[:data] ||= {}
         rename(stat, :thread, threads)
         rename(stat[:data], :item_id, items)
         rename(stat[:data], :new_thread, threads)

data/lib/rake/thread_pool.rb

@@ -1,6 +1,8 @@
 require 'thread'
 require 'set'
 
+require 'rake/promise'
+
 module Rake
 
   class ThreadPool              # :nodoc: all
@@ -28,63 +30,12 @@ module Rake
     # 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 }
-
-      promise_mutex = Mutex.new
-      promise_result = promise_error = NOT_SET
-
-      # (promise code builds on Ben Lavender's public-domain 'promise' gem)
-      promise = lambda do
-        # return immediately if the future has been executed
-        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)
-            #execute the promise
-            begin
-              promise_result = block.call(*local_args)
-            rescue Exception => e
-              promise_error = e
-            end
-            block = local_args = nil # GC can now clean these up
-          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.
-
-          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_active_threads += 1 }
-            start_thread
-            wait_for_promise.call
-            @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
+    def future(*args, &block)
+      promise = Promise.new(args, &block)
+      promise.recorder = lambda { |*stats| stat(*stats) }
 
       @queue.enq promise
-      stat :item_queued, item_id: promise.object_id
+      stat :queued, :item_id => promise.object_id
       start_thread
       promise
     end
@@ -93,14 +44,18 @@ module Rake
     def join
       @threads_mon.synchronize do
         begin
-            @join_cond.wait unless @threads.empty?
+          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
@@ -119,45 +74,58 @@ module Rake
     # (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 }
+      @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,
+        :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 && !@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
+            while @threads.count <= @max_active_threads
+              break unless process_queue_item
             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
+              stat :ended, :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
+        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
@@ -165,10 +133,10 @@ module Rake
     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,
+        :event  => event,
+        :data   => data,
+        :time   => Time.now,
+        :thread => Thread.current.object_id,
       }
       @history_mon.synchronize { @history << info }
     end
@@ -182,8 +150,6 @@ module Rake
     def __threads__ # :nodoc:
       @threads.dup
     end
-
-    NOT_SET = Object.new.freeze # :nodoc:
   end
 
 end

data/lib/rake/version.rb

@@ -4,8 +4,6 @@ module Rake
       MAJOR = 10,
       MINOR = 0,
       BUILD = 0,
-      'beta',
-      BETA = 2,
     ]
   end
   VERSION = Version::NUMBERS.join('.')

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

data/test/test_rake_application_options.rb

@@ -145,7 +145,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

data/test/test_rake_backtrace.rb

@@ -24,8 +24,8 @@ class TestRakeBacktrace < Rake::TestCase
 
     assert_equal "rake aborted!", lines[0]
     assert_equal "foooo!", lines[1]
-    assert_match %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!, lines[2]
-    assert_match %r!\ATasks:!, lines[3]
+    assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines
+    assert_something_matches %r!\ATasks:!, lines
   end
 
   def test_multi_collapse
@@ -42,9 +42,9 @@ class TestRakeBacktrace < Rake::TestCase
 
     assert_equal "rake aborted!", lines[0]
     assert_equal "barrr!", lines[1]
-    assert_match %r!\A#{Regexp.quote Dir.pwd}/Rakefile:6!, lines[2]
-    assert_match %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!, lines[3]
-    assert_match %r!\ATasks:!, lines[4]
+    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
@@ -57,11 +57,25 @@ class TestRakeBacktrace < Rake::TestCase
     lines = rake("baz").split("\n")
     assert_equal "rake aborted!", lines[0]
     assert_equal "bazzz!", lines[1]
-    assert_match %r!Rakefile!, lines[2]
+    assert_something_matches %r!Rakefile!i, lines
 
-    lines = rake("--suppress-backtrace", "R.k.file", "baz").split("\n")
+    lines = rake("--suppress-backtrace", ".ak.file", "baz").split("\n")
     assert_equal "rake aborted!", lines[0]
     assert_equal "bazzz!", lines[1]
-    refute_match %r!Rakefile!, lines[2]
+    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_functional.rb

@@ -435,7 +435,7 @@ class TestRakeFunctional < Rake::TestCase
       assert_match(/ATEST/, @out)
       refute_match(/BTEST/, @out)
     else
-      puts "\nWARNING: Signal detect seems broken on this system (#{__FILE__}:#{__LINE__})"
+      skip "Signal detect seems broken on this system"
     end
   end
 

data/test/test_rake_thread_pool.rb

@@ -69,7 +69,7 @@ class TestRakeTestThreadPool < Rake::TestCase
     }
 
     pool.join
-    assert_equal true, pool.__send__(:__queue__).empty?
+    assert_equal true, pool.__send__(:__queue__).empty?, "queue should be empty"
   end
 
   # test that throwing an exception way down in the blocks propagates
@@ -88,29 +88,6 @@ class TestRakeTestThreadPool < Rake::TestCase
 
   end
 
-  def test_pool_always_has_max_threads_doing_work
-    # here we need to test that even if some threads are halted, there
-    # are always at least max_threads that are not sleeping.
-    pool = ThreadPool.new(2)
-    initial_sleep_time = 0.2
-    future1 = pool.future { sleep initial_sleep_time }
-    dependent_futures = 5.times.collect { pool.future{ future1.value } }
-    future2 = pool.future { sleep initial_sleep_time }
-    future3 = pool.future { sleep 0.01 }
-
-    sleep initial_sleep_time / 2.0 # wait for everything to queue up
-
-    # at this point, we should have 5 threads sleeping depending on future1, and
-    # two threads doing work on future1 and future 2.
-    assert_equal pool.__send__(:__threads__).count, 7
-
-    # 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.value }
-    pool.join
-  end
-
   def test_pool_prevents_deadlock
     pool = ThreadPool.new(5)
 

data/test/test_thread_history_display.rb

@@ -18,7 +18,7 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_item_queued
-    @stats << event(:item_queued,  item_id: 123)
+    @stats << event(:item_queued,  :item_id => 123)
     out, _ = capture_io do
       @display.show
     end
@@ -26,7 +26,7 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_item_dequeued
-    @stats << event(:item_dequeued,  item_id: 123)
+    @stats << event(:item_dequeued,  :item_id => 123)
     out, _ = capture_io do
       @display.show
     end
@@ -34,8 +34,8 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_multiple_items
-    @stats << event(:item_queued,  item_id: 123)
-    @stats << event(:item_queued,  item_id: 124)
+    @stats << event(:item_queued,  :item_id => 123)
+    @stats << event(:item_queued,  :item_id => 124)
     out, _ = capture_io do
       @display.show
     end
@@ -44,7 +44,7 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_waiting
-    @stats << event(:waiting, item_id: 123)
+    @stats << event(:waiting, :item_id => 123)
     out, _ = capture_io do
       @display.show
     end
@@ -52,7 +52,7 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_continue
-    @stats << event(:continue, item_id: 123)
+    @stats << event(:continue, :item_id => 123)
     out, _ = capture_io do
       @display.show
     end
@@ -60,29 +60,29 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_thread_deleted
-    @stats << event(:thread_deleted, deleted_thread: 123456, thread_count: 12)
+    @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)
+    assert_match(/^ *1000000 +A +thread_deleted( +deleted_thread:B| +thread_count:12){2}$/, out)
   end
 
   def test_thread_created
-    @stats << event(:thread_created, new_thread: 123456, thread_count: 13)
+    @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)
+    assert_match(/^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/, out)
   end
 
   private
 
   def event(type, data={})
     result = {
-      event: type,
-      time: @time / 1_000_000.0,
-      data: data,
-      thread: Thread.current.object_id
+      :event => type,
+      :time  => @time / 1_000_000.0,
+      :data  => data,
+      :thread => Thread.current.object_id
     }
     @time += 1
     result

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rake
 version: !ruby/object:Gem::Version
-  version: 10.0.0.beta.2
-  prerelease: 7
+  version: 10.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Jim Weirich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-26 00:00:00.000000000 Z
+date: 2012-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -106,6 +106,8 @@ files:
 - lib/rake/packagetask.rb
 - lib/rake/pathmap.rb
 - lib/rake/phony.rb
+- lib/rake/private_reader.rb
+- lib/rake/promise.rb
 - lib/rake/pseudo_status.rb
 - lib/rake/rake_module.rb
 - lib/rake/rake_test_loader.rb
@@ -124,6 +126,7 @@ files:
 - lib/rake/win32.rb
 - test/file_creation.rb
 - test/helper.rb
+- test/test_private_reader.rb
 - test/test_rake.rb
 - test/test_rake_application.rb
 - test/test_rake_application_options.rb