autoproj 2.0.0.rc9 → 2.0.0.rc10

data/bin/autoproj_install.in

@@ -12,3 +12,4 @@ ENV.delete('RUBYLIB')
 ops = Autoproj::Ops::Install.new(Dir.pwd)
 ops.parse_options(ARGV)
 ops.stage1
+ops.call_stage2

data/lib/autoproj/autobuild.rb

@@ -549,15 +549,11 @@ class Autobuild::Git
     #   only override the branch
     # @return [Hash] the snapshot information, in a format that can be used by
     #   {#relocate}
-    def snapshot(package, target_dir = nil, options = Hash.new)
-        options = Kernel.validate_options options,
-            local: true,
-            exact_state: true
-
-        if options[:local]
-            snapshot_local(package, exact_state: options[:exact_state])
+    def snapshot(package, target_dir = nil, only_local: true, exact_state: true)
+        if only_local
+            snapshot_local(package, exact_state: exact_state)
         else
-            snapshot_against_remote(package, exact_state: options[:exact_state])
+            snapshot_against_remote(package, exact_state: exact_state)
         end
     end
 

data/lib/autoproj/cli/bootstrap.rb

@@ -64,7 +64,7 @@ def run(buildconf_info, options)
 amake
 
 The resulting software is installed in
-#{root_dir}/install
+#{ws.prefix_dir}
 
                     EOTEXT
 

data/lib/autoproj/cli/locate.rb

@@ -59,7 +59,7 @@ def run(selection, options = Hash.new)
                     if name == selection || pkg.srcdir == selection
                         puts result_value(pkg, options)
                         return
-                    elsif name =~ selection_rx || selection.start_with?(pkg.srcdir)
+                    elsif name =~ selection_rx || selection.start_with?(pkg.srcdir) || (selection.start_with?(pkg.builddir) if pkg.builddir)
                         candidates << pkg
                     end
                 end

data/lib/autoproj/cli/main.rb

@@ -26,8 +26,14 @@ class Main < Thor
                 def run_autoproj_cli(filename, classname, report_options, *args)
                     require "autoproj/cli/#{filename}"
                     Autoproj.report(Hash[silent: !options[:debug], debug: options[:debug]].merge(report_options)) do
+                        options = self.options.dup
+                        # We use --local on the CLI but the APIs are expecting
+                        # only_local
+                        if options.has_key?('local')
+                            options[:only_local] = options.delete('local')
+                        end
                         cli = CLI.const_get(classname).new
-                        run_args = cli.validate_options(args, self.options)
+                        run_args = cli.validate_options(args, options)
                         cli.run(*run_args)
                     end
                 end
@@ -57,7 +63,7 @@ def envsh
             end
 
             desc 'status [PACKAGES]', 'displays synchronization status between this workspace and the package(s) source'
-            option :only_local,
+            option :local, type: :boolean, default: false,
                 desc: 'only use locally available information (mainly for distributed version control systems such as git)'
             option :mainline, type: :string,
                 desc: "compare to the given baseline. if 'true', the comparison will ignore any override, otherwise it will take into account overrides only up to the given package set"

data/lib/autoproj/cli/status.rb

@@ -27,6 +27,10 @@ def run(user_selection, options = Hash.new)
                     return
                 end
 
+                if !options.has_key?(:parallel) && options[:only_local]
+                    options[:parallel] = 1
+                end
+
                 if options[:config]
                     pkg_sets = ws.manifest.each_package_set.to_a
                     if !pkg_sets.empty?
@@ -40,7 +44,7 @@ def run(user_selection, options = Hash.new)
                 packages = packages.sort.map do |pkg_name|
                     ws.manifest.find_package(pkg_name)
                 end
-                display_status(packages, snapshot: options[:snapshot], only_local: options[:only_local])
+                display_status(packages, parallel: options[:parallel], snapshot: options[:snapshot], only_local: options[:only_local])
             end
 
             def snapshot_overrides_vcs?(importer, vcs, snapshot)
@@ -53,7 +57,7 @@ def snapshot_overrides_vcs?(importer, vcs, snapshot)
             end
 
             PackageStatus = Struct.new :msg, :sync, :uncommitted, :local, :remote
-            def status_of_package(package_description, options = Hash.new)
+            def status_of_package(package_description, only_local: false, snapshot: false)
                 pkg = package_description.autobuild
                 importer = pkg.importer
                 package_status = PackageStatus.new(Array.new, false, false, false, false)
@@ -66,7 +70,7 @@ def status_of_package(package_description, options = Hash.new)
                 else
                     if importer.respond_to?(:snapshot)
                         snapshot =
-                            begin importer.snapshot(pkg, nil, exact_state: false, local: options[:only_local])
+                            begin importer.snapshot(pkg, nil, exact_state: false, only_local: only_local)
                             rescue Autobuild::PackageException
                                 Hash.new
                             end
@@ -74,13 +78,13 @@ def status_of_package(package_description, options = Hash.new)
                             non_nil_values = snapshot.delete_if { |k, v| !v }
                             package_status.msg << Autoproj.color("  found configuration that contains all local changes: #{non_nil_values.sort_by(&:first).map { |k, v| "#{k}: #{v}" }.join(", ")}", :bright_green)
                             package_status.msg << Autoproj.color("  consider adding this to your overrides, or use autoproj versions to do it for you", :bright_green)
-                            if options[:snapshot]
+                            if snapshot
                                 importer.relocate(importer.repository, snapshot)
                             end
                         end
                     end
 
-                    begin status = importer.status(pkg, options[:only_local])
+                    begin status = importer.status(pkg, only_local)
                     rescue Interrupt
                         raise
                     rescue Exception => e
@@ -139,7 +143,10 @@ def display_status(packages, options = Hash.new)
                     pkg.autobuild.importer && pkg.autobuild.importer.interactive?
                 end
                 noninteractive = noninteractive.map do |pkg|
-                    [pkg, Concurrent::Future.execute(executor: executor) { status_of_package(pkg, snapshot: options[:snapshot], only_local: options[:only_local]) }]
+                    future = Concurrent::Future.execute(executor: executor) do
+                        status_of_package(pkg, snapshot: options[:snapshot], only_local: options[:only_local])
+                    end
+                    [pkg, future]
                 end
 
                 sync_packages = ""

data/lib/autoproj/cli/update.rb

@@ -57,7 +57,7 @@ def run(selected_packages, options)
 
                 ws.load_package_sets(
                     mainline: options[:mainline],
-                    only_local: options[:local],
+                    only_local: options[:only_local],
                     checkout_only: !options[:config] || options[:checkout_only],
                     reset: options[:reset],
                     ignore_errors: options[:keep_going],
@@ -112,7 +112,7 @@ def run(selected_packages, options)
                 source_packages, osdep_packages = 
                     ops.import_packages(selected_packages,
                                     checkout_only: options[:checkout_only],
-                                    only_local: options[:local],
+                                    only_local: options[:only_local],
                                     reset: options[:reset],
                                     recursive: options[:deps],
                                     ignore_errors: options[:keep_going],

data/lib/autoproj/cli/versions.rb

@@ -33,16 +33,15 @@ def run(user_selection, options)
                     finalize_setup(user_selection,
                                    recursive: options[:deps],
                                    ignore_non_imported_packages: true)
-
                 
                 ops = Ops::Snapshot.new(ws.manifest, ignore_errors: options[:keep_going])
 
                 versions = Array.new
                 if (config_selected && options[:config] != false) || user_selection.empty?
-                    versions += ops.snapshot_package_sets(nil, local: options[:local])
+                    versions += ops.snapshot_package_sets(nil, only_local: options[:only_local])
                 end
                 if (!config_selected && !options[:config]) || !user_selection.empty?
-                    versions += ops.snapshot_packages(packages, nil, local: options[:local])
+                    versions += ops.snapshot_packages(packages, nil, only_local: options[:only_local])
                 end
 
                 if output_file = options[:save]

data/lib/autoproj/configuration.rb

@@ -207,15 +207,36 @@ def parallel_import_level=(level)
         end
 
         def private_bundler?
-            get('private_bundler', false)
+            !!get('private_bundler', false)
+        end
+
+        def bundler_gem_home
+            get('private_bundler', Gem.user_dir)
         end
 
         def private_autoproj?
-            get('private_autoproj', false)
+            !!get('private_autoproj', false)
+        end
+
+        def autoproj_gem_home
+            get('private_autoproj', Gem.user_dir)
         end
 
         def private_gems?
-            get('private_gems', false)
+            !!get('private_gems', false)
+        end
+
+        def gems_gem_home
+            value = get('private_gems', false)
+            if value.respond_to?(:to_str)
+                return value
+            elsif value
+                default = File.join(ws.prefix_dir, 'gems')
+                set('private_gems', default)
+                default
+            else
+                Gem.user_dir
+            end
         end
 
         def ruby_executable
@@ -229,13 +250,15 @@ def ruby_executable
         end
 
         def validate_ruby_executable
+            actual   = OSPackageResolver.autodetect_ruby_program
             if has_value_for?('ruby_executable')
                 expected = get('ruby_executable')
-                if expected != ruby_executable
-                    raise ConfigError.new, "this autoproj installation was bootstrapped using #{expected}, but you are currently running under #{ruby_executable}. This is usually caused by calling a wrong gem program (for instance, gem1.8 instead of gem1.9.1)"
+                if expected != actual
+                    raise ConfigError.new, "this autoproj installation was bootstrapped using #{expected}, but you are currently running under #{actual}. This is usually caused by manually calling a wrong gem program (for instance, gem2.1 instead of gem2.0)"
                 end
+            else
+                set('ruby_executable', actual, true)
             end
-            set('ruby_executable', ruby_executable, true)
         end
 
         def use_prerelease?
@@ -441,4 +464,3 @@ def prefer_indep_over_os_packages?
         end
     end
 end
-

data/lib/autoproj/default.osdeps

@@ -207,6 +207,7 @@ pip:
   freebsd: pip
 
 sudo:
+  macos-brew: ignore
   default: sudo
 
 # vim: expandtab

data/lib/autoproj/ops/configuration.rb

@@ -225,6 +225,9 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
             by_repository_id = Hash.new
             by_name = Hash.new
 
+            required_remotes_dirs = Array.new
+            required_user_dirs = Array.new
+
             queue = queue_auto_imports_if_needed(Array.new, root_pkg_set, root_pkg_set)
             while !queue.empty?
                 vcs, import_options, imported_from = queue.shift
@@ -243,17 +246,30 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
                 end
                 by_repository_id[repository_id] = [vcs, imported_from]
 
+                # Make sure the package set has been already checked out to
+                # retrieve the actual name of the package set
                 if !vcs.local?
                     update_remote_package_set(vcs, options)
                     create_remote_set_user_dir(vcs)
+                    raw_local_dir = PackageSet.raw_local_dir_of(vcs)
+                    required_remotes_dirs << raw_local_dir
                 end
 
                 name = PackageSet.name_of(ws.manifest, vcs)
+
+                required_user_dirs = by_name.collect { |k,v| k }
+                Autoproj.debug "Trying to load package_set: #{name} from definition #{repository_id}"
+                Autoproj.debug "Already loaded package_sets are: #{required_user_dirs}"
+
                 if already_loaded = by_name[name]
                     already_loaded_pkg_set, already_loaded_vcs = *already_loaded
                     if already_loaded_vcs != vcs
                         if imported_from
-                            Autoproj.warn "#{imported_from.name} auto-imports a package set from #{vcs}, but a package set with the same name (#{name}) has already been imported from #{already_loaded_vcs}, I am skipping this one"
+                            Autoproj.warn "redundant auto-import by #{imported_from.name} for package set '#{name}'."
+                            Autoproj.warn "    A package set with the same name (#{name}) has already been imported from"
+                            Autoproj.warn "        #{already_loaded_vcs}"
+                            Autoproj.warn "    Skipping the following one: "
+                            Autoproj.warn "        #{vcs}"
                         else
                             Autoproj.warn "the manifest refers to a package set from #{vcs}, but a package set with the same name (#{name}) has already been imported from #{already_loaded_vcs}, I am skipping this one"
                         end
@@ -264,6 +280,8 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
                         imported_from.imports << already_loaded_pkg_set
                     end
                     next
+                else
+                    create_remote_set_user_dir(vcs)
                 end
 
                 pkg_set = load_package_set(vcs, import_options, imported_from)
@@ -276,18 +294,20 @@ def load_and_update_package_sets(root_pkg_set, options = Hash.new)
                 queue_auto_imports_if_needed(queue, pkg_set, root_pkg_set)
             end
 
-            cleanup_remotes_dir(package_sets)
-            cleanup_remotes_user_dir(package_sets)
+            cleanup_remotes_dir(package_sets, required_remotes_dirs)
+            cleanup_remotes_user_dir(package_sets, required_user_dirs)
             package_sets
         end
 
         # Removes from {remotes_dir} the directories that do not match a package
         # set
-        def cleanup_remotes_dir(package_sets = ws.manifest.package_sets)
+        def cleanup_remotes_dir(package_sets = ws.manifest.package_sets, required_remotes_dirs = Array.new)
             # Cleanup the .remotes and remotes_symlinks_dir directories
             Dir.glob(File.join(remotes_dir, '*')).each do |dir|
                 dir = File.expand_path(dir)
-                if File.directory?(dir) && !package_sets.find { |pkg| pkg.raw_local_dir == dir }
+                # Once a package set has been checked out during the process,
+                # keep it -- so that it won't be checked out again
+                if File.directory?(dir) && !required_remotes_dirs.include?(dir)
                     FileUtils.rm_rf dir
                 end
             end
@@ -295,10 +315,11 @@ def cleanup_remotes_dir(package_sets = ws.manifest.package_sets)
 
         # Removes from {remotes_user_dir} the directories that do not match a
         # package set
-        def cleanup_remotes_user_dir(package_sets = ws.manifest.package_sets)
+        def cleanup_remotes_user_dir(package_sets = ws.manifest.package_sets, required_user_dirs = Array.new)
             Dir.glob(File.join(remotes_user_dir, '*')).each do |file|
                 file = File.expand_path(file)
-                if File.symlink?(file) && !package_sets.find { |pkg_set| pkg_set.user_local_dir == file }
+                user_dir = File.basename(file)
+                if File.symlink?(file) && !required_user_dirs.include?(user_dir)
                     FileUtils.rm_f file
                 end
             end

data/lib/autoproj/ops/install.rb

@@ -30,20 +30,15 @@ def initialize(root_dir)
                     @gemfile = default_gemfile_contents
                 end
 
-                load_config
-                @local = false
-                @env = self.class.clean_env
-            end
-
-            def self.clean_env
-                env = Hash.new
+                @env = Hash.new
                 env['RUBYLIB'] = []
                 env['GEM_PATH'] = []
-                %w{PATH GEM_HOME}.each do |name|
-                    env[name] = sanitize_env(ENV[name] || "")
-                end
+                env['GEM_HOME'] = []
+                env['PATH'] = self.class.sanitize_env(ENV['PATH'] || "")
                 env['BUNDLE_GEMFILE'] = []
-                env
+
+                load_config
+                @local = false
             end
 
             def env_for_child
@@ -81,7 +76,7 @@ def self.in_workspace?(base_dir)
 
 
             def dot_autoproj; File.join(root_dir, '.autoproj') end
-            def bundler_install_dir; File.join(dot_autoproj, 'bundler') end
+
             def autoproj_install_dir; File.join(dot_autoproj, 'autoproj') end
             # The path to the gemfile used to install autoproj
             def autoproj_gemfile_path; File.join(autoproj_install_dir, 'Gemfile') end
@@ -93,18 +88,47 @@ def local?; !!@local end
             def local=(flag); @local = flag end
 
             # Whether bundler should be installed locally in {#dot_autoproj}
-            def private_bundler?; @private_bundler end
+            def private_bundler?; !!@private_bundler end
+            # The path to the directory into which the bundler gem should be
+            # installed
+            def bundler_gem_home; @private_bundler || gem_bindir end
             # (see #private_bundler?)
-            def private_bundler=(flag); @private_bundler = !!flag end
+            def private_bundler=(flag)
+                @private_bundler =
+                    if flag.respond_to?(:to_str) then File.expand_path(flag)
+                    elsif flag
+                        File.join(dot_autoproj, 'bundler')
+                    end
+            end
+
             # Whether autoproj should be installed locally in {#dot_autoproj}
-            def private_autoproj?; @private_autoproj end
+            def private_autoproj?; !!@private_autoproj end
+            # The path to the directory into which the autoproj gem should be
+            # installed
+            def autoproj_gem_home; @private_autoproj || gem_bindir end
             # (see #private_autoproj?)
-            def private_autoproj=(flag); @private_autoproj = !!flag end
-            # Whether bundler should be installed locally in the workspace
-            # prefix directory
-            def private_gems?; @private_gems end
+            def private_autoproj=(flag)
+                @private_autoproj =
+                    if flag.respond_to?(:to_str) then File.expand_path(flag)
+                    elsif flag
+                        File.join(dot_autoproj, 'autoproj')
+                    end
+            end
+
+            # Whether autoproj should be installed locally in {#dot_autoproj}
+            #
+            # Unlike for {#private_autoproj?} and {#private_bundler?}, there is
+            # no default path to save the gems as we don't yet know the path to
+            # the prefix directory
+            def private_gems?; !!@private_gems end
             # (see #private_gems?)
-            def private_gems=(flag); @private_gems = !!flag end
+            def private_gems=(value)
+                @private_gems =
+                    if value.respond_to?(:to_str) then File.expand_path(value)
+                    else value
+                    end
+            end
+
             # Whether autoproj should prefer OS-independent packages over their
             # OS-packaged equivalents (e.g. the thor gem vs. the ruby-thor
             # Debian package)
@@ -146,19 +170,19 @@ def parse_options(args = ARGV)
                     opt.on '--local', 'do not access the network (may fail)' do
                         @local = true
                     end
-                    opt.on '--private-bundler', 'install bundler locally in the workspace' do
-                        @private_bundler = true
+                    opt.on '--private-bundler[=PATH]', 'install bundler locally in the workspace' do |path|
+                        self.private_bundler = path || true
                     end
-                    opt.on '--private-autoproj', 'install autoproj locally in the workspace' do
-                        @private_autoproj = true
+                    opt.on '--private-autoproj[=PATH]', 'install autoproj locally in the workspace' do |path|
+                        self.private_autoproj = path || true
                     end
-                    opt.on '--private-gems', 'install gems locally in the prefix directory' do
-                        @private_gems = true
+                    opt.on '--private-gems[=PATH]', 'install gems locally in the prefix directory' do |path|
+                        self.private_gems = path || true
                     end
-                    opt.on '--private', 'whether bundler, autoproj and the workspace gems should be installed locally in the workspace' do
-                        @private_bundler = true
-                        @private_autoproj = true
-                        @private_gems = true
+                    opt.on '--private[=PATH]', 'whether bundler, autoproj and the workspace gems should be installed locally in the workspace' do |path|
+                        self.private_bundler = path || true
+                        self.private_autoproj = path || true
+                        self.private_gems = path || true
                     end
                     opt.on '--version=VERSION_CONSTRAINT', String, 'use the provided string as a version constraint for autoproj' do |version|
                         @gemfile = default_gemfile_contents(version)
@@ -180,54 +204,51 @@ def install_bundler
                 local = ['--local'] if local?
 
                 result = system(
-                    env_for_child.merge('GEM_PATH' => nil, 'GEM_HOME' => bundler_install_dir),
-                    gem_program, 'install', '--no-document', '--no-user-install', '--no-format-executable',
+                    env_for_child.merge('GEM_PATH' => "", 'GEM_HOME' => bundler_gem_home),
+                    gem_program, 'install', '--no-document', '--no-format-executable',
                         *local,
-                        "--bindir=#{File.join(bundler_install_dir, 'bin')}", 'bundler')
+                        "--bindir=#{File.join(bundler_gem_home, 'bin')}", 'bundler')
 
                 if !result
                     STDERR.puts "FATAL: failed to install bundler in #{dot_autoproj}"
                     exit 1
                 end
-                env['PATH'].unshift File.join(bundler_install_dir, 'bin')
-                File.join(bundler_install_dir, 'bin', 'bundler')
+                File.join(bundler_gem_home, 'bin', 'bundler')
             end
 
             def find_bundler
-                self.env['PATH'].unshift gem_bindir
                 clean_env = env_for_child
-                Gem.paths = Hash[
-                    'GEM_HOME' => clean_env['GEM_HOME'] || Gem.default_dir,
-                    'GEM_PATH' => clean_env['GEM_PATH'] || nil
-                ]
-
-                bundler = find_in_clean_path('bundler')
-                if !bundler
-                    clean_path = env_for_child['PATH']
-                    STDERR.puts "cannot find 'bundler' in PATH=#{clean_path}"
-                    STDERR.puts "installing it now ..."
-                    result = system(clean_env, Gem.ruby, '-S', 'gem', 'install', 'bundler')
-                    if !result
-                        if ENV['PATH'] != clean_path
-                            STDERR.puts "  it appears that you already have some autoproj-generated env.sh loaded"
-                            STDERR.puts "  - if you are running 'autoproj upgrade', please contact the autoproj author at https://github.com/rock-core/autoproj/issues/new"
-                            STDERR.puts "  - if you are running an install, try again in a console where the env.sh is not loaded"
-                            exit 1
-                        else
-                            STDERR.puts "  the recommended action is to install it manually first by running 'gem install bundler'"
-                            STDERR.puts "  or call this command again with --private-bundler to have it installed in the workspace"
-                            exit 1
-                        end
-                    end
+                if bundler   = find_in_clean_path('bundler', gem_bindir)
+                    return bundler
+                end
+
+                clean_path = env_for_child['PATH']
+                STDERR.puts "cannot find 'bundler' in PATH=#{clean_path}#{File::PATH_SEPARATOR}#{gem_bindir}"
+                STDERR.puts "installing it now ..."
+                result = system(
+                    clean_env.merge('GEM_PATH' => "", 'GEM_HOME' => bundler_gem_path),
+                    Gem.ruby, '-S', 'gem', 'install', 'bundler')
 
-                    bundler = find_in_clean_path('bundler')
-                    if !bundler
-                        STDERR.puts "FATAL: gem install bundler returned successfully, but still cannot find bundler"
-                        STDERR.puts "FATAL: in #{clean_path}"
+                if !result
+                    if ENV['PATH'] != clean_path
+                        STDERR.puts "  it appears that you already have some autoproj-generated env.sh loaded"
+                        STDERR.puts "  - if you are running 'autoproj upgrade', please contact the autoproj author at https://github.com/rock-core/autoproj/issues/new"
+                        STDERR.puts "  - if you are running an install, try again in a console where the env.sh is not loaded"
+                        exit 1
+                    else
+                        STDERR.puts "  the recommended action is to install it manually first by running 'gem install bundler'"
+                        STDERR.puts "  or call this command again with --private-bundler to have it installed in the workspace"
+                        exit 1
                     end
                 end
 
-                bundler
+                bundler = File.join(bundler_gem_path, 'bin', 'bundler')
+                if File.exist?(bundler)
+                    bundler
+                else
+                    STDERR.puts "gem install bundler returned successfully, but still cannot find bundler in #{bundler}"
+                    nil
+                end
             end
 
             def install_autoproj(bundler)
@@ -238,17 +259,17 @@ def install_autoproj(bundler)
                     FileUtils.rm lockfile
                 end
 
-                opts = Array.new
-                clean_env = env_for_child.merge('BUNDLE_GEMFILE' => nil)
+                clean_env = env_for_child.dup
 
+                opts = Array.new
                 opts << '--local' if local?
                 if private_autoproj?
-                    clean_env['GEM_PATH'] = (bundler_install_dir if private_bundler?)
+                    clean_env['GEM_PATH'] = bundler_gem_home
                     clean_env['GEM_HOME'] = nil
-                    opts << "--clean" << "--path=#{autoproj_install_dir}"
+                    opts << "--clean" << "--path=#{autoproj_gem_home}"
                 end
                 binstubs_path = File.join(autoproj_install_dir, 'bin')
-                result = system(clean_env,
+                result = system(clean_env.merge('GEM_HOME' => autoproj_gem_home),
                     Gem.ruby, bundler, 'install',
                         "--gemfile=#{autoproj_gemfile_path}",
                         "--shebang=#{Gem.ruby}",
@@ -259,6 +280,17 @@ def install_autoproj(bundler)
                     STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
                     exit 1
                 end
+            ensure
+                self.class.clean_binstubs(binstubs_path)
+            end
+
+            def self.clean_binstubs(binstubs_path)
+                %w{bundler bundle}.each do |bundler_bin|
+                    path = File.join(binstubs_path, bundler_bin)
+                    if File.file?(path)
+                        FileUtils.rm path
+                    end
+                end
 
                 # Now tune the binstubs to force the usage of the autoproj
                 # gemfile. Otherwise, they get BUNDLE_GEMFILE from the
@@ -279,15 +311,6 @@ def install_autoproj(bundler)
                         io.write filtered.join("")
                     end
                 end
-
-                env['PATH'].unshift File.join(autoproj_install_dir, 'bin')
-                if private_autoproj?
-                    env['GEM_PATH'].unshift autoproj_install_dir
-                end
-            ensure
-                if binstubs_path
-                    FileUtils.rm_f File.join(binstubs_path, 'bundler')
-                end
             end
 
             def save_env_sh(*vars)
@@ -327,8 +350,8 @@ def save_gemfile
             ENV_BUNDLE_GEMFILE_RX = /^(\s*ENV\[['"]BUNDLE_GEMFILE['"]\]\s*)(?:\|\|)?=/
 
 
-            def find_in_clean_path(command)
-                clean_path = env_for_child['PATH'].split(File::PATH_SEPARATOR)
+            def find_in_clean_path(command, *additional_paths)
+                clean_path = env_for_child['PATH'].split(File::PATH_SEPARATOR) + additional_paths
                 clean_path.each do |p|
                     full_path = File.join(p, command)
                     if File.file?(full_path)
@@ -352,7 +375,7 @@ def gem_bindir
                 #
                 # So, we're calling 'gem' as a subcommand to discovery the
                 # actual bindir
-                bindir = IO.popen(env_for_child, [Gem.ruby, '-e', 'puts Gem.bindir']).read
+                bindir = IO.popen(env_for_child, [Gem.ruby, '-e', 'puts "#{Gem.user_dir}/bin"']).read
                 if bindir
                     @gem_bindir = bindir.chomp
                 else
@@ -362,11 +385,12 @@ def gem_bindir
 
             def install
                 if private_bundler?
-                    puts "Installing bundler in #{bundler_install_dir}"
+                    puts "Installing bundler in #{bundler_gem_home}"
                     bundler = install_bundler
-                else
-                    bundler = find_bundler
+                elsif bundler = find_bundler
                     puts "Detected bundler at #{bundler}"
+                else
+                    exit 1
                 end
                 save_gemfile
                 puts "Installing autoproj in #{dot_autoproj}"
@@ -384,6 +408,17 @@ def load_config
                     config.merge!(YAML.load(File.read(autoproj_config_path)))
                 end
 
+                ruby = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+                ruby_bindir = RbConfig::CONFIG['bindir']
+                ruby_executable = File.join(ruby_bindir, ruby)
+                if current = config['ruby_executable'] # When upgrading or reinstalling
+                    if current != ruby_executable
+                        raise "this workspace has already been initialized using #{current}, you cannot run autoproj install with #{ruby_executable}. If you know what you're doing, delete the ruby_executable line in config.yml and try again"
+                    end
+                else
+                    config['ruby_executable'] = ruby_executable
+                end
+
                 @config = config
                 %w{private_bundler private_gems private_autoproj prefer_indep_over_os_packages}.each do |flag|
                     instance_variable_set "@#{flag}", config.fetch(flag, false)
@@ -391,25 +426,33 @@ def load_config
             end
 
             def save_config
-                config['private_bundler']  = private_bundler?
-                config['private_autoproj'] = private_autoproj?
-                config['private_gems']     = private_gems?
+                config['private_bundler']  = (bundler_gem_home  if private_bundler?)
+                config['private_autoproj'] = (autoproj_gem_home if private_autoproj?)
+                config['private_gems'] = @private_gems
                 config['prefer_indep_over_os_packages'] = prefer_indep_over_os_packages?
                 File.open(autoproj_config_path, 'w') { |io| YAML.dump(config, io) }
             end
 
+            def autoproj_path
+                File.join(autoproj_install_dir, 'bin', 'autoproj')
+            end
+
+            def run_autoproj(*args)
+                system env_for_child.merge('BUNDLE_GEMFILE' => autoproj_gemfile_path),
+                    Gem.ruby, autoproj_path, *args
+            end
+
             def stage1
                 FileUtils.mkdir_p dot_autoproj
                 save_config
                 install
+            end
 
+            def call_stage2
                 clean_env = env_for_child
                 stage2_vars = clean_env.map { |k, v| "#{k}=#{v}" }
                 puts "starting the newly installed autoproj for stage2 install"
-                result = system clean_env.merge('BUNDLE_GEMFILE' => autoproj_gemfile_path),
-                    Gem.ruby, File.join(autoproj_install_dir, 'bin', 'autoproj'),
-                    'install-stage2', root_dir, *stage2_vars
-                if !result
+                if !run_autoproj('install-stage2', root_dir, *stage2_vars)
                     raise "failed to execute autoproj install-stage2"
                 end
             end
@@ -419,7 +462,7 @@ def stage2(*vars)
                 puts "saving env.sh and .autoproj/env.sh"
                 save_env_sh(*vars)
                 puts "calling autoproj envsh"
-                system(Gem.ruby, $0, 'envsh')
+                system(Gem.ruby, autoproj_path, 'envsh')
             end
         end
     end