rake 0.6.2 → 0.7.0

data/lib/rake.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #--
-# Copyright (c) 2003, 2004 Jim Weirich
+# Copyright (c) 2003, 2004, 2005, 2006 Jim Weirich
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -29,20 +29,15 @@
 # referenced as a library via a require statement, but it can be
 # distributed independently as an application.
 
-RAKEVERSION = '0.6.2'
+RAKEVERSION = '0.7.0'
 
 require 'rbconfig'
 require 'ftools'
 require 'getoptlong'
 require 'fileutils'
 require 'singleton'
-
-$last_comment = nil
-$show_tasks = nil
-$show_prereqs = nil
-$trace = nil
-$dryrun = nil
-$silent = false
+require 'thread'
+require 'ostruct'
 
 # Some objects are dupable, some are not.  So we define a version of
 # dup (called rake_dup) that returns self on the handful of classes
@@ -89,6 +84,9 @@ end
 ######################################################################
 module Rake
 
+  # ------------------------------------------------------------------
+  # Rake module singleton methods.
+  #
   class << self
     # Current Rake Application
     def application
@@ -97,13 +95,23 @@ module Rake
 
     # Set the current Rake application object.
     def application=(app)
-      fail "Rake::Application already exists" if defined?(@application)
       @application = app
     end
 
+    # Return the original directory where the Rake application was
+    # started.
+    def original_dir
+      application.original_dir
+    end
+
   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
       sibling = self.class.new
       instance_variables.each do |ivar|
@@ -117,6 +125,7 @@ module Rake
 end
 
 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
@@ -128,15 +137,24 @@ module Rake
   # 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
+
+    # Application owning this task.
+    attr_accessor :application
     
     # Comment for this task.
     attr_accessor :comment
     
+    # Array of nested namespaces names used for task lookup by this task.
+    attr_reader :scope
+
+    # Return task name
+    def to_s
+      name
+    end
+    
+    # List of sources for task.
     attr_writer :sources
     def sources
       @sources ||= []
@@ -149,12 +167,15 @@ module Rake
     
     # 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
+    def initialize(task_name, app)
+      @name = task_name.to_s
       @prerequisites = FileList[]
       @actions = []
       @already_invoked = false
       @comment = nil
+      @lock = Mutex.new
+      @application = app
+      @scope = app.current_scope
     end
     
     # Enhance a task with prerequisites or actions.  Returns self.
@@ -164,22 +185,31 @@ module Rake
       self
     end
     
-    # Name of the task.
+    # Name of the task, including any namespace qualifiers.
     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}"
+      @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?
       end
-      return if @already_invoked
-      @already_invoked = true
-      @prerequisites.each { |n| Rake::Task[n].invoke }
-      execute if needed?
     end
-    
+
+    # Invoke all the prerequisites of a task.
+    def invoke_prerequisites
+      @prerequisites.each { |n|
+	application[n, @scope].invoke
+      }
+    end
+
     # Format the trace flags for display.
     def format_trace_flags
       flags = []
@@ -191,14 +221,14 @@ module Rake
     
     # Execute the actions associated with this task.
     def execute
-      if $dryrun
+      if application.options.dryrun
 	puts "** Execute (dry run) #{name}"
 	return
       end
-      if $trace
+      if application.options.trace
 	puts "** Execute #{name}"
       end
-      self.class.enhance_with_matching_rule(name) if @actions.empty?
+      application.enhance_with_matching_rule(name) if @actions.empty?
       @actions.each { |act| result = act.call(self) }
     end
     
@@ -216,14 +246,13 @@ module Rake
     # Add a comment to the task.  If a comment alread exists, separate
     # the new comment with " / ".
     def add_comment(comment)
-      return if ! $last_comment
+      return if ! comment
       if @comment 
 	@comment << " / "
       else
 	@comment = ''
       end
-      @comment << $last_comment
-      $last_comment = nil
+      @comment << comment
     end
     
     # Return a string describing the internal state of a task.  Useful
@@ -246,21 +275,21 @@ module Rake
       return result
     end
     
-    # Rake Module Methods ----------------------------------------------
-    
+    # ----------------------------------------------------------------
+    # 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
+	Rake.application.clear
       end
       
       # List of all defined tasks.
       def tasks
-	TASKS.keys.sort.collect { |tn| Rake::Task[tn] }
+	Rake.application.tasks
       end
       
       # Return a task with the given name.  If the task is not currently
@@ -268,119 +297,33 @@ module Rake
       # 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}'"
+	Rake.application[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]
+	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)
-	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)
+	Rake.application.define_task(self, args, &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
+	Rake.application.create_rule(args, &block)
       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]
+      # Apply the scope to the task name according to the rules for
+      # this kind of task.  Generic tasks will accept the scope as
+      # part of the name.
+      def scope_name(scope, task_name)
+	(scope + [task_name]).join(':')
       end
+
     end
   end
   
@@ -417,6 +360,18 @@ module Rake
     def out_of_date?(stamp)
       @prerequisites.any? { |n| Rake::Task[n].timestamp > stamp}
     end
+
+    # ----------------------------------------------------------------
+    # Task class methods.
+    #
+    class << self
+      # Apply the scope to the task name according to the rules for
+      # this kind of task.  File based tasks ignore the scope when
+      # creating the name.
+      def scope_name(scope, task_name)
+	task_name
+      end
+    end
   end
   
   ######################################################################
@@ -437,6 +392,19 @@ module Rake
       Rake::EARLY
     end
   end
+
+  ####################################################################
+  # Same as a regular task, but the immediate prerequisites are done
+  # in parallel using Ruby threads.
+  #
+  class MultiTask < Task
+    def invoke_prerequisites
+      threads = @prerequisites.collect { |p|
+	Thread.new(p) { |r| Task[r].invoke }
+      }
+      threads.each { |t| t.join }
+    end
+  end
 end
 
 ######################################################################
@@ -491,6 +459,32 @@ def directory(dir)
   end
 end
 
+# Declare a task that performs its prerequisites in parallel.
+# Multitasks does *not* guarantee that its prerequisites will execute
+# in any given order (which is obvious when you think about it)
+#
+# Example:
+#   multitask :deploy => [:deploy_gem, :deploy_rdoc]
+#
+def multitask(args, &block)
+  Rake::MultiTask.define_task(args, &block)
+end
+
+# Create a new rake namespace and use it for evaluating the given
+# block. Returns a NameSpace object that can be used to lookup tasks
+# defined in the namespace.
+#
+# E.g.
+#
+#   ns = namespace "nested" do
+#     task :run
+#   end
+#   task_run = ns[:run] # find :run in the given namespace.
+#
+def namespace(name=nil, &block)
+  Rake.application.in_namespace(name, &block)
+end
+
 # Declare a rule for auto-tasks.
 #
 # Example:
@@ -511,16 +505,27 @@ end
 #   end
 #
 def desc(comment)
-  $last_comment = comment
+  Rake.application.last_comment = comment
 end
 
-# Import the partial Rakekfile +fn+.
+# Import the partial Rakefiles +fn+.  Imported files are loaded
+# _after_ the current file is completely loaded.  This allows the
+# import statement to appear anywhere in the importing file, and yet
+# allowing the imported files to depend on objects defined in the
+# importing file.
+#
+# A common use of the import statement is to include files containing
+# dependency declarations.
+#
+# See also the --rakelibdir command line option.
 #
 # Example:
-#   import ".depend"
+#   import ".depend", "my_rules"
 #
-def import(fn)
-  Rake.application.add_import(fn)
+def import(*fns)
+  fns.each do |fn|
+    Rake.application.add_import(fn)
+  end
 end
 
 ######################################################################
@@ -598,7 +603,7 @@ module FileUtils
     else
       begin
         ln(*args)
-      rescue Errno::EOPNOTSUPP
+      rescue Errno::EOPNOTSUPP, Errno::EXDEV
         LN_SUPPORTED[0] = false
         cp(*args)
       end
@@ -624,20 +629,32 @@ end
 #
 module RakeFileUtils
   include FileUtils
+
+  class << self
+    attr_accessor :verbose_flag, :nowrite_flag
+  end
+  RakeFileUtils.verbose_flag = true
+  RakeFileUtils.nowrite_flag = false
   
-  $fileutils_output  = $stderr
-  $fileutils_label   = ''
   $fileutils_verbose = true
   $fileutils_nowrite = false
   
   FileUtils::OPT_TABLE.each do |name, opts|
-    next unless opts.include?('verbose')
+    default_options = []
+    if opts.include?('verbose')
+      default_options << ':verbose => RakeFileUtils.verbose_flag'
+    end
+    if opts.include?('noop')
+      default_options << ':noop => RakeFileUtils.nowrite_flag'
+    end
+
+    next if default_options.empty?
     module_eval(<<-EOS, __FILE__, __LINE__ + 1)
     def #{name}( *args, &block )
-      super(*fu_merge_option(args,
-          :verbose => $fileutils_verbose,
-          :noop => $fileutils_nowrite),
-        &block)
+      super(
+	*fu_merge_option(args,
+	  #{default_options.join(', ')}
+	  ), &block)
     end
     EOS
   end
@@ -652,16 +669,16 @@ module RakeFileUtils
   #    verbose(v) { code }  # Execute code with the verbose flag set temporarily to _v_.
   #                         # Return to the original value when code is done.
   def verbose(value=nil)
-    oldvalue = $fileutils_verbose
-    $fileutils_verbose = value unless value.nil?
+    oldvalue = RakeFileUtils.verbose_flag
+    RakeFileUtils.verbose_flag = value unless value.nil?
     if block_given?
       begin
         yield
       ensure
-        $fileutils_verbose = oldvalue
+        RakeFileUtils.verbose_flag = oldvalue
       end
     end
-    $fileutils_verbose
+    RakeFileUtils.verbose_flag
   end
 
   # Get/set the nowrite flag controlling output from the FileUtils
@@ -674,13 +691,13 @@ module RakeFileUtils
   #    nowrite(v) { code }  # Execute code with the nowrite flag set temporarily to _v_.
   #                         # Return to the original value when code is done.
   def nowrite(value=nil)
-    oldvalue = $fileutils_nowrite
-    $fileutils_nowrite = value unless value.nil?
+    oldvalue = RakeFileUtils.nowrite_flag
+    RakeFileUtils.nowrite_flag = value unless value.nil?
     if block_given?
       begin
         yield
       ensure
-        $fileutils_nowrite = oldvalue
+	RakeFileUtils.nowrite_flag = oldvalue
       end
     end
     oldvalue
@@ -701,7 +718,7 @@ module RakeFileUtils
   # instead of actually building the project.
   #
   def when_writing(msg=nil)
-    if $fileutils_nowrite
+    if RakeFileUtils.nowrite_flag
       puts "DRYRUN: #{msg}" if msg
     else
       yield
@@ -977,6 +994,7 @@ module Rake
         self << fn
       end
     end
+    private :resolve_add
 
     def resolve_exclude
       @exclude_patterns.each do |pat|
@@ -992,6 +1010,7 @@ module Rake
       end
       self
     end
+    private :resolve_exclude
 
     # Return a new FileList with the results of running +sub+ against
     # each element of the oringal list.
@@ -1162,7 +1181,7 @@ module Rake
   # Default Rakefile loader used by +import+.
   class DefaultLoader
     def load(fn)
-      Kernel.load fn
+      Kernel.load(File.expand_path(fn))
     end
   end
 
@@ -1186,24 +1205,243 @@ end
 
 ######################################################################
 # Extensions to time to allow comparisons with an early time class.
+#
 class Time
-  alias pre_early_time_compare :<=>
+  alias rake_original_time_compare :<=>
   def <=>(other)
     if Rake::EarlyTime === other
       - other.<=>(self)
     else
-      pre_early_time_compare(other)
+      rake_original_time_compare(other)
     end
   end     
 end
 
 module Rake
 
+  ####################################################################
+  # The NameSpace class will lookup task names in the the scope
+  # defined by a +namespace+ command.
+  #
+  class NameSpace
+
+    # Create a namespace lookup object using the given task manager
+    # and the list of scopes.
+    def initialize(task_manager, scope_list)
+      @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
+  end
+
+
+  ####################################################################
+  # The TaskManager module is a mixin for managing tasks.  
+  module TaskManager
+    # Track the last comment made in the Rakefile.
+    attr_accessor :last_comment
+
+    def initialize
+      super
+      @tasks = Hash.new
+      @rules = Array.new
+      @scope = Array.new
+      @last_comment = nil
+    end
+
+    def create_rule(args, &block)
+      pattern, 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)
+      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.application = self
+      task.add_comment(@last_comment)
+      @last_comment = nil
+      task.enhance(deps, &block)
+      task
+    end
+
+    # Lookup a task.  Return an existing task if found, otherwise
+    # create a task of the current type.
+    def intern(task_class, task_name)
+      @tasks[task_name.to_s] ||= task_class.new(task_name, self)
+    end
+
+    # Find a matching task for +task_name+.  
+    def [](task_name, scopes=nil)
+      task_name = task_name.to_s
+      self.lookup(task_name, scopes) or
+	enhance_with_matching_rule(task_name) or
+	synthesize_file_task(task_name) or
+	fail "Don't know how to build task '#{task_name}'"
+    end
+
+    def synthesize_file_task(task_name)
+      return nil unless File.exist?(task_name)
+      define_task(Rake::FileTask, task_name)
+    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
+    
+    # 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
+    
+    # List of all defined tasks in this application.
+    def tasks
+      @tasks.values.sort_by { |t| t.name }
+    end
+
+    # Clear all tasks in this application.
+    def clear
+      @tasks.clear
+      @rules.clear
+    end
+
+    # Lookup a task, using scope and the scope hints in the task name.
+    # This method performs straight lookups without trying to
+    # synthesize file tasks or rules.  Special scope names (e.g. '^')
+    # are recognized.  If no scope argument is supplied, use the
+    # current scope.  Return nil if the task cannot be found.
+    def lookup(task_name, initial_scope=nil)
+      initial_scope ||= @scope
+      task_name = task_name.to_s
+      if task_name =~ /^rake:/
+	scopes = []
+	task_name = task_name.sub(/^rake:/, '')
+      elsif task_name =~ /^(\^+)/
+	scopes = initial_scope[0, initial_scope.size - $1.size]
+	task_name = task_name.sub(/^(\^+)/, '')
+      else
+	scopes = initial_scope
+      end
+      lookup_in_scope(task_name, scopes)
+    end
+
+    # Lookup the task name 
+    def lookup_in_scope(name, scope)
+      n = scope.size
+      while n >= 0
+	tn = (scope[0,n] + [name]).join(':')
+	task = @tasks[tn]
+	return task if task
+	n -= 1
+      end
+      nil
+    end
+    private :lookup_in_scope
+
+    # Return the list of scope names currently active in the task
+    # manager.
+    def current_scope
+      @scope.dup
+    end
+
+    # Evaluate the block in a nested namespace named +name+.  Create
+    # an anonymous namespace if +name+ is nil.
+    def in_namespace(name)
+      name ||= generate_name
+      @scope.push(name)
+      ns = NameSpace.new(self, @scope)
+      yield(ns)
+      ns
+    ensure
+      @scope.pop
+    end
+
+    private
+
+    # Generate an anonymous namespace name.
+    def generate_name
+      @seed ||= 0
+      @seed += 1
+      "_anon_#{@seed}"
+    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|
+	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
+    
+  end
+
   ######################################################################
   # Rake main application object.  When invoking +rake+ from the
   # command line, a Rake::Application object is created and run.
   #
   class Application
+    include TaskManager
+
+    # The original directory where rake was invoked.
+    attr_reader :original_dir
+
     RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb']
     
     OPTIONS = [
@@ -1213,6 +1451,8 @@ module Rake
 	"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,
@@ -1241,15 +1481,22 @@ module Rake
     
     # Create a Rake::Application object.
     def initialize
+      super
       @rakefile = nil
       @pending_imports = []
       @imported = []
-      @nosearch = false
       @loaders = {}
       @default_loader = Rake::DefaultLoader.new
-      Rake.application = self
+      @original_dir = Dir.pwd
+      add_loader('rf', DefaultLoader.new)
+      add_loader('rake', DefaultLoader.new)
     end
     
+    # Application options from the command line
+    def options
+      @options ||= OpenStruct.new
+    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
@@ -1318,31 +1565,33 @@ module Rake
       when '--dry-run'
 	verbose(true)
 	nowrite(true)
-	$dryrun = true
-	$trace = true
+	options.dryrun = true
+	options.trace = true
       when '--help'
 	help
 	exit
       when '--libdir'
 	$:.push(value)
       when '--nosearch'
-	@nosearch = true
+	options.nosearch = true
       when '--prereqs'
-	$show_prereqs = true
+	options.show_prereqs = true
       when '--quiet'
 	verbose(false)
       when '--rakefile'
 	RAKEFILES.clear
 	RAKEFILES << value
+      when '--rakelibdir'
+	options.rakelib = value.split(':')
       when '--require'
 	require value
       when '--silent'
 	verbose(false)
-	$silent = true
+	options.silent = true
       when '--tasks'
-	$show_tasks = true
+	options.show_tasks = true
       when '--trace'
-	$trace = true
+	options.trace = true
 	verbose(true)
       when '--usage'
 	usage
@@ -1354,6 +1603,7 @@ module Rake
 	exit
       when '--classic-namespace'
 	require 'rake/classic_namespace'
+	options.classic_namespace = true
       else
 	fail "Unknown option: #{opt}"
       end
@@ -1361,22 +1611,37 @@ module Rake
     
     # Read and handle the command line options.
     def handle_options
+      options.rakelib = 'rakelib'
+
       opts = GetoptLong.new(*command_line_options)
       opts.each { |opt, value| do_option(opt, value) }
+
+      # If class namespaces are requested, set the global options
+      # according to the values in the options structure.
+      if options.classic_namespace
+	$show_tasks = options.show_tasks
+	$show_prereqs = options.show_prereqs
+	$trace = options.trace
+	$dryrun = options.dryrun
+	$silent = options.silent
+      end
     end
     
     def load_rakefile
       here = Dir.pwd
       while ! have_rakefile
 	Dir.chdir("..")
-	if Dir.pwd == here || @nosearch
+	if Dir.pwd == here || options.nosearch
 	  fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
 	end
 	here = Dir.pwd
       end
-      puts "(in #{Dir.pwd})" unless $silent
+      puts "(in #{Dir.pwd})" unless options.silent
       $rakefile = @rakefile
-      load @rakefile
+      load File.expand_path(@rakefile)
+      options.rakelib.each do |rlib|
+	Dir["#{rlib}/*.rake"].each do |name| add_import name end
+      end
       load_imports
     end
     
@@ -1425,7 +1690,7 @@ module Rake
       @const_warning ||= false
       if ! @const_warning
 	puts %{WARNING: Deprecated reference to top-level constant '#{const_name}'} +
-	  %{found at: #{rakefile_location}}
+	  %{found at: #{rakefile_location}} # '
 	puts %{    Use --classic-namespace on rake command}
 	puts %{    or 'require "rake/classic_namespace"' in Rakefile}
       end
@@ -1446,9 +1711,9 @@ module Rake
       begin
 	tasks = collect_tasks
 	load_rakefile
-	if $show_tasks
+	if options.show_tasks
 	  display_tasks_and_comments
-	elsif $show_prereqs
+	elsif options.show_prereqs
 	  display_prerequisites
 	else
 	  tasks.each { |task_name| Rake::Task[task_name].invoke }
@@ -1456,29 +1721,28 @@ module Rake
       rescue Exception => ex
 	puts "rake aborted!"
 	puts ex.message
-	if $trace
+	if options.trace
 	  puts ex.backtrace.join("\n")
 	else
 	  puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+	  puts "(See full trace by running task with --trace)"
 	end
 	exit(1)
       end    
     end
   end
-
 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
-  # --class-namespace will define these constants in Object and avoid
-  # this handler.
+  # name, display a warning and return the proper object.  Using the
+  # --classic-namespace command line option will define these
+  # constants in Object and avoid this handler.
   def const_missing(const_name)
     case const_name
     when :Task