autoproj 2.11.0 → 2.14.0

data/lib/autoproj/manifest.rb

@@ -50,12 +50,19 @@ module Autoproj
 
         # Load the manifest data contained in +file+
         def load(file)
-            if !File.exist?(file)
-                raise ConfigError.new(File.dirname(file)), "expected an autoproj configuration in #{File.dirname(file)}, but #{file} does not exist"
+            unless File.exist?(file)
+                raise ConfigError.new(File.dirname(file)),
+                      "expected an autoproj configuration in #{File.dirname(file)}, "\
+                      "but #{file} does not exist"
             end
 
             data = Autoproj.in_file(file, Autoproj::YAML_LOAD_ERROR) do
-                YAML.load(File.read(file)) || Hash.new
+                YAML.safe_load(File.read(file)) || {}
+            end
+
+            if data["layout"]&.member?(nil)
+                Autoproj.warn "There is an empty entry in your layout in #{file}. All empty entries are ignored."
+                data["layout"] = data["layout"].compact
             end
 
             @file = file
@@ -81,7 +88,8 @@ module Autoproj
             @has_layout = !!data['layout']
 
             if data['constants']
-                @constant_definitions = Autoproj.resolve_constant_definitions(data['constants'])
+                @constant_definitions =
+                    Autoproj.resolve_constant_definitions(data['constants'])
             end
         end
 
@@ -1234,7 +1242,7 @@ module Autoproj
         workspace.config
     end
 
-    def self.add_osdeps_overrides(*args, &block)
-        manifest.add_osdeps_overrides(*args, &block)
+    def self.add_osdeps_overrides(*args, **kw, &block)
+        manifest.add_osdeps_overrides(*args, **kw, &block)
     end
 end

data/lib/autoproj/ops/build.rb

@@ -87,34 +87,36 @@ module Autoproj
             #   names of the packages that should be rebuilt
             # @return [void]
             def build_packages(all_enabled_packages, options = Hash.new)
+                if @report_path
+                    reporting = Ops::PhaseReporting.new(
+                        'build', @report_path, method(:package_metadata)
+                    )
+                end
+
                 Autobuild.do_rebuild = false
                 Autobuild.do_forced_build = false
+                reporting&.initialize_incremental_report
                 begin
-                    Autobuild.apply(all_enabled_packages, "autoproj-build", ['build'], options)
+                    Autobuild.apply(
+                        all_enabled_packages,
+                        "autoproj-build", ['build'], options
+                    ) do |pkg, phase|
+                        reporting&.report_incremental(pkg) if phase == 'build'
+                    end
+
                 ensure
-                    create_report(all_enabled_packages) if @report_path
+                    packages = all_enabled_packages.map do |name|
+                        @manifest.find_autobuild_package(name)
+                    end
+                    reporting&.create_report(packages)
                 end
             end
 
-            def create_report(package_list)
-                FileUtils.mkdir_p File.dirname(@report_path)
-
-                packages = package_list.each_with_object({}) do |pkg_name, h|
-                    pkg = manifest.find_autobuild_package(pkg_name)
-
-                    h[pkg.name] = {
-                        invoked: !!pkg.install_invoked?,
-                        success: !!pkg.installed?
-                    }
-                end
-
-                report = JSON.pretty_generate({
-                    build_report: {
-                        timestamp: Time.now,
-                        packages: packages
-                    }
-                })
-                IO.write(@report_path, report)
+            def package_metadata(autobuild_package)
+                {
+                    invoked: !!autobuild_package.install_invoked?,
+                    success: !!autobuild_package.installed?
+                }
             end
         end
     end

data/lib/autoproj/ops/cache.rb

@@ -4,9 +4,10 @@ module Autoproj
             attr_reader :cache_dir
             attr_reader :manifest
 
-            def initialize(cache_dir, manifest)
+            def initialize(cache_dir, ws)
                 @cache_dir = cache_dir
-                @manifest  = manifest
+                @ws = ws
+                @manifest = ws.manifest
             end
 
             def with_retry(count)
@@ -27,29 +28,39 @@ module Autoproj
                 File.join(cache_dir, 'git')
             end
 
-            def cache_git(pkg, options = Hash.new)
+            def cache_git(pkg, checkout_only: false)
                 pkg.importdir = File.join(git_cache_dir, pkg.name)
-                if options[:checkout_only] && File.directory?(pkg.importdir)
-                    return
-                end
+                return if checkout_only && File.directory?(pkg.importdir)
 
                 pkg.importer.local_branch = nil
                 pkg.importer.remote_branch = nil
                 pkg.importer.remote_name = 'autobuild'
 
-                if !File.directory?(pkg.importdir)
+                unless File.directory?(pkg.importdir)
                     FileUtils.mkdir_p File.dirname(pkg.importdir)
-                    Autobuild::Subprocess.run("autoproj-cache", "import", Autobuild.tool(:git), "--git-dir", pkg.importdir, 'init', "--bare")
+                    Autobuild::Subprocess.run(
+                        "autoproj-cache", "import", Autobuild.tool(:git),
+                        "--git-dir", pkg.importdir, 'init', "--bare"
+                    )
                 end
                 pkg.importer.update_remotes_configuration(pkg)
 
                 with_retry(10) do
-                    Autobuild::Subprocess.run('autoproj-cache', :import, Autobuild.tool('git'), '--git-dir', pkg.importdir, 'remote', 'update', 'autobuild')
+                    Autobuild::Subprocess.run(
+                        'autoproj-cache', :import, Autobuild.tool('git'),
+                        '--git-dir', pkg.importdir, 'remote', 'update', 'autobuild'
+                    )
                 end
                 with_retry(10) do
-                    Autobuild::Subprocess.run('autoproj-cache', :import, Autobuild.tool('git'), '--git-dir', pkg.importdir, 'fetch', 'autobuild', '--tags')
+                    Autobuild::Subprocess.run(
+                        'autoproj-cache', :import, Autobuild.tool('git'),
+                        '--git-dir', pkg.importdir, 'fetch', 'autobuild', '--tags'
+                    )
                 end
-                Autobuild::Subprocess.run('autoproj-cache', :import, Autobuild.tool('git'), '--git-dir', pkg.importdir, 'gc', '--prune=all')
+                Autobuild::Subprocess.run(
+                    'autoproj-cache', :import, Autobuild.tool('git'),
+                    '--git-dir', pkg.importdir, 'gc', '--prune=all'
+                )
             end
 
             def archive_cache_dir
@@ -63,7 +74,8 @@ module Autoproj
                 end
             end
 
-            def create_or_update(*package_names, all: true, keep_going: false, checkout_only: false)
+            def create_or_update(*package_names, all: true, keep_going: false,
+                                 checkout_only: false)
                 FileUtils.mkdir_p cache_dir
 
                 if package_names.empty?
@@ -75,7 +87,7 @@ module Autoproj
                         end
                 else
                     packages = package_names.map do |name|
-                        if pkg = manifest.find_autobuild_package(name)
+                        if (pkg = manifest.find_autobuild_package(name))
                             pkg
                         else
                             raise PackageNotFound, "no package named #{name}"
@@ -88,42 +100,148 @@ module Autoproj
                 total = packages.size
                 Autoproj.message "Handling #{total} packages"
                 packages.each_with_index do |pkg, i|
-                    next if pkg.srcdir != pkg.importdir # No need to process this one, it is uses another package's import
+                    # No need to process this one, it is uses another package's
+                    # import
+                    next if pkg.srcdir != pkg.importdir
+
                     begin
                         case pkg.importer
                         when Autobuild::Git
-                            Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (git)"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] caching #{pkg.name} (git)"
+                            )
                             cache_git(pkg, checkout_only: checkout_only)
                         when Autobuild::ArchiveImporter
-                            Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (archive)"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] caching #{pkg.name} (archive)"
+                            )
                             cache_archive(pkg)
                         else
-                            Autoproj.message "  [#{i}/#{total}] not caching #{pkg.name} (cannot cache #{pkg.importer.class})"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] not caching #{pkg.name} "\
+                                "(cannot cache #{pkg.importer.class})"
+                            )
                         end
                     rescue Interrupt
                         raise
                     rescue ::Exception => e
-                        if keep_going
-                            pkg.error "       failed to cache #{pkg.name}, but going on as requested"
-                            lines = e.to_s.split("\n")
-                            if lines.empty?
-                                lines = e.message.split("\n")
-                            end
-                            if lines.empty?
-                                lines = ["unknown error"]
-                            end
-                            pkg.message(lines.shift, :red, :bold)
-                            lines.each do |line|
-                                pkg.message(line)
+                        raise unless keep_going
+
+                        pkg.error "       failed to cache #{pkg.name}, "\
+                                  'but going on as requested'
+                        lines = e.to_s.split('\n')
+                        lines = e.message.split('\n') if lines.empty?
+                        lines = ['unknown error'] if lines.empty?
+                        pkg.message(lines.shift, :red, :bold)
+                        lines.each do |line|
+                            pkg.message(line)
+                        end
+                        nil
+                    end
+                end
+            end
+
+            def gems_cache_dir
+                File.join(cache_dir, 'package_managers', 'gem')
+            end
+
+            def create_or_update_gems(keep_going: true, compile_force: false, compile: [])
+                # Note: this might directly copy into the cache directoy, and
+                # we support it later
+                cache_dir = File.join(@ws.prefix_dir, 'gems', 'vendor', 'cache')
+                PackageManagers::BundlerManager.run_bundler(
+                    @ws, 'cache'
+                )
+
+                FileUtils.mkdir_p(gems_cache_dir) unless File.exist?(gems_cache_dir)
+
+                needs_copy =
+                    if File.exist?(cache_dir)
+                        real_cache_dir = File.realpath(cache_dir)
+                        real_target_dir = File.realpath(gems_cache_dir)
+                        (real_cache_dir != real_target_dir)
+                    end
+
+                synchronize_gems_cache_dirs(real_cache_dir, real_target_dir) if needs_copy
+
+                platform_suffix = "-#{Gem::Platform.local}.gem"
+                failed = []
+                compile.each do |gem_name, artifacts: []|
+                    Dir.glob(File.join(cache_dir, "#{gem_name}*.gem")) do |gem|
+                        next if gem.end_with?(platform_suffix)
+
+                        gem_basename = File.basename(gem, ".gem")
+                        expected_platform_gem = File.join(
+                            real_target_dir, "#{gem_basename}#{platform_suffix}"
+                        )
+                        next if !compile_force && File.file?(expected_platform_gem)
+
+                        begin
+                            compile_gem(
+                                gem, artifacts: artifacts, output: real_target_dir
+                            )
+                        rescue CompilationFailed
+                            unless keep_going
+                                raise CompilationFailed, "#{gem} failed to compile"
                             end
-                            nil
-                        else
-                            raise
+
+                            failed << gem
                         end
                     end
                 end
+
+                unless failed.empty?
+                    raise CompilationFailed, "#{failed.sort.join(', ')} failed to compile"
+                end
+            end
+
+            class CompilationFailed < RuntimeError; end
+
+            def synchronize_gems_cache_dirs(source, target)
+                Dir.glob(File.join(source, "*.gem")) do |source_file|
+                    basename = File.basename(source_file)
+                    target_file = File.join(target, basename)
+                    next if File.file?(target_file)
+
+                    Autoproj.message "gems: caching #{basename}"
+                    FileUtils.cp source_file, target_file
+                end
+            end
+
+            def guess_gem_program
+                return Autobuild.programs['gem'] if Autobuild.programs['gem']
+
+                ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+                ruby_bindir = RbConfig::CONFIG['bindir']
+
+                candidates = ['gem']
+                candidates << "gem#{$1}" if ruby_bin =~ /^ruby(.+)$/
+
+                candidates.each do |gem_name|
+                    if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
+                        Autobuild.programs['gem'] = gem_full_path
+                        return Autobuild.programs['gem']
+                    end
+                end
+
+                raise ArgumentError,
+                      'cannot find a gem program (tried '\
+                      "#{candidates.sort.join(', ')} in #{ruby_bindir})"
+            end
+
+            private def compile_gem(gem_path, output:, artifacts: [])
+                artifacts = artifacts.flat_map do |include, n|
+                    if include
+                        ["--include", n]
+                    else
+                        ["--exclude", n]
+                    end
+                end
+                unless system(Autobuild.tool('ruby'), '-S', guess_gem_program,
+                              'compile', '--output', output, *artifacts, gem_path)
+                    raise CompilationFailed, "#{gem_path} failed to compile"
+                end
             end
         end
     end
 end
-

data/lib/autoproj/ops/cached_env.rb

@@ -9,7 +9,7 @@ module Autoproj
         def self.load_cached_env(root_dir)
             path = cached_env_path(root_dir)
             if File.file?(path)
-                env = YAML.load(File.read(path))
+                env = YAML.safe_load(File.read(path))
                 Autobuild::Environment::ExportedEnvironment.new(
                     env['set'], env['unset'], env['update'])
             end
@@ -20,7 +20,7 @@ module Autoproj
             path = cached_env_path(root_dir)
             existing =
                 begin
-                    YAML.load(File.read(path))
+                    YAML.safe_load(File.read(path))
                 rescue Exception
                 end
 

data/lib/autoproj/ops/import.rb

@@ -199,6 +199,7 @@ module Autoproj
                                          install_vcs_packages: Hash.new,
                                          non_imported_packages: :checkout,
                                          auto_exclude: auto_exclude?,
+                                         filter: ->(package) { true },
                                          **import_options)
 
                 unless %i[checkout ignore return].include?(non_imported_packages)
@@ -235,6 +236,11 @@ module Autoproj
                 missing_vcs = Array.new
                 installed_vcs_packages = Set['none', 'local']
                 while failures.empty? || keep_going
+                    # Allow 'filter' to parallelize as well
+                    if filter.respond_to?(:lookahead)
+                        package_queue.each { |pkg| filter.lookahead(pkg) }
+                    end
+
                     # Queue work for all packages in the queue
                     package_queue.each do |pkg|
                         # Remove packages that have already been processed
@@ -255,6 +261,11 @@ module Autoproj
                         end
                         all_processed_packages << pkg
 
+                        unless filter.call(pkg)
+                            completion_queue << [pkg, Time.now]
+                            next
+                        end
+
                         importer = pkg.autobuild.importer
                         if !pre_package_import(selection, manifest, pkg.autobuild,
                                                reverse_dependencies)
@@ -272,8 +283,8 @@ module Autoproj
                             next
                         end
 
-                        pending_packages << pkg
                         begin
+                            pending_packages << pkg
                             queue_import_work(
                                 executor, completion_queue, pkg,
                                 retry_count: retry_count,
@@ -288,8 +299,12 @@ module Autoproj
                     if completion_queue.empty? && pending_packages.empty?
                         unless missing_vcs.empty?
                             installed_vcs_packages.merge(
-                                install_vcs_packages_for(*missing_vcs,
-                                                         **install_vcs_packages))
+                                install_vcs_packages_for(
+                                    *missing_vcs,
+                                     install_only: import_options[:checkout_only],
+                                     **install_vcs_packages
+                                )
+                            )
                             package_queue.concat(missing_vcs)
                             missing_vcs.clear
                             next
@@ -366,7 +381,9 @@ module Autoproj
                 end
             end
 
-            def finalize_package_load(processed_packages, auto_exclude: auto_exclude?)
+            def finalize_package_load(processed_packages,
+                                      ignore_optional_dependencies: false,
+                                      auto_exclude: auto_exclude?)
                 manifest = ws.manifest
 
                 all = Set.new
@@ -426,6 +443,7 @@ module Autoproj
                                 keep_going: false,
                                 install_vcs_packages: Hash.new,
                                 auto_exclude: auto_exclude?,
+                                filter: ->(pkg) { true },
                                 **import_options)
 
                 manifest = ws.manifest
@@ -437,6 +455,7 @@ module Autoproj
                     recursive: recursive,
                     install_vcs_packages: install_vcs_packages,
                     auto_exclude: auto_exclude,
+                    filter: filter,
                     **import_options)
 
                 raise failures.first if !keep_going && !failures.empty?

data/lib/autoproj/ops/install.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'optparse'
 require 'fileutils'
 require 'yaml'
+require 'English'
 
 module Autoproj
     module Ops
@@ -13,6 +16,36 @@ module Autoproj
         class Install
             class UnexpectedBinstub < RuntimeError; end
 
+            RUBYLIB_REINIT = <<~RUBY
+                if defined?(Bundler)
+                    if Bundler.respond_to?(:with_unbundled_env)
+                        Bundler.with_unbundled_env do
+                            exec(Hash['RUBYLIB' => nil], $0, *ARGV)
+                        end
+                    else
+                        Bundler.with_clean_env do
+                            exec(Hash['RUBYLIB' => nil], $0, *ARGV)
+                        end
+                    end
+                elsif ENV['RUBYLIB']
+                    exec(Hash['RUBYLIB' => nil], $0, *ARGV)
+                end
+            RUBY
+
+            WITHOUT_BUNDLER = <<~RUBY
+                if defined?(Bundler)
+                    if Bundler.respond_to?(:with_unbundled_env)
+                        Bundler.with_unbundled_env do
+                            exec($0, *ARGV)
+                        end
+                    else
+                        Bundler.with_clean_env do
+                            exec($0, *ARGV)
+                        end
+                    end
+                end
+            RUBY
+
             # The created workspace's root directory
             attr_reader :root_dir
             # Content of the Gemfile generated to install autoproj itself
@@ -220,6 +253,10 @@ module Autoproj
                  "gem \"utilrb\", \">= 3.0.1\""].join("\n")
             end
 
+            def add_seed_config(path)
+                @config.merge!(YAML.safe_load(File.read(path), [Symbol]))
+            end
+
             # Parse the provided command line options and returns the non-options
             def parse_options(args = ARGV)
                 options = OptionParser.new do |opt|
@@ -243,6 +280,10 @@ module Autoproj
                     opt.on '--public-gems', "install gems in the default gem location" do
                         self.install_gems_in_gem_user_dir
                     end
+                    opt.on '--bundler-version=VERSION_CONSTRAINT', String, 'use the provided '\
+                        'string as a version constraint for bundler' do |version|
+                        @config['bundler_version'] = version
+                    end
                     opt.on '--version=VERSION_CONSTRAINT', String, 'use the provided '\
                         'string as a version constraint for autoproj' do |version|
                         if @gemfile
@@ -257,9 +298,14 @@ module Autoproj
                         end
                         @gemfile = File.read(path)
                     end
+                    opt.on '--no-seed-config',
+                           'when reinstalling an existing autoproj workspace, do not '\
+                           'use the config in .autoproj/ as seed' do
+                        @config.clear
+                    end
                     opt.on '--seed-config=PATH', String, 'path to a seed file that '\
                         'should be used to initialize the configuration' do |path|
-                        @config.merge!(YAML.load(File.read(path)))
+                        add_seed_config(path)
                     end
                     opt.on '--prefer-os-independent-packages', 'prefer OS-independent '\
                         'packages (such as a RubyGem) over their OS-packaged equivalent '\
@@ -289,22 +335,50 @@ module Autoproj
                 @autoproj_options + args
             end
 
-            def find_bundler(gem_program)
-                setup_paths =
-                    IO.popen([env_for_child, Gem.ruby, gem_program, 'which','-a', 'bundler/setup']) do |io|
-                        io.read
-                    end
-                return unless $?.success?
+            def bundler_version
+                @config['bundler_version']
+            end
+
+            def find_bundler(gem_program, version: nil)
                 bundler_path = File.join(gems_gem_home, 'bin', 'bundle')
-                setup_paths.each_line do |setup_path|
-                    if File.exist?(bundler_path) && setup_path.start_with?(gems_gem_home)
-                        return bundler_path
+                return unless File.exist?(bundler_path)
+
+                setup_paths =
+                    if version
+                        find_versioned_bundler_setup(gem_program, version)
+                    else
+                        find_unversioned_bundler_setup(gem_program)
                     end
+
+                setup_paths.each do |setup_path|
+                    return bundler_path if setup_path.start_with?(gems_gem_home)
                 end
-                return
+                nil
+            end
+
+            def find_versioned_bundler_setup(gem_program, version)
+                contents = IO.popen(
+                    [env_for_child, Gem.ruby, gem_program,
+                     'contents', '-v', version, 'bundler'],
+                    &:readlines
+                )
+                return [] unless $CHILD_STATUS.success?
+
+                contents.grep(%r{bundler/setup.rb$})
+            end
+
+            def find_unversioned_bundler_setup(gem_program)
+                setup_paths = IO.popen(
+                    [env_for_child, Gem.ruby, gem_program,
+                     'which', '-a', 'bundler/setup'],
+                    &:readlines
+                )
+                return [] unless $CHILD_STATUS.success?
+
+                setup_paths
             end
 
-            def install_bundler(gem_program, silent: false)
+            def install_bundler(gem_program, version: nil, silent: false)
                 local = ['--local'] if local?
 
                 redirection = Hash.new
@@ -312,6 +386,9 @@ module Autoproj
                     redirection = Hash[out: :close]
                 end
 
+                version_args = []
+                version_args << '-v' << version if version
+
                 # Shut up the bundler warning about 'bin' not being in PATH
                 env = self.env
                 env['PATH'] += [File.join(gems_gem_home, 'bin')]
@@ -322,14 +399,14 @@ module Autoproj
                         '--clear-sources', '--source', gem_source,
                         '--no-user-install', '--install-dir', gems_gem_home,
                         *local, "--bindir=#{File.join(gems_gem_home, 'bin')}",
-                        'bundler', **redirection)
+                        'bundler', *version_args, **redirection)
 
                 if !result
                     STDERR.puts "FATAL: failed to install bundler in #{gems_gem_home}"
                     nil
                 end
 
-                if (bundler_path = find_bundler(gem_program))
+                if (bundler_path = find_bundler(gem_program, version: version))
                     bundler_path
                 else
                     STDERR.puts "gem install bundler returned successfully, but still "\
@@ -338,7 +415,7 @@ module Autoproj
                 end
             end
 
-            def install_autoproj(bundler)
+            def install_autoproj(bundler, bundler_version: self.bundler_version)
                 # Force bundler to update. If the user does not want this, let
                 # him specify a Gemfile with tighter version constraints
                 lockfile = File.join(dot_autoproj, 'Gemfile.lock')
@@ -353,14 +430,19 @@ module Autoproj
                 opts << "--path=#{gems_install_path}"
                 shims_path = File.join(dot_autoproj, 'bin')
 
-                result = system(clean_env,
-                    Gem.ruby, bundler, 'install',
-                        "--gemfile=#{autoproj_gemfile_path}",
-                        "--shebang=#{Gem.ruby}",
-                        "--binstubs=#{shims_path}",
-                        *opts, chdir: dot_autoproj)
+                version_arg = []
+                version_arg << "_#{bundler_version}_" if bundler_version
 
-                if !result
+                result = system(
+                    clean_env,
+                    Gem.ruby, bundler, *version_arg, 'install',
+                    "--gemfile=#{autoproj_gemfile_path}",
+                    "--shebang=#{Gem.ruby}",
+                    "--binstubs=#{shims_path}",
+                    *opts, chdir: dot_autoproj
+                )
+
+                unless result
                     STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
                     exit 1
                 end
@@ -369,7 +451,7 @@ module Autoproj
                     root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
-            EXCLUDED_FROM_SHIMS = %w{rake thor}
+            EXCLUDED_FROM_SHIMS = %w[rake thor].freeze
 
             def self.rewrite_shims(shim_path, ruby_executable,
                 root_dir, autoproj_gemfile_path, gems_gem_home)
@@ -425,11 +507,7 @@ module Autoproj
 #
 
 # Autoproj generated preamble
-if defined?(Bundler)
-    Bundler.with_clean_env do
-        exec($0, *ARGV)
-    end
-end
+#{WITHOUT_BUNDLER}
 ENV['BUNDLE_GEMFILE'] ||= '#{autoproj_gemfile_path}'
 ENV['GEM_HOME'] = '#{gems_gem_home}'
 ENV.delete('GEM_PATH')
@@ -441,12 +519,7 @@ Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
             def self.shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home)
 "#! #{ruby_executable}
 
-if defined?(Bundler)
-    Bundler.with_clean_env do
-        exec($0, *ARGV)
-    end
-end
-
+#{WITHOUT_BUNDLER}
 ENV['BUNDLE_GEMFILE'] ||= '#{autoproj_gemfile_path}'
 ENV['GEM_HOME'] = '#{gems_gem_home}'
 ENV.delete('GEM_PATH')
@@ -471,14 +544,7 @@ load Gem.bin_path('bundler', 'bundler')"
 #
 
 # Autoproj generated preamble, v1
-if defined?(Bundler)
-    Bundler.with_clean_env do
-        exec(Hash['RUBYLIB' => nil], $0, *ARGV)
-    end
-elsif ENV['RUBYLIB']
-    exec(Hash['RUBYLIB' => nil], $0, *ARGV)
-end
-
+#{RUBYLIB_REINIT}
 ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
 ENV['AUTOPROJ_CURRENT_ROOT'] = '#{root_dir}'
 Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
@@ -490,14 +556,7 @@ Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
                 gems_gem_home, load_line)
 "#! #{ruby_executable}
 
-if defined?(Bundler)
-    Bundler.with_clean_env do
-        exec(Hash['RUBYLIB' => nil], $0, *ARGV)
-    end
-elsif ENV['RUBYLIB']
-    exec(Hash['RUBYLIB' => nil], $0, *ARGV)
-end
-
+#{RUBYLIB_REINIT}
 ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
 ENV['AUTOPROJ_CURRENT_ROOT'] = '#{root_dir}'
 require 'rubygems'
@@ -591,8 +650,11 @@ require 'bundler/setup'
                 #
                 # So, we're calling 'gem' as a subcommand to discovery the
                 # actual bindir
-                bindir = IO.popen(env_for_child,
-                    [Gem.ruby, '-e', 'puts "#{Gem.user_dir}/bin"']).read
+                bindir = IO.popen(
+                    env_for_child,
+                    [Gem.ruby, '-e', 'puts "#{Gem.user_dir}/bin"'], # rubocop:disable Lint/InterpolationCheck
+                    &:read
+                )
                 if bindir
                     @gem_bindir = bindir.chomp
                 else
@@ -600,11 +662,11 @@ require 'bundler/setup'
                 end
             end
 
-            def install
+            def install(bundler_version: self.bundler_version)
                 if ENV['BUNDLER_GEMFILE']
                     raise "cannot run autoproj_install or autoproj_bootstrap while "\
-                        "under a 'bundler exec' subcommand or having loaded an env.sh. "\
-                        "Open a new console and try again"
+                          "under a 'bundler exec' subcommand or having loaded an "\
+                          "env.sh. Open a new console and try again"
                 end
 
                 gem_program  = self.class.guess_gem_program
@@ -612,13 +674,12 @@ require 'bundler/setup'
                 env['GEM_HOME'] = [gems_gem_home]
                 env['GEM_PATH'] = [gems_gem_home]
 
-                if bundler = find_bundler(gem_program)
+                if (bundler = find_bundler(gem_program, version: bundler_version))
                     puts "Detected bundler at #{bundler}"
                 else
                     puts "Installing bundler in #{gems_gem_home}"
-                    if !(bundler = install_bundler(gem_program))
-                        exit 1
-                    end
+                    bundler = install_bundler(gem_program, version: bundler_version)
+                    exit(1) unless bundler
                 end
                 self.class.rewrite_shims(
                     File.join(dot_autoproj, 'bin'),
@@ -630,7 +691,7 @@ require 'bundler/setup'
                 save_gemfile
 
                 puts "Installing autoproj in #{gems_gem_home}"
-                install_autoproj(bundler)
+                install_autoproj(bundler, bundler_version: bundler_version)
             end
 
             def load_config