rake 0.9.3.beta.1 → 0.9.3.beta.2

data/lib/rake/clean.rb

@@ -16,7 +16,7 @@ require 'rake'
 # :stopdoc:
 CLEAN = Rake::FileList["**/*~", "**/*.bak", "**/core"]
 CLEAN.clear_exclude.exclude { |fn|
-  fn.pathmap("%f") == 'core' && File.directory?(fn)
+  fn.pathmap("%f").downcase == 'core' && File.directory?(fn)
 }
 
 desc "Remove any temporary products."

data/lib/rake/cloneable.rb

@@ -3,23 +3,14 @@ module Rake
   # Mixin for creating easily cloned objects.
   #
   module Cloneable
-    # Clone an object by making a new object and setting all the instance
-    # variables to the same values.
-    def dup
-      sibling = self.class.new
-      instance_variables.each do |ivar|
-        value = self.instance_variable_get(ivar)
-        new_value = value.clone rescue value
-        sibling.instance_variable_set(ivar, new_value)
+    # The hook that invoked by 'clone' and 'dup' methods.
+    def initialize_copy(source)
+      super
+      source.instance_variables.each do |var|
+        src_value  = source.instance_variable_get(var)
+        value = src_value.clone rescue src_value
+        instance_variable_set(var, value)
       end
-      sibling.taint if tainted?
-      sibling
-    end
-
-    def clone
-      sibling = dup
-      sibling.freeze if frozen?
-      sibling
     end
   end
 end

data/lib/rake/contrib/ftptools.rb

@@ -127,7 +127,8 @@ module Rake # :nodoc:
     # Upload all files matching +wildcard+ to the uploader's root
     # path.
     def upload_files(wildcard)
-      Dir[wildcard].each do |fn|
+      fail "OUCH"
+      Rake.glob(wildcard).each do |fn|
         upload(fn)
       end
     end

data/lib/rake/contrib/sys.rb

@@ -27,7 +27,7 @@ module Sys
   # Install all the files matching +wildcard+ into the +dest_dir+
   # directory.  The permission mode is set to +mode+.
   def install(wildcard, dest_dir, mode)
-    Dir[wildcard].each do |fn|
+    Rake.glob(wildcard).each do |fn|
       File.install(fn, dest_dir, mode, $verbose)
     end
   end
@@ -81,7 +81,7 @@ module Sys
   # recursively delete directories.
   def delete(*wildcards)
     wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
+      Rake.glob(wildcard).each do |fn|
         if File.directory?(fn)
           log "Deleting directory #{fn}"
           Dir.delete(fn)
@@ -96,10 +96,10 @@ module Sys
   # Recursively delete all files and directories matching +wildcard+.
   def delete_all(*wildcards)
     wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
+      Rake.glob(wildcard).each do |fn|
         next if ! File.exist?(fn)
         if File.directory?(fn)
-          Dir["#{fn}/*"].each do |subfn|
+          Rake.glob("#{fn}/*").each do |subfn|
             next if subfn=='.' || subfn=='..'
             delete_all(subfn)
           end
@@ -161,7 +161,7 @@ module Sys
   # Perform a block with each file matching a set of wildcards.
   def for_files(*wildcards)
     wildcards.each do |wildcard|
-      Dir[wildcard].each do |fn|
+      Rake.glob(wildcard).each do |fn|
         yield(fn)
       end
     end
@@ -172,7 +172,7 @@ module Sys
   private # ----------------------------------------------------------
 
   def for_matching_files(wildcard, dest_dir)
-    Dir[wildcard].each do |fn|
+    Rake.glob(wildcard).each do |fn|
       dest_file = File.join(dest_dir, fn)
       parent = File.dirname(dest_file)
       makedirs(parent) if ! File.directory?(parent)

data/lib/rake/dsl_definition.rb

@@ -78,8 +78,8 @@ module Rake
     # Example:
     #   multitask :deploy => [:deploy_gem, :deploy_rdoc]
     #
-    def multitask(args, &block)
-      Rake::MultiTask.define_task(args, &block)
+    def multitask(*args, &block)
+      Rake::MultiTask.define_task(*args, &block)
     end
 
     # Create a new rake namespace and use it for evaluating the given

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

@@ -6,10 +6,12 @@ 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 }
+      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
   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/rake_module.rb

@@ -24,6 +24,13 @@ module Rake
     def load_rakefile(path)
       load(path)
     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)

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

@@ -0,0 +1,133 @@
+require 'thread'
+require 'set'
+
+module Rake
+
+  class ThreadPool
+
+    # 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
+      @threads = Set.new
+      @threads_mon = Monitor.new
+      @queue = Queue.new
+      @join_cond = @threads_mon.new_cond
+    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)
+    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 { promise_mutex.synchronize{} }
+
+          unless @threads_mon.synchronize { @threads.include? Thread.current }
+            wait_for_promise.call
+          else
+            @threads_mon.synchronize { @max_thread_count += 1 }
+            start_thread
+            wait_for_promise.call
+            @threads_mon.synchronize { @max_thread_count -= 1 }
+          end
+        end
+        promise_error.equal?(NOT_SET) ? promise_result : raise(promise_error)
+      end
+
+      @queue.enq promise
+      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")
+          @threads.each do |t|
+            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
+      @threads_mon.synchronize do
+        next unless @threads.count < @max_thread_count
+
+        @threads << 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
+            end
+          rescue ThreadError # this means the queue is empty
+          ensure
+            @threads_mon.synchronize do
+              @threads.delete Thread.current
+              @join_cond.broadcast if @threads.empty?
+            end
+          end
+        end
+      end
+    end
+    
+    # for testing only
+    
+    def __queue__
+      @queue
+    end
+    
+    def __threads__
+      @threads.dup
+    end
+    
+    NOT_SET = Object.new.freeze
+    FIXNUM_MAX = (2**(0.size * 8 - 2) - 1) # FIXNUM_MAX
+  end
+  
+end

data/lib/rake/version.rb

@@ -1,8 +1,12 @@
 module Rake
-  VERSION = '0.9.3.beta.1'
-
   module Version # :nodoc: all
-    MAJOR, MINOR, BUILD = VERSION.split '.'
-    NUMBERS = [ MAJOR, MINOR, BUILD ]
+    NUMBERS = [
+      MAJOR = 0,
+      MINOR = 9,
+      BUILD = 3,
+      'beta',
+      BETA = 2,
+    ]
   end
+  VERSION = Version::NUMBERS.join('.')
 end

data/test/helper.rb

@@ -488,5 +488,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