rake 0.7.1 → 0.7.2

data/CHANGES

@@ -1,5 +1,40 @@
 = Rake Changelog
 
+== Pre-Version 0.7.2
+
+* Error messages are now send to stderr rather than stdout (from
+  Payton Quackenbush).
+* Better error handling on invalid command line arguments (from Payton
+  Quackenbush).
+* Added rcov task and updated unit testing for better code coverage.
+* Fixed some bugs where the application object was going to the global
+  appliation instead of using its own data.
+* Added square and curly bracket patterns to FileList#include (Tilman
+  Sauerbeck). 
+* Added plain filename support to rule dependents (suggested by Nobu
+  Nakada). 
+* Added pathmap support to rule dependents.
+* Added a 'tasks' method to a namespace to get a list of tasks
+  associated with the namespace.
+* Fixed the method name leak from FileUtils (bug found by Glenn
+  Vanderburg). 
+* Added rake_extension to handle detection of extension collisions.
+* Added test for noop, bad_option and verbose flags to sh command.
+* Removed dependency on internal fu_xxx functions from FileUtils.
+* Added a 'shame' task to the Rakefile.
+* Added tar_command and zip_command options to the Package task.
+* Added a description to the gem task in GemPackageTask.
+* Fixed a bug when rules have multiple prerequisites (patch by Joel
+  VanderWerf)
+* Added a protected 'require "rubygems"' to test/test_application to
+  unbreak cruisecontrol.rb.
+* Added the handful of RakeFileUtils to the private method as well.
+* Added block based exclusion.
+* The clean task will no longer delete 'core' if it is a directory.
+* Removed rake_dup.  Now we just simply rescue a bad dup.
+* Refactored the FileList reject logic to remove duplication.
+* Removed if __FILE__ at the end of the rake.rb file.
+
 == Version 0.7.1
 
 * Added optional filter parameter to the --tasks command line option.

data/Rakefile

@@ -3,7 +3,7 @@
 # Copyright 2003, 2004, 2005 by Jim Weirich (jim@weirichhouse.org)
 # All rights reserved.
 
-# This file is may be distributed under an MIT style license.  See
+# This file may be distributed under an MIT style license.  See
 # MIT-LICENSE for details.
 
 begin
@@ -16,13 +16,14 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-CLEAN.include('**/*.o')
+CLEAN.include('**/*.o', '*.dot')
 CLOBBER.include('doc/example/main', 'testdata')
 CLOBBER.include('test/data/**/temp_*')
 CLOBBER.include('test/data/chains/play.*')
 CLOBBER.include('test/data/file_creation_task/build')
 CLOBBER.include('test/data/file_creation_task/src')
 CLOBBER.include('TAGS')
+CLOBBER.include('coverage')
 
 def announce(msg='')
   STDERR.puts msg
@@ -87,6 +88,18 @@ Rake::TestTask.new(:test_contribs) do |t|
   t.warning = true
 end
 
+require 'rcov/rcovtask'
+
+Rcov::RcovTask.new do |t|
+  t.libs << "test"
+  t.rcov_opts = ['-xRakefile', '-xrakefile', '-xpublish.rf', '--text-report']
+  t.test_files = FileList[
+    'test/test*.rb',
+    'test/contrib/test*.rb'
+  ]
+  t.verbose = true
+end
+
 directory 'testdata'
 [:test_all, :test_units, :test_contribs, :test_functional].each do |t|
   task t => ['testdata']
@@ -107,9 +120,11 @@ rd = Rake::RDocTask.new("rdoc") { |rdoc|
   rdoc.rdoc_dir = 'html'
 #  rdoc.template = 'kilmer'
 #  rdoc.template = 'css2'
-  rdoc.template = '/home/jim/working/rubyforge/rake/doc/jamis.rb'
+  rdoc.template = 'doc/jamis.rb'
   rdoc.title    = "Rake -- Ruby Make"
-  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.options << '--line-numbers' << '--inline-source' <<
+    '--main' << 'README' <<
+    '--title' <<  'Rake -- Ruby Make' 
   rdoc.rdoc_files.include('README', 'MIT-LICENSE', 'TODO', 'CHANGES')
   rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc')
   rdoc.rdoc_files.exclude(/\bcontrib\b/)
@@ -173,10 +188,7 @@ else
 
     s.has_rdoc = true
     s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
-    s.rdoc_options <<
-      '--title' <<  'Rake -- Ruby Make' <<
-      '--main' << 'README' <<
-      '--line-numbers'
+    s.rdoc_options = rd.options
 
     #### Author and project details.
 
@@ -245,12 +257,12 @@ load "publish.rf" if File.exist? "publish.rf"
 
 desc "Look for TODO and FIXME tags in the code"
 task :todo do
-  FileList['**/*.rb'].exclude('pkg').egrep /#.*(FIXME|TODO|TBD)/
+  FileList['**/*.rb'].exclude('pkg').egrep(/#.*(FIXME|TODO|TBD)/)
 end
 
 desc "Look for Debugging print lines"
 task :dbg do
-  FileList['**/*.rb'].egrep /\bDBG|\bbreakpoint\b/
+  FileList['**/*.rb'].egrep(/\bDBG|\bbreakpoint\b/)
 end
 
 desc "List all ruby files"
@@ -333,7 +345,7 @@ task :update_version => [:prerelease] do
     if ENV['RELTEST']
       announce "Release Task Testing, skipping commiting of new version"
     else
-      sh %{cvs commit -m "Updated to version #{PKG_VERSION}" lib/rake.rb}
+      sh %{cvs commit -m "Updated to version #{PKG_VERSION}" lib/rake.rb} # "
     end
   end
 end
@@ -361,3 +373,7 @@ end
 # Require experimental XForge/Metaproject support.
 
 load 'xforge.rf' if File.exist?('xforge.rf')
+
+task :where_am_i do
+  puts Rake.original_dir
+end

data/doc/jamis.rb

@@ -250,7 +250,7 @@ FILE_PAGE = <<HTML
             <td>Path:</td>
             <td>%full_path%
 IF:cvsurl
-				&nbsp;(<a href="%cvsurl%">CVS</a>)
+              &nbsp;(<a href="%cvsurl%">CVS</a>)
 ENDIF:cvsurl
             </td>
           </tr>

data/doc/rakefile.rdoc

@@ -356,6 +356,24 @@ resolve in different locations.
   # "one:run"      => "one:run"
   # "one:two:run"  => "one:two:run"
 
+== FileLists
+
+FileLists are the way Rake manages lists of files.  You can treat a
+FileList as an array of strings for the most part, but FileLists
+support some additional operations.
+
+=== Creating a FileList
+
+Creating a file list is easy.  Just give it the list of file names:
+
+   fl = FileList['file1.rb', file2.rb']
+
+Or give it a glob pattern:
+
+   fl = FileList['*.rb']
+
+   
+
 == Odds and Ends
 
 === do/end verses { }

data/doc/release_notes/rake-0.7.2.rdoc

@@ -0,0 +1,121 @@
+= Rake 0.7.2 Released
+
+Version 0.7.2 supplies a bug fix and a few minor enhancements.  In
+particular, the new version fixes an incompatibility with the soon to
+be released Ruby 1.8.6.  We strongly recommend upgrading to Rake 0.7.2
+in order to be compatible with the new version of Ruby.
+
+== Changes
+
+=== Bug Fixes in 0.7.2
+
+There are quite a number of bug fixes in the new 0.7.2 version of
+Rake:
+
+* Removed dependency on internal fu_xxx functions from FileUtils.
+
+* Error messages are now send to stderr rather than stdout (from
+  Payton Quackenbush).
+
+* Better error handling on invalid command line arguments (from Payton
+  Quackenbush).
+
+* Fixed some bugs where the application object was going to the global
+  appliation instead of using its own data.
+
+* Fixed the method name leak from FileUtils (bug found by Glenn
+  Vanderburg). 
+
+* Added test for noop, bad_option and verbose flags to sh command.
+
+* Added a description to the gem task in GemPackageTask.
+
+* Fixed a bug when rules have multiple prerequisites (patch by Joel
+  VanderWerf)
+
+* Added the handful of RakeFileUtils to the private method as well.
+
+=== New Features in 0.7.2
+
+The following new features are available in Rake version 0.7.2:
+
+* Added square and curly bracket patterns to FileList#include (Tilman
+  Sauerbeck). 
+
+* FileLists can now pass a block to FileList#exclude to exclude files
+  based on calculated values.
+
+* Added plain filename support to rule dependents (suggested by Nobu
+  Nakada). 
+
+* Added pathmap support to rule dependents.  In other words, if a
+  pathmap format (beginning with a '%') is given as a Rake rule
+  dependent, then the name of the depend will be the name of the
+  target with the pathmap format applied.
+
+* Added a 'tasks' method to a namespace to get a list of tasks
+  associated with the namespace.
+
+* Added tar_command and zip_command options to the Package task.
+
+* The clean task will no longer delete 'core' if it is a directory.
+
+=== Internal Rake Improvements
+
+The following changes will are mainly internal improvements and
+refactorings and have little effect on the end user.  But they may be
+of interest to the general public.
+
+* Added rcov task and updated unit testing for better code coverage.
+
+* Added a 'shame' task to the Rakefile.
+
+* Added rake_extension to handle detection of extension collisions.
+
+* Added a protected 'require "rubygems"' to test/test_application to
+  unbreak cruisecontrol.rb.
+
+* Removed rake_dup.  Now we just simply rescue a bad dup.
+
+* Refactored the FileList reject logic to remove duplication.
+
+* Removed if __FILE__ at the end of the rake.rb file.
+
+== 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 ...
+
+* Payton Quackenbush -- For several error handling improvements.
+
+* Glenn Vanderburg -- For finding and fixing the method name leak from
+  FileUtils.
+
+* Joel VanderWerf -- for finding and fixing a bug in the handling of
+  multiple prerequisites.
+
+* Tilman Sauerbeck -- For some enhancing FileList to support more
+  advanced file globbing.
+
+* Nobu Nakada -- For suggesting plain file name support to rule dependents.
+
+-- 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.7.1'
+RAKEVERSION = '0.7.2'
 
 require 'rbconfig'
 require 'ftools'
@@ -39,31 +39,41 @@ require 'singleton'
 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
-# that are not dupable.
+######################################################################
+# Rake extensions to Module.
+#
+class Module
 
-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
+  # Check for an existing method in the current class before
+  # extending.  IF the method already exists, then a warning is
+  # printed and the extension is not added.  Otherwise the block is
+  # yielded and any definitions in the block will take effect.
+  #
+  # Usage:
+  #
+  #   class String
+  #     rake_extension("xyz") do
+  #       def xyz
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  def rake_extension(method)
+    if instance_methods.include?(method)
+      $stderr.puts "WARNING: Possible conflict with Rake extension: #{self}##{method} already exists"
+    else
+      yield
+    end
   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"
+  rake_extension("ext") do
     # 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
@@ -73,14 +83,13 @@ class String
     def ext(newext='')
       return self.dup if ['.', '..'].include? self
       if newext != ''
- 	newext = (newext =~ /^\./) ? newext : ("." + newext)
+        newext = (newext =~ /^\./) ? newext : ("." + newext)
       end
       dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext
     end
   end
 
-
-  unless instance_methods.include? "pathmap" 
+  rake_extension("pathmap") do
     # Explode a path into individual components.  Used by +pathmap+.
     def pathmap_explode
       head, tail = File.split(self)
@@ -147,7 +156,7 @@ class String
     # * <b>%X</b> -- Everything *but* the file extension.
     # * <b>%s</b> -- The alternate file separater if defined,
     #   otherwise use the standard file separator.
-    # # <b>%%</b> -- A percent sign.
+    # * <b>%%</b> -- A percent sign.
     #
     # The %d specifier can also have a numeric prefix (e.g. '%2d').
     # If the number is positive, only return (up to) +n+ directories
@@ -218,6 +227,8 @@ class String
           result << self
         when '%s'
           result << (File::ALT_SEPARATOR || File::SEPARATOR)
+        when '%-'
+          # do nothing
         when '%%'
           result << "%"
         when /%(-?\d+)d/
@@ -271,7 +282,8 @@ module Rake
       sibling = self.class.new
       instance_variables.each do |ivar|
         value = self.instance_variable_get(ivar)
-        sibling.instance_variable_set(ivar, value.rake_dup)
+        new_value = value.clone rescue value
+        sibling.instance_variable_set(ivar, new_value)
       end
       sibling
     end
@@ -348,20 +360,20 @@ module Rake
     # Invoke the task if it is needed.  Prerequites are invoked first.
     def invoke
       @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?
+        if application.options.trace
+          puts "** Invoke #{name} #{format_trace_flags}"
+        end
+        return if @already_invoked
+        @already_invoked = true
+        invoke_prerequisites
+        execute if needed?
       end
     end
 
     # Invoke all the prerequisites of a task.
     def invoke_prerequisites
       @prerequisites.each { |n|
-	application[n, @scope].invoke
+        application[n, @scope].invoke
       }
     end
 
@@ -377,11 +389,11 @@ module Rake
     # Execute the actions associated with this task.
     def execute
       if application.options.dryrun
-	puts "** Execute (dry run) #{name}"
-	return
+        puts "** Execute (dry run) #{name}"
+        return
       end
       if application.options.trace
-	puts "** Execute #{name}"
+        puts "** Execute #{name}"
       end
       application.enhance_with_matching_rule(name) if @actions.empty?
       @actions.each { |act| result = act.call(self) }
@@ -395,7 +407,7 @@ module Rake
     # 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
+      @prerequisites.collect { |p| application[p].timestamp }.max || Time.now
     end
     
     # Add a comment to the task.  If a comment alread exists, separate
@@ -403,9 +415,9 @@ module Rake
     def add_comment(comment)
       return if ! comment
       if @comment 
-	@comment << " / "
+        @comment << " / "
       else
-	@comment = ''
+        @comment = ''
       end
       @comment << comment
     end
@@ -419,12 +431,12 @@ module Rake
       result <<  "task needed: #{needed?}\n"
       result <<  "timestamp: #{timestamp}\n"
       result << "pre-requisites: \n"
-      prereqs = @prerequisites.collect {|name| Rake::Task[name]}
+      prereqs = @prerequisites.collect {|name| application[name]}
       prereqs.sort! {|a,b| a.timestamp <=> b.timestamp}
       prereqs.each do |p|
-	result << "--#{p.name} (#{p.timestamp})\n"
+        result << "--#{p.name} (#{p.timestamp})\n"
       end
-      latest_prereq = @prerequisites.collect{|n| Rake::Task[n].timestamp}.max
+      latest_prereq = @prerequisites.collect{|n| application[n].timestamp}.max
       result <<  "latest-prerequisite time: #{latest_prereq}\n"
       result << "................................\n\n"
       return result
@@ -439,12 +451,12 @@ module Rake
       # the tasks that have been assigned.  (Normally used in the unit
       # tests.)
       def clear
-	Rake.application.clear
+        Rake.application.clear
       end
       
       # List of all defined tasks.
       def tasks
-	Rake.application.tasks
+        Rake.application.tasks
       end
       
       # Return a task with the given name.  If the task is not currently
@@ -452,31 +464,31 @@ 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)
-	Rake.application[task_name]
+        Rake.application[task_name]
       end
       
       # TRUE if the task name is already defined.
       def task_defined?(task_name)
-	Rake.application.lookup(task_name) != nil
+        Rake.application.lookup(task_name) != nil
       end
       
       # Define a task given +args+ and an option block.  If a rule with
       # the given name already exists, the prerequisites and actions are
       # added to the existing task.  Returns the defined task.
       def define_task(args, &block)
-	Rake.application.define_task(self, args, &block)
+        Rake.application.define_task(self, args, &block)
       end
       
       # Define a rule for synthesizing tasks.  
       def create_rule(args, &block)
-	Rake.application.create_rule(args, &block)
+        Rake.application.create_rule(args, &block)
       end
 
       # 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(':')
+        (scope + [task_name]).join(':')
       end
 
     end
@@ -502,9 +514,9 @@ module Rake
     # Time stamp for file task.
     def timestamp
       if File.exist?(name)
-	File.mtime(name.to_s)
+        File.mtime(name.to_s)
       else
-	Rake::EARLY
+        Rake::EARLY
       end
     end
 
@@ -513,7 +525,7 @@ module Rake
     # 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}
+      @prerequisites.any? { |n| application[n].timestamp > stamp}
     end
 
     # ----------------------------------------------------------------
@@ -524,7 +536,7 @@ module Rake
       # this kind of task.  File based tasks ignore the scope when
       # creating the name.
       def scope_name(scope, task_name)
-	task_name
+        task_name
       end
     end
   end
@@ -555,7 +567,7 @@ module Rake
   class MultiTask < Task
     def invoke_prerequisites
       threads = @prerequisites.collect { |p|
-	Thread.new(p) { |r| Task[r].invoke }
+        Thread.new(p) { |r| application[r].invoke }
       }
       threads.each { |t| t.join }
     end
@@ -710,11 +722,7 @@ module FileUtils
   #   end
   #
   def sh(*cmd, &block)
-    if Hash === cmd.last then
-      options = cmd.pop
-    else
-      options = {}
-    end
+    options = (Hash === cmd.last) ? cmd.pop : {}
     unless block_given?
       show_command = cmd.join(" ")
       show_command = show_command[0,42] + "..." if show_command.length > 45
@@ -722,10 +730,10 @@ module FileUtils
         ok or fail "Command failed with status (#{status.exitstatus}): [#{show_command}]"
       }
     end
-    fu_check_options options, :noop, :verbose
-    fu_output_message cmd.join(" ") if options[:verbose]
+    rake_check_options options, :noop, :verbose
+    rake_output_message cmd.join(" ") if options[:verbose]
     unless options[:noop]
-      res = system(*cmd)      
+      res = system(*cmd)
       block.call(res, $?)
     end
   end
@@ -736,11 +744,7 @@ module FileUtils
   #   ruby %{-pe '$_.upcase!' <README}
   #
   def ruby(*args,&block)
-    if Hash === args.last
-      options = args.pop
-    else
-      options = {}
-    end
+    options = (Hash === args.last) ? args.pop : {}
     if args.length > 1 then
       sh(*([RUBY] + args + [options]), &block)
     else
@@ -758,7 +762,7 @@ module FileUtils
     else
       begin
         ln(*args)
-      rescue StandardError, NotImplementedError
+      rescue StandardError, NotImplementedError => ex
         LN_SUPPORTED[0] = false
         cp(*args)
       end
@@ -807,9 +811,9 @@ module RakeFileUtils
     module_eval(<<-EOS, __FILE__, __LINE__ + 1)
     def #{name}( *args, &block )
       super(
-	*fu_merge_option(args,
-	  #{default_options.join(', ')}
-	  ), &block)
+        *rake_merge_option(args,
+          #{default_options.join(', ')}
+          ), &block)
     end
     EOS
   end
@@ -852,7 +856,7 @@ module RakeFileUtils
       begin
         yield
       ensure
-	RakeFileUtils.nowrite_flag = oldvalue
+        RakeFileUtils.nowrite_flag = oldvalue
       end
     end
     oldvalue
@@ -881,7 +885,7 @@ module RakeFileUtils
   end
 
   # Merge the given options with the default values.
-  def fu_merge_option(args, defaults)
+  def rake_merge_option(args, defaults)
     if Hash === args.last
       defaults.update(args.last)
       args.pop
@@ -889,10 +893,27 @@ module RakeFileUtils
     args.push defaults
     args
   end
-  private :fu_merge_option
+  private :rake_merge_option
+
+  # Send the message to the default rake output (which is $stderr).
+  def rake_output_message(message)
+    $stderr.puts(message)
+  end
+  private :rake_output_message
+
+  # Check that the options do not contain options not listed in
+  # +optdecl+.  An ArgumentError exception is thrown if non-declared
+  # options are found.
+  def rake_check_options(options, *optdecl)
+    h = options.dup
+    optdecl.each do |name|
+      h.delete name
+    end
+    raise ArgumentError, "no such option: #{h.keys.join(' ')}" unless h.empty?
+  end
+  private :rake_check_options
 
   extend self
-  
 end
 
 ######################################################################
@@ -902,6 +923,7 @@ end
 
 include RakeFileUtils
 private(*FileUtils.instance_methods(false))
+private(*RakeFileUtils.instance_methods(false))
 
 ######################################################################
 module Rake
@@ -1018,6 +1040,7 @@ module Rake
       @pending_add = []
       @pending = false
       @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+      @exclude_procs = DEFAULT_IGNORE_PROCS.dup
       @exclude_re = nil
       @items = []
       patterns.each { |pattern| include(pattern) }
@@ -1034,11 +1057,11 @@ module Rake
     def include(*filenames)
       # TODO: check for pending
       filenames.each do |fn|
-	if fn.respond_to? :to_ary
-	  include(*fn.to_ary)
-	else
-	  @pending_add << fn
-	end
+        if fn.respond_to? :to_ary
+          include(*fn.to_ary)
+        else
+          @pending_add << fn
+        end
       end
       @pending = true
       self
@@ -1047,7 +1070,9 @@ module Rake
     
     # Register a list of file name patterns that should be excluded
     # from the list.  Patterns may be regular expressions, glob
-    # patterns or regular strings.
+    # patterns or regular strings.  In addition, a block given to
+    # exclude will remove entries that return true when given to the 
+    # block.
     #
     # Note that glob patterns are expanded against the file system.
     # If a file is explicitly added to a file list, but does not exist
@@ -1064,12 +1089,14 @@ module Rake
     # If "a.c" is not a file, then ...
     #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
     #
-    def exclude(*patterns)
-      patterns.each do |pat| @exclude_patterns << pat end
-      if ! @pending
-        calculate_exclude_regexp
-        reject! { |fn| fn =~ @exclude_re }
+    def exclude(*patterns, &block)
+      patterns.each do |pat|
+        @exclude_patterns << pat 
       end
+      if block_given?
+        @exclude_procs << block
+      end        
+      resolve_exclude if ! @pending
       self
     end
 
@@ -1077,7 +1104,9 @@ module Rake
     # Clear all the exclude patterns so that we exclude nothing.
     def clear_exclude
       @exclude_patterns = []
+      @exclude_procs = []
       calculate_exclude_regexp if ! @pending
+      self
     end
 
     # Define equality.
@@ -1102,9 +1131,9 @@ module Rake
       result = @items * other
       case result
       when Array
-	FileList.new.import(result)
+        FileList.new.import(result)
       else
-	result
+        result
       end
     end
 
@@ -1125,7 +1154,7 @@ module Rake
         case pat
         when Regexp
           ignores << pat
-        when /[*.]/
+        when /[*?]/
           Dir[pat].each do |p| ignores << p end
         else
           ignores << Regexp.quote(pat)
@@ -1141,9 +1170,7 @@ module Rake
 
     def resolve_add(fn)
       case fn
-      when Array
-        fn.each { |f| self.resolve_add(f) }
-      when %r{[*?]}
+      when %r{[*?\[\{]}
         add_matching(fn)
       else
         self << fn
@@ -1152,17 +1179,8 @@ module Rake
     private :resolve_add
 
     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
-      end
+      calculate_exclude_regexp
+      reject! { |fn| exclude?(fn) }
       self
     end
     private :resolve_exclude
@@ -1227,25 +1245,25 @@ module Rake
     # 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
+        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:
+    def partition(&block)       # :nodoc:
       resolve
       result = @items.partition(&block)
       [
@@ -1271,15 +1289,17 @@ module Rake
     # Should the given file name be excluded?
     def exclude?(fn)
       calculate_exclude_regexp unless @exclude_re
-      fn =~ @exclude_re
+      fn =~ @exclude_re || @exclude_procs.any? { |p| p.call(fn) }
     end
 
     DEFAULT_IGNORE_PATTERNS = [
       /(^|[\/\\])CVS([\/\\]|$)/,
       /(^|[\/\\])\.svn([\/\\]|$)/,
       /\.bak$/,
-      /~$/,
-      /(^|[\/\\])core$/
+      /~$/
+    ]
+    DEFAULT_IGNORE_PROCS = [
+      proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
     ]
     @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
 
@@ -1326,9 +1346,9 @@ module Rake
     def each_dir_parent(dir)
       old_length = nil
       while dir != '.' && dir.length != old_length
-	yield(dir)
-	old_length = dir.length
-	dir = File.dirname(dir)
+        yield(dir)
+        old_length = dir.length
+        dir = File.dirname(dir)
       end
     end
   end
@@ -1398,6 +1418,11 @@ module Rake
     def [](name)
       @task_manager.lookup(name, @scope)
     end
+
+    # Return the list of tasks defined in this namespace.
+    def tasks
+      @task_manager.tasks
+    end
   end
 
 
@@ -1427,7 +1452,6 @@ module Rake
       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)
@@ -1444,9 +1468,9 @@ module Rake
     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}'"
+        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)
@@ -1458,14 +1482,14 @@ module Rake
     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
@@ -1476,12 +1500,12 @@ module Rake
     # 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)
-	  task = attempt_rule(task_name, extensions, block, level)
-	  return task if task
-	end
+        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
@@ -1509,13 +1533,13 @@ module Rake
       initial_scope ||= @scope
       task_name = task_name.to_s
       if task_name =~ /^rake:/
-	scopes = []
-	task_name = task_name.sub(/^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(/^(\^+)/, '')
+        scopes = initial_scope[0, initial_scope.size - $1.size]
+        task_name = task_name.sub(/^(\^+)/, '')
       else
-	scopes = initial_scope
+        scopes = initial_scope
       end
       lookup_in_scope(task_name, scopes)
     end
@@ -1524,10 +1548,10 @@ module Rake
     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
+        tn = (scope[0,n] + [name]).join(':')
+        task = @tasks[tn]
+        return task if task
+        n -= 1
       end
       nil
     end
@@ -1564,13 +1588,13 @@ module Rake
     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
+        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
@@ -1581,14 +1605,20 @@ module Rake
     # translation procs.
     def make_sources(task_name, extensions)
       extensions.collect { |ext|
-	case ext
-	when String
-	  task_name.sub(/\.[^.]*$/, ext)
-	when Proc
-	  ext.call(task_name)
-	else
-	  fail "Don't know how to handle rule dependent: #{ext.inspect}"
-	end
+        case ext
+        when /^%/
+          task_name.pathmap(ext)
+        when %r{/}
+          ext
+        when /^\./
+          task_name.ext(ext)
+        when String
+          ext
+        when Proc
+          ext.call(task_name)
+        else
+          fail "Don't know how to handle rule dependent: #{ext.inspect}"
+        end
       }.flatten
     end
     
@@ -1602,48 +1632,49 @@ module Rake
     include TaskManager
 
     # The original directory where rake was invoked.
-    attr_reader :original_dir
+    attr_reader :original_dir, :rakefile
 
-    RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb']
+    DEFAULT_RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb'].freeze
     
     OPTIONS = [
       ['--dry-run',  '-n', GetoptLong::NO_ARGUMENT,
-	"Do a dry run without executing actions."],
+        "Do a dry run without executing actions."],
       ['--help',     '-H', GetoptLong::NO_ARGUMENT,
-	"Display this help message."],
+        "Display this help message."],
       ['--libdir',   '-I', GetoptLong::REQUIRED_ARGUMENT,
-	"Include LIBDIR in the search path for required modules."],
+        "Include LIBDIR in the search path for required modules."],
       ['--rakelibdir', '-R', GetoptLong::REQUIRED_ARGUMENT,
-	"Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')"],
+        "Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')"],
       ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
-	"Do not search parent directories for the Rakefile."],
+        "Do not search parent directories for the Rakefile."],
       ['--prereqs',  '-P', GetoptLong::NO_ARGUMENT,
-	"Display the tasks and dependencies, then exit."],
+        "Display the tasks and dependencies, then exit."],
       ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
-	"Do not log messages to standard output."],
+        "Do not log messages to standard output."],
       ['--rakefile', '-f', GetoptLong::OPTIONAL_ARGUMENT,
-	"Use FILE as the rakefile."],
+        "Use FILE as the rakefile."],
       ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
-	"Require MODULE before executing rakefile."],
+        "Require MODULE before executing rakefile."],
       ['--silent',   '-s', GetoptLong::NO_ARGUMENT,
-	"Like --quiet, but also suppresses the 'in directory' announcement."],
+        "Like --quiet, but also suppresses the 'in directory' announcement."],
       ['--tasks',    '-T', GetoptLong::OPTIONAL_ARGUMENT,
-	"Display the tasks (matching optional PATTERN) with descriptions, then exit."],
+        "Display the tasks (matching optional PATTERN) with descriptions, then exit."],
       ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
-	"Turn on invoke/execute tracing, enable full backtrace."],
+        "Turn on invoke/execute tracing, enable full backtrace."],
       ['--usage',    '-h', GetoptLong::NO_ARGUMENT,
-	"Display usage."],
+        "Display usage."],
       ['--verbose',  '-v', GetoptLong::NO_ARGUMENT,
-	"Log message to standard output (default)."],
+        "Log message to standard output (default)."],
       ['--version',  '-V', GetoptLong::NO_ARGUMENT,
-	"Display the program version."],
+        "Display the program version."],
       ['--classic-namespace', '-C', GetoptLong::NO_ARGUMENT,
-	"Put Task and FileTask in the top level namespace"],
+        "Put Task and FileTask in the top level namespace"],
     ]
     
     # Create a Rake::Application object.
     def initialize
       super
+      @rakefiles = DEFAULT_RAKEFILES.dup
       @rakefile = nil
       @pending_imports = []
       @imported = []
@@ -1662,11 +1693,11 @@ module Rake
     # True if one of the files in RAKEFILES is in the current directory.
     # If a match is found, it is copied into @rakefile.
     def have_rakefile
-      RAKEFILES.each do |fn|
-	if File.exist?(fn) || fn == ''
-	  @rakefile = fn
-	  return true
-	end
+      @rakefiles.each do |fn|
+        if File.exist?(fn) || fn == ''
+          @rakefile = fn
+          return true
+        end
       end
       return false
     end
@@ -1683,34 +1714,32 @@ module Rake
       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
+        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
     
     # Display the tasks and dependencies.
     def display_tasks_and_comments
-      displayable_tasks = Rake::Task.tasks.select { |t|
-	t.comment && t.name =~ options.show_task_pattern
+      displayable_tasks = tasks.select { |t|
+        t.comment && t.name =~ options.show_task_pattern
       }
-      width = displayable_tasks.collect { |t|
-	t.name.length
-      }.max
+      width = displayable_tasks.collect { |t| t.name.length }.max
       displayable_tasks.each do |t|
-	printf "rake %-#{width}s  # %s\n", t.name, t.comment
+        printf "rake %-#{width}s  # %s\n", t.name, t.comment
       end
     end
     
     # Display the tasks and prerequisites
     def display_prerequisites
-      Rake::Task.tasks.each do |t|
-	puts "rake #{t.name}"
-	t.prerequisites.each { |pre| puts "    #{pre}" }
+      tasks.each do |t|
+        puts "rake #{t.name}"
+        t.prerequisites.each { |pre| puts "    #{pre}" }
       end
     end
     
@@ -1724,26 +1753,26 @@ module Rake
     def do_option(opt, value)
       case opt
       when '--dry-run'
-	verbose(true)
-	nowrite(true)
-	options.dryrun = true
-	options.trace = true
+        verbose(true)
+        nowrite(true)
+        options.dryrun = true
+        options.trace = true
       when '--help'
-	help
-	exit
+        help
+        exit
       when '--libdir'
-	$:.push(value)
+        $:.push(value)
       when '--nosearch'
-	options.nosearch = true
+        options.nosearch = true
       when '--prereqs'
-	options.show_prereqs = true
+        options.show_prereqs = true
       when '--quiet'
-	verbose(false)
+        verbose(false)
       when '--rakefile'
-	RAKEFILES.clear
-	RAKEFILES << value
+        @rakefiles.clear
+        @rakefiles << value
       when '--rakelibdir'
-	options.rakelib = value.split(':')
+        options.rakelib = value.split(':')
       when '--require'
         begin
           require value
@@ -1755,27 +1784,25 @@ module Rake
           end
         end
       when '--silent'
-	verbose(false)
-	options.silent = true
+        verbose(false)
+        options.silent = true
       when '--tasks'
-	options.show_tasks = true
-	options.show_task_pattern = Regexp.new(value || '.')
+        options.show_tasks = true
+        options.show_task_pattern = Regexp.new(value || '.')
       when '--trace'
-	options.trace = true
-	verbose(true)
+        options.trace = true
+        verbose(true)
       when '--usage'
-	usage
-	exit
+        usage
+        exit
       when '--verbose'
-	verbose(true)
+        verbose(true)
       when '--version'
-	puts "rake, version #{RAKEVERSION}"
-	exit
+        puts "rake, version #{RAKEVERSION}"
+        exit
       when '--classic-namespace'
-	require 'rake/classic_namespace'
-	options.classic_namespace = true
-      else
-	fail "Unknown option: #{opt}"
+        require 'rake/classic_namespace'
+        options.classic_namespace = true
       end
     end
     
@@ -1789,11 +1816,11 @@ module Rake
       # 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
+        $show_tasks = options.show_tasks
+        $show_prereqs = options.show_prereqs
+        $trace = options.trace
+        $dryrun = options.dryrun
+        $silent = options.silent
       end
     end
     
@@ -1817,32 +1844,32 @@ module Rake
     def load_rakefile
       here = Dir.pwd
       while ! have_rakefile
-	Dir.chdir("..")
-	if Dir.pwd == here || options.nosearch
-	  fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
-	end
-	here = Dir.pwd
+        Dir.chdir("..")
+        if Dir.pwd == here || options.nosearch
+          fail "No Rakefile found (looking for: #{@rakefiles.join(', ')})"
+        end
+        here = Dir.pwd
       end
       puts "(in #{Dir.pwd})" unless options.silent
       $rakefile = @rakefile
       load File.expand_path(@rakefile) if @rakefile != ''
       options.rakelib.each do |rlib|
-	Dir["#{rlib}/*.rake"].each do |name| add_import name end
+        Dir["#{rlib}/*.rake"].each do |name| add_import name end
       end
       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.
+    # given, 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
+        if arg =~ /^(\w+)=(.*)$/
+          ENV[$1] = $2
+        else
+          tasks << arg
+        end
       end
       tasks.push("default") if tasks.size == 0
       tasks
@@ -1856,12 +1883,14 @@ module Rake
     # 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
+        next if @imported.member?(fn)
+        if fn_task = lookup(fn)
+          fn_task.invoke
+        end
+        ext = File.extname(fn)
+        loader = @loaders[ext] || @default_loader
+        loader.load(fn)
+        @imported << fn
       end
     end
     
@@ -1876,45 +1905,49 @@ module Rake
     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}
+        $stderr.puts %{WARNING: Deprecated reference to top-level constant '#{const_name}'} +
+          %{found at: #{rakefile_location}} # '
+        $stderr.puts %{    Use --classic-namespace on rake command}
+        $stderr.puts %{    or 'require "rake/classic_namespace"' in Rakefile}
       end
       @const_warning = true
     end
 
     def rakefile_location
       begin
-	fail
+        fail
       rescue RuntimeError => ex
-	ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+        ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
       end
     end
 
     # Run the +rake+ application.
     def run
-      handle_options
       begin
-	tasks = collect_tasks
-	load_rakefile
-	if options.show_tasks
-	  display_tasks_and_comments
-	elsif options.show_prereqs
-	  display_prerequisites
-	else
-	  tasks.each { |task_name| Rake::Task[task_name].invoke }
-	end
+        handle_options
+        tasks = collect_tasks
+        load_rakefile
+        if options.show_tasks
+          display_tasks_and_comments
+        elsif options.show_prereqs
+          display_prerequisites
+        else
+          tasks.each { |task_name| self[task_name].invoke }
+        end
+      rescue SystemExit, GetoptLong::InvalidOption => ex
+        # Exit silently
+        exit(1)
       rescue Exception => ex
-	puts "rake aborted!"
-	puts ex.message
-	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)
+        # Exit with error message
+        $stderr.puts "rake aborted!"
+        $stderr.puts ex.message
+        if options.trace
+          $stderr.puts ex.backtrace.join("\n")
+        else
+          $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+          $stderr.puts "(See full trace by running task with --trace)"
+        end
+        exit(1)
       end    
     end
   end
@@ -1949,7 +1982,3 @@ class Module
     end
   end
 end
-
-if __FILE__ == $0 then
-  Rake::Application.new.run
-end