rake 0.9.3.beta.3 → 0.9.3.beta.4

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/command_line_usage.rdoc

@@ -11,6 +11,16 @@ Options are:
     during the execution of the <b>rake</b> command.  You can access
     the value by using ENV['<em>name</em>'].
 
+[<tt>--all</tt> (-A)]
+    Used in combination with the -T and -D options, will force
+    those options to show all the tasks, even the ones without comments.
+
+[<tt>--backtrace</tt> _output_ (-n)]
+    Enable a full backtrace (i.e. like --trace, but without the task
+    tracing details). The backtrace output will be directed to stderr
+    by default. If the options _output_ parameter is set to "stdout",
+    then the output will be directed to standard output.
+
 [<tt>--classic-namespace</tt> (-n)]
     Import the Task, FileTask, and FileCreateTask into the top-level
     scope to be compatible with older versions of Rake.  Alternatively
@@ -18,6 +28,11 @@ Options are:
     'rake/classic_namespace'</code> in your Rakefile to get the
     classic behavior.
 
+[<tt>--comments</tt>]
+    Used in combination with the -W options to force the output to
+    contain commented options only. This is the reverse of
+    <tt>--all</tt>.
+
 [<tt>--describe</tt> _pattern_ (-D)]
     Describe the tasks (matching optional PATTERN), then exit.
 
@@ -38,14 +53,27 @@ Options are:
     Display some help text and exit.
 
 [<tt>--jobs</tt> _number_  (-j)]
-    Specifies the maximum number of concurrent tasks. The suggested
-    value is equal to the number of CPUs.
-    
+    Specifies the number of active concurrent tasks used. The
+    suggested value is equal to the number of CPUs. The concurrent
+    tasks are used to execute the <tt>multitask</tt> prerequisites.
+    Also see the <tt>-m</tt> option which turns all tasks into
+    multitasks.
+
     Sample values:
      (no -j) : unlimited concurrent tasks (standard rake behavior)
      -j      : 2 concurrent tasks (exact number may change)
      -j 16   : 16 concurrent tasks
 
+[<tt>--job-stats</tt> _level_]
+
+    Display job statistics at the completion of the run. By default,
+    this will display the requested number of active tasks (from the
+    -j options) and the maximum number of tasks in play at any given
+    time.
+
+    If the optional _level_ is <tt>history</tt>, then a complete trace
+    of task history will be displayed on standard output.
+
 [<tt>--libdir</tt> _directory_  (-I)]
     Add _directory_ to the list of directories searched for require.
 
@@ -72,6 +100,16 @@ Options are:
 [<tt>--rakelibdir</tt> _rakelibdir_ (-R)]
     Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')
 
+[<tt>--reduce-compat</tt>]
+
+    Remove the DSL commands from the Object inheritance hierarchy and
+    do not define top level constants. This reduces the backwards
+    compatibility of Rake, but allows rake to be used with software
+    that would otherwise have conflicting definitions.
+
+    *NOTE:* The next major version of Rake will only be able to be run
+    in "reduce-compat" mode.
+
 [<tt>--require</tt> _name_ (-r)]
     Require _name_ before executing the Rakefile.
 
@@ -81,6 +119,11 @@ Options are:
 [<tt>--silent (-s)</tt>]
     Like --quiet, but also suppresses the 'in directory' announcement.
 
+[<tt>--suppress-backtrace _pattern_ </tt>]
+    Line matching the regular expression _pattern_ will be removed
+    from the backtrace output. Note that the --backtrace option is the
+    full backtrace without these lines suppressed.
+
 [<tt>--system</tt> (-g)]
     Use the system wide (global) rakefiles. The project Rakefile is
     ignored. By default, the system wide rakefiles are used only if no
@@ -97,16 +140,6 @@ Options are:
     are defined using the "desc" command.  If a pattern is given, then
     only tasks matching the pattern are displayed.
 
-[<tt>--no-top-level-dsl</tt> (-X)]
-    Do not put the Rake DSL commands into the top level scope.
-
-[<tt>--top-level-dsl</tt>]
-    Put the Rake DSL commands into the top level scope (default).
-
-    NOTE: Although currently Rake defaults to its DSL in the top level
-    scope, the plan is to deprecate this in the future and default ot
-    having the DSL commands *not* appear in the top level scope.
-
 [<tt>--trace</tt> (-t)]
     Turn on invoke/execute tracing. Also enable full backtrace on
     errors.
@@ -119,7 +152,11 @@ Options are:
 
 [<tt>--where</tt> <em>pattern</em> (-W)]
     Display tasks that match <em>pattern</em> and the file and line
-    number where the task is defined.
+    number where the task is defined. By default this option will
+    display all tasks, not just the tasks that have descriptions.
+
+[<tt>--no-deprecation-warnings</tt> (-W)]
+    Do not display the deprecation warnings.
 
 In addition, any command line option of the form
 <em>VAR</em>=<em>VALUE</em> will be added to the environment hash

data/doc/release_notes/rake-0.9.2.2.rdoc

@@ -0,0 +1,55 @@
+= Rake 0.9.3 Released
+
+Rake version 0.9.3 is mainly bug fixes.
+
+== Changes
+
+* The rake test loader now removes arguments it has processed.  Issue #51
+* Rake::TaskArguments now responds to #values_at
+* RakeFileUtils.verbose_flag = nil silences output the same as 0.8.7
+* Rake tests are now directory-independent
+* Rake tests are no longer require flexmock
+* Commands constant is no longer polluting top level namespace.
+* Show only the interesting portion of the backtrace by default (James M. Lawrence).
+* Added --reduce-compat option to remove backward compatible DSL hacks (James M. Lawrence).
+
+== What is Rake
+
+Rake is a build tool similar to the make program in many ways. But
+instead of cryptic make recipes, Rake uses standard Ruby code to
+declare tasks and dependencies. You have the full power of a modern
+scripting language built right into your build tool.
+
+== Availability
+
+The easiest way to get and install rake is via RubyGems ...
+
+  gem install rake    (you may need root/admin privileges)
+
+Otherwise, you can get it from the more traditional places:
+
+Home Page:: http://rake.rubyforge.org/
+Download::  http://rubyforge.org/project/showfiles.php?group_id=50
+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
+otherwise helpful comments.  Thanks to ...
+
+* James M. Lawrence (quix)
+* Roger Pack
+* Cezary Baginski
+* Sean Scot August Moon
+* R.T. Lechow
+* Alex Chaffee
+* James Tucker
+* Matthias Lüdtke
+* Santiago Pastorino
+
+Also, bit thanks to Eric Hodel for assisting with getting this release
+out the door (where "assisting" includes, but is not by any means
+limited to, "pushing" me to get it done).
+
+-- Jim Weirich

data/doc/release_notes/rake-0.9.3.rdoc

@@ -1,17 +1,59 @@
 = Rake 0.9.3 Released
 
-Rake version 0.9.3 is mainly bug fixes.
+Rake version 0.9.3 contains some new, backwards compatible features and
+a number of bug fixes.
 
 == Changes
 
-* The rake test loader now removes arguments it has processed.  Issue #51
-* Rake::TaskArguments now responds to #values_at
-* RakeFileUtils.verbose_flag = nil silences output the same as 0.8.7
-* Rake tests are now directory-independent
-* Rake tests are no longer require flexmock
-* Commands constant is no longer polluting top level namespace.
-* Show only the interesting portion of the backtrace by default (James M. Lawrence).
-* Added --reduce-compat optiont to remove backward compatible DSL hacks (James M. Lawrence).
+=== New Features
+
+* Multitask tasks now use a thread pool. Use -j to limit the number of
+  available threads.
+
+* Use -m to turn regular tasks into multitasks (use at your own risk).
+
+* You can now do "Rake.add_rakelib 'dir'" in your Rakefile to
+  programatically add rake task libraries.
+
+* You can specific backtrace suppression patterns (see
+  --supress-backtrace)
+
+* Directory tasks can now take prerequisites and actions
+
+* Use --backtrace to request a full backtrace without the task trace.
+
+* You can say "--backtrace=stdout" and "--trace=stdout" to route trace
+  output to standard output rather than standard error.
+
+* Optional 'phony' target (enable with 'require 'rake/phony'") for
+  special purpose builds.
+
+* Task#clear now clears task comments as well as actions and
+  prerequisites. Task#clear_comment will specifically target comments.
+
+* The --all option will force -T and -D to consider all the tasks,
+  with and without descriptions.
+
+=== Bug Fixes
+
+* Semi-colons in windows rakefile paths now work.
+
+* Improved Control-C support when invoking multiple test suites.
+
+* egrep method now reads files in text mode (better support for
+  Windows)
+
+* Better deprecation line number reporting.
+
+* The -W option now works with all tasks, whether they have a
+  description or not.
+
+* File globs in rake should not be sorted alphabetically, independent
+  of file system and platform.
+
+* Numerous internal improvements.
+
+* Documentation typos and fixes.
 
 == What is Rake
 
@@ -28,7 +70,7 @@ The easiest way to get and install rake is via RubyGems ...
 
 Otherwise, you can get it from the more traditional places:
 
-Home Page:: http://rake.rubyforge.org/
+Home Page:: http://github.com/jimweirich/rake
 Download::  http://rubyforge.org/project/showfiles.php?group_id=50
 GitHub::    git://github.com/jimweirich/rake.git
 
@@ -38,18 +80,23 @@ As usual, it was input from users that drove a alot of these changes. The
 following people either contributed patches, made suggestions or made
 otherwise helpful comments.  Thanks to ...
 
-* James M. Lawrence (quix)
-* Roger Pack
-* Cezary Baginski
-* Sean Scot August Moon
-* R.T. Lechow
-* Alex Chaffee
-* James Tucker
-* Matthias Lüdtke
-* Santiago Pastorino
-
-Also, bit thanks to Eric Hodel for assisting with getting this release
-out the door (where "assisting" includes, but is not by any means
-limited to, "pushing" me to get it done).
+* Aaron Patterson
+* Dylan Smith
+* Jo Liss
+* Jonas Pfenniger
+* Kazuki Tsujimoto
+* Michael Bishop
+* Michael Elufimov
+* NAKAMURA Usaku
+* Ryan Davis
+* Sam Grönblom
+* Sam Phippen
+* Sergio Wong
+* Tay Ray Chuan
+* grosser
+* quix
+
+Also, many thanks to Eric Hodel for assisting with getting this release
+out the door.
 
 -- Jim Weirich

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

@@ -11,4 +11,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
-    attr_reader :stats, :items, :threads
-    private :stats, :items, :threads
+  class ThreadHistoryDisplay    # :nodoc: all
+    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

@@ -5,7 +5,7 @@ module Rake
       MINOR = 9,
       BUILD = 3,
       'beta',
-      BETA = 3,
+      BETA = 4,
     ]
   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.rb

@@ -498,4 +498,3 @@ class TestRakeApplication < Rake::TestCase
   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_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,27 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: rake
 version: !ruby/object:Gem::Version
-  version: 0.9.3.beta.3
   prerelease: 6
+  version: !binary |-
+    MC45LjMuYmV0YS40
 platform: ruby
 authors:
 - Jim Weirich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-25 00:00:00.000000000 Z
+date: 2012-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.1'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -62,6 +63,7 @@ extra_rdoc_files:
 - doc/release_notes/rake-0.8.7.rdoc
 - doc/release_notes/rake-0.9.0.rdoc
 - doc/release_notes/rake-0.9.1.rdoc
+- doc/release_notes/rake-0.9.2.2.rdoc
 - doc/release_notes/rake-0.9.2.rdoc
 - doc/release_notes/rake-0.9.3.rdoc
 files:
@@ -107,6 +109,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
@@ -126,6 +130,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
@@ -201,6 +206,7 @@ files:
 - doc/release_notes/rake-0.8.7.rdoc
 - doc/release_notes/rake-0.9.0.rdoc
 - doc/release_notes/rake-0.9.1.rdoc
+- doc/release_notes/rake-0.9.2.2.rdoc
 - doc/release_notes/rake-0.9.2.rdoc
 - doc/release_notes/rake-0.9.3.rdoc
 homepage: http://rake.rubyforge.org