autoproj 1.5.8 → 1.6.0.rc1

data/doc/guide/src/package_sets/index.page

@@ -25,7 +25,9 @@ Adding a package
 
 Adding a package to a package set involves changing two files:
 
- * the package set's autobuild file that declares what type of package it is and
+ * one of the package set's autobuild file that declares what packages there
+   are. Any file ending with .autobuild is loaded as an autobuild file by
+   autoproj.
  * the package set's source.yml file that declares where to get it (version
    control information)
 

data/lib/autoproj/autobuild.rb

@@ -3,6 +3,29 @@ require 'fileutils'
 require 'autobuild'
 require 'set'
 
+def explicit_osdeps_selection(name)
+    if !Autoproj.declared_option?("osdeps_#{name}")
+	if Autoproj.has_config_key?("osdeps_#{name}")
+	    doc_string = "install #{name} from source ?"
+	else
+	    # Declare the option
+	    doc_string =<<-EOT
+The #{name} package is listed as a dependency of #{self.name}. It is listed as an operating
+system package for other operating systems than yours, and is also listed as a source package.
+Since you requested manual updates, I have to ask you:
+
+Do you want me to build #{name} from source ? If you say 'no', you will have to install it yourself.
+	    EOT
+	end
+
+	Autoproj.configuration_option(
+	    "osdeps_#{name}", "boolean",
+	    :default => "yes",
+	    :doc => doc_string)
+    end
+    !Autoproj.user_config("osdeps_#{name}")
+end
+
 module Autobuild
     class Package
         def autoproj_name # :nodoc:
@@ -11,23 +34,40 @@ module Autobuild
 
         alias __depends_on__ depends_on
         def depends_on(name)
-            explicit_selection = Autoproj.manifest.explicitly_selected_package?(name)
-            if Autoproj.osdeps.has?(name) && !explicit_selection
-                @os_packages ||= Set.new
-                @os_packages << name
-            else
-                begin
-                    __depends_on__(name)
-                rescue Exception => e
-                    if explicit_selection
-                        raise e
-                    else
-                        # Re-call osdeps to get a proper error message
-                        osdeps, gems = Autoproj.osdeps.partition_packages([name].to_set, name => [self.name])
-                        Autoproj.osdeps.resolve_os_dependencies(osdeps)
+            explicit_selection  = Autoproj.manifest.explicitly_selected_package?(name)
+	    osdeps_availability = Autoproj.osdeps.availability_of(name)
+            available_as_source = Autobuild::Package[name]
+
+	    # Prefer OS packages to source packages
+            if !explicit_selection 
+                if osdeps_availability == Autoproj::OSDependencies::AVAILABLE
+                    @os_packages ||= Set.new
+                    @os_packages << name
+                    return
+                end
+
+                if osdeps_availability == Autoproj::OSDependencies::UNKNOWN_OS
+                    # If we can't handle that OS, but other OSes have a
+                    # definition for it, we assume that it can be installed as
+                    # an external package. However, if it is also available as a
+                    # source package, prompt the user
+                    if !available_as_source || explicit_osdeps_selection(name)
+                        @os_packages ||= Set.new
+                        @os_packages << name
+                        return
                     end
                 end
+
+                if !available_as_source
+                    # Call osdeps to get a proper error message
+                    osdeps, gems = Autoproj.osdeps.partition_packages([name].to_set, name => [self.name])
+                    Autoproj.osdeps.resolve_os_dependencies(osdeps)
+                    # Should never reach further than that
+                end
             end
+
+
+            __depends_on__(name) # to get the error message
         end
 
         def depends_on_os_package(name)
@@ -83,12 +123,18 @@ module Autoproj
     def self.filter_load_exception(error, source, path)
         raise error if Autoproj.verbose
         rx_path = Regexp.quote(path)
-        error_line = error.backtrace.find { |l| l =~ /#{rx_path}/ }
-        line_number = Integer(/#{rx_path}:(\d+)/.match(error_line)[1])
-        if source.local?
-            raise ConfigError, "#{path}:#{line_number}: #{error.message}", error.backtrace
+        if error_line = error.backtrace.find { |l| l =~ /#{rx_path}/ }
+            if line_number = Integer(/#{rx_path}:(\d+)/.match(error_line)[1])
+                line_number = "#{line_number}:"
+            end
+
+            if source.local?
+                raise ConfigError, "#{path}:#{line_number} #{error.message}", error.backtrace
+            else
+                raise ConfigError, "#{File.basename(path)}(source=#{source.name}):#{line_number} #{error.message}", error.backtrace
+            end
         else
-            raise ConfigError, "#{File.basename(path)}(source=#{source.name}):#{line_number}: #{error.message}", error.backtrace
+            raise error
         end
     end
 
@@ -98,6 +144,8 @@ module Autoproj
         @file_stack.push([source, File.basename(path)])
         begin
             Kernel.load path
+        rescue ConfigError => e
+            raise
         rescue Exception => e
             filter_load_exception(e, source, path)
         end

data/lib/autoproj/cmdline.rb

@@ -20,12 +20,68 @@ module Autoproj
         end
     end
 
+    def self.color(*args)
+        console.color(*args)
+    end
+
     # Displays a warning message
     def self.warn(message)
         Autoproj.progress("  WARN: #{message}", :magenta)
     end
 
     module CmdLine
+	def self.handle_automatic_osdeps
+            if !Autoproj.has_config_key?('automatic_osdeps') && ENV['AUTOPROJ_AUTOMATIC_OSDEPS']
+                mode = ENV['AUTOPROJ_AUTOMATIC_OSDEPS']
+                mode =
+                    if mode == 'true'     then Autoproj::OSDependencies::AUTOMATIC
+                    elsif mode == 'false' then Autoproj::OSDependencies::MANUAL
+                    elsif mode == 'wait'  then Autoproj::OSDependencies::WAIT
+                    else Autoproj::OSDependencies::ASK
+                    end
+
+                Autoproj.change_option('automatic_osdeps', mode, true)
+            end
+
+	    if Autoproj.has_config_key?("automatic_osdeps")
+		doc_string = "Should autoproj handle the OS package installation automatically (yes, no, wait or ask) ?"
+	    else
+		# Ask the user for the automatic_osdeps option
+		doc_string =<<-EOT
+#{color("Should autoproj handle the OS package installation automatically (yes, no, wait or ask) ?", :bold)}
+    If you say "no", the list of OS dependencies that need to be installed will be listed,
+    and autoproj will go on, assuming that you have installed them yourself. If you say
+    "ask", you will be prompted each time a package needs to be installed. Finally, if you
+    say "wait", autoproj will simply wait for you to press ENTER to continue after it prompted
+    you for the dependencies.
+
+    This value can be changed anytime by calling an autoproj operation with the --reconfigure
+    option (e.g. autoproj update --reconfigure). Moreover, the "autoproj osdeps" call will
+    always allow you to install OS dependencies through autoproj.
+
+		EOT
+		doc_string = doc_string.strip
+	    end
+
+	    Autoproj.configuration_option 'automatic_osdeps', 'string',
+		:default => 'yes',
+		:doc => doc_string do |value|
+                    begin
+                        Autoproj::BuildOption.validate_boolean(value, Hash.new)
+                    rescue Autoproj::InputError
+                        if value.to_s == "ask"
+                            :ask
+                        elsif value.to_s == "wait"
+                            :wait
+                        else
+                            raise Autoproj::InputError, "invalid value. Please answer 'yes', 'no', 'wait' or 'ask' -- without the quotes"
+                        end
+                    end
+                end
+
+	    Autoproj.user_config('automatic_osdeps')
+	end
+
         def self.initialize
             Autobuild::Reporting << Autoproj::Reporter.new
             if mail_config[:to]
@@ -34,6 +90,10 @@ module Autoproj
 
             Autoproj.load_config
 
+            if Autoproj.has_config_key?('prefix')
+                Autoproj.prefix = Autoproj.user_config('prefix')
+            end
+
             # If we are under rubygems, check that the GEM_HOME is right ...
             if $LOADED_FEATURES.any? { |l| l =~ /rubygems/ }
                 if ENV['GEM_HOME'] != Autoproj.gem_home
@@ -50,6 +110,8 @@ module Autoproj
             Autobuild.srcdir  = Autoproj.root_dir
             Autobuild.logdir = File.join(Autobuild.prefix, 'log')
 
+	    handle_automatic_osdeps
+
             ruby = RbConfig::CONFIG['RUBY_INSTALL_NAME']
             if ruby != 'ruby'
                 bindir = File.join(Autoproj.build_dir, 'bin')
@@ -282,6 +344,27 @@ module Autoproj
             selected_packages
         end
 
+        def self.verify_package_availability(pkg_name)
+            if reason = Autoproj.manifest.exclusion_reason(pkg_name)
+                raise ConfigError, "#{pkg_name} is excluded from the build: #{reason}"
+            end
+            pkg = Autobuild::Package[pkg_name]
+            if !pkg
+                raise ConfigError, "#{pkg_name} does not seem to exist"
+            end
+
+            # Verify that its dependencies are there, and add
+            # them to the selected_packages set so that they get
+            # imported as well
+            pkg.dependencies.each do |dep_name|
+                begin
+                    verify_package_availability(dep_name)
+                rescue ConfigError => e
+                    raise e, "#{pkg_name} depends on #{dep_name}, but #{e.message}"
+                end
+            end
+        end
+
         def self.import_packages(selected_packages)
             selected_packages = selected_packages.dup.
                 map do |pkg_name|
@@ -309,6 +392,7 @@ module Autoproj
                 Autobuild.do_update = old_update_flag
             end
 
+            known_available_packages = Set.new
             all_enabled_packages = Set.new
 
             package_queue = selected_packages.dup
@@ -320,6 +404,12 @@ module Autoproj
                     delete_if { |pkg| all_enabled_packages.include?(pkg.name) }
                 all_enabled_packages |= current_packages.map(&:name).to_set
 
+                # Recursively check that no package in the selection depend on
+                # excluded packages
+                current_packages.each do |pkg|
+                    verify_package_availability(pkg.name)
+                end
+
                 # We import first so that all packages can export the
                 # additional targets they provide.
                 current_packages.each do |pkg|
@@ -334,21 +424,14 @@ module Autoproj
                 end
 
                 current_packages.each do |pkg|
+                    verify_package_availability(pkg.name)
                     Rake::Task["#{pkg.name}-prepare"].invoke
 
                     # Verify that its dependencies are there, and add
                     # them to the selected_packages set so that they get
                     # imported as well
                     pkg.dependencies.each do |dep_name|
-                        if reason = Autoproj.manifest.exclusion_reason(dep_name)
-                            raise ConfigError, "#{pkg.name} depends on #{dep_name}, which is excluded from the build: #{reason}"
-                        end
-                        dep_pkg = Autobuild::Package[dep_name]
-                        if !dep_pkg
-                            raise ConfigError, "#{pkg.name} depends on #{dep_name}, but it does not seem to exist"
-                        end
-
-                        package_queue << dep_pkg
+                        package_queue << Autobuild::Package[dep_name]
                     end
                 end
             end
@@ -630,6 +713,7 @@ where 'mode' is one of:
                 Autobuild.do_update = false
                 @update_os_dependencies = true
                 Autobuild.do_build  = false
+                Autoproj::OSDependencies.force_osdeps = true
             when "status"
                 @only_status = true
                 Autobuild.do_update = false

data/lib/autoproj/manifest.rb

@@ -938,6 +938,7 @@ module Autoproj
                     if dest != source.raw_local_dir
                         FileUtils.rm_f symlink_dest
                     end
+                    FileUtils.ln_sf source.raw_local_dir, symlink_dest
                 else
                     FileUtils.rm_f symlink_dest
                     FileUtils.ln_sf source.raw_local_dir, symlink_dest
@@ -1151,9 +1152,9 @@ module Autoproj
                 begin
                     package.depends_on name
                 rescue Autobuild::ConfigException => e
-                    raise ConfigError, "manifest #{manifest_path} of #{package.name} from #{source.name} lists '#{name}' as dependency, which is listed in the layout but has no autobuild definition"
+                    raise ConfigError, "manifest #{manifest_path} of #{package.name} from #{source.name} lists '#{name}' as dependency, which is listed in the layout but has no autobuild definition", e.backtrace
                 rescue ConfigError => e
-                    raise ConfigError, "manifest #{manifest_path} of #{package.name} from #{source.name} lists '#{name}' as dependency, but it is neither a normal package nor an osdeps package. osdeps reports: #{e.message}"
+                    raise ConfigError, "manifest #{manifest_path} of #{package.name} from #{source.name} lists '#{name}' as dependency, but it is neither a normal package nor an osdeps package. osdeps reports: #{e.message}", e.backtrace
                 end
             end
         end

data/lib/autoproj/options.rb

@@ -23,12 +23,14 @@ module Autoproj
         end
 
         def ask(current_value)
-            default_value = if current_value then current_value.to_s
-                            elsif options[:default] then options[:default].to_str
-                            else ''
-                            end
-
-            STDERR.print "  #{doc} [#{default_value}] "
+            default_value =
+		if current_value then current_value.to_s
+		elsif options[:default] then options[:default].to_str
+		else ''
+		end
+
+            STDOUT.print "  #{doc} [#{default_value}] "
+            STDOUT.flush
             answer = STDIN.readline.chomp
             if answer == ''
                 answer = default_value
@@ -90,7 +92,11 @@ module Autoproj
             value = configure(key)
         else
             if !seen
-                Autoproj.progress "  #{@declared_options[key].doc}: #{value}"
+                doc = @declared_options[key].doc
+                if doc[-1, 1] != "?"
+                    doc = "#{doc}:"
+                end
+                Autoproj.progress "  #{doc} #{value}"
                 @user_config[key] = [value, true]
             end
             value
@@ -102,6 +108,10 @@ module Autoproj
         @declared_options[name] = BuildOption.new(name, type, options, validator)
     end
 
+    def self.declared_option?(name)
+	@declared_options.has_key?(name)
+    end
+
     def self.configure(option_name)
         if opt = @declared_options[option_name]
             if current_value = @user_config[option_name]

data/lib/autoproj/osdeps.rb

@@ -15,6 +15,8 @@ module Autoproj
 
         class << self
             attr_reader :aliases
+            attr_accessor :force_osdeps
+            attr_accessor :gem_with_prerelease
         end
         @aliases = Hash.new
 
@@ -142,11 +144,13 @@ module Autoproj
                         ['gentoo', [version]]
                     elsif File.exists?('/etc/arch-release')
                         ['arch', []]
-                    else
-                        raise ConfigError, "Unknown operating system"
                     end
             end
 
+            if !@operating_system
+                return
+            end
+
             # Normalize the names to lowercase
             @operating_system =
                 [@operating_system[0].downcase,
@@ -182,62 +186,118 @@ module Autoproj
             'arch' => 'pacman -Sy --noconfirm %s'
         }
 
-        # Resolves the given OS dependencies into the actual packages that need
-        # to be installed on this particular OS.
+        NO_PACKAGE       = 0
+        WRONG_OS         = 1
+        WRONG_OS_VERSION = 2
+        IGNORE           = 3
+        PACKAGES         = 4
+        SHELL_SNIPPET    = 5
+        UNKNOWN_OS       = 7
+        AVAILABLE        = 10
+
+        # Check for the definition of +name+ for this operating system
         #
-        # Raises ConfigError if some packages can't be found
-        def resolve_os_dependencies(dependencies)
+        # It can return
+        #
+        # NO_PACKAGE::
+        #   there are no package definition for +name
+        # UNKNOWN_OS::
+        #   this is not an OS autoproj knows how to deal with
+        # WRONG_OS::
+        #   there are a package definition, but not for this OS
+        # WRONG_OS_VERSION::
+        #   there is a package definition for this OS, but not for this
+        #   particular version of the OS
+        # IGNORE::
+        #   there is a package definition that told us to ignore the package
+        # [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
-            if !OS_PACKAGE_INSTALL.has_key?(os_name)
-                raise ConfigError, "I don't know how to install packages on #{os_name}"
+
+            dep_def = definitions[name]
+            if !dep_def
+                return NO_PACKAGE
             end
 
-            os_packages    = []
-            shell_snippets = []
-            dependencies.each do |name|
-                dep_def = definitions[name]
-                if !dep_def
-                    raise ConfigError, "I don't know how to install '#{name}'"
-                end
+            if !os_name
+                return UNKNOWN_OS
+            end
+
+            # Find a matching entry for the OS name
+            os_entry = dep_def.find do |name_list, data|
+                name_list.split(',').
+                    map(&:downcase).
+                    any? { |n| n == os_name }
+            end
+
+            if !os_entry
+                return WRONG_OS
+            end
+
+            data = os_entry.last
 
-                # Find a matching entry for the OS name
-                os_entry = dep_def.find do |name_list, data|
-                    name_list.split(',').
+            # This package does not need to be installed on this operating system (example: build tools on Gentoo)
+            if !data || data == "ignore"
+                return IGNORE
+            end
+
+            if data.kind_of?(Hash)
+                version_entry = data.find do |version_list, data|
+                    version_list.to_s.split(',').
                         map(&:downcase).
-                        any? { |n| n == os_name }
+                        any? do |v|
+                        os_version.any? { |osv| Regexp.new(v) =~ osv }
+                        end
                 end
 
-                if !os_entry
-                    raise ConfigError, "I don't know how to install '#{name}' on #{os_name}"
+                if !version_entry
+                    return WRONG_OS_VERSION
                 end
+                data = version_entry.last
+            end
 
-                data = os_entry.last
-
-                # This package does not need to be installed on this operating system (example: build tools on Gentoo)
-                next if !data || data == "ignore"
+            if data.respond_to?(:to_ary)
+                return [PACKAGES, data]
+            elsif data.to_str =~ /\w+/
+                return [PACKAGES, [data.to_str]]
+            else
+                return [SHELL_SNIPPET, data.to_str]
+            end
+        end
 
-                if data.kind_of?(Hash)
-                    version_entry = data.find do |version_list, data|
-                        version_list.to_s.split(',').
-                            map(&:downcase).
-                            any? do |v|
-                                os_version.any? { |osv| Regexp.new(v) =~ osv }
-                            end
-                    end
+        # Resolves the given OS dependencies into the actual packages that need
+        # to be installed on this particular OS.
+        #
+        # Raises ConfigError if some packages can't be found
+        def resolve_os_dependencies(dependencies)
+            os_name, os_version = OSDependencies.operating_system
 
-                    if !version_entry
-                        raise ConfigError, "I don't know how to install '#{name}' on this specific version of #{os_name} (#{os_version.join(", ")})"
-                    end
-                    data = version_entry.last
+            os_packages    = []
+            shell_snippets = []
+            dependencies.each do |name|
+                result = resolve_package(name)
+                if result == NO_PACKAGE
+                    raise ConfigError, "there is no osdeps definition for #{name}"
+                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"
+                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 data.respond_to?(:to_ary)
-                    os_packages.concat data.to_ary
-                elsif data.to_str =~ /\w+/
-                    os_packages << data.to_str
-                else
-                    shell_snippets << data.to_str
-                end
+            if !OS_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
@@ -254,14 +314,27 @@ module Autoproj
                 "\n" + shell_snippets.join("\n")
         end
 
-        # Returns true if there is an operating-system package with that name,
-        # and false otherwise
+        # Returns true if +name+ is an acceptable OS package for this OS and
+        # version
         def has?(name)
+            availability_of(name) == AVAILABLE
+        end
+
+        # If +name+ is an osdeps that is available for this operating system,
+        # returns AVAILABLE. Otherwise, returns the same error code than
+        # resolve_package.
+        def availability_of(name)
             osdeps, gemdeps = partition_packages([name].to_set)
-            resolve_os_dependencies(osdeps)
-            true
-        rescue ConfigError
-            false
+            if !osdeps.empty?
+                status = resolve_package(name)
+                if status.respond_to?(:to_ary) || status == IGNORE
+                    AVAILABLE
+                else
+                    status
+                end
+            else
+                AVAILABLE
+            end
         end
 
         # call-seq:
@@ -282,12 +355,10 @@ module Autoproj
             package_set.to_set.each do |name|
                 pkg_def = definitions[name]
                 if !pkg_def
-                    msg = "I know nothing about a prepackaged software called '#{name}'"
-                    if pkg_names = package_osdeps[name]
-                        msg += ", it is listed as dependency of the following package(s): #{pkg_names.join(", ")}"
-                    end
-
-                    raise ConfigError, msg
+                    # Error cases are taken care of later, because that is were
+                    # the automatic/manual osdeps logic lies
+                    osdeps << name
+                    next
                 end
 
                 pkg_def = pkg_def.dup
@@ -298,6 +369,9 @@ module Autoproj
                     when "gem" then
                         gems << name
                     else
+                        # This is *not* handled later, as is the absence of a
+                        # package definition. The reason is that it is a bad
+                        # configuration file, and should be fixed by the user
                         raise ConfigError, "unknown OS-independent package management type #{pkg_def} for #{name}"
                     end
                 else
@@ -328,19 +402,123 @@ module Autoproj
             end
         end
 
+        def filter_uptodate_gems(gems)
+            Autobuild.progress "looking for RubyGems updates"
+
+            # Don't install gems that are already there ...
+            gems = gems.dup
+            gems.delete_if do |name|
+                version_requirements = Gem::Requirement.default
+                installed = Gem.source_index.find_name(name, version_requirements)
+                if !installed.empty? && Autobuild.do_update
+                    # Look if we can update the package ...
+                    dep = Gem::Dependency.new(name, version_requirements)
+                    available = gem_fetcher.find_matching(dep)
+                    installed_version = installed.map(&:version).max
+                    available_version = available.map { |(name, v), source| v }.max
+                    needs_update = (available_version > installed_version)
+                    !needs_update
+                else
+                    !installed.empty?
+                end
+            end
+            gems
+        end
+
+        AUTOMATIC = true
+        MANUAL    = false
+        WAIT      = :wait
+        ASK       = :ask
+
+        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
+            else
+                Autoproj.user_config('automatic_osdeps')
+            end
+        end
+
         # Requests the installation of the given set of packages
         def install(packages, package_osdeps = Hash.new)
+            os_def = OSDependencies.operating_system
             osdeps, gems = partition_packages(packages, package_osdeps)
+            gems = filter_uptodate_gems(gems)
+            if osdeps.empty? && gems.empty?
+                return
+            end
+
+            if automatic_osdeps_mode == AUTOMATIC && !os_def && !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 automatic_osdeps_mode == ASK
+                    print "Should I install these packages ? [yes] "
+                    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
+                        end
+                    end
+                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
+                end
+
+                if !do_osdeps
+                    return
+                end
+            end
 
             did_something = false
 
-            # Ideally, we would feed the OS dependencies to rosdep.
-            # Unfortunately, this is C++ code and I don't want to install the
-            # whole ROS stack just for rosdep ...
-            #
-            # So, for now, reimplement rosdep by ourselves. Given how things
-            # are done, this is actually not so hard.
-            if !osdeps.empty?
+            if os_def && !osdeps.empty?
                 shell_script = generate_os_script(osdeps)
                 if Autoproj.verbose
                     Autoproj.progress "Installing non-ruby OS dependencies with"
@@ -360,35 +538,25 @@ module Autoproj
             end
 
             if !gems.empty?
-                Autobuild.progress "looking for RubyGems updates"
-                # Don't install gems that are already there ...
-                gems.delete_if do |name|
-                    version_requirements = Gem::Requirement.default
-                    installed = Gem.source_index.find_name(name, version_requirements)
-                    if !installed.empty? && Autobuild.do_update
-                        # Look if we can update the package ...
-                        dep = Gem::Dependency.new(name, version_requirements)
-                        available = gem_fetcher.find_matching(dep)
-                        installed_version = installed.map(&:version).max
-                        available_version = available.map { |(name, v), source| v }.max
-                        needs_update = (available_version > installed_version)
-                        !needs_update
-                    else
-                        !installed.empty?
-                    end
-                end
+                gems = filter_uptodate_gems(gems)
             end
 
             # Now install what is left
             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 Autobuild::OSDependencies.gem_with_prerelease
+                    cmdline << "--prerelease"
+                end
+                cmdline.concat(gems)
+
                 Autobuild.progress "installing/updating RubyGems dependencies: #{gems.join(", ")}"
-                Autobuild::Subprocess.run 'autoproj', 'osdeps', Autobuild.tool('gem'), 'install', *gems
+                Autobuild::Subprocess.run 'autoproj', 'osdeps', *cmdline
                 did_something ||= true
             end