rant 0.4.2 → 0.4.4

data/NEWS

@@ -1,6 +1,20 @@
 
 = Rant NEWS
 
+== Rant 0.4.4
+
+Besides internal changes, this release is backwards compatible to
+0.4.2.
+
+Fixes and minor improvements:
+* Rant is Ruby 1.8.0 compatible now.
+* Fixes for filelists.
+* A fix for Directory generator (and thus dependent features).
+
+New features:
+* Optional recognition of file changes based on MD5 checksums.
+  Read doc/md5.rdoc[link:files/doc/md5_rdoc.html] for documentation.
+
 == Rant 0.4.2
 
 This is mainly a bugfix release and thus fully backwards compatible to

data/README

@@ -16,6 +16,8 @@ Rant currently features:
   so you don't depend on an rant installation anymore.
 * Creating gzipped tar and zip archives -- without installing
   additional software.
+* Optional recognition of file changes based on MD5 checksums instead
+  of file modification times.
 * Primitive support for compiling C# sources portably with csc, cscc
   and mcs.
 * Dependency checking for C/C++ source files.
@@ -28,7 +30,7 @@ basic example of rant usage:
 A file called +Rantfile+ contains the code:
 
     file "backup/data" => "data" do |t|
-	sys.cp "data", t.name
+	sys.cp t.source, t.name
     end
 
 Running rant in the directory of this file:
@@ -39,7 +41,7 @@ Running rant in the directory of this file:
 will ensure that the "data" file in the "backup" directory is up to
 date.
 
-This document was written for version 0.4.2 of Rant. Most things
+This document was written for version 0.4.4 of Rant. Most things
 described here will work for older/newer versions of Rant, but look at
 the README file in the Rant distribution you've installed for exact
 documentation of your Rant version.
@@ -49,9 +51,10 @@ documentation of your Rant version.
 The newest version of this document can be found at
 http://make.rubyforge.org.
 
-For further information, feature requests, bugreports or comments
-visit the
-{RubyForge site for Rant}[http://rubyforge.org/projects/make/].
+For further information, feature requests, bugreports or comments join
+the mailing list
+{make-cafe}[http://rubyforge.org/mailman/listinfo/make-cafe] or visit
+the {RubyForge site for Rant}[http://rubyforge.org/projects/make/].
 
 Also feel free to contact the author directly by sending an email to
 mailto:langstefan@gmx.at.
@@ -74,6 +77,8 @@ Advanced Rantfiles::
     read doc/advanced.rdoc[link:files/doc/advanced_rdoc.html]
 Packaging (creating zip/tgz archives)::
     read doc/package.rdoc[link:files/doc/package_rdoc.html]
+Using MD5 checksums instead of file modification times::
+    read doc/md5.rdoc[link:files/doc/md5_rdoc.html]
 Compiling C/C++::
     read doc/c.rdoc[link:files/doc/c_rdoc.html]
 Using the Configure plugin::
@@ -204,7 +209,8 @@ Rant was tested on:
 
     System		Ruby version
     =======================================================
-    Linux		1.8.1
+    Linux		1.8.0
+                        1.8.1
                         1.8.2
 			1.8.3 preview 1
 			1.9
@@ -215,7 +221,7 @@ Rant was tested on:
 It *should* run on most platforms where Ruby runs, but you never
 know...
 
-If you encounter problems with Rant on any platform (with Ruby 1.8.1
+If you encounter problems with Rant on any platform (with Ruby 1.8.0
 or higher) please write a bugreport!
 
 === Why did you write another build tool?

data/Rantfile

@@ -1,6 +1,7 @@
 
 # Rantfile for Rant :)
 
+import "md5"
 import %w(rubytest rubydoc rubypackage autoclean win32/rubycmdwrapper)
 
 task :default => :test
@@ -8,6 +9,10 @@ task :default => :test
 dist_files = sys["{bin,lib,test,doc,misc}/**/*"]
 dist_files.shun("html", "coverage")
 dist_files += sys["*"].no_dir.exclude("InstalledFiles", "Session.vim")
+
+# remove when compiler stuff is getting useful...
+dist_files.exclude "lib/rant/compiler*", "lib/rant/import/c/program.rb"
+
 rdoc_opts = %w(-S -c UTF-8 --title Rant --main README)
 
 gen RubyPackage, "rant" do |t|
@@ -103,6 +108,12 @@ gen RubyTest, :tall do |g|
     g.test_files = sys["test/**/test_*.rb"]
 end
 
+task :t180 do |t|
+    # my installed testrb version doesn't work with ruby-1.8.0
+    sys.cd "test"
+    sys "ruby180 ts_all.rb"
+end
+
 desc "Remove autogenerated files."
 gen AutoClean, :clean
 var[:clean].include %w(

data/doc/md5.rdoc

@@ -0,0 +1,49 @@
+
+== Using MD5 checksums to detect file changes
+
+Most build tools rely on the modification time of a file which is
+updated usually when a program writes to the file. But this is not
+always as accurate as one would like, e.g. when you edit a C source
+file to simple change/add a comment, the compiler will probably
+produce the same object file as before. The build tool recognizes that
+the file modification time of the object file is newer than that of
+the target program and rebuilds the target program.
+
+With MD5 checksums instead of file modification times, the build tool
+recognizes that the object file didn't change and thus the target
+program doesn't need to be rebuilt.
+
+Even worse is the case where the file modification time isn't updated
+or is corrupted and the build tool thinks a source file hasn't changed
+were in fact it has! In other words, with MD5 checksums, the build
+tool recognizes when the *contents* of a file changes.
+
+To enable this nice feature for your project, put this single line at
+the top (before other +import+, +task+, +file+ or +gen+ statements) of
+the Rantfile:
+
+    import "md5"
+
+Note that Rant saves the checksums after a build in a file called
+<tt>.rant.meta</tt>. If you remove this file, Rant looses all
+information about the last builds, and so will rebuild all targets on
+invocation.
+
+If you want to switch back to modification time based builds, simply
+remove the <tt>import "md5"</tt> statement and remove the file
+<tt>.rant.meta</tt>.
+
+== See also
+
+Writing an Rantfile::
+    doc/rantfile.rdoc[link:files/doc/rantfile_rdoc.html]
+Advanced Rantfiles::
+    doc/advanced.rdoc[link:files/doc/advanced_rdoc.html]
+Support for C/C++::
+    doc/c.rdoc[link:files/doc/c_rdoc.html]
+Packaging::
+    doc/package.rdoc[link:files/doc/package_rdoc.html]
+Ruby project howto::
+    doc/rubyproject.rdoc[link:files/doc/rubyproject_rdoc.html]
+Rant Overview::
+    README[link:files/README.html]

data/doc/rantfile.rdoc

@@ -64,7 +64,7 @@ Running rant now:
     mytask
 
 Add prerequisites to create relations between tasks:
-    task :first => [:t1, :t2] do
+    task :first => [:t1, :t2] do |t|
 	puts t.name
     end
     task :t1 do |t|

data/lib/rant/coregen.rb

@@ -0,0 +1,193 @@
+
+# coregen.rb - Generators available in all Rantfiles.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+    module Generators
+        class Task
+	    def self.rant_gen(rac, ch, args, &block)
+		unless args.size == 1
+		    rac.abort("Task takes only one argument " +
+			"which has to be like one given to the " +
+			"`task' function")
+		end
+		rac.prepare_task(args.first, nil, ch) { |name,pre,blk|
+		    rac.node_factory.new_custom(rac, name, pre, block)
+		}
+	    end
+        end
+        class Directory
+	    # Generate a task for making a directory path.
+	    # Prerequisites can be given, which will be added as
+	    # prerequistes for the _last_ directory.
+	    #
+	    # A special feature is used if you provide a block: The
+	    # block will be called after complete directory creation.
+	    # After the block execution, the modification time of the
+	    # directory will be updated.
+	    def self.rant_gen(rac, ch, args, &block)
+		case args.size
+		when 1
+		    name, pre = 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 = rac.normalize_task_arg(args.first, ch)
+		    self.task(rac, ch, name, pre, basedir, &block)
+		else
+		    rac.abort_at(ch, "Directory takes one argument, " +
+			"which should be like one given to the `task' command.")
+		end
+	    end
+
+	    # Returns the task which creates the last directory
+	    # element (and has all other necessary directories as
+	    # prerequisites).
+	    def self.task(rac, ch, name, prerequisites=[], basedir=nil, &block)
+		dirs = ::Rant::Sys.split_path(name)
+		if dirs.empty?
+		    rac.abort_at(ch,
+			"Not a valid directory name: `#{name}'")
+		end
+		path = basedir
+		last_task = nil
+		task_block = nil
+		desc_for_last = rac.pop_desc
+		dirs.each { |dir|
+                    pre = [path]
+                    pre.compact!
+		    if dir.equal?(dirs.last)
+			rac.cx.desc desc_for_last
+
+                        # add prerequisites to pre
+                        # if prerequisites is a FileList: there is
+                        # only one save (no later removal) way to add
+                        # an entry: with <<
+                        dp = prerequisites.dup
+                        pre.each { |elem| dp << elem }
+                        pre = dp
+
+			task_block = block
+		    end
+		    path = path.nil? ? dir : File.join(path, dir)
+		    last_task = rac.prepare_task({:__caller__ => ch,
+			    path => pre}, task_block) { |name,pre,blk|
+			rac.node_factory.new_dir(rac, name, pre, blk)
+		    }
+		}
+		last_task
+	    end
+        end # class Directory
+        class SourceNode
+            def self.rant_gen(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|
+                    rac.node_factory.new_source(rac, name, pre, blk)
+                }
+            end
+        end
+	class Rule < ::Proc
+	    # Generate a rule by installing an at_resolve hook for
+	    # +rac+.
+	    def self.rant_gen(rac, ch, args, &block)
+		unless args.size == 1
+		    rac.abort_at(ch, "Rule takes only one argument.")
+		end
+		arg = args.first
+		target = nil
+		src_arg = nil
+		if Symbol === arg
+		    target = ".#{arg}"
+		elsif arg.respond_to? :to_str
+		    target = arg.to_str
+		elsif Regexp === arg
+		    target = arg
+		elsif Hash === arg && arg.size == 1
+		    arg.each_pair { |target, src_arg| }
+		    src_arg = src_arg.to_str if src_arg.respond_to? :to_str
+		    target = target.to_str if target.respond_to? :to_str
+		    src_arg = ".#{src_arg}" if Symbol === src_arg
+		    target = ".#{target}" if Symbol === target
+		else
+		    rac.abort_at(ch, "Rule argument " +
+			"has to be a hash with one key-value pair.")
+		end
+		esc_target = nil
+		target_rx = case target
+		when String
+		    esc_target = Regexp.escape(target)
+		    /#{esc_target}$/
+		when Regexp
+		    target
+		else
+		    rac.abort_at(ch, "rule target has " +
+			"to be a string or regular expression")
+		end
+		src_proc = case src_arg
+		when String
+		    unless String === target
+			rac.abort(ch, "rule target has to be a string " +
+			    "if source is a string")
+		    end
+		    lambda { |name| name.sub(/#{esc_target}$/, src_arg) }
+		when Proc: src_arg
+		when nil: lambda { |name| [] }
+		else
+		    rac.abort_at(ch, "rule source has to be " +
+			"String or Proc")
+		end
+		blk = self.new { |task_name|
+		    if target_rx =~ task_name
+                        have_src = true
+                        src = src_proc[task_name]
+                        if src.respond_to? :to_ary
+                            src.each { |f|
+                                if rac.resolve(f).empty? && !test(?e, f)
+                                    have_src = false
+                                    break
+                                end
+                            }
+                        else
+                            if rac.resolve(src).empty? && !test(?e, src)
+                                have_src = false
+                            end
+                        end
+                        if have_src
+                            t = rac.file(:__caller__ => ch,
+                                    task_name => src_proc[task_name], &block)
+                            t.project_subdir = rac.current_subdir
+                            [t]
+                        end
+		    end
+		}
+		blk.target_rx = target_rx
+		rac.resolve_hooks << blk
+		nil
+	    end
+	    attr_accessor :target_rx
+	end	# class Rule
+	class Action
+	    def self.rant_gen(rac, ch, args, &block)
+		unless args.empty?
+		    rac.warn_msg(rac.pos_text(ch[:file], ch[:ln]),
+			"Action doesn't take arguments.")
+		end
+		unless (rac[:tasks] || rac[:stop_after_load])
+		    yield
+		end
+	    end
+	end
+    end	# module Generators
+end # module Rant

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

@@ -42,6 +42,8 @@ module Rant::Generators::Archive
 	end
         def rubyzip fn, files, opts = {:recurse => false}
             require 'rant/archive/rubyzip'
+            # rubyzip creates only a new file if fn doesn't exist
+            @rac.sys.rm_f fn if test ?e, fn
             @rac.cmd_msg "rubyzip #{fn}"
             Rant::Archive::Rubyzip::ZipFile.open fn,
                 Rant::Archive::Rubyzip::ZipFile::CREATE do |z|

data/lib/rant/import/archive.rb

@@ -160,6 +160,14 @@ module Rant::Generators::Archive
 	    end
             # remove leading `./' relicts
             @res_files = fl.lazy_map! { |fn| fn.sub(/^\.\/(?=.)/,'') }
+            if defined?(@dist_path) && @dist_path
+                # Remove entries from the dist_path directory, which
+                # would create some sort of weird recursion.
+                #
+                # Normally, the Rantfile writer should care himself,
+                # but since I tapped into this trap frequently now...
+                @res_files.exclude(/^#{Regexp.escape @dist_path}/)
+            end
             @res_files.lazy_uniq!.lazy_sort!
 	end
 
@@ -187,7 +195,7 @@ module Rant::Generators::Archive
 	def define_manifest_task
 	    return @manifest_task if @manifest_task
 	    @manifest_task =
-		@rac.gen ::Rant::Task, @manifest do |t|
+		@rac.gen ::Rant::Generators::Task, @manifest do |t|
 		    def t.each_target
 			goto_task_home
 			yield name
@@ -249,12 +257,12 @@ module Rant::Generators::Archive
 	def define_task_for_dir(&block)
 	    return @pkg_task if @pkg_task
 
-            get_files # set @res_files
 	    @dist_dirname = File.split(name).last
 	    @dist_dirname << "-#@version" if @version
 	    @dist_root, = File.split path
 	    @dist_path = (@dist_root == "." ?
 		@dist_dirname : File.join(@dist_root, @dist_dirname))
+            get_files # set @res_files
 
             targ = {get_archive_path => [@dist_path]}
 	    #STDERR.puts "basedir: #{basedir}, fn: #@archive_path"

data/lib/rant/import/autoclean.rb

@@ -58,15 +58,24 @@ class Rant::Generators::AutoClean
 		    end
 		}
 	    end
+            common = rac.var._get("__autoclean_common__")
+            if common
+                rac.rantfiles.each{ |rf|
+                    sd = rf.project_subdir
+                    common.each { |fn|
+                        path = sd.empty? ? fn : File.join(sd, fn)
+                        clean rac, path
+                    }
+                }
+            end
+            t.goto_task_home
 	end
     end
     def self.clean(rac, entry)
-	if test ?e, entry
-	    if test ?f, entry
-		rac.cx.sys.rm_f entry
-	    else
-		rac.cx.sys.rm_rf entry
-	    end
-	end
+        if test ?f, entry
+            rac.cx.sys.rm_f entry
+        elsif test ?e, entry
+            rac.cx.sys.rm_rf entry
+        end
     end
 end

data/lib/rant/import/c/dependencies.rb

@@ -91,7 +91,7 @@ class Rant::Generators::C::Dependencies
 		f_task = tmp_rac.tasks[cf.to_str]
 		deps = f_task ? f_task.prerequisites : nil
 		if !deps or File.mtime(cf) > depfile_ts
-		    rac.cmd_msg "parsing #{cf}"
+		    rac.cmd_msg "scanning #{cf}"
 		    std_includes, local_includes = 
 			::Rant::C::Include.parse_includes(File.read(cf))
 		    deps = []

data/lib/rant/import/directedrule.rb

@@ -93,7 +93,7 @@ class Rant::Generators::DirectedRule
 		# pre 0.3.7
 		#[@rac.file(:__caller__ => @ch, name => src, &@block)]
 		[@rac.prepare_task({name => src}, @block, @ch) { |name,pre,blk|
-		    ::Rant::AutoSubFileTask.new(@rac, name, pre, &blk)
+		    @rac.node_factory.new_auto_subfile(@rac, name, pre, blk)
 		}]
 	    else
 		nil
@@ -105,7 +105,7 @@ class Rant::Generators::DirectedRule
     def define_hook
 	@rac.resolve_hooks << self
     end
-    def each_target &block
+    def each_target(&block)
 	@rac.cx.sys["#@target_dir/*"].each { |entry|
 	    yield entry if entry =~ @target_rx
 	}

data/lib/rant/import/md5.rb

@@ -0,0 +1,16 @@
+
+# md5.rb - Use md5 checksums to recognize source changes.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+#require 'rant/import/signature/md5' #rant-import:uncomment
+#require 'rant/import/metadata' #rant-import:uncomment
+#require 'rant/import/nodes/signed' #rant-import:uncomment
+
+module Rant
+    def self.init_import_md5(rac, *rest)
+        rac.import "signature/md5"
+        rac.import "metadata"
+        rac.import "nodes/signed"
+    end
+end

data/lib/rant/import/metadata.rb

@@ -0,0 +1,162 @@
+
+# metadata.rb - Management of meta-information for Rant targets.
+#
+# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+module Rant
+    
+    def self.init_import_metadata(rac, *rest)
+        mi = MetaData::Interface.new(rac)
+        rac.var._set("__metadata__", mi)
+        rac.at_return(&mi.method(:save))
+        rac.var._init("__autoclean_common__", []) << MetaData::META_FN
+    end
+    
+    module MetaData
+
+        META_FN = ".rant.meta"
+
+        class Interface
+
+            def initialize(rac)
+                @rac = rac
+                # the keys in this hash are project directory names,
+                # the corresponding values are again hashes and their
+                # keys are target names
+                @store = {}
+                # just a set
+                @modified_dirs = {}
+                # just a set
+                @read_dirs = {}
+            end
+
+            # Fetch the meta value associated with the given key for
+            # target in dir. Note that the value will probably end in
+            # a newline. Very important is, that the +dir+ (third
+            # argument, relative to the projects root directory) has
+            # to be the current working directory! An example:
+            #   project root directory: /home/foo/myproject
+            #   dir:                    bar
+            #   => Dir.pwd has to be:   /home/foo/myproject/bar
+            #
+            # Returns nil only if the value doesn't exist.
+            def fetch(key, target, dir=@rac.current_subdir)
+                # first check if a value for the given key, target and
+                # dir already exists
+                dstore = @store[dir]
+                if dstore
+                    tstore = dstore[target]
+                    if tstore
+                        val = tstore[key]
+                        return val if val
+                    end
+                end
+                # check if the meta file in dir was already read
+                unless @read_dirs.include? dir
+                    read_meta_file_in_dir(dir)
+                end
+                tstore = @store[dir][target]
+                tstore[key] if tstore
+            end
+
+            # Set the key-value pair for the given target in dir. Note
+            # that if value.class is not String, the value will be
+            # replaced with a newline! key should also be a string and
+            # mustn't contain a newline.
+            #
+            # Returns nil.
+            def set(key, value, target, dir=@rac.current_subdir)
+                value = "\n" unless value.class == String
+                @modified_dirs[dir] ||= true
+                dstore = @store[dir]
+                unless dstore
+                    @store[dir] = {target => {key => value}}
+                    return
+                end
+                tstore = dstore[target]
+                if tstore
+                    tstore[key] = value
+                else
+                    dstore[target] = {key => value}
+                end
+                nil
+            end
+
+            # Assumes to be called from the projects root directory.
+            def save
+                @modified_dirs.each_key { |dir|
+                    write_dstore(@store[dir], dir)
+                }
+                nil
+            end
+
+            private
+            # assumes that dir is already the current working
+            # directory
+            def read_meta_file_in_dir(dir)
+                #puts "in dir: #{dir}, pwd: #{Dir.pwd}"
+                @read_dirs[dir] = true
+                #fn = dir.empty? ? META_FN : File.join(dir, META_FN)
+                fn = META_FN
+                dstore = @store[dir]
+                @store[dir] = dstore = {} unless dstore
+                return unless File.exist? fn
+                open fn do |f|
+                    # first line should only contain "Rant", later
+                    # Rant versions can add version and other
+                    # information
+                    invalid_format(fn) unless f.readline == "Rant\n"
+                    until f.eof?
+                        target_name = f.readline.chomp!
+                        dstore[target_name] = read_target_data(f)
+                    end
+                end
+            rescue
+                invalid_format(fn)
+            end
+
+            def read_target_data(file)
+                h = {}
+                num_of_entries = file.readline.to_i
+                num_of_entries.times { |i|
+                    key = file.readline.chomp!
+                    value = ""
+                    file.readline.to_i.times { |j|
+                        value << file.readline
+                    }
+                    value.chomp!
+                    h[key] = value
+                }
+                h
+            end
+
+            # assumes to be called from the projects root directory
+            def write_dstore(dstore, dir)
+                fn = dir.empty? ? META_FN : File.join(dir, META_FN)
+                target = sigs = key = value = lines = nil
+                open fn, "w" do |f|
+                    f.puts "Rant"
+                    dstore.each { |target, sigs|
+                        f.puts target
+                        f.puts sigs.size
+                        sigs.each { |key, value|
+                            f.puts key
+                            lines = value.split(/\n/)
+                            f.puts lines.size
+                            f.puts lines
+                        }
+                    }
+                end
+            end
+
+            def invalid_format(fn)
+                raise Rant::Error, "The file `#{fn}' is used by " +
+                    "Rant to store meta information, it is in an " +
+                    "invalid state. Check that it doesn't contain " +
+                    "important data, remove it and retry."
+            end
+
+        end
+
+    end # module MetaData
+end # module Rant