rake 0.5.0 → 0.5.3

data/CHANGES

@@ -1,5 +1,21 @@
 = Rake Changelog
 
+== Version 0.5.3
+
+* Added support for importing Rakefile and other dependencies.
+* Fixed bug so that now rules can chain off of existing tasks as well
+  as existing files.
+* Fixed verbose flag bug in the testing task.  Shortened some failure
+  messages.
+* Make FileUtils methods private at the top level module to avoid
+  accidental method leaking into other objects.
+* Added test loader option to test task.  "testrb" is no longer the
+  default test loader.  It is now eating syntax errors that should
+  halt the unit tests.
+* Revamped FileList so that it works more like and array (addressed
+  flatten bug).  Added many tests around file list.
+* Added +ext+ method to both String and FileList.
+
 == Version 0.5.0
 
 * Fixed documentation that was lacking the Rake module name (Tilman
@@ -10,7 +26,7 @@
 * The jamis rdoc template is only used if it exists.
 * Added fix for Ruby 1.8.2 test/unit and rails problem.
 * Added contributed rake man file (Jani Monoses).
-* Added Brian Chandler's fix for problems in --trace and --dry-run
+* Added Brian Candler's fix for problems in --trace and --dry-run
   mode.
 
 == Version 0.4.15

data/Rakefile

@@ -19,6 +19,7 @@ require 'rake/rdoctask'
 CLEAN.include('**/*.o')
 CLOBBER.include('doc/example/main', 'testdata')
 CLOBBER.include('test/data/**/temp_*')
+CLOBBER.include('test/data/chains/play.*')
 
 
 def announce(msg='')
@@ -45,11 +46,16 @@ SRC_RB = FileList['lib/**/*.rb']
 # The default task is run if rake is given no explicit arguments.
 
 desc "Default Task"
-task :default => :testall
+task :default => :alltests
 
 # Test Tasks ---------------------------------------------------------
 
-Rake::TestTask.new(:testall) do |t|
+task :a => :alltests
+task :f => :funtests
+task :u => :unittests
+task :c => :contribtests
+
+Rake::TestTask.new(:alltests) do |t|
   t.test_files = FileList[
     'test/test*.rb',
     'test/contrib/test*.rb',
@@ -59,36 +65,37 @@ Rake::TestTask.new(:testall) do |t|
   t.verbose = true
 end
 
-Rake::TestTask.new(:test) do |t|
+Rake::TestTask.new(:unittests) do |t|
   t.test_files = FileList['test/test*.rb']
   t.warning = true if t.respond_to? :warning
   t.verbose = true
 end
 
-Rake::TestTask.new(:testfun) do |t|
+Rake::TestTask.new(:funtests) do |t|
   t.pattern = 'test/fun*.rb'
   t.warning = true if t.respond_to? :warning
 end
 
-Rake::TestTask.new(:testcontrib) do |t|
+Rake::TestTask.new(:contribtests) do |t|
   t.pattern = 'test/contrib/test*.rb'
   t.verbose = true
   t.warning = true if t.respond_to? :warning
 end
 
 directory 'testdata'
-task :test => ['testdata']
-
+[:alltests, :unittests, :contribtests, :funtests].each do |t|
+  task t => ['testdata']
+end
 
 # Abbreviations
 
-task :ta => [:testall]
-task :tf => [:testfun]
-task :tc => [:testcontrib]
+task :a => [:alltests]
+task :u => [:unittests]
+task :f => [:funtests]
+task :c => [:contribtests]
 
 # CVS Tasks ----------------------------------------------------------
 
-
 # Install rake using the standard install.rb script.
 
 desc "Install the application"
@@ -268,7 +275,7 @@ desc "Make a new release"
 task :release => [
   :prerelease,
   :clobber,
-  :testall,
+  :alltests,
   :update_version,
   :package,
   :tag] do

data/doc/release_notes/rake-0.5.0.rdoc

@@ -6,7 +6,7 @@ of Rake available.
 == Changes
 
 * Fixed bug where missing intermediate file dependencies could cause
-  an abort with --trace or --dry-run.  (Brian Chandler)
+  an abort with --trace or --dry-run.  (Brian Candler)
 
 * Recursive rules are now supported (Tilman Sauerbeck).
 
@@ -46,7 +46,7 @@ Download::  http://rubyforge.org/project/showfiles.php?group_id=50
 Lots of people provided input to this release.  Thanks to Tilman
 Sauerbeck for numerous patches, documentation fixes and suggestions.
 And for also pushing me to get this release out.  Also, thanks to
-Brian Chandler for the finding and fixing --trace/dry-run fix.  That
+Brian Candler for the finding and fixing --trace/dry-run fix.  That
 was an obscure bug.  Also to Eric Hodel for some good suggestions.
 
 -- Jim Weirich

data/lib/rake.rb

@@ -29,7 +29,7 @@
 # referenced as a library via a require statement, but it can be
 # distributed independently as an application.
 
-RAKEVERSION = '0.5.0'
+RAKEVERSION = '0.5.3'
 
 require 'rbconfig'
 require 'ftools'
@@ -43,6 +43,76 @@ $trace = nil
 $dryrun = nil
 $silent = false
 
+# 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
+# that are not dupable.
+
+module Kernel
+  # Duplicate an object if it can be duplicated.  If it can not be
+  # cloned or duplicated, then just return the original object.
+  def rake_dup()
+    dup
+  end
+end
+
+[NilClass, FalseClass, TrueClass, Fixnum, Symbol].each do |clazz|
+  clazz.class_eval {
+    # Duplicate an object if it can be duplicated.  If it can not be
+    # cloned or duplicated, then just return the original object.
+    def rake_dup() self end
+  }
+end
+
+######################################################################
+# User defined methods to be added to String.
+#
+class String
+  unless instance_methods.include? "ext"
+    # Replace the file extension with +newext+.  If there is no
+    # extenson 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.
+    #
+    # +ext+ is a user added method for the String class.
+    def ext(newext='')
+      return self.dup if ['.', '..'].include? self
+      if newext != ''
+ 	newext = (newext =~ /^\./) ? newext : ("." + newext)
+      end
+      dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext
+    end
+  end
+end
+
+
+######################################################################
+module Rake
+
+  class << self
+    # Current Rake Application
+    def application
+      @application ||= RakeApp.new
+    end
+
+    def application=(app)
+      fail "RakeApp already exists" if defined?(@application)
+      @application = app
+    end
+  end
+
+  module Cloneable
+    def clone
+      sibling = self.class.new
+      instance_variables.each do |ivar|
+        value = self.instance_variable_get(ivar)
+        sibling.instance_variable_set(ivar, value.rake_dup)
+      end
+      sibling
+    end
+    alias dup clone
+  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
@@ -71,7 +141,7 @@ class Task
   # use +enhance+ to add actions and prerequisites.
   def initialize(task_name)
     @name = task_name
-    @prerequisites = []
+    @prerequisites = FileList[]
     @actions = []
     @already_invoked = false
     @comment = nil
@@ -146,7 +216,7 @@ class Task
     $last_comment = nil
   end
 
-  # Class Methods ----------------------------------------------------
+  # Rake Module Methods ----------------------------------------------
 
   class << self
 
@@ -170,13 +240,13 @@ class Task
     def [](task_name)
       task_name = task_name.to_s
       if task = TASKS[task_name]
-	return task
+        return task
       end
       if task = enhance_with_matching_rule(task_name)
-	return task
+        return task
       end
       if File.exist?(task_name)
-	return FileTask.define_task(task_name)
+        return FileTask.define_task(task_name)
       end
       fail "Don't know how to build task '#{task_name}'"
     end
@@ -221,28 +291,28 @@ class Task
     # 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
+        "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 = 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
+        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
       end
       nil
     rescue Rake::RuleRecursionOverflowError => ex
@@ -256,14 +326,14 @@ class Task
     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)
+        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 = []
+        task_name = args
+        deps = []
       end
       [task_name, deps]
     end
@@ -367,6 +437,14 @@ def desc(comment)
   $last_comment = comment
 end
 
+# Import the partial Rakekfile +fn+.
+#
+# Example:
+#   import ".depend"
+#
+def import(fn)
+  Rake.application.add_import(fn)
+end
 
 ######################################################################
 # This a FileUtils extension that defines several additional commands
@@ -401,8 +479,10 @@ module FileUtils
       options = {}
     end
     unless block_given?
+      show_command = cmd.join(" ")
+      show_command = show_command[0,42] + "..." if show_command.length > 45
       block = lambda { |ok, status|
-	ok or fail "Command failed with status (#{status.exitstatus}): [#{cmd.join(" ")}]"
+        ok or fail "Command failed with status (#{status.exitstatus}): [#{show_command}]"
       }
     end
     fu_check_options options, :noop, :verbose
@@ -440,10 +520,10 @@ module FileUtils
       cp(*args)
     else
       begin
-	ln(*args)
+        ln(*args)
       rescue Errno::EOPNOTSUPP
-	LN_SUPPORTED[0] = false
-	cp(*args)
+        LN_SUPPORTED[0] = false
+        cp(*args)
       end
     end
   end
@@ -478,9 +558,9 @@ module RakeFileUtils
     module_eval(<<-EOS, __FILE__, __LINE__ + 1)
     def #{name}( *args, &block )
       super(*fu_merge_option(args,
-	  :verbose => $fileutils_verbose,
-	  :noop => $fileutils_nowrite),
-	&block)
+          :verbose => $fileutils_verbose,
+          :noop => $fileutils_nowrite),
+        &block)
     end
     EOS
   end
@@ -499,9 +579,9 @@ module RakeFileUtils
     $fileutils_verbose = value unless value.nil?
     if block_given?
       begin
-	yield
+        yield
       ensure
-	$fileutils_verbose = oldvalue
+        $fileutils_verbose = oldvalue
       end
     end
     $fileutils_verbose
@@ -521,9 +601,9 @@ module RakeFileUtils
     $fileutils_nowrite = value unless value.nil?
     if block_given?
       begin
-	yield
+        yield
       ensure
-	$fileutils_nowrite = oldvalue
+        $fileutils_nowrite = oldvalue
       end
     end
     oldvalue
@@ -566,8 +646,20 @@ module RakeFileUtils
   
 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.
+
+file_utils_methods = (FileUtils.methods - Object.methods)
 include RakeFileUtils
 
+file_utils_methods.each do |name|
+  private name.to_sym
+end
+file_utils_methods = nil
+
+######################################################################
 module Rake
 
   class RuleRecursionOverflowError < StandardError
@@ -589,27 +681,82 @@ module Rake
   # A FileList is essentially an array with a few helper methods
   # defined to make file manipulation a bit easier.
   #
-  class FileList < Array
+  # FileLists are lazy.  When given a list of glob patterns for
+  # possible files to be included in the file list, instead of
+  # searching the file structures to find the files, a FileList holds
+  # the pattern for latter use.
+  #
+  # This allows us to define a number of FileList to match any number of
+  # files, but only search out the actual files when then FileList
+  # itself is actually used.  The key is that the first time an
+  # element of the FileList/Array is requested, the pending patterns
+  # are resolved into a real list of file names.
+  #
+  class FileList 
 
-    # Rewrite all array methods (and to_s/inspect) to resolve the list
-    # before running.
-    method_list = Array.instance_methods - Object.instance_methods
-    %w[to_a inspect].each do |meth|
-      method_list << meth unless method_list.include? meth
-    end
-    method_list.each_with_index do |sym, i|
-      if sym =~ /^[A-Za-z_]+$/
-	name = sym
+    include Cloneable
+
+    # == Method Delegation
+    #
+    # The lazy evaluation magic of FileLists happens by implementing
+    # all the array specific methods to call +resolve+ before
+    # delegating the heavy lifting to an embedded array object
+    # (@items).
+    #
+    # In addition, there are two kinds of delegation calls.  The
+    # regular kind delegates to the @items array and returns the
+    # result directly.  Well, almost directly.  It checks if the
+    # returned value is the @items object itself, and if so will
+    # return the FileList object instead.
+    #
+    # The second kind of delegation call is used in methods that
+    # normally return a new Array object.  We want to capture the
+    # return value of these methods and wrap them in a new FileList
+    # object.  We enumerate these methods in the +SPECIAL_RETURN+ list
+    # below.
+
+    # List of array methods (that are not in +Object+) that need to be
+    # delegated.
+    ARRAY_METHODS = Array.instance_methods - Object.instance_methods
+
+    # List of additional methods that must be delegated.
+    MUST_DEFINE = %w[to_a inspect]
+
+    # List of methods that should not be delegated here (we define
+    # special versions of them explicitly below).
+    MUST_NOT_DEFINE = %w[to_a to_ary partition *]
+
+    # List of delegated methods that return new array values which
+    # need wrapping.
+    SPECIAL_RETURN = %w[
+      map collect sort sort_by select find_all reject grep
+      compact flatten uniq values_at
+      + - & |
+    ]
+    
+    DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).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
+            result = @items.send(:#{sym}, *args, &block)
+            FileList.new.import(result)
+          end
+        }, __FILE__, ln
       else
-	name = i
+        ln = __LINE__+1
+        class_eval %{
+          def #{sym}(*args, &block)
+            resolve if @pending
+            result = @items.send(:#{sym}, *args, &block)
+            result.object_id == @items.object_id ? self : result
+          end
+        }, __FILE__, ln
       end
-      alias_method "array_#{name}", sym
-      class_eval %{
-        def #{sym}(*args, &block)
-          resolve if @pending
-	  array_#{name}(*args, &block)
-	end
-      }
     end
 
     # Create a file list from the globbable patterns given.  If you
@@ -628,6 +775,7 @@ module Rake
       @pending = false
       @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
       @exclude_re = nil
+      @items = []
       patterns.each { |pattern| include(pattern) }
       yield self if block_given?
     end
@@ -667,72 +815,102 @@ module Rake
     #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
     #
     def exclude(*patterns)
-      # TODO: check for pending
       patterns.each do |pat| @exclude_patterns << pat end
       if ! @pending
-	calculate_exclude_regexp
-	reject! { |fn| fn =~ @exclude_re }
+        calculate_exclude_regexp
+        reject! { |fn| fn =~ @exclude_re }
       end
       self
     end
 
     
+    # Clear all the exclude patterns so that we exclude nothing.
     def clear_exclude
       @exclude_patterns = []
       calculate_exclude_regexp if ! @pending
     end
 
+    # Define equality.
+    def ==(array)
+      to_ary == array
+    end
+
+    # Return the internal array object.
+    def to_a
+      resolve
+      @items
+    end
+
+    # Return the internal array object.
+    def to_ary
+      resolve
+      @items
+    end
+
+    # Redefine * to return either a string or a new file list.
+    def *(other)
+      result = @items * other
+      case result
+      when Array
+	FileList.new.import(result)
+      else
+	result
+      end
+    end
+
     # Resolve all the pending adds now.
     def resolve
-      @pending = false
-      @pending_add.each do |fn| resolve_add(fn) end
-      @pending_add = []
-      resolve_exclude
+      if @pending
+        @pending = false
+        @pending_add.each do |fn| resolve_add(fn) end
+        @pending_add = []
+        resolve_exclude
+      end
       self
     end
 
     def calculate_exclude_regexp
       ignores = []
       @exclude_patterns.each do |pat|
-	case pat
-	when Regexp
-	  ignores << pat
-	when /[*.]/
-	  Dir[pat].each do |p| ignores << p end
-	else
-	  ignores << Regexp.quote(pat)
-	end
+        case pat
+        when Regexp
+          ignores << pat
+        when /[*.]/
+          Dir[pat].each do |p| ignores << p end
+        else
+          ignores << Regexp.quote(pat)
+        end
       end
       if ignores.empty?
-	@exclude_re = /^$/
+        @exclude_re = /^$/
       else
-	re_str = ignores.collect { |p| "(" + p.to_s + ")" }.join("|")
-	@exclude_re = Regexp.new(re_str)
+        re_str = ignores.collect { |p| "(" + p.to_s + ")" }.join("|")
+        @exclude_re = Regexp.new(re_str)
       end
     end
 
     def resolve_add(fn)
       case fn
       when Array
-	fn.each { |f| self.resolve_add(f) }
+        fn.each { |f| self.resolve_add(f) }
       when %r{[*?]}
-	add_matching(fn)
+        add_matching(fn)
       else
-	self << fn
+        self << fn
       end
     end
 
     def resolve_exclude
       @exclude_patterns.each do |pat|
-	case pat
-	when Regexp
-	  reject! { |fn| fn =~ pat }
-	when /[*.]/
-	  reject_list = Dir[pat]
-	  reject! { |fn| reject_list.include?(fn) }
-	else
-	  reject! { |fn| fn == pat }
-	end
+        case pat
+        when Regexp
+          reject! { |fn| fn =~ pat }
+        when /[*.]/
+          reject_list = Dir[pat]
+          reject! { |fn| reject_list.include?(fn) }
+        else
+          reject! { |fn| fn == pat }
+        end
       end
       self
     end
@@ -770,6 +948,30 @@ module Rake
       self
     end
 
+    # Return a new array with <tt>String#ext</tt> method applied to
+    # each member of the array.
+    #
+    # This method is a shortcut for:
+    #
+    #    array.collect { |item| item.ext(newext) }
+    #
+    # +ext+ is a user added method for the Array class.
+    def ext(newext='')
+      collect { |fn| fn.ext(newext) }
+    end
+
+
+    # FileList version of partition.  Needed because the nested arrays
+    # should be FileLists in this version.
+    def partition(&block)	# :nodoc:
+      resolve
+      result = @items.partition(&block)
+      [
+        FileList.new.import(result[0]),
+        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
@@ -779,7 +981,7 @@ module Rake
     # Add matching glob patterns.
     def add_matching(pattern)
       Dir[pattern].each do |fn|
-	self << fn unless exclude?(fn)
+        self << fn unless exclude?(fn)
       end
     end
     private :add_matching
@@ -798,12 +1000,17 @@ module Rake
     ]
     @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
 
+    def import(array)
+      @items = array
+      self
+    end
+
     class << self
       # Create a new file list including the files listed. Similar to:
       #
       #   FileList.new(*args)
       def [](*args)
-	new(*args)
+        new(*args)
       end
 
       # Set the ignore patterns back to the default value.  The
@@ -817,12 +1024,12 @@ module Rake
       # 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
+        @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
       end
 
       # Clear the ignore patterns.  
       def clear_ignore_patterns
-	@exclude_patterns = [ /^$/ ]
+        @exclude_patterns = [ /^$/ ]
       end
     end
   end
@@ -831,6 +1038,17 @@ end
 # Alias FileList to be available at the top level.
 FileList = Rake::FileList
 
+######################################################################
+module Rake
+
+  # Default Rakefile loader used by +import+.
+  class DefaultLoader
+    def load(fn)
+      Kernel.load fn
+    end
+  end
+end
+
 ######################################################################
 # Rake main application object.  When invoking +rake+ from the command
 # line, a RakeApp object is created and run.
@@ -872,7 +1090,12 @@ class RakeApp
   # Create a RakeApp 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.
@@ -880,8 +1103,8 @@ class RakeApp
   def have_rakefile
     RAKEFILES.each do |fn|
       if File.exist?(fn)
-	@rakefile = fn
-	return true
+        @rakefile = fn
+        return true
       end
     end
     return false
@@ -900,9 +1123,9 @@ class RakeApp
     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
+        if desc =~ /\b([A-Z]{2,})\b/
+          long = long + "=#{$1}"
+        end
       end
       printf "  %-20s (%s)\n", long, short
       printf "      %s\n", desc
@@ -918,7 +1141,7 @@ class RakeApp
     }.max
     Task.tasks.each do |t|
       if t.comment
-	printf "rake %-#{width}s  # %s\n", t.name, t.comment
+        printf "rake %-#{width}s  # %s\n", t.name, t.comment
       end
     end
   end
@@ -993,13 +1216,14 @@ class RakeApp
     while ! have_rakefile
       Dir.chdir("..")
       if Dir.pwd == here || @nosearch
-	fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
+        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
@@ -1009,15 +1233,39 @@ class RakeApp
     tasks = []
     ARGV.each do |arg|
       if arg =~ /^(\w+)=(.*)$/
-	ENV[$1] = $2
+        ENV[$1] = $2
       else
-	tasks << arg
+        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)
+      Task[fn].invoke if 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
+
   # Run the +rake+ application.
   def run
     handle_options
@@ -1025,19 +1273,19 @@ class RakeApp
       tasks = collect_tasks
       load_rakefile
       if $show_tasks
-	display_tasks_and_comments
+        display_tasks_and_comments
       elsif $show_prereqs
-	display_prerequisites
+        display_prerequisites
       else
-	tasks.each { |task_name| Task[task_name].invoke }
+        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")
+        puts ex.backtrace.join("\n")
       else
-	puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+        puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
       end
       exit(1)
     end