autobuild 0.2 → 0.3

data/README

@@ -120,6 +120,7 @@ Autobuild uses three sections:
 <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.
+*nice*::      The priority at which autobuild should launch subprocesses
 
 
 === Environment (<tt>autobuild-config/environment</tt>)
@@ -193,7 +194,12 @@ source and the builder to build and install it.
             the importer type. For now, only +cvs+ and +svn+ are available. See the <b>Available importers</b>
             section.
 
-<b>importer/source</b>:: 
+*patch*::   the list of patch we should apply. Patches are applied in order, with -p0. Autobuild
+            remembers the list of already applied patches, and will handle the changes to this list gracefully.
+            Since relative paths for patch files are relative to the autobuild working directory, I recommend 
+            you put absolute paths here.
+
+*source*</b>:: 
             where the importer should get the sources. The format of this options depends on
             the importer used. See Available importers.
 
@@ -279,6 +285,12 @@ The only program used during the build phase is +make+. The make command can too
 = Running autobuild in daemon mode
 The <tt>--daemon</tt> command line options makes autobuild go into daemon mode.
  
+= Changes
+== 0.2 to 0.3
+* added support for patching source code. Add patch: [ patches ] to the package configuration
+* renamed autobuild-config, common-config and clean-log to autobuild, common and clean_log. Autobuild
+  warns if it finds one the previous spelling
+
 = Copyright and license
 Author::    Sylvain Joyeux <sylvain.joyeux@m4x.org>
 Copyright:: Copyright (c) 2005 Sylvain Joyeux

data/bin/autobuild

@@ -6,6 +6,7 @@ require 'rake'
 require 'ostruct'
 require 'optparse'
 
+require 'autobuild/options'
 require 'autobuild/config'
 require 'autobuild/logging'
 require 'daemons'
@@ -13,15 +14,7 @@ require 'daemons'
 DEFAULT_HTTP_PORT = 2000
 
 def parse_options(args)
-    options = OpenStruct.new
-    options.update = false
-    options.srcdir = nil
-    options.prefix = nil
-    options.builddir = "build"
-    options.logdir = nil
-    options.daemonize = false
-    options.use_http = false
-    $VERBOSE = false
+    options = Options.default
 
     parser = OptionParser.new do |opts|
         opts.banner = "Usage: autobuild [options] config.yml"
@@ -31,17 +24,19 @@ def parse_options(args)
         opts.on("--prefix PATH", "Packages are installed in PATH") do |options.prefix|
             options.logdir = "#{options.prefix}/autobuild"
         end
-
         opts.on("--logdir", "Where logs are saved (default: <prefix>/autobuild)") do |options.logdir| end
+
         opts.on("--[no-]update", "Update already checked-out sources") do |options.update| end
-        opts.on("--verbose", "Display output of commands on stdout") do |$VERBOSE| end
 
+        opts.on('--nice NICE', Integer, 'Nice the subprocesses to the given value') do |options.nice| end
         opts.on("--[no-]daemon", "Go into daemon mode") do |options.daemonize| end
         #opts.on("--http [PORT]", Integer, 
         #        "Display a HTTP information page on PORT (PORT default: #{DEFAULT_HTTP_PORT})") do |port| 
         #    options.http = (port || DEFAULT_HTTP_PORT)
         #end
+        opts.on("--[no-]verbose", "Display output of commands on stdout") do |options.verbose| end
         opts.on("--[no-]debug", "Verbose information (for debugging purposes)") do |options.debug| end
+
         opts.on_tail("-h", "--help", "Show this message") do
             puts opts
             exit
@@ -59,14 +54,18 @@ end
 
 # Load the command line options
 options, conffile, targets = parse_options(ARGV)
+
+# make conffile an absolute path since daemonize mode makes
+# / the current directory
+conffile = File.expand_path(conffile, Dir.pwd)
 if options.daemonize
     puts "Going into daemon mode ..."
     Daemons.daemonize 
 end
 
-Config.load(conffile, options)
-
-$trace = $DEBUG = options.debug
+File.open(conffile) do |f|
+    Config.load(f, options)
+end
 
 begin
     if targets.empty?

data/lib/autobuild/config-interpolator.rb

@@ -0,0 +1,96 @@
+class Regexp
+    def each_match(string)
+        string = string.to_str
+        while data = match(string)
+            yield(data)
+            string = data.post_match
+        end
+    end
+end
+
+class UndefinedVariable < Exception
+    attr_reader :name
+    def initialize(name); @name = name end
+end
+
+class Interpolator
+    VarDefKey = 'defines'
+    MatchExpr = '\$\{([^}]+)\}|\$(\w+)'
+    PartialMatch = Regexp.new(MatchExpr)
+    WholeMatch = Regexp.new("^(?:#{MatchExpr})$")
+
+    def self.interpolate(config, parent = nil)
+        Interpolator.new(config, parent).interpolate
+    end
+
+    def initialize(node, parent = nil, variables = {})
+        @node = node
+        @variables = {}
+        @defines = {}
+        @parent = parent
+    end
+
+    def interpolate
+        case @node
+        when Hash
+            @defines = (@node[VarDefKey] || {})
+
+            interpolated = Hash.new
+            @node.each do |k, v|
+                next if k == VarDefKey
+                interpolated[k] = Interpolator.interpolate(v, self)
+            end
+
+            interpolated
+
+        when Array
+            @node.collect { |v| Interpolator.interpolate(v, self) }
+
+        else
+            each_interpolation(@node) { |varname| value_of(varname) }
+        end
+    end
+
+    def value_of(name)
+        if @defines.has_key?(name)
+            value = @defines.delete(name)
+            @variables[name] = each_interpolation(value) { |varname|
+                begin
+                    value_of(varname)
+                rescue UndefinedVariable => e
+                    if e.varname == name
+                        raise "Cyclic reference found in definition of #{name}"
+                    else
+                        raise
+                    end
+                end
+            }
+        elsif @variables.has_key?(name)
+            @variables[name]
+        elsif @parent
+            @parent.value_of(name)
+        else
+            raise UndefinedVariable.new(name), "Interpolated variable #{name} is not defined"
+        end
+    end
+
+    def each_interpolation(value)
+        return value if (!value.respond_to?(:to_str) || value.empty?)
+        
+        # Special case: if 'value' is *only* an interpolation, avoid
+        # conversion to string
+        WholeMatch.each_match(value) do |data|
+            return yield(data[1] || data[2])
+        end
+
+        interpolated = ''
+        data = nil
+        PartialMatch.each_match(value) do |data|
+            varname = data[1] || data[2]
+            interpolated << data.pre_match << yield(varname)
+        end
+        return data ? (interpolated << data.post_match) : value
+    end
+end
+
+

data/lib/autobuild/config.rb

@@ -1,108 +1,80 @@
 require 'yaml'
 require 'pathname'
 
+require 'autobuild/config-interpolator'
 require 'autobuild/logging'
 require 'autobuild/package'
 require 'autobuild/importer'
 
-class Regexp
-    def each_match(string)
-        string = string.to_str
-        while data = match(string)
-            yield(data)
-            string = data.post_match
+class Hash
+    def keys_to_sym
+        inject(Hash.new) do |h, sample|
+            k, v = sample[0], sample[1]
+            if v.respond_to?(:keys_to_sym)
+                h[k.to_sym] = v.keys_to_sym
+            else
+                h[k.to_sym] = v
+            end
+            h
         end
     end
-end
-
-class UndefinedVariable < Exception
-    attr_reader :name
-    def initialize(name); @name = name end
-end
-
-class Interpolator
-    VarDefKey = 'defines'
-    InterpolationMatch = Regexp.new('\$\{([^}]+)\}|\$(\w+)')
-
-    def self.interpolate(config, parent = nil)
-        Interpolator.new(config, parent).interpolate
-    end
-
-    def initialize(node, parent = nil, variables = {})
-        @node = node
-        @variables = {}
-        @defines = {}
-        @parent = parent
-    end
-
-    def interpolate
-        case @node
-        when Hash
-            @defines = (@node[VarDefKey] || {})
 
-            interpolated = Hash.new
-            @node.each do |k, v|
-                next if k == VarDefKey
-                interpolated[k] = Interpolator.interpolate(v, self)
+    def each_recursive(&p)
+        each { |k, v|
+            yield(k, v)
+            if v.respond_to?(:each_recursive)
+                v.each_recursive(&p)
             end
+        }
+    end
+end
 
-            interpolated
-
-        when Array
-            @node.collect { |v| Interpolator.interpolate(v, self) }
-
-        else
-            if @node.respond_to?(:to_str)
-                do_string(@node.to_str) { |varname| value_of(varname) }
-            else
-                @node
+module Config
+    def self.check_backward_compatibility(config)
+        if config.has_key?('autobuild-config')
+            puts 'WARNING: the \'autobuild-config\' block is now named \'autobuild\''
+        end
+        config.each_recursive { |k, v|
+            if k == 'common-config'
+                puts 'WARNING: the \'common-config\' blocks are now named \'common\''
             end
+        }
+        if config["autobuild"] && config["autobuild"]["clean-log"]
+            puts 'WARNING: the \'clean-log\' option is now named \'clean_log\''
         end
     end
 
-    def value_of(name)
-        if @defines.has_key?(name)
-            value = @defines.delete(name)
-            @variables[name] = do_string(value) { |varname|
-                begin
-                    value_of(varname)
-                rescue UndefinedVariable => e
-                    if e.varname == name
-                        raise "Cyclic reference found in definition of #{name}"
-                    else
-                        raise
-                    end
-                end
-            }
-        elsif @variables.has_key?(name)
-            @variables[name]
-        elsif @parent
-            @parent.value_of(name)
+    def self.load(conffile, user_options = Options.nil)
+        case conffile
+        when Hash
+            config = conffile
         else
-            raise UndefinedVariable.new(name), "Interpolated variable #{name} is not defined"
+            data = YAML.load(conffile)
+            config = Interpolator.interpolate(data)
         end
-    end
-
-    def do_string(value)
-        return value if value.empty?
 
-        interpolated = ''
-        data = nil
-        InterpolationMatch.each_match(value) do |data|
-            varname = data[1] || data[2]
-            interpolated << data.pre_match << yield(varname)
+        check_backward_compatibility(config)
+        config = config.keys_to_sym
+        if !config[:autobuild]
+            raise ConfigException, "no autobuild block"
         end
-        return data ? (interpolated << data.post_match) : value
-    end
-end
 
-module Config
-    def self.load(conffile, user_options)
-        data = YAML.load( File.open(conffile) )
-        data = Interpolator.interpolate(data)
+        # Merge user_options into the autobuild block
+        autobuild_config = config[:autobuild]
+        default_options = Options.default
+        user_options.each_pair { |sym, value|
+            if !value.nil?
+                autobuild_config[sym] = value
+            elsif !autobuild_config.has_key?(sym)
+                autobuild_config[sym] = default_options.send(sym)
+            end
+        }
 
-        get_autobuild_config(data, user_options)
-        get_package_config(data)
+        $VERBOSE = config[:verbose]
+        $DEBUG   = config[:debug]
+
+        get_autobuild_config(config)
+        get_package_config(config)
     rescue ConfigException => error
         error(error, "Error in config file '#{conffile}'")
         exit(1)
@@ -111,35 +83,31 @@ module Config
         exit(1)
     end
 
-    def self.get_autobuild_config(data, options)
-        $PROGRAMS = (data["programs"] or "make")
+    def self.get_autobuild_config(config)
+        $PROGRAMS = (config[: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"])
+        autobuild = config[:autobuild]
+        $SRCDIR = autobuild[:srcdir]
+        $PREFIX = autobuild[:prefix]
         if !$SRCDIR || !$PREFIX
-            raise ConfigException, "you must at least set srcdir and prefix in the config files"
+            raise ConfigException, 'you must at least set srcdir and prefix in the config files'
         end
 
-        $LOGDIR = (options.logdir or setup["logdir"] or "#{$PREFIX}/autobuild")
+        $LOGDIR = (autobuild[:logdir] || "#{$PREFIX}/autobuild")
 
         FileUtils.mkdir_p $SRCDIR if !File.directory?($SRCDIR)
         FileUtils.mkdir_p $LOGDIR if !File.directory?($LOGDIR)
-        if setup["clean-log"]
+        if autobuild[:clean_log]
             puts "Cleaning log dir #{$LOGDIR}"
             FileUtils.rm_rf Dir.glob("#{$LOGDIR}/*.log")
         end
 
-        $MAIL = setup["mail"]
-        $UPDATE = options.update
-        $UPDATE = setup["update"] if $UPDATE.nil?
-        $UPDATE = true if $UPDATE.nil?
+        $MAIL   = autobuild[:mail]
+        $UPDATE = autobuild[:update]
+        $NICE   = autobuild[:nice]
 
-        envvars = setup["environment"]
-        envvars.each { |k, v|
-            ENV[k] = v.to_a.join(":")
+        autobuild[:environment].to_a.each { |k, v|
+            ENV[k.to_s] = v.to_a.join(':')
         }
     end
 
@@ -160,41 +128,33 @@ module Config
         end
 
         # Set the default dir if needed
-        config[:srcdir] ||= name
-        config[:prefix] ||= name
+        config[:srcdir] ||= name.to_s
+        config[:prefix] ||= name.to_s
 
         # 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"]
+    def self.get_package_config(config)
+        packages = config[:packages]
+        return if !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
+        common = packages[:common]
+        packages.each do |p, config|
+            next if p == :common
 
             # Merge the common config
-            config = config.merge(common_config) { |k, v1, v2|
+            config = config.merge(common) { |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
+            # Remove p -> p dependency which may come from common
             if config.has_key?(:depends)
-                config[:depends] = config[:depends].to_a.reject { |el| el == p }
+                config[:depends] = config[:depends].to_a.reject { |el| el == p.to_s }
             end
 
             add_package(p, config)

data/lib/autobuild/importer.rb

@@ -8,6 +8,7 @@ class Importer
         if File.directory?(srcdir)
             if $UPDATE
                 update(package)
+                patch(package)
             else
                 puts "Not updating #{package.target}"
                 return
@@ -26,12 +27,52 @@ class Importer
         end
     end
 
-    #    def patch(package)
-    #        patch = $PROGRAMS['patch'] || 'patch'
-    #        # Apply patches, if any
-    #        @options[:patch].to_a.each do |path|
-    #            subcommand(package.target, 'patch', patch
-    #        end
-    #    end
+    private
+    
+    # We assume that package.srcdir already exists (checkout 
+    # is supposed to have been called)
+    def patchlist(package)
+        "#{package.srcdir}/autobuild-patches"
+    end
+
+    def call_patch(package, reverse, file)
+        patch = ($PROGRAMS['patch'] || 'patch')
+        Dir.chdir(package.srcdir) {
+            subcommand(package.target, 'patch', patch, '-p0', (reverse ? '-R' : nil), "<#{file}")
+        }
+    end
+
+    def apply(package, path);   call_patch(package, false, path) end
+    def unapply(package, path); call_patch(package, true, path)   end
+
+    def patch(package)
+        # Get the list of already applied patches
+        patches_file = patchlist(package)
+        cur_patches =   if !File.exists?(patches_file) then []
+                        else
+                            File.open(patches_file) do |f| 
+                                f.readlines.collect { |path| path.rstrip } 
+                            end
+                        end
+
+        # Do not be smart, remove all already applied patches
+        # and then apply the new ones
+        begin
+            while p = cur_patches.pop
+                unapply(package, p) 
+            end
+
+            @options[:patch].to_a.each { |p| 
+                apply(package, p) 
+                cur_patches << p
+            }
+        rescue SubcommandFailed => e
+            raise ImportException.new(e), "can't patch #{package.target} (#{e.message})"
+        ensure
+            File.open(patchlist(package), 'w+') do |f|
+                f.write(cur_patches.join("\n"))
+            end
+        end
+    end
 end
 

data/lib/autobuild/logging.rb

@@ -75,9 +75,9 @@ module RMail
 end
 
 def send_mail(subject, body)
-    from = ($MAIL['from'] || "autobuild@#{Socket.gethostname}")
-    to = $MAIL['to']
-    smtp = ($MAIL['smtp']  || "localhost" )
+    from = ($MAIL[:from] || "autobuild@#{Socket.gethostname}")
+    to = $MAIL[:to]
+    smtp = ($MAIL[:smtp]  || "localhost" )
 
     mail = RMail::Message.new
     mail.header.date = Time.now
@@ -96,7 +96,7 @@ def send_mail(subject, body)
     end
 
     # Send the mail
-    smtp = Net::SMTP.new(smtp, Integer($MAIL['port'] || 25))
+    smtp = Net::SMTP.new(smtp, Integer($MAIL[:port] || 25))
     smtp.start {
         smtp.send_mail RMail::Serialize.write('', mail), from, to
     }

data/lib/autobuild/options.rb

@@ -0,0 +1,15 @@
+Options = Struct.new( :update, :nice,
+        :srcdir, :prefix, :builddir, :logdir, 
+        :verbose, :debug,
+        :daemonize, :use_http )
+
+class Options
+    def self.default
+        default_values = { :update => true, :nice => 0,
+            :srcdir => nil, :prefix => nil, :builddir => nil, :logdir => nil,
+            :verbose => false, :debug => false,
+            :daemonize => false, :use_http => false }
+        Options.new default_values
+    end
+end
+

data/lib/autobuild/packages/genom.rb

@@ -1,4 +1,5 @@
 require 'autobuild/packages/autotools'
+require 'open3'
 
 class GenomModule < Autotools
     def initialize(target, options)
@@ -15,7 +16,7 @@ class GenomModule < Autotools
 
     def get_requires
         cpp = ($PROGRAMS['cpp'] || 'cpp')
-        Open3.popen3("#{cpp} #{cpp_options.join(" ")} #{srcdir}/#{target}.gen") do |in, out, err|
+        Open3.popen3("#{cpp} #{cpp_options.join(" ")} #{srcdir}/#{target}.gen") do |cin, out, err|
             out.each_line { |line|
                 if line =~ /^\s*requires\s*:\s*([\w\-]+(?:\s*,\s*[\w\-]+)*);/
                     $1.split(/, /).each { |name| 

data/lib/autobuild/subcommand.rb

@@ -2,14 +2,19 @@ require 'autobuild/logging'
 
 def subcommand(target, type, *command)
     # Filter nil and empty? in command
-    command = command.reject { |o| o.nil? || (o.respond_to?(:empty?) && o.empty?) }
+    command.reject! { |o| o.nil? || (o.respond_to?(:empty?) && o.empty?) }
     command.collect! { |o| o.to_s }
-
     logname = "#{$LOGDIR}/#{target}-#{type}.log"
     puts "#{target}: running #{command.join(" ")}\n    (output goes to #{logname})"
 
-    status = File.open(logname, "a") { |logfile|
+    input_streams = command.collect { |o| $1 if o =~ /^\<(.+)/ }.compact
+    command.reject! { |o| o =~ /^\<(.+)/ }
+
+    status = File.open(logname, "a") do |logfile|
+        pread, pwrite = IO.pipe
+
         pid = fork { 
+            Process.setpriority(Process::PRIO_PROCESS, 0, $NICE) if $NICE
             if $VERBOSE
                 $stderr.dup.reopen(logfile.dup)
                 $stdout.dup.reopen(logfile.dup)
@@ -17,20 +22,37 @@ def subcommand(target, type, *command)
                 $stderr.reopen(logfile.dup)
                 $stdout.reopen(logfile.dup)
             end
+
+            if !input_streams.empty?
+                pwrite.close
+                $stdin.reopen(pread)
+            end
            
             if !exec(*command)
                 raise "Error running command"
             end
         }
+
+        # Feed the input
+        pread.close
+        begin
+            input_streams.each do |infile|
+                File.open(infile) do |instream|
+                    instream.each_line { |line| pwrite.write(line) }
+                end
+            end
+        rescue Errno::ENOENT => e
+            logfile.puts "Cannot open input files: #{e.message}"
+            raise SubcommandFailed.new(target, command.join(" "), logname, 0), e.message
+        end
+        pwrite.close
+
         childpid, childstatus = Process.wait2(pid)
         childstatus
-    }
+    end
 
     if status.exitstatus > 0
         raise SubcommandFailed.new(target, command.join(" "), logname, status.exitstatus)
-        return false
-    else
-        return true
     end
 end
 

data/test/base.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+require 'rubygems'
+require 'test/unit'
+require 'test/tc_config_interpolation.rb'
+require 'test/tc_config.rb'
+require 'test/tc_subcommand.rb'

data/test/conffile-generator.rb

@@ -0,0 +1,34 @@
+require 'tmpdir'
+require 'erb'
+
+DATADIR = File.dirname(__FILE__)
+
+class ConffileGenerator
+    class << self
+        def tempdir
+            @tmpdir = Dir::tmpdir + "/autobuild-#{Process.uid}"
+            FileUtils.mkdir_p(@tmpdir, :mode => 0700)
+        end
+
+        def dummy(basedir = tempdir)
+            apply(binding, basedir, 'dummy')
+        end
+
+        def clean
+            FileUtils.rm_rf tempdir
+        end
+
+        private
+
+        def apply(binding, basedir, basename)
+            template = File.open(File.join(DATADIR, "#{basename}.ryml")) { |f| f.readlines }.join('')
+            result = ERB.new(template).result(binding)
+
+            yml = File.join(basedir, "#{basename}.yml")
+            File.open(yml, 'w+') { |f| f.write(result) }
+            
+            return yml
+        end
+    end
+end
+

data/test/dummy.ryml

@@ -0,0 +1,24 @@
+defines:
+    global_prefix: <%= "#{basedir}/prefix" %>
+    platform: B21R
+    buildname: i386-linux
+    mail: doudou@melix.net
+    nice: 0
+
+autobuild:
+    prefix: ${global_prefix}/build
+    srcdir: ${global_prefix}/src
+    clean_log: true
+    nice: $nice
+
+    mail:
+        to: $mail
+
+    environment:
+        PATH: [ /bin, /usr/bin, $global_prefix/$buildname/tools/bin ]
+        PKG_CONFIG_PATH: $global_prefix/$buildname/tools/lib/pkgconfig
+        LD_LIBRARY_PATH:
+
+programs:
+    aclocal: aclocal-1.9
+

data/test/tc_config.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'test/conffile-generator'
+require 'autobuild/options'
+require 'autobuild/config'
+
+class TC_Config < Test::Unit::TestCase
+    def setup
+        @conffile = ConffileGenerator.dummy
+        @options_hash = File.open(@conffile) { |f| YAML.load(f) }
+        @options = File.open(@conffile) { |f| Config.load(f, Options.default) }
+    end
+
+    def teardown
+        ConffileGenerator.clean
+    end
+
+    def test_keys_to_sym
+        symed = @options_hash.keys_to_sym
+
+        pass_through = {}
+        symed.each_recursive { |k, v|
+            assert_kind_of(Symbol, k)
+            pass_through[k] = true
+        }
+
+        assert(pass_through[:PATH])
+        assert(pass_through[:prefix])
+        assert(pass_through[:autobuild])
+        assert_kind_of(String, symed[:autobuild][:srcdir])
+    end
+        
+    def test_value_type
+        assert_kind_of(String, $SRCDIR)
+        assert_kind_of(Fixnum, $NICE)
+        assert_equal(0, $NICE)
+    end
+end
+

data/test/tc_config_interpolation.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'yaml'
+require 'autobuild/config-interpolator'
+require 'stringio'
+
+class TC_ConfigInterpolation < Test::Unit::TestCase
+WELL_FORMED = <<EOF
+defines:
+    global_prefix: /home/doudou
+    srcdir: ${global_prefix}/src
+    prefix: ${global_prefix}/build
+    nice: 10
+
+autobuild:
+    srcdir: $srcdir
+    prefix: $prefix
+    nice: $nice
+
+EOF
+        
+    def setup
+        @wellformed = StringIO.open(WELL_FORMED, 'r') { |d| YAML.load(d) }
+    end
+
+    def teardown
+        @wellformed = nil
+    end
+
+    # Check that interpolation matches both forms ${var} and $var
+    def test_match
+        data = @wellformed['defines']['srcdir']
+        all_matches = []
+        Interpolator::PartialMatch.each_match(data) { |m| all_matches << m[1] }
+        assert_equal( ['global_prefix'], all_matches )
+        
+        data = @wellformed['autobuild']['srcdir']
+        all_matches = []
+        Interpolator::PartialMatch.each_match(data) { |m| all_matches << m[2] }
+        assert_equal( ['srcdir'], all_matches )
+    end
+        
+    def test_interpolation
+        data = Interpolator.interpolate(@wellformed)
+        assert_equal('/home/doudou/src', data["autobuild"]["srcdir"])
+        assert_equal('/home/doudou/build', data["autobuild"]["prefix"])
+        assert_equal(10, data["autobuild"]["nice"])
+        assert_kind_of(Fixnum, data["autobuild"]["nice"])
+    end
+end
+

data/test/tc_subcommand.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'fileutils'
+require 'autobuild/options'
+require 'autobuild/config'
+require 'tmpdir'
+
+require 'test/conffile-generator'
+
+TESTDIR = File.join(File.dirname(__FILE__), 'dummy.yml')
+
+class TC_Subcommand < Test::Unit::TestCase
+EXAMPLE_1 = <<EOF
+This is a file
+It will be the first part of the two-part cat
+EOF
+
+EXAMPLE_2 = <<EOF
+This is another file
+It will be the second part of the two-part cat
+EOF
+
+    attr_reader :tmpdir
+    attr_reader :source1, :source2
+    def setup
+        conffile = ConffileGenerator.dummy
+        @tmpdir = File.dirname(conffile)
+
+        options = Options.default
+        options.logdir = tmpdir
+        File.open(conffile) do |confstream|
+            Config.load confstream, options
+        end
+
+        # Write example files
+        @source1 = File.join(tmpdir, 'source1')
+        @source2 = File.join(tmpdir, 'source2')
+        File.open(source1, 'w+') { |f| f.write(EXAMPLE_1) }
+        File.open(source2, 'w+') { |f| f.write(EXAMPLE_2) }
+    end
+
+    def teardown
+        ConffileGenerator.clean
+    end
+
+    def test_subcommand
+        assert_raise(SubcommandFailed) { || subcommand('test', 'copy', 'cat', 'bla') }
+        
+        subcommand('test', 'simple', 'cat', nil, '', source1)
+        assert( FileUtils.identical?(source1, File.join(tmpdir, 'test-simple.log')) )
+
+        subcommand('test', 'use-lt', 'cat', "<#{source1}")
+        assert( FileUtils.identical?(source1, File.join(tmpdir, 'test-use-lt.log')) )
+
+        subcommand('test', 'use-both', 'cat', source1, '-', "<#{source2}")
+        result = File.open( File.join(tmpdir, 'test-use-both.log') ) do |f|
+            f.readlines
+        end
+        assert_equal(EXAMPLE_1 + EXAMPLE_2, result.join(""))
+    end
+end
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: autobuild
 version: !ruby/object:Gem::Version 
-  version: "0.2"
-date: 2005-09-12 00:00:00 +02:00
+  version: "0.3"
+date: 2005-09-13 00:00:00 +02:00
 summary: Rake-based utility to build and install multiple packages with dependencies
 require_paths: 
   - lib
@@ -40,6 +40,8 @@ files:
   - lib/autobuild/package.rb
   - lib/autobuild/subcommand.rb
   - lib/autobuild/timestamps.rb
+  - lib/autobuild/options.rb
+  - lib/autobuild/config-interpolator.rb
   - lib/autobuild/import/cvs.rb
   - lib/autobuild/import/svn.rb
   - lib/autobuild/packages/autotools.rb
@@ -47,7 +49,13 @@ files:
   - lib/autobuild/packages/import.rb
   - bin/autobuild
   - README
-test_files: []
+test_files: 
+  - test/tc_subcommand.rb
+  - test/tc_config_interpolation.rb
+  - test/tc_config.rb
+  - test/dummy.ryml
+  - test/base.rb
+  - test/conffile-generator.rb
 rdoc_options: 
   - "--title"
   - Autobuild
@@ -66,9 +74,9 @@ dependencies:
     version_requirements: !ruby/object:Gem::Version::Requirement 
       requirements: 
         - 
-          - ">"
+          - ">="
           - !ruby/object:Gem::Version 
-            version: 0.0.0
+            version: 0.6.0
       version: 
   - !ruby/object:Gem::Dependency 
     name: rmail