rant 0.4.2 → 0.4.4

data/lib/rant/import/signedfile.rb

@@ -0,0 +1,235 @@
+
+# signedfile.rb - File tasks with checksum change recognition.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+    def self.init_import_signedfile(rac, *rest)
+        rac.import "signature/md5" unless rac.var._get("__signature__")
+        rac.import "metadata" unless rac.var._get("__metadata__")
+    end
+    module Generators
+        class SignedFile
+            include Node
+
+            def self.rant_gen(rac, ch, args, &block)
+                unless args.size == 1
+                    rac.abort_at(ch, "SignedFile: too many arguments")
+                end
+                rac.prepare_task(args.first, block, ch) { |name,pre,blk|
+                    self.new(rac, name, pre, &blk)
+                }
+            end
+
+            def initialize(rac, name, prerequisites, &block)
+                super()
+                @rac = rac
+                @name = name
+                @pre = prerequisites or
+                    raise ArgumentError, "prerequisites required"
+                @block = block
+                @run = false
+                @success = nil
+                @needed_blk = nil
+            end
+            def prerequisites
+                @pre
+            end
+            alias deps prerequisites
+            # first prerequisite
+            def source
+                @pre.first.to_s
+            end
+            def has_actions?
+                !!@block
+            end
+            def <<(pre)
+                @pre << pre
+            end
+            def invoked?
+                !@success.nil?
+            end
+            def fail?
+                @success == false
+            end
+            def done?
+                @success
+            end
+            def enhance(deps = nil, &blk)
+                @pre.concat(deps) if deps
+                if @block
+                    if blk
+                        first_block = @block
+                        @block = lambda { |t|
+                            first_block[t]
+                            blk[t]
+                        }
+                    end
+                else
+                    @block = blk
+                end
+            end
+            def needed?
+                invoke(:needed? => true)
+            end
+            def needed(&blk)
+                @needed_blk = blk
+            end
+            def invoke(opt = INVOKE_OPT)
+                return circular_dep if @run
+                @run = true
+                begin
+                    return if done?
+                    goto_task_home
+                    @cur_checksums = []
+                    @sigs = @rac.var._get("__signature__")
+                    key = "prerequisites_sig_#{@sigs.name}"
+                    target_key = "target_sig_#{@sigs.name}"
+                    up = signed_process_prerequisites(opt)
+                    up ||= opt[:force]
+                    if @needed_blk
+                        up = true if @needed_blk.call(self)
+                    end
+                    @cur_checksums.sort!
+                    check_str = @cur_checksums.join
+                    @cur_checksums = nil
+                    metadata = @rac.var._get("__metadata__")
+                    old_check_str = metadata.fetch(key, @name)
+                    old_target_str = metadata.fetch(target_key, @name)
+                    # check explicitely for plain file, thus allow the
+                    # target of a SignedFile to be a directory ;)
+                    if test(?f, @name)
+                        target_str = @sigs.signature_for_file(@name)
+                    else
+                        target_str = ""
+                        up ||= !File.exist?(@name)
+                    end
+                    check_str_changed = old_check_str != check_str
+                    target_changed = old_target_str != target_str
+                    up ||= check_str_changed || target_changed
+                    return up if opt[:needed?]
+                    return false unless up
+                    # run action and save checksums
+                    run
+                    goto_task_home
+                    target_str = test(?f, @name) ?
+                        @sigs.signature_for_file(@name) : ""
+                    target_changed = target_str != old_target_str
+                    if target_changed
+                        metadata.set(target_key, target_str, @name)
+                    end
+                    if check_str_changed
+                        metadata.set(key, check_str, @name)
+                    end
+                    return target_changed
+                rescue TaskFail => e
+                    raise
+                rescue Exception => e
+                    self.fail(nil, e)
+                ensure
+                    @sigs = nil
+                    @run = false
+                end
+            end
+            def each_target
+                goto_task_home
+                yield @name
+            end
+            def timestamp
+                File.exist?(@name) ? File.mtime(@name) : T0
+            end
+            def signature
+                goto_task_home
+                sigs = @rac.var._get("__signature__")
+                md = @rac.var._get("__metadata__")
+                key = "target_sig_#{sigs.name}"
+                md.fetch(key, @name)
+            end
+            private
+            # returns true if update required
+            def signed_process_prerequisites(opt)
+                up = false
+                # set with already handled prerequisites, don't
+                # handle on prerequisite multiple times
+                handled = {@name => true}
+                my_subdir = project_subdir
+                @pre.each { |dep|
+                    dep_str = dep.to_rant_target
+                    next if handled.include? dep_str
+                    if Node === dep
+                        up = true if handle_node(dep, dep_str, opt)
+                    else
+                        tasks = @rac.resolve(dep_str, my_subdir)
+                        if tasks.empty?
+                            if test(?d, dep_str)
+                                handle_dir(dep_str)
+                            elsif File.exist?(dep_str)
+                                handle_file(dep_str)
+                            else
+                                rac.err_msg @rac.pos_text(rantfile.path, line_number),
+                                    "in prerequisites: no such file or task: `#{dep_str}'"
+                                self.fail
+                            end
+                        else
+                            tasks.each { |t|
+                                up = true if handle_node(t, dep_str, opt)
+                            }
+                        end
+                    end
+                    handled[dep_str] = true
+                }
+                up
+            end
+            def handle_node(node, dep_str, opt)
+                up = node.invoke(opt)
+                if node.respond_to? :signature
+                    @cur_checksums << node.signature
+                elsif test(?f, dep_str)
+                    # calculate checksum for plain file
+                    handle_file(dep_str)
+                elsif File.exist?(dep_str)
+                    @cur_checksums << @sigs.signature_for_string(dep_str)
+                end
+                goto_task_home
+                up
+            end
+            def handle_file(path)
+                @cur_checksums << @sigs.signature_for_file(path)
+            end
+            def handle_dir(path)
+                @cur_checksums << @sigs.signature_for_string(path)
+            end
+        end # class SignedFile
+
+        class AutoSubSignedFile < SignedFile
+            include AutoInvokeDirNode
+        end
+
+        class SignedDirectory < SignedFile
+            def respond_to?(meth)
+                if meth == :signature
+                    @block
+                else
+                    super
+                end
+            end
+            def signature
+                goto_task_home
+                sigs = @rac.var._get("__signature__")
+                md = @rac.var._get("__metadata__")
+                key = "prerequisites_sig_#{sigs.name}"
+                md.fetch(key, @name)
+            end
+            private
+            def run
+                @rac.cx.sys.mkdir @name unless test ?d, @name
+                if @block
+                    @block.arity == 0 ? @block.call : @block[self]
+                    goto_task_home
+                    # for compatibility with mtime based tasks
+                    @rac.cx.sys.touch @name
+                end
+            end
+        end # class SignedDirectory
+    end # module Generators
+end # module Rant

data/lib/rant/import/subfile.rb

@@ -49,7 +49,7 @@ class Rant::Generators::SubFile
                 pre << dirp
 	    end
 	    rac.cx.desc file_desc
-	    ::Rant::FileTask.new(rac, name, pre, &blk)
+	    rac.node_factory.new_file(rac, name, pre, blk)
 	}
     end
 end

data/lib/rant/import.rb

@@ -103,6 +103,10 @@ module Rant
 		@imports.concat(@rantapp.imports)
 		@plugins.concat(@rantapp.plugins.map { |p| p.name })
 	    end
+
+            #unless @imports.include? "nodes/default"
+                #@imports.unshift "nodes/default"
+            #end
 	    
 	    if File.exist?(@mono_fn) && !@force
 		abort("#{@mono_fn} exists. Rant won't overwrite this file.",
@@ -298,7 +302,7 @@ EOF
 		next if line =~ /^#! ?(\/|\\)?\w/
                 # uncomment line if +uncomment+ directive given
                 if line =~ /^\s*#.*#\s?rant-import:\s?uncomment\s*$/
-                    line.sub! '#', ''
+                    line.sub!(/#/, '')
                 end
                 # skip line if +remove+ directive given
                 next if line =~ /#\s?rant-import:\s?remove\s*$/

data/lib/rant/node.rb

@@ -0,0 +1,165 @@
+
+# node.rb - Base of Rant nodes.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+
+    class TaskFail < StandardError
+	def initialize(task, orig, msg)
+	    @task = task
+	    @orig = orig
+            @msg = msg
+	end
+        def exception
+            self
+        end
+	def task
+	    @task
+	end
+	def tname
+	    @task ? @task.name : nil
+	end
+	# the exception which caused the task to fail
+	def orig
+	    @orig
+	end
+        def msg
+            @msg
+        end
+    end
+
+    class Rantfile
+	attr_reader :tasks, :path
+	attr_accessor :project_subdir
+	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::Node === object</tt> is true.
+    #
+    # Most important classes including this module are the Rant::Task
+    # class and the Rant::FileTask class.
+    module Node
+
+	INVOKE_OPT = {}.freeze
+
+	T0 = Time.at(0).freeze
+
+	# Name of the task, this is always a string.
+	attr_reader :name
+	# 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.
+	# Should be a Rant::Rantfile instance.
+	attr_accessor :rantfile
+	# The linenumber in rantfile where this task was defined.
+	attr_accessor :line_number
+	# The directory in which this task was defined, relative to
+	# the projects root directory.
+        attr_accessor :project_subdir
+	
+	def initialize
+	    @description = nil
+	    @rantfile = nil
+	    @line_number = nil
+	    @run = false
+            @project_subdir = ""
+	end
+
+	# Returns the name of this task.
+	def to_s
+	    name
+	end
+
+        def to_rant_target
+            name
+        end
+
+	# Basically project_subdir/name
+	#
+	# The Rant compiler (or application) references tasks by their
+	# full_name.
+	def full_name
+	    sd = project_subdir
+	    sd.empty? ? name : File.join(sd, name)
+	end
+
+	# Change current working directory to the directory this task
+	# was defined in.
+	#
+	# Important for subclasses: Call this method always before
+	# invoking code from Rantfiles (e.g. task action blocks).
+	def goto_task_home
+	    @rac.goto_project_dir project_subdir
+	end
+
+	def done?
+	    @done
+	end
+
+	def needed?
+	    !done?
+	end
+
+	# True during invoke. Used to encounter circular dependencies.
+	def run?
+	    @run
+	end
+
+	# +opt+ is a Hash and shouldn't be modified.
+	# 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 Node#needed?
+	# <tt>:force</tt>::
+	#	Run task action even if needed? is false.
+	# Returns true if task action was run.
+	def invoke(opt = INVOKE_OPT)
+	    return circular_dep if run?
+	    @run = true
+	    begin
+		return needed? if opt[:needed?]
+		self.run if opt[:force] || self.needed?
+	    ensure
+		@run = false
+	    end
+	end
+
+	# Cause task to fail. Usually called from inside the block
+	# given to +act+.
+	def fail msg = nil, orig = nil
+            raise TaskFail.new(self, orig, msg)
+	end
+
+	# Change pwd to task home directory and yield for each created
+	# file/directory.
+	#
+	# Override in subclasses if your task instances create files.
+	def each_target
+	end
+
+	def run
+	    return unless @block
+	    goto_task_home
+	    @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

data/lib/rant/plugin/csharp.rb

@@ -3,6 +3,8 @@
 
 require 'rant/plugin_methods'
 require 'rant/cs_compiler'
+# TODO
+require 'rant/import/nodes/default'
 
 module Rant
 

data/lib/rant/rantlib.rb

@@ -10,8 +10,10 @@
 require 'getoptlong'
 require 'rant/rantvar'
 require 'rant/rantenv'
-require 'rant/rantfile'
 require 'rant/rantsys'
+require 'rant/node'
+require 'rant/import/nodes/default' # could be optimized away
+require 'rant/coregen'
 
 # There is one problem with executing Rantfiles in a special context:
 # In the top-level execution environment, there are some methods
@@ -23,11 +25,19 @@ require 'rant/rantsys'
 # this object.
 Rant::MAIN_OBJECT = self
 
-unless Process::Status.method_defined?(:success?)
+unless Process::Status.method_defined?(:success?) # new in 1.8.2
     class Process::Status
         def success?;  exitstatus == 0; end
     end
 end
+unless Regexp.respond_to? :union # new in 1.8.1
+    def Regexp.union(*patterns)
+        # let's hope it comes close to ruby-1.8.1 and upwards...
+        return /(?!)/ if patterns.empty?
+        # i guess the options are lost
+        Regexp.new(patterns.join("|"))
+    end
+end
 if RUBY_VERSION < "1.8.2"
     class Array
         def flatten
@@ -54,6 +64,13 @@ if RUBY_VERSION < "1.8.2"
         end
     end
 end
+if RUBY_VERSION < "1.8.1"
+    module FileUtils
+        def fu_list(arg)
+            arg.respond_to?(:to_ary) ? arg.to_ary : [arg]
+        end
+    end
+end
 
 class Array
 
@@ -194,12 +211,12 @@ class RantAppContext
     include RantContext
 
     def initialize(app)
-	@rac = app
+	@__rac__ = app
     end
 
     # +rac+ stands for "rant compiler"
     def rac
-	@rac
+	@__rac__
     end
 
     def method_missing(sym, *args)
@@ -271,6 +288,16 @@ end	# module Rant
 class Rant::RantApp
     include Rant::Console
 
+    class AutoLoadNodeFactory
+        def initialize(rac)
+            @rac = rac
+        end
+        def method_missing(sym, *args, &block)
+            @rac.import "nodes/default"
+            @rac.node_factory.send(sym, *args, &block)
+        end
+    end
+
     # Important: We try to synchronize all tasks referenced indirectly
     # by @rantfiles with the task hash @tasks. The task hash is
     # intended for fast task lookup per task name.
@@ -305,6 +332,7 @@ class Rant::RantApp
 	# internal use. A private option is distuingished from others
 	# by having +nil+ as description!
 
+        [ "--import",   "-i",   GetoptLong::REQUIRED_ARGUMENT, nil ],
 	[ "--stop-after-load",	GetoptLong::NO_ARGUMENT, nil	],
 	# Print caller to $stderr on abort.
 	[ "--trace-abort",	GetoptLong::NO_ARGUMENT, nil	],
@@ -347,6 +375,8 @@ class Rant::RantApp
     # Note: Might change before 1.0
     attr_reader :resolve_hooks
 
+    attr_accessor :node_factory
+
     def initialize(*args)
 	unless args.empty?
 	    STDERR.puts caller[0]
@@ -381,6 +411,8 @@ class Rant::RantApp
 	@orig_pwd = nil
 	@current_subdir = ""
 	@resolve_hooks = []
+
+        @node_factory = AutoLoadNodeFactory.new(self)
     end
 
     def [](opt)
@@ -531,6 +563,8 @@ class Rant::RantApp
 	return 1
     ensure
 	# TODO: exception handling!
+        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
@@ -550,13 +584,13 @@ class Rant::RantApp
 
     def task(targ, &block)
 	prepare_task(targ, block) { |name,pre,blk|
-	    Rant::Task.new(self, name, pre, &blk)
+            @node_factory.new_task(self, name, pre, blk)
 	}
     end
 
     def file(targ, &block)
 	prepare_task(targ, block) { |name,pre,blk|
-	    Rant::FileTask.new(self, name, pre, &blk)
+            @node_factory.new_file(self, name, pre, blk)
 	}
     end
 
@@ -594,6 +628,8 @@ class Rant::RantApp
 		    end
 		    Rant::CODE_IMPORTS << arg.dup
 		end
+                init_msg = "init_import_#{arg.gsub(/[^\w]/, '__')}"
+                Rant.send init_msg, self if Rant.respond_to? init_msg
 		@imports << arg.dup
 	    end
 	}
@@ -661,7 +697,7 @@ class Rant::RantApp
 	    end
 	    warn_msg "enhance \"#{name}\": no such task",
 		"Generating a new file task with the given name."
-	    Rant::FileTask.new(self, name, pre, &blk)
+            @node_factory.new_file(self, name, pre, blk)
 	}
     end
 
@@ -924,7 +960,7 @@ class Rant::RantApp
             tn = nil
             prepare_task(targ, block, ch) { |name,pre,blk|
                 tn = name
-                Rant::FileTask.new(self, name, pre, &blk)
+                @node_factory.new_file(self, name, pre, blk)
             }
             build(tn)
         elsif target.respond_to? :to_rant_target
@@ -938,7 +974,7 @@ class Rant::RantApp
                 # create a file task
                 ch ||= Rant::Lib.parse_caller_elem(caller[1])
                 prepare_task(rt, block, ch) { |name,pre,blk|
-                    Rant::FileTask.new(self, name, pre, &blk)
+                    @node_factory.new_file(self, name, pre, blk)
                 }
                 build(rt)
             else
@@ -1017,6 +1053,18 @@ class Rant::RantApp
     end
     public :at_resolve
 
+    # block will be called before this rac returns from #run
+    # pwd will be the projects root directory
+    def at_return(&block)
+        hooks = var._get("__at_return__")
+        if hooks
+            hooks << block
+        else
+            var._set("__at_return__", [block])
+        end
+    end
+    public :at_return
+
     # Returns a list with all tasks for which yield
     # returns true.
     def select_tasks
@@ -1130,6 +1178,8 @@ class Rant::RantApp
 		@arg_rantfiles << value
 	    when "--force-run"
 		@force_targets << value
+            when "--import"
+                import value
 	    else
 		# simple switch
 		@opts[opt.sub(/^--/, '').tr('-', "_").to_sym] = true
@@ -1305,6 +1355,11 @@ class Rant::RantApp
                 msg << orig.backtrace[0..4] unless ch
             end
 	end
+        if e.msg && !e.msg.empty?
+            ch = get_ch_from_backtrace(e.backtrace)
+            t_msg.unshift(e.msg)
+            t_msg.unshift(pos_text(ch[:file], ch[:ln])) if ch
+        end
 	err_msg msg unless msg.empty?
 	err_msg t_msg
     end