rant 0.3.0 → 0.3.2

data/lib/rant/rantlib.rb

@@ -14,7 +14,7 @@ require 'rant/rantfile'
 require 'rant/rantsys'
 
 module Rant
-    VERSION	= '0.3.0'
+    VERSION	= '0.3.2'
 
     # Those are the filenames for rantfiles.
     # Case matters!
@@ -83,7 +83,7 @@ class Array
 end
 
 module Rant::Lib
-    
+
     # Parses one string (elem) as it occurs in the array
     # which is returned by caller.
     # E.g.:
@@ -317,9 +317,15 @@ class Rant::RantApp
 	# "private" options intended for debugging, testing and
 	# internal use. A private option is distuingished from others
 	# by having +nil+ as description!
+
 	[ "--stop-after-load",	GetoptLong::NO_ARGUMENT, nil	],
+	# Print caller to $stderr on abort.
+	[ "--trace-abort",	GetoptLong::NO_ARGUMENT, nil	],
     ]
 
+    ROOT_DIR_ID = "#"
+    ESCAPE_ID = "\\"
+
     # Arguments, usually those given on commandline.
     attr_reader :args
     # A list of all Rantfiles used by this app.
@@ -346,6 +352,8 @@ class Rant::RantApp
     # A list with of all imports (code loaded with +import+).
     attr_reader :imports
 
+    attr_reader :current_subdir
+
     def initialize *args
 	@args = args.flatten
 	# Rantfiles will be loaded in the context of this object.
@@ -371,14 +379,10 @@ class Rant::RantApp
 	@task_desc = nil
 
 	@orig_pwd = nil
+	@current_subdir = ""
 
     end
 
-    # Just ensure that Rant.rantapp holds an RantApp after loading
-    # this file. The code in initialize will register the new app with
-    # Rant.rantapp= if necessary.
-    self.new
-
     def [](opt)
 	@opts[opt]
     end
@@ -393,7 +397,8 @@ class Rant::RantApp
     end
 
     def rootdir
-	@opts[:directory].dup
+	od = @opts[:directory]
+	od ? od.dup : ""
     end
 
     def rootdir=(newdir)
@@ -402,9 +407,71 @@ class Rant::RantApp
 		"be changed after calling `run'"
 	end
 	@opts[:directory] = newdir.dup
-	rootdir	# return a dup of the new rootdir
     end
 
+    ### experimental support for subdirectories ######################
+    def expand_project_path(path)
+	expand_path(@current_subdir, path)
+=begin
+	case path
+	when nil:	@current_subdir.dup
+	when "":	@current_subdir.dup
+	when /^#/:	path.sub(/^#/, '')
+	when /^\\#/:	path.sub(/^\\/, '')
+	else
+	    #puts "epp: current_subdir: #@current_subdir"
+	    if @current_subdir.empty?
+		# we are in project's root directory
+		path
+	    else
+		File.join(@current_subdir, path)
+	    end
+	end
+=end
+    end
+    def expand_path(subdir, path)
+	case path
+	when nil:	subdir.dup
+	when "":	subdir.dup
+	when /^#/:	path.sub(/^#/, '')
+	when /^\\#/:	path.sub(/^\\/, '')
+	else
+	    #puts "epp: current_subdir: #@current_subdir"
+	    if subdir.empty?
+		# we are in project's root directory
+		path
+	    else
+		File.join(subdir, path)
+	    end
+	end
+    end
+    # Returns an absolute path. If path resolves to a directory this
+    # 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)
+    end
+    def goto(dir)
+	# TODO: optimize
+	p_dir = expand_project_path(dir)
+	abs_path = project_to_fs_path(dir)
+	@current_subdir = p_dir
+	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}"
+	end
+    end
+    def goto_project_dir(dir)
+	# TODO: optimize
+	goto "##{dir}"
+    end
+    ##################################################################
+
     def ran?
 	@ran
     end
@@ -423,10 +490,12 @@ class Rant::RantApp
 	# Set pwd.
 	opts_dir = @opts[:directory]
 	if opts_dir
+	    opts_dir = File.expand_path(opts_dir)
 	    unless test(?d, opts_dir)
 		abort("No such directory - #{opts_dir}")
 	    end
-	    opts_dir != @orig_pwd && Dir.chdir(opts_dir)
+	    Dir.chdir(opts_dir) if opts_dir != @orig_pwd
+	    @opts[:directory] = opts_dir
 	else
 	    @opts[:directory] = @orig_pwd
 	end
@@ -594,8 +663,14 @@ class Rant::RantApp
     # and a new file task.
     def enhance targ, &block
 	prepare_task(targ, block) { |name,pre,blk|
-	    t = select_task { |t| t.name == name }
+	    t = @tasks[name]
+	    if Rant::MetaTask === t
+		t = t.last
+	    end
 	    if t
+		unless t.respond_to? :enhance
+		    abort("Can't enhance task `#{name}'")
+		end
 		t.enhance(pre, &blk)
 		return t
 	    end
@@ -622,9 +697,9 @@ class Rant::RantApp
 	ln = cinf[:ln] || 0
 	file = cinf[:file]
 	args.each { |arg|
-	    if arg.is_a? Symbol
-		arg = arg.to_s
-	    elsif arg.respond_to? :to_str
+	    #if arg.is_a? Symbol
+	    #	arg = arg.to_s
+	    if arg.respond_to? :to_str
 		arg = arg.to_str
 	    end
 	    unless arg.is_a? String
@@ -632,13 +707,25 @@ class Rant::RantApp
 		    "in `subdirs' command: arguments must be strings")
 	    end
 	    loaded = false
-	    rantfiles_in_dir(arg).each { |f|
-		loaded = true
-		rf, is_new = rantfile_for_path(f)
-		if is_new
-		    load_file rf
-		end
-	    }
+	    prev_subdir = @current_subdir
+	    begin
+		#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 is_new
+			load_file rf
+		    end
+		}
+	    ensure
+		#puts "  going back to project dir: #{prev_subdir}"
+		goto_project_dir prev_subdir
+	    end
 	    unless loaded || quiet?
 		warn_msg(pos_text(file, ln) + "; in `subdirs' command:",
 		    "No Rantfile in subdir `#{arg}'.")
@@ -649,7 +736,7 @@ class Rant::RantApp
 	    "in `subdirs' command: " + e.message)
     end
 
-    def sys *args
+    def sys(*args)
 	if args.empty?
 	    @sys
 	else
@@ -665,9 +752,10 @@ class Rant::RantApp
 	td
     end
 
-    # Prints msg as error message and throws a RantAbortException.
+    # Prints msg as error message and raises a RantAbortException.
     def abort *msg
 	err_msg(msg) unless msg.empty?
+	$stderr.puts caller if @opts[:trace_abort]
 	raise Rant::RantAbortException
     end
 
@@ -709,6 +797,8 @@ class Rant::RantApp
 	@opts[:quiet] = false
     end
     
+    # This is actually an integer indicating the verbosity level.
+    # Usual values range from 0 to 3.
     def verbose
 	@opts[:verbose]
     end
@@ -812,7 +902,9 @@ class Rant::RantApp
 		opt[:force] = true
 		@force_targets.delete(target)
 	    end
-	    (select_tasks { |t| t.name == target }).each { |t|
+	    ### pre 0.3.1 ###
+	    #(select_tasks { |t| t.name == target }).each { |t|
+	    select_tasks_by_name(target).each { |t|
 		matching_tasks += 1
 		begin
 		    t.invoke(opt)
@@ -845,8 +937,10 @@ class Rant::RantApp
 
     # Returns an array (might be a MetaTask) with all tasks that have
     # the given name.
-    def select_tasks_by_name name
-	s = @tasks[name]
+    def select_tasks_by_name name, project_dir = @current_subdir
+	# pre 0.3.1
+	#s = @tasks[name]
+	s = @tasks[expand_path(project_dir, name)]
 	case s
 	when nil: []
 	when Rant::Worker: [s]
@@ -969,6 +1063,8 @@ class Rant::RantApp
 		@opts[:targets] = true
 	    when "--stop-after-load"
 		@opts[:stop_after_load] = true
+	    when "--trace-abort"
+		@opts[:trace_abort] = true
 	    end
 	}
     rescue GetoptLong::Error => e
@@ -986,7 +1082,9 @@ class Rant::RantApp
 	}
     end
 
+    # Every task has to be registered with this method.
     def prepare_task(targ, block, clr = caller[2])
+	#STDERR.puts "prepare task (#@current_subdir):\n  #{targ.inspect}"
 
 	# Allow override of caller, usefull for plugins and libraries
 	# that define tasks.
@@ -1018,7 +1116,8 @@ class Rant::RantApp
     public :prepare_task
 
     def hash_task task
-	n = task.name
+	n = task.full_name
+	#STDERR.puts "hash_task: `#{n}'"
 	et = @tasks[n]
 	case et
 	when nil
@@ -1109,10 +1208,17 @@ class Rant::RantApp
 	    file = @rantfiles.find { |rf| rf.absolute_path == abs_path }
 	    [file, false]
 	else
+	    # create new Rantfile object
 	    file = Rant::Rantfile.new(abs_path, abs_path)
+	    file.project_subdir = @current_subdir
 	    @rantfiles << file
 	    [file, true]
 	end
     end
 
+    # Just ensure that Rant.rantapp holds an RantApp after loading
+    # this file. The code in initialize will register the new app with
+    # Rant.rantapp= if necessary.
+    self.new
+
 end	# class Rant::RantApp

data/lib/rant/rantsys.rb

@@ -4,39 +4,170 @@ require 'rant/rantenv'
 
 module Rant
 
-    class FileList < Array
+    class Glob < String
+	class << self
+	    # A synonym for +new+.
+	    def [](pattern)
+		new(pattern)
+	    end
+	end
+    end
+
+    class FileList
+	include Enumerable
 
-	attr_reader :pattern
+	ESC_SEPARATOR = Regexp.escape(File::SEPARATOR)
+	ESC_ALT_SEPARATOR = File::ALT_SEPARATOR ?
+	    Regexp.escape(File::ALT_SEPARATOR) : nil
+
+	# Flags for the File::fnmatch method.
+	# Initialized to 0.
+	attr_accessor :glob_flags
 
 	class << self
-	    def [] pattern
-		new(pattern).no_suffix("~").no_suffix(".bak")
+	    def [](*patterns)
+		new(*patterns)
 	    end
 	end
 
-	def initialize(pattern, flags = 0)
-	    super(Dir.glob(pattern, flags))
-	    @actions = []
+	def initialize(*patterns)
+	    @glob_flags = 0
+	    @files = []
+	    @actions = patterns.map { |pat| [:apply_include, pat] }
+	    @pending = true
+	    yield self if block_given?
+	end
+
+	protected
+	attr_reader :actions, :files
+	attr_accessor :pending
+
+	public
+	### Methods having an equivalent in the Array class. #########
+
+	def each &block
+	    resolve if @pending
+	    @files.each(&block)
+	end
+
+	def to_ary
+	    resolve if @pending
+	    @files
+	end
+
+	def to_a
+	    to_ary
 	end
 
 	def +(other)
-	    fl = self.dup
-	    fl.concat(other.to_ary)
-	    fl
-	end
-
-	# Reevaluate pattern. Replay all modifications
-	# if replay is given.
-	def update(replay = true)
-	    self.replace(Dir[pattern])
-	    if replay
-		@actions.each { |action|
-		    self.send(*action)
-		}
+	    case other
+	    when Array
+		dup.files.concat(other)
+	    when self.class
+		c = other.dup
+		c.actions.concat(@actions)
+		c.files.concat(@files)
+		c.pending = !c.actions.empty?
+		c
+	    else
+		raise "argument has to be an Array or FileList"
+	    end
+	end
+
+	def <<(file)
+	    @files << file
+	    self
+	end
+
+	def size
+	    resolve if @pending
+	    @files.size
+	end
+
+	def method_missing(sym, *args, &block)
+	    if @files.respond_to? sym
+		resolve if @pending
+		@files.send(sym, *args, &block)
+	    else
+		super
 	    end
+	end
+	##############################################################
+
+	def resolve
+	    @pending = false
+	    @actions.each { |action|
+		self.send(*action)
+	    }
 	    @actions.clear
 	end
 
+	def include(*patterns)
+	    patterns.each { |pat|
+		@actions << [:apply_include, pat]
+	    }
+	    @pending = true
+	    self
+	end
+	alias glob include
+
+	def apply_include(pattern)
+	    @files.concat Dir.glob(pattern, @glob_flags)
+	end
+	private :apply_include
+
+	def exclude(*patterns)
+	    patterns.each { |pat|
+		if Regexp === pat
+		    @actions << [:apply_exclude_rx, pat]
+		else
+		    @actions << [:apply_exclude, pat]
+		end
+	    }
+	    @pending = true
+	    self
+	end
+
+	def apply_exclude(pattern)
+	    @files.reject! { |elem|
+		File.fnmatch? pattern, elem, @glob_flags
+	    }
+	end
+	private :apply_exclude
+
+	def apply_exclude_rx(rx)
+	    @files.reject! { |elem|
+		elem =~ rx
+	    }
+	end
+	private :apply_exclude_rx
+
+	def exclude_all(*files)
+	    files.each { |file|
+		@actions << [:apply_exclude_rx, mk_all_rx(file)]
+	    }
+	    @pending = true
+	    self
+	end
+	alias shun exclude_all
+
+	if File::ALT_SEPARATOR
+	    # TODO: check for FS case sensitivity?
+	    def mk_all_rx(file)
+
+		/(^|(#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+)
+		    #{Regexp.escape(file)}
+		    ((#{ESC_SEPARATOR}|#{ESC_ALT_SEPARATOR})+|$)/x
+	    end
+	else
+	    def mk_all_rx(file)
+		/(^|#{ESC_SEPARATOR}+)
+		    #{Regexp.escape(file)}
+		    (#{ESC_SEPARATOR}+|$)/x
+	    end
+	end
+	private :mk_all_rx
+
 	# Remove all entries which contain a directory with the
 	# given name.
 	# If no argument or +nil+ given, remove all directories.
@@ -48,16 +179,21 @@ module Rant
 	#       src/CVS/lib.c
 	#       CVS/foo/bar/
 	def no_dir(name = nil)
-	    @actions << [:no_dir, name]
+	    @actions << [:apply_no_dir, name]
+	    @pending = true
+	    self
+	end
+
+	def apply_no_dir(name)
 	    entry = nil
 	    unless name
-		self.reject! { |entry|
+		@files.reject! { |entry|
 		    test(?d, entry)
 		}
-		return self
+		return
 	    end
 	    elems = nil
-	    self.reject! { |entry|
+	    @files.reject! { |entry|
 		elems = Sys.split_path(entry)
 		i = elems.index(name)
 		if i
@@ -67,45 +203,61 @@ module Rant
 		    false
 		end
 	    }
-	    self
 	end
+	private :apply_no_dir
 
 	# Remove all files which have the given name.
 	def no_file(name)
-	    @actions << [:no_file, name]
-	    self.reject! { |entry|
+	    @actions << [:apply_no_file, name]
+	    @pending = true
+	    self
+	end
+
+	def apply_no_file(name)
+	    @files.reject! { |entry|
 		entry == name and test(?f, entry)
 	    }
-	    self
 	end
+	private :apply_no_file
 
 	# Remove all entries which contain an element
 	# with the given suffix.
 	def no_suffix(suffix)
 	    @actions << [:no_suffix, suffix]
-	    elems = elem = nil
-	    self.reject! { |entry|
+	    @pending = true
+	    self
+	end
+
+	def apply_no_suffix(suffix)
+	    elems =  nil
+	    elem = nil
+	    @files.reject! { |entry|
 		elems = Sys.split_path(entry)
 		elems.any? { |elem|
 		    elem =~ /#{suffix}$/
 		}
 	    }
-	    self
 	end
+	private :apply_no_suffix
 
 	# Remove all entries which contain an element
 	# with the given prefix.
 	def no_prefix(prefix)
 	    @actions << [:no_prefix, prefix]
+	    @pending = true
+	    self
+	end
+
+	def apply_no_prefix(prefix)
 	    elems = elem = nil
-	    self.reject! { |entry|
+	    @files.reject! { |entry|
 		elems = Sys.split_path(entry)
 		elems.any? { |elem|
 		    elem =~ /^#{prefix}/
 		}
 	    }
-	    self
 	end
+	private :apply_no_prefix
 
 	# Get a string with all entries. This is very usefull
 	# if you invoke a shell:
@@ -115,6 +267,9 @@ module Rant
 	#	rdoc foo\bar "with space"
 	# on other systems:
 	#	rdoc foo/bar 'with space'
+	def arglist
+	    to_ary.arglist
+	end
 =begin
 	def arglist
 	    self.list.join(' ')
@@ -141,6 +296,7 @@ module Rant
 	    end
 	end
 =end
+
     end	# class FileList
 
     class CommandError < StandardError
@@ -182,26 +338,25 @@ module Rant
 	# We override the output method of the FileUtils module to
 	# allow the Rant application to control output.
 	def fu_output_message(msg)	#:nodoc:
-	    ::Rant.rantapp.cmd_msg msg
+	    ::Rant.rantapp.cmd_msg msg if ::Rant.rantapp
 	end
 
 	def sh(*cmd_args, &block)
 	    cmd_args.flatten!
 	    cmd = cmd_args.join(" ")
-	    unless block_given?
-		block = lambda { |succ, status|
-		    succ or raise CommandError.new(cmd, status)
-		}
-	    end
 	    fu_output_message cmd
-	    block.call(system(*cmd_args), $?)
+	    if block_given?
+		block[system(*cmd_args), $?]
+	    else
+		system(*cmd_args) or raise CommandError.new(cmd, $?)
+	    end
 	end
 
 	def ruby(*args, &block)
 	    if args.size > 1
-		sh(*([Env::RUBY] + args), &block)
+		sh([Env::RUBY] + args, &block)
 	    else
-		sh(Env::RUBY + ' ' + args.join(' '), &block)
+		sh("#{Env::RUBY} #{args.first}", &block)
 	    end
 	end