rake 0.7.3 → 0.8.7

data/lib/rake.rb

@@ -2,7 +2,7 @@
 
 #--
 
-# Copyright (c) 2003, 2004, 2005, 2006 Jim Weirich
+# Copyright 2003, 2004, 2005, 2006, 2007, 2008 by Jim Weirich (jim@weirichhouse.org)
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -24,26 +24,28 @@
 #++
 #
 # = Rake -- Ruby Make
-#      
+#
 # This is the main file for the Rake application.  Normally it is referenced
 # as a library via a require statement, but it can be distributed
 # independently as an application.
 
-RAKEVERSION = '0.7.3'
+RAKEVERSION = '0.8.7'
 
 require 'rbconfig'
-require 'ftools'
-require 'getoptlong'
 require 'fileutils'
 require 'singleton'
-require 'thread'
+require 'monitor'
+require 'optparse'
 require 'ostruct'
 
+require 'rake/win32'
+
+$trace = false
+
 ######################################################################
 # Rake extensions to Module.
 #
 class Module
-
   # Check for an existing method in the current class before extending.  IF
   # the method already exists, then a warning is printed and the extension is
   # not added.  Otherwise the block is yielded and any definitions in the
@@ -60,13 +62,13 @@ class Module
   #   end
   #
   def rake_extension(method)
-    if instance_methods.include?(method)
+    if method_defined?(method)
       $stderr.puts "WARNING: Possible conflict with Rake extension: #{self}##{method} already exists"
     else
       yield
     end
   end
-end
+end # module Module
 
 
 ######################################################################
@@ -74,7 +76,7 @@ end
 #
 class String
   rake_extension("ext") do
-    # Replace the file extension with +newext+.  If there is no extenson on
+    # 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
     # is not given, or is the empty string, remove any existing extension.
     #
@@ -84,7 +86,7 @@ class String
       if newext != ''
         newext = (newext =~ /^\./) ? newext : ("." + newext)
       end
-      dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext
+      self.chomp(File.extname(self)) << newext
     end
   end
 
@@ -103,23 +105,19 @@ class String
     # front end (left hand side) if +n+ is positive.  Include |+n+|
     # directories from the back end (right hand side) if +n+ is negative.
     def pathmap_partial(n)
-      target = File.dirname(self)
-      dirs = target.pathmap_explode
-      if n > 0
-        File.join(dirs[0...n])
-      elsif n < 0
-        partial = dirs[n..-1]
-        if partial.nil? || partial.empty?
-          target
+      dirs = File.dirname(self).pathmap_explode
+      partial_dirs =
+        if n > 0
+          dirs[0...n]
+        elsif n < 0
+          dirs.reverse[0...-n].reverse
         else
-          File.join(partial)
+          "."
         end
-      else
-        "."
-      end
+      File.join(partial_dirs)
     end
     protected :pathmap_partial
-
+      
     # Preform the pathmap replacement operations on the given path. The
     # patterns take the form 'pat1,rep1;pat2,rep2...'.
     def pathmap_replace(patterns, &block)
@@ -143,7 +141,7 @@ class String
     # controls the details of the mapping.  The following special patterns are
     # recognized:
     #
-    # * <b>%p</b> -- The complete path.   
+    # * <b>%p</b> -- The complete path.
     # * <b>%f</b> -- The base file name of the path, with its file extension,
     #   but without any directories.
     # * <b>%n</b> -- The file name of the path without its file extension.
@@ -165,7 +163,7 @@ class String
     #   'a/b/c/d/file.txt'.pathmap("%2d")   => 'a/b'
     #   'a/b/c/d/file.txt'.pathmap("%-2d")  => 'c/d'
     #
-    # Also the %d, %p, $f, $n, %x, and %X operators can take a
+    # Also the %d, %p, %f, %n, %x, and %X operators can take a
     # pattern/replacement argument to perform simple string substititions on a
     # particular part of the path.  The pattern and replacement are speparated
     # by a comma and are enclosed by curly braces.  The replacement spec comes
@@ -178,10 +176,10 @@ class String
     # excluded from both the pattern and replacement text (let's keep parsing
     # reasonable).
     #
-    # For example: 
+    # For example:
     #
     #    "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
-    #  
+    #
     # returns:
     #
     #    "bin/org/onestepback/proj/A.class"
@@ -211,13 +209,9 @@ class String
         when '%d'
           result << File.dirname(self)
         when '%x'
-          result << $1 if self =~ /[^\/](\.[^.]+)$/
+          result << File.extname(self)
         when '%X'
-          if self =~ /^(.+[^\/])(\.[^.]+)$/
-            result << $1
-          else
-            result << self
-          end
+          result << self.ext
         when '%p'
           result << self
         when '%s'
@@ -240,11 +234,33 @@ class String
       result
     end
   end
-end
+end # class String
 
 ##############################################################################
 module Rake
 
+  # Errors -----------------------------------------------------------
+
+  # Error indicating an ill-formed task declaration.
+  class TaskArgumentError < ArgumentError
+  end
+
+  # Error indicating a recursion overflow error in task selection.
+  class RuleRecursionOverflowError < StandardError
+    def initialize(*args)
+      super
+      @targets = []
+    end
+
+    def add_target(target)
+      @targets << target
+    end
+
+    def message
+      super + ": [" + @targets.reverse.join(' => ') + "]"
+    end
+  end
+
   # --------------------------------------------------------------------------
   # Rake module singleton methods.
   #
@@ -266,28 +282,182 @@ module Rake
 
   end
 
-  # ##########################################################################
+  ####################################################################
   # 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 clone
+    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)
       end
+      sibling.taint if tainted?
+      sibling
+    end
+
+    def clone
+      sibling = dup
+      sibling.freeze if frozen?
       sibling
     end
-    alias dup clone
   end
-end
+
+  ####################################################################
+  # Exit status class for times the system just gives us a nil.
+  class PseudoStatus
+    attr_reader :exitstatus
+    def initialize(code=0)
+      @exitstatus = code
+    end
+    def to_i
+      @exitstatus << 8
+    end
+    def >>(n)
+      to_i >> n
+    end
+    def stopped?
+      false
+    end
+    def exited?
+      true
+    end
+  end
+
+  ####################################################################
+  # TaskAguments manage the arguments passed to a task.
+  #
+  class TaskArguments
+    include Enumerable
+
+    attr_reader :names
+
+    # Create a TaskArgument object with a list of named arguments
+    # (given by :names) and a set of associated values (given by
+    # :values).  :parent is the parent argument object.
+    def initialize(names, values, parent=nil)
+      @names = names
+      @parent = parent
+      @hash = {}
+      names.each_with_index { |name, i|
+        @hash[name.to_sym] = values[i] unless values[i].nil?
+      }
+    end
+
+    # Create a new argument scope using the prerequisite argument
+    # names.
+    def new_scope(names)
+      values = names.collect { |n| self[n] }
+      self.class.new(names, values, self)
+    end
+
+    # Find an argument value by name or index.
+    def [](index)
+      lookup(index.to_sym)
+    end
+
+    # Specify a hash of default values for task arguments. Use the
+    # defaults only if there is no specific value for the given
+    # argument.
+    def with_defaults(defaults)
+      @hash = defaults.merge(@hash)
+    end
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def method_missing(sym, *args, &block)
+      lookup(sym.to_sym)
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_s
+      @hash.inspect
+    end
+
+    def inspect
+      to_s
+    end
+    
+    protected
+    
+    def lookup(name)
+      if @hash.has_key?(name)
+        @hash[name]
+      elsif ENV.has_key?(name.to_s)
+        ENV[name.to_s]
+      elsif ENV.has_key?(name.to_s.upcase)
+        ENV[name.to_s.upcase]
+      elsif @parent
+        @parent.lookup(name)
+      end
+    end
+  end
+
+  EMPTY_TASK_ARGS = TaskArguments.new([], [])
+
+  ####################################################################
+  # InvocationChain tracks the chain of task invocations to detect
+  # circular dependencies.
+  class InvocationChain
+    def initialize(value, tail)
+      @value = value
+      @tail = tail
+    end
+
+    def member?(obj)
+      @value == obj || @tail.member?(obj)
+    end
+
+    def append(value)
+      if member?(value)
+        fail RuntimeError, "Circular dependency detected: #{to_s} => #{value}"
+      end
+      self.class.new(value, self)
+    end
+
+    def to_s
+      "#{prefix}#{@value}"
+    end
+
+    def self.append(value, chain)
+      chain.append(value)
+    end
+
+    private
+
+    def prefix
+      "#{@tail.to_s} => "
+    end
+
+    class EmptyInvocationChain
+      def member?(obj)
+        false
+      end
+      def append(value)
+        InvocationChain.new(value, self)
+      end
+      def to_s
+        "TOP"
+      end
+    end
+
+    EMPTY = EmptyInvocationChain.new
+
+  end # class InvocationChain
+
+end # module Rake
 
 module Rake
 
-  # #########################################################################
+  ###########################################################################
   # A Task is the basic unit of work in a Rakefile.  Tasks have associated
   # actions (possibly more than one) and a list of prerequisites.  When
   # invoked, a task will first ensure that all of its prerequisites have an
@@ -300,12 +470,19 @@ module Rake
     # List of prerequisites for a task.
     attr_reader :prerequisites
 
+    # List of actions attached to a task.
+    attr_reader :actions
+
     # Application owning this task.
     attr_accessor :application
-    
-    # Comment for this task.
-    attr_accessor :comment
-    
+
+    # Comment for this task.  Restricted to a single line of no more than 50
+    # characters.
+    attr_reader :comment
+
+    # Full text of the (possibly multi-line) comment.
+    attr_reader :full_comment
+
     # Array of nested namespaces names used for task lookup by this task.
     attr_reader :scope
 
@@ -313,7 +490,11 @@ module Rake
     def to_s
       name
     end
-    
+
+    def inspect
+      "<#{self.class} #{name} => [#{prerequisites.join(', ')}]>"
+    end
+
     # List of sources for task.
     attr_writer :sources
     def sources
@@ -324,49 +505,106 @@ module Rake
     def source
       @sources.first if defined?(@sources)
     end
-    
+
     # Create a task named +task_name+ with no actions or prerequisites. Use
     # +enhance+ to add actions and prerequisites.
     def initialize(task_name, app)
       @name = task_name.to_s
-      @prerequisites = FileList[]
+      @prerequisites = []
       @actions = []
       @already_invoked = false
+      @full_comment = nil
       @comment = nil
-      @lock = Mutex.new
+      @lock = Monitor.new
       @application = app
       @scope = app.current_scope
+      @arg_names = nil
     end
-    
+
     # Enhance a task with prerequisites or actions.  Returns self.
     def enhance(deps=nil, &block)
       @prerequisites |= deps if deps
       @actions << block if block_given?
       self
     end
-    
+
     # Name of the task, including any namespace qualifiers.
     def name
       @name.to_s
     end
-    
+
+    # Name of task with argument list description.
+    def name_with_args # :nodoc:
+      if arg_description
+        "#{name}#{arg_description}"
+      else
+        name
+      end
+    end
+
+    # Argument description (nil if none).
+    def arg_description # :nodoc:
+      @arg_names ? "[#{(arg_names || []).join(',')}]" : nil
+    end
+
+    # Name of arguments for this task.
+    def arg_names
+      @arg_names || []
+    end
+
+    # Reenable the task, allowing its tasks to be executed if the task
+    # is invoked again.
+    def reenable
+      @already_invoked = false
+    end
+
+    # Clear the existing prerequisites and actions of a rake task.
+    def clear
+      clear_prerequisites
+      clear_actions
+      self
+    end
+
+    # Clear the existing prerequisites of a rake task.
+    def clear_prerequisites
+      prerequisites.clear
+      self
+    end
+
+    # Clear the existing actions on a rake task.
+    def clear_actions
+      actions.clear
+      self
+    end
+
     # Invoke the task if it is needed.  Prerequites are invoked first.
-    def invoke
+    def invoke(*args)
+      task_args = TaskArguments.new(arg_names, args)
+      invoke_with_call_chain(task_args, InvocationChain::EMPTY)
+    end
+
+    # Same as invoke, but explicitly pass a call chain to detect
+    # circular dependencies.
+    def invoke_with_call_chain(task_args, invocation_chain) # :nodoc:
+      new_chain = InvocationChain.append(self, invocation_chain)
       @lock.synchronize do
         if application.options.trace
           puts "** Invoke #{name} #{format_trace_flags}"
         end
         return if @already_invoked
         @already_invoked = true
-        invoke_prerequisites
-        execute if needed?
+        invoke_prerequisites(task_args, new_chain)
+        execute(task_args) if needed?
       end
     end
+    protected :invoke_with_call_chain
 
     # Invoke all the prerequisites of a task.
-    def invoke_prerequisites
+    def invoke_prerequisites(task_args, invocation_chain) # :nodoc:
       @prerequisites.each { |n|
-        application[n, @scope].invoke
+        prereq = application[n, @scope]
+        prereq_args = task_args.new_scope(prereq.arg_names)
+        prereq.invoke_with_call_chain(prereq_args, invocation_chain)
       }
     end
 
@@ -378,9 +616,10 @@ module Rake
       flags.empty? ? "" : "(" + flags.join(", ") + ")"
     end
     private :format_trace_flags
-    
+
     # Execute the actions associated with this task.
-    def execute
+    def execute(args=nil)
+      args ||= EMPTY_TASK_ARGS
       if application.options.dryrun
         puts "** Execute (dry run) #{name}"
         return
@@ -389,37 +628,68 @@ module Rake
         puts "** Execute #{name}"
       end
       application.enhance_with_matching_rule(name) if @actions.empty?
-      @actions.each { |act| result = act.call(self) }
+      @actions.each do |act|
+        case act.arity
+        when 1
+          act.call(self)
+        else
+          act.call(self, args)
+        end
+      end
     end
-    
+
     # Is this task needed?
     def needed?
       true
     end
-    
+
     # Timestamp for this task.  Basic tasks return the current time for their
     # time stamp.  Other tasks can be more sophisticated.
     def timestamp
       @prerequisites.collect { |p| application[p].timestamp }.max || Time.now
     end
-    
+
+    # Add a description to the task.  The description can consist of an option
+    # argument list (enclosed brackets) and an optional comment.
+    def add_description(description)
+      return if ! description
+      comment = description.strip
+      add_comment(comment) if comment && ! comment.empty?
+    end
+
+    # Writing to the comment attribute is the same as adding a description.
+    def comment=(description)
+      add_description(description)
+    end
+
     # Add a comment to the task.  If a comment alread exists, separate
     # the new comment with " / ".
     def add_comment(comment)
-      return if ! comment
-      if @comment 
-        @comment << " / "
+      if @full_comment
+        @full_comment << " / "
+      else
+        @full_comment = ''
+      end
+      @full_comment << comment
+      if @full_comment =~ /\A([^.]+?\.)( |$)/
+        @comment = $1
       else
-        @comment = ''
+        @comment = @full_comment
       end
-      @comment << comment
     end
-    
+    private :add_comment
+
+    # Set the names of the arguments for this task. +args+ should be
+    # an array of symbols, one for each argument name.
+    def set_arg_names(args)
+      @arg_names = args.map { |a| a.to_sym }
+    end
+
     # Return a string describing the internal state of a task.  Useful for
     # debugging.
     def investigation
       result = "------------------------------\n"
-      result << "Investigating #{name}\n" 
+      result << "Investigating #{name}\n"
       result << "class: #{self.class}\n"
       result <<  "task needed: #{needed?}\n"
       result <<  "timestamp: #{timestamp}\n"
@@ -434,23 +704,23 @@ module Rake
       result << "................................\n\n"
       return result
     end
-    
+
     # ----------------------------------------------------------------
     # Rake Module Methods
-    #    
+    #
     class << self
-      
+
       # Clear the task list.  This cause rake to immediately forget all the
       # tasks that have been assigned.  (Normally used in the unit tests.)
       def clear
         Rake.application.clear
       end
-      
+
       # List of all defined tasks.
       def tasks
         Rake.application.tasks
       end
-      
+
       # Return a task with the given name.  If the task is not currently
       # known, try to synthesize one from the defined rules.  If no rules are
       # found, but an existing file matches the task name, assume it is a file
@@ -458,22 +728,22 @@ module Rake
       def [](task_name)
         Rake.application[task_name]
       end
-      
+
       # TRUE if the task name is already defined.
       def task_defined?(task_name)
         Rake.application.lookup(task_name) != nil
       end
-      
+
       # Define a task given +args+ and an option block.  If a rule with the
       # given name already exists, the prerequisites and actions are added to
       # the existing task.  Returns the defined task.
-      def define_task(args, &block)
-        Rake.application.define_task(self, args, &block)
+      def define_task(*args, &block)
+        Rake.application.define_task(self, *args, &block)
       end
-      
-      # Define a rule for synthesizing tasks.  
-      def create_rule(args, &block)
-        Rake.application.create_rule(args, &block)
+
+      # Define a rule for synthesizing tasks.
+      def create_rule(*args, &block)
+        Rake.application.create_rule(*args, &block)
       end
 
       # Apply the scope to the task name according to the rules for
@@ -483,26 +753,24 @@ module Rake
         (scope + [task_name]).join(':')
       end
 
-    end
-  end
-  
-  
-  # #########################################################################
+    end # class << Rake::Task
+  end # class Rake::Task
+
+
+  ###########################################################################
   # A FileTask is a task that includes time based dependencies.  If any of a
   # FileTask's prerequisites have a timestamp that is later than the file
   # represented by this task, then the file must be rebuilt (using the
   # supplied actions).
   #
   class FileTask < Task
-    
+
     # Is this file task needed?  Yes if it doesn't exist, or if its time stamp
     # is out of date.
     def needed?
-      return true unless File.exist?(name)
-      return true if out_of_date?(timestamp)
-      false
+      ! File.exist?(name) || out_of_date?(timestamp)
     end
-    
+
     # Time stamp for file task.
     def timestamp
       if File.exist?(name)
@@ -529,9 +797,9 @@ module Rake
         task_name
       end
     end
-  end
-  
-  # #########################################################################
+  end # class Rake::FileTask
+
+  ###########################################################################
   # A FileCreationTask is a file task that when used as a dependency will be
   # needed if and only if the file has not been created.  Once created, it is
   # not re-triggered if any of its dependencies are newer, nor does trigger
@@ -542,7 +810,7 @@ module Rake
     def needed?
       ! File.exist?(name)
     end
-    
+
     # Time stamp for file creation task.  This time stamp is earlier
     # than any other time stamp.
     def timestamp
@@ -550,21 +818,22 @@ module Rake
     end
   end
 
-  # #########################################################################
+  ###########################################################################
   # Same as a regular task, but the immediate prerequisites are done in
   # parallel using Ruby threads.
   #
   class MultiTask < Task
-    def invoke_prerequisites
+    private
+    def invoke_prerequisites(args, invocation_chain)
       threads = @prerequisites.collect { |p|
-        Thread.new(p) { |r| application[r].invoke }
+        Thread.new(p) { |r| application[r].invoke_with_call_chain(args, invocation_chain) }
       }
       threads.each { |t| t.join }
     end
   end
-end
+end # module Rake
 
-# ###########################################################################
+## ###########################################################################
 # Task Definition Functions ...
 
 # Declare a basic task.
@@ -574,8 +843,8 @@ end
 #     rm_rf "html"
 #   end
 #
-def task(args, &block)
-  Rake::Task.define_task(args, &block)
+def task(*args, &block)
+  Rake::Task.define_task(*args, &block)
 end
 
 
@@ -592,8 +861,8 @@ end
 #     end
 #  end
 #
-def file(args, &block)
-  Rake::FileTask.define_task(args, &block)
+def file(*args, &block)
+  Rake::FileTask.define_task(*args, &block)
 end
 
 # Declare a file creation task.
@@ -648,8 +917,8 @@ end
 #    sh %{cc -o #{t.name} #{t.source}}
 #  end
 #
-def rule(args, &block)
-  Rake::Task.create_rule(args, &block)
+def rule(*args, &block)
+  Rake::Task.create_rule(*args, &block)
 end
 
 # Describe the next rake task.
@@ -660,8 +929,8 @@ end
 #     runtests
 #   end
 #
-def desc(comment)
-  Rake.application.last_comment = comment
+def desc(description)
+  Rake.application.last_description = description
 end
 
 # Import the partial Rakefiles +fn+.  Imported files are loaded _after_ the
@@ -683,12 +952,19 @@ def import(*fns)
   end
 end
 
-# ###########################################################################
+#############################################################################
 # This a FileUtils extension that defines several additional commands to be
 # added to the FileUtils utility functions.
 #
 module FileUtils
-  RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  RUBY_EXT = ((Config::CONFIG['ruby_install_name'] =~ /\.(com|cmd|exe|bat|rb|sh)$/) ?
+    "" :
+    Config::CONFIG['EXEEXT'])
+  
+  RUBY = File.join(
+    Config::CONFIG['bindir'],
+    Config::CONFIG['ruby_install_name'] + RUBY_EXT).
+    sub(/.*\s.*/m, '"\&"')
 
   OPT_TABLE['sh']  = %w(noop verbose)
   OPT_TABLE['ruby'] = %w(noop verbose)
@@ -713,20 +989,33 @@ module FileUtils
     options = (Hash === cmd.last) ? cmd.pop : {}
     unless block_given?
       show_command = cmd.join(" ")
-      show_command = show_command[0,42] + "..." 
-        # TODO code application logic heref show_command.length > 45
+      show_command = show_command[0,42] + "..." unless $trace
+      # TODO code application logic heref show_command.length > 45
       block = lambda { |ok, status|
         ok or fail "Command failed with status (#{status.exitstatus}): [#{show_command}]"
       }
     end
+    if RakeFileUtils.verbose_flag == :default
+      options[:verbose] = true
+    else
+      options[:verbose] ||= RakeFileUtils.verbose_flag
+    end
+    options[:noop]    ||= RakeFileUtils.nowrite_flag
     rake_check_options options, :noop, :verbose
     rake_output_message cmd.join(" ") if options[:verbose]
     unless options[:noop]
-      res = system(*cmd)
-      block.call(res, $?)
+      res = rake_system(*cmd)
+      status = $?
+      status = PseudoStatus.new(1) if !res && status.nil?
+      block.call(res, status)
     end
   end
 
+  def rake_system(*cmd)
+    Rake::AltSystem.system(*cmd)
+  end
+  private :rake_system
+
   # Run a Ruby interpreter with the given arguments.
   #
   # Example:
@@ -737,10 +1026,10 @@ module FileUtils
     if args.length > 1 then
       sh(*([RUBY] + args + [options]), &block)
     else
-      sh("#{RUBY} #{args}", options, &block)
+      sh("#{RUBY} #{args.first}", options, &block)
     end
   end
-  
+
   LN_SUPPORTED = [true]
 
   #  Attempt to do a normal file link, but fall back to a copy if the link
@@ -771,7 +1060,7 @@ module FileUtils
   end
 end
 
-# ###########################################################################
+#############################################################################
 # RakeFileUtils provides a custom version of the FileUtils methods that
 # respond to the <tt>verbose</tt> and <tt>nowrite</tt> commands.
 #
@@ -781,18 +1070,18 @@ module RakeFileUtils
   class << self
     attr_accessor :verbose_flag, :nowrite_flag
   end
-  RakeFileUtils.verbose_flag = true
+  RakeFileUtils.verbose_flag = :default
   RakeFileUtils.nowrite_flag = false
-  
+
   $fileutils_verbose = true
   $fileutils_nowrite = false
-  
+
   FileUtils::OPT_TABLE.each do |name, opts|
     default_options = []
-    if opts.include?('verbose')
+    if opts.include?(:verbose) || opts.include?("verbose")
       default_options << ':verbose => RakeFileUtils.verbose_flag'
     end
-    if opts.include?('noop')
+    if opts.include?(:noop) || opts.include?("noop")
       default_options << ':noop => RakeFileUtils.nowrite_flag'
     end
 
@@ -807,7 +1096,7 @@ module RakeFileUtils
     EOS
   end
 
-  # Get/set the verbose flag controlling output from the FileUtils utilities. 
+  # Get/set the verbose flag controlling output from the FileUtils utilities.
   # If verbose is true, then the utility method is echoed to standard output.
   #
   # Examples:
@@ -828,7 +1117,7 @@ module RakeFileUtils
     RakeFileUtils.verbose_flag
   end
 
-  # Get/set the nowrite flag controlling output from the FileUtils utilities. 
+  # Get/set the nowrite flag controlling output from the FileUtils utilities.
   # If verbose is true, then the utility method is echoed to standard output.
   #
   # Examples:
@@ -852,7 +1141,7 @@ module RakeFileUtils
   # Use this function to prevent protentially destructive ruby code from
   # running when the :nowrite flag is set.
   #
-  # Example: 
+  # Example:
   #
   #   when_writing("Building Project") do
   #     project.build
@@ -902,7 +1191,7 @@ module RakeFileUtils
   extend self
 end
 
-# ###########################################################################
+#############################################################################
 # Include the FileUtils file manipulation functions in the top level module,
 # but mark them private so that they don't unintentionally define methods on
 # other objects.
@@ -914,22 +1203,7 @@ private(*RakeFileUtils.instance_methods(false))
 ######################################################################
 module Rake
 
-  class RuleRecursionOverflowError < StandardError
-    def initialize(*args)
-      super
-      @targets = []
-    end
-
-    def add_target(target)
-      @targets << target
-    end
-
-    def message
-      super + ": [" + @targets.reverse.join(' => ') + "]"
-    end
-  end
-
-  # #########################################################################
+  ###########################################################################
   # A FileList is essentially an array with a few helper methods defined to
   # make file manipulation a bit easier.
   #
@@ -943,7 +1217,7 @@ module Rake
   # FileList/Array is requested, the pending patterns are resolved into a real
   # list of file names.
   #
-  class FileList 
+  class FileList
 
     include Cloneable
 
@@ -965,7 +1239,7 @@ module Rake
 
     # List of array methods (that are not in +Object+) that need to be
     # delegated.
-    ARRAY_METHODS = Array.instance_methods - Object.instance_methods
+    ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
 
     # List of additional methods that must be delegated.
     MUST_DEFINE = %w[to_a inspect]
@@ -981,16 +1255,16 @@ module Rake
       compact flatten uniq values_at
       + - & |
     ]
-    
+
     DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq
-    
+
     # Now do the delegation.
     DELEGATING_METHODS.each_with_index do |sym, i|
       if SPECIAL_RETURN.include?(sym)
         ln = __LINE__+1
         class_eval %{
           def #{sym}(*args, &block)
-            resolve if @pending
+            resolve
             result = @items.send(:#{sym}, *args, &block)
             FileList.new.import(result)
           end
@@ -999,7 +1273,7 @@ module Rake
         ln = __LINE__+1
         class_eval %{
           def #{sym}(*args, &block)
-            resolve if @pending
+            resolve
             result = @items.send(:#{sym}, *args, &block)
             result.object_id == @items.object_id ? self : result
           end
@@ -1048,8 +1322,8 @@ module Rake
       @pending = true
       self
     end
-    alias :add :include 
-    
+    alias :add :include
+
     # Register a list of file name patterns that should be excluded from the
     # list.  Patterns may be regular expressions, glob patterns or regular
     # strings.  In addition, a block given to exclude will remove entries that
@@ -1072,16 +1346,16 @@ module Rake
     #
     def exclude(*patterns, &block)
       patterns.each do |pat|
-        @exclude_patterns << pat 
+        @exclude_patterns << pat
       end
       if block_given?
         @exclude_procs << block
-      end        
+      end
       resolve_exclude if ! @pending
       self
     end
 
-    
+
     # Clear all the exclude patterns so that we exclude nothing.
     def clear_exclude
       @exclude_patterns = []
@@ -1105,7 +1379,7 @@ module Rake
     def to_ary
       to_a
     end
-    
+
     # Lie about our class.
     def is_a?(klass)
       klass == Array || super(klass)
@@ -1211,8 +1485,8 @@ module Rake
       collect { |fn| fn.pathmap(spec) }
     end
 
-    # Return a new array with <tt>String#ext</tt> method applied to each
-    # member of the array.
+    # Return a new FileList with <tt>String#ext</tt> method applied
+    # to each member of the array.
     #
     # This method is a shortcut for:
     #
@@ -1229,9 +1503,9 @@ module Rake
     # name, line number, and the matching line of text.  If no block is given,
     # a standard emac style file:linenumber:line message will be printed to
     # standard out.
-    def egrep(pattern)
+    def egrep(pattern, *options)
       each do |fn|
-        open(fn) do |inf|
+        open(fn, "rb", *options) do |inf|
           count = 0
           inf.each do |line|
             count += 1
@@ -1240,7 +1514,7 @@ module Rake
                 yield fn, count, line
               else
                 puts "#{fn}:#{count}:#{line}"
-              end               
+              end
             end
           end
         end
@@ -1250,14 +1524,14 @@ module Rake
     # Return a new file list that only contains file names from the current
     # file list that exist on the file system.
     def existing
-      select { |fn| File.exists?(fn) }
+      select { |fn| File.exist?(fn) }
     end
-    
+
     # Modify the current file list so that it contains only file name that
     # exist on the file system.
     def existing!
       resolve
-      @items = @items.select { |fn| File.exists?(fn) }
+      @items = @items.select { |fn| File.exist?(fn) }
       self
     end
 
@@ -1271,10 +1545,10 @@ module Rake
         FileList.new.import(result[1]),
       ]
     end
-    
+
     # Convert a FileList to a string by joining all elements with a space.
     def to_s
-      resolve if @pending
+      resolve
       self.join(' ')
     end
 
@@ -1301,7 +1575,7 @@ module Rake
     DEFAULT_IGNORE_PROCS = [
       proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
     ]
-    @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+#    @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
 
     def import(array)
       @items = array
@@ -1315,26 +1589,6 @@ module Rake
       def [](*args)
         new(*args)
       end
-
-      # Set the ignore patterns back to the default value.  The default
-      # patterns will ignore files 
-      # * containing "CVS" in the file path
-      # * containing ".svn" in the file path
-      # * ending with ".bak"
-      # * ending with "~"
-      # * named "core"
-      #
-      # Note that file names beginning with "." are automatically ignored by
-      # Ruby's glob patterns and are not specifically listed in the ignore
-      # patterns.
-      def select_default_ignore_patterns
-        @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
-      end
-
-      # Clear the ignore patterns.  
-      def clear_ignore_patterns
-        @exclude_patterns = [ /^$/ ]
-      end
     end
   end # FileList
 end
@@ -1343,7 +1597,7 @@ module Rake
   class << self
 
     # Yield each file or directory component.
-    def each_dir_parent(dir)
+    def each_dir_parent(dir)    # :nodoc:
       old_length = nil
       while dir != '.' && dir.length != old_length
         yield(dir)
@@ -1352,12 +1606,12 @@ module Rake
       end
     end
   end
-end
+end # module Rake
 
 # Alias FileList to be available at the top level.
 FileList = Rake::FileList
 
-# ###########################################################################
+#############################################################################
 module Rake
 
   # Default Rakefile loader used by +import+.
@@ -1382,9 +1636,9 @@ module Rake
   end
 
   EARLY = EarlyTime.instance
-end
+end # module Rake
 
-# ###########################################################################
+#############################################################################
 # Extensions to time to allow comparisons with an early time class.
 #
 class Time
@@ -1395,8 +1649,8 @@ class Time
     else
       rake_original_time_compare(other)
     end
-  end     
-end
+  end
+end # class Time
 
 module Rake
 
@@ -1412,47 +1666,49 @@ module Rake
       @task_manager = task_manager
       @scope = scope_list.dup
     end
-    
+
     # Lookup a task named +name+ in the namespace.
     def [](name)
       @task_manager.lookup(name, @scope)
     end
 
-    # Return the list of tasks defined in this namespace.
+    # Return the list of tasks defined in this and nested namespaces.
     def tasks
-      @task_manager.tasks
+      @task_manager.tasks_in_scope(@scope)
     end
-  end
+  end # NameSpace
 
 
   ####################################################################
-  # The TaskManager module is a mixin for managing tasks.  
+  # The TaskManager module is a mixin for managing tasks.
   module TaskManager
     # Track the last comment made in the Rakefile.
-    attr_accessor :last_comment
+    attr_accessor :last_description
+    alias :last_comment :last_description    # Backwards compatibility
 
     def initialize
       super
       @tasks = Hash.new
       @rules = Array.new
       @scope = Array.new
-      @last_comment = nil
+      @last_description = nil
     end
 
-    def create_rule(args, &block)
-      pattern, deps = resolve_args(args)
+    def create_rule(*args, &block)
+      pattern, arg_names, deps = resolve_args(args)
       pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
       @rules << [pattern, deps, block]
     end
 
-    def define_task(task_class, args, &block)
-      task_name, deps = resolve_args(args)
+    def define_task(task_class, *args, &block)
+      task_name, arg_names, deps = resolve_args(args)
       task_name = task_class.scope_name(@scope, task_name)
       deps = [deps] unless deps.respond_to?(:to_ary)
       deps = deps.collect {|d| d.to_s }
       task = intern(task_class, task_name)
-      task.add_comment(@last_comment)
-      @last_comment = nil
+      task.set_arg_names(arg_names) unless arg_names.empty?
+      task.add_description(@last_description)
+      @last_description = nil
       task.enhance(deps, &block)
       task
     end
@@ -1463,7 +1719,7 @@ module Rake
       @tasks[task_name.to_s] ||= task_class.new(task_name, self)
     end
 
-    # Find a matching task for +task_name+.  
+    # Find a matching task for +task_name+.
     def [](task_name, scopes=nil)
       task_name = task_name.to_s
       self.lookup(task_name, scopes) or
@@ -1476,22 +1732,68 @@ module Rake
       return nil unless File.exist?(task_name)
       define_task(Rake::FileTask, task_name)
     end
-    
-    # Resolve the arguments for a task/rule.
+
+    # Resolve the arguments for a task/rule.  Returns a triplet of
+    # [task_name, arg_name_list, prerequisites].
     def resolve_args(args)
-      case args
-      when Hash
-        fail "Too Many Task Names: #{args.keys.join(' ')}" if args.size > 1
-        fail "No Task Name Given" if args.size < 1
-        task_name = args.keys[0]
-        deps = args[task_name]
-        deps = [deps] if (String===deps) || (Regexp===deps) || (Proc===deps)
+      if args.last.is_a?(Hash)
+        deps = args.pop
+        resolve_args_with_dependencies(args, deps)
+      else
+        resolve_args_without_dependencies(args)
+      end
+    end
+
+    # Resolve task arguments for a task or rule when there are no
+    # dependencies declared.
+    #
+    # The patterns recognized by this argument resolving function are:
+    #
+    #   task :t
+    #   task :t, [:a]
+    #   task :t, :a                 (deprecated)
+    #
+    def resolve_args_without_dependencies(args)
+      task_name = args.shift
+      if args.size == 1 && args.first.respond_to?(:to_ary)
+        arg_names = args.first.to_ary
+      else
+        arg_names = args
+      end
+      [task_name, arg_names, []]
+    end
+    private :resolve_args_without_dependencies
+    
+    # Resolve task arguments for a task or rule when there are
+    # dependencies declared.
+    #
+    # The patterns recognized by this argument resolving function are:
+    #
+    #   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
+      key, value = hash.map { |k, v| [k,v] }.first
+      if args.empty?
+        task_name = key
+        arg_names = []
+        deps = value
+      elsif key == :needs
+        task_name = args.shift
+        arg_names = args
+        deps = value
       else
-        task_name = args
-        deps = []
+        task_name = args.shift
+        arg_names = key
+        deps = value
       end
-      [task_name, deps]
+      deps = [deps] unless deps.respond_to?(:to_ary)
+      [task_name, arg_names, deps]
     end
+    private :resolve_args_with_dependencies
     
     # If a rule can be found that matches the task name, enhance the
     # task with the prerequisites and actions from the rule.  Set the
@@ -1511,12 +1813,21 @@ module Rake
       ex.add_target(task_name)
       fail ex
     end
-    
+
     # List of all defined tasks in this application.
     def tasks
       @tasks.values.sort_by { |t| t.name }
     end
 
+    # List of all the tasks defined in the given scope (and its
+    # sub-scopes).
+    def tasks_in_scope(scope)
+      prefix = scope.join(":")
+      tasks.select { |t|
+        /^#{prefix}:/ =~ t.name
+      }
+    end
+
     # Clear all tasks in this application.
     def clear
       @tasks.clear
@@ -1543,7 +1854,7 @@ module Rake
       lookup_in_scope(task_name, scopes)
     end
 
-    # Lookup the task name 
+    # Lookup the task name
     def lookup_in_scope(name, scope)
       n = scope.size
       while n >= 0
@@ -1583,15 +1894,23 @@ module Rake
       "_anon_#{@seed}"
     end
 
+    def trace_rule(level, message)
+      puts "#{"    "*level}#{message}" if Rake.application.options.trace_rules
+    end
+
     # Attempt to create a rule given the list of prerequisites.
     def attempt_rule(task_name, extensions, block, level)
       sources = make_sources(task_name, extensions)
       prereqs = sources.collect { |source|
+        trace_rule level, "Attempting Rule #{task_name} => #{source}"
         if File.exist?(source) || Rake::Task.task_defined?(source)
+          trace_rule level, "(#{task_name} => #{source} ... EXIST)"
           source
-        elsif parent = enhance_with_matching_rule(sources.first, level+1)
+        elsif parent = enhance_with_matching_rule(source, level+1)
+          trace_rule level, "(#{task_name} => #{source} ... ENHANCE)"
           parent.name
         else
+          trace_rule level, "(#{task_name} => #{source} ... FAIL)"
           return nil
         end
       }
@@ -1599,13 +1918,13 @@ module Rake
       task.sources = prereqs
       task
     end
-    
+
     # Make a list of sources from the list of file name extensions /
     # translation procs.
     def make_sources(task_name, extensions)
       extensions.collect { |ext|
         case ext
-        when /^%/
+        when /%/
           task_name.pathmap(ext)
         when %r{/}
           ext
@@ -1614,14 +1933,18 @@ module Rake
         when String
           ext
         when Proc
-          ext.call(task_name)
+          if ext.arity == 1
+            ext.call(task_name)
+          else
+            ext.call
+          end
         else
           fail "Don't know how to handle rule dependent: #{ext.inspect}"
         end
       }.flatten
     end
-    
-  end
+
+  end # TaskManager
 
   ######################################################################
   # Rake main application object.  When invoking +rake+ from the
@@ -1635,50 +1958,15 @@ module Rake
 
     # The original directory where rake was invoked.
     attr_reader :original_dir
-    
+
     # Name of the actual rakefile used.
     attr_reader :rakefile
-    
+
     # List of the top level task names (task names from the command line).
     attr_reader :top_level_tasks
 
     DEFAULT_RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb'].freeze
-    
-    OPTIONS = [     # :nodoc:
-      ['--dry-run',  '-n', GetoptLong::NO_ARGUMENT,
-        "Do a dry run without executing actions."],
-      ['--help',     '-H', GetoptLong::NO_ARGUMENT,
-        "Display this help message."],
-      ['--libdir',   '-I', GetoptLong::REQUIRED_ARGUMENT,
-        "Include LIBDIR in the search path for required modules."],
-      ['--rakelibdir', '-R', GetoptLong::REQUIRED_ARGUMENT,
-        "Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')"],
-      ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
-        "Do not search parent directories for the Rakefile."],
-      ['--prereqs',  '-P', GetoptLong::NO_ARGUMENT,
-        "Display the tasks and dependencies, then exit."],
-      ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
-        "Do not log messages to standard output."],
-      ['--rakefile', '-f', GetoptLong::OPTIONAL_ARGUMENT,
-        "Use FILE as the rakefile."],
-      ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
-        "Require MODULE before executing rakefile."],
-      ['--silent',   '-s', GetoptLong::NO_ARGUMENT,
-        "Like --quiet, but also suppresses the 'in directory' announcement."],
-      ['--tasks',    '-T', GetoptLong::OPTIONAL_ARGUMENT,
-        "Display the tasks (matching optional PATTERN) with descriptions, then exit."],
-      ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
-        "Turn on invoke/execute tracing, enable full backtrace."],
-      ['--usage',    '-h', GetoptLong::NO_ARGUMENT,
-        "Display usage."],
-      ['--verbose',  '-v', GetoptLong::NO_ARGUMENT,
-        "Log message to standard output (default)."],
-      ['--version',  '-V', GetoptLong::NO_ARGUMENT,
-        "Display the program version."],
-      ['--classic-namespace', '-C', GetoptLong::NO_ARGUMENT,
-        "Put Task and FileTask in the top level namespace"],
-    ]
-    
+
     # Initialize a Rake::Application object.
     def initialize
       super
@@ -1691,8 +1979,10 @@ module Rake
       @default_loader = Rake::DefaultLoader.new
       @original_dir = Dir.pwd
       @top_level_tasks = []
+      add_loader('rb', DefaultLoader.new)
       add_loader('rf', DefaultLoader.new)
       add_loader('rake', DefaultLoader.new)
+      @tty_output = STDOUT.tty?
     end
 
     # Run the Rake application.  The run method performs the following three steps:
@@ -1701,7 +1991,7 @@ module Rake
     # * Define the tasks (+load_rakefile+).
     # * Run the top level tasks (+run_tasks+).
     #
-    # If you wish to build a custom rake command, you should call +init+ on your 
+    # If you wish to build a custom rake command, you should call +init+ on your
     # application.  The define any tasks.  Finally, call +top_level+ to run your top
     # level tasks.
     def run
@@ -1726,7 +2016,7 @@ module Rake
       standard_exception_handling do
         raw_load_rakefile
       end
-    end 
+    end
 
     # Run the top level tasks of a Rake application.
     def top_level
@@ -1736,7 +2026,7 @@ module Rake
         elsif options.show_prereqs
           display_prerequisites
         else
-          top_level_tasks.each { |task_name| self[task_name].invoke }
+          top_level_tasks.each { |task_name| invoke_task(task_name) }
         end
       end
     end
@@ -1747,7 +2037,7 @@ module Rake
       ext = ".#{ext}" unless ext =~ /^\./
       @loaders[ext] = loader
     end
-    
+
     # Application options from the command line
     def options
       @options ||= OpenStruct.new
@@ -1755,16 +2045,36 @@ module Rake
 
     # private ----------------------------------------------------------------
 
+    def invoke_task(task_string)
+      name, args = parse_task_string(task_string)
+      t = self[name]
+      t.invoke(*args)
+    end
+
+    def parse_task_string(string)
+      if string =~ /^([^\[]+)(\[(.*)\])$/
+        name = $1
+        args = $3.split(/\s*,\s*/)
+      else
+        name = string
+        args = []
+      end
+      [name, args]
+    end
+
     # Provide standard execption handling for the given block.
     def standard_exception_handling
       begin
         yield
-      rescue SystemExit, GetoptLong::InvalidOption => ex
+      rescue SystemExit => ex
+        # Exit silently with current status
+        raise
+      rescue OptionParser::InvalidOption => ex
         # Exit silently
-        exit(1)
+        exit(false)
       rescue Exception => ex
         # Exit with error message
-        $stderr.puts "rake aborted!"
+        $stderr.puts "#{name} aborted!"
         $stderr.puts ex.message
         if options.trace
           $stderr.puts ex.backtrace.join("\n")
@@ -1772,132 +2082,246 @@ module Rake
           $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
           $stderr.puts "(See full trace by running task with --trace)"
         end
-        exit(1)
-      end    
+        exit(false)
+      end
     end
-        
+
     # True if one of the files in RAKEFILES is in the current directory.
     # If a match is found, it is copied into @rakefile.
     def have_rakefile
       @rakefiles.each do |fn|
-        if File.exist?(fn) || fn == ''
-          @rakefile = fn
-          return true
+        if File.exist?(fn)
+          others = Dir.glob(fn, File::FNM_CASEFOLD)
+          return others.size == 1 ? others.first : fn
+        elsif fn == ''
+          return fn
         end
       end
-      return false
+      return nil
     end
-    
-    # Display the program usage line.
-    def usage
-      puts "rake [-f rakefile] {options} targets..."
+
+    # True if we are outputting to TTY, false otherwise
+    def tty_output?
+      @tty_output
     end
-    
-    # Display the rake command line help.
-    def help
-      usage
-      puts
-      puts "Options are ..."
-      puts
-      OPTIONS.sort.each do |long, short, mode, desc|
-        if mode == GetoptLong::REQUIRED_ARGUMENT
-          if desc =~ /\b([A-Z]{2,})\b/
-            long = long + "=#{$1}"
-          end
-        end
-        printf "  %-20s (%s)\n", long, short
-        printf "      %s\n", desc
-      end
+
+    # Override the detected TTY output state (mostly for testing)
+    def tty_output=( tty_output_state )
+      @tty_output = tty_output_state
     end
-    
-    # Display the tasks and dependencies.
+
+    # We will truncate output if we are outputting to a TTY or if we've been
+    # given an explicit column width to honor
+    def truncate_output?
+      tty_output? || ENV['RAKE_COLUMNS']
+    end
+
+    # Display the tasks and comments.
     def display_tasks_and_comments
       displayable_tasks = tasks.select { |t|
         t.comment && t.name =~ options.show_task_pattern
       }
-      width = displayable_tasks.collect { |t| t.name.length }.max
-      displayable_tasks.each do |t|
-        printf "#{name} %-#{width}s  # %s\n", t.name, t.comment
+      if options.full_description
+        displayable_tasks.each do |t|
+          puts "#{name} #{t.name_with_args}"
+          t.full_comment.split("\n").each do |line|
+            puts "    #{line}"
+          end
+          puts
+        end
+      else
+        width = displayable_tasks.collect { |t| t.name_with_args.length }.max || 10
+        max_column = truncate_output? ? terminal_width - name.size - width - 7 : nil
+        displayable_tasks.each do |t|
+          printf "#{name} %-#{width}s  # %s\n",
+            t.name_with_args, max_column ? truncate(t.comment, max_column) : t.comment
+        end
+      end
+    end
+
+    def terminal_width
+      if ENV['RAKE_COLUMNS']
+        result = ENV['RAKE_COLUMNS'].to_i
+      else
+        result = unix? ? dynamic_width : 80
       end
+      (result < 10) ? 80 : result
+    rescue
+      80
+    end
+
+    # Calculate the dynamic width of the 
+    def dynamic_width
+      @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
+    end
+
+    def dynamic_width_stty
+      %x{stty size 2>/dev/null}.split[1].to_i
+    end
+
+    def dynamic_width_tput
+      %x{tput cols 2>/dev/null}.to_i
+    end
+
+    def unix?
+      RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
     end
     
+    def windows?
+      Win32.windows?
+    end
+
+    def truncate(string, width)
+      if string.length <= width
+        string
+      else
+        ( string[0, width-3] || "" ) + "..."
+      end
+    end
+
     # Display the tasks and prerequisites
     def display_prerequisites
       tasks.each do |t|
-        puts "rake #{t.name}"
+        puts "#{name} #{t.name}"
         t.prerequisites.each { |pre| puts "    #{pre}" }
       end
     end
-    
-    # Return a list of the command line options supported by the
-    # program.
-    def command_line_options
-      OPTIONS.collect { |lst| lst[0..-2] }
-    end
-    
-    # Do the option defined by +opt+ and +value+.
-    def do_option(opt, value)
-      case opt
-      when '--dry-run'
-        verbose(true)
-        nowrite(true)
-        options.dryrun = true
-        options.trace = true
-      when '--help'
-        help
-        exit
-      when '--libdir'
-        $:.push(value)
-      when '--nosearch'
-        options.nosearch = true
-      when '--prereqs'
-        options.show_prereqs = true
-      when '--quiet'
-        verbose(false)
-      when '--rakefile'
-        @rakefiles.clear
-        @rakefiles << value
-      when '--rakelibdir'
-        options.rakelib = value.split(':')
-      when '--require'
-        begin
-          require value
-        rescue LoadError => ex
-          begin
-            rake_require value
-          rescue LoadError => ex2
-            raise ex
-          end
-        end
-      when '--silent'
-        verbose(false)
-        options.silent = true
-      when '--tasks'
-        options.show_tasks = true
-        options.show_task_pattern = Regexp.new(value || '.')
-      when '--trace'
-        options.trace = true
-        verbose(true)
-      when '--usage'
-        usage
-        exit
-      when '--verbose'
-        verbose(true)
-      when '--version'
-        puts "rake, version #{RAKEVERSION}"
-        exit
-      when '--classic-namespace'
-        require 'rake/classic_namespace'
-        options.classic_namespace = true
-      end
+
+    # A list of all the standard options used in rake, suitable for
+    # passing to OptionParser.
+    def standard_rake_options
+      [
+        ['--classic-namespace', '-C', "Put Task and FileTask in the top level namespace",
+          lambda { |value|
+            require 'rake/classic_namespace'
+            options.classic_namespace = true
+          }
+        ],
+        ['--describe', '-D [PATTERN]', "Describe the tasks (matching optional PATTERN), then exit.",
+          lambda { |value|
+            options.show_tasks = true
+            options.full_description = true
+            options.show_task_pattern = Regexp.new(value || '')
+          }
+        ],
+        ['--dry-run', '-n', "Do a dry run without executing actions.",
+          lambda { |value|
+            verbose(true)
+            nowrite(true)
+            options.dryrun = true
+            options.trace = true
+          }
+        ],
+        ['--execute',  '-e CODE', "Execute some Ruby code and exit.",
+          lambda { |value|
+            eval(value)
+            exit
+          }
+        ],
+        ['--execute-print',  '-p CODE', "Execute some Ruby code, print the result, then exit.",
+          lambda { |value|
+            puts eval(value)
+            exit
+          }
+        ],
+        ['--execute-continue',  '-E CODE',
+          "Execute some Ruby code, then continue with normal task processing.",
+          lambda { |value| eval(value) }            
+        ],
+        ['--libdir', '-I LIBDIR', "Include LIBDIR in the search path for required modules.",
+          lambda { |value| $:.push(value) }
+        ],
+        ['--prereqs', '-P', "Display the tasks and dependencies, then exit.",
+          lambda { |value| options.show_prereqs = true }
+        ],
+        ['--quiet', '-q', "Do not log messages to standard output.",
+          lambda { |value| verbose(false) }
+        ],
+        ['--rakefile', '-f [FILE]', "Use FILE as the rakefile.",
+          lambda { |value| 
+            value ||= ''
+            @rakefiles.clear 
+            @rakefiles << value
+          }
+        ],
+        ['--rakelibdir', '--rakelib', '-R RAKELIBDIR',
+          "Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')",
+          lambda { |value| options.rakelib = value.split(':') }
+        ],
+        ['--require', '-r MODULE', "Require MODULE before executing rakefile.",
+          lambda { |value|
+            begin
+              require value
+            rescue LoadError => ex
+              begin
+                rake_require value
+              rescue LoadError => ex2
+                raise ex
+              end
+            end
+          }
+        ],
+        ['--rules', "Trace the rules resolution.",
+          lambda { |value| options.trace_rules = true }
+        ],
+        ['--no-search', '--nosearch', '-N', "Do not search parent directories for the Rakefile.",
+          lambda { |value| options.nosearch = true }
+        ],
+        ['--silent', '-s', "Like --quiet, but also suppresses the 'in directory' announcement.",
+          lambda { |value|
+            verbose(false)
+            options.silent = true
+          }
+        ],
+        ['--system',  '-g',
+          "Using system wide (global) rakefiles (usually '~/.rake/*.rake').",
+          lambda { |value| options.load_system = true }
+        ],
+        ['--no-system', '--nosystem', '-G',
+          "Use standard project Rakefile search paths, ignore system wide rakefiles.",
+          lambda { |value| options.ignore_system = true }
+        ],
+        ['--tasks', '-T [PATTERN]', "Display the tasks (matching optional PATTERN) with descriptions, then exit.",
+          lambda { |value|
+            options.show_tasks = true
+            options.show_task_pattern = Regexp.new(value || '')
+            options.full_description = false
+          }
+        ],
+        ['--trace', '-t', "Turn on invoke/execute tracing, enable full backtrace.",
+          lambda { |value|
+            options.trace = true
+            verbose(true)
+          }
+        ],
+        ['--verbose', '-v', "Log message to standard output.",
+          lambda { |value| verbose(true) }
+        ],
+        ['--version', '-V', "Display the program version.",
+          lambda { |value|
+            puts "rake, version #{RAKEVERSION}"
+            exit
+          }
+        ]
+      ]
     end
-    
+
     # Read and handle the command line options.
     def handle_options
-      options.rakelib = 'rakelib'
+      options.rakelib = ['rakelib']
 
-      opts = GetoptLong.new(*command_line_options)
-      opts.each { |opt, value| do_option(opt, value) }
+      OptionParser.new do |opts|
+        opts.banner = "rake [-f rakefile] {options} targets..."
+        opts.separator ""
+        opts.separator "Options are ..."
+
+        opts.on_tail("-h", "--help", "-H", "Display this help message.") do
+          puts opts
+          exit
+        end
+
+        standard_rake_options.each { |args| opts.on(*args) }
+      end.parse!
 
       # If class namespaces are requested, set the global options
       # according to the values in the options structure.
@@ -1909,9 +2333,9 @@ module Rake
         $silent = options.silent
       end
     end
-    
+
     # Similar to the regular Ruby +require+ command, but will check
-    # for .rake files in addition to .rb files.
+    # for *.rake files in addition to *.rb files.
     def rake_require(file_name, paths=$LOAD_PATH, loaded=$")
       return false if loaded.include?(file_name)
       paths.each do |path|
@@ -1926,24 +2350,75 @@ module Rake
       fail LoadError, "Can't find #{file_name}"
     end
 
-    def raw_load_rakefile # :nodoc:
+    def find_rakefile_location
       here = Dir.pwd
-      while ! have_rakefile
+      while ! (fn = have_rakefile)
         Dir.chdir("..")
         if Dir.pwd == here || options.nosearch
-          fail "No Rakefile found (looking for: #{@rakefiles.join(', ')})"
+          return nil
         end
         here = Dir.pwd
       end
-      puts "(in #{Dir.pwd})" unless options.silent
-      $rakefile = @rakefile
-      load File.expand_path(@rakefile) if @rakefile != ''
-      options.rakelib.each do |rlib|
-        Dir["#{rlib}/*.rake"].each do |name| add_import name end
+      [fn, here]
+    ensure
+      Dir.chdir(Rake.original_dir)
+    end
+
+    def raw_load_rakefile # :nodoc:
+      rakefile, location = find_rakefile_location
+      if (! options.ignore_system) &&
+          (options.load_system || rakefile.nil?) &&
+          system_dir && File.directory?(system_dir)
+        puts "(in #{Dir.pwd})" unless options.silent
+        glob("#{system_dir}/*.rake") do |name|
+          add_import name
+        end
+      else
+        fail "No Rakefile found (looking for: #{@rakefiles.join(', ')})" if
+          rakefile.nil?
+        @rakefile = rakefile
+        Dir.chdir(location)
+        puts "(in #{Dir.pwd})" unless options.silent
+        $rakefile = @rakefile if options.classic_namespace
+        load File.expand_path(@rakefile) if @rakefile && @rakefile != ''
+        options.rakelib.each do |rlib|
+          glob("#{rlib}/*.rake") do |name|
+            add_import name
+          end
+        end
       end
       load_imports
     end
+
+    def glob(path, &block)
+      Dir[path.gsub("\\", '/')].each(&block)
+    end
+    private :glob
+
+    # The directory path containing the system wide rakefiles.
+    def system_dir
+      @system_dir ||=
+        begin
+          if ENV['RAKE_SYSTEM']
+            ENV['RAKE_SYSTEM']
+          else
+            standard_system_dir
+          end
+        end
+    end
     
+    # The standard directory containing system wide rake files.
+    if Win32.windows?
+      def standard_system_dir #:nodoc:
+        Win32.win32_system_dir
+      end
+    else
+      def standard_system_dir #:nodoc:
+        File.join(File.expand_path('~'), '.rake')
+      end
+    end
+    private :standard_system_dir
+
     # Collect the list of tasks on the command line.  If no tasks are
     # given, return a list containing only the default task.
     # Environmental assignments are processed at this time as well.
@@ -1953,17 +2428,17 @@ module Rake
         if arg =~ /^(\w+)=(.*)$/
           ENV[$1] = $2
         else
-          @top_level_tasks << arg
+          @top_level_tasks << arg unless arg =~ /^-/
         end
       end
       @top_level_tasks.push("default") if @top_level_tasks.size == 0
     end
-    
+
     # Add a file to the list of files to be imported.
     def add_import(fn)
       @pending_imports << fn
     end
-    
+
     # Load the pending list of imported files.
     def load_imports
       while fn = @pending_imports.shift
@@ -1977,7 +2452,7 @@ module Rake
         @imported << fn
       end
     end
-    
+
     # Warn about deprecated use of top level constant names.
     def const_warning(const_name)
       @const_warning ||= false
@@ -2004,7 +2479,7 @@ end
 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