autobuild 1.5.34 → 1.5.35

data/Changes.txt

@@ -1,3 +1,10 @@
+== Version 1.5.35
+* fix some bad behaviour when using fallback importers
+  - git does not update the git configuration with the bad URLs anymore
+* orogen: removed automatic dependency detection, it was half-broken anyway.
+* orogen: avoid unnecessary regeneration (experimental, disabled by default).
+  It can be enabled by setting Autobuild::Orogen.always_regenerate = true
+
 == Version 1.5.34
 * make sure oroGen handlers will trigger a new generation
   on force-build

data/README.txt

@@ -1,8 +1,6 @@
-Copyright (c) 2006-2009 Sylvain Joyeux <sylvain.joyeux@m4x.org>
+Copyright (c) 2006-2011 Sylvain Joyeux <sylvain.joyeux@m4x.org> and contributors
 
-* http://doudou.github.com/autobuild
-* http://github.com/doudou/autobuild
-* http://doudou.github.com/autoproj
+* http://rock-robotics.org
 
 This work is licensed under the GPLv2 license. See License.txt for details
 

data/lib/autobuild/config.rb

@@ -71,28 +71,34 @@ module Autobuild
         send("#{name}=", value)
     end
 
+    @post_install_handlers = Array.new
     def self.post_install(*args, &block)
 	if args.empty?
-	    @post_install_handler = block
+	    @post_install_handlers << block
 	elsif !block
-	    @post_install_handler = args
+	    @post_install_handlers << args
 	else
 	    raise ArgumentError, "cannot set both arguments and block"
 	end
     end
-    attr_reader :post_install_handler
+    class << self
+        attr_reader :post_install_handlers
+    end
 
-    def self.apply_post_install(name, info)
+    def self.apply_post_install(pkg, info)
 	return unless info
 
 	case info
 	when Array
 	    args = info.dup
 	    tool = Autobuild.tool(args.shift)
-
-	    Autobuild::Subprocess.run name, 'post-install', tool, *args
+	    pkg.run 'post-install', tool, *args
 	when Proc
-	    info.call
+            if info.arity == 1
+                info.call(pkg)
+            else
+                info.call
+            end
 	end
     end
 

data/lib/autobuild/import/git.rb

@@ -23,9 +23,9 @@ module Autobuild
             if branch
                 STDERR.puts "WARN: the git importer now expects you to provide the branch as a named option"
                 STDERR.puts "WARN: this form is deprecated:"
-                STDERR.puts "WARN:    Autobuild.git 'git://github.com/doudou/autobuild.git', 'master'"
+                STDERR.puts "WARN:    Autobuild.git 'git://gitorious.org/rock/buildconf.git', 'master'"
                 STDERR.puts "WARN: and should be replaced by"
-                STDERR.puts "WARN:    Autobuild.git 'git://github.com/doudou/autobuild.git', :branch => 'master'"
+                STDERR.puts "WARN:    Autobuild.git 'git://gitorious.org/rock/buildconf.git', :branch => 'master'"
             end
 
             gitopts, common = Kernel.filter_options options, :push_to => nil, :branch => nil, :tag => nil, :commit => nil
@@ -121,7 +121,20 @@ module Autobuild
         def fetch_remote(package)
             validate_srcdir(package)
             Dir.chdir(package.srcdir) do
-                # Update the remote definition
+                # If we are checking out a specific commit, we don't know which
+                # branch to refer to in git fetch. So, we have to set up the
+                # remotes and call git fetch directly (so that all branches get
+                # fetch)
+                #
+                # Otherwise, do git fetch now
+                #
+                # Doing it now is better as it makes sure that we replace the
+                # configuration parameters only if the repository and branch are
+                # OK (i.e. we keep old working configuration instead)
+                if !commit 
+                    Subprocess.run(package, :import, Autobuild.tool('git'), 'fetch', repository, branch || tag)
+                end
+
                 Subprocess.run(package, :import, Autobuild.tool('git'), 'config',
                                "--replace-all", "remote.autobuild.url", repository)
                 if push_to
@@ -146,11 +159,8 @@ module Autobuild
                                    "--replace-all", "branch.#{local_branch}.merge", "refs/heads/#{branch}")
                 end
 
-                # We are checking out a specific commit. We just call git fetch
-                if commit 
+                if commit
                     Subprocess.run(package, :import, Autobuild.tool('git'), 'fetch', 'autobuild')
-                else
-                    Subprocess.run(package, :import, Autobuild.tool('git'), 'fetch', repository, branch || tag)
                 end
 
                 # Now get the actual commit ID from the FETCH_HEAD file, and
@@ -180,14 +190,12 @@ module Autobuild
                 validate_srcdir(package)
                 remote_commit = nil
                 if only_local
-                    Dir.chdir(package.srcdir) do
-                        remote_commit = `git show-ref -s refs/heads/#{local_branch}`.chomp
-                    end
+                    remote_commit = `git show-ref -s refs/heads/#{local_branch}`.chomp
                 else	
                     remote_commit =
                         begin fetch_remote(package)
                         rescue Exception => e
-                            fallback(e, package, :status, package, only_local)
+                            return fallback(e, package, :status, package, only_local)
                         end
 
                     if !remote_commit
@@ -205,6 +213,11 @@ module Autobuild
 
         end
 
+        def has_local_branch?
+            `git show-ref -q --verify refs/heads/#{local_branch}`
+            $?.exitstatus == 0
+        end
+
         # Checks if the current branch is the target branch. Expects that the
         # current directory is the package's directory
         def on_target_branch?
@@ -258,7 +271,7 @@ module Autobuild
 
         def merge_status(fetch_commit)
             common_commit = `git merge-base HEAD #{fetch_commit}`.chomp
-            head_commit   = `git rev-parse #{local_branch}`.chomp
+            head_commit   = `git rev-parse HEAD`.chomp
 
             status = if common_commit != fetch_commit
                          if common_commit == head_commit

data/lib/autobuild/importer.rb

@@ -88,6 +88,8 @@ class Importer
                         update(package)
                         patch(package)
                         package.updated = true
+                    rescue Interrupt
+                        raise
                     rescue ::Exception => e
                         fallback(e, package, :import, package)
                     end
@@ -124,7 +126,10 @@ class Importer
         Importer.fallback_handlers.each do |handler|
             fallback_importer = handler.call(package, self)
             if fallback_importer.kind_of?(Importer)
-                return fallback_importer.send(*args, &block)
+                begin fallback_importer.send(*args, &block)
+                rescue Exception
+                    raise error
+                end
             end
         end
         raise error

data/lib/autobuild/package.rb

@@ -195,15 +195,26 @@ module Autobuild
             # Don't do anything if we already have failed
             return if failed?
 
-            begin yield
+            begin
+                do_isolate = Autobuild.ignore_errors
+                Autobuild.ignore_errors = false
+                yield
+            rescue Interrupt
+                raise
             rescue ::Exception => e
                 @failures << e
                 if mark_as_failed
                     @failed = true
                 end
 
-                if Autobuild.ignore_errors
+                if do_isolate
                     lines = e.to_s.split("\n")
+                    if lines.empty?
+                        lines = e.message.split("\n")
+                    end
+                    if lines.empty?
+                        lines = ["unknown error"]
+                    end
                     progress(lines.shift, :red, :bold)
                     lines.each do |line|
                         progress(line)
@@ -212,6 +223,8 @@ module Autobuild
                 else
                     raise
                 end
+            ensure
+                Autobuild.ignore_errors = do_isolate
             end
         end
 
@@ -282,8 +295,11 @@ module Autobuild
         # Install the result in prefix
         def install
             Dir.chdir(srcdir) do
+                Autobuild.post_install_handlers.each do |b|
+                    Autobuild.apply_post_install(self, b)
+                end
                 @post_install_blocks.each do |b|
-                    Autobuild.apply_post_install(name, b)
+                    Autobuild.apply_post_install(self, b)
                 end
             end
             Autobuild.touch_stamp(installstamp)

data/lib/autobuild/packages/orogen.rb

@@ -3,136 +3,9 @@ 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
-
-        attr_reader :orogen_file
-        attr_reader :base_dir
-        attr_reader :project_name, :dependencies, :provides
-        def self.load(pkg, file)
-            FakeOrogenEnvironment.new(pkg).load(file)
-        end
-
-        # The Autobuild::Orogen instance we are working for
-        attr_reader :pkg
-
-        def initialize(pkg)
-            @pkg = pkg
-            @dependencies = Array.new
-            @provides = Array.new
-        end
-
-        def load(file)
-            @orogen_file = file
-            @base_dir = File.dirname(file)
-
-            begin
-                Kernel.eval(File.read(file), binding, file, 0)
-            rescue ::Exception => e
-                backtrace = e.backtrace.dup
-                message   = e.message.dup
-
-                backtrace.delete_if { |line| line !~ /(\s|^)#{Regexp.quote(file)}:/ }
-                if message =~ /^(#{Regexp.quote(file)}:\d+): (.*)/m
-                    backtrace.unshift $1
-                    message = $2
-                end
-                raise e, message, backtrace
-            end
-
-            self
-        end
-
-        def name(name)
-            @project_name = name
-            nil
-        end
-        def using_library(*names)
-            @dependencies.concat(names)
-            nil
-        end
-        def import_types_from(name, *args)
-            if !File.file?(File.join(base_dir, name)) && name.downcase !~ /\.(hh|hpp|h)/
-                using_toolkit name
-            end
-        end
-        def using_toolkit(*names)
-            names = names.map { |n| "#{n}-toolkit-#{pkg.orocos_target}" }
-            @dependencies.concat(names)
-            nil
-        end
-        def using_task_library(*names)
-            names = names.map { |n| "#{n}-tasks-#{pkg.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.
+    # framework. See http://rock-robotics.org 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
@@ -150,10 +23,33 @@ module Autobuild
     class Orogen < CMake
         class << self
             attr_accessor :corba
+
+            # If set to true, all components are generated with the
+            # --extended-states option
+            #
+            # The default is false
             attr_accessor :extended_states
+
+            # See #always_regenerate?
+            attr_reader :always_regenerate
+
+            # If true (the default), the oroGen component will be regenerated
+            # every time a dependency is newer than the package itself.
+            #
+            # Otherwise, autobuild tries to regenerate it only when needed
+            #
+            # This is still considered experimental. Use
+            # Orogen.always_regenerate= to set it
+            def always_regenerate?
+                !!@always_regenerate
+            end
         end
 
+        @always_regenerate = true
+
         @orocos_target = nil
+
+        # The target that should be used to generate and build orogen components
         def self.orocos_target
             user_target = ENV['OROCOS_TARGET']
             if @orocos_target
@@ -173,6 +69,7 @@ module Autobuild
         @default_type_export_policy = :used
         @transports = %w{corba typelib}
 
+        # Path to the orogen tool
         def self.orogen_bin
             if @orogen_bin
                 @orogen_bin
@@ -186,6 +83,7 @@ module Autobuild
             end
         end
 
+        # Path to the root of the orogen package
         def self.orogen_root
             if @orogen_root
                 @orogen_root
@@ -194,6 +92,10 @@ module Autobuild
             end
         end
 
+        # The version of orogen, given as a string
+        #
+        # It is used to enable/disable some configuration features based on the
+        # orogen version string
         def self.orogen_version
             if !@orogen_version && root = orogen_root
                 version_file = File.join(root, 'orogen', 'version.rb')
@@ -205,7 +107,16 @@ module Autobuild
             @orogen_version
         end
 
+        # Overrides the global Orocos.orocos_target for this particular package
         attr_writer :orocos_target
+
+        # The orocos target that should be used for this particular orogen
+        # package
+        #
+        # By default, it is the same than Orogen.orocos_target. It can be set by
+        # doing
+        #
+        #   package.orocos_target = 'target_name'
         def orocos_target
             if @orocos_target.nil?
                 Orogen.orocos_target
@@ -214,19 +125,22 @@ module Autobuild
             end
         end
 
-        attr_reader :orogen_spec
-
         attr_writer :corba
         def corba
             @corba || (@corba.nil? && Orogen.corba)
         end
 
+        # Overrides the global Orocos.extended_states for this particular package
         attr_writer :extended_states
         def extended_states
             @extended_states || (@extended_states.nil? && Orogen.extended_states)
         end
 
+        # Path to the orogen file used for this package
+        #
+        # If present, it defaults to the package name with '.orogen' appended
         attr_accessor :orogen_file
+
         def initialize(*args, &config)
             super
 
@@ -241,13 +155,6 @@ module Autobuild
 
         def import
             super
-
-            @orogen_spec = FakeOrogenEnvironment.load(self, File.join(srcdir, orogen_file))
-            provides "pkgconfig/#{orogen_spec.project_name}-toolkit-#{orocos_target}"
-            provides "pkgconfig/#{orogen_spec.project_name}-tasks-#{orocos_target}"
-            orogen_spec.provides.each do |name|
-                provides name
-            end
         end
 
         def update_environment
@@ -272,26 +179,18 @@ module Autobuild
                 depends_on rtt.name
             end
 
-            # 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
+            # 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
+            if orogen_root = self.class.orogen_root
+                orogen_tree = Autobuild.source_tree(orogen_root)
             end
 
             # Check if there is an orogen package registered. If it is the case,
             # simply depend on it. Otherwise, look out for orogen --base-dir
             if Autobuild::Package['orogen']
                 depends_on "orogen"
-            else
-                # 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
-                if orogen_root = self.class.orogen_root
-                    orogen_root = File.join(orogen_root, 'orogen')
-                    file genstamp => Autobuild.source_tree(orogen_root)
-                end
+            elsif orogen_tree
+                file genstamp => orogen_tree
             end
 
             file configurestamp => genstamp
@@ -319,7 +218,7 @@ module Autobuild
         end
 
         def regen
-            cmdline = [guess_ruby_name, self.class.orogen_bin]
+            cmdline = []
             cmdline << '--corba' if corba
 
             ext_states = extended_states
@@ -330,7 +229,6 @@ module Autobuild
                     cmdline << '--no-extended-states'
                 end
             end
-            cmdline << orogen_file
 
             if (version = Orogen.orogen_version)
                 if version >= "1.0"
@@ -338,13 +236,50 @@ module Autobuild
                 end
                 if version >= "1.1"
                     cmdline << "--type-export-policy=#{Orogen.default_type_export_policy}"
-                    cmdline << "--transports=#{Orogen.transports.join(",")}"
+                    cmdline << "--transports=#{Orogen.transports.sort.uniq.join(",")}"
                 end
             end
+            cmdline = cmdline.sort
+            cmdline << orogen_file
+
+            needs_regen = Autobuild::Orogen.always_regenerate?
+
+            # Try to avoid unnecessary regeneration as generation can be pretty
+            # long
+            #
+            # First, check if the command line changed
+            needs_regen ||=
+                if File.exists?(genstamp)
+                    last_cmdline = File.read(genstamp).split("\n")
+                    last_cmdline != cmdline
+                else
+                    true
+                end
+
+            # Then, if it has already been built, check what the check-uptodate
+            # target says
+            needs_regen ||=
+                if File.directory?(builddir)
+                    Dir.chdir(builddir) do
+                        !system("#{Autobuild.tool('make')} check-uptodate > /dev/null 2>&1")
+                    end
+                else
+                    true
+                end
+
+            # Finally, verify that orogen itself did not change
+            needs_regen ||= (Rake::Task[Orogen.orogen_root].timestamp > Rake::Task[genstamp].timestamp)
 
-            progress "generating oroGen project %s"
-            Dir.chdir(srcdir) do
-                Subprocess.run self, 'orogen', *cmdline
+            if needs_regen
+                progress "generating oroGen project %s"
+                Dir.chdir(srcdir) do
+                    Subprocess.run self, 'orogen', guess_ruby_name, self.class.orogen_bin, *cmdline
+                    File.open(genstamp, 'w') do |io|
+                        io.print cmdline.join("\n")
+                    end
+                end
+            else
+                progress "no need to regenerate the oroGen project %s"
                 Autobuild.touch_stamp genstamp
             end
         end

data/lib/autobuild/version.rb

@@ -1,5 +1,5 @@
 module Autobuild
-    VERSION = "1.5.34" unless defined? Autobuild::VERSION
+    VERSION = "1.5.35" unless defined? Autobuild::VERSION
 end
 
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: autobuild
 version: !ruby/object:Gem::Version 
-  hash: 71
-  prerelease: false
+  hash: 69
+  prerelease: 
   segments: 
   - 1
   - 5
-  - 34
-  version: 1.5.34
+  - 35
+  version: 1.5.35
 platform: ruby
 authors: 
 - Sylvain Joyeux
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-02 00:00:00 +01:00
+date: 2011-05-02 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -166,7 +166,7 @@ files:
 - test/test_subcommand.rb
 - test/tools.rb
 has_rdoc: true
-homepage: http://github.com/doudou/autobuild
+homepage: 
 licenses: []
 
 post_install_message: 
@@ -196,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: autobuild
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Rake-based utility to build and install multiple packages with dependencies