autobuild 1.2.15 → 1.3.0

data/lib/autobuild/importer.rb

@@ -5,6 +5,38 @@ require 'autobuild/exceptions'
 # various RCS into the package source directory. A list of patches to apply
 # after the import can be given in the +:patches+ option.
 class Autobuild::Importer
+    # Instances of the Importer::Status class represent the status of a current
+    # checkout w.r.t. the remote repository.
+    class Status
+        # Remote and local are at the same point
+        UP_TO_DATE    = 0
+        # Local contains all data that remote has, but has new commits
+        ADVANCED      = 1
+        # Next update will require a merge
+        NEEDS_MERGE   = 2
+        # Next update will be simple (no merge)
+        SIMPLE_UPDATE = 3
+
+        # The update status
+        attr_accessor :status
+        # True if there is code in the working copy that is not committed
+        attr_accessor :uncommitted_code
+
+        # An array of strings that represent commits that are in the remote
+        # repository and not in this one (would be merged by an update)
+        attr_accessor :remote_commits
+        # An array of strings that represent commits that are in the local
+        # repository and not in the remote one (would be pushed by an update)
+        attr_accessor :local_commits
+
+        def initialize
+            @status = -1
+            @uncommitted_code = false
+            @remote_commits = Array.new
+            @local_commits  = Array.new
+        end
+    end
+
     # Creates a new Importer object. The options known to Importer are:
     # [:patches] a list of patch to apply after import
     #
@@ -20,10 +52,13 @@ class Autobuild::Importer
         srcdir = package.srcdir
         if File.directory?(srcdir)
             if Autobuild.do_update
+		Autobuild.progress "updating #{package.name}"
                 update(package)
                 patch(package)
             else
-                puts "Not updating #{package.name}"
+		if Autobuild.verbose
+		    puts "  not updating #{package.name}"
+		end
                 return
             end
 
@@ -31,6 +66,7 @@ class Autobuild::Importer
             raise ConfigException, "#{srcdir} exists but is not a directory"
         else
             begin
+		Autobuild.progress "checking out #{package.name}"
                 checkout(package)
                 patch(package)
             rescue Autobuild::Exception
@@ -68,6 +104,10 @@ class Autobuild::Importer
                             end
                         end
 
+	if !patches.empty?
+	    Autobuild.progress "patching #{package.name}"
+	end
+
         # Do not be smart, remove all already applied patches
         # and then apply the new ones
         begin

data/lib/autobuild/package.rb

@@ -11,6 +11,35 @@ module Autobuild
     #   - import
     #   - prepare
     #   - build & install
+    #
+    # In the first stage checks the source out and/or updates it.
+    #
+    # In the second stage, packages create their dependency structure to handle
+    # specific build systems. For instance, it is there that build systems like
+    # CMake are handled so that reconfiguration happens if needed. In the same
+    # way, it is there that code generation will happen as well.
+    #
+    # Finally, the build stage actually calls the package's build targets (of
+    # the form "package_name-build", which will trigger the build if needed.
+    #
+    # <b>Autodetecting dependencies</b>
+    # There are two sides in dependency autodetection. The first side is that
+    # packages must declare what they provide. One example is the handling of
+    # pkgconfig dependencies: packages must declare that they provide a
+    # pkgconfig definition. This side of the autodetection must be done just
+    # after the package's import, by overloading the #import method:
+    #
+    #   def import
+    #     super
+    #
+    #     # Do autodetection and call Package#provides
+    #   end
+    #
+    # Note that, in most cases, the overloaded import method *must* begin with
+    # "super".
+    #
+    # The other side is the detection itself. That must be done by overloading
+    # the #prepare method.
     class Package
 	@@packages = {}
 	@@provides = {}
@@ -23,6 +52,9 @@ module Autobuild
 	# set the installation directory. If a relative path is given,
 	# it is relative to Autobuild.prefix. Defaults to ''
 	attr_writer :prefix
+        # Sets the log directory. If no value is set, the package will use
+        # Autobuild.logdir
+        attr_writer :logdir
 	
 	# Sets importer object for this package. Defined for backwards compatibility.
 	# Use the #importer attribute instead
@@ -44,7 +76,9 @@ module Autobuild
 	# has finished. The path is absolute
 	#
 	# A package is sucessfully built when it is installed
-	def installstamp; "#{Autobuild.logdir}/#{name}-#{STAMPFILE}" end
+	def installstamp
+            File.join(@logdir || Autobuild.logdir, "#{name}-#{STAMPFILE}")
+        end
 
 	def initialize(spec)
 	    @dependencies   = Array.new
@@ -66,17 +100,8 @@ module Autobuild
 
             @doc_dir        ||= 'doc'
             @doc_target_dir ||= name
-	    
-	    # Declare the installation stampfile
-	    file installstamp do
-		Dir.chdir(srcdir) do
-		    Autobuild.apply_post_install(name, @post_install)
-		end
-	    end
-	    # Add dependencies declared in spec
-	    depends_on *depends if depends
 
-	    # Define the import task
+	    # Define the default tasks
 	    task "#{name}-import" do import end
 	    task :import => "#{name}-import"
 
@@ -84,7 +109,7 @@ module Autobuild
 	    task "#{name}-prepare" => "#{name}-import" do prepare end
 	    task :prepare => "#{name}-prepare"
 
-	    task "#{name}-build" => ["#{name}-prepare", installstamp]
+	    task "#{name}-build" => "#{name}-prepare"
 	    task :build => "#{name}-build"
 
 	    task(name) do
@@ -96,10 +121,34 @@ module Autobuild
                 end
 	    end
 	    task :default => name
+	    
+            # The dependencies will be declared in the prepare phase,  so save
+            # them there for now
+            @spec_dependencies = depends
 	end
 
+        # Call the importer if there is one. Autodetection of "provides" should
+        # be done there as well. See the documentation of Autobuild::Package for
+        # more information.
 	def import; @importer.import(self) if @importer end
-	def prepare; end
+        # Create all the dependencies required to reconfigure and/or rebuild the
+        # package when required. The package's build target is called
+        # "package_name-build".
+	def prepare
+            super if defined? super
+
+            task "#{name}-build" => installstamp
+	    # Declare the installation stampfile
+	    file installstamp do
+		Dir.chdir(srcdir) do
+		    Autobuild.apply_post_install(name, @post_install)
+		end
+	    end
+	    # Add dependencies declared in spec
+	    depends_on *@spec_dependencies if @spec_dependencies
+
+            Autobuild.update_environment prefix
+        end
 
         # Directory in which the documentation target will have generated the
         # documentation (if any). The interpretation of relative directories
@@ -141,6 +190,9 @@ module Autobuild
                             raise
                         else
                             STDERR.puts "W: failed to generate documentation for #{name}"
+                            if e.kind_of?(SubcommandFailed)
+                                STDERR.puts "W: see #{e.logfile} for more details"
+                            end
                         end
                     end
                 end
@@ -183,7 +235,9 @@ module Autobuild
 	    end
 	end
 
-	# This package depends on +packages+
+	# This package depends on +packages+. It means that its build will
+        # always be triggered after the packages listed in +packages+ are built
+        # and installed.
 	def depends_on(*packages)
 	    packages.each do |p|
 		p = p.to_s
@@ -198,7 +252,8 @@ module Autobuild
 	    end
 	end
 
-	# Declare that this package provides +packages+
+	# Declare that this package provides +packages+. In effect, the names
+        # listed in +packages+ are aliases for this package.
 	def provides(*packages)
 	    packages.each do |p|
 		p = p.to_s

data/lib/autobuild/packages/autotools.rb

@@ -51,8 +51,6 @@ module Autobuild
 	    @configureflags = []
 
             super
-
-            Autobuild.update_environment(prefix)
         end
         
         def install_doc(relative_to = builddir)
@@ -63,6 +61,7 @@ module Autobuild
         def with_doc(target = 'doc')
             doc_task do
                 Dir.chdir(builddir) do
+                    Autobuild.progress "generating documentation for #{name}"
                     Subprocess.run(name, 'doc', Autobuild.tool(:make), target)
                     yield if block_given?
                 end
@@ -120,6 +119,8 @@ module Autobuild
         end
 
         def prepare
+            super
+
 	    configureflags.flatten!
 
 	    # Check if config.status has been generated with the
@@ -146,7 +147,7 @@ module Autobuild
                 configure
             end
 
-            source_tree srcdir do |pkg|
+            Autobuild.source_tree srcdir do |pkg|
 		pkg.exclude << Regexp.new("^#{Regexp.quote(builddir)}")
 	    end
             file buildstamp => [ srcdir, "#{builddir}/config.status" ] do 
@@ -157,10 +158,10 @@ module Autobuild
 
             file installstamp => buildstamp do 
                 install
-                Autobuild.update_environment(prefix)
             end
-        end
 
+            Autobuild.update_environment(prefix)
+        end
 
     private
         # Adds a target to rebuild the autotools environment
@@ -180,6 +181,7 @@ module Autobuild
                         using[:autogen] = %w{autogen autogen.sh}.find { |f| File.exists?(f) }
                     end
 
+                    Autobuild.progress "generating build system for #{name}"
                     if using[:autogen]
                         Subprocess.run(name, 'configure', File.expand_path(using[:autogen]))
                     else
@@ -221,6 +223,7 @@ module Autobuild
                 command = [ "#{srcdir}/configure", "--no-create", "--prefix=#{prefix}" ]
                 command += Array[*configureflags]
                 
+                Autobuild.progress "configuring build system for #{name}"
                 Subprocess.run(name, 'configure', *command)
             }
         end
@@ -228,18 +231,21 @@ module Autobuild
         # Do the build in builddir
         def build
             Dir.chdir(builddir) {
+                Autobuild.progress "building #{name}"
                 Subprocess.run(name, 'build', './config.status')
                 Subprocess.run(name, 'build', Autobuild.tool(:make))
             }
-            touch_stamp(buildstamp)
+            Autobuild.touch_stamp(buildstamp)
         end
 
         # Install the result in prefix
         def install
             Dir.chdir(builddir) {
+                Autobuild.progress "installing #{name}"
                 Subprocess.run(name, 'install', Autobuild.tool(:make), 'install')
             }
-            touch_stamp(installstamp)
+            Autobuild.touch_stamp(installstamp)
+            Autobuild.update_environment(prefix)
         end
     end
 end

data/lib/autobuild/packages/cmake.rb

@@ -39,6 +39,7 @@ module Autobuild
         def with_doc(target = 'doc')
             doc_task do
                 Dir.chdir(builddir) do
+                    Autobuild.progress "generating documentation for #{name}"
                     Subprocess.run(name, 'doc', Autobuild.tool(:make), target)
                     yield if block_given?
                 end
@@ -65,6 +66,15 @@ module Autobuild
             end
         end
 
+        def import
+            super
+
+            Dir.glob(File.join(srcdir, "*.pc.in")) do |file|
+                file = File.basename(file, ".pc.in")
+                provides "pkgconfig/#{file}"
+            end
+        end
+
         def prepare
             super
 
@@ -115,6 +125,7 @@ module Autobuild
                 end
                 command << srcdir
                 
+                Autobuild.progress "generating and configuring build system for #{name}"
                 Subprocess.run(name, 'configure', *command)
                 super
             end
@@ -123,18 +134,21 @@ module Autobuild
         # Do the build in builddir
         def build
             Dir.chdir(builddir) do
+                Autobuild.progress "building #{name}"
                 if always_reconfigure || !File.file?('Makefile')
                     Subprocess.run(name, 'build', Autobuild.tool(:cmake), '.')
                 end
                 Subprocess.run(name, 'build', Autobuild.tool(:make))
             end
-            touch_stamp(buildstamp)
+            Autobuild.touch_stamp(buildstamp)
         end
 
         # Install the result in prefix
         def install
             Dir.chdir(builddir) do
+                Autobuild.progress "installing #{name}"
                 Subprocess.run(name, 'install', Autobuild.tool(:make), 'install')
+                Autobuild.update_environment prefix
             end
             super
         end

data/lib/autobuild/packages/genom.rb

@@ -89,10 +89,10 @@ module Autobuild
 		genom_pkg = PkgConfig.new('genom')
 
 		includedir = File.join(genom_pkg.includedir, 'genom')
-		source_tree includedir
+		Autobuild.source_tree includedir
 
 		canvasdir = File.join(genom_pkg.prefix, "share", "genom", genom_pkg.version);;
-		source_tree canvasdir
+		Autobuild.source_tree canvasdir
 
 		binary = File.join(genom_pkg.exec_prefix, "bin", "genom")
 		file binary
@@ -121,6 +121,7 @@ module Autobuild
 	    file genomstamp => genom_dependencies
             file genomstamp => srcdir do
                 Dir.chdir(srcdir) do
+                    Autobuild.progress "generating GenoM files for #{package.name}"
                     Subprocess.run(name, 'genom', *cmdline)
 		end
             end
@@ -130,6 +131,7 @@ module Autobuild
                 # configure does not depend on the .gen file
                 # since the generation takes care of rebuilding configure
                 # if .gen has changed
+                Autobuild.progress "generating build system for #{package.name}"
                 Dir.chdir(srcdir) { Subprocess.run(name, 'genom', File.expand_path('autogen')) }
             end
 

data/lib/autobuild/packages/import.rb

@@ -16,15 +16,20 @@ module Autobuild
         def initialize(*args)
 	    @exclude = []
             super
+        end
+
+        def prepare
+            super
+
 	    exclude << Regexp.new("^#{Regexp.quote(installstamp)}")
 
-            source_tree(srcdir) do |pkg|
+            Autobuild.source_tree(srcdir) do |pkg|
 		pkg.exclude.concat exclude
 		exclude.freeze
 	    end
 
             file installstamp => srcdir do 
-                touch_stamp installstamp
+                Autobuild.touch_stamp installstamp
             end
         end
     end

data/lib/autobuild/packages/orogen.rb

@@ -3,11 +3,141 @@ module Autobuild
         Orogen.new(opts, &proc)
     end
 
+
+    # This discards everything but the calls to import_types_from,
+    # using_task_library and using_toolkit. This is used to automatically
+    # discover the dependencies without resorting to an actual build
+    class FakeOrogenEnvironment
+        class BlackHole
+            def initialize(*args)
+            end
+            def method_missing(*args)
+                self
+            end
+            def self.method_missing(*args)
+                self
+            end
+            def self.const_missing(*args)
+                self
+            end
+        end
+        StaticDeployment = BlackHole
+        StaticDeployment::Logger = BlackHole
+        TaskContext = BlackHole
+
+        class FakeDeployment
+            attr_reader :env
+            def initialize(env, name)
+                @env = env
+                env.provides << "pkgconfig/orogen-#{name}"
+            end
+            def add_default_logger
+                env.using_task_library 'logger'
+                BlackHole
+            end
+            def task(*args)
+                method_missing(*args)
+            end
+            def const_missing(*args)
+                BlackHole
+            end
+            def method_missing(*args)
+                BlackHole
+            end
+            def self.const_missing(*args)
+                BlackHole
+            end
+        end
+
+        def self.orocos_target
+            user_target = ENV['OROCOS_TARGET']
+            if @orocos_target
+                @orocos_target.dup
+            elsif user_target && !user_target.empty?
+                user_target
+            else
+                'gnulinux'
+            end
+        end
+
+        attr_reader :project_name, :dependencies, :provides
+        def self.load(file)
+            FakeOrogenEnvironment.new.load(file)
+        end
+
+        def initialize
+            @dependencies = Array.new
+            @provides = Array.new
+        end
+
+        def load(file)
+            Kernel.eval(File.read(file), binding)
+            self
+        end
+
+        def name(name)
+            @project_name = name
+            nil
+        end
+        def using_library(*names)
+            @dependencies.concat(names)
+            nil
+        end
+        def using_toolkit(*names)
+            names = names.map { |n| "#{n}-toolkit-#{FakeOrogenEnvironment.orocos_target}" }
+            @dependencies.concat(names)
+            nil
+        end
+        def using_task_library(*names)
+            names = names.map { |n| "#{n}-tasks-#{FakeOrogenEnvironment.orocos_target}" }
+            @dependencies.concat(names)
+            nil
+        end
+
+        def static_deployment(name = nil, &block)
+            deployment("test_#{project_name}", &block)
+        end
+        def deployment(name, &block)
+            deployment = FakeDeployment.new(self, name)
+            deployment.instance_eval(&block) if block
+            deployment
+        end
+
+        def self.const_missing(*args)
+            BlackHole
+        end
+        def const_missing(*args)
+            BlackHole
+        end
+        def method_missing(*args)
+            BlackHole
+        end
+    end
+
+    # This class represents packages generated by orogen. oroGen is a
+    # specification and code generation tool for the Orocos/RTT integration
+    # framework. See http://doudou.github.com/orogen for more information.
+    #
+    # This class extends the CMake package class to handle the code generation
+    # step. Moreover, it will load the orogen specification and automatically
+    # add the relevant pkg-config dependencies as dependencies.
+    #
+    # This requires that the relevant packages define the pkg-config definitions
+    # they install in the pkgconfig/ namespace. It means that a "driver/camera"
+    # package (for instance) that installs a "camera.pc" file will have to
+    # provide the "pkgconfig/camera" virtual package. This is done automatically
+    # by the CMake package handler if the source contains a camera.pc.in file,
+    # but can also be done manually with a call to Package#provides:
+    #
+    #   pkg.provides "pkgconfig/camera"
+    #
     class Orogen < CMake
         class << self
             attr_accessor :corba
         end
 
+        attr_reader :orogen_spec
+
         attr_accessor :corba
 
         attr_accessor :orogen_file
@@ -16,18 +146,6 @@ module Autobuild
             super
 
             @orogen_file ||= "#{File.basename(name)}.orogen"
-
-            # Find out where orogen is, and make sure the configurestamp depend
-            # on it. Ignore if orogen is too old to have a --base-dir option
-            orogen_root = File.join(`orogen --base-dir`.chomp, 'orogen')
-            if !orogen_root.empty?
-                file genstamp => Autobuild.source_tree(orogen_root)
-            end
-
-            file configurestamp => genstamp
-            file genstamp => File.join(srcdir, orogen_file) do
-                regen
-            end
         end
 
         def depends_on(*packages)
@@ -38,6 +156,43 @@ module Autobuild
             end
         end
 
+        def import
+            super
+
+            @orogen_spec = FakeOrogenEnvironment.load(File.join(srcdir, orogen_file))
+            provides "pkgconfig/#{orogen_spec.project_name}-toolkit-#{FakeOrogenEnvironment.orocos_target}"
+            provides "pkgconfig/#{orogen_spec.project_name}-tasks-#{FakeOrogenEnvironment.orocos_target}"
+            orogen_spec.provides.each do |name|
+                provides name
+            end
+        end
+
+        def prepare
+            super
+
+            # If required, load the component's specification and add
+            # dependencies based on the orogen specification.
+            orogen_spec.dependencies.each do |pkg_name|
+                target = "pkgconfig/#{pkg_name}"
+                if Autobuild::Package[target]
+                    depends_on target
+                end
+            end
+
+            # Find out where orogen is, and make sure the configurestamp depend
+            # on it. Ignore if orogen is too old to have a --base-dir option
+            orogen_root = `orogen --base-dir`.chomp
+            if orogen_root.empty?
+                raise ConfigException, "cannot find the orogen tool"
+            end
+            orogen_root = File.join(orogen_root, 'orogen')
+            file genstamp => Autobuild.source_tree(orogen_root)
+
+            file configurestamp => genstamp
+            file genstamp => File.join(srcdir, orogen_file) do
+                regen
+            end
+        end
         def genstamp; File.join(srcdir, '.orogen', 'orogen-stamp') end
 
         def regen
@@ -45,9 +200,10 @@ module Autobuild
             cmdline << '--corba' if corba
             cmdline << orogen_file
 
+            Autobuild.progress "generating oroGen project #{name}"
             Dir.chdir(srcdir) do
                 Subprocess.run name, 'orogen', *cmdline
-                touch_stamp genstamp
+                Autobuild.touch_stamp genstamp
             end
         end
     end