autoproj 1.6.1 → 1.6.2.rc2

data/lib/autoproj/options.rb

@@ -32,9 +32,12 @@ module Autoproj
         def doc
             doc = (options[:doc] || "#{name} (no documentation for this option)")
             if doc.respond_to?(:to_ary) # multi-line
-                first_line = Autoproj.color(doc[0, 1], :bold)
-                remaining = doc[1..-1].join("\n").split("\n").join("\n    ")
-                first_line + "\n    " + remaining
+                first_line = Autoproj.color(doc[0], :bold)
+                remaining = doc[1..-1]
+                if !remaining.empty?
+                    remaining = remaining.join("\n").split("\n").join("\n    ")
+                    first_line + "\n    " + remaining
+                end
             else
                 doc
             end
@@ -80,6 +83,9 @@ module Autoproj
 
         def self.validate_string(value, options)
             if possible_values = options[:possible_values]
+                if options[:lowercase]
+                    value = value.downcase
+                end
                 if !possible_values.include?(value)
                     raise InputError, "invalid value '#{value}', accepted values are '#{possible_values.join(", ")}'"
                 end
@@ -97,6 +103,10 @@ module Autoproj
         end
     end
 
+    def self.reset_option(key)
+        @user_config.delete(key)
+    end
+
     def self.change_option(key, value, user_validated = false)
         @user_config[key] = [value, user_validated]
     end

data/lib/autoproj/osdeps.rb

@@ -20,6 +20,9 @@ module Autoproj
         end
         @aliases = Hash.new
 
+        attr_writer :silent
+        def silent?; @silent end
+
         def self.alias(old_name, new_name)
             @aliases[new_name] = old_name
         end
@@ -52,17 +55,24 @@ module Autoproj
         # The Gem::SpecFetcher object that should be used to query RubyGems, and
         # install RubyGems packages
         def gem_fetcher
-            @gem_fetcher ||= Gem::SpecFetcher.fetcher
+            if !@gem_fetcher
+                Autobuild.progress "looking for RubyGems updates"
+                @gem_fetcher = Gem::SpecFetcher.fetcher
+            end
+            @gem_fetcher
         end
 
         def initialize(defs = Hash.new, file = nil)
             @definitions = defs.to_hash
             @sources     = Hash.new
+            @installed_packages = Array.new
             if file
                 defs.each_key do |package_name|
                     sources[package_name] = file
                 end
             end
+            @silent = true
+            @filter_uptodate_packages = true
         end
 
         # Returns the full path to the osdeps file from which the package
@@ -108,10 +118,15 @@ module Autoproj
         # Returns true if it is possible to install packages for the operating
         # system on which we are installed
         def self.supported_operating_system?
-            osdef = operating_system
-            return false if !osdef
-
-            OS_PACKAGE_INSTALL.has_key?(osdef[0])
+            if @supported_operating_system.nil?
+                osdef = operating_system
+                @supported_operating_system =
+                    if !osdef then false
+                    else
+                        OS_AUTO_PACKAGE_INSTALL.has_key?(osdef[0])
+                    end
+            end
+            return @supported_operating_system
         end
 
         # Autodetects the operating system name and version
@@ -128,11 +143,14 @@ module Autoproj
             if @operating_system
                 return @operating_system
             elsif Autoproj.has_config_key?('operating_system')
-                @operating_system = Autoproj.user_config('operating_system')
-            elsif data = os_from_lsb
+                return (@operating_system = Autoproj.user_config('operating_system'))
+            end
+
+            Autoproj.progress "  autodetecting the operating system"
+            if data = os_from_lsb
                 if data[0] != "debian"
-                    # Fall back to reading debian_version, as
-                    # sid is listed as lenny by lsb-release
+                    # if on Debian proper, fall back to reading debian_version,
+                    # as sid is listed as lenny by lsb-release
                     @operating_system = data
                 end
             end
@@ -180,15 +198,48 @@ module Autoproj
             return [distributor, [codename, version]]
         end
 
+        # On a dpkg-enabled system, checks if the provided package is installed
+        # and returns true if it is the case
+        def self.dpkg_package_installed?(package_name)
+            if !@dpkg_installed_packages
+                @dpkg_installed_packages = Set.new
+                dpkg_status = File.readlines('/var/lib/dpkg/status')
+                dpkg_status.grep(/^(Package|Status)/).
+                    each_slice(2) do |package, status|
+                        if status.chomp == "Status: install ok installed"
+                            @dpkg_installed_packages << package.split[1].chomp
+                        end
+                    end
+            end
+            
+            if package_name =~ /^(\w[a-z0-9+-.]+)/
+                @dpkg_installed_packages.include?($1)
+            else
+                Autoproj.progress "WARN: #{package_name} is not a valid Debian package name"
+                false
+            end
+        end
 
         GAIN_ROOT_ACCESS = <<-EOSCRIPT
-        if test `id -u` != "0"; then
-            exec sudo /bin/bash $0 "$@"
-        
-        fi
+# Gain root access using sudo
+if test `id -u` != "0"; then
+    exec sudo /bin/bash $0 "$@"
+
+fi
         EOSCRIPT
 
-        OS_PACKAGE_INSTALL = {
+        OS_PACKAGE_CHECK = {
+            'debian' => method(:dpkg_package_installed?),
+            'ubuntu' => method(:dpkg_package_installed?)
+        }
+        OS_USER_PACKAGE_INSTALL = {
+            'debian' => "apt-get install '%s'",
+            'ubuntu' => "apt-get install '%s'",
+            'gentoo' => "emerge '%s'",
+            'arch' => "pacman '%s'"
+        }
+
+        OS_AUTO_PACKAGE_INSTALL = {
             'debian' => "export DEBIAN_FRONTEND=noninteractive; apt-get install -y '%s'",
             'ubuntu' => "export DEBIAN_FRONTEND=noninteractive; apt-get install -y '%s'",
             'gentoo' => "emerge --noreplace '%s'",
@@ -200,7 +251,6 @@ module Autoproj
         WRONG_OS_VERSION = 2
         IGNORE           = 3
         PACKAGES         = 4
-        SHELL_SNIPPET    = 5
         UNKNOWN_OS       = 7
         AVAILABLE        = 10
 
@@ -222,9 +272,6 @@ module Autoproj
         # [PACKAGES, definition]::
         #   +definition+ is an array of package names that this OS's package
         #   manager can understand
-        # [SHELL_SNIPPET, definition]::
-        #   +definition+ is a string which is a shell snippet that will install
-        #   the package
         def resolve_package(name)
             os_name, os_version = OSDependencies.operating_system
 
@@ -260,7 +307,7 @@ module Autoproj
                     version_list.to_s.split(',').
                         map(&:downcase).
                         any? do |v|
-                        os_version.any? { |osv| Regexp.new(v) =~ osv }
+                            os_version.any? { |osv| Regexp.new(v) =~ osv }
                         end
                 end
 
@@ -275,7 +322,7 @@ module Autoproj
             elsif data.to_str =~ /\w+/
                 return [PACKAGES, [data.to_str]]
             else
-                return [SHELL_SNIPPET, data.to_str]
+                raise ConfigError, "invalid package specificiation #{data} in #{source_of(name)}"
             end
         end
 
@@ -287,7 +334,6 @@ module Autoproj
             os_name, os_version = OSDependencies.operating_system
 
             os_packages    = []
-            shell_snippets = []
             dependencies.each do |name|
                 result = resolve_package(name)
                 if result == NO_PACKAGE
@@ -295,32 +341,30 @@ module Autoproj
                 elsif result == WRONG_OS
                     raise ConfigError, "there is an osdeps definition for #{name}, but not for this operating system"
                 elsif result == WRONG_OS_VERSION
-                    raise ConfigError, "there is an osdeps definition for #{name}, but no for this particular operating system version"
+                    raise ConfigError, "there is an osdeps definition for #{name}, but not for this particular operating system version"
                 elsif result == IGNORE
                     next
                 elsif result[0] == PACKAGES
                     os_packages.concat(result[1])
-                elsif result[0] == SHELL_SNIPPET
-                    shell_snippets << result[1]
                 end
             end
 
-            if !OS_PACKAGE_INSTALL.has_key?(os_name)
+            if !OS_AUTO_PACKAGE_INSTALL.has_key?(os_name)
                 raise ConfigError, "I don't know how to install packages on #{os_name}"
             end
 
-            return os_packages, shell_snippets
+            return os_packages
         end
 
 
-        def generate_os_script(dependencies)
-            os_name, os_version = OSDependencies.operating_system
-            os_packages, shell_snippets = resolve_os_dependencies(dependencies)
-
-            "#! /bin/bash\n" +
-            GAIN_ROOT_ACCESS + "\n" +
-                (OS_PACKAGE_INSTALL[os_name] % [os_packages.join("' '")]) +
-                "\n" + shell_snippets.join("\n")
+        def generate_user_os_script(os_name, os_packages)
+            if OS_USER_PACKAGE_INSTALL[os_name]
+                (OS_USER_PACKAGE_INSTALL[os_name] % [os_packages.join("' '")])
+            else generate_auto_os_script(os_name, os_packages)
+            end
+        end
+        def generate_auto_os_script(os_name, os_packages)
+            (OS_AUTO_PACKAGE_INSTALL[os_name] % [os_packages.join("' '")])
         end
 
         # Returns true if +name+ is an acceptable OS package for this OS and
@@ -411,9 +455,25 @@ module Autoproj
             end
         end
 
-        def filter_uptodate_gems(gems)
-            Autobuild.progress "looking for RubyGems updates"
+        # Returns true if the osdeps system knows how to remove uptodate
+        # packages from the needs-to-be-installed package list on this OS
+        def can_filter_uptodate_packages?
+            os_name, _ = OSDependencies.operating_system
+            !!OS_PACKAGE_CHECK[os_name]
+        end
+
+        # Returns the set of packages in +packages+ that are not already
+        # installed on this OS, if it is supported
+        def filter_uptodate_os_packages(packages, os_name)
+            check_method = OS_PACKAGE_CHECK[os_name]
+            return packages.dup if !check_method
 
+            packages.find_all { |pkg| !check_method[pkg] }
+        end
+
+        # Returns the set of RubyGem packages in +packages+ that are not already
+        # installed, or that can be upgraded
+        def filter_uptodate_gems(gems)
             # Don't install gems that are already there ...
             gems = gems.dup
             gems.delete_if do |name|
@@ -434,143 +494,300 @@ module Autoproj
             gems
         end
 
-        AUTOMATIC = true
-        MANUAL    = false
-        WAIT      = :wait
-        ASK       = :ask
+        HANDLE_ALL  = 'all'
+        HANDLE_RUBY = 'ruby'
+        HANDLE_OS   = 'os'
+        HANDLE_NONE = 'none'
+
+        def self.osdeps_mode_option_unsupported_os
+            long_doc =<<-EOT
+The software packages that autoproj will have to build may require other
+prepackaged softwares (a.k.a. OS dependencies) to be installed (RubyGems
+packages, packages from your operating system/distribution, ...). Autoproj is
+usually able to install those automatically, but unfortunately your operating
+system is not (yet) supported by autoproj's osdeps mechanism, it can only offer
+you some limited support.
+
+RubyGem packages are a cross-platform mechanism, and are therefore supported.
+However, you will have to install the kind of OS dependencies (so-called OS
+packages)
+
+This option is meant to allow you to control autoproj's behaviour while handling
+OS dependencies.
+
+* if you say "ruby", the RubyGem packages will be installed.
+* if you say "none", autoproj will not do anything related to the OS
+  dependencies.
+
+As any configuration value, the mode can be changed anytime by calling
+an autoproj operation with the --reconfigure option (e.g. autoproj update
+--reconfigure).
+
+Finally, OS dependencies can be installed by calling "autoproj osdeps"
+with the corresponding option (--all, --ruby, --os or --none). Calling
+"autoproj osdeps" without arguments will also give you information as
+to what you should install to compile the software successfully.
+            EOT
+            message = [ "Which prepackaged software (a.k.a. 'osdeps') should autoproj install automatically (ruby, none) ?", long_doc.strip ]
+
+	    Autoproj.configuration_option 'osdeps_mode', 'string',
+		:default => 'ruby',
+		:doc => [short_doc, long_doc],
+                :possible_values => %w{ruby none},
+                :lowercase => true
+        end
 
-        def automatic_osdeps_mode
-            if mode = ENV['AUTOPROJ_AUTOMATIC_OSDEPS']
-                mode =
-                    if mode == 'true' then AUTOMATIC
-                    elsif mode == 'false' then MANUAL
-                    elsif mode == 'wait' then WAIT
-                    else ASK
-                    end
-                Autoproj.change_option('automatic_osdeps', mode, true)
-                mode
+        def self.osdeps_mode_option_supported_os
+            long_doc =<<-EOT
+The software packages that autoproj will have to build may require other
+prepackaged softwares (a.k.a. OS dependencies) to be installed (RubyGems
+packages, packages from your operating system/distribution, ...). Autoproj
+is able to install those automatically for you.
+
+Advanced users may want to control this behaviour. Additionally, the
+installation of some packages require administration rights, which you may
+not have. This option is meant to allow you to control autoproj's behaviour
+while handling OS dependencies.
+
+* if you say "all", it will install all packages automatically.
+  This requires root access thru 'sudo'
+* if you say "ruby", only the Ruby packages will be installed.
+  Installing these packages does not require root access.
+* if you say "os", only the OS-provided packages will be installed.
+  Installing these packages requires root access.
+* if you say "none", autoproj will not do anything related to the
+  OS dependencies.
+
+As any configuration value, the mode can be changed anytime by calling
+an autoproj operation with the --reconfigure option (e.g. autoproj update
+--reconfigure).
+
+Finally, OS dependencies can be installed by calling "autoproj osdeps"
+with the corresponding option (--all, --ruby, --os or --none).
+            EOT
+            message = [ "Which prepackaged software (a.k.a. 'osdeps') should autoproj install automatically (all, ruby, os, none) ?", long_doc.strip ]
+
+	    Autoproj.configuration_option 'osdeps_mode', 'string',
+		:default => 'all',
+		:doc => message,
+                :possible_values => %w{all ruby os none},
+                :lowercase => true
+        end
+
+        def self.define_osdeps_mode_option
+            if supported_operating_system?
+                osdeps_mode_option_supported_os
             else
-                Autoproj.user_config('automatic_osdeps')
+                osdeps_mode_option_unsupported_os
             end
         end
 
-        # Requests the installation of the given set of packages
-        def install(packages, package_osdeps = Hash.new)
-            handled_os = OSDependencies.supported_operating_system?
-            osdeps, gems = partition_packages(packages, package_osdeps)
-            gems = filter_uptodate_gems(gems)
-            if osdeps.empty? && gems.empty?
-                return
+        def self.osdeps_mode_string_to_value(string)
+            string = string.downcase
+            case string
+            when 'all'  then HANDLE_ALL
+            when 'ruby' then HANDLE_RUBY
+            when 'os'   then HANDLE_OS
+            when 'none' then HANDLE_NONE
+            else raise ArgumentError, "invalid osdeps mode string '#{string}'"
             end
+        end
 
-            if automatic_osdeps_mode == AUTOMATIC && !handled_os && !osdeps.empty?
-                puts
-                puts Autoproj.color("==============================", :bold)
-                puts Autoproj.color("The packages that will be built require some other software to be installed", :bold)
-                puts "  " + osdeps.join("\n  ")
-                puts Autoproj.color("==============================", :bold)
-                puts
-            end
-
-            if !OSDependencies.force_osdeps && automatic_osdeps_mode != AUTOMATIC
-                puts
-                puts Autoproj.color("==============================", :bold)
-                puts Autoproj.color("The packages that will be built require some other software to be installed", :bold)
-                puts
-                if !osdeps.empty?
-                    puts "From the operating system:"
-                    puts "  " + osdeps.join("\n  ")
-                    puts
-                end
-                if !gems.empty?
-                    puts "From RubyGems:"
-                    puts "  " + gems.join("\n  ")
-                    puts
-                end
+        # If set to true (the default), #install will try to remove the list of
+        # already uptodate packages from the installed packages. Set to false to
+        # install all packages regardless of their status
+        attr_accessor :filter_uptodate_packages
+
+        # Override the osdeps mode
+        def osdeps_mode=(value)
+            @osdeps_mode = OSDependencies.osdeps_mode_string_to_value(value)
+        end
+
+        # Returns the osdeps mode chosen by the user
+        def osdeps_mode
+            # This has two uses. It caches the value extracted from the
+            # AUTOPROJ_OSDEPS_MODE and/or configuration file. Moreover, it
+            # allows to override the osdeps mode by using
+            # OSDependencies#osdeps_mode=
+            if @osdeps_mode
+                return @osdeps_mode
+            end
 
-                if automatic_osdeps_mode == ASK
-                    if !handled_os
-                        if gems.empty?
-                            # Nothing we can do, but the users required "ASK".
-                            # So, at least, let him press enter
-                            print "There are external packages, but I can't install them on this OS. Press ENTER to continue"
-                            STDOUT.flush
-                            STDIN.readline
-                            do_osdeps = false
-                        else
-                            print "Should I install the RubyGems packages ? [yes] "
+            @osdeps_mode = OSDependencies.osdeps_mode
+        end
+
+        def self.osdeps_mode
+            puts caller.join("\n  ")
+            while true
+                mode =
+                    if !Autoproj.has_config_key?('osdeps_mode') &&
+                        mode_name = ENV['AUTOPROJ_OSDEPS_MODE']
+                        begin OSDependencies.osdeps_mode_string_to_value(mode_name)
+                        rescue ArgumentError
+                            Autoproj.warn "invalid osdeps mode given through AUTOPROJ_OSDEPS_MODE (#{mode})"
+                            nil
                         end
                     else
-                        print "Should I install these packages ? [yes] "
-                    end
-                    STDOUT.flush
-
-                    do_osdeps = nil
-                    while do_osdeps.nil?
-                        answer = STDIN.readline.chomp
-                        if answer == ''
-                            do_osdeps = true
-                        elsif answer == "no"
-                            do_osdeps = false
-                        elsif answer == 'yes'
-                            do_osdeps = true
-                        else
-                            print "invalid answer. Please answer with 'yes' or 'no' "
-                            STDOUT.flush
+                        mode_name = Autoproj.user_config('osdeps_mode')
+                        begin OSDependencies.osdeps_mode_string_to_value(mode_name)
+                        rescue ArgumentError
+                            Autoproj.warn "invalid osdeps mode stored in configuration file"
+                            nil
                         end
                     end
+
+                if mode
+                    @osdeps_mode = mode
+                    return mode
+                end
+
+                # Invalid configuration values. Retry
+                Autoproj.reset_option('osdeps_mode')
+                ENV['AUTOPROJ_OSDEPS_MODE'] = nil
+            end
+        end
+
+        # The set of packages that have already been installed
+        attr_reader :installed_packages
+
+        def osdeps_interaction_unknown_os(osdeps)
+            puts <<-EOMSG
+  #{Autoproj.color("The build process requires some other software packages to be installed on our operating system", :bold)}
+  #{Autoproj.color("If they are already installed, simply ignore this message", :red)}"
+  
+    #{osdeps.join("\n    ")}
+
+            EOMSG
+            print Autoproj.color("Press ENTER to continue", :bold)
+            STDOUT.flush
+            STDIN.readline
+            puts
+            nil
+        end
+
+        def osdeps_interaction(osdeps, os_packages, shell_script, silent)
+            if !OSDependencies.supported_operating_system?
+                if silent
+                    return false
                 else
-                    puts "Since you requested autoproj to not handle the osdeps automatically, you have to"
-                    puts "do it yourself. Alternatively, you can run 'autoproj osdeps' and/or change to"
-                    puts "automatic osdeps handling by running an autoproj operation with the --reconfigure"
-                    puts "option (e.g. autoproj build --reconfigure)"
-                    puts Autoproj.color("==============================", :bold)
-                    puts
-
-                    if automatic_osdeps_mode == WAIT
-                        print "Press ENTER to continue "
-                        STDOUT.flush
-                        STDIN.readline
-                    end
+                    return osdeps_interaction_unknown_os(osdeps)
                 end
+            elsif OSDependencies.force_osdeps
+                return true
+            elsif osdeps_mode == HANDLE_ALL || osdeps_mode == HANDLE_OS
+                return true
+            elsif silent
+                return false
+            end
+
+            # We're asked to not install the OS packages but to display them
+            # anyway, do so now
+            puts <<-EOMSG
+
+  #{Autoproj.color("The build process and/or the packages require some other software to be installed", :bold)}
+  #{Autoproj.color("and you required autoproj to not install them itself", :bold)}
+  #{Autoproj.color("\nIf these packages are already installed, simply ignore this message\n", :red) if !can_filter_uptodate_packages?}
+    The following packages are available as OS dependencies, i.e. as prebuilt
+    packages provided by your distribution / operating system. You will have to
+    install them manually if they are not already installed
+    
+      #{os_packages.sort.join("\n      ")}
+    
+    the following command line(s) can be run as root to install them:
+    
+      #{shell_script.split("\n").join("\n|   ")}
+
+            EOMSG
+            print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+            STDOUT.flush
+            STDIN.readline
+            puts
+            false
+        end
+
+        def gems_interaction(gems, cmdline, silent)
+            if OSDependencies.force_osdeps
+                return true
+            elsif osdeps_mode == HANDLE_ALL || osdeps_mode == HANDLE_RUBY
+                return true
+            elsif silent
+                return false
+            end
+
+            # We're not supposed to install rubygem packages but silent is not
+            # set, so display information about them anyway
+            puts <<-EOMSG
+  #{Autoproj.color("The build process and/or the packages require some Ruby Gems to be installed", :bold)}
+  #{Autoproj.color("and you required autoproj to not do it itself", :bold)}
+    You can use the --all or --ruby options to autoproj osdeps to install these
+    packages anyway, and/or change to the osdeps handling mode by running an
+    autoproj operation with the --reconfigure option as for instance
+    autoproj build --reconfigure
+    
+    The following command line can be used to install them manually
+    
+      #{cmdline.join(" ")}
+    
+    Autoproj expects these Gems to be installed in #{Autoproj.gem_home} This can
+    be overriden by setting the AUTOPROJ_GEM_HOME environment variable manually
+
+            EOMSG
+            print "    #{Autoproj.color("Press ENTER to continue ", :bold)}"
+
+            STDOUT.flush
+            STDIN.readline
+            puts
+            false
+        end
 
-                if !do_osdeps
-                    return
+        # Requests the installation of the given set of packages
+        def install(packages, package_osdeps = Hash.new)
+            handled_os = OSDependencies.supported_operating_system?
+            # Remove the set of packages that have already been installed 
+            packages -= installed_packages
+            return if packages.empty?
+
+            osdeps, gems = partition_packages(packages, package_osdeps)
+            if handled_os
+                os_name, os_version = OSDependencies.operating_system
+                os_packages = resolve_os_dependencies(osdeps)
+                if filter_uptodate_packages
+                    os_packages = filter_uptodate_os_packages(os_packages, os_name)
                 end
             end
+            if filter_uptodate_packages
+                gems   = filter_uptodate_gems(gems)
+            end
 
             did_something = false
 
-            if handled_os && !osdeps.empty?
-                shell_script = generate_os_script(osdeps)
-                if Autoproj.verbose
-                    Autoproj.progress "Installing non-ruby OS dependencies with"
-                    Autoproj.progress shell_script
+            if !osdeps.empty? && (!os_packages || !os_packages.empty?)
+                if handled_os
+                    shell_script = generate_auto_os_script(os_name, os_packages)
+                    user_shell_script = generate_user_os_script(os_name, os_packages)
                 end
+                if osdeps_interaction(osdeps, os_packages, user_shell_script, silent?)
+                    Autoproj.progress "  installing OS packages: #{os_packages.sort.join(", ")}"
 
-                File.open('osdeps.sh', 'w') do |file|
-                    file.write shell_script
-                end
-                Autobuild.progress "installing/updating OS dependencies: #{osdeps.join(", ")}"
-                begin
-                    Autobuild::Subprocess.run 'autoproj', 'osdeps', '/bin/bash', File.expand_path('osdeps.sh')
-                ensure
-                    FileUtils.rm_f 'osdeps.sh'
-                end
-                did_something ||= true
-            end
+                    if Autoproj.verbose
+                        Autoproj.progress "Generating installation script for non-ruby OS dependencies"
+                        Autoproj.progress shell_script
+                    end
 
-            if !gems.empty?
-                gems = filter_uptodate_gems(gems)
+                    Tempfile.open('osdeps_sh') do |io|
+                        io.puts "#! /bin/bash"
+                        io.puts GAIN_ROOT_ACCESS
+                        io.write shell_script
+                        io.flush
+                        Autobuild::Subprocess.run 'autoproj', 'osdeps', '/bin/bash', io.path
+                    end
+                    did_something = true
+                end
             end
 
-            # Now install what is left
+            # Now install the RubyGems
             if !gems.empty?
                 guess_gem_program
-                if Autoproj.verbose
-                    Autoproj.progress "Installing rubygems dependencies with"
-                    Autoproj.progress "gem install #{gems.join(" ")}"
-                end
 
                 cmdline = [Autobuild.tool('gem'), 'install']
                 if Autoproj::OSDependencies.gem_with_prerelease
@@ -578,9 +795,11 @@ module Autoproj
                 end
                 cmdline.concat(gems)
 
-                Autobuild.progress "installing/updating RubyGems dependencies: #{gems.join(", ")}"
-                Autobuild::Subprocess.run 'autoproj', 'osdeps', *cmdline
-                did_something ||= true
+                if gems_interaction(gems, cmdline, silent?)
+                    Autobuild.progress "installing/updating RubyGems dependencies: #{gems.sort.join(", ")}"
+                    Autobuild::Subprocess.run 'autoproj', 'osdeps', *cmdline
+                    did_something = true
+                end
             end
 
             did_something