metabuild 0.3

data/Manifest

@@ -0,0 +1,4 @@
+Manifest
+README
+Rakefile
+lib/metabuild.rb

data/README

@@ -0,0 +1,5 @@
+MetaBuild is a ruby "make-like" tool that builds components. 
+It supports tracking of dependencies among components, and a hierarchical reporting facility.
+
+
+See metabuild.rubyforge.org

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('metabuild', '0.3') do |s|
+  s.author = "F. Brault"
+  s.email = "castorpilot@yahoo.com"
+  s.description = "MetaBuild is a ruby make-like tool that builds components. It supports tracking of dependencies among components, and a hierarchical reporting facility."
+  s.url = "http://metabuild.rubyforge.org/"
+  s.project = "metabuild"
+end

data/lib/metabuild.rb

@@ -0,0 +1,1016 @@
+#!/usr/bin/ruby
+
+#
+# MetaBuild is a ruby "make-like" tool that builds components.
+#       
+# Author::  F. Brault
+# Copyright:: Copyright (c) 2010 F. Brault
+# License:: GPL
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#  
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#  
+#    You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#  For further information, see http://rubyforge.org/projects/metabuild/
+#
+
+require 'optparse'
+require 'fileutils'
+require 'digest/sha1'
+require 'forwardable'
+require 'tempfile'
+
+include FileUtils
+
+# This module defines a "meta-make" system in ruby.
+# The goal is to create build directive for a component,
+# along with different targets an depedencies among them ( like in Make).
+# A hierarchical reporting tool is included.
+module Metabuild
+
+  CACHE = ENV.fetch("RBUILD_CACHE", "/work/common/build_cache")
+
+  DEFAULT_TAGS = [
+                 lambda {`uname -p`},
+                 lambda {`uname -o`},
+                 lambda {File.read("/etc/fedora-release")},
+                 lambda {s = ""; 1.upto(ARGV.length-1) {|i| s += ARGV[i]};s}
+                 ]
+  
+  DEFAULT_OPTIONS = {
+                    "clone" => [".", "Path of the SCM clone"],
+                    "cache" => ["no", "Use caching to speed up builds"],
+                    "dependency" => ["yes", "Track dependencies between targets"],
+                    "workspace" => ENV.fetch("WORKSPACE", Dir.pwd),
+                    "logtype" => "text",
+                    "logfile" => "",
+                    "dep_graph" => ["no", "Output Dependency graph in Graphviz dot format"],
+                    "parallel" => ["no", "Run threads in parallel. Make sure that your dependency graph can handle this !"],
+                    }
+
+  # Function to extend fileutils
+
+  # helper function that does (rm -rf dir; mkdir dir; cd dir)
+  def create_goto_dir!(dir)
+    rm_rf dir
+    mkdir_p dir
+    cd dir
+  end
+
+  # helper function that does goes into dir if it exists, or create it and goes into it
+  def cd!(dir)
+    mkdir_p dir unless File.directory? dir
+    cd dir
+  end
+
+    
+  # Mother class for all SCM access, "virtual"
+  class SCM
+
+    attr_accessor :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def cksum
+      raise "Should be implemented in child class"
+    end
+
+    def get_diff
+      raise "Should be implemented in child class"
+    end
+
+    def apply_patch(patch)
+      raise "Should be implemented in child class"
+    end
+
+    def clone(path)
+      raise "Should be implemented in child class"
+    end
+
+  end
+
+  # Git access, uses Grit ruby lib
+  class Git < SCM
+
+    def initialize(path)
+      super
+    end
+
+    # Like running "git diff" in a git repo
+    def get_diff
+      `cd #{path} && git diff` 
+    end
+
+    def apply_patch(patch)
+      pipe = IO.popen("git apply -")
+      pipe.puts patch
+      pipe.close_write
+    end
+
+    def clone(path)
+      raise "unable to clone #{path}" unless system("git clone " + path)
+    end
+
+    # id is the SHA1 of head + of any diff (locals)
+    def cksum
+      `cd #{path};git log --pretty=format:'%H' | head -n 1`.to_i(16) ^ Digest::SHA1.hexdigest(get_diff).to_i(16)
+    end
+
+  end
+
+  # Mother class for reporting. Defines a simple text-based logfile
+  class Log
+
+    attr_accessor :name
+
+    def initialize(name)
+      @name = name
+      @subscript = (defined? $subscript_log and not $subscript_log.nil?) ? true : false
+    end
+
+    # Helper while waiting for Ruby 1.9 and the "env" option in _system_
+    def env_system(cmd, env)
+      str = ""
+      env.each { |k, v| str += "export #{k}=#{v};"}
+      system(str + cmd)
+    end
+
+    # Run a shell command, log if it fails (override in child class)
+    def run(command, env, fail_msg)
+      env_system(command, env)
+    end
+
+    # Run a shell command, no logging (override in child class)
+    def silent(command, env)
+      env_system(command, env)
+    end
+
+    # Run a shell command. Log success +and+ failure (override in child class)
+    def valid(command, env, fail_msg, success_msg)
+      env_system(command, env)
+    end
+
+    # Spawn with env
+    def env_spawn(cmd, env, fail_msg, success_msg)
+      str = ""
+      env.each { |k, v| str += "export #{k}=#{v};"}
+      pid = spawn(str + cmd)
+      return [pid, fail_msg]
+    end
+
+    def parallel_wait(p)
+      pid, stat = Process::waitpid2(p[0])
+      failure p[1] unless stat.success?
+    end
+
+    # Run another ruby build script
+    # Be careful with global variables !!!
+    # By default, the default options values are transmitted to the subscript
+    def script(script, args, options, fail_msg, use_default)
+      $subscript_argv = args.split
+      options.each {|k,v| $subscript_argv.push "--#{k}=#{v}" if (DEFAULT_OPTIONS.has_key?(k) and not args =~ /--#{k}=/)} if use_default
+      $subscript_log = ""
+      begin
+        load(script, true)
+      rescue Exception => exception
+        integrate $subscript_log if $subscript_log != ""
+        if exception.kind_of? SystemExit 
+          failure fail_msg unless exception.success?
+        else
+          failure(fail_msg + "(#{exception.class}: #{exception.message})\n" + exception.backtrace.join("\n")) 
+        end
+      end
+      integrate $subscript_log
+      $subscript_log = nil
+      $subscript_argv = nil
+    end
+    
+    def failure(f)
+      exit false
+    end
+
+    def integrate log
+      raise "Should be implemented in child class"
+    end
+
+    def finish
+      exit true
+    end
+
+    def status
+      false
+    end
+  
+  end    
+
+  # Simple log that just prints out text (for console builds)
+  class LogText < Log
+
+    attr_reader :name, :success, :fail
+
+    def initialize(name)
+      super(name)
+      @fail, @success = [], []
+      @subscripts = []
+      @report_done = false
+    end 
+
+    def add_fail(msg)
+      @fail.push msg
+    end
+
+    def add_success(msg)
+      @success.push msg
+    end
+
+    def report
+      return if @report_done # prevent reporting several times
+      if @subscript
+        $subscript_log = self
+      else
+        output
+      end
+      @report_done = true
+    end
+
+    def output
+      puts "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
+      puts @name
+      puts "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
+      puts "Ran the following subscripts :"
+      @subscripts.each {|s| puts s}
+      puts "----------------------------------------------"
+      puts "Sucess : "
+      @success.each {|s| puts s}
+      puts "----------------------------------------------"
+      puts "Fail : "
+      @fail.each {|s| puts s}
+      puts "----------------------------------------------"
+    end
+
+    def status
+      @fail.empty?
+    end
+
+    # Run a shell command, log if it fails
+    def run(command, env, fail_msg)
+      failure fail_msg unless env_system(command, env)
+    end
+
+    # Run a shell command, no logging
+    def silent(command, env)
+      stop unless env_system(command, env)
+    end
+
+    # Run a shell command. Log success +and+ failure 
+    def valid(command, env, fail_msg, success_msg)
+      if env_system(command, env)
+        add_success success_msg if success_msg != ""
+      else
+        add_fail fail_msg
+      end
+    end
+
+    def integrate log
+      @subscripts.push log.name
+      log.success.each {|s| @success.push("[#{log.name}] " + s)}
+      log.fail.each {|f| @fail.push("[#{log.name}] " + f)}
+    end
+
+    # Stop script, adding a message to the log
+    def failure(msg)
+      add_fail msg
+      stop
+    end
+
+    # Output log and exit with error exit status
+    def stop
+      report
+      exit false
+    end
+
+    def finish
+      report
+      exit status
+    end
+
+  end
+
+  # Html log. For reporting in continuous integration systems, for example.
+  class LogHtml < Log
+
+    attr_reader :name, :html, :success, :fail
+
+    def initialize(name, file)
+      super(name)
+      @file = file
+      @fail, @success = [], []
+      @subscripts = []
+      @report_done = false
+      @html = ""
+      @has_bash = system("bash --version > /dev/null")
+    end 
+
+    def add_fail(cmd, msg, output)
+      @fail.push [cmd, msg, output]
+    end
+
+    def add_success(cmd, msg, output)
+      @success.push [cmd, msg, output]
+    end
+
+    def report
+      return if @report_done # prevent reporting several times
+      fill_html
+      if @subscript
+        $subscript_log = self
+      else
+        output
+      end
+      @report_done = true
+    end
+
+    def fill_html
+
+      top =  "<div class='raised'>\n" +
+             "<b class='b1'></b><b class='b2'></b><b class='b3'></b><b class='b4'></b><div class='boxcontent'>\n"
+      bottom = "</div><b class='b4b'></b><b class='b3b'></b><b class='b2b'></b><b class='b1b'></b></div>\n"
+      red = "<img src='data:image/png;base64,
+                iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAIAAABL1vtsAAAAAXNSR0IArs4c6QAAAWdJREFUOMul
+                VD1zgkAUfF48nDmTIZPEZM6CxgZrCitqKwsaK3+elY2NjY2NFhZQyy8AE5jMkMSLQgIpjjn8jKBb
+                Hrf79i3vXsk0TbgO5cOjUhRVXFdyHMl1se8DQIJxSGlI6YbSqFY7I4EYk+fz+8mk4jjScok9j0ts
+                KA3r9e9G473dZs3mTsntRspB8DgaPYzHZLE46jkm5KPV8judQNePuCgHwdNw+DwY8MpHgRiTZzPe
+                nVBB2bfp9H++SIrY9ku/L5wiflq17Tx8obJ9HwHADWO3lnWq/1Md3VkWse1UAjFWLcIXKpyVuuB6
+                hSBYaRY5U9hLJMviSiA+fIdjexaChQDglxCmqkUlBAvxsV3tjn0eCFbq4kvTWBGVmJBPTctcJBiv
+                VPWt282ZyN59JFQDXc+jkmDMVPW11xOus5f6I8u+YSQYX/7YuYpnGCGll6+cw8UneR4AxJJUYPHx
+                mmtFWStKzr/zB1QX2NNv3dXcAAAAAElFTkSuQmCC'>"
+      green = "<img src='data:image/png;base64,
+                iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAIAAABL1vtsAAAAAXNSR0IArs4c6QAAAWhJREFUOMul
+                lMGKwjAQhsdUUlq2UCIs23oVb148eNUH8AHWJ9wHWB+gexXx0lvx2mQRHIQslgaFPaRkS+tqiv8x
+                zf/1ZzIzve12C8+p3z6STiFc5BQFRekUABBcvUixWLGoZMHVe4DgFJMw3QV7TlG4NUTJYsWmcrQ4
+                TWLF/kVkfr4ebJIw5RQbuaSfZ36e+fm3i8vjbHwe3kBkfv7x+pWEqf7zTXGKn4ONdIrVYW4oxHzT
+                /7/jN4mSMF0PNiYpMac2/jrF3CcAIFzU9bN/SE5xF+yFixWCU+zkNxTtIgAgKGpeJwkXhUFIp7Cs
+                QvOlTS2eFNHN127bhzIuAgCRYlHJuiKikkWKVYhYsUbb28i4iOZN5agTRY+czl7VYnGaLE4Ty4o0
+                7hNDXR5nNhTtXx5nJvXfpI7Pw9VhHly99rDX82v/7WHXlPfL/K1knVZOr707zeLjFH/6BQC8XLzY
+                fvFVPXMe1qPe1y/ZDt7tn1jpQgAAAABJRU5ErkJggg=='>" 
+
+      unless @subscript
+        @html << "<html>\n"
+        @html << "<head>\n"
+        @html << "<script type='text/javascript'>\n"
+        @html << "function toggleMe(a){\n"
+        @html << "var e=document.getElementById(a);\n"
+        @html << "if(!e)return true;\n"
+        @html << "if(e.style.display=='none'){\n"
+        @html << "e.style.display='block'\n"
+        @html << "} else {\n"
+        @html << "e.style.display='none'\n"
+        @html << "}\n"
+        @html << "return true;\n"
+        @html << "}\n"
+        @html << "</script>\n"
+        @html << "<style type='text/css'>\n"
+        @html << "A"
+        @html << "{"
+        @html << "  color:white;"
+        @html << "}"
+        @html << "A:link {color:#000000}"
+        @html << "A:visited {color:#ffffff}"
+        @html << "A:active {color:#ffffff}"
+        @html << "A:hover {background-color: black; color: white}"
+        @html << "div.header"
+        @html << "{"
+        @html << "  text-align: center;"
+        @html << "  margin-left: 100px;"
+        @html << "  margin-right: 100px;"
+        @html << "  margin-bottom: 50px;"
+        @html << "  float: center;"
+        @html << "}"
+        @html << "div.content"
+        @html << "{"
+        @html << "  float:center;"
+        @html << "  margin-left:100px;"
+        @html << "  margin-right:100px;"
+        @html << "}"
+        @html << "div.output"
+        @html << "{"
+        @html << "  float:center;"
+        @html << "  margin-left:100px;"
+        @html << "  margin-right:100px;"
+        @html << "  border-style: dashed;" 
+        @html << "}"
+        @html << ".raised {"
+        @html << "  background:transparent; "
+        @html << "  width:100%;"
+        @html << "}"
+        @html << ".raised h1, .raised p {"
+        @html << "  margin:0 10px;"
+        @html << "  }"
+        @html << ".raised h1 {"
+        @html << "  font-size:2em; "
+        @html << "  }"
+        @html << ".raised p {"
+        @html << "  padding-bottom:0.5em;"
+        @html << "  }"
+        @html << ".raised .b1, .raised .b2, .raised .b3, .raised .b4, .raised .b1b, .raised .b2b, .raised .b3b, .raised .b4b {"
+        @html << "  display:block; "
+        @html << "  overflow:hidden;"
+        @html << "  font-size:1px;"
+        @html << "  }"
+        @html << ".raised .b1, .raised .b2, .raised .b3, .raised .b1b, .raised .b2b, .raised .b3b {"
+        @html << "  height:1px;"
+        @html << "  }"
+        @html << ".raised .b2 {"
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #fff; "
+        @html << "  border-right:1px solid #eee;"
+        @html << "  }"
+        @html << ".raised .b3 {"
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #fff; "
+        @html << "  border-right:1px solid #ddd;"
+        @html << "  }"
+        @html << ".raised .b4 {"
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #fff; "
+        @html << "  border-right:1px solid #aaa;"
+        @html << "  }"
+        @html << ".raised .b4b {"
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #eee; "
+        @html << "  border-right:1px solid #999;"
+        @html << "  }"
+        @html << ".raised .b3b {"
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #ddd; "
+        @html << "  border-right:1px solid #999;"
+        @html << "  }"
+        @html << ".raised .b2b {"
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #aaa; "
+        @html << "  border-right:1px solid #999;"
+        @html << "  }"
+        @html << ".raised .b1 {"
+        @html << "  margin:0 5px; "
+        @html << "  background:#fff;"
+        @html << "  }"
+        @html << ".raised .b2, .raised .b2b {"
+        @html << "  margin:0 3px; "
+        @html << "  border-width:0 2px;"
+        @html << "  }"
+        @html << ".raised .b3, .raised .b3b {"
+        @html << "  margin:0 2px;"
+        @html << "  }"
+        @html << ".raised .b4, .raised .b4b {"
+        @html << "  height:2px; margin:0 1px;"
+        @html << "  }"
+        @html << ".raised .b1b {"
+        @html << "  margin:0 5px; background:#999;"
+        @html << "  }"
+        @html << ".raised .boxcontent {"
+        @html << "  display:block;  "
+        @html << "  background:#ccc; "
+        @html << "  border-left:1px solid #fff; "
+        @html << "  border-right:1px solid #999;"
+        @html << "  }"
+        @html << "</style>\n"
+        @html << "</head><body bgcolor='grey'>\n"
+      end
+      
+      @html << "<div class='header'>\n"
+      @html << top
+      @html << "<h1>#{@name}  "
+      if status
+        @html << green + "</h1><br>\n"
+      else
+        @html << red + "</h1><br>\n"
+      end
+      @html << bottom + "</div>"
+
+      @html << "<div class='content'>\n"
+      @html << top
+      @html << "<p><h2>Subscript run :</h2><br>\n"
+      id = (rand() * 500).to_i # FIXME
+      @subscripts.each do |s|
+        name, status, html = s[0], s[1], s[2]
+        stat = status ? green : red
+        @html << "<div id='para#{id}' style='display:none'>\n"
+        @html << "<div class='output'>\n"
+        @html << html
+        @html << "</div>"
+        @html << "</div>\n"
+        @html << "<br>#{stat} #{name}<input type='button' class='button' onclick='return toggleMe(\"para#{id}\")' value='Show Html log'>\n"
+        id += 1
+      end
+      @html << "<br></p>\n"
+
+      @html << "<p><h2>Tests :</h2><br>\n"
+
+      @fail.each do |s|
+        cmd, msg, output = s[0], s[1], s[2]
+        @html << "<div id='para#{id}' style='display:none'>\n"
+        @html << "<div class='output'>\n"
+        @html << "<pre>" + output + "</pre>"
+        @html << "</div>"
+        @html << "</div>\n"
+        @html << "<br>#{red} #{msg}\n"
+        @html << "<input type='button' class='button' onclick='return toggleMe(\"para#{id}\")' value='Show output'>\n"
+        id += 1
+      end
+
+      @success.each do |s|
+        cmd, msg, output = s[0], s[1], s[2]
+        @html << "<div id='para#{id}' style='display:none'>\n"
+        @html << "<div class='output'>\n"
+        @html << "<pre>" + output + "</pre>"
+        @html << "</div>"
+        @html << "</div>\n"
+        @html << "<br>#{green} #{msg}\n"
+        @html << "<input type='button' class='button' onclick='return toggleMe(\"para#{id}\")' value='Show output'>\n"
+        id += 1
+      end
+
+      @html << "<br></p>\n"
+
+      @html << bottom + "</div>"
+
+      unless @subscript
+        @html << "</body></html>\n"
+      end
+
+    end
+
+    def output
+      File.open(@file, "w") do |f|
+        f.puts @html
+      end
+    end
+
+    def status
+      @fail.empty?
+    end
+
+    def setup_script(cmd, env)
+      file = Tempfile.new("output")
+      file.close
+      script = Tempfile.new("script")
+      if @has_bash
+        script.puts "exec > >(tee #{file.path}) 2>&1" # Redirect output to tmpfile + tee
+      else
+        script.puts "exec > #{file.path} 2>&1" # Redirect output to tmpfile
+      end
+      env.each { |k, v| script.puts "export #{k}=#{v}"}
+      script.puts cmd
+      script.close
+      return script.path, file.path
+    end
+
+    def env_system(cmd, env)
+      script, file = setup_script(cmd, env)
+      puts "@@@@@@@@@@@ Running #{cmd} @@@@@@@@@@@@@"
+      shell = @has_bash ? "bash " : "sh " 
+      success = system(shell + script)
+      output = File.new(file).read.strip
+      File.delete script
+      File.delete file
+      return success, output
+    end
+
+    def env_spawn(cmd, env, fail_msg = "", success_msg = "")
+      script, file, shell = setup_script(cmd, env)
+      puts "@@@@@@@@@@@ Running #{cmd} in background @@@@@@@@@@@@@"
+      pid = spawn(shell + script)
+      return [pid, file, script, cmd, fail_msg, success_msg]
+    end
+
+    def parallel_wait(p)
+      pid, file, script, cmd, fail_msg, success_msg= p[0], p[1], p[2], p[3], p[4], p[5]
+      pid, stat = Process::waitpid2(pid)
+      success = stat.success?
+      output = File.new(file).read.strip
+      File.delete script
+      File.delete file
+      if success
+        add_success cmd, success_msg, output
+      else
+        add_fail cmd, fail_msg, output
+      end
+    end
+
+
+    # Run a shell command, log if it fails
+    def run(command, env, fail_msg)
+      success, output= env_system(command, env)
+      unless success
+        add_fail command, fail_msg, output
+        stop
+      end
+    end
+
+    # Run a shell command, no logging
+    def silent(command, env)
+      success, output = env_system(command, env)
+      stop unless success
+    end
+
+    # Run a shell command. Log success +and+ failure 
+    def valid(command, env, fail_msg, success_msg)
+      success, output = env_system(command, env)
+      if success
+        add_success command, success_msg, output
+      else
+        add_fail command, fail_msg, output
+      end
+    end
+
+    def integrate log
+      if log.kind_of? LogHtml
+        @subscripts.push [log.name, log.status, log.html]
+      else 
+        @subscripts.push [log.name, log.status, ""]
+      end
+    end
+
+    # Stop script, adding a message to the log
+    def failure(msg, cmd = "", output = "")
+      add_fail cmd, msg, output
+      stop
+    end
+
+    # Output log and exit with error exit status
+    def stop
+      report
+      exit false
+    end
+
+    def finish
+      report
+      exit status
+    end
+
+  end
+  # A Target is really at the heart of a build. It handles dependencies, caching ...
+  class Target
+
+    attr_accessor :name, :repo, :tags, :results, :depends, :block, :done
+
+    def initialize(name, repo, depends = [], results = [], tags = [])
+      @name, @repo, @tags, @results, @depends  = name, repo, tags, results, depends
+      @done = false
+      @block = lambda { raise "Target #{@name} has empty code block !" }
+    end
+
+    def to_s
+      @name
+    end
+
+    def add_result res
+      @results.push res
+    end
+
+    def add_dep dep
+      if dep.kind_of? Array
+        @depends = @depends | dep
+      else
+        @depends.push dep
+      end
+    end
+
+    def remove_dep dep
+      @depends.delete dep
+    end
+
+    def each_dep
+      @depends.each do |d|
+        yield d
+      end
+    end
+
+    def each_result
+      @results.each do |r|
+        yield r
+      end
+    end
+
+    # The checksum is a mix of the repository checksum + the default tags + local tags
+    # Default tags include processor type, kernel name, etc.
+    def cksum
+      DEFAULT_TAGS.concat(@tags).inject(@repo.cksum) { |sum, tag|
+        Digest::SHA1.hexdigest(tag.call).to_i(16) ^ sum
+      }.to_s(16)
+    end
+
+    def check_cache
+      File.exist?(CACHE + cksum + ".tgz")
+    end
+
+    def get_cache
+      cmd = "tar zxf " + CACHE + "/" + cksum + ".tgz"
+      raise "Error getting target #{@name} in cache" unless  system(cmd)
+    end
+
+    def update_cache
+      cmd = ":;" + @results.inject("tar zcf " + CACHE + "/" + cksum + ".tgz "){|s, r| s += "#{r} "}
+      raise "Error tar for target #{@name}" unless system(cmd)
+    end
+
+    # Run a block that defines all the steps of the build.
+    # Use caching if asked to.
+    # +Note+ : Whatever the directory changes happening in the block,
+    #          when the block exits, we are in the same directory as when it started
+    def run(use_cache = false)
+      return if @done
+      old_dir = pwd
+      if use_cache
+        if check_cache
+          puts "getting from cache"
+          get_cache
+        else
+          block.call self
+          update_cache
+        end
+      else
+        block.call self
+      end
+      cd old_dir
+      @done = true
+    end
+
+    # Run according to dependency list, from bottom to top
+    def propagate_run(use_cache=false, parallel=false)
+      if parallel
+        each_dep do |d|
+          fork {d.propagate_run(use_cache, parallel)}
+        end
+        Process.waitall unless @depends.empty?
+      else
+        each_dep do |d|
+          d.propagate_run(use_cache, parallel)
+        end
+      end
+      run(use_cache)
+    end
+
+    def propagate_disable
+      each_dep do |d|
+        d.done = true
+        d.propagate_disable
+      end
+    end
+
+    def output_graph
+      each_dep do |d|
+        puts "#{@name} -> #{d.name};"
+      end
+    end
+
+  end
+
+  # A class for parsing command line options
+  class Options
+
+    extend Forwardable
+    attr_reader :opts, :rest, :from_targets
+    def_delegators :@opts, :[], :fetch, :each
+
+    # By default, the following options are set : --help, and DEFAULT_OPTIONS. 
+    # So caching and target dependencies tracking are disabled by default.
+    # h is a hashmap of tuples option_name => default_value
+    def initialize(h)
+      @opts = {}
+      @help = false
+      hash = DEFAULT_OPTIONS.merge(h)
+      @parser = OptionParser.new
+      @parser.on("--help") {|val| @help = true}
+      @from_targets = []
+      @parser.on("--from=[target]", "Disable everything below target in dep tree. Only with dependency=yes") {|val| @from_targets.push val}
+      hash.each do |opt, default|
+        if default.kind_of? Array
+          @parser.on("--#{opt}=[#{default[0]}]", default[1]) {|val| @opts[opt] = val}
+        else 
+          @parser.on("--#{opt}=[#{default}]") {|val| @opts[opt] = val}
+        end
+      end
+      if defined? $subscript_argv and not $subscript_argv.nil?
+        argv = $subscript_argv
+      else
+        argv = ARGV
+      end
+      @rest = @parser.parse(*argv)
+      hash.each do |opt, default|
+        default = default[0] if default.kind_of? Array
+        @opts[opt] = default unless @opts.has_key? opt
+      end
+    end
+
+    def help?
+      @help
+    end
+
+    def help
+      @parser.to_s
+    end
+
+  end
+
+  # The builder class is responsible for triggerring targets and reporting failures or
+  # exceptions via the logging facilities
+  class Builder
+    
+    extend Forwardable
+    attr_accessor :name, :targets, :default_targets, :env
+    def_delegators :@log, :finish
+
+    def initialize(name, options = nil, targets = [])
+      @name, @options, @targets  = name, options, targets
+      raise "Builder needs Options (none given)!" if options.nil?
+      title = "Report for #{name}"
+      @log = case @options.fetch("logtype", "text")
+             when "text" then LogText.new(title)
+             when "html" 
+               raise "Need a logfile for html reports" if @options["logfile"].nil? or @options["logfile"].empty?
+               LogHtml.new(title, @options["logfile"])
+             else raise "Unknown log type #{@options["logtype"]}"
+             end  
+      @default_targets = []
+      @env = {"WORKSPACE" => @options.fetch("workspace", Dir.pwd)}
+      @subprocesses = []
+    end
+
+    def logtitle=(title)
+      @log.name = title
+    end
+
+    def logtitle
+      @log.name
+    end
+
+    # Run targets according to what the user specified in ARGV
+    # Dependencies among targets can be propagated or not (default = no)
+    # Outpout log and stop
+    def launch
+      begin
+        
+        if @options.help?
+          puts @options.help
+          puts "Default targets are built if no targets are given as argument. You can specify any of the targets listed below"
+          puts "Default targets :"
+          @default_targets.each { |t| puts t.name }
+          puts "The following targets are defined :"
+          @targets.each { |t| puts t.name }
+          exit
+        end
+
+        if @options.fetch("dep_graph", "no").downcase == "yes"
+          output_graph
+        end
+
+        @options.from_targets.each do |targ|
+          get_target(targ).propagate_disable
+        end
+
+        use_cache = (@options.fetch("cache", "no").downcase == "yes")
+        parallel = (@options.fetch("parallel", "no").downcase == "yes")
+        targs = @options.rest.empty? ? @default_targets.map {|t| t.to_s} : @options.rest
+        if @options.fetch("dependency", "yes").downcase != "yes"
+          targs.each { |t| targ = get_target(t); targ.run(use_cache) unless targ.nil? }
+        else
+          targs.each { |t| targ = get_target(t); targ.propagate_run(use_cache, parallel) unless targ.nil? }
+        end
+        @log.finish
+      rescue Exception => exception
+        # Uses @report_done in Log to prevent reporting several times
+        if exception.kind_of? SystemExit 
+          @log.failure "Error : target exited with failure code" unless exception.success?
+        else
+          @log.failure("Error in target : (#{exception.class}: #{exception.message})\n" + exception.backtrace.join("\n")) 
+        end
+      end
+    end
+
+    # Output dependencies between targets in Graphviz dot format
+    def output_graph
+      puts "digraph Dependencies {"
+      @targets.each {|t| puts "node [shape=ellipse];#{t.name};"}
+      @targets.each {|t| t.output_graph}
+      puts "}"
+      exit
+    end
+
+    # Run another ruby build script
+    # Be careful with global variables !!!
+    # By default, the default options values are transmitted to the subscript
+    def script(script, args, fail_msg = "FAILED running #{script} #{args}", use_default = true)
+      @log.script(script, args, @options, fail_msg, use_default)
+    end
+
+    # Run a shell command, giving it (optional) env variables (a hashmap), and (optional) failure message
+    # Only log failures.
+    # :call-seq:
+    #   run(:cmd => "cmd", :env => env, :msg => "msg")  -> nil
+    #   run("cmd")                                      -> nil    
+    def run(h)
+      if h.kind_of? String
+        @log.run(h, @env, "#{h} FAIL")
+      else
+        raise "run command needs a non nil command" if h[:cmd].nil?
+        @log.run(h[:cmd], @env.merge(h.fetch(:env, @env)), h.fetch(:msg, "#{h[:cmd]} FAIL"))
+      end
+    end
+
+    # Run a shell command, no logging. Give it (optional) env variables (hashmap)
+    # :call-seq:
+    #   silent(:cmd => "cmd", :env => env)  -> nil
+    #   silent("cmd")                       -> nil    
+    def silent(h)
+      if h.kind_of? String
+        @log.silent(h, @env)
+      else
+        raise "silent command needs a non nil command" if h[:cmd].nil?
+        @log.silent(h[:cmd], @env.merge(h.fetch(:env, {})))
+      end
+    end
+
+    # Run a shell command, giving it (optional) env variables (a hashmap), and (optional) failure message
+    # Log success +and+ failure.
+    # :call-seq:
+    #   valid(:cmd => "cmd", :env => env, :fail_msg => "msg", :success_msg => "msg")    -> nil
+    #   valid("cmd")                                                                    -> nil    
+    def valid(h)
+      if h.kind_of? String
+        @log.valid(h, @env, "#{h} FAIL", "#{h} SUCCESS")
+      else
+        raise "valid command needs a non nil command" if h[:cmd].nil?
+        @log.valid(h[:cmd], @env.merge(h.fetch(:env, {})), h.fetch(:fail_msg, "#{h[:cmd]} FAIL"), h.fetch(:success_msg, "#{h[:cmd]} SUCCESS"))
+      end
+    end
+
+    # Run a shell command in subprocess, giving it (optional) env variables (a hashmap), and (optional) failure message
+    # Use parallel_wait on the returned object _P_ .
+    # :call-seq:
+    #   parallel_valid(:cmd => "cmd", :env => env, :fail_msg => "msg", :success_msg => "msg")    -> P
+    #   parallel_valid("cmd")                                                                    -> P    
+    def parallel_valid(h)
+      if h.kind_of? String
+        p = @log.env_spawn(h, @env, "#{h} FAIL", "#{h} SUCCESS")
+      else
+        raise "valid command needs a non nil command" if h[:cmd].nil?
+        p = @log.env_spawn(h[:cmd], @env.merge(h.fetch(:env, {})), h.fetch(:fail_msg, "#{h[:cmd]} FAIL"), h.fetch(:success_msg, "#{h[:cmd]} SUCCESS"))
+      end
+      @subprocess.push p
+      return p
+    end
+
+    # Wait for a subprocess,  Log success +and+ failure (like valid)  
+    def parallel_wait(p)
+      @log.parallel_wait(p)
+      @subprocess.delete(p)
+    end
+
+    # Wait for a all subprocess,  Log success +and+ failure (like valid)  
+    def parallel_waitall
+      @subprocess.each do |p|
+        @log.parallel_wait(p)
+      end
+      @subprocess = []
+    end
+
+    # Add target, either a single one, or an array of targets
+    def add_target(target)
+      if target.kind_of? Array
+        @targets = @targets | target
+      else
+        @targets.push target
+      end
+    end
+
+    def remove_target(target)
+      @targets.delete target
+    end
+
+    def get_target(name)
+      @targets.each do |t|
+        return t if t.name == name
+      end
+      raise "Unkonwn target #{name} for build #{@name}"
+    end
+
+    # Set a block of code to be run as target, catching doing logging
+    def target(target, &block)
+      get_target(target).block = block
+    end
+
+  end
+
+end        

data/metabuild.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{metabuild}
+  s.version = "0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["F. Brault"]
+  s.date = %q{2010-05-20}
+  s.description = %q{MetaBuild is a ruby make-like tool that builds components. It supports tracking of dependencies among components, and a hierarchical reporting facility.}
+  s.email = %q{castorpilot@yahoo.com}
+  s.extra_rdoc_files = ["README", "lib/metabuild.rb"]
+  s.files = ["Manifest", "README", "Rakefile", "lib/metabuild.rb", "metabuild.gemspec"]
+  s.homepage = %q{http://metabuild.rubyforge.org/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Metabuild", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{metabuild}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{MetaBuild is a ruby make-like tool that builds components. It supports tracking of dependencies among components, and a hierarchical reporting facility.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: metabuild
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  version: "0.3"
+platform: ruby
+authors: 
+- F. Brault
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: MetaBuild is a ruby make-like tool that builds components. It supports tracking of dependencies among components, and a hierarchical reporting facility.
+email: castorpilot@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- lib/metabuild.rb
+files: 
+- Manifest
+- README
+- Rakefile
+- lib/metabuild.rb
+- metabuild.gemspec
+has_rdoc: true
+homepage: http://metabuild.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Metabuild
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: metabuild
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: MetaBuild is a ruby make-like tool that builds components. It supports tracking of dependencies among components, and a hierarchical reporting facility.
+test_files: []
+