autoproj 2.12.1 → 2.15.1

data/bin/autoproj_install

@@ -1,20 +1,20 @@
 #! /usr/bin/ruby
 
-if RUBY_VERSION < "2.3.0"
-    STDERR.puts "autoproj requires Ruby >= 2.3.0"
+if RUBY_VERSION < "2.5.0"
+    STDERR.puts "autoproj requires Ruby >= 2.5.0"
     exit 1
-elsif ENV['AUTOPROJ_CURRENT_ROOT'] && (ENV['AUTOPROJ_CURRENT_ROOT'] != Dir.pwd)
+elsif ENV["AUTOPROJ_CURRENT_ROOT"] && (ENV["AUTOPROJ_CURRENT_ROOT"] != Dir.pwd)
     STDERR.puts "it seems that you've already loaded an env.sh script in this console, open a new console and try again"
     exit 1
 end
 
 # frozen_string_literal: true
 
-require 'pathname'
-require 'optparse'
-require 'fileutils'
-require 'yaml'
-require 'English'
+require "pathname"
+require "optparse"
+require "fileutils"
+require "yaml"
+require "English"
 
 module Autoproj
     module Ops
@@ -81,33 +81,30 @@ module Autoproj
                 @autoproj_options = Array.new
 
                 @env = Hash.new
-                env['RUBYOPT'] = []
-                env['RUBYLIB'] = []
-                env['PATH'] = self.class.sanitize_env(ENV['PATH'] || "")
-                env['BUNDLE_GEMFILE'] = []
+                env["RUBYOPT"] = []
+                env["RUBYLIB"] = []
+                env["PATH"] = self.class.sanitize_env(ENV["PATH"] || "")
+                env["BUNDLE_GEMFILE"] = []
 
                 load_config
 
-                if config['ruby_executable'] != Gem.ruby
+                if config["ruby_executable"] != Gem.ruby
                     raise "this autoproj installation was already bootstrapped using "\
-                        "#{config['ruby_executable']}, but you are currently running "\
-                        "under #{Gem.ruby}. Changing the ruby interpreter in a given "\
-                        "workspace is not supported, you need to do a clean bootstrap"
+                          "#{config['ruby_executable']}, but you are currently running "\
+                          "under #{Gem.ruby}. Changing the ruby interpreter in a given "\
+                          "workspace is not supported, you need to do a clean bootstrap"
                 end
-                @ruby_executable = config['ruby_executable']
+                @ruby_executable = config["ruby_executable"]
                 @local = false
 
-                unless @gems_install_path
-                    install_gems_in_gem_user_dir
-                end
-                env['GEM_HOME'] = [gems_gem_home]
-                env['GEM_PATH'] = [gems_gem_home]
+                install_gems_in_gem_user_dir unless @gems_install_path
+                env["GEM_HOME"] = [gems_gem_home]
+                env["GEM_PATH"] = [gems_gem_home]
             end
 
             def env_for_child(env = self.env)
                 env.inject(Hash.new) do |h, (k, v)|
-                    h[k] = if v && !v.empty? then v.join(File::PATH_SEPARATOR)
-                           end
+                    h[k] = (v.join(File::PATH_SEPARATOR) if v && !v.empty?)
                     h
                 end
             end
@@ -123,57 +120,75 @@ module Autoproj
             end
 
             def self.sanitize_env(value)
-                value.split(File::PATH_SEPARATOR).
-                    find_all { |p| !in_workspace?(p) }
+                value.split(File::PATH_SEPARATOR)
+                     .find_all { |p| !in_workspace?(p) }
             end
 
             def self.in_workspace?(base_dir)
                 path = Pathname.new(base_dir)
-                while !path.root?
-                    if (path + ".autoproj").exist? || (path + "autoproj").exist?
+                until path.root?
+                    if path.join(".autoproj").exist? || path.join("autoproj").exist?
                         return true
                     end
+
                     path = path.parent
                 end
-                return false
+                false
             end
 
             # The path to the .autoproj configuration directory
             #
             # @return [String]
-            def dot_autoproj; File.join(root_dir, '.autoproj') end
+            def dot_autoproj
+                File.join(root_dir, ".autoproj")
+            end
 
             # The path to the gemfile used to install autoproj
             #
             # @return [String]
-            def autoproj_gemfile_path; File.join(dot_autoproj, 'Gemfile') end
+            def autoproj_gemfile_path
+                File.join(dot_autoproj, "Gemfile")
+            end
 
             # The path to the autoproj configuration file
             #
             # @return [String]
-            def autoproj_config_path; File.join(dot_autoproj, 'config.yml') end
+            def autoproj_config_path
+                File.join(dot_autoproj, "config.yml")
+            end
 
             # Whether the stage2 install should be called or not
-            def skip_stage2?; !!@skip_stage2 end
+            def skip_stage2?
+                !!@skip_stage2
+            end
             # (see #skip_stage2?)
-            def skip_stage2=(flag); @skip_stage2 = flag end
+            attr_writer :skip_stage2
 
             # Whether we can access the network while installing
-            def local?; !!@local end
+            def local?
+                !!@local
+            end
             # (see #local?)
-            def local=(flag); @local = flag end
+            attr_writer :local
 
             # The user-wide place where RubyGems installs gems
-            def dot_gem_dir
-                File.join(Gem.user_home, ".gem")
+            def self.dot_gem_dir
+                if Gem.respond_to?(:data_home) # Debian 11+
+                    File.join(Gem.data_home, "gem")
+                else
+                    File.join(Gem.user_home, ".gem")
+                end
             end
 
             # The version and platform-specific suffix under {#dot_gem_dir}
             #
             # This is also the suffix used by bundler to install gems
-            def gem_path_suffix
-                @gem_path_suffix ||= Pathname.new(Gem.user_dir).
-                    relative_path_from(Pathname.new(dot_gem_dir)).to_s
+            def self.gems_path_suffix
+                @gems_path_suffix ||=
+                    Pathname
+                    .new(Gem.user_dir)
+                    .relative_path_from(Pathname.new(dot_gem_dir))
+                    .to_s
             end
 
             # The path into which the workspace's gems should be installed
@@ -182,21 +197,19 @@ module Autoproj
             # {#gem_path_suffix}.
             #
             # @return [String]
-            attr_reader :gems_install_path
+            attr_accessor :gems_install_path
+
             # The GEM_HOME under which the workspace's gems should be installed
             #
             # @return [String]
             def gems_gem_home
-                File.join(gems_install_path, gem_path_suffix)
+                File.join(gems_install_path, self.class.gems_path_suffix)
             end
             # Sets where the workspace's gems should be installed
             #
             # @param [String] path the absolute path that should be given to
             #   bundler. The gems themselves will be installed in the
-            #   {#gem_path_suffix} subdirectory under this
-            def gems_install_path=(path)
-                @gems_install_path = path
-            end
+            #   {.gems_path_suffix} subdirectory under this
 
             private def xdg_var(varname, default)
                 if (env = ENV[varname]) && !env.empty?
@@ -208,10 +221,11 @@ module Autoproj
 
             # Install autoproj in Gem's default user dir
             def install_gems_in_gem_user_dir
-                xdg_default_gem_path = xdg_var('XDG_DATA_HOME',
-                    File.join(Dir.home, '.local', 'share', 'autoproj', 'gems'))
+                xdg_default_gem_path = xdg_var("XDG_DATA_HOME",
+                                               File.join(Dir.home, ".local", "share", "autoproj", "gems"))
                 default_gem_path = File.join(
-                    Dir.home, '.autoproj', 'gems')
+                    Dir.home, ".autoproj", "gems"
+                )
                 @gems_install_path =
                     if File.directory?(xdg_default_gem_path)
                         xdg_default_gem_path
@@ -228,19 +242,18 @@ module Autoproj
             def prefer_indep_over_os_packages?
                 @prefer_indep_over_os_packages
             end
+
             # (see #prefer_index_over_os_packages?)
             def prefer_indep_over_os_packages=(flag)
                 @prefer_indep_over_os_packages = !!flag
             end
 
             def self.guess_gem_program
-                ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
-                ruby_bindir = RbConfig::CONFIG['bindir']
+                ruby_bin = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
+                ruby_bindir = RbConfig::CONFIG["bindir"]
 
-                candidates = ['gem']
-                if ruby_bin =~ /^ruby(.+)$/
-                    candidates.unshift "gem#{$1}"
-                end
+                candidates = ["gem"]
+                candidates.unshift "gem#{$1}" if ruby_bin =~ /^ruby(.+)$/
 
                 candidates.each do |gem_name|
                     if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
@@ -248,7 +261,7 @@ module Autoproj
                     end
                 end
                 raise ArgumentError, "cannot find a gem program "\
-                    "(tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
+                                     "(tried #{candidates.sort.join(', ')} in #{ruby_bindir})"
             end
 
             # The content of the default {#gemfile}
@@ -264,80 +277,81 @@ module Autoproj
             end
 
             def add_seed_config(path)
-                @config.merge!(YAML.safe_load(File.read(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|
-                    opt.on '--local', 'do not access the network (may fail)' do
+                    opt.on "--local", "do not access the network (may fail)" do
                         @local = true
                     end
-                    opt.on '--skip-stage2', 'do not run the stage2 install' do
+                    opt.on "--skip-stage2", "do not run the stage2 install" do
                         @skip_stage2 = true
                     end
-                    opt.on '--debug', 'Run in debug mode' do
-                        @autoproj_options << '--debug'
+                    opt.on "--debug", "Run in debug mode" do
+                        @autoproj_options << "--debug"
                     end
-                    opt.on '--gem-source=URL', String, 'use this source for RubyGems '\
-                        'instead of rubygems.org' do |url|
+                    opt.on "--gem-source=URL", String, "use this source for RubyGems "\
+                                                       "instead of rubygems.org" do |url|
                         @gem_source = url
                     end
-                    opt.on '--gems-path=PATH', 'install gems under this path instead '\
-                        'of ~/.autoproj/gems' do |path|
-                        self.gems_install_path     = path
+                    opt.on "--gems-path=PATH", "install gems under this path instead "\
+                                               "of ~/.autoproj/gems" do |path|
+                        self.gems_install_path = path
                     end
-                    opt.on '--public-gems', "install gems in the default gem location" do
-                        self.install_gems_in_gem_user_dir
+                    opt.on "--public-gems", "install gems in the default gem location" do
+                        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
+                    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
-                            raise "cannot give both --version and --gemfile"
-                        end
+                    opt.on "--version=VERSION_CONSTRAINT", String, "use the provided "\
+                                                                   "string as a version constraint for autoproj" do |version|
+                        raise "cannot give both --version and --gemfile" if @gemfile
+
                         @gemfile = default_gemfile_contents(version)
                     end
-                    opt.on '--gemfile=PATH', String, 'use the given Gemfile to install '\
-                        'autoproj instead of the default' do |path|
-                        if @gemfile
-                            raise "cannot give both --version and --gemfile"
-                        end
+                    opt.on "--gemfile=PATH", String, "use the given Gemfile to install "\
+                                                     "autoproj instead of the default" do |path|
+                        raise "cannot give both --version and --gemfile" if @gemfile
+
                         @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
+                    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|
+                    opt.on "--seed-config=PATH", String, "path to a seed file that "\
+                                                         "should be used to initialize the configuration" do |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 '\
-                        '(e.g. the thor gem vs. the ruby-thor debian package)' do
+                    opt.on "--prefer-os-independent-packages", "prefer OS-independent "\
+                                                               "packages (such as a RubyGem) over their OS-packaged equivalent "\
+                                                               "(e.g. the thor gem vs. the ruby-thor debian package)" do
                         @prefer_indep_over_os_packages = true
                     end
-                    opt.on '--[no-]color', 'do not use colored output (enabled by '\
-                        'default if the terminal supports it)' do |color|
+                    opt.on "--[no-]color", "do not use colored output (enabled by "\
+                                           "default if the terminal supports it)" do |color|
                         if color then @autoproj_options << "--color"
-                        else @autoproj_options << '--no-color'
+                        else
+                            @autoproj_options << "--no-color"
                         end
                     end
-                    opt.on '--[no-]progress', 'do not use progress output (enabled by '\
-                        'default if the terminal supports it)' do |progress|
+                    opt.on "--[no-]progress", "do not use progress output (enabled by "\
+                                              "default if the terminal supports it)" do |progress|
                         if progress then @autoproj_options << "--progress"
-                        else @autoproj_options << '--no-progress'
+                        else
+                            @autoproj_options << "--no-progress"
                         end
                     end
-                    opt.on '--[no-]interactive', 'if non-interactive, use default '\
-                           'answer for questions' do |flag|
+                    opt.on "--[no-]interactive", "if non-interactive, use default "\
+                                                 "answer for questions" do |flag|
                         if flag then @autoproj_options << "--interactive"
-                        else @autoproj_options << "--no-interactive"
+                        else
+                            @autoproj_options << "--no-interactive"
                         end
                     end
                 end
@@ -346,11 +360,11 @@ module Autoproj
             end
 
             def bundler_version
-                @config['bundler_version']
+                @config["bundler_version"]
             end
 
             def find_bundler(gem_program, version: nil)
-                bundler_path = File.join(gems_gem_home, 'bin', 'bundle')
+                bundler_path = File.join(gems_gem_home, "bin", "bundle")
                 return unless File.exist?(bundler_path)
 
                 setup_paths =
@@ -369,7 +383,7 @@ module Autoproj
             def find_versioned_bundler_setup(gem_program, version)
                 contents = IO.popen(
                     [env_for_child, Gem.ruby, gem_program,
-                     'contents', '-v', version, 'bundler'],
+                     "contents", "-v", version, "bundler"],
                     &:readlines
                 )
                 return [] unless $CHILD_STATUS.success?
@@ -380,7 +394,7 @@ module Autoproj
             def find_unversioned_bundler_setup(gem_program)
                 setup_paths = IO.popen(
                     [env_for_child, Gem.ruby, gem_program,
-                     'which', '-a', 'bundler/setup'],
+                     "which", "-a", "bundler/setup"],
                     &:readlines
                 )
                 return [] unless $CHILD_STATUS.success?
@@ -389,29 +403,30 @@ module Autoproj
             end
 
             def install_bundler(gem_program, version: nil, silent: false)
-                local = ['--local'] if local?
+                local = ["--local"] if local?
 
                 redirection = Hash.new
-                if silent
-                    redirection = Hash[out: :close]
-                end
+                redirection = Hash[out: :close] if silent
 
                 version_args = []
-                version_args << '-v' << version if version
+                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')]
+                env = env.merge(
+                    { "PATH" => env["PATH"] + [File.join(gems_gem_home, "bin")] }
+                )
                 result = system(
                     env_for_child(env),
-                    Gem.ruby, gem_program, 'install',
-                        '--env-shebang', '--no-document', '--no-format-executable',
-                        '--clear-sources', '--source', gem_source,
-                        '--no-user-install', '--install-dir', gems_gem_home,
-                        *local, "--bindir=#{File.join(gems_gem_home, 'bin')}",
-                        'bundler', *version_args, **redirection)
-
-                if !result
+                    Gem.ruby, gem_program, "install",
+                    "--env-shebang", "--no-document", "--no-format-executable",
+                    "--clear-sources", "--source", gem_source,
+                    "--no-user-install", "--install-dir", gems_gem_home,
+                    *local, "--bindir=#{File.join(gems_gem_home, 'bin')}",
+                    "bundler", *version_args, **redirection
+                )
+
+                unless result
                     STDERR.puts "FATAL: failed to install bundler in #{gems_gem_home}"
                     nil
                 end
@@ -420,7 +435,7 @@ module Autoproj
                     bundler_path
                 else
                     STDERR.puts "gem install bundler returned successfully, but still "\
-                        "cannot find bundler in #{gems_gem_home}"
+                                "cannot find bundler in #{gems_gem_home}"
                     nil
                 end
             end
@@ -428,37 +443,45 @@ module Autoproj
             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')
-                if File.exist?(lockfile)
-                    FileUtils.rm lockfile
-                end
+                lockfile = File.join(dot_autoproj, "Gemfile.lock")
+                FileUtils.rm lockfile if File.exist?(lockfile)
+
+                run_bundler(bundler, "config", "set", "--local", "path", gems_install_path,
+                            bundler_version: bundler_version)
+                run_bundler(bundler, "config", "set", "--local", "shebang", Gem.ruby,
+                            bundler_version: bundler_version)
+
+                install_args = ["--gemfile=#{autoproj_gemfile_path}"]
+                install_args << "--local" if local?
+                run_bundler(bundler, "install", *install_args,
+                            bundler_version: bundler_version)
+
+                shims_path = File.join(dot_autoproj, "bin")
+                run_bundler(bundler, "binstubs", "--all", "--force", "--path", shims_path,
+                            bundler_version: bundler_version)
+                self.class.rewrite_shims(
+                    shims_path, ruby_executable, root_dir,
+                    autoproj_gemfile_path, gems_gem_home
+                )
+            end
 
-                clean_env = env_for_child.dup
+            class BundlerFailed < RuntimeError; end
 
-                opts = Array.new
-                opts << '--local' if local?
-                opts << "--path=#{gems_install_path}"
-                shims_path = File.join(dot_autoproj, 'bin')
+            def run_bundler(bundler, *args, bundler_version: self.bundler_version)
+                clean_env = env_for_child.dup
 
                 version_arg = []
                 version_arg << "_#{bundler_version}_" if bundler_version
 
                 result = system(
-                    clean_env,
-                    Gem.ruby, bundler, *version_arg, 'install',
-                    "--gemfile=#{autoproj_gemfile_path}",
-                    "--shebang=#{Gem.ruby}",
-                    "--binstubs=#{shims_path}",
-                    *opts, chdir: dot_autoproj
+                    clean_env, Gem.ruby, bundler, *version_arg,
+                    *args, chdir: dot_autoproj
                 )
 
                 unless result
-                    STDERR.puts "FATAL: failed to install autoproj in #{dot_autoproj}"
-                    exit 1
+                    raise BundlerFailed,
+                          "FAILED: bundler #{args.join(', ')} in #{dot_autoproj}"
                 end
-            ensure
-                self.class.rewrite_shims(shims_path, ruby_executable,
-                    root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
             EXCLUDED_FROM_SHIMS = %w[rake thor].freeze
@@ -466,13 +489,13 @@ module Autoproj
             def self.rewrite_shims(shim_path, ruby_executable,
                 root_dir, autoproj_gemfile_path, gems_gem_home)
                 FileUtils.mkdir_p shim_path
-                File.open(File.join(shim_path, 'ruby'), 'w') do |io|
+                File.open(File.join(shim_path, "ruby"), "w") do |io|
                     io.puts "#! /bin/sh"
                     io.puts "exec #{ruby_executable} \"$@\""
                 end
-                FileUtils.chmod 0755, File.join(shim_path, 'ruby')
+                FileUtils.chmod 0755, File.join(shim_path, "ruby")
 
-                Dir.glob(File.join(shim_path, '*')) do |bin_script|
+                Dir.glob(File.join(shim_path, "*")) do |bin_script|
                     next unless File.file?(bin_script)
 
                     bin_name = File.basename(bin_script)
@@ -480,25 +503,30 @@ module Autoproj
                         FileUtils.rm_f bin_script
                         next
                     end
-                    next if bin_name == 'ruby'
+                    next if bin_name == "ruby"
 
                     bin_shim = File.join(shim_path, bin_name)
                     bin_script_lines = File.readlines(bin_script)
                     next if has_autoproj_preamble?(bin_script_lines)
+                    next unless ruby_script?(bin_script_lines)
 
-                    File.open(bin_shim, 'w') do |io|
-                        if bin_name == 'bundler' || bin_name == 'bundle'
+                    File.open(bin_shim, "w") do |io|
+                        if bin_name == "bundler" || bin_name == "bundle"
                             io.puts shim_bundler(bin_script_lines, ruby_executable,
-                                autoproj_gemfile_path, gems_gem_home)
+                                                 autoproj_gemfile_path, gems_gem_home)
                         else
                             io.puts shim_script(bin_script_lines, ruby_executable, root_dir,
-                                autoproj_gemfile_path, gems_gem_home)
+                                                autoproj_gemfile_path, gems_gem_home)
                         end
                     end
                     FileUtils.chmod 0755, bin_shim
                 end
             end
 
+            def self.ruby_script?(script_lines)
+                script_lines.first =~ /\#\s*!(.*ruby.*)/
+            end
+
             def self.new_style_bundler_binstub?(script_lines)
                 script_lines.any? { |l| l =~ /This file was generated by Bundler/ }
             end
@@ -527,7 +555,7 @@ Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
             end
 
             def self.shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home)
-"#! #{ruby_executable}
+                "#! #{ruby_executable}
 
 #{WITHOUT_BUNDLER}
 ENV['BUNDLE_GEMFILE'] ||= '#{autoproj_gemfile_path}'
@@ -539,13 +567,13 @@ load Gem.bin_path('bundler', 'bundler')"
             end
 
             def self.shim_script(script_lines, ruby_executable, root_dir,
-                    autoproj_gemfile_path, gems_gem_home)
+                autoproj_gemfile_path, gems_gem_home)
                 new_style = !script_lines.empty? && script_lines.any? do |l|
                     l =~ /This file was generated by Bundler/
                 end
                 load_line = script_lines.grep(/load Gem.bin_path/).first
                 return shim_script_old(ruby_executable, root_dir,
-                    autoproj_gemfile_path, gems_gem_home, load_line) \
+                                       autoproj_gemfile_path, gems_gem_home, load_line) \
                     unless new_style
 
                 script_lines.insert(1, <<-AUTOPROJ_PREAMBLE)
@@ -559,12 +587,12 @@ ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
 ENV['AUTOPROJ_CURRENT_ROOT'] = '#{root_dir}'
 Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
                 AUTOPROJ_PREAMBLE
-                return script_lines.join
+                script_lines.join
             end
 
             def self.shim_script_old(ruby_executable, root_dir, autoproj_gemfile_path,
                 gems_gem_home, load_line)
-"#! #{ruby_executable}
+                "#! #{ruby_executable}
 
 #{RUBYLIB_REINIT}
 ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
@@ -589,15 +617,15 @@ require 'bundler/setup'
                     end
                 end
                 # Generate environment files right now, we can at least use bundler
-                File.open(File.join(dot_autoproj, 'env.sh'), 'w') do |io|
+                File.open(File.join(dot_autoproj, "env.sh"), "w") do |io|
                     env.export_env_sh(io)
                 end
 
                 # And now the root envsh
                 env = Autobuild::Environment.new
-                env.source_before File.join(dot_autoproj, 'env.sh')
-                env.set('AUTOPROJ_CURRENT_ROOT', root_dir)
-                File.open(File.join(root_dir, 'env.sh'), 'w') do |io|
+                env.source_before File.join(dot_autoproj, "env.sh")
+                env.set("AUTOPROJ_CURRENT_ROOT", root_dir)
+                File.open(File.join(root_dir, "env.sh"), "w") do |io|
                     env.export_env_sh(io)
                 end
             end
@@ -626,22 +654,19 @@ require 'bundler/setup'
                 ].join("\n")
 
                 FileUtils.mkdir_p File.dirname(autoproj_gemfile_path)
-                File.open(autoproj_gemfile_path, 'w') do |io|
+                File.open(autoproj_gemfile_path, "w") do |io|
                     io.write gemfile
                 end
             end
 
             ENV_BUNDLE_GEMFILE_RX = /^(\s*ENV\[['"]BUNDLE_GEMFILE['"]\]\s*)(?:\|\|)?=/
 
-
             def find_in_clean_path(command, *additional_paths)
-                clean_path = env_for_child['PATH'].split(File::PATH_SEPARATOR) +
-                    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)
-                        return full_path
-                    end
+                    return full_path if File.file?(full_path)
                 end
                 nil
             end
@@ -662,7 +687,7 @@ require 'bundler/setup'
                 # actual bindir
                 bindir = IO.popen(
                     env_for_child,
-                    [Gem.ruby, '-e', 'puts "#{Gem.user_dir}/bin"'], # rubocop:disable Lint/InterpolationCheck
+                    [Gem.ruby, "-e", 'puts "#{Gem.user_dir}/bin"'], # rubocop:disable Lint/InterpolationCheck
                     &:read
                 )
                 if bindir
@@ -673,16 +698,16 @@ require 'bundler/setup'
             end
 
             def install(bundler_version: self.bundler_version)
-                if ENV['BUNDLER_GEMFILE']
+                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"
                 end
 
-                gem_program  = self.class.guess_gem_program
+                gem_program = self.class.guess_gem_program
                 puts "Detected 'gem' to be #{gem_program}"
-                env['GEM_HOME'] = [gems_gem_home]
-                env['GEM_PATH'] = [gems_gem_home]
+                env["GEM_HOME"] = [gems_gem_home]
+                env["GEM_PATH"] = [gems_gem_home]
 
                 if (bundler = find_bundler(gem_program, version: bundler_version))
                     puts "Detected bundler at #{bundler}"
@@ -692,12 +717,13 @@ require 'bundler/setup'
                     exit(1) unless bundler
                 end
                 self.class.rewrite_shims(
-                    File.join(dot_autoproj, 'bin'),
+                    File.join(dot_autoproj, "bin"),
                     ruby_executable,
                     root_dir,
                     autoproj_gemfile_path,
-                    gems_gem_home)
-                env['PATH'].unshift File.join(dot_autoproj, 'bin')
+                    gems_gem_home
+                )
+                env["PATH"].unshift File.join(dot_autoproj, "bin")
                 save_gemfile
 
                 puts "Installing autoproj in #{gems_gem_home}"
@@ -705,7 +731,7 @@ require 'bundler/setup'
             end
 
             def load_config
-                v1_config_path = File.join(root_dir, 'autoproj', 'config.yml')
+                v1_config_path = File.join(root_dir, "autoproj", "config.yml")
 
                 config = Hash.new
                 if File.file?(v1_config_path)
@@ -715,49 +741,49 @@ require 'bundler/setup'
                     config.merge!(YAML.load(File.read(autoproj_config_path)) || Hash.new)
                 end
 
-                ruby = RbConfig::CONFIG['RUBY_INSTALL_NAME']
-                ruby_bindir = RbConfig::CONFIG['bindir']
+                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 = 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"
+                              "#{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
+                    config["ruby_executable"] = ruby_executable
                 end
 
                 @config = config
-                %w{gems_install_path prefer_indep_over_os_packages}.each do |flag|
+                %w[gems_install_path prefer_indep_over_os_packages].each do |flag|
                     instance_variable_set "@#{flag}", config.fetch(flag, false)
                 end
             end
 
             def save_config
-                config['gems_install_path']     = gems_install_path
-                config['prefer_indep_over_os_packages'] = prefer_indep_over_os_packages?
-                File.open(autoproj_config_path, 'w') { |io| YAML.dump(config, io) }
+                config["gems_install_path"] = gems_install_path
+                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(dot_autoproj, 'bin', 'autoproj')
+                File.join(dot_autoproj, "bin", "autoproj")
             end
 
             def run_autoproj(*args)
-                system env_for_child.merge('BUNDLE_GEMFILE' => autoproj_gemfile_path),
-                    Gem.ruby, autoproj_path, *args, *@autoproj_options
+                system env_for_child.merge("BUNDLE_GEMFILE" => autoproj_gemfile_path),
+                       Gem.ruby, autoproj_path, *args, *@autoproj_options
             end
 
             def v1_workspace?
-                File.file?(File.join(root_dir, 'autoproj', 'config.yml')) &&
-                    !File.directory?(File.join(root_dir, '.autoproj'))
+                File.file?(File.join(root_dir, "autoproj", "config.yml")) &&
+                    !File.directory?(File.join(root_dir, ".autoproj"))
             end
 
             def stage1
-                if v1_workspace? && File.file?(v1_envsh = File.join(root_dir, 'env.sh'))
-                    FileUtils.cp v1_envsh, 'env.sh-autoproj-v1'
+                if v1_workspace? && File.file?(v1_envsh = File.join(root_dir, "env.sh"))
+                    FileUtils.cp v1_envsh, "env.sh-autoproj-v1"
                 end
                 FileUtils.mkdir_p dot_autoproj
                 save_config
@@ -771,27 +797,27 @@ require 'bundler/setup'
                 clean_env = env_for_child
                 stage2_vars = clean_env.map { |k, v| "#{k}=#{v}" }
                 puts "starting the newly installed autoproj for stage2 install"
-                if !run_autoproj('install-stage2', root_dir, *stage2_vars, *@autoproj_options)
+                unless run_autoproj("install-stage2", root_dir, *stage2_vars, *@autoproj_options)
                     raise "failed to execute autoproj install-stage2"
                 end
             end
 
             def stage2(*vars)
-                require 'autobuild'
+                require "autobuild"
                 puts "saving temporary env.sh and .autoproj/env.sh"
                 save_env_sh(*vars)
                 puts "running 'autoproj envsh' to generate a proper env.sh"
-                if !system(Gem.ruby, autoproj_path, 'envsh', *@autoproj_options)
+                unless system(Gem.ruby, autoproj_path, "envsh", *@autoproj_options)
                     STDERR.puts "failed to run autoproj envsh on the newly installed "\
-                        "autoproj (#{autoproj_path})"
+                                "autoproj (#{autoproj_path})"
                     exit 1
                 end
                 # This is really needed on an existing install to install the
                 # gems that were present in the v1 layout
                 puts "running 'autoproj osdeps' to re-install missing gems"
-                if !system(Gem.ruby, autoproj_path, 'osdeps', *@autoproj_options)
+                unless system(Gem.ruby, autoproj_path, "osdeps", *@autoproj_options)
                     STDERR.puts "failed to run autoproj osdeps on the newly installed "\
-                        "autoproj (#{autoproj_path})"
+                                "autoproj (#{autoproj_path})"
                     exit 1
                 end
             end
@@ -799,12 +825,11 @@ require 'bundler/setup'
     end
 end
 
-
-ENV.delete('BUNDLE_GEMFILE')
-ENV.delete('RUBYLIB')
+ENV.delete("BUNDLE_GEMFILE")
+ENV.delete("RUBYLIB")
 ops = Autoproj::Ops::Install.new(Dir.pwd)
 
-existing_config = File.join(Dir.pwd, '.autoproj', 'config.yml')
+existing_config = File.join(Dir.pwd, ".autoproj", "config.yml")
 if File.file?(existing_config)
     puts "Found existing configuration, using it as seed"
     puts "use --no-seed-config to avoid this behavior"