autobuild 0.1

data/README

@@ -0,0 +1,284 @@
+= Introduction
+== What's autobuild ?
+Autobuild is a builder for a set of software packages. It takes as input a yaml config file as input and
+
+* imports the package from a SCM or (optionnaly) updates it
+* configures it (for instance for autoconf-based packages)
+* builds and installs it
+
+It takes the dependencies between packages into account in its build process.
+
+== Example config explained
+
+1.  This section is not used at all by autobuild. It is only here to define references 
+    used in the reste of the config file
+
+        variables:
+          - &openrobots ':ext:sjoyeux@cvs.laas.fr/cvs/openrobots'
+          - &openprs_cvs ':ext:sjoyeux@cvs.laas.fr:/usr/local/openprs/CVS-Repository'
+          - &compilers [ "CC=gcc-3.3", "CXX=g++-3.3" ]
+          - &global_prefix /home/doudou/laas/openrobots
+
+2.  <tt>autobuild-config</tt> holds the configuration of the build tool itself. See the
+    <b>Autobuild configuration</b> section for the available configuration options.
+
+        autobuild-config:
+          srcdir: &srcdir /home/doudou/laas/openrobots/tools
+          prefix: &prefix /home/doudou/laas/openrobots/build/tools
+          clean-log: true
+        
+          mail:
+            to: sjoyeux@laas.fr
+        
+          environment:
+            PATH: [ "/bin", "/usr/bin" ]
+            LD_LIBRARY_PATH:
+            PKG_CONFIG_PATH:
+
+3.  +programs+ defines the tools autobuild should use instead of the its default values.
+    See each the rest of the documentation to know what values are used.
+
+        programs:
+           aclocal: "aclocal-1.9"
+           automake: "automake-1.9"
+
+ 
+4.  the +packages+ sections is where packages are defined
+
+        packages:
+
+5.  options in <tt>common-config</tt> are merged in each package configuration. See 
+    <b>Configuring packages</b> for the detailed merging rules.
+
+            common-config:
+                configureflags: *compilers
+                prefix: ""
+
+6.  Tell autobuild to build the pocolibs package. Two common options here: 
+    *type*::    the builder to use. Available package types are currently +autotools+,
+                +import+ and +genom+ (a tool used at my lab;)). See the <b>Available
+                package types</b> section for their configuration.
+    *import*::  the importer to use. Source definition for the importer is always in 
+                the +source+ option.
+    
+            pocolibs:
+                type: autotools
+                import: cvs
+                source: [ *openrobots, pocolibs ]
+
+   
+7. Autobuild takes the dependencies between packages into account. Just list in +depends+ 
+   the packages which should be installed before this one is built.
+
+            genom:
+                type: autotools
+                import: cvs
+                source: [ *openrobots, genom ]
+                depends: pocolibs
+
+
+
+
+
+= Configuration file
+
+The config file is {a Yaml file}[http://yaml4r.sourceforge.net/cookbook]. It is a hash where 
+each element is a section:
+
+  section1:
+    option1: value
+    option2: value
+  section2:
+
+In the documentation, I'll sometime use paths to reference the config options. For instance, 
++option1+ is <tt>section1/option1</tt>. The +to+ option in the configuration example
+is <tt>autobuild-config/mail/to</tt>
+  
+Autobuild uses three sections:
+
+<b>autobuild-config</b>::   main autobuild configuration. See <b>Autobuild configuration</b> below
+*programs*::                the programs used by importers and builders. See each tool 
+                            documentation for the list of used options
+*packages*::                the list of packages to build. See <b>Package configuration</b> below
+
+
+== Autobuild configuration (<tt>autobuild-config</tt>)
+=== Misc options
+*noupdate*::  if true, do not update the packages that are already imported (default: false). You
+              can also add the <tt>--noupdate</tt> on the command line
+
+=== Directories (<tt>autobuild-config/srcdir</tt>, <tt>autobuild-config/prefix</tt> and <tt>autobuild-config/logdir</tt>)
+*srcdir*::    the path where programs are to be imported. See <b>Packages configuration</b> for 
+              more information on how this option is used.
+*prefix*::    the path where programs are to be installed. See <b>Packages configuration</b> for more 
+              information on how this option is used.
+*logdir*::    by default, autobuild does not displays the output of each subcommand it launches. 
+              Insteads, it saves this output in log files. These log files are saved in +logdir+. 
+              The default value is <tt>prefix/autobuild</tt>
+<b>clean-log</b>:: if we must remove all logfiles before each autobuild run or if we should append to them. The
+                   default is +true+, that is log files are removed. Note that if mailing is active, all log 
+                   files are attached to notification mail.
+
+
+=== Environment (<tt>autobuild-config/environment</tt>)
+The <tt>autobuild-config/environment</tt> section lists the initial values for 
+the environment variables. While packages builders shall update the environment 
+variables as needed, you can have to set up a proper initial environment. Arrays 
+are converted into strings by joining elements by ':'
+
+For instance
+    autobuild-config:
+          environment:
+            PATH: [ "/bin", "/usr/bin" ]
+            LD_LIBRARY_PATH:
+            PKG_CONFIG_PATH:
+
+sets
+
+    PATH="/bin:/usr/bin"
+    LD_LIBRARY_PATH=""
+    PKG_CONFIG_PATH=""
+
+
+=== Mail (<tt>autobuild-config/mail</tt>)
+If you want to receive a mail when the build has finished (on success and failures), set
+at least the +to+ option, like this:
+
+    autobuild-config:
+        mail:
+            from: autobuild@mymachine.rubyrules.org
+            to: myself+autobuild@rubyrules.org
+            smtp: localhost
+
+Other options are:
+*from*:: what to set in the <tt>From:</tt> field, default is <tt>autobuild@hostname</tt>
+*smtp*:: the stmp server to use. Default is +localhost+
+
+All log files relative to the current build are attached to the mail.
+
+
+
+== Configuring packages (<tt>packages/*</tt>)
+=== The <tt>packages/common-config</tt> section
+If you want to add common options in each package, just set it them here. Note that the options
+are /merged/ in the package config. It neither replaces the values in the package nor be replaced
+by them. The merging strategy depends on the way the <tt>common-config</tt> is specified:
+* if it is an array, the package option is converted to an array and the common option is appended
+* if it is a string, the package option is converted to a string and the common option is appended
+with a space inserted between the two
+* if it is a boolean value, it is <em>overriden</em> by the package value
+* any other values are forbidden
+
+To ease the config file writing, all options that accept arrays also accept a string when there 
+is only one element. <b>Do not</b> do that in the <tt>common-config</tt> option.
+
+=== Package definition
+All subsections of the <tt>packages/</tt> section but <tt>common-config</tt> are package definitions
+The section name is used as the package name. The package definition sets up the importer to get the
+source and the builder to build and install it.
+
+*type*::    the package type. See the <b>Available package types</b> sections
+
+*srcdir*::  where sources are to be imported. If this is a relative path, it is relative to the global
+            <tt>/autobuild-config/srcdir</tt> option. Otherwise, the absolute path is used. If no +srcdir+
+            is given, the package name is used, so that the default import dir is 
+            <em>global srcdir</em>/<em>package_name</em>.
+        
+            *Note* because of most SCM operations, it is forbidden that two packages have the same srcdir.
+            Empty srcdir are forbidden for the same reason.
+
+*importer*::    
+            the importer type. For now, only +cvs+ and +svn+ are available. See the <b>Available importers</b>
+            section.
+
+<b>importer/source</b>:: 
+            where the importer should get the sources. The format of this options depends on
+            the importer used.
+
+*prefix*::  where the program is to be installed. If this is a relative path, it is relative to the global
+            <tt>/autobuild-config/prefix</tt> option. Otherwise, the absolute path is used. If no prefix
+            is given, the package name is used, so that the default install dir is 
+            <em>global prefix</em>/<em>package name</em>
+
+*depends*::     the array of packages that should be built and installed before this one is built. <tt>depends: [ foo ]</tt>
+                is equivalent to <tt>depends: foo</tt>. To make the use of +depends+ in the <tt>common-config</tt> 
+                section possible, this package name is automatically removed from the package +depends+ array.
+*provides*::    defines aliases for this package. As for +depends+, an array with only element can be replaced
+                by the simple value.
+
+== Available importers
+=== CVS (<tt>type: cvs</tt>)
+*source*::  the source specification is a [ repository, module ] array
+*cvsup*::   options to add to cvs up. Defaults to '-dP'
+*cvsco*::   options to add to cvs ci, Defaults to -P
+
+=== Subversion (<tt>type: svn</tt>)
+*source*::  the svn URL. To ease the Yaml nodes reference (the <tt>*ref</tt> form), it can be an array
+            which is then converted into a path by joining the elements with '/'. For instance:
+    
+                packages:
+                    foo:
+                        import: svn
+                        source: [ *my_home_repository, /trunk/foo ]
+
+*svnup*::   options to add to svn up. Defaults to ''
+*svnco*::   options to add to svn co. Defaults to ''
+
+== Available package types (<tt>packages/</tt><em>name</em><tt>/type</tt>)
+=== Source only (<tt>type: import</tt>)
+Use +import+ if you need the package sources but don't need to build it. You just need
+to set up the importer and +srcdir+. +prefix+ is ignored.
+
+    packages:
+        bar:
+            type: import
+            import: cvs
+            source: [ *my_repository, "bar" ]
+            srcdir: &bar_srcdir bar
+
+=== Autotools (<tt>type: autotools</tt>)
+Use this to build GNU autotools-based packages. This handles autoconf-only packages as 
+well as automake-based packages.
+
+==== Configuration programs
+The <tt>autotools</tt> packages use four programs: *autoheader*, *autoconf*, *aclocal*, 
+*automake*. The default values can be overriden in the <tt>/programs</tt> section. For 
+instance, to be sure that automake 1.9 is used, you set
+
+    programs:
+        automake: automake-1.9
+
+Autobuild tries to detect what tools it should run
+* +aclocal+ and +autoheader+ are always used
+* +autoconf+ is used if there is <tt>configure.ac</tt> or <tt>configure.in</tt> in the import dir
+* +automake+ is used if there is a <tt>Makefile.am</tt> file in the import dir
+* you can force to enable or disable any of these four tools in each package config by setting the tool
+  flag to true or false. For instance, if you don't want package +foo+ to use automake, you say
+
+    packages:
+        foo:
+            automake: false
+
+==== Build programs
+The only program used during the build phase is +make+. The make command can too be overriden in the
+<tt>programs</tt> section.
+
+    programs:
+        make: gnumake
+
+==== Other options
+*builddir*::    the directory where the build takes place. For now, it has to be a relative path, 
+                which is added to the import dir. The default value is "build"
+*configureflags*::  array of options to add to the +configure+ command line. To ease the reuse of 
+                    Yaml references (the <tt>*label</tt> form), you can use an array of arrays, in which
+                    case the second array levels are joined using ''. For example if our +foo+ package 
+                    needs the source of the +bar+ package we added as an import package earlier,
+
+                        configureflags: [ [ --with-bar-source=, *srcdir, '/', *bar_srcdir ] ]
+                        depends: bar
+
+= Copyright and license
+Author::    Sylvain Joyeux <sylvain.joyeux@m4x.org>
+Copyright:: Copyright (c) 2005 Sylvain Joyeux
+License::   GPL
+

data/bin/autobuild

@@ -0,0 +1,81 @@
+#! /usr/bin/ruby -w
+
+# :main: README
+
+require 'rake'
+require 'ostruct'
+require 'optparse'
+
+require 'autobuild/config'
+require 'autobuild/logging'
+
+def parse_options(args)
+    options = OpenStruct.new
+    options.noupdate = false
+    options.srcdir = nil
+    options.prefix = nil
+    options.builddir = "build"
+    options.logdir = nil
+    $VERBOSE = false
+
+    parser = OptionParser.new do |opts|
+        opts.banner = "Usage: autobuild [options] config.yml"
+        opts.separator ""
+
+        opts.on("--srcdir PATH", "Find or imports sources in PATH") do |p|
+            options.srcdir = p
+        end
+
+        opts.on("--prefix PATH", "Packages are installed in PATH") do |p|
+            options.prefix = p
+            options.logdir = "#{p}/autobuild"
+        end
+
+        opts.on("--logdir", "Where logs are saved (default: <prefix>/autobuild)") do |p|
+            options.logdir = p
+        end
+
+        opts.on("--noupdate", "Do not update already checked-out sources") do
+            options.noupdate = true
+        end
+
+        opts.on("--verbose", "Display output of commands on stdout") do
+            $VERBOSE = true
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+        end
+    end
+
+    parser.parse!(args)
+    if !args[0]
+        puts parser
+        exit
+    end
+
+    [ options, args[0], args[1..-1] ]
+end
+
+# Load the command line options
+options, conffile, targets = parse_options(ARGV)
+Config.load(conffile, options)
+
+$DEBUG = true
+if $DEBUG
+    $trace = true
+end
+
+begin
+    if targets.empty?
+        Task[:default].invoke
+    else
+        targets.each { |t| Task[t.to_sym].invoke }
+    end
+    success
+rescue BuildException => error
+    error(error, "Error during build of #{error.target}")
+    exit(1)
+end
+

data/lib/autobuild/config.rb

@@ -0,0 +1,112 @@
+require 'yaml'
+require 'pathname'
+
+require 'autobuild/logging'
+require 'autobuild/package'
+require 'autobuild/importer'
+
+module Config
+    def self.load(conffile, user_options)
+        data = YAML.load( File.open(conffile) )
+
+        get_autobuild_config(data, user_options)
+        get_package_config(data)
+    rescue ConfigException => error
+        error(error, "Error in config file '#{conffile}'")
+        exit(1)
+    rescue ImportException => error
+        error(error, "Error: unable to import #{p}")
+        exit(1)
+    end
+
+    def self.get_autobuild_config(data, options)
+        $PROGRAMS = (data["programs"] or "make")
+        
+        setup = data["autobuild-config"]
+        raise ConfigException, "no autobuild-config block" if !setup
+            
+        $SRCDIR = (options.srcdir or setup["srcdir"])
+        $PREFIX = (options.prefix or setup["prefix"])
+        if !$SRCDIR || !$PREFIX
+            raise ConfigException, "you must at least set srcdir and prefix in the config files"
+        end
+
+        $LOGDIR = (options.logdir or setup["logdir"] or "#{$PREFIX}/autobuild")
+
+        FileUtils.mkdir_p $SRCDIR if !File.directory?($SRCDIR)
+        FileUtils.mkdir_p $LOGDIR if !File.directory?($LOGDIR)
+        if setup["clean-log"]
+            puts "Cleaning log dir #{$LOGDIR}"
+            FileUtils.rm_rf Dir.glob("#{$LOGDIR}/*")
+        end
+
+        $MAIL = setup["mail"]
+        $NOUPDATE = (options.noupdate or setup["noupdate"] or false)
+
+        envvars = setup["environment"]
+        envvars.each { |k, v|
+            ENV[k] = ( v.to_a.collect { |path| path.to_a.join("") }.join(":") )
+        }
+    end
+
+    def self.add_package(name, config)
+        # Get the package type
+        package_type = config[:type].to_sym
+        require "autobuild/packages/#{package_type}"
+
+        # Build the importer object, if there is one
+        import_type = config[:import]
+        if import_type
+            require "autobuild/import/#{import_type}"
+            if !config.has_key?(:source)
+                raise ConfigException, "missing 'source' option in the '#{name}' package description"
+            end
+
+            config[:import] = Import.method(import_type).call(config[:source], config)
+        end
+
+        # Set the default dir if needed
+        config[:srcdir] ||= name
+        config[:prefix] ||= name
+
+        # Build the rake rules for this package
+        Package.build(package_type, name, config)
+    end
+
+    # Get the package config
+    def self.get_package_config(data)
+        setup = data["packages"]
+        
+        # Get the common config block
+        common_config = Hash.new
+        setup["common-config"].each { |k, v| common_config[k.to_sym] = v } if setup.has_key?("common-config")
+
+        setup.each do |p, yml_config|
+            next if p == "common-config"
+
+            # Change keys into symbols
+            config = {}
+            yml_config.each do |k, v|
+                config[k.to_sym] = v
+            end
+
+            # Merge the common config
+            config = config.merge(common_config) { |k, v1, v2|
+                if v2.respond_to?(:to_ary)
+                    v1.to_a | v2.to_ary
+                elsif v2.respond_to?(:to_str)
+                    v1.to_s + " " + v2.to_str
+                end
+            }
+            # Remove p -> p dependency which may come from common_config
+            if config.has_key?(:depends)
+                config[:depends] = config[:depends].to_a.find_all { |el| el != p }
+            end
+
+            add_package(p, config)
+        end
+    end
+
+    private_class_method :get_autobuild_config, :get_package_config, :add_package
+end
+

data/lib/autobuild/environment.rb

@@ -0,0 +1,16 @@
+def pathvar(path, varname)
+    if File.directory?(path)
+        oldpath = ENV[varname]
+        if oldpath.empty?
+            ENV[varname] = path
+        else
+            ENV[varname] = "#{oldpath}:#{path}"
+        end
+    end
+end
+
+def update_environment(newprefix)
+    pathvar("#{newprefix}/bin", 'PATH')
+    pathvar("#{newprefix}/lib/pkgconfig", 'PKG_CONFIG_PATH')
+end
+

data/lib/autobuild/import/cvs.rb

@@ -0,0 +1,47 @@
+require 'autobuild/subcommand'
+require 'autobuild/importer'
+
+class CVSImporter < Importer
+    def initialize(root, name, options)
+        @root = root
+        @module = name
+
+        @program = ($PROGRAMS[:cvs] || 'cvs')
+        @up = (options[:cvsup] || '-dP')
+        @co = (options[:cvsco] || '-P')
+    end
+
+    private
+
+    def update(package)
+        Dir.chdir(package.srcdir) {
+            begin
+                subcommand(package.target, 'cvs', "#{@program} up #{@up}")
+            rescue SubcommandFailed => e
+                raise ImportException.new(e), "failed to update #{modulename}"
+            end
+        }
+    end
+
+    def checkout(package)
+        head, tail = File.split(package.srcdir)
+        cvsroot = @root
+        modulename = @module
+           
+        FileUtils.mkdir_p(head) if !File.directory?(head)
+        Dir.chdir(head) {
+            begin
+                subcommand(package.target, 'cvs', "#{@program} -d #{cvsroot} co #{@co} -d #{tail} #{modulename}")
+            rescue SubcommandFailed => e
+                raise ImportException.new(e), "failed to check out #{modulename}"
+            end
+        }
+    end
+end
+
+module Import
+    def self.cvs(source, package_options)
+        CVSImporter.new(source[0], source[1], package_options)
+    end
+end
+

data/lib/autobuild/import/svn.rb

@@ -0,0 +1,39 @@
+require 'autobuild/subcommand' 
+require 'autobuild/importer'
+
+class SVNImporter < Importer
+    def initialize(source, options)
+        @source = source.to_a.join("/")
+
+        @program = ($PROGRAMS[:svn] || 'svn')
+        @up = options[:svnup]
+        @co = options[:svnco]
+    end
+
+    private
+
+    def update(package)
+        Dir.chdir(package.srcdir) {
+            begin
+                subcommand(package.target, 'svn', "#{program} up #{@up}")
+            rescue SubcommandFailed => e
+                raise ImportException.new(e), "failed to update #{modulename}"
+            end
+        }
+    end
+
+    def checkout(package)
+        begin
+            subcommand(package.target, 'svn', "#{program} co #{@co} #{@source} #{package.srcdir}")
+        rescue SubcommandFailed => e
+            raise ImportException.new(e), "failed to check out #{modulename}"
+        end
+    end
+end
+
+module Import
+    def self.svn(source, options)
+        SVNImporter.new(source, options)
+    end
+end
+

data/lib/autobuild/importer.rb

@@ -0,0 +1,24 @@
+class Importer
+    def import(package)
+        srcdir = package.srcdir
+        if File.directory?(srcdir)
+            if $NOUPDATE
+                puts "Not updating #{package.target} since noupdate is set"
+                return
+            end
+
+            update(package)
+
+        elsif File.exists?(srcdir)
+            raise ImportException, "#{srcdir} exists but is not a directory"
+        else
+            begin
+                checkout(package)
+            rescue ImportException => error
+                FileUtils.rm_rf package.srcdir
+                raise error
+            end
+        end
+    end
+end
+

data/lib/autobuild/logging.rb

@@ -0,0 +1,105 @@
+require 'rmail'
+require 'rmail/serialize'
+require 'net/smtp'
+require 'socket'
+
+class SubcommandFailed < Exception
+    attr_reader :target, :command, :logfile, :status
+    def initialize(target, command, logfile, status)
+        @target = target
+        @command = command
+        @logfile = logfile
+        @status = status
+    end
+end
+        
+class ConfigException < Exception
+    def mail?; false end
+end
+
+class ImportException < SubcommandFailed
+    def mail?; true end
+
+    def initialize(subcommand)
+        super(subcommand.target, subcommand.command, subcommand.logfile, subcommand.status)
+    end
+end
+class BuildException < SubcommandFailed
+    def mail?; true end
+
+    def initialize(subcommand)
+        super(subcommand.target, subcommand.command, subcommand.logfile, subcommand.status)
+    end
+end
+
+def success
+    message = "Build finished successfully at #{Time.now}"
+    puts message
+    send_mail("Build success", message) if $MAIL
+end
+
+def error(object, place)
+    if object.kind_of?(SubcommandFailed)
+        body = <<EOF
+#{place}: #{object.message}
+    command '#{object.command}' failed with status #{object.status}
+    see #{File.basename(object.logfile)} for details
+EOF
+
+        message = <<EOF
+#{place}: #{object.message}
+    command '#{object.command}' failed with status #{object.status}
+    see #{object.logfile} for details
+EOF
+    else
+        body = message = "#{place}: #{object.message}"
+    end
+
+    puts message
+    send_mail("Build failed", body) if $MAIL
+end
+
+module RMail
+    class Message
+        def add_file(path, content_type='text/plain')
+            part = RMail::Message.new
+            part.header.set('Content-Type', content_type)
+            part.header.set('Content-Disposition', 'attachment', 'filename' => File.basename(path))
+            part.body = ''
+            File.open(path) do |file|
+                part.body << file.readlines.join("\n")
+            end
+            self.add_part(part)
+        end
+    end
+end
+
+def send_mail(subject, body)
+    from = ($MAIL['from'] || "autobuild@#{Socket.gethostname}")
+    to = $MAIL['to']
+    smtp = ($MAIL['smtp']  || "localhost" )
+
+    mail = RMail::Message.new
+    mail.header.date = Time.now
+    mail.header.from = from
+    mail.header.to = to
+    mail.header.subject = subject
+
+    part = RMail::Message.new
+    part.header.set('Content-Type', 'text/plain')
+    part.body = body
+    mail.add_part(part)
+
+    # Attach log files
+    Dir.glob("#{$LOGDIR}/*.log") do |file|
+        mail.add_file(file)
+    end
+
+    # Send the mail
+    smtp = Net::SMTP.new(smtp, Integer($MAIL['port'] || 25))
+    smtp.start {
+        smtp.send_mail RMail::Serialize.write('', mail), from, to
+    }
+end
+
+

data/lib/autobuild/package.rb

@@ -0,0 +1,83 @@
+require 'autobuild/timestamps'
+require 'autobuild/environment'
+require 'autobuild/subcommand'
+
+class Package
+    @@packages = {}
+
+    attr_reader :dependencies
+    attr_reader :target, :srcdir, :prefix
+
+    def installstamp; "#{prefix}/#{target}-#{STAMPFILE}" end
+    def self.[](target); @@packages[target] end
+
+    def initialize(target, options)
+        @target = Package.name2target(target)
+        raise ConfigException, "Package #{target} is already defined" if Package[target]
+            
+        @options = options
+        @dependencies = Array.new
+        @provides = Array.new
+
+        srcdir, prefix = 
+            (options[:srcdir] or target.to_s),
+            (options[:prefix] or "")
+
+        srcdir = File.expand_path(srcdir, $SRCDIR)
+        prefix = File.expand_path(prefix, $PREFIX)
+
+        @srcdir, @prefix = srcdir, prefix
+        @import = options[:import]
+        @import.import(self) if @import
+
+        file installstamp
+        task @target => installstamp
+
+        @options[:depends].to_a.each { |p| depends_on(p) }
+        @options[:provides].to_a.each { |p| provides(p) }
+        @@packages[target] = self
+    end
+
+    @@factories = Hash.new
+
+    def depends_on(p)
+        p = Package.name2target(p)
+        raise :bla if !(Symbol === p)
+        task target => p
+        puts "#{target} depends on #{p}"
+
+        @dependencies << p
+    end
+
+    def provides(p)
+        p = Package.name2target(p)
+        @@packages[p] = self 
+        puts "Defining #{p} as an alias to #{target}"
+        task p => target
+
+        @provides << p
+    end
+
+    def self.all; @@packages; end
+    def self.name2target(name)
+        if name.respond_to?(:to_str)
+            name.to_str.gsub(/-\//, '_').to_sym
+        elsif name.respond_to?(:to_sym)
+            name.to_sym
+        else
+            raise TypeError, "expected either a symbol or a string, got #{name.class}"
+        end
+    end
+    def self.factory(type, klass)
+        @@factories[type] = klass
+    end
+    def self.build(type, name, options)
+        raise ConfigException, "#{type} is not a valide package type" if !@@factories.has_key?(type)
+
+        target = name2target(name)
+        task :default => [ target ]
+        raise ConfigException, "there is already a package named #{target}" if Package[target]
+        return @@factories[type].new(target, options)
+    end
+end
+

data/lib/autobuild/packages/autotools.rb

@@ -0,0 +1,115 @@
+require 'autobuild/timestamps'
+require 'autobuild/environment'
+require 'autobuild/package'
+require 'autobuild/subcommand'
+
+class Autotools < Package
+    factory :autotools, self
+
+    attr_reader :builddir
+
+    def buildstamp; 
+        "#{builddir}/#{target}-#{STAMPFILE}"
+    end
+
+    def initialize(target, options)
+        super(target, options)
+
+        @builddir = (options[:builddir] || "build")
+        raise ConfigException, "Autotools packages need a non-empty builddir" if (@builddir.nil? || @builddir.empty?)
+        raise ConfigException, "No support for absolute builddirs" if (Pathname.new(@builddir).absolute?)
+        @builddir = File.expand_path(builddir, srcdir)
+
+        regen_targets
+
+        file "#{builddir}/config.status" => "#{srcdir}/configure" do
+            configure
+        end
+
+        source_tree srcdir, builddir
+        file srcdir => dependencies if !dependencies.empty?
+        file buildstamp => [ srcdir, "#{builddir}/config.status" ] do 
+            build
+        end
+        file installstamp => [ buildstamp ] do 
+            install
+            update_environment(prefix)
+        end
+        update_environment(prefix)
+    end
+
+    def regen_targets
+        conffile = "#{srcdir}/configure"
+        if File.exists?("#{conffile}.ac")
+            file conffile => [ "#{conffile}.ac" ]
+        else
+            file conffile => [ "#{conffile}.in" ]
+        end
+        file conffile do
+            Dir.chdir(srcdir) {
+                $PROGRAMS["aclocal"] ||= "aclocal"
+                $PROGRAMS["autoconf"] ||= "autoconf"
+                $PROGRAMS["autoheader"] ||= "autoheader"
+                $PROGRAMS["automake"] ||= "automake"
+
+                begin
+                    subcommand(target, "configure", $PROGRAMS["aclocal"]) if @options[:aclocal]
+                    subcommand(target, "configure", $PROGRAMS["autoconf"]) if @options[:autoconf]
+                    subcommand(target, "configure", $PROGRAMS["autoheader"]) if @options[:autoheader]
+                    subcommand(target, "configure", $PROGRAMS["automake"]) if @options[:automake]
+                rescue SubcommandFailed => e
+                    raise BuildException.new(e), "failed to build the configure environment of #{target}"
+                end
+            }
+        end
+    end
+
+    def configure
+        if File.exists?(builddir) && !File.directory?(builddir)
+            raise BuildException, "#{builddir} already exists but is not a directory"
+        end
+
+        FileUtils.mkdir_p builddir if !File.directory?(builddir)
+        Dir.chdir(builddir) {
+            command = "#{srcdir}/configure --no-create --prefix=#{prefix}"
+
+            configureflags = @options[:configureflags].to_a.collect { |item|
+                item.to_a.join("")
+            }.join(" ")
+            command += " #{configureflags}" if !configureflags.empty?
+            
+            begin
+                subcommand(target, "configure", command)
+            rescue SubcommandFailed => e
+                raise BuildException.new(e), "failed to configure #{target}"
+            end
+        }
+    end
+
+    def build
+        Dir.chdir(builddir) {
+            begin
+                subcommand(target, "build", "./config.status")
+                $PROGRAMS["make"] ||= "make"
+                subcommand(target, "build", $PROGRAMS["make"])
+            rescue SubcommandFailed => e
+                raise BuildException.new(e), "failed to build #{target}"
+            end
+        }
+        touch_stamp(buildstamp)
+    end
+
+    def install
+        Dir.chdir(builddir) {
+            make = ($PROGRAMS["make"] or "make")
+            begin
+                subcommand(target, "install", "#{make} install")
+            rescue SubcommandFailed => e
+                raise BuildException.new(e), "failed to install #{builddir}"
+            end
+        }
+        touch_stamp(installstamp)
+    end
+end
+
+

data/lib/autobuild/packages/genom.rb

@@ -0,0 +1,70 @@
+require 'autobuild/packages/autotools'
+
+class GenomModule < Autotools
+    def initialize(target, options)
+        super(target, options)
+        get_requires
+        get_provides
+    end
+
+    def genomstamp; "#{srcdir}/.genom/genom-stamp" end
+
+    def get_requires
+        File.open("#{srcdir}/#{target}.gen") do |f|
+            f.each_line { |line|
+                if line =~ /^require\s*:\s*([\w\-]+(?:\s*,\s*[\w\-]+)*);/
+                    $1.split(/, /).each { |name| 
+                        depends_on name
+                        file genomstamp => Package.name2target(name)
+                    }
+                elsif line =~ /^require/
+                    puts "failed to math #{line}"
+                end
+            }
+        end
+    end
+
+    def get_provides
+        File.open("#{srcdir}/configure.ac.user") do |f|
+            f.each_line { |line|
+                if line =~ /^\s*EXTRA_PKGCONFIG\s*=\s*"?([\w\-]+(?:\s+[\w\-]+)*)"?/
+                    $1.split(/\s+/).each { |pkg|
+                        provides pkg
+                    }
+                end
+            }
+        end
+    end
+        
+
+    def regen_targets
+        file buildstamp => genomstamp
+        file genomstamp => [ :genom, "#{srcdir}/#{target}.gen" ] do
+            Dir.chdir(srcdir) {
+                cmdline = "genom " + @options[:genomflags].to_a.join(" ") + " #{target}"
+                begin
+                    subcommand(target, 'genom', cmdline)
+                rescue SubcommandFailed => e
+                    raise BuildException.new(e), "failed to generate module #{target}"
+                end
+            }
+        end
+
+        acuser = "#{srcdir}/configure.ac.user"
+        if File.exists?(acuser)
+            file "#{srcdir}/configure" => acuser do
+                # configure does not depend on the .gen file
+                # since the generation takes care of rebuilding configure
+                # if .gen has changed
+                begin
+                    subcommand(target, 'genom', cmdline)
+                rescue SubcommandFailed => e
+                    raise BuildException.new(e), "failed to generate module #{target}"
+                end
+            end
+        end
+    end
+
+    factory :genom, self
+end
+

data/lib/autobuild/packages/import.rb

@@ -0,0 +1,19 @@
+require 'autobuild/timestamps'
+require 'autobuild/package'
+
+class ImporterPackage < Package
+    def installstamp
+        "#{srcdir}/#{STAMPFILE}"
+    end
+    def initialize(target, options)
+        super(target, options)
+        source_tree srcdir, installstamp
+        file installstamp => srcdir do 
+            touch_stamp installstamp
+        end
+    end
+
+    factory :import, ImporterPackage
+end
+
+

data/lib/autobuild/subcommand.rb

@@ -0,0 +1,32 @@
+require 'autobuild/logging'
+
+def subcommand(target, type, command)
+    logname = "#{$LOGDIR}/#{target}-#{type}.log"
+    puts "#{target}: running #{command}\n    (output goes to #{logname})"
+
+    status = File.open(logname, "a") { |logfile|
+        pid = fork { 
+            if $VERBOSE
+                $stderr.dup.reopen(logfile.dup)
+                $stdout.dup.reopen(logfile.dup)
+            else
+                $stderr.reopen(logfile.dup)
+                $stdout.reopen(logfile.dup)
+            end
+           
+            if !exec(*command.split(" "))
+                raise "Error running command"
+            end
+        }
+        childpid, childstatus = Process.wait2(pid)
+        childstatus
+    }
+
+    if status.exitstatus > 0
+        raise SubcommandFailed.new(target, command, logname, status.exitstatus)
+        return false
+    else
+        return true
+    end
+end
+

data/lib/autobuild/timestamps.rb

@@ -0,0 +1,48 @@
+require 'find'
+require 'rake/tasklib'
+
+STAMPFILE = "autobuild-stamp"
+
+def tree_timestamp(path, *exclude)
+    latest = Time.at(0)
+    latest_file = ""
+    dot = "."[0]
+
+    exclude.collect! { |e| File.expand_path(e, path) }
+    Find.find(path) { |p|
+        Find.prune if File.basename(p)[0] == dot
+        exclude.each { |pattern| 
+            Find.prune if File.fnmatch?(pattern, p) 
+        }
+        next if File.directory?(p)
+
+        p_time = File.mtime(p)
+        if latest < p_time
+            latest = p_time
+            latest_file = p
+        end
+    }
+
+    return latest
+end
+
+class SourceTreeTask < Task
+    attr_accessor :exclude
+    def timestamp
+        tree_timestamp(name, "*CVS", *@exclude)
+    end
+end
+def source_tree(path, exclude, &block)
+    task = SourceTreeTask.define_task(path, &block)
+    task.exclude = exclude
+end
+        
+def get_stamp(stampfile)
+    return Time.at(0) if !File.exists?(stampfile)
+    return File.mtime(stampfile)
+end
+
+def touch_stamp(stampfile)
+    File.open(stampfile, "w") { |*| }
+end
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: autobuild
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2005-08-31 00:00:00 +02:00
+summary: Rake-based utility to build and install multiple packages with dependencies
+require_paths: 
+  - lib
+  - lib
+email: sylvain.joyeux@m4x.org
+homepage: 
+rubyforge_project: 
+description: "autobuild imports, configures, builds and installs software packages (mainly 
+  C/C++ autotools packages for now) with dependencies. It can be used in 
+  community-based software development to make sure that nothing is broken in the
+  build process of a set of packages."
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Sylvain Joyeux
+files: 
+  - lib/autobuild/config.rb
+  - lib/autobuild/importer.rb
+  - lib/autobuild/package.rb
+  - lib/autobuild/timestamps.rb
+  - lib/autobuild/logging.rb
+  - lib/autobuild/subcommand.rb
+  - lib/autobuild/environment.rb
+  - lib/autobuild/import/cvs.rb
+  - lib/autobuild/import/svn.rb
+  - lib/autobuild/packages/autotools.rb
+  - lib/autobuild/packages/genom.rb
+  - lib/autobuild/packages/import.rb
+  - bin/autobuild
+  - README
+test_files: []
+rdoc_options: 
+  - "--title"
+  - Autobuild
+  - "--main"
+  - README
+extra_rdoc_files: 
+  - README
+executables: 
+  - autobuild
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rake
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: rmail
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: