autoproj 1.6.1 → 1.6.2.rc2

data/Rakefile

@@ -51,6 +51,7 @@ namespace 'dist' do
     task 'bootstrap' do
         require 'yaml'
         osdeps_code = File.read(File.join(Dir.pwd, 'lib', 'autoproj', 'osdeps.rb'))
+        options_code = File.read(File.join(Dir.pwd, 'lib', 'autoproj', 'options.rb'))
         osdeps_defaults = File.read(File.join(Dir.pwd, 'lib', 'autoproj', 'default.osdeps'))
         # Filter rubygems dependencies from the OSdeps default. They will be
         # installed at first build
@@ -67,6 +68,7 @@ namespace 'dist' do
 
         bootstrap_code = File.read(File.join(Dir.pwd, 'bin', 'autoproj_bootstrap.in')).
             gsub('OSDEPS_CODE', osdeps_code).
+            gsub('OPTIONS_CODE', options_code).
             gsub('OSDEPS_DEFAULTS', osdeps_defaults)
         File.open(File.join(Dir.pwd, 'doc', 'guide', 'src', 'autoproj_bootstrap'), 'w') do |io|
             io.write bootstrap_code

data/bin/autoproj

@@ -21,8 +21,8 @@ end
 def report(debug)
     Autobuild::Reporting.report do
         yield
-        Autobuild::Reporting.success
     end
+    Autobuild::Reporting.success
 
 rescue ConfigError => e
     STDERR.puts
@@ -51,7 +51,7 @@ Autoproj::OSDependencies.autodetect_ruby
 report(Autobuild.debug) do
     selected_packages =
         begin Autoproj::CmdLine.parse_arguments(ARGV.dup)
-        rescue Exception => e
+        rescue RuntimeError => e
             if Autoproj::CmdLine.bootstrap? && !Autoproj.in_autoproj_installation?(Dir.pwd)
                 STDERR.puts <<EOTEXT
 
@@ -86,8 +86,10 @@ EOTEXT
 
     # Basic initialization
     Autoproj::CmdLine.initialize
-    Autoproj::CmdLine.update_myself
-    Autoproj::CmdLine.update_configuration
+    if selected_packages.empty?
+        Autoproj::CmdLine.update_myself
+        Autoproj::CmdLine.update_configuration
+    end
     Autoproj::CmdLine.load_configuration
     manifest = Autoproj.manifest
 
@@ -154,6 +156,12 @@ EOTEXT
         all_enabled_packages = Autoproj::CmdLine.import_packages(selected_packages)
         Autoproj::CmdLine.snapshot(Autoproj::CmdLine.snapshot_dir, all_enabled_packages)
         exit(0)
+    elsif Autoproj::CmdLine.revshow_osdeps?
+        all_enabled_packages = Autoproj::CmdLine.import_packages(selected_packages)
+        Autoproj::CmdLine.revshow_osdeps(all_enabled_packages)
+    elsif Autoproj::CmdLine.show_osdeps?
+        all_enabled_packages = Autoproj::CmdLine.import_packages(selected_packages)
+        Autoproj::CmdLine.show_osdeps(all_enabled_packages)
     end
 
     STDERR.puts
@@ -165,36 +173,39 @@ EOTEXT
         Autoproj.osdeps.install(Autoproj.build_system_dependencies)
     end
 
-    begin
-        # Now, we actually do the import. Unfortunately, at this stage, we need to
-        # import the package and its dependencies ourselves so that we are able to
-        # build the list of packages that have actually been selected on the command
-        # line.
-        all_enabled_packages = Autoproj::CmdLine.import_packages(selected_packages)
-
-        if Autoproj::CmdLine.build? || Autoproj::CmdLine.doc? || Autoproj::CmdLine.update_os_dependencies?
-            if all_enabled_packages.empty?
-                STDERR.puts color("autoproj: nothing to do", :bold)
-            elsif Autoproj::CmdLine.build? || Autoproj::CmdLine.doc?
-                Autoproj::CmdLine.build_packages(selected_packages, all_enabled_packages)
-            elsif Autoproj::CmdLine.update_os_dependencies?
-                manifest.install_os_dependencies(all_enabled_packages)
-            end
+    # Now, we actually do the import. Unfortunately, at this stage, we need to
+    # import the package and its dependencies ourselves so that we are able to
+    # build the list of packages that have actually been selected on the command
+    # line.
+    all_enabled_packages = Autoproj::CmdLine.import_packages(selected_packages)
+
+    if all_enabled_packages.empty?
+        STDERR.puts color("autoproj: nothing to do", :bold)
+    elsif Autoproj::CmdLine.update_os_dependencies?
+        manifest.install_os_dependencies(all_enabled_packages)
+    elsif Autoproj::CmdLine.doc?
+        Autoproj::CmdLine.build_packages(selected_packages, all_enabled_packages)
+    elsif Autoproj::CmdLine.build? 
+        begin
+            Autoproj::CmdLine.build_packages(selected_packages, all_enabled_packages)
 
             # Now, do some sanity checks on the result
             prefixes = all_enabled_packages.inject(Set.new) do |set, pkg_name|
                 set << Autobuild::Package[pkg_name].prefix
             end
+
+            Autoproj.progress
+            Autoproj.progress "checking for undefined symbols in installed libraries", :bold
             prefixes.each do |prefix|
                 libdir = File.join(prefix, "lib")
                 if File.directory?(libdir)
                     Autoproj.validate_solib_dependencies(libdir)
                 end
             end
+        ensure
+            Autoproj.export_env_sh
+            STDERR.puts color("autoproj: updated #{Autoproj.root_dir}/env.sh", :green)
         end
-    ensure
-        Autoproj.export_env_sh
-        STDERR.puts color("autoproj: updated #{Autoproj.root_dir}/env.sh", :green)
     end
 end
 

data/doc/guide/src/autoproj_bootstrap

@@ -5,6 +5,30 @@ if RUBY_VERSION < "1.8.7"
     exit 1
 end
 
+require 'set'
+curdir_entries = Dir.entries('.').to_set - [".", "..", "autoproj_bootstrap", ".gems", 'env.sh'].to_set
+if !curdir_entries.empty? && ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] != '1'
+    while true
+        print "The current directory is not empty, continue bootstrapping anyway ? [yes] "
+        STDOUT.flush 
+        answer = STDIN.readline.chomp
+        if answer == "no"
+            exit
+        elsif answer == "" || answer == "yes"
+            # Set the environment variable since we might restart the
+            # autoproj_bootstrap script and -- anyway -- will run "autoproj
+            # bootstrap" later on
+            break
+        else
+            STDOUT.puts "invalid answer. Please answer 'yes' or 'no'"
+            STDOUT.flush
+        end
+    end
+end
+
+# Environment is clean, so just mark it as so unconditionally
+ENV['AUTOPROJ_BOOTSTRAP_IGNORE_NONEMPTY_DIR'] = '1'
+
 needed_gem_home = ENV['AUTOPROJ_GEM_HOME'] || "#{Dir.pwd}/.gems"
 if $LOADED_FEATURES.find { |str| str =~ /bygems/ }
     if ENV['GEM_HOME'] != needed_gem_home
@@ -27,26 +51,15 @@ module Autoproj
     class ConfigError < RuntimeError; end
     class << self
         attr_reader :verbose
-        attr_reader :config
-    end
-    @config = Hash.new
-
-    # Fake option management for the OSdeps class
-    def self.has_config_key?(key)
-        config.has_key?(key)
-    end
-
-    def self.user_config(key)
-        config[key]
-    end
-
-    def self.change_option(name, value, ignored = true)
-        config[name] = value
     end
 
     def self.color(string, *args)
         string
     end
+
+    def self.progress(str)
+        STDERR.puts "  #{str}"
+    end
 end
 
 module Autobuild
@@ -106,6 +119,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
@@ -138,17 +154,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
@@ -194,10 +217,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
@@ -214,11 +242,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
@@ -266,15 +297,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'",
@@ -286,7 +350,6 @@ module Autoproj
         WRONG_OS_VERSION = 2
         IGNORE           = 3
         PACKAGES         = 4
-        SHELL_SNIPPET    = 5
         UNKNOWN_OS       = 7
         AVAILABLE        = 10
 
@@ -308,9 +371,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
 
@@ -346,7 +406,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
 
@@ -361,7 +421,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
 
@@ -373,7 +433,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
@@ -381,32 +440,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
@@ -497,9 +554,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|
@@ -520,143 +593,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
+
+            @osdeps_mode = OSDependencies.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] "
+        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
@@ -664,9 +894,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
@@ -675,53 +907,206 @@ module Autoproj
 end
 
 
+module Autoproj
+    class InputError < RuntimeError; end
+
+    class BuildOption
+        attr_reader :name
+        attr_reader :type
+        attr_reader :options
+
+        attr_reader :validator
+
+        TRUE_STRINGS = %w{on yes y true}
+        FALSE_STRINGS = %w{off no n false}
+        def initialize(name, type, options, validator)
+            @name, @type, @options = name.to_str, type.to_str, options.to_hash
+            @validator = validator.to_proc if validator
+            if !BuildOption.respond_to?("validate_#{type}")
+                raise ConfigError, "invalid option type #{type}"
+            end
+        end
+
+        def short_doc
+            if short_doc = options[:short_doc]
+                short_doc
+            elsif doc = options[:doc]
+                if doc.respond_to?(:to_ary) then doc.first
+                else doc
+                end
+            else "#{name} (no documentation for this option)"
+            end
+        end
+
+        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], :bold)
+                remaining = doc[1..-1]
+                if !remaining.empty?
+                    remaining = remaining.join("\n").split("\n").join("\n    ")
+                    first_line + "\n    " + remaining
+                end
+            else
+                doc
+            end
+        end
+
+        def ask(current_value, doc = nil)
+            default_value =
+		if current_value then current_value.to_s
+		elsif options[:default] then options[:default].to_str
+		else ''
+		end
+
+            STDOUT.print "  #{doc || self.doc} [#{default_value}] "
+            STDOUT.flush
+            answer = STDIN.readline.chomp
+            if answer == ''
+                answer = default_value
+            end
+            validate(answer)
+
+        rescue InputError => e
+            Autoproj.progress("invalid value: #{e.message}", :red)
+            retry
+        end
+
+        def validate(value)
+            value = BuildOption.send("validate_#{type}", value, options)
+            if validator
+                value = validator[value]
+            end
+            value
+        end
+
+        def self.validate_boolean(value, options)
+            if TRUE_STRINGS.include?(value.downcase)
+                true
+            elsif FALSE_STRINGS.include?(value.downcase)
+                false
+            else
+                raise InputError, "invalid boolean value '#{value}', accepted values are '#{TRUE_STRINGS.join(", ")}' for true, and '#{FALSE_STRINGS.join(", ")} for false"
+            end
+        end
+
+        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
+            end
+            value
+        end
+    end
+
+    @user_config = Hash.new
+
+    def self.option_set
+        @user_config.inject(Hash.new) do |h, (k, v)|
+            h[k] = v.first
+            h
+        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
+
+    def self.user_config(key)
+        value, seen = @user_config[key]
+        # All non-user options are always considered as "seen"
+        seen ||= !@declared_options.has_key?(key)
+
+        if value.nil? || (!seen && Autoproj.reconfigure?)
+            value = configure(key)
+        else
+            if !seen
+                doc = @declared_options[key].short_doc
+                if doc[-1, 1] != "?"
+                    doc = "#{doc}:"
+                end
+                Autoproj.progress "  #{doc} #{value}"
+                @user_config[key] = [value, true]
+            end
+            value
+        end
+    end
+
+    @declared_options = Hash.new
+    def self.configuration_option(name, type, options, &validator)
+        @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]
+                current_value = current_value.first
+            end
+            value = opt.ask(current_value)
+            @user_config[option_name] = [value, true]
+            value
+        else
+            raise ConfigError, "undeclared option '#{option_name}'"
+        end
+    end
+
+    def self.save_config
+        File.open(File.join(Autoproj.config_dir, "config.yml"), "w") do |io|
+            config = Hash.new
+            @user_config.each_key do |key|
+                config[key] = @user_config[key].first
+            end
+
+            io.write YAML.dump(config)
+        end
+    end
+
+    def self.has_config_key?(name)
+        @user_config.has_key?(name)
+    end
+
+    def self.load_config
+        config_file = File.join(Autoproj.config_dir, "config.yml")
+        if File.exists?(config_file)
+            config = YAML.load(File.read(config_file))
+            config.each do |key, value|
+                @user_config[key] = [value, false]
+            end
+        end
+    end
+
+    class << self
+        attr_accessor :reconfigure
+    end
+    def self.reconfigure?; @reconfigure end
+end
+
+
 
 DEFS = <<EODEFS
 --- 
-svn: 
-  arch: subversion
-  gentoo: dev-util/subversion
-  debian,ubuntu: subversion
-autobuild: gem
-zlib: 
-  debian,ubuntu: zlib1g-dev
-libxml2: 
-  arch: libxml2
-  gentoo: dev-libs/libxml2
-  debian,ubuntu: libxml2-dev
 none: ignore
-autotools: 
-  arch: automake autoconf
-  gentoo: 
-  - sys-devel/automake:1.9
-  - sys-devel/autoconf
-  debian,ubuntu: 
-  - automake1.9
-  - autoconf
-autoproj: gem
-archive: 
-  arch: 
-  - tar
-  - unzip
-  gentoo: 
-  - app-arch/tar
-  - app-arch/unzip
-  debian,ubuntu: 
-  - tar
-  - unzip
-lsb_release: 
-  arch: 
-  gentoo: sys-apps/lsb-release
-  debian,ubuntu: lsb-release
 ruby18: 
-  gentoo: 
-  - dev-lang/ruby:1.8
   debian,ubuntu: 
   - ruby1.8-dev
   - ruby1.8
   - rubygems1.8
   - ri1.8
   - libopenssl-ruby1.8
+  gentoo: 
+  - dev-lang/ruby:1.8
 ruby19: 
   debian: 
     squeeze,sid: 
@@ -732,104 +1117,72 @@ ruby19:
     - ruby1.9.1
     - ruby1.9.1-dev
     - rubygems1.9.1
-  arch: 
-  - ruby
-  gentoo: 
-  - dev-lang/ruby:1.9
   ubuntu: 
   - ruby1.9.1
   - ruby1.9.1-dev
   - rubygems1.9.1
   - ri1.9.1
   - libopenssl-ruby1.9.1
+  gentoo: 
+  - dev-lang/ruby:1.9
+  arch: 
+  - ruby
+rdoc: gem
+build-essential: 
+  debian,ubuntu: build-essential
+  gentoo: 
+  arch: 
+libxml2: 
+  debian,ubuntu: libxml2-dev
+  gentoo: dev-libs/libxml2
+  arch: libxml2
+libxslt: 
+  debian,ubuntu: libxslt1-dev
+  gentoo: dev-libs/libxslt
+  arch: libxslt
+zlib: 
+  debian,ubuntu: zlib1g-dev
+autobuild: gem
+autoproj: gem
 git: 
-  arch: git
-  gentoo: dev-vcs/git
   debian,ubuntu: git-core
+  gentoo: dev-vcs/git
+  arch: git
+svn: 
+  debian,ubuntu: subversion
+  gentoo: dev-util/subversion
+  arch: subversion
 cmake: 
-  arch: cmake
-  gentoo: dev-util/cmake
   debian,ubuntu: cmake
-build-essential: 
+  gentoo: dev-util/cmake
+  arch: cmake
+autotools: 
+  debian,ubuntu: 
+  - automake1.9
+  - autoconf
+  gentoo: 
+  - sys-devel/automake:1.9
+  - sys-devel/autoconf
+  arch: automake autoconf
+lsb_release: 
+  debian,ubuntu: lsb-release
+  gentoo: sys-apps/lsb-release
   arch: 
+archive: 
+  debian,ubuntu: 
+  - tar
+  - unzip
   gentoo: 
-  debian,ubuntu: build-essential
-libxslt: 
-  arch: libxslt
-  gentoo: dev-libs/libxslt
-  debian,ubuntu: libxslt1-dev
-rdoc: gem
+  - app-arch/tar
+  - app-arch/unzip
+  arch: 
+  - tar
+  - unzip
 
 EODEFS
 
-if ENV['AUTOPROJ_AUTOMATIC_OSDEPS']
-    automatic_osdeps = ENV['AUTOPROJ_AUTOMATIC_OSDEPS']
-else
-    if !Autoproj::OSDependencies.supported_operating_system?
-        puts <<-EOT
-
-    autoproj is usually able to handle the installation of operating system packages
-    himself. However, it does not handle your operating system (yet), and will
-    therefore have to let you install the packages yourself.
-
-    It can still install the RubyGems packages that are required by the built
-    packages.
-
-    If you answer 'no' to the following question, autoproj will always go on,
-    assuming that all the required dependencies are already installed. If you answer
-    'yes', it will make sure that the RubyGems are installed himself, but it will
-    assume that you took care of the other packages. If you answer 'wait', it will
-    not install anything but will wait for you to press ENTER each time some
-    external software is needed. Finally, if you answer 'ask', it will ask you each
-    time what it should do when there is something to install
-
-        EOT
-
-        print "How should autoproj install RubyGems packages automatically (yes, no, wait or ask) ? [yes] "
-        STDOUT.flush
-    else
-        # Before doing *anything*, we have to ask the user if he wants us to install
-        # the osdeps ...
-        puts <<-EOT
-
-    autoproj is able to handle the installation of operating system packages
-    himself. This functionality will use 'sudo' to gain root access each time
-    it is needed.
-
-    If you answer 'no' to the following question, autoproj will go on, assuming that
-    all the required dependencies are already installed. If you answer 'yes', it
-    will make sure that they are installed himself. If you answer 'wait', it will
-    not install anything but wait for you to press ENTER each time some external
-    software is needed.  Finally, if you answer 'ask', it will ask you what it
-    should do each time there is something to install.
-
-        EOT
-        print "Should autoproj install OS packages automatically (yes, no, wait or ask) ? [yes] "
-        STDOUT.flush
-    end
-
-    automatic_osdeps = nil
-    while automatic_osdeps.nil?
-        answer = STDIN.readline.chomp
-        if answer == ''
-            automatic_osdeps = true
-        elsif answer == "no"
-            automatic_osdeps = false
-        elsif answer == 'wait'
-            automatic_osdeps = :wait
-        elsif answer == 'ask'
-            automatic_osdeps = :ask
-        elsif answer == 'yes'
-            automatic_osdeps = true
-        else
-            print "invalid answer. Please answer with 'yes', 'no', 'wait' or 'ask' "
-            STDOUT.flush
-        end
-    end
-end
-
-Autoproj.config['automatic_osdeps'] =
-    automatic_osdeps
+Autoproj::OSDependencies.define_osdeps_mode_option
+ENV['AUTOPROJ_OSDEPS_MODE'] = Autoproj::OSDependencies.osdeps_mode
 
 # First thing we do is install a proper ruby environment. We make sure that we
 # aren't installing any gems for now (as we need to choose the right gem
@@ -887,7 +1240,6 @@ if ARGV.first != "localdev"
     end
     Autoproj::OSDependencies.gem_with_prerelease = false
 
-    ENV['AUTOPROJ_AUTOMATIC_OSDEPS'] = automatic_osdeps.to_s
     if !system('autoproj', 'bootstrap', *ARGV)
         STDERR.puts "ERROR: failed to run autoproj bootstrap #{ARGV.join(", ")}"
         exit 1