rake 0.5.4 → 0.6.0

data/doc/release_notes/rake-0.6.0.rdoc

@@ -0,0 +1,141 @@
+= Rake 0.6.0 Released
+
+Its time for some long requested enhancements and lots of bug fixes
+... And a whole new web page.
+
+== New Web Page
+
+The primary documentation for rake has moved from the RubyForge based
+wiki to its own Hieraki based web site.  Constant spam on the wiki
+made it a difficult to keep clean.  The new site will be easier to
+update and organize.
+
+Check out the new documentation at: http://docs.rubyrake.org
+
+We will be adding new documentation to the site as time goes on.
+
+In addition to the new docs page, make sure you check out Martin
+Fowlers article on rake at http://martinfowler.com/articles/rake.html
+
+== Changes
+
+=== New Features
+
+* Multiple prerequisites on Rake rules now allowed.  However, keep the
+  following in mind:
+
+  1. All the prerequisites of a rule must be available before a rule
+     is triggered, where "enabled" means (a) an existing file, (b) a
+     defined rule, or (c) another rule which also must be
+     trigger-able.
+  2. Rules are checked in order of definition, so it is important to
+     order your rules properly.  If a file can be created by two
+     different rules, put the more specific rule first (otherwise the
+     more general rule will trigger first and the specific one will
+     never be triggered).
+  3. The <tt>source</tt> method now returns the name of the first
+     prerequisite listed in the rule.  <tt>sources</tt> returns the
+     names of all the rule prerequisites, ordered as they are defined
+     in the rule.  If the task has other prerequisites not defined in
+     the rule (but defined in an explicit task definition), then they
+     will _not_ be included in the sources list.
+
+* FileLists may now use the egrep command.  This popular enhancement
+  is now a core part of the FileList object.  If you want to get a
+  list of all your to-dos, fixmes and TBD comments, add the following
+  to your Rakefile.
+
+    desc "Look for TODO and FIXME tags in the code"
+    task :todo do
+      FileList['**/*.rb'].egrep /#.*(FIXME|TODO|TBD)/
+    end
+
+* The <tt>investigation</tt> method was added to task object to dump
+  out some important values.  This makes it a bit easier to debug Rake
+  tasks.
+
+  For example, if you are having problems with a particular task, just
+  print it out:
+
+    task :huh do
+      puts Rake::Task['huh'].investigation
+    end
+
+* The Rake::TestTask class now supports a "ruby_opts" option to pass
+  arbitrary ruby options to a test subprocess.
+
+=== Some Incompatibilities
+
+* When using the <tt>ruby</tt> command to start a Ruby subprocess, the
+  Ruby interpreter that is currently running rake is used by default.
+  This makes it easier to use rake in an environment with multiple
+  ruby installation.  (Previously, the first ruby command found in the
+  PATH was used).
+
+  If you wish to chose a different Ruby interpreter, you can
+  explicitly choose the interpreter via the <tt>sh</tt> command.
+
+* The major rake classes (Task, FileTask, FileCreationTask, RakeApp)
+  have been moved out of the toplevel scope and are now accessible as
+  Rake::Task, Rake::FileTask, Rake::FileCreationTask and
+  Rake::Application.  If your Rakefile
+  directly references any one of these tasks, you may:
+
+  1. Update your Rakefile to use the new classnames
+  2. Use the --classic-namespace option on the rake command to get the
+     old behavior,
+  3. Add <code>require 'rake/classic_namespace'</code> to the
+     Rakefile to get the old behavior.
+
+  <tt>rake</tt> will print a rather annoying warning whenever a
+  deprecated class name is referenced without enabling classic
+  namespace.
+
+=== Bug Fixes
+
+* Several unit tests and functional tests were fixed to run better
+  under windows.
+
+* Directory tasks are now a specialized version of a File task.  A
+  directory task will only be triggered if it doesn't exist.  It will
+  not be triggered if it is out of date w.r.t. any of its
+  prerequisites.
+
+* Fixed a bug in the Rake::GemPackageTask class so that the gem now
+  properly contains the platform name.
+
+* Fixed a bug where a prerequisite on a <tt>file</tt> task would cause
+  an exception if the prerequisite did not exist.
+
+== What is Rake
+
+Rake is a build tool similar to the make program in many ways.  But
+instead of cryptic make recipes, Rake uses standard Ruby code to
+declare tasks and dependencies.  You have the full power of a modern
+scripting language built right into your build tool.
+
+== Availability
+
+The easiest way to get and install rake is via RubyGems ...
+
+  gem install rake    (you may need root/admin privileges)
+
+Otherwise, you can get it from the more traditional places:
+
+Home Page:: http://rake.rubyforge.org/
+Download::  http://rubyforge.org/project/showfiles.php?group_id=50
+
+== Thanks
+
+As usual, it was input from users that drove a alot of these changes.
+The following people either contributed patches, made suggestions or
+made otherwise helpful comments.  Thanks to ...
+
+* Greg Fast (better ruby_opt test options)
+* Kelly Felkins (requested by better namespace support)
+* Martin Fowler (suggested Task.investigation)
+* Stuart Jansen (send initial patch for multiple prerequisites).
+* Masao Mutch (better support for non-ruby Gem platforms)
+* Philipp Neubeck (patch for file task exception fix)
+
+-- Jim Weirich

data/lib/rake.rb

@@ -29,12 +29,13 @@
 # referenced as a library via a require statement, but it can be
 # distributed independently as an application.
 
-RAKEVERSION = '0.5.4'
+RAKEVERSION = '0.6.0'
 
 require 'rbconfig'
 require 'ftools'
 require 'getoptlong'
 require 'fileutils'
+require 'singleton'
 
 $last_comment = nil
 $show_tasks = nil
@@ -91,13 +92,15 @@ module Rake
   class << self
     # Current Rake Application
     def application
-      @application ||= RakeApp.new
+      @application ||= Rake::Application.new
     end
 
+    # Set the current Rake application object.
     def application=(app)
-      fail "RakeApp already exists" if defined?(@application)
+      fail "Rake::Application already exists" if defined?(@application)
       @application = app
     end
+
   end
 
   module Cloneable
@@ -113,257 +116,326 @@ module Rake
   end
 end
 
-######################################################################
-# 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 opportunity to run and then it will
-# execute its own actions.
-#
-# Tasks are not usually created directly using the new method, but
-# rather use the +file+ and +task+ convenience methods.
-#
-class Task
-  TASKS = Hash.new
-  RULES = Array.new
-
-  # List of prerequisites for a task.
-  attr_reader :prerequisites
-
-  # Comment for this task.
-  attr_accessor :comment
-
-  # Source dependency for rule synthesized tasks.  Nil if task was not
-  # sythesized from a rule.
-  attr_accessor :source
-
-  # Create a task named +task_name+ with no actions or prerequisites..
-  # use +enhance+ to add actions and prerequisites.
-  def initialize(task_name)
-    @name = task_name
-    @prerequisites = FileList[]
-    @actions = []
-    @already_invoked = false
-    @comment = 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.
-  def name
-    @name.to_s
-  end
-
-  # Invoke the task if it is needed.  Prerequites are invoked first.
-  def invoke
-    if $trace
-      puts "** Invoke #{name} #{format_trace_flags}"
+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 opportunity to run and then it will
+  # execute its own actions.
+  #
+  # Tasks are not usually created directly using the new method, but
+  # rather use the +file+ and +task+ convenience methods.
+  #
+  class Task
+    TASKS = Hash.new
+    RULES = Array.new
+    
+    # List of prerequisites for a task.
+    attr_reader :prerequisites
+    
+    # Comment for this task.
+    attr_accessor :comment
+    
+    attr_writer :sources
+    def sources
+      @sources ||= []
     end
-    return if @already_invoked
-    @already_invoked = true
-    @prerequisites.each { |n| Task[n].invoke }
-    execute if needed?
-  end
-
-  # Format the trace flags for display.
-  def format_trace_flags
-    flags = []
-    flags << "first_time" unless @already_invoked
-    flags << "not_needed" unless needed?
-    flags.empty? ? "" : "(" + flags.join(", ") + ")"
-  end
-  private :format_trace_flags
 
-  # Execute the actions associated with this task.
-  def execute
-    if $dryrun
-      puts "** Execute (dry run) #{name}"
-      return
+    # First source from a rule (nil if no sources)
+    def source
+      @sources.first if defined?(@sources)
     end
-    if $trace
-      puts "** Execute #{name}"
-    end
-    self.class.enhance_with_matching_rule(name) if @actions.empty?
-    @actions.each { |act| result = act.call(self) }
-  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| Task[p].timestamp }.max || Time.now
-  end
-
-  # Add a comment to the task.  If a comment alread exists, separate
-  # the new comment with " / ".
-  def add_comment(comment)
-    return if ! $last_comment
-    if @comment 
-      @comment << " / "
-    else
-      @comment = ''
+    
+    # Create a task named +task_name+ with no actions or prerequisites..
+    # use +enhance+ to add actions and prerequisites.
+    def initialize(task_name)
+      @name = task_name
+      @prerequisites = FileList[]
+      @actions = []
+      @already_invoked = false
+      @comment = nil
     end
-    @comment << $last_comment
-    $last_comment = nil
-  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
-      TASKS.clear
-      RULES.clear
+    
+    # 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
-
-    # List of all defined tasks.
-    def tasks
-      TASKS.keys.sort.collect { |tn| Task[tn] }
+    
+    # Name of the task.
+    def name
+      @name.to_s
     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 task with no dependencies or actions.
-    def [](task_name)
-      task_name = task_name.to_s
-      if task = TASKS[task_name]
-        return task
+    
+    # Invoke the task if it is needed.  Prerequites are invoked first.
+    def invoke
+      if $trace
+	puts "** Invoke #{name} #{format_trace_flags}"
       end
-      if task = enhance_with_matching_rule(task_name)
-        return task
+      return if @already_invoked
+      @already_invoked = true
+      @prerequisites.each { |n| Rake::Task[n].invoke }
+      execute if needed?
+    end
+    
+    # Format the trace flags for display.
+    def format_trace_flags
+      flags = []
+      flags << "first_time" unless @already_invoked
+      flags << "not_needed" unless needed?
+      flags.empty? ? "" : "(" + flags.join(", ") + ")"
+    end
+    private :format_trace_flags
+    
+    # Execute the actions associated with this task.
+    def execute
+      if $dryrun
+	puts "** Execute (dry run) #{name}"
+	return
       end
-      if File.exist?(task_name)
-        return FileTask.define_task(task_name)
+      if $trace
+	puts "** Execute #{name}"
       end
-      fail "Don't know how to build task '#{task_name}'"
+      self.class.enhance_with_matching_rule(name) if @actions.empty?
+      @actions.each { |act| result = act.call(self) }
     end
-
-    # TRUE if the task name is already defined.
-    def task_defined?(task_name)
-      task_name = task_name.to_s
-      TASKS[task_name]
+    
+    # Is this task needed?
+    def needed?
+      true
     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)
-      task_name, deps = resolve_args(args)
-      deps = [deps] if (Symbol === deps) || (String === deps)
-      deps = deps.collect {|d| d.to_s }
-      t = lookup(task_name)
-      t.add_comment($last_comment)
-      t.enhance(deps, &block)
+    
+    # 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| Rake::Task[p].timestamp }.max || Time.now
     end
-
-    # Define a rule for synthesizing tasks.  
-    def create_rule(args, &block)
-      pattern, deps = resolve_args(args)
-      fail "Too many dependents specified in rule #{pattern}: #{deps.inspect}" if deps.size > 1
-      pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
-      RULES << [pattern, deps, block]
+    
+    # Add a comment to the task.  If a comment alread exists, separate
+    # the new comment with " / ".
+    def add_comment(comment)
+      return if ! $last_comment
+      if @comment 
+	@comment << " / "
+      else
+	@comment = ''
+      end
+      @comment << $last_comment
+      $last_comment = nil
     end
-
     
-    # Lookup a task.  Return an existing task if found, otherwise
-    # create a task of the current type.
-    def lookup(task_name)
-      name = task_name.to_s
-      TASKS[name] ||= self.new(task_name)
-    end
-
-    # If a rule can be found that matches the task name, enhance the
-    # task with the prerequisites and actions from the rule.  Set the
-    # source attribute of the task appropriately for the rule.  Return
-    # the enhanced task or nil of no rule was found.
-    def enhance_with_matching_rule(task_name, level=0)
-      fail Rake::RuleRecursionOverflowError,
-        "Rule Recursion Too Deep" if level >= 16
-      RULES.each do |pattern, extensions, block|
-        if md = pattern.match(task_name)
-          ext = extensions.first
-          case ext
-          when String
-            source = task_name.sub(/\.[^.]*$/, ext)
-          when Proc
-            source = ext.call(task_name)
-          else
-            fail "Don't know how to handle rule dependent: #{ext.inspect}"
-          end
-          if File.exist?(source) || Task.task_defined?(source)
-            task = FileTask.define_task({task_name => [source]}, &block)
-            task.source = source
-            return task
-          elsif parent = enhance_with_matching_rule(source, level+1)
-            task = FileTask.define_task({task_name => [parent.name]}, &block)
-            task.source = parent.name
-            return task
-          end
-        end
+    # Return a string describing the internal state of a task.  Useful
+    # for debugging.
+    def investigation
+      result = "------------------------------\n"
+      result << "Investigating #{name}\n" 
+      result << "class: #{self.class}\n"
+      result <<  "task needed: #{needed?}\n"
+      result <<  "timestamp: #{timestamp}\n"
+      result << "pre-requisites: \n"
+      prereqs = @prerequisites.collect {|name| Rake::Task[name]}
+      prereqs.sort! {|a,b| a.timestamp <=> b.timestamp}
+      prereqs.each do |p|
+	result << "--#{p.name} (#{p.timestamp})\n"
       end
-      nil
-    rescue Rake::RuleRecursionOverflowError => ex
-      ex.add_target(task_name)
-      fail ex
+      latest_prereq = @prerequisites.collect{|n| Rake::Task[n].timestamp}.max
+      result <<  "latest-prerequisite time: #{latest_prereq}\n"
+      result << "................................\n\n"
+      return result
     end
     
-    private 
-
-    # Resolve the arguments for a task/rule.
-    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)
-      else
-        task_name = args
-        deps = []
+    # 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
+	TASKS.clear
+	RULES.clear
+      end
+      
+      # List of all defined tasks.
+      def tasks
+	TASKS.keys.sort.collect { |tn| Rake::Task[tn] }
+      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 task with no dependencies or actions.
+      def [](task_name)
+	task_name = task_name.to_s
+	if task = TASKS[task_name]
+	  return task
+	end
+	if task = enhance_with_matching_rule(task_name)
+	  return task
+	end
+	if File.exist?(task_name)
+	  return Rake::FileTask.define_task(task_name)
+	end
+	fail "Don't know how to build task '#{task_name}'"
+      end
+      
+      # TRUE if the task name is already defined.
+      def task_defined?(task_name)
+	task_name = task_name.to_s
+	TASKS[task_name]
+      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)
+	task_name, deps = resolve_args(args)
+	deps = [deps] if (Symbol === deps) || (String === deps)
+	deps = deps.collect {|d| d.to_s }
+	t = lookup(task_name)
+	t.add_comment($last_comment)
+	t.enhance(deps, &block)
+      end
+      
+      # Define a rule for synthesizing tasks.  
+      def create_rule(args, &block)
+	pattern, deps = resolve_args(args)
+	pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
+	RULES << [pattern, deps, block]
+      end
+      
+      # Lookup a task.  Return an existing task if found, otherwise
+      # create a task of the current type.
+      def lookup(task_name)
+	name = task_name.to_s
+	TASKS[name] ||= self.new(task_name)
+      end
+      
+      # If a rule can be found that matches the task name, enhance the
+      # task with the prerequisites and actions from the rule.  Set the
+      # source attribute of the task appropriately for the rule.  Return
+      # the enhanced task or nil of no rule was found.
+      def enhance_with_matching_rule(task_name, level=0)
+	fail Rake::RuleRecursionOverflowError,
+	  "Rule Recursion Too Deep" if level >= 16
+	RULES.each do |pattern, extensions, block|
+	  if md = pattern.match(task_name)
+	    task = attempt_rule(task_name, extensions, block, level)
+	    return task if task
+	  end
+	end
+	nil
+      rescue Rake::RuleRecursionOverflowError => ex
+	ex.add_target(task_name)
+	fail ex
+      end
+      
+      private
+
+      # 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|
+	  if File.exist?(source) || Rake::Task.task_defined?(source)
+	    source
+	  elsif parent = enhance_with_matching_rule(sources.first, level+1)
+	    parent.name
+	  else
+	    return nil
+	  end
+	}
+	task = FileTask.define_task({task_name => prereqs}, &block)
+	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 String
+	    source = task_name.sub(/\.[^.]*$/, ext)
+	  when Proc
+	    source = ext.call(task_name)
+	  else
+	    fail "Don't know how to handle rule dependent: #{ext.inspect}"
+	  end
+	}
+      end
+      
+      # Resolve the arguments for a task/rule.
+      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)
+	else
+	  task_name = args
+	  deps = []
+	end
+	[task_name, deps]
       end
-      [task_name, deps]
     end
   end
-end
+  
+  
+  ######################################################################
+  # 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
+    end
+    
+    # Time stamp for file task.
+    def timestamp
+      if File.exist?(name)
+	File.mtime(name.to_s)
+      else
+	Rake::EARLY
+      end
+    end
 
+    private
 
-######################################################################
-# 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)
-    latest_prereq = @prerequisites.collect{|n| Task[n].timestamp}.max
-    return false if latest_prereq.nil?
-    timestamp < latest_prereq
-  rescue Errno::ENOENT => ex # one of the prereqs does not exist
-    raise unless $dryrun or $trace
-    true
+    # Are there any prerequisites with a later time than the given
+    # time stamp?
+    def out_of_date?(stamp)
+      @prerequisites.any? { |n| Rake::Task[n].timestamp > stamp}
+    end
   end
-
-  # Time stamp for file task.
-  def timestamp
-    File.mtime(name.to_s)
+  
+  ######################################################################
+  # 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 any rebuilds of tasks that depend on it
+  # whenever it is updated.
+  class FileCreationTask < FileTask
+    # Is this file task needed?  Yes if it doesn't exist.
+    def needed?
+      ! File.exist?(name)
+    end
+    
+    # Time stamp for file creation task.  This time stamp is earlier
+    # than any other time stamp.
+    def timestamp
+      Rake::EARLY
+    end
   end
 end
 
@@ -378,7 +450,7 @@ end
 #   end
 #
 def task(args, &block)
-  Task.define_task(args, &block)
+  Rake::Task.define_task(args, &block)
 end
 
 
@@ -396,7 +468,13 @@ end
 #  end
 #
 def file(args, &block)
-  FileTask.define_task(args, &block)
+  Rake::FileTask.define_task(args, &block)
+end
+
+# Declare a file creation task.
+# (Mainly used for the directory command).
+def file_create(args, &block)
+  Rake::FileCreationTask.define_task(args, &block)
 end
 
 # Declare a set of files tasks to create the given directories on
@@ -406,11 +484,10 @@ end
 #   directory "testdata/doc"
 #
 def directory(dir)
-  while dir != '.' && dir != '/'
-    file dir do |t|
+  Rake.each_dir_parent(dir) do |d|
+    file_create d do |t|
       mkdir_p t.name if ! File.exist?(t.name)
     end
-    dir = File.dirname(dir)
   end
 end
 
@@ -422,7 +499,7 @@ end
 #  end
 #
 def rule(args, &block)
-  Task.create_rule(args, &block)
+  Rake::Task.create_rule(args, &block)
 end
 
 # Describe the next rake task.
@@ -451,7 +528,7 @@ end
 # to be added to the FileUtils utility functions.
 #
 module FileUtils
-  RUBY = Config::CONFIG['ruby_install_name']
+  RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
 
   OPT_TABLE['sh']  = %w(noop verbose)
   OPT_TABLE['ruby'] = %w(noop verbose)
@@ -962,6 +1039,29 @@ module Rake
     end
 
 
+    # Grep each of the files in the filelist using the given pattern.
+    # If a block is given, call the block on each matching line,
+    # passing the file 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)
+      each do |fn|
+	open(fn) do |inf|
+	  count = 0
+	  inf.each do |line|
+	    count += 1
+	    if pattern.match(line)
+	      if block_given?
+		yield fn, count, line
+	      else
+		puts "#{fn}:#{count}:#{line}"
+	      end		
+	    end
+	  end
+	end
+      end
+    end
+
     # FileList version of partition.  Needed because the nested arrays
     # should be FileLists in this version.
     def partition(&block)	# :nodoc:
@@ -1035,6 +1135,21 @@ module Rake
         @exclude_patterns = [ /^$/ ]
       end
     end
+  end # FileList
+end
+
+module Rake
+  class << self
+
+    # Yield each file or directory component.
+    def each_dir_parent(dir)
+      old_length = nil
+      while dir != '.' && dir.length != old_length
+	yield(dir)
+	old_length = dir.length
+	dir = File.dirname(dir)
+      end
+    end
   end
 end
 
@@ -1050,251 +1165,342 @@ module Rake
       Kernel.load fn
     end
   end
-end
 
-######################################################################
-# Rake main application object.  When invoking +rake+ from the command
-# line, a RakeApp object is created and run.
-#
-class RakeApp
-  RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb']
-
-  OPTIONS = [
-    ['--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."],
-    ['--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::REQUIRED_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::NO_ARGUMENT,
-      "Display the tasks and dependencies, 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."],
-  ]
-
-  # Create a RakeApp object.
-  def initialize
-    @rakefile = nil
-    @pending_imports = []
-    @imported = []
-    @nosearch = false
-    @loaders = {}
-    @default_loader = Rake::DefaultLoader.new
-    Rake.application = self
-  end
+  # EarlyTime is a fake timestamp that occurs _before_ any other time
+  # value.
+  class EarlyTime
+    include Comparable
+    include Singleton
 
-  # 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)
-        @rakefile = fn
-        return true
-      end
+    def <=>(other)
+      -1
     end
-    return false
-  end
 
-  # Display the program usage line.
-  def usage
-    puts "rake [-f rakefile] {options} targets..."
-  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
+    def to_s
+      "<EARLY TIME>"
     end
   end
 
-  # Display the tasks and dependencies.
-  def display_tasks_and_comments
-    width = Task.tasks.select { |t|
-      t.comment
-    }.collect { |t|
-      t.name.length
-    }.max
-    Task.tasks.each do |t|
-      if t.comment
-        printf "rake %-#{width}s  # %s\n", t.name, t.comment
-      end
-    end
-  end
+  EARLY = EarlyTime.instance
+end
 
-  # Display the tasks and prerequisites
-  def display_prerequisites
-    Task.tasks.each do |t|
-      puts "rake #{t.name}"
-      t.prerequisites.each { |pre| puts "    #{pre}" }
+######################################################################
+# Extensions to time to allow comparisons with an early time class.
+class Time
+  alias pre_early_time_compare :<=>
+  def <=>(other)
+    if Rake::EarlyTime === other
+      - other.<=>(self)
+    else
+      pre_early_time_compare(other)
     end
-  end
+  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
+module Rake
 
-  # Do the option defined by +opt+ and +value+.
-  def do_option(opt, value)
-    case opt
-    when '--dry-run'
-      verbose(true)
-      nowrite(true)
-      $dryrun = true
-      $trace = true
-    when '--help'
-      help
-      exit
-    when '--libdir'
-      $:.push(value)
-    when '--nosearch'
-      @nosearch = true
-    when '--prereqs'
-      $show_prereqs = true
-    when '--quiet'
-      verbose(false)
-    when '--rakefile'
-      RAKEFILES.clear
-      RAKEFILES << value
-    when '--require'
-      require value
-    when '--silent'
-      verbose(false)
-      $silent = true
-    when '--tasks'
-      $show_tasks = true
-    when '--trace'
-      $trace = true
-      verbose(true)
-    when '--usage'
+  ######################################################################
+  # Rake main application object.  When invoking +rake+ from the
+  # command line, a Rake::Application object is created and run.
+  #
+  class Application
+    RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb']
+    
+    OPTIONS = [
+      ['--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."],
+      ['--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::REQUIRED_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::NO_ARGUMENT,
+	"Display the tasks and dependencies, 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"],
+    ]
+    
+    # Create a Rake::Application object.
+    def initialize
+      @rakefile = nil
+      @pending_imports = []
+      @imported = []
+      @nosearch = false
+      @loaders = {}
+      @default_loader = Rake::DefaultLoader.new
+      Rake.application = self
+    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)
+	  @rakefile = fn
+	  return true
+	end
+      end
+      return false
+    end
+    
+    # Display the program usage line.
+    def usage
+      puts "rake [-f rakefile] {options} targets..."
+    end
+    
+    # Display the rake command line help.
+    def help
       usage
-      exit
-    when '--verbose'
-      verbose(true)
-    when '--version'
-      puts "rake, version #{RAKEVERSION}"
-      exit
-    else
-      fail "Unknown option: #{opt}"
+      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
     end
-  end
-  
-  # Read and handle the command line options.
-  def handle_options
-    opts = GetoptLong.new(*command_line_options)
-    opts.each { |opt, value| do_option(opt, value) }
-  end
-
-  def load_rakefile
-    here = Dir.pwd
-    while ! have_rakefile
-      Dir.chdir("..")
-      if Dir.pwd == here || @nosearch
-        fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
+    
+    # Display the tasks and dependencies.
+    def display_tasks_and_comments
+      width = Rake::Task.tasks.select { |t|
+	t.comment
+      }.collect { |t|
+	t.name.length
+      }.max
+      Rake::Task.tasks.each do |t|
+	if t.comment
+	  printf "rake %-#{width}s  # %s\n", t.name, t.comment
+	end
       end
-      here = Dir.pwd
     end
-    puts "(in #{Dir.pwd})" unless $silent
-    $rakefile = @rakefile
-    load @rakefile
-    load_imports
-  end
-
-  # Collect the list of tasks on the command line.  If no tasks are
-  # give, return a list containing only the default task.
-  # Environmental assignments are processed at this time as well.
-  def collect_tasks
-    tasks = []
-    ARGV.each do |arg|
-      if arg =~ /^(\w+)=(.*)$/
-        ENV[$1] = $2
+    
+    # Display the tasks and prerequisites
+    def display_prerequisites
+      Rake::Task.tasks.each do |t|
+	puts "rake #{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)
+	$dryrun = true
+	$trace = true
+      when '--help'
+	help
+	exit
+      when '--libdir'
+	$:.push(value)
+      when '--nosearch'
+	@nosearch = true
+      when '--prereqs'
+	$show_prereqs = true
+      when '--quiet'
+	verbose(false)
+      when '--rakefile'
+	RAKEFILES.clear
+	RAKEFILES << value
+      when '--require'
+	require value
+      when '--silent'
+	verbose(false)
+	$silent = true
+      when '--tasks'
+	$show_tasks = true
+      when '--trace'
+	$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'
       else
-        tasks << arg
+	fail "Unknown option: #{opt}"
       end
     end
-    tasks.push("default") if tasks.size == 0
-    tasks
-  end
+    
+    # Read and handle the command line options.
+    def handle_options
+      opts = GetoptLong.new(*command_line_options)
+      opts.each { |opt, value| do_option(opt, value) }
+    end
+    
+    def load_rakefile
+      here = Dir.pwd
+      while ! have_rakefile
+	Dir.chdir("..")
+	if Dir.pwd == here || @nosearch
+	  fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
+	end
+	here = Dir.pwd
+      end
+      puts "(in #{Dir.pwd})" unless $silent
+      $rakefile = @rakefile
+      load @rakefile
+      load_imports
+    end
+    
+    # Collect the list of tasks on the command line.  If no tasks are
+    # give, return a list containing only the default task.
+    # Environmental assignments are processed at this time as well.
+    def collect_tasks
+      tasks = []
+      ARGV.each do |arg|
+	if arg =~ /^(\w+)=(.*)$/
+	  ENV[$1] = $2
+	else
+	  tasks << arg
+	end
+      end
+      tasks.push("default") if tasks.size == 0
+      tasks
+    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
+	next if @imported.member?(fn)
+	Rake::Task[fn].invoke if Rake::Task.task_defined?(fn)
+	ext = File.extname(fn)
+	loader = @loaders[ext] || @default_loader
+	loader.load(fn)
+	@imported << fn
+      end
+    end
+    
+    # Add a loader to handle imported files ending in the extension
+    # +ext+.
+    def add_loader(ext, loader)
+      ext = ".#{ext}" unless ext =~ /^\./
+      @loaders[ext] = loader
+    end
+    
+    # Warn about deprecated use of top level constant names.
+    def const_warning(const_name)
+      @const_warning ||= false
+      if ! @const_warning
+	puts %{WARNING: Deprecated reference to top-level constant '#{const_name}'} +
+	  %{found at: #{rakefile_location}}
+	puts %{    Use --classic-namespace on rake command}
+	puts %{    or 'require "rake/classic_namespace"' in Rakefile}
+      end
+      @const_warning = true
+    end
 
-  # Add a file to the list of files to be imported.
-  def add_import(fn)
-    @pending_imports << fn
-  end
+    def rakefile_location
+      begin
+	fail
+      rescue RuntimeError => ex
+	ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+      end
+    end
 
-  # Load the pending list of imported files.
-  def load_imports
-    while fn = @pending_imports.shift
-      next if @imported.member?(fn)
-      Task[fn].invoke if Task.task_defined?(fn)
-      ext = File.extname(fn)
-      loader = @loaders[ext] || @default_loader
-      loader.load(fn)
-      @imported << fn
+    # Run the +rake+ application.
+    def run
+      handle_options
+      begin
+	tasks = collect_tasks
+	load_rakefile
+	if $show_tasks
+	  display_tasks_and_comments
+	elsif $show_prereqs
+	  display_prerequisites
+	else
+	  tasks.each { |task_name| Rake::Task[task_name].invoke }
+	end
+      rescue Exception => ex
+	puts "rake aborted!"
+	puts ex.message
+	if $trace
+	  puts ex.backtrace.join("\n")
+	else
+	  puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+	end
+	exit(1)
+      end    
     end
   end
 
-  # Add a loader to handle imported files ending in the extension
-  # +ext+.
-  def add_loader(ext, loader)
-    ext = ".#{ext}" unless ext =~ /^\./
-    @loaders[ext] = loader
-  end
+end
 
-  # Run the +rake+ application.
-  def run
-    handle_options
-    begin
-      tasks = collect_tasks
-      load_rakefile
-      if $show_tasks
-        display_tasks_and_comments
-      elsif $show_prereqs
-        display_prerequisites
-      else
-        tasks.each { |task_name| Task[task_name].invoke }
-      end
-    rescue Exception => ex
-      puts "rake aborted!"
-      puts ex.message
-      if $trace
-        puts ex.backtrace.join("\n")
+
+class Object
+  class << self
+
+    # 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
+    # --class-namespace 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
-        puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+	rake_original_const_missing(const_name)
       end
-      exit(1)
-    end    
+    end
   end
 end
 
 if __FILE__ == $0 then
-  RakeApp.new.run
+  Rake::Application.new.run
 end