rake 0.9.2 → 13.0.3

data/lib/rake/testtask.rb

@@ -1,13 +1,13 @@
-# Define a task library for running unit tests.
-
-require 'rake'
-require 'rake/tasklib'
+# frozen_string_literal: true
+require "rake"
+require "rake/tasklib"
 
 module Rake
 
   # Create a task that runs a set of tests.
   #
   # Example:
+  #   require "rake/testtask"
   #
   #   Rake::TestTask.new do |t|
   #     t.libs << "test"
@@ -37,7 +37,7 @@ module Rake
     # Name of test task. (default is :test)
     attr_accessor :name
 
-    # List of directories to added to $LOAD_PATH before running the
+    # List of directories added to $LOAD_PATH before running the
     # tests. (default is 'lib')
     attr_accessor :libs
 
@@ -51,6 +51,7 @@ module Rake
 
     # Request that the tests be run with the warning flag set.
     # E.g. warning=true implies "ruby -w" used to run the tests.
+    # (default is true)
     attr_accessor :warning
 
     # Glob pattern to match test files. (default is 'test/test*.rb')
@@ -64,9 +65,15 @@ module Rake
     #
     attr_accessor :loader
 
-    # Array of commandline options to pass to ruby when running test loader.
+    # Array of command line options to pass to ruby when running test loader.
     attr_accessor :ruby_opts
 
+    # Description of the test task. (default is 'Run tests')
+    attr_accessor :description
+
+    # Task prerequisites.
+    attr_accessor :deps
+
     # Explicitly define the list of test files to be included in a
     # test.  +list+ is expected to be an array of file names (a
     # FileList is acceptable).  If both +pattern+ and +test_files+ are
@@ -83,108 +90,99 @@ module Rake
       @options = nil
       @test_files = nil
       @verbose = false
-      @warning = false
+      @warning = true
       @loader = :rake
       @ruby_opts = []
+      @description = "Run tests" + (@name == :test ? "" : " for #{@name}")
+      @deps = []
+      if @name.is_a?(Hash)
+        @deps = @name.values.first
+        @name = @name.keys.first
+      end
       yield self if block_given?
-      @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil?
+      @pattern = "test/test*.rb" if @pattern.nil? && @test_files.nil?
       define
     end
 
     # Create the tasks defined by this task lib.
     def define
-      desc "Run tests" + (@name==:test ? "" : " for #{@name}")
-      task @name do
+      desc @description
+      task @name => Array(deps) do
         FileUtilsExt.verbose(@verbose) do
-          ruby "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}"
+          puts "Use TESTOPTS=\"--verbose\" to pass --verbose" \
+            ", etc. to runners." if ARGV.include? "--verbose"
+          args =
+            "#{ruby_opts_string} #{run_code} " +
+            "#{file_list_string} #{option_list}"
+          ruby args do |ok, status|
+            if !ok && status.respond_to?(:signaled?) && status.signaled?
+              raise SignalException.new(status.termsig)
+            elsif !ok
+              status  = "Command failed with status (#{status.exitstatus})"
+              details = ": [ruby #{args}]"
+              message =
+                if Rake.application.options.trace or @verbose
+                  status + details
+                else
+                  status
+                end
+
+              fail message
+            end
+          end
         end
       end
       self
     end
 
     def option_list # :nodoc:
-      (ENV['TESTOPTS'] ||
-        ENV['TESTOPT'] ||
-        ENV['TEST_OPTS'] ||
-        ENV['TEST_OPT'] ||
+      (ENV["TESTOPTS"] ||
+        ENV["TESTOPT"] ||
+        ENV["TEST_OPTS"] ||
+        ENV["TEST_OPT"] ||
         @options ||
         "")
     end
 
-    def ruby_opts_string
+    def ruby_opts_string # :nodoc:
       opts = @ruby_opts.dup
-      opts.unshift( "-I\"#{lib_path}\"" ) unless @libs.empty?
-      opts.unshift( "-w" ) if @warning
+      opts.unshift("-I\"#{lib_path}\"") unless @libs.empty?
+      opts.unshift("-w") if @warning
       opts.join(" ")
     end
 
-    def lib_path
+    def lib_path # :nodoc:
       @libs.join(File::PATH_SEPARATOR)
     end
 
-    def file_list_string
-      file_list.collect { |fn| "\"#{fn}\"" }.join(' ')
+    def file_list_string # :nodoc:
+      file_list.map { |fn| "\"#{fn}\"" }.join(" ")
     end
 
     def file_list # :nodoc:
-      if ENV['TEST']
-        FileList[ ENV['TEST'] ]
+      if ENV["TEST"]
+        FileList[ENV["TEST"]]
       else
         result = []
         result += @test_files.to_a if @test_files
-        result << @pattern if @pattern
+        result += FileList[@pattern].to_a if @pattern
         result
       end
     end
 
-    def fix # :nodoc:
-      case ruby_version
-      when '1.8.2'
-        "\"#{find_file 'rake/ruby182_test_unit_fix'}\""
-      else
-        nil
-      end || ''
-    end
-
-    def ruby_version
+    def ruby_version # :nodoc:
       RUBY_VERSION
     end
 
-    def run_code
+    def run_code # :nodoc:
       case @loader
       when :direct
         "-e \"ARGV.each{|f| require f}\""
       when :testrb
-        "-S testrb #{fix}"
+        "-S testrb"
       when :rake
-        "-I\"#{rake_lib_dir}\" \"#{rake_loader}\""
-      end
-    end
-
-    def rake_loader # :nodoc:
-      find_file('rake/rake_test_loader') or
-        fail "unable to find rake test loader"
-    end
-
-    def find_file(fn) # :nodoc:
-      $LOAD_PATH.each do |path|
-        file_path = File.join(path, "#{fn}.rb")
-        return file_path if File.exist? file_path
-      end
-      nil
-    end
-
-    def rake_lib_dir # :nodoc:
-      find_dir('rake') or
-        fail "unable to find rake lib"
-    end
-
-    def find_dir(fn) # :nodoc:
-      $LOAD_PATH.each do |path|
-        file_path = File.join(path, "#{fn}.rb")
-        return path if File.exist? file_path
+        "#{__dir__}/rake_test_loader.rb"
       end
-      nil
     end
 
   end

data/lib/rake/thread_history_display.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+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 do |k, v| "#{k}:#{v}" end.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,163 @@
+# frozen_string_literal: true
+require "set"
+
+require "rake/promise"
+
+module Rake
+
+  class ThreadPool # :nodoc: all
+
+    # Creates a ThreadPool object.  The +thread_count+ 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
+    # Thread#new) The return value is an object representing
+    # a future which has been created and added to the queue in the
+    # pool. Sending #value 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"
+            $stderr.puts t.backtrace.join("\n")
+          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 safe_thread_count
+      @threads_mon.synchronize do
+        @threads.count
+      end
+    end
+
+    def start_thread # :nodoc:
+      @threads_mon.synchronize do
+        next unless @threads.count < @max_active_threads
+
+        t = Thread.new do
+          begin
+            while safe_thread_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
+  end
+
+end

data/lib/rake/trace_output.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Rake
+  module TraceOutput # :nodoc: all
+
+    # Write trace output to output stream +out+.
+    #
+    # The write is done as a single IO call (to print) to lessen the
+    # chance that the trace output is interrupted by other tasks also
+    # producing output.
+    def trace_on(out, *strings)
+      sep = $\ || "\n"
+      if strings.empty?
+        output = sep
+      else
+        output = strings.map { |s|
+          next if s.nil?
+          s.end_with?(sep) ? s : s + sep
+        }.join
+      end
+      out.print(output)
+    end
+  end
+end

data/lib/rake/version.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
 module Rake
-  module Version
-    NUMBERS = [
-      MAJOR = 0,
-      MINOR = 9,
-      BUILD = 2,
-    ]
+  VERSION = "13.0.3"
+
+  module Version # :nodoc: all
+    MAJOR, MINOR, BUILD, *OTHER = Rake::VERSION.split "."
+
+    NUMBERS = [MAJOR, MINOR, BUILD, *OTHER]
   end
-  VERSION = Version::NUMBERS.join('.')
 end