autobuild 0.5.1 → 0.6

data/lib/autobuild/packages/autotools.rb

@@ -1,115 +1,158 @@
+require 'pathname'
 require 'autobuild/timestamps'
 require 'autobuild/environment'
 require 'autobuild/package'
 require 'autobuild/subcommand'
 
 module Autobuild
-    ## 
+    def self.autotools(opts, &proc)
+        Autotools.new(opts, &proc)
+    end
+        
+    # 
     # ==== Handles autotools-based packages
     #
-    # == Used programs
-    # - aclocal, autoheader, autoconf, automake
+    # == Used programs (see <tt>Autobuild.programs</tt>)
+    # * aclocal
+    # * autoheader
+    # * autoconf
+    # * automake
     #
     # == Available options
-    # - aclocal (default: true if autoconf is enabled, false otherwise) run aclocal
-    # - autoconf (default: autodetect) run autoconf. Will be enabled if there is 
-    #   +configure.in+ or +configure.ac+ in the source directory
-    # - autoheader (default: false) run autoheader
-    # - automake (default: autodetect) run automake. Will run automake if there is a 
-    #   +Makefile.am+ in the source directory
+    # * aclocal     (default: true if autoconf is enabled, false otherwise) run aclocal
+    # * autoconf    (default: true)
+    # * autoheader  (default: false) run autoheader
+    # * automake    (default: autodetect) run automake. Will run automake if there is a 
+    #               +Makefile.am+ in the source directory
     # 
     class Autotools < Package
-        factory :autotools, self
+        attr_accessor   :using
+        attr_accessor   :configureflags
+        class << self
+            attr_reader :builddir
+            def builddir=(new)
+                raise ConfigException, "absolute builddirs are not supported" if (Pathname.new(new).absolute?)
+                raise ConfigException, "builddir must be non-nil and non-empty" if (new.nil? || new.empty?)
+                @builddir = new
+            end
+        end
+        @builddir = 'build'
+        
+        def builddir=(new)
+            raise ConfigException, "absolute builddirs are not supported" if (Pathname.new(new).absolute?)
+            raise ConfigException, "builddir must be non-empty" if new.empty?
+            @builddir = new
+        end
+        # Returns the absolute builddir
+        def builddir; File.expand_path(@builddir || Autotools.builddir, srcdir) end
+
+        # Build stamp
+        # This returns the name of the file which marks when the package has been
+        # successfully built for the last time. The path is absolute
+        def buildstamp; "#{builddir}/#{name}-#{STAMPFILE}" end
 
-        attr_reader :builddir
+        def initialize(options)
+            @using = Hash.new
 
-        DefaultOptions = {
-            :autoheader => false,
-            :aclocal => nil,
-            :autoconf => nil,
-            :automake => nil,
-            :builddir => 'build'
-        }
+            super
 
-        def buildstamp
-            "#{builddir}/#{target}-#{STAMPFILE}"
+            Autobuild.update_environment(prefix)
         end
 
-        def initialize(target, options)
-            options = DefaultOptions.merge(options) { |key, old, new|
-                (new.nil? || (new.respond_to?(:empty) && new.empty?)) ? old : new
-            }
-            super(target, options)
+        def use(*programs)
+            programs = *programs
+            if !programs.kind_of?(Hash)
+                programs = Array[*programs].inject({}) do |programs, spec|
+                    programs[spec.first] = spec.last
+                    programs
+                end
+            end
+            programs.each do |name, opt|
+                using[name.to_sym] = opt
+            end
 
-            @builddir = options[:builddir]
-            raise ConfigException, "autotools packages need a non-empty builddir" if (@builddir.nil? || @builddir.empty?)
-            raise ConfigException, "absolute builddirs are unsupported" if (Pathname.new(@builddir).absolute?)
-            @builddir = File.expand_path(builddir, srcdir)
+            nil
         end
 
-        def prepare
-            regen_targets
+        def depends_on(*packages)
+            super
+            stamps = packages.collect { |p| Package[p.to_s].installstamp }
+            #file "#{builddir}/config.status" => stamps
+            file buildstamp => stamps
+        end
+
+        def ensure_dependencies_installed
+            dependencies.each do |pkg|
+                Rake::Task[Package[pkg].installstamp].invoke
+            end
+        end
 
-            file "#{builddir}/config.status" => "#{srcdir}/configure" do
+        def prepare
+            file "#{builddir}/config.status" => regen do
+                ensure_dependencies_installed
                 configure
             end
 
             source_tree srcdir, builddir
             file buildstamp => [ srcdir, "#{builddir}/config.status" ] do 
+                ensure_dependencies_installed
                 build
             end
 
-            if !dependencies.empty?
-                file buildstamp => dependencies
-                file srcdir => dependencies
-            end
-
             file installstamp => buildstamp do 
                 install
                 Autobuild.update_environment(prefix)
             end
-            Autobuild.update_environment(prefix)
         end
 
-        def regen_targets
+
+    private
+        # Adds a target to rebuild the autotools environment
+        def regen
             conffile = "#{srcdir}/configure"
-            if File.exists?("#{conffile}.ac")
-                file conffile => [ "#{conffile}.ac" ]
-            elsif File.exists?("#{conffile}.in")
-                file conffile => [ "#{conffile}.in" ]
+            if confext = %w{.ac .in}.find { |ext| File.exists?("#{conffile}#{ext}") }
+                file conffile => "#{conffile}#{confext}"
             else
-                raise PackageException.new(target), "neither configure.ac nor configure.in present in #{srcdir}"
+                raise PackageException.new(name), "neither configure.ac nor configure.in present in #{srcdir}"
             end
+
             file conffile do
                 Dir.chdir(srcdir) {
-                    $PROGRAMS[:aclocal]     ||= 'aclocal'
-                    $PROGRAMS[:autoconf]    ||= 'autoconf'
-                    $PROGRAMS[:autoheader]  ||= 'autoheader'
-                    $PROGRAMS[:automake]    ||= 'automake'
+                    if using[:autogen].nil?
+                        using[:autogen] = %w{autogen autogen.sh}.find { |f| File.exists?(f) }
+                    end
 
-                    if @options[:autogen]
-                        Subprocess.run(target, 'configure', File.expand_path(@options[:autogen]))
+                    if using[:autogen]
+                        Subprocess.run(name, 'configure', File.expand_path(using[:autogen]))
                     else
                         # Autodetect autoconf/aclocal/automake
-                        if @options[:autoconf].nil?
-                            @options[:autoconf] = 
-                                File.exists?(File.join(srcdir, 'configure.in')) ||
-                                File.exists?(File.join(srcdir, 'configure.ac'))
-                        end
-                        @options[:aclocal] ||= @options[:autoconf]
-                        if @options[:automake].nil?
-                            @options[:automake] = File.exists?(File.join(srcdir, 'Makefile.am'))
+                        #
+                        # Let the user disable the use of autoconf explicitely by using 'false'.
+                        # 'nil' means autodetection
+                        using[:autoconf] = true if using[:autoconf].nil?
+                        using[:aclocal] = using[:autoconf] if using[:aclocal].nil?
+                        if using[:automake].nil?
+                            using[:automake] = File.exists?(File.join(srcdir, 'Makefile.am'))
                         end
 
-                        Subprocess.run(target, 'configure', $PROGRAMS[:aclocal])    if @options[:aclocal]
-                        Subprocess.run(target, 'configure', $PROGRAMS[:autoconf])   if @options[:autoconf]
-                        Subprocess.run(target, 'configure', $PROGRAMS[:autoheader]) if @options[:autoheader]
-                        Subprocess.run(target, 'configure', $PROGRAMS[:automake])   if @options[:automake]
+                        [ :aclocal, :autoconf, :autoheader, :automake ].each do |tool|
+                            if tool_flag = using[tool]
+				tool_program = if tool_flag.respond_to?(:to_str)
+						   tool_flag.to_str
+					       else; Autobuild.tool(tool)
+					       end
+
+                                Subprocess.run(name, 'configure', tool_program)
+                            end
+                        end
                     end
                 }
             end
+
+            return conffile
         end
 
+        # Configure the builddir directory before starting make
         def configure
             if File.exists?(builddir) && !File.directory?(builddir)
                 raise ConfigException, "#{builddir} already exists but is not a directory"
@@ -118,25 +161,25 @@ module Autobuild
             FileUtils.mkdir_p builddir if !File.directory?(builddir)
             Dir.chdir(builddir) {
                 command = [ "#{srcdir}/configure", "--no-create", "--prefix=#{prefix}" ]
-                command |= @options[:configureflags].to_a
+                command |= Array[*configureflags]
                 
-                Subprocess.run(target, 'configure', *command)
+                Subprocess.run(name, 'configure', *command)
             }
         end
 
+        # Do the build in builddir
         def build
             Dir.chdir(builddir) {
-                Subprocess.run(target, 'build', './config.status')
-                $PROGRAMS['make'] ||= 'make'
-                Subprocess.run(target, 'build', $PROGRAMS['make'])
+                Subprocess.run(name, 'build', './config.status')
+                Subprocess.run(name, 'build', Autobuild.tool(:make))
             }
             touch_stamp(buildstamp)
         end
 
+        # Install the result in prefix
         def install
             Dir.chdir(builddir) {
-                make = ($PROGRAMS['make'] or 'make')
-                Subprocess.run(target, 'install', make, 'install')
+                Subprocess.run(name, 'install', Autobuild.tool(:make), 'install')
             }
             touch_stamp(installstamp)
         end

data/lib/autobuild/packages/genom.rb

@@ -2,26 +2,44 @@ require 'autobuild/packages/autotools'
 require 'open3'
 
 module Autobuild
+    def self.genom(opts, &proc)
+        GenomModule.new(opts, &proc)
+    end
+
     class GenomModule < Autotools
+        attr_accessor :genomflags
+
+        def initialize(*args, &config)
+            @genomflags = []
+            super
+
+	    use :autogen => 'autogen'
+        end
+
+        # Called before running the rake tasks and
+        # after all imports have been made
         def prepare
+
             super
             get_requires
             get_provides
         end
-        def genomstamp; "#{srcdir}/.genom/genom-stamp" end
 
+        # The file touched by genom on successful generation
+	def genomstamp; File.join(srcdir, '.genom', 'genom-stamp') end
+
+        # Extract the cpp options from the genom options
         def cpp_options
-            @options[:genomflags].to_a.find_all { |opt| opt =~ /^-D/ }
+            [*genomflags].find_all { |opt| opt =~ /^-D/ }
         end
 
+        # Extracts dependencies using the requires: field in the .gen file
         def get_requires
-            cpp = ($PROGRAMS['cpp'] || 'cpp')
-            Open3.popen3("#{cpp} #{cpp_options.join(" ")} #{srcdir}/#{target}.gen") do |cin, out, err|
+            cpp = Autobuild.tool(:cpp)
+            Open3.popen3("#{cpp} #{cpp_options.join(" ")} #{srcdir}/#{name}.gen") do |cin, out, err|
                 out.each_line { |line|
                     if line =~ /^\s*requires\s*:\s*([\w\-]+(?:\s*,\s*[\w\-]+)*);/
-                        $1.split(/, /).each { |name| 
-                            depends_on name
-                        }
+                        $1.split(/, /).each { |name| depends_on name }
                     elsif line =~ /^\s*requires/
                         puts "failed to match #{line}"
                     end
@@ -29,46 +47,44 @@ module Autobuild
             end
         end
 
-        def depends_on(name)
-            super
-            file genomstamp => Package.name2target(name)
-        end
-
+        # Alias this package to the ones defined in the EXTRA_PKGCONFIG 
+        # flag in configure.ac.user
         def get_provides
-            File.open("#{srcdir}/configure.ac.user") do |f|
+            File.open(File.join(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
-                        }
+                        $1.split(/\s+/).each { |pkg| provides pkg }
                     end
                 }
             end
         end
             
+        def depends_on(*packages)
+            super
+	    file genomstamp => packages.map { |p| Package[p].installstamp }
+	end
 
-        def regen_targets
-            cmdline = [ 'genom', target ] | @options[:genomflags].to_a
+        def regen
+            cmdline = [ 'genom', "#{name}.gen", *genomflags ]
 
             file buildstamp => genomstamp
-            file genomstamp => [ :genom, "#{srcdir}/#{target}.gen" ] do
-                Dir.chdir(srcdir) {
-                    Subprocess.run(target, 'genom', *cmdline)
-                }
+            file genomstamp => srcdir do
+                Dir.chdir(srcdir) do
+                    Subprocess.run(name, 'genom', *cmdline)
+		end
+            end
+            if Package['genom']
+                file genomstamp => Package['genom'].installstamp
             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
-                    Subprocess.run(target, 'genom', File.expand_path('autogen'))
-                end
+            acuser = File.join(srcdir, "configure.ac.user")
+            file File.join(srcdir, 'configure') => acuser do
+                # configure does not depend on the .gen file
+                # since the generation takes care of rebuilding configure
+                # if .gen has changed
+                Dir.chdir(srcdir) { Subprocess.run(name, 'genom', File.expand_path('autogen')) }
             end
         end
-
-        factory :genom, self
     end
 end
 

data/lib/autobuild/packages/import.rb

@@ -2,20 +2,22 @@ require 'autobuild/timestamps'
 require 'autobuild/package'
 
 module Autobuild
+    def self.import(spec, &proc)
+        ImporterPackage.new(spec, &proc)
+    end
+    
     class ImporterPackage < Package
         def installstamp
             "#{srcdir}/#{STAMPFILE}"
         end
-        def initialize(target, options)
-            super(target, options)
+        def initialize(target)
+            super
             source_tree srcdir, installstamp
             file installstamp => srcdir do 
                 touch_stamp installstamp
             end
         end
         def prepare; end
-
-        factory :import, ImporterPackage
     end
 end
 

data/lib/autobuild/reporting.rb

@@ -4,12 +4,20 @@ require 'net/smtp'
 require 'socket'
 require 'etc'
 
+require 'autobuild/config'
 require 'autobuild/exceptions'
 
 module Autobuild
-    class Reporting
+    ## The reporting module provides the framework
+    # to run commands in autobuild and report errors 
+    # to the user
+    #
+    # It does not use a logging framework like Log4r, but it should ;-)
+    module Reporting
         @@reporters = Array.new
 
+        ## Run a block and report known exception
+        # If an exception is fatal, the program is terminated using exit()
         def self.report
             begin
                 yield
@@ -20,28 +28,38 @@ module Autobuild
             end
         end
         
+        ## Reports a successful build to the user
         def self.success
             @@reporters.each do |rep| rep.success end
         end
 
+        ## Reports that the build failed to the user
         def self.error(error)
             @@reporters.each do |rep| rep.error(error) end
         end
 
+        ## Add a new reporter
         def self.<<(reporter)
             @@reporters << reporter
         end
 
+	def self.each_reporter(&iter)
+	    @@reporters.each(&iter)
+	end
+
+        ## Iterate on all log files
         def self.each_log(&iter)
-            Dir.glob("#{$LOGDIR}/*.log", &iter)
+            Dir.glob("#{Autobuild.logdir}/*.log", &iter)
         end
     end
 
+    ## Base class for reporters
     class Reporter
         def error(error); end
         def success; end
     end
 
+    ## Display using stdout
     class StdoutReporter < Reporter
         def error(error)
             puts "Build failed: #{error}"
@@ -51,6 +69,7 @@ module Autobuild
         end
     end
 
+    ## Report by mail
     class MailReporter < Reporter
         def default_mail
             Etc::endpwent
@@ -62,29 +81,36 @@ module Autobuild
             "#{pwent.name}@#{Socket.gethostname}"
         end
         
+	attr_reader :from_email, :to_email, :smtp_hostname, :smtp_port, :subject, :only_errors
         def initialize(config)
-            @from = (config[:from] || default_mail)
-            @to   = (config[:to]   || default_mail)
-            @smtp = (config[:smtp] || "localhost" )
-            @port = Integer(config[:port] || Socket.getservbyname('smtp'))
+            @from_email = (config[:from] || default_mail)
+            @to_email   = (config[:to]   || default_mail)
+	    @subject = (config[:subject] || "Build %result% on #{Socket.gethostname} at %time%")
+	    @only_errors = config[:only_errors]
+            @smtp_hostname = (config[:smtp] || "localhost" )
+            @smtp_port = Integer(config[:port] || Socket.getservbyname('smtp'))
         end
 
         def error(error)
             if error.mail?
-                send_mail("Build failed", error.to_s)
+                send_mail("failed", error.to_s)
             end
         end
 
         def success
-            send_mail("Build success", "finished successfully at #{Time.now}")
+	    unless only_errors
+		send_mail("success")
+	    end
         end
 
-        def send_mail(subject, body)
+        def send_mail(result, body = "")
             mail = RMail::Message.new
             mail.header.date = Time.now
-            mail.header.from = @from
-            mail.header.to = @to
-            mail.header.subject = subject
+            mail.header.from = from_email
+            mail.header.subject = subject.
+		gsub('%result%', result).
+		gsub('%time%', Time.now.to_s).
+		gsub('%hostname%', Socket.gethostname)
 
             part = RMail::Message.new
             part.header.set('Content-Type', 'text/plain')
@@ -96,21 +122,24 @@ module Autobuild
                 mail.add_file(file)
             end
 
-            # Send the mail
-            smtp = Net::SMTP.new(@smtp, @port)
-            smtp.start {
-                smtp.send_mail RMail::Serialize.write('', mail), @from, @to
-            }
+            # Send the mails
+	    smtp = Net::SMTP.new(smtp_hostname, smtp_port)
+	    smtp.start {
+		to_email.each do |email|
+		    mail.header.to = email
+		    smtp.send_mail RMail::Serialize.write('', mail), from_email, email
+		end
+	    }
 
             # Notify the sending
-            puts "Sent notification mail to #{@to} with source #{@from}"
-
+            puts "Sent notification mail to #{to_email} with source #{from_email}"
         end
     end
 end
 
 module RMail
     class Message
+        ## Attachs a file to a message
         def add_file(path, content_type='text/plain')
             part = RMail::Message.new
             part.header.set('Content-Type', content_type)