rant 0.4.4 → 0.4.6

data/lib/rant/import/sys/tgz.rb

@@ -0,0 +1,43 @@
+
+# tgz.rb - +sys+ methods for tgz archiving.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+#require 'rant/archive/minitar' #rant-import:uncomment
+
+module Rant
+    module Sys
+        # Unpack the gzipped tar archive, to which the +archive+ path
+        # points. Use the <tt>:in => "some/dir"</tt> option to specify
+        # a output directory. It defaults to the working directory.
+        def unpack_tgz(archive, opts={})
+            output_dir = opts[:to] || opts[:in] || "."
+            mkpath output_dir unless test ?d, output_dir
+            if Env.have_tar?
+                sh "tar", "-xzf", archive, "-C", output_dir
+            else
+                minitar_unpack(archive, output_dir)
+            end
+            nil
+        end
+        private
+        def minitar_tgz(fn, files, opts)
+            require 'zlib'
+            require 'rant/archive/minitar' #rant-import:remove
+            fu_output_message "minitar #{fn}"
+            files = files.to_ary if files.respond_to? :to_ary
+            tgz = Zlib::GzipWriter.new(File.open(fn, 'wb'))
+            # pack closes tgz
+            Rant::Archive::Minitar.pack(files, tgz, opts[:recurse])
+            nil
+        end
+        def minitar_unpack(archive, output_dir)
+            fu_output_message "unpacking #{archive} in #{output_dir}"
+            require 'zlib'
+            require 'rant/archive/minitar' #rant-import:remove
+            tgz = Zlib::GzipReader.new(File.open(archive, 'rb'))
+            # unpack closes tgz
+            Archive::Minitar.unpack(tgz, output_dir)
+        end
+    end # module Sys
+end # module Rant

data/lib/rant/import/sys/zip.rb

@@ -0,0 +1,42 @@
+
+# zip.rb - +sys+ methods for zip archiving.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+#require 'rant/archive/rubyzip' #rant-import:uncomment
+
+module Rant
+    module Sys
+        # Unpack the zip archive, to which the +archive+ path points.
+        # Use the <tt>:in => "some/dir"</tt> option to specify a
+        # output directory. It defaults to the working directory.
+        def unpack_zip(archive, opts={})
+            output_dir = opts[:to] || opts[:in] || "."
+            mkpath output_dir unless test ?d, output_dir
+            if Env.find_bin("unzip")
+                sh "unzip", "-q", archive, "-d", output_dir
+            else
+                rubyzip_unpack(archive, output_dir)
+            end
+            nil
+        end
+        private
+        def rubyzip_unpack(archive, output_dir)
+            fu_output_message "unpacking #{archive} in #{output_dir}"
+            require 'rant/archive/rubyzip' #rant-import:remove
+            f = Archive::Rubyzip::ZipFile.open archive
+            f.entries.each { |e|
+                fn = e.name
+                dir = File.dirname fn
+                if dir == "."
+                    dir = output_dir
+                elsif output_dir != "."
+                    dir = File.join(output_dir, dir)
+                end
+                FileUtils.mkpath dir unless test ?d, dir
+                f.extract(e, File.join(output_dir, fn))
+            }
+            f.close
+        end
+    end # module Sys
+end # module Rant

data/lib/rant/node.rb

@@ -37,9 +37,8 @@ module Rant
 	    @tasks = []
 	    @project_subdir = nil
 	end
-	def to_s
-	    @path
-	end
+        alias to_s path
+        alias to_str path
     end	# class Rantfile
 
     # Any +object+ is considered a _task_ if
@@ -76,15 +75,18 @@ module Rant
             @project_subdir = ""
 	end
 
-	# Returns the name of this task.
-	def to_s
-	    name
-	end
-
-        def to_rant_target
-            name
+        def reference_name
+            sd = rac.current_subdir
+            case sd
+            when "": full_name
+            when project_subdir: name
+            else "@#{full_name}".sub(/^@#{Regexp.escape sd}\//, '')
+            end
         end
 
+        alias to_s reference_name
+        alias to_rant_target name
+
 	# Basically project_subdir/name
 	#
 	# The Rant compiler (or application) references tasks by their
@@ -103,6 +105,10 @@ module Rant
 	    @rac.goto_project_dir project_subdir
 	end
 
+        def file_target?
+            false
+        end
+
 	def done?
 	    @done
 	end
@@ -149,17 +155,17 @@ module Rant
 	def each_target
 	end
 
+        private
 	def run
 	    return unless @block
 	    goto_task_home
+            @rac.running_task(self)
 	    @block.arity == 0 ? @block.call : @block[self]
 	end
-	private :run
 
 	def circular_dep
 	    rac.warn_msg "Circular dependency on task `#{full_name}'."
 	    false
 	end
-	private :circular_dep
     end	# module Node
-end
+end # module Rant

data/lib/rant/plugin/configure.rb

@@ -270,7 +270,7 @@ module Rant::Plugin
 	end
 
 	def write_yaml
-	    @app.msg 1, "Writing config to `#{@file}'."
+	    @app.vmsg 1, "Writing config to `#{@file}'."
 	    File.open(@file, "w") { |f|
 		f << data.to_yaml
 		f << "\n"

data/lib/rant/progress.rb

@@ -0,0 +1,33 @@
+
+# progress.rb - Simple progress bar features for Rant.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+    class ProgressCountdown
+        attr_reader :total, :current
+        def initialize(total, rant=nil)
+            @total = total
+            @step = @total / 10
+            @fraction = 10
+            @rant = rant
+            @current = 0
+        end
+        def inc
+            @current += 1
+            if @step > 0 and @current % @step == 0
+                @fraction -= 1
+                print_progress "#@fraction " if @fraction >= 0
+            end
+        end
+        private
+        def print_progress(text)
+            if @rant
+                @rant.cmd_print(text)
+            else
+                print text
+                $stdout.flush
+            end
+        end
+    end # class ProgressCountdown
+end # module Rant

data/lib/rant/rantenv.rb

@@ -111,18 +111,18 @@ module Rant::Console
     end
     def msg(*text)
         pre = msg_prefix
-        text = text.join("\n" + ' ' * pre.length)
-        $stderr.puts(pre + text)
+        $stderr.puts "#{pre}#{text.join("\n" + ' ' * pre.length)}"
+    end
+    def vmsg(importance, *text)
+        msg(*text) if verbose >= importance
     end
     def err_msg(*text)
         pre = msg_prefix + ERROR_PREFIX
-        text = text.join("\n" + ' ' * pre.length)
-        $stderr.puts(pre + text)
+        $stderr.puts "#{pre}#{text.join("\n" + ' ' * pre.length)}"
     end
     def warn_msg(*text)
         pre = msg_prefix + WARN_PREFIX
-        text = text.join("\n" + ' ' * pre.length)
-        $stderr.puts(pre + text)
+        $stderr.puts "#{pre}#{text.join("\n" + ' ' * pre.length)}"
     end
     def ask_yes_no text
         $stderr.print msg_prefix + text + " [y|n] "
@@ -152,7 +152,7 @@ module Rant::Console
 	    next unless desc	# "private" option
 	    optstr = ""
 	    arg = nil
-	    if mode == GetoptLong::REQUIRED_ARGUMENT
+	    if mode != GetoptLong::NO_ARGUMENT
 		if desc =~ /(\b[A-Z_]{2,}\b)/
 		    arg = $1
 		end

data/lib/rant/rantlib.rb

@@ -27,7 +27,7 @@ Rant::MAIN_OBJECT = self
 
 unless Process::Status.method_defined?(:success?) # new in 1.8.2
     class Process::Status
-        def success?;  exitstatus == 0; end
+        def success?; exitstatus == 0; end
     end
 end
 unless Regexp.respond_to? :union # new in 1.8.1
@@ -155,55 +155,63 @@ module RantContext
 
     # Define a basic task.
     def task(targ, &block)
-	rac.task(targ, &block)
+	rant.task(targ, &block)
     end
 
     # Define a file task.
     def file(targ, &block)
-	rac.file(targ, &block)
+	rant.file(targ, &block)
     end
 
     # Add code and/or prerequisites to existing task.
     def enhance(targ, &block)
-	rac.enhance(targ, &block)
+	rant.enhance(targ, &block)
     end
 
     def desc(*args)
-	rac.desc(*args)
+	rant.desc(*args)
     end
 
     def gen(*args, &block)
-	rac.gen(*args, &block)
+	rant.gen(*args, &block)
     end
 
     def import(*args, &block)
-	rac.import(*args, &block)
+	rant.import(*args, &block)
     end
 
     def plugin(*args, &block)
-	rac.plugin(*args, &block)
+	rant.plugin(*args, &block)
     end
 
     # Look in the subdirectories, given by args,
     # for rantfiles.
     def subdirs(*args)
-	rac.subdirs(*args)
+	rant.subdirs(*args)
     end
 
     def source(opt, rantfile = nil)
-	rac.source(opt, rantfile)
+	rant.source(opt, rantfile)
     end
 
     def sys(*args, &block)
-	rac.sys(*args)
+	rant.sys(*args, &block)
     end
 
     def var(*args, &block)
-	rac.var(*args, &block)
+	rant.var(*args, &block)
     end
 
     def make(*args, &block)
-        rac.make(*args, &block)
+        rant.make(*args, &block)
+    end
+
+    # +rac+ stands for "rant compiler"
+    def rac
+        ch = Rant::Lib.parse_caller_elem caller[0]
+        rant.warn_msg(@__rant__.pos_text(ch[:file], ch[:ln]),
+            "Method `rac' is deprecated. Use `rant' instead.")
+	rant
     end
 end	# module RantContext
 
@@ -211,12 +219,11 @@ class RantAppContext
     include RantContext
 
     def initialize(app)
-	@__rac__ = app
+	@__rant__ = app
     end
 
-    # +rac+ stands for "rant compiler"
-    def rac
-	@__rac__
+    def rant
+        @__rant__
     end
 
     def method_missing(sym, *args)
@@ -233,10 +240,6 @@ end
 
 module Rant
 
-    # In the class definition of Rant::RantApp, this will be set to a
-    # new application object.
-    @@rac = nil
-
     class << self
 
 	# Run a new rant application in the current working directory.
@@ -265,36 +268,32 @@ module Rant
 	def run(first_arg=nil, *other_args)
 	    other_args = other_args.flatten
 	    args = first_arg.nil? ? ARGV.dup : ([first_arg] + other_args)
-	    if @@rac && !@@rac.run?
-		@@rac.args.replace(args.flatten)
-		@@rac.run
+	    if rant && !rant.run?
+		rant.run(args.flatten)
 	    else
-		@@rac = Rant::RantApp.new
-		@@rac.run(args)
+                Rant::MAIN_OBJECT.instance_variable_set(
+                    :@__rant__, Rant::RantApp.new)
+		rant.run(args)
 	    end
 	end
 
-	def rac
-	    @@rac
-	end
-
-	def rac=(app)
-	    @@rac = app
+	def rant
+	    Rant::MAIN_OBJECT.instance_variable_get(:@__rant__)
 	end
     end
 
-end	# module Rant
+end # module Rant
 
 class Rant::RantApp
     include Rant::Console
 
     class AutoLoadNodeFactory
-        def initialize(rac)
-            @rac = rac
+        def initialize(rant)
+            @rant = rant
         end
         def method_missing(sym, *args, &block)
-            @rac.import "nodes/default"
-            @rac.node_factory.send(sym, *args, &block)
+            @rant.import "nodes/default"
+            @rant.node_factory.send(sym, *args, &block)
         end
     end
 
@@ -320,9 +319,13 @@ class Rant::RantApp
 	    "Print failed commands and their exit status."	],
 	[ "--directory","-C",	GetoptLong::REQUIRED_ARGUMENT,
 	    "Run rant in DIRECTORY."				],
+        [ "--cd-parent","-c",   GetoptLong::NO_ARGUMENT,
+            "Run rant in parent directory with Rantfile."       ],
+        [ "--look-up",  "-u",   GetoptLong::NO_ARGUMENT,
+            "Look in parent directories for root Rantfile."     ],
 	[ "--rantfile",	"-f",	GetoptLong::REQUIRED_ARGUMENT,
 	    "Process RANTFILE instead of standard rantfiles.\n" +
-	    "Multiple files may be specified with this option"	],
+	    "Multiple files may be specified with this option." ],
 	[ "--force-run","-a",	GetoptLong::REQUIRED_ARGUMENT,
 	    "Force rebuild of TARGET and all dependencies."     ],
 	[ "--tasks",	"-T",	GetoptLong::NO_ARGUMENT,
@@ -340,7 +343,7 @@ class Rant::RantApp
 
     # Reference project's root directory in task names by preceding
     # them with this character.
-    ROOT_DIR_ID = "#"
+    ROOT_DIR_ID = "@"
     ESCAPE_ID = "\\"
 
     # Arguments, usually those given on commandline.
@@ -374,6 +377,11 @@ class Rant::RantApp
     #
     # Note: Might change before 1.0
     attr_reader :resolve_hooks
+    # Root directory of project. Will be initialized to working
+    # directory in #initialize. This is always an absolute path
+    # beginning with a <tt>/</tt> and not ending in a slash (unless
+    # rootdir is <tt>/</tt>).
+    attr_reader :rootdir
 
     attr_accessor :node_factory
 
@@ -387,28 +395,26 @@ class Rant::RantApp
 	# Rantfiles will be loaded in the context of this object.
 	@context = RantAppContext.new(self)
 	@sys = ::Rant::SysObject.new(self)
-	Rant.rac ||= self
 	@rantfiles = []
 	@tasks = {}
 	@opts = {
-	    :verbose	=> 0,
-	    :quiet	=> false,
-	    :directory	=> "",
+	    :verbose        => 0,
+	    :quiet          => false,
 	}
+        @rootdir = Dir.pwd      # root directory of project
 	@arg_rantfiles = []	# rantfiles given in args
 	@arg_targets = []	# targets given in args
-	@force_targets = []
-	@run = false
-	@done = false
+	@force_targets = []     # targets given with -a option
+	@run = false            # run method was called at least once
+	@done = false           # run method was successful
 	@plugins = []
 	@var = Rant::RantVar::Space.new
 	@var.query :ignore, :AutoList, []
 	@imports = []
 
-	#@task_show = nil
 	@task_desc = nil
+        @last_build_subdir = ""
 
-	@orig_pwd = nil
 	@current_subdir = ""
 	@resolve_hooks = []
 
@@ -420,41 +426,17 @@ class Rant::RantApp
     end
 
     def []=(opt, val)
-	case opt
-	when :directory
-	    self.rootdir = val
-	else
-	    @opts[opt] = val
-	end
-    end
-
-    def rootdir
-	@opts[:directory]
-    end
-
-    def rootdir=(newdir)
-	if @run
-	    raise "rootdir of rant application can't " +
-		"be changed after calling `run'"
-	end
-	unless String === newdir
-	    raise "rootdir has to be a String"
-	end
-	@opts[:directory] = newdir.dup
+        @opts[opt] = val
     end
 
     ### support for subdirectories ###################################
-    def expand_project_path(path)
-	expand_path(@current_subdir, path)
-    end
     def expand_path(subdir, path)
 	case path
 	when nil:	subdir.dup
 	when "":	subdir.dup
-	when /^#/:	path.sub(/^#/, '')
-	when /^\\#/:	path.sub(/^\\/, '')
+	when /^@/:	path.sub(/^@/, '')
 	else
-	    #puts "epp: current_subdir: #@current_subdir"
+            path = path.sub(/^\\(?=@)/, '')
 	    if subdir.empty?
 		# we are in project's root directory
 		path
@@ -467,37 +449,42 @@ class Rant::RantApp
     # method ensures that the returned absolute path doesn't end in a
     # slash.
     def project_to_fs_path(path)
-	base = rootdir.empty? ? Dir.pwd : rootdir
-	sub = expand_project_path(path)
-	sub.empty? ? base : File.join(base, sub)
+	sub = expand_path(@current_subdir, path)
+	sub.empty? ? @rootdir : File.join(@rootdir, sub)
     end
     def goto(dir)
-	# TODO: optimize
-	p_dir = expand_project_path(dir)
-	base = rootdir.empty? ? Dir.pwd : rootdir
-	abs_path = p_dir.empty? ? base : File.join(base, p_dir)
-	@current_subdir = p_dir
+        goto_project_dir(expand_path(@current_subdir, dir))
+    end
+    # +dir+ is a path relative to +rootdir+. It has to be a "clean"
+    # path string, i.e. it mustn't start with <tt>./</tt>, contain any
+    # <tt>..</tt> parent reference and it mustn't have a trailing
+    # slash.
+    #
+    # To go to the root directory, dir has to be an empty string,
+    # which is the default value.
+    def goto_project_dir(dir='')
+        @current_subdir = dir
+        abs_path = @current_subdir.empty? ?
+            @rootdir : File.join(@rootdir, @current_subdir)
 	unless Dir.pwd == abs_path
-	    #puts "pwd: #{Dir.pwd}; abs_path: #{abs_path}"
-	    #puts "   current subdir: #@current_subdir"
 	    Dir.chdir abs_path
-	    msg 1, "in #{abs_path}"
-	    #STDERR.puts "rant: in #{p_dir}"
+	    vmsg 1, "in #{abs_path}"
 	end
     end
-    # +dir+ is a path relative to +rootdir+
-    def goto_project_dir(dir)
-	# TODO: optimize
-	goto "##{dir}"
-    end
-    # Execute the give block in project directory dir.
-    def in_project_dir(dir)
-	prev_subdir = @current_subdir
-	goto_project_dir(dir)
-	yield
+=begin
+    # Execute block in subdirectory context to subdir, relative to
+    # project root directory. Important: Does NOT change the process
+    # working directory. Not thread safe.
+    #
+    # For Rant internal use only!
+    def define_in_project_dir(dir)
+        old_subdir = @current_subdir
+        @current_subdir = dir
+        yield
     ensure
-	goto_project_dir(prev_subdir)
+        @current_subdir = old_subdir
     end
+=end
     ##################################################################
 
     def run?
@@ -508,27 +495,20 @@ class Rant::RantApp
 	@done
     end
 
+    # Run this Rant application with the given arguments. The process
+    # working directory after this method returns, will be the same as
+    # before invocation.
+    #
     # Returns 0 on success and 1 on failure.
     def run(*args)
 	@run = true
 	@args.concat(args.flatten)
 	# remind pwd
-	@orig_pwd = Dir.pwd
+	orig_pwd = @rootdir = Dir.pwd
 	# Process commandline.
 	process_args
-	# Set pwd.
-	opts_dir = @opts[:directory]
-	if !(opts_dir.empty? || opts_dir.nil?)
-	    opts_dir = File.expand_path(opts_dir)
-	    unless test(?d, opts_dir)
-		abort("No such directory - #{opts_dir}")
-	    end
-	    Dir.chdir(opts_dir) if opts_dir != @orig_pwd
-	    @opts[:directory] = opts_dir
-	else
-	    @opts[:directory] = @orig_pwd
-	end
-	# read rantfiles
+        Dir.chdir(@rootdir)
+	# read rantfiles, might change @rootdir and Dir.pwd
 	load_rantfiles
 
 	raise Rant::RantDoneException if @opts[:stop_after_load]
@@ -541,12 +521,10 @@ class Rant::RantApp
 	end
 	# run tasks
 	run_tasks
-	goto "#"
 	raise Rant::RantDoneException
     rescue Rant::RantDoneException
 	@done = true
 	# Notify plugins
-	goto "#"
 	@plugins.each { |plugin| plugin.rant_done }
 	return 0
     rescue Rant::RantAbortException
@@ -563,13 +541,13 @@ class Rant::RantApp
 	return 1
     ensure
 	# TODO: exception handling!
+        Dir.chdir @rootdir
         hooks = var._get("__at_return__")
         hooks.each { |hook| hook.call } if hooks
 	@plugins.each { |plugin| plugin.rant_plugin_stop }
 	@plugins.each { |plugin| plugin.rant_quit }
 	# restore pwd
-	Dir.pwd != @orig_pwd && Dir.chdir(@orig_pwd)
-	Rant.rac = self.class.new
+        Dir.chdir orig_pwd
     end
 
     ###### methods accessible through RantContext ####################
@@ -621,7 +599,7 @@ class Rant::RantApp
 	    unless @imports.include? arg
 		unless Rant::CODE_IMPORTS.include? arg
 		    begin
-			msg 2, "import #{arg}"
+			vmsg 2, "import #{arg}"
 			require "rant/import/#{arg}"
 		    rescue LoadError => e
 			abort_at(ch, "No such import - #{arg}")
@@ -673,7 +651,7 @@ class Rant::RantApp
 	plugin = pl_class.rant_plugin_new(self, ch, *args, &block)
 	# TODO: check for rant_plugin?
 	@plugins << plugin
-	msg 2, "Plugin `#{plugin.rant_plugin_name}' registered."
+	vmsg 2, "Plugin `#{plugin.rant_plugin_name}' registered."
 	plugin.rant_plugin_init
 	# return plugin instance
 	plugin
@@ -731,32 +709,41 @@ class Rant::RantApp
 	    loaded = false
 	    prev_subdir = @current_subdir
 	    begin
-		#puts "* subdir *",
-		#    "  rootdir:        #{rootdir}",
-		#    "  current subdir: #@current_subdir",
-		#    "  pwd:            #{Dir.pwd}",
-		#    "  arg:            #{arg}"
+                #puts "* subdir *",
+                #    "  rootdir:        #{rootdir}",
+                #    "  current subdir: #@current_subdir",
+                #    "  pwd:            #{Dir.pwd}",
+                #    "  arg:            #{arg}"
 		goto arg
-		rantfiles_in_dir.each { |f|
-		    loaded = true
-		    rf, is_new = rantfile_for_path(f)
+                if test(?f, Rant::SUB_RANTFILE)
+                    path = Rant::SUB_RANTFILE
+                else
+                    path = rantfile_in_dir
+                end
+                if path
+                    if defined? @initial_subdir and
+                            @initial_subdir == @current_subdir
+                        rf, is_new = rantfile_for_path(path, false)
+                        @rantfiles.unshift rf if is_new
+                    else
+                        rf, is_new = rantfile_for_path(path)
+                    end
 		    load_file rf if is_new
-		}
+                elsif !@opts[:no_warn_subdir]
+                    warn_msg(pos_text(ch[:file], ch[:ln]),
+                        "subdirs: No Rantfile in subdir `#{arg}'.")
+                end
 	    ensure
-		#puts "  going back to project dir: #{prev_subdir}"
+                #puts "  going back to project dir: #{prev_subdir}"
 		goto_project_dir prev_subdir
 	    end
-	    unless loaded || @opts[:no_warn_subdir]
-		warn_msg(pos_text(ch[:file], ch[:ln]),
-		    "subdirs: No Rantfile in subdir `#{arg}'.")
-	    end
 	}
     rescue SystemCallError => e
 	abort_at(ch, "subdirs: " + e.message)
     end
 
     def sys(*args, &block)
-	args.empty? ? @sys : @sys.sh(*args)
+	args.empty? ? @sys : @sys.sh(*args, &block)
     end
 
     # The [] and []= operators may be used to set/get values from this
@@ -807,26 +794,21 @@ class Rant::RantApp
 	end
 	prefix = "rant "
 	infix = "  # "
-	name_length = 0
-	tlist.each { |t|
-	    if t.full_name.length > name_length
-		name_length = t.full_name.length
-	    end
-	}
-	name_length < 7 && name_length = 7
+        name_length = (tlist.map{ |t| t.to_s.length } << 7).max
 	cmd_length = prefix.length + name_length
-	unless tlist.first.full_name == def_target
+	unless tlist.first.to_s == def_target
 	    defaults = list_task_names(
 		resolve(def_target)).join(', ')
 	    puts "#{prefix}#{' ' * name_length}#{infix}=> #{defaults}"
 	end
 	tlist.each { |t|
-	    print(prefix + t.full_name.ljust(name_length) + infix)
+	    print(prefix + t.to_s.ljust(name_length) + infix)
 	    dt = t.description.sub(/\s+$/, "")
 	    puts dt.sub(/\n/, "\n" + ' ' * cmd_length + infix + "  ")
 	}
 	true
     end
+
     def list_task_names(*tasks)
 	rsl = []
 	tasks.flatten.each { |t|
@@ -836,7 +818,10 @@ class Rant::RantApp
 		if t.prerequisites.empty?
 		    rsl << t
 		else
-		    rsl.concat(list_task_names(t.prerequisites))
+                    t.prerequisites.each { |pre|
+                        rsl.concat(list_task_names(
+                            resolve(pre, t.project_subdir)))
+                    }
 		end
 	    else
 		rsl << t
@@ -862,50 +847,31 @@ class Rant::RantApp
 	t << ": "
     end
 
-    def msg(*args)
-	verbose_level = args[0]
-	if verbose_level.is_a? Integer
-	    super(args[1..-1]) if verbose_level <= verbose
-	else
-	    super
-	end
-    end
-
     # Print a command message as would be done from a call to a
-    # Sys method.
+    # sys method.
     def cmd_msg(cmd)
 	puts cmd unless quiet?
     end
 
-    ###### public methods regarding plugins ##########################
-    # The preferred way for a plugin to report a warning.
-    def plugin_warn(*args)
-	warn_msg(*args)
-    end
-    # The preferred way for a plugin to report an error.
-    def plugin_err(*args)
-	err_msg(*args)
+    def cmd_print(text)
+        print text unless quiet?
+        $stdout.flush
     end
 
-    # Get the plugin with the given name or nil. Yields the plugin
-    # object if block given.
-    def plugin_named(name)
-	@plugins.each { |plugin|
-	    if plugin.rant_plugin_name == name
-		yield plugin if block_given?
-		return plugin
-	    end
-	}
-	nil
-    end
-    ##################################################################
-
     # All targets given on commandline, including those given
     # with the -a option. The list will be in processing order.
     def cmd_targets
 	@force_targets + @arg_targets
     end
 
+    def running_task(task)
+        if @current_subdir != @last_build_subdir
+            cmd_msg "(in #{@current_subdir.empty? ?
+                @rootdir : @current_subdir})"
+            @last_build_subdir = @current_subdir
+        end
+    end
+
     private
     def have_any_task?
         !@tasks.empty?
@@ -921,15 +887,16 @@ class Rant::RantApp
 	# run default task, if not given:
 	# run first defined task.
 	target_list = @force_targets + @arg_targets
-	# The target list is a list of strings, not Task objects!
+	# The target list is a list of strings, not node objects!
 	if target_list.empty?
 	    def_tasks = resolve "default"
 	    unless def_tasks.empty?
 		target_list << "default"
 	    else
 		@rantfiles.each { |f|
-		    unless f.tasks.empty?
-			target_list << f.tasks.first.full_name
+                    first = f.tasks.first
+		    if first
+                        target_list << first.reference_name
 			break
 		    end
 		}
@@ -938,17 +905,18 @@ class Rant::RantApp
 	target_list
     end
 
+    # If this method returns (i.e. no exception was risen),
+    # current_subdir is the same as before invocation.
     def run_tasks
 	# Now, run all specified tasks in all rantfiles,
 	# rantfiles in reverse order.
-	opt = {}
-	matching_tasks = 0
-	target_list.each do |target|
-	    goto "#"
+	target_list.each { |target|
+            # build ensures that current_subdir is the same before
+            # and after invocation
 	    if build(target) == 0
 		abort("Don't know how to make `#{target}'.")
 	    end
-	end
+        }
     end
 
     def make(target, *args, &block)
@@ -1026,7 +994,7 @@ class Rant::RantApp
 	when nil
 	    @resolve_hooks.each { |s|
 		# Note: will probably change to get more params
-		s = s[task_name]
+		s = s[task_name, rel_project_dir]
                 #if s
                 #    puts s.size
                 #    t = s.first
@@ -1053,7 +1021,7 @@ class Rant::RantApp
     end
     public :at_resolve
 
-    # block will be called before this rac returns from #run
+    # block will be called before this rant returns from #run
     # pwd will be the projects root directory
     def at_return(&block)
         hooks = var._get("__at_return__")
@@ -1083,79 +1051,107 @@ class Rant::RantApp
 	# some "rant code" could already have run!
 	# We run the default Rantfiles only if no tasks where
 	# already defined and no Rantfile was given in args.
-	new_rf = []
-	@arg_rantfiles.each { |rf|
-	    if test(?f, rf)
-		new_rf << rf
-	    else
-		abort("No such file: " + rf)
-	    end
-	}
-	if new_rf.empty? && !have_any_task?
-	    # no Rantfiles given in args, no tasks defined,
-	    # so let's look for the default files
-	    new_rf = rantfiles_in_dir
-	end
-	new_rf.map! { |path|
-	    rf, is_new = rantfile_for_path(path)
-	    if is_new
-		load_file rf
-	    end
-	    rf
-	}
-	if @rantfiles.empty?
-	    abort("No Rantfile in current directory (" + Dir.pwd + ")",
-		"looking for " + Rant::RANTFILES.join(", ") +
-		"; case matters!")
-	end
+        unless @arg_rantfiles.empty?
+            @arg_rantfiles.each { |fn|
+                if test(?f, fn)
+                    rf, is_new = rantfile_for_path(fn)
+                    load_file rf if is_new
+                else
+                    abort "No such file -- #{rf}"
+                end
+            }
+            return
+        end
+        return if have_any_task?
+        # look for standard Rantfile in working directory
+        fn = rantfile_in_dir
+        if @opts[:cd_parent]
+            # search for Rantfile in parent directories
+            old_root = @rootdir
+            until fn or @rootdir == "/"
+                @rootdir = File.dirname(@rootdir)
+                fn = rantfile_in_dir(@rootdir)
+            end
+            if @rootdir != old_root and fn
+                Dir.chdir @rootdir
+                cmd_msg "(in #@rootdir)" 
+            end
+        end
+        if fn
+            rf, is_new = rantfile_for_path(fn)
+            load_file rf if is_new
+            return
+        end
+        have_sub_rantfile = test(?f, Rant::SUB_RANTFILE)
+        if have_sub_rantfile || @opts[:look_up]
+            # search for "root" Rantfile in parent directories, treat
+            # current working directory as project subdirectory
+            cur_dir = Dir.pwd
+            until cur_dir == "/"
+                cur_dir = File.dirname(cur_dir)
+                Dir.chdir cur_dir
+                fn = rantfile_in_dir
+                if fn
+                    @initial_subdir = @rootdir.sub(
+                        /^#{Regexp.escape cur_dir}\//, '')
+                    # adjust rootdir
+                    @rootdir = cur_dir
+                    cmd_msg "(root is #@rootdir, in #@initial_subdir)"
+                    @last_build_subdir = @initial_subdir
+                    rf, is_new = rantfile_for_path(fn)
+                    load_file rf if is_new
+                    goto_project_dir @initial_subdir
+                    # ensure to read sub.rant in initial subdir even
+                    # if it wasn't mentioned with +subdirs+.
+                    if have_sub_rantfile
+                        rf, is_new = rantfile_for_path(
+                                Rant::SUB_RANTFILE, false)
+                        if is_new
+                            @rantfiles.unshift rf
+                            load_file rf
+                        end
+                    end
+                    break
+                end
+            end
+        end
+        if @rantfiles.empty?
+            abort("No Rantfile found, looking for:",
+                Rant::RANTFILES.join(", "))
+        end
     end
 
     # Returns the value of the last expression executed in +rantfile+.
     # +rantfile+ has to be an Rant::Rantfile instance.
     def load_file(rantfile)
-	msg 1, "source #{rantfile}"
-	rv = nil
-	begin
-	    path = rantfile.path
-	    rv = @context.instance_eval(File.read(path), path)
-	rescue NameError => e
-	    abort("Name error when loading `#{rantfile}':",
-	    e.message, e.backtrace)
-	rescue LoadError => e
-	    abort("Load error when loading `#{rantfile}':",
-	    e.message, e.backtrace)
-	rescue ScriptError => e
-	    abort("Script error when loading `#{rantfile}':",
-	    e.message, e.backtrace)
-	end
-	unless @rantfiles.include?(rantfile)
-	    @rantfiles << rantfile
-	end
-	rv
+	vmsg 1, "source #{rantfile}"
+	@context.instance_eval(File.read(rantfile), rantfile)
     end
     private :load_file
 
-    # Get all rantfiles in dir.
+    # Get path to Rantfile in +dir+ or nil if dir doesn't contain an
+    # Rantfile.
+    #
     # If dir is nil, look in current directory.
-    # Returns always an array with the pathes (not only the filenames)
-    # to the rantfiles.
-    def rantfiles_in_dir(dir=nil)
-	files = []
+    def rantfile_in_dir(dir=nil)
 	::Rant::RANTFILES.each { |rfn|
 	    path = dir ? File.join(dir, rfn) : rfn
-	    # We don't accept rantfiles with pathes that differ only
-	    # in case. This protects from loading the same file twice
-	    # on case insensitive file systems.
-	    unless files.find { |f| f.downcase == path.downcase }
-		files << path if test(?f, path)
-	    end
+            return path if test ?f, path
 	}
-	files
+	::Rant::DEPRECATED_RANTFILES.each { |rfn|
+	    path = dir ? File.join(dir, rfn) : rfn
+            if test ?f, path
+                warn_msg "filename deprecated -- #{path}",
+                    "please rename it to `Rantfile' or `root.rant'!"
+                return path
+            end
+	}
+        nil
     end
 
     def process_args
 	# WARNING: we currently have to fool getoptlong,
-	# by temporory changing ARGV!
+	# by temporary changing ARGV!
 	# This could cause problems (e.g. multithreading).
 	old_argv = ARGV.dup
 	ARGV.replace(@args.dup)
@@ -1171,9 +1167,7 @@ class Rant::RantApp
 		show_help
 		raise Rant::RantDoneException
 	    when "--directory"
-		# take care: we bypass the checks of self.rootdir=
-		# because @run is true
-		@opts[:directory] = value
+                @rootdir = File.expand_path(value)
 	    when "--rantfile"
 		@arg_rantfiles << value
 	    when "--force-run"
@@ -1192,7 +1186,7 @@ class Rant::RantApp
 	ARGV.replace(old_argv)
 	rem_args.each { |ra|
 	    if ra =~ /(^[^=]+)=([^=]+)$/
-		msg 2, "var: #$1=#$2"
+		vmsg 2, "var: #$1=#$2"
 		@var[$1] = $2
 	    else
 		@arg_targets << ra
@@ -1216,7 +1210,8 @@ class Rant::RantApp
 	file, is_new = rantfile_for_path(ch[:file])
 	nt = yield(name, pre, block)
 	nt.rantfile = file
-        nt.project_subdir = file.project_subdir
+        #nt.project_subdir = file.project_subdir
+        nt.project_subdir = @current_subdir
 	nt.line_number = ch[:ln]
 	nt.description = @task_desc
 	@task_desc = nil
@@ -1302,17 +1297,17 @@ class Rant::RantApp
     # and a boolean value as second. If the second is true,
     # the rantfile was created and added, otherwise the rantfile
     # already existed.
-    def rantfile_for_path(path)
+    def rantfile_for_path(path, register=true)
 	# all rantfiles have an absolute path as path attribute
 	abs_path = File.expand_path(path)
-	if @rantfiles.any? { |rf| rf.path == abs_path }
-	    file = @rantfiles.find { |rf| rf.path == abs_path }
+        file = @rantfiles.find { |rf| rf.path == abs_path }
+	if file
 	    [file, false]
 	else
 	    # create new Rantfile object
 	    file = Rant::Rantfile.new abs_path
 	    file.project_subdir = @current_subdir
-	    @rantfiles << file
+	    @rantfiles << file if register
 	    [file, true]
 	end
     end
@@ -1363,10 +1358,5 @@ class Rant::RantApp
 	err_msg msg unless msg.empty?
 	err_msg t_msg
     end
-
-    # Just ensure that Rant.rac holds an RantApp after loading
-    # this file. The code in initialize will register the new app with
-    # Rant.rac= if necessary.
-    self.new
-
 end	# class Rant::RantApp
+# this line prevents ruby 1.8.3 from segfaulting