rant 0.3.6 → 0.3.8

data/lib/rant/rantfile.rb

@@ -24,31 +24,34 @@ module Rant
 	end
     end
 
-    class Rantfile < Path
+    class Rantfile
 
-	attr_reader :tasks
+	attr_reader :tasks, :path
 	attr_accessor :project_subdir
 	
-	def initialize(*args)
-	    super
+	def initialize(path)
+	    @path = path or raise ArgumentError, "path required"
 	    @tasks = []
 	    @project_subdir = nil
 	end
+	def to_s
+	    @path
+	end
     end	# class Rantfile
 
     # Any +object+ is considered a _task_ if
-    # <tt>Rant::Worker === object</tt> is true.
+    # <tt>Rant::Node === object</tt> is true.
     #
     # Most important classes including this module are the Rant::Task
     # class and the Rant::FileTask class.
-    module Worker
+    module Node
 
 	INVOKE_OPT = {}.freeze
 
 	# Name of the task, this is always a string.
 	attr_reader :name
-	# A reference to the application this task belongs to.
-	attr_reader :app
+	# A reference to the Rant compiler this task belongs to.
+	attr_reader :rac
 	# Description for this task.
 	attr_accessor :description
 	# The rantfile this task was defined in.
@@ -90,7 +93,7 @@ module Rant
 	# Important for subclasses: Call this method always before
 	# invoking code from Rantfiles (e.g. task action blocks).
 	def goto_task_home
-	    @app.goto_project_dir project_subdir
+	    @rac.goto_project_dir project_subdir
 	end
 
 	def done?
@@ -107,11 +110,11 @@ module Rant
 	end
 
 	# +opt+ is a Hash and shouldn't be modified.
-	# All objects implementing the Rant::Worker protocol should
+	# All objects implementing the Rant::Node protocol should
 	# know about the following +opt+ values:
 	# <tt>:needed?</tt>::
 	#	Just check if this task is needed.  Should do the same
-	#	as calling Worker#needed?
+	#	as calling Node#needed?
 	# <tt>:force</tt>::
 	#	Run task action even if needed? is false.
 	# Returns true if task action was run.
@@ -147,7 +150,7 @@ module Rant
 	private :run
 
 	def circular_dep
-	    app.warn_msg "Circular dependency on task `#{full_name}'."
+	    rac.warn_msg "Circular dependency on task `#{full_name}'."
 	    false
 	end
 	private :circular_dep
@@ -158,121 +161,40 @@ module Rant
 	end
 
 	def eql? other
-	    Worker === other and full_name.eql? other.full_name
-	end
-    end	# module Worker
-
-    # A list of tasks with an equal full_name.
-    class MetaTask < Array
-	include Worker
-
-	class << self
-	    def for_task t
-		mt = self.new(t.full_name)
-		mt << t
-	    end
-	    def for_tasks *tasks
-		mt = self.new(tasks.first.full_name)
-		mt.concat tasks
-		mt
-	    end
-	    def for_task_list tasks
-		mt = self.new(tasks.first.full_name)
-		mt.concat tasks
-		mt
-	    end
+	    Node === other and full_name.eql? other.full_name
 	end
-
-	def initialize(name)
-	    super()
-	    @name = name or raise ArgumentError, "no name given"
-	end
-
-	def done?
-	    all? { |t| t.done? }
-	end
-
-	def needed?
-	    any? { |t| t.needed? }
-	end
-
-	def invoke(opt = INVOKE_OPT)
-	    uf = false
-	    each { |t| t.invoke(opt) && uf = true }
-	    uf
-	end
-
-	def description
-	    nil
-	end
-	
-	def description=(val)
-	    # spit out a warning?
-	end
-
-	def rantfile
-	    nil
-	end
-	
-	def rantfile=(val)
-	    # spit out a warning?
-	end
-
-	def line_number
-	    0
-	end
-
-	def line_number=(val)
-	    # spit out a warning?
-	end
-
-	def app
-	    empty? ? nil : first.app
-	end
-
-	def each_target &block
-	    self.each { |t| t.each_target &block }
-	end
-    end	# class MetaTask
+    end	# module Node
 
     # A very lightweight task for special purposes.
     class LightTask
-	include Worker
+	include Node
 
 	class << self
-	    def rant_generate(app, ch, args, &block)
+	    def rant_generate(rac, ch, args, &block)
 		unless args.size == 1
-		    app.abort("LightTask takes only one argument " +
+		    rac.abort("LightTask takes only one argument " +
 			"which has to be the taskname (string or symbol)")
 		end
-		app.prepare_task({args.first => [], :__caller__ => ch},
+		rac.prepare_task({args.first => [], :__caller__ => ch},
 			block) { |name,pre,blk|
 		    # TODO: ensure pre is empty
-		    # TODO: earlier setting of app?
-		    self.new(app, name, &blk)
+		    self.new(rac, name, &blk)
 		}
 	    end
 	end
 
-	def initialize(app, name)
+	def initialize(rac, name)
 	    super()
-	    @app = app or raise ArgumentError, "no app given"
-	    @name = case name
-	    when String: name
-	    when Symbol: name.to_s
-	    else
-		raise ArgumentError,
-		    "invalid name argument: #{name.inspect}"
-	    end
+	    @rac = rac or raise ArgumentError, "no rac given"
+	    @name = name
 	    @needed = nil
 	    @block = nil
 	    @done = false
-
 	    yield self if block_given?
 	end
 
-	def app
-	    @app
+	def rac
+	    @rac
 	end
 
 	def needed &block
@@ -297,19 +219,12 @@ module Rant
 		return needed? if opt[:needed?]
 		# +run+ already calls +goto_task_home+
 		#goto_task_home
-		if opt[:force] && !@done
-		    self.run
+		if opt[:force] && !@done or needed?
+		    run
 		    @done = true
-		else
-		    if needed?
-			run
-			@done = true
-		    else
-			false
-		    end
 		end
 	    rescue CommandError => e
-		err_msg e.message if app[:err_commands]
+		err_msg e.message if rac[:err_commands]
 		self.fail(nil, e)
 	    rescue SystemCallError => e
 		err_msg e.message
@@ -321,25 +236,25 @@ module Rant
     end	# LightTask
 
     class Task
-	include Worker
+	include Node
 	include Console
 
 	T0 = Time.at(0).freeze
 
 	class << self
-	    def rant_generate(app, ch, args, &block)
+	    def rant_generate(rac, ch, args, &block)
 		if args.size == 1
-		    UserTask.rant_generate(app, ch, args, &block)
+		    UserTask.rant_generate(rac, ch, args, &block)
 		else
-		    app.abort("Task generator currently takes only one" +
+		    rac.abort("Task generator currently takes only one" +
 			" argument. (generates a UserTask)")
 		end
 	    end
 	end
 
-	def initialize(app, name, prerequisites = [], &block)
+	def initialize(rac, name, prerequisites = [], &block)
 	    super()
-	    @app = app || Rant.rac
+	    @rac = rac || Rant.rac
 	    @name = name or raise ArgumentError, "name not given"
 	    @pre = prerequisites || []
 	    @pre_resolved = false
@@ -435,12 +350,12 @@ module Rant
 	    dep = nil
 	    uf = false
 	    each_dep { |dep|
-		if FileTask === dep
-		    handle_filetask(dep, opt) && update = true
-		elsif Worker === dep
-		    handle_worker(dep, opt) && update = true
+		if dep.respond_to? :timestamp
+		    handle_timestamped(dep, opt) && update = true
+		elsif Node === dep
+		    handle_node(dep, opt) && update = true
 		else
-		    dep, uf = handle_non_worker(dep, opt)
+		    dep, uf = handle_non_node(dep, opt)
 		    uf && update = true
 		    dep
 		end
@@ -458,25 +373,25 @@ module Rant
 	private :internal_invoke
 
 	# Called from internal_invoke. +dep+ is a prerequisite which
-	# is_a? Worker, but not a FileTask. +opt+ are opts as given to
-	# Worker#invoke.
+	# is_a? Node, but not a FileTask. +opt+ are opts as given to
+	# Node#invoke.
 	#
 	# Override this method in subclasses to modify behaviour of
 	# prerequisite handling.
 	#
-	# See also: handle_filetask, handle_non_worker
-	def handle_worker(dep, opt)
+	# See also: handle_timestamped, handle_non_node
+	def handle_node(dep, opt)
 	    dep.invoke opt
 	end
 
 	# Called from internal_invoke. +dep+ is a prerequisite which
-	# is_a? FileTask. +opt+ are opts as given to Worker#invoke.
+	# is_a? FileTask. +opt+ are opts as given to Node#invoke.
 	#
 	# Override this method in subclasses to modify behaviour of
 	# prerequisite handling.
 	#
-	# See also: handle_worker, handle_non_worker
-	def handle_filetask(dep, opt)
+	# See also: handle_node, handle_non_node
+	def handle_timestamped(dep, opt)
 	    dep.invoke opt
 	end
 
@@ -488,8 +403,8 @@ module Rant
 	# [1] Fail with an exception.
 	# [2] Return two values: replacement_for_dep, update_required
 	#
-	# See also: handle_worker, handle_filetask
-	def handle_non_worker(dep, opt)
+	# See also: handle_node, handle_timestamped
+	def handle_non_node(dep, opt)
 	    err_msg "Unknown task `#{dep}',",
 		"referenced in `#{rantfile.path}', line #{@line_number}!"
 	    self.fail
@@ -506,7 +421,7 @@ module Rant
 	    my_full_name = full_name
 	    my_project_subdir = project_subdir
 	    @pre.map! { |t|
-		if Worker === t
+		if Node === t
 		    # Remove references to self from prerequisites!
 		    if t.full_name == my_full_name
 			nil
@@ -520,7 +435,7 @@ module Rant
 			nil
 		    else
 			#STDERR.puts "selecting `#{t}'"
-			selection = @app.resolve t,
+			selection = @rac.resolve t,
 					my_project_subdir
 			#STDERR.puts selection.size
 			if selection.empty?
@@ -544,14 +459,14 @@ module Rant
     class UserTask < Task
 
 	class << self
-	    def rant_generate(app, ch, args, &block)
+	    def rant_generate(rac, ch, args, &block)
 		unless args.size == 1
-		    app.abort("UserTask takes only one argument " +
+		    rac.abort("UserTask takes only one argument " +
 			"which has to be like one given to the " +
 			"`task' function")
 		end
-		app.prepare_task(args.first, nil, ch) { |name,pre,blk|
-		    self.new(app, name, pre, &block)
+		rac.prepare_task(args.first, nil, ch) { |name,pre,blk|
+		    self.new(rac, name, pre, &block)
 		}
 	    end
 	end
@@ -602,19 +517,9 @@ module Rant
 
 	def initialize *args
 	    super
-	    if @name.is_a? Path
-		@path = @name
-		@name = @path.to_s
-	    else
-		@path = Path.new @name
-	    end
 	    @ts = T0
 	end
 
-	def path
-	    @path
-	end
-
 	def needed?
 	    return false if done?
 	    invoke(:needed? => true)
@@ -626,8 +531,8 @@ module Rant
 	    begin
 		return if done?
 		goto_task_home
-		if @path.exist?
-		    @ts = @path.mtime
+		if File.exist? @name
+		    @ts = File.mtime @name
 		    internal_invoke opt, false
 		else
 		    @ts = T0
@@ -638,23 +543,23 @@ module Rant
 	    end
 	end
 
-	def handle_filetask(dep, opt)
+	def timestamp
+	    File.exist?(@name) ? File.mtime(@name) : T0
+	end
+
+	def handle_timestamped(dep, opt)
 	    return true if dep.invoke opt
-	    # TODO: require dep to exist after invoke?
-	    if dep.path.exist?
-		#puts "***`#{dep.name}' requires update" if dep.path.mtime > @ts
-		dep.path.mtime > @ts
-	    end
+	    #puts "***`#{dep.name}' requires update" if dep.timestamp > @ts
+	    dep.timestamp > @ts
 	end
 
-	def handle_non_worker(dep, opt)
-	    dep = Path.new(dep) unless Path === dep
-	    unless dep.exist?
-		err_msg @app.pos_text(rantfile.path, line_number),
+	def handle_non_node(dep, opt)
+	    unless File.exist? dep
+		err_msg @rac.pos_text(rantfile.path, line_number),
 		    "in prerequisites: no such file or task: `#{dep}'"
 		self.fail
 	    end
-	    [dep, dep.mtime > @ts]
+	    [dep, File.mtime(dep) > @ts]
 	end
 
 	def each_target
@@ -663,6 +568,18 @@ module Rant
 	end
     end	# class FileTask
 
+    class AutoSubFileTask < FileTask
+	private
+	def run
+	    dir, = File.split(name)
+	    unless dir == "."
+		dt = @rac.resolve(dir, project_subdir).last
+		dt.invoke if DirTask === dt
+	    end
+	    super
+	end
+    end	# class AutoSubFileTask
+
     # An instance of this class is a task to create a _single_
     # directory.
     class DirTask < Task
@@ -677,12 +594,23 @@ module Rant
 	    # block will be called after complete directory creation.
 	    # After the block execution, the modification time of the
 	    # directory will be updated.
-	    def rant_generate(app, ch, args, &block)
-		if args && args.size == 1
-		    name, pre, file, ln = app.normalize_task_arg(args.first, ch)
-		    self.task(app, ch, name, pre, &block)
+	    def rant_generate(rac, ch, args, &block)
+		case args.size
+		when 1
+		    name, pre, file, ln = rac.normalize_task_arg(args.first, ch)
+		    self.task(rac, ch, name, pre, &block)
+		when 2
+		    basedir = args.shift
+		    if basedir.respond_to? :to_str
+			basedir = basedir.to_str
+		    else
+			rac.abort_at(ch,
+			    "Directory: basedir argument has to be a string.")
+		    end
+		    name, pre, file, ln = rac.normalize_task_arg(args.first, ch)
+		    self.task(rac, ch, name, pre, basedir, &block)
 		else
-		    app.abort(app.pos_text(ch[:file], ch[:ln]),
+		    rac.abort(rac.pos_text(ch[:file], ch[:ln]),
 			"Directory takes one argument, " +
 			"which should be like one given to the `task' command.")
 		end
@@ -691,44 +619,40 @@ module Rant
 	    # Returns the task which creates the last directory
 	    # element (and has all other necessary directories as
 	    # prerequisites).
-	    def task(app, ch, name, prerequisites = [], &block)
+	    def task(rac, ch, name, prerequisites=[], basedir=nil, &block)
 		dirs = ::Rant::Sys.split_path(name)
 		if dirs.empty?
-		    app.abort(app.pos_text(ch[:file], ch[:ln]),
+		    rac.abort_at(ch,
 			"Not a valid directory name: `#{name}'")
 		end
-		ld = nil
-		path = nil
+		path = basedir
 		last_task = nil
 		task_block = nil
+		desc_for_last = rac.pop_desc
 		dirs.each { |dir|
-		    pre = [ld]
+		    pre = [path]
 		    pre.compact!
 		    if dir.equal?(dirs.last)
+			rac.cx.desc desc_for_last
 			pre.concat prerequisites if prerequisites
 			task_block = block
 		    end
 		    path = path.nil? ? dir : File.join(path, dir)
-		    last_task = app.prepare_task({:__caller__ => ch,
+		    last_task = rac.prepare_task({:__caller__ => ch,
 			    path => pre}, task_block) { |name,pre,blk|
-			self.new(app, name, pre, &blk)
+			self.new(rac, name, pre, &blk)
 		    }
-		    ld = dir
 		}
 		last_task
 	    end
 	end
 
-	def intialize *args
+	def initialize *args
 	    super
 	    @ts = T0
 	    @isdir = nil
 	end
 
-	#def needed?
-	#    invoke(:needed? => true)
-	#end
-
 	def invoke(opt = INVOKE_OPT)
 	    return circular_dep if @run
 	    @run = true
@@ -748,29 +672,26 @@ module Rant
 	    end
 	end
 
-	def handle_filetask(dep, opt)
+	def handle_timestamped(dep, opt)
 	    return @block if dep.invoke opt
-	    if dep.path.exist?
-		@block && dep.path.mtime > @ts
-	    end
+	    @block && dep.timestamp > @ts
 	end
 
-	def handle_non_worker(dep, opt)
-	    dep = Path.new(dep) unless Path === dep
-	    unless dep.exist?
-		err_msg @app.pos_text(rantfile.path, line_number),
+	def handle_non_node(dep, opt)
+	    unless File.exist? dep
+		err_msg @rac.pos_text(rantfile.path, line_number),
 		    "in prerequisites: no such file or task: `#{dep}'"
 		self.fail
 	    end
-	    [dep, @block && dep.mtime > @ts]
+	    [dep, @block && File.mtime(dep) > @ts]
 	end
 
 	def run
-	    @app.sys.mkdir @name unless @isdir
+	    @rac.sys.mkdir @name unless @isdir
 	    if @block
 		@block.arity == 0 ? @block.call : @block[self]
 		goto_task_home
-		@app.sys.touch @name
+		@rac.sys.touch @name
 	    end
 	end
 
@@ -779,10 +700,102 @@ module Rant
 	    yield name
 	end
     end	# class DirTask
+
+    # A SourceNode describes dependencies between source files. Thus
+    # there is no action attached to a SourceNode. The target should
+    # be an existing file as well as all dependencies.
+    #
+    # An example would be a C source file which depends on other C
+    # source files because of <tt>#include</tt> statements.
+    #
+    # Rantfile usage:
+    #	gen SourceNode, "myext.c" => %w(ruby.h myext.h)
+    class SourceNode
+	include Node
+
+	def self.rant_generate(rac, ch, args)
+	    unless args.size == 1
+		rac.abort_at(ch, "SourceNode takes one argument.")
+	    end
+	    if block_given?
+		rac.abort_at(ch, "SourceNode doesn't take a block.")
+	    end
+	    rac.prepare_task(args.first, nil, ch) { |name, pre, blk|
+		new(rac, name, pre, &blk)
+	    }
+	end
+
+	def initialize(rac, name, prerequisites = [])
+	    super()
+	    @rac = rac
+	    @name = name or raise ArgumentError, "name not given"
+	    @pre = prerequisites
+	    @run = false
+	    # The timestamp is the latest of this file and all
+	    # dependencies:
+	    @ts = nil
+	end
+
+	# Use this readonly!
+	def prerequisites
+	    @pre
+	end
+
+	# Note: The timestamp will only be calculated once!
+	def timestamp
+	    # Circular dependencies don't generate endless
+	    # recursion/loops because before calling the timestamp
+	    # method of any other node, we set @ts to some non-nil
+	    # value.
+	    return @ts if @ts
+	    goto_task_home
+	    if File.exist?(@name)
+		@ts = File.mtime @name
+	    else
+		rac.abort(rac.pos_text(@rantfile, @line_number),
+		    "SourceNode: no such file -- #@name")
+	    end
+	    sd = project_subdir
+	    @pre.each { |f|
+		nodes = rac.resolve f, sd
+		if nodes.empty?
+		    if File.exist? f
+			mtime = File.mtime f
+			@ts = mtime if mtime > @ts
+		    else
+			rac.abort(rac.pos_text(@rantfile, @line_number),
+			    "SourceNode: no such file -- #{f}")
+		    end
+		else
+		    nodes.each { |node|
+			if node.respond_to? :timestamp
+			    node_ts = node.timestamp
+			    @ts = node_ts if node_ts > @ts
+			else
+			    rac.abort(rac.pos_text(@rantfile, @line_number),
+				"SourceNode can't depend on #{node.name}")
+			end
+		    }
+		end
+	    }
+	    @ts
+	end
+
+	def needed?
+	    false
+	end
+
+	def invoke(opt = INVOKE_OPT)
+	    false
+	end
+
+    end # class SourceNode
+
     module Generators
 	Task = ::Rant::Task
 	LightTask = ::Rant::LightTask
 	Directory = ::Rant::DirTask
+	SourceNode = ::Rant::SourceNode
 
 	class Rule < ::Proc
 	    # Generate a rule by installing an at_resolve hook for
@@ -843,7 +856,7 @@ module Rant
 		    end
 		}
 		blk.target_rx = target_rx
-		rac.at_resolve &blk
+		rac.resolve_hooks << blk
 		nil
 	    end
 	    attr_accessor :target_rx