rake 0.9.6 → 10.0.0.beta.1

data/lib/rake/backtrace.rb

@@ -2,12 +2,11 @@ module Rake
   module Backtrace
     SUPPRESSED_PATHS =
       RbConfig::CONFIG.values_at(*RbConfig::CONFIG.
-                                 keys.grep(/(prefix|libdir)/)).uniq + [
+                                 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+)!i
+    SUPPRESS_PATTERN = %r!(\A#{SUPPRESSED_PATHS.join('|')}|bin/rake:\d+)!
 
     def self.collapse(backtrace)
       pattern = Rake.application.options.suppress_backtrace_pattern ||

data/lib/rake/contrib/ftptools.rb

@@ -5,7 +5,6 @@
 
 require 'date'
 require 'net/ftp'
-require 'rake/file_list'
 
 module Rake # :nodoc:
 
@@ -128,7 +127,8 @@ module Rake # :nodoc:
     # Upload all files matching +wildcard+ to the uploader's root
     # path.
     def upload_files(wildcard)
-      FileList.glob(wildcard).each do |fn|
+      fail "OUCH"
+      Rake.glob(wildcard).each do |fn|
         upload(fn)
       end
     end

data/lib/rake/dsl_definition.rb

@@ -32,7 +32,6 @@ module Rake
       Rake::Task.define_task(*args, &block)
     end
 
-
     # Declare a file task.
     #
     # Example:
@@ -147,31 +146,7 @@ module Rake
         Rake.application.add_import(fn)
       end
     end
-
   end
-
-  DeprecatedCommands = Object.new.extend(DSL)
-
-  module DeprecatedObjectDSL # :nodoc:
-    DSL.private_instance_methods(false).each do |name|
-      line = __LINE__+1
-      class_eval %{
-        def #{name}(*args, &block)
-          unless Rake.application.options.ignore_deprecate
-            unless @rake_dsl_warning
-              $stderr.puts "WARNING: Global access to Rake DSL methods is deprecated.  Please include"
-              $stderr.puts "    ...  Rake::DSL into classes and modules which use the Rake DSL methods."
-              @rake_dsl_warning = true
-            end
-            $stderr.puts "WARNING: DSL method \#{self.class}##{name} called at \#{caller.first}"
-          end
-          Rake::DeprecatedCommands.send(:#{name}, *args, &block)
-        end
-        private :#{name}
-      }, __FILE__, line
-    end
-  end unless defined? Rake::REDUCE_COMPAT
-
   extend FileUtilsExt
 end
 
@@ -179,4 +154,3 @@ end
 # calls to task, etc. to work from a Rakefile without polluting the
 # object inheritance tree.
 self.extend Rake::DSL
-include Rake::DeprecatedObjectDSL unless defined? Rake::REDUCE_COMPAT

data/lib/rake/ext/module.rb

@@ -1,39 +0,0 @@
-require 'rake/ext/core'
-require 'rake/task'
-require 'rake/file_task'
-require 'rake/file_creation_task'
-require 'rake/application'
-require 'rake/task_manager'
-
-######################################################################
-# Rake extensions to Module.
-#
-class Module
-
-  # Rename the original handler to make it available.
-  alias :rake_original_const_missing :const_missing
-
-  # Check for deprecated uses of top level (i.e. in Object) uses of
-  # Rake class names.  If someone tries to reference the constant
-  # name, display a warning and return the proper object.  Using the
-  # --classic-namespace command line option will define these
-  # constants in Object and avoid this handler.
-  def const_missing(const_name)
-    case const_name
-    when :Task
-      Rake.application.const_warning(const_name)
-      Rake::Task
-    when :FileTask
-      Rake.application.const_warning(const_name)
-      Rake::FileTask
-    when :FileCreationTask
-      Rake.application.const_warning(const_name)
-      Rake::FileCreationTask
-    when :RakeApp
-      Rake.application.const_warning(const_name)
-      Rake::Application
-    else
-      rake_original_const_missing(const_name)
-    end
-  end
-end unless defined? Rake::REDUCE_COMPAT

data/lib/rake/ext/string.rb

@@ -4,7 +4,6 @@ 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
@@ -164,5 +163,5 @@ class String
       result
     end
   end
+end # class String
 
-end

data/lib/rake/ext/time.rb

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

data/lib/rake/file_list.rb

@@ -340,7 +340,7 @@ module Rake
 
     # Add matching glob patterns.
     def add_matching(pattern)
-      FileList.glob(pattern).each do |fn|
+      Rake.glob(pattern).each do |fn|
         self << fn unless exclude?(fn)
       end
     end
@@ -383,13 +383,6 @@ module Rake
       def [](*args)
         new(*args)
       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
 end

data/lib/rake/file_utils.rb

@@ -6,7 +6,7 @@ require 'fileutils'
 # added to the FileUtils utility functions.
 module FileUtils
   # Path to the currently running Ruby program
-  RUBY = ENV['RUBY'] || File.join(
+  RUBY = File.join(
     RbConfig::CONFIG['bindir'],
     RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']).
     sub(/.*\s.*/m, '"\&"')

data/lib/rake/phony.rb

@@ -8,8 +8,6 @@ require 'rake'
 
 task :phony
 
-Rake::Task[:phony].tap do |task|
-  def task.timestamp # :nodoc:
-    Time.at 0
-  end
+def (Rake::Task[:phony]).timestamp
+  Time.at 0
 end

data/lib/rake/rake_module.rb

@@ -32,6 +32,13 @@ module Rake
         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/runtest.rb

@@ -1,12 +1,11 @@
 require 'test/unit'
 require 'test/unit/assertions'
-require 'rake/file_list'
 
 module Rake
   include Test::Unit::Assertions
 
   def run_tests(pattern='test/test*.rb', log_enabled=false)
-    FileList.glob(pattern).each { |fn|
+    Rake.glob(pattern).each { |fn|
       $stderr.puts fn if log_enabled
       begin
         require fn

data/lib/rake/task.rb

@@ -105,7 +105,7 @@ module Rake
 
     # Argument description (nil if none).
     def arg_description # :nodoc:
-      @arg_names ? "[#{arg_names.join(',')}]" : nil
+      @arg_names ? "[#{(arg_names || []).join(',')}]" : nil
     end
 
     # Name of arguments for this task.
@@ -182,22 +182,21 @@ module Rake
       if application.options.always_multitask
         invoke_prerequisites_concurrently(task_args, invocation_chain)
       else
-        prerequisite_tasks.each { |p|
-          prereq_args = task_args.new_scope(p.arg_names)
-          p.invoke_with_call_chain(prereq_args, invocation_chain)
+        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(task_args, invocation_chain) # :nodoc:
-      futures = prerequisite_tasks.collect do |p|
-        prereq_args = task_args.new_scope(p.arg_names)
+    def invoke_prerequisites_concurrently(args, invocation_chain) # :nodoc:
+      futures = @prerequisites.collect do |p|
         application.thread_pool.future(p) do |r|
-          r.invoke_with_call_chain(prereq_args, invocation_chain)
+          application[r, @scope].invoke_with_call_chain(args, invocation_chain)
         end
       end
-      futures.each { |f| f.value }
+      futures.each { |f| f.call }
     end
 
     # Format the trace flags for display.

data/lib/rake/task_manager.rb

@@ -72,7 +72,6 @@ module Rake
     #
     #   task :t
     #   task :t, [:a]
-    #   task :t, :a                 (deprecated)
     #
     def resolve_args_without_dependencies(args)
       task_name = args.shift
@@ -92,8 +91,6 @@ module Rake
     #
     #   task :t => [:d]
     #   task :t, [a] => [:d]
-    #   task :t, :needs => [:d]                 (deprecated)
-    #   task :t, :a, :needs => [:d]             (deprecated)
     #
     def resolve_args_with_dependencies(args, hash) # :nodoc:
       fail "Task Argument Error" if hash.size != 1
@@ -102,14 +99,6 @@ module Rake
         task_name = key
         arg_names = []
         deps = value
-      elsif key == :needs
-        Rake.application.deprecate(
-          "task :t, arg, :needs => [deps]",
-          "task :t, [args] => [deps]",
-          caller.detect { |c| c !~ /\blib\/rake\b/ })
-        task_name = args.shift
-        arg_names = args
-        deps = value
       else
         task_name = args.shift
         arg_names = key

data/lib/rake/testtask.rb

@@ -96,12 +96,9 @@ module Rake
       desc "Run tests" + (@name==:test ? "" : " for #{@name}")
       task @name do
         FileUtilsExt.verbose(@verbose) do
-          args = "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}"
-          ruby args do |ok, status|
+          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)
-            elsif !ok
-              fail "Command failed with status (#{status.exitstatus}): [ruby #{args}]"
             end
           end
         end

data/lib/rake/thread_history_display.rb

@@ -1,11 +1,8 @@
-require 'rake/private_reader'
-
 module Rake
 
-  class ThreadHistoryDisplay    # :nodoc: all
-    include Rake::PrivateReader
-
-    private_reader :stats, :items, :threads
+  class ThreadHistoryDisplay
+    attr_reader :stats, :items, :threads
+    private :stats, :items, :threads
 
     def initialize(stats)
       @stats   = stats
@@ -16,7 +13,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,8 +1,6 @@
 require 'thread'
 require 'set'
 
-require 'rake/promise'
-
 module Rake
 
   class ThreadPool              # :nodoc: all
@@ -30,12 +28,63 @@ 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)
-      promise = Promise.new(args, &block)
-      promise.recorder = lambda { |*stats| stat(*stats) }
+    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
 
       @queue.enq promise
-      stat :queued, :item_id => promise.object_id
+      stat :item_queued, item_id: promise.object_id
       start_thread
       promise
     end
@@ -44,18 +93,14 @@ module Rake
     def join
       @threads_mon.synchronize do
         begin
-          stat :joining
-          @join_cond.wait unless @threads.empty?
-          stat :joined
+            @join_cond.wait unless @threads.empty?
         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
@@ -74,58 +119,45 @@ 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 }.
-        sort_by { |i| i[:time] }.
-        each { |i| i[:time] -= @history_start_time }
+      @history_mon.synchronize { @history.dup }
     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
-              break unless process_queue_item
+            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
             end
+          rescue ThreadError # this means the queue is empty
           ensure
             @threads_mon.synchronize do
               @threads.delete Thread.current
-              stat :ended, :thread_count => @threads.count
+              stat :thread_deleted, deleted_thread: Thread.current.object_id, 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
+        stat :thread_created, new_thread: t.object_id, thread_count: @threads.count
         @total_threads_in_play = @threads.count if @threads.count > @total_threads_in_play
       end
     end
@@ -133,10 +165,10 @@ module Rake
     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,
+        event: event,
+        data: data,
+        time: (Time.now-@history_start_time),
+        thread: Thread.current.object_id,
       }
       @history_mon.synchronize { @history << info }
     end
@@ -150,6 +182,8 @@ module Rake
     def __threads__ # :nodoc:
       @threads.dup
     end
+
+    NOT_SET = Object.new.freeze # :nodoc:
   end
 
 end