autoproj 2.14.0 → 2.15.0

data/lib/autoproj/ops/install.rb

@@ -1,10 +1,10 @@
 # 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
@@ -71,33 +71,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
@@ -113,45 +110,56 @@ 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
@@ -162,8 +170,8 @@ module Autoproj
             #
             # 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
+                @gem_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
@@ -172,7 +180,8 @@ 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]
@@ -184,9 +193,6 @@ module Autoproj
             # @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
 
             private def xdg_var(varname, default)
                 if (env = ENV[varname]) && !env.empty?
@@ -198,10 +204,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
@@ -218,19 +225,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))
@@ -238,7 +244,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}
@@ -260,74 +266,75 @@ module Autoproj
             # 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
@@ -336,11 +343,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 =
@@ -359,7 +366,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?
@@ -370,7 +377,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?
@@ -379,29 +386,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
@@ -410,7 +418,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
@@ -418,24 +426,22 @@ 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)
 
                 clean_env = env_for_child.dup
 
                 opts = Array.new
-                opts << '--local' if local?
+                opts << "--local" if local?
                 opts << "--path=#{gems_install_path}"
-                shims_path = File.join(dot_autoproj, 'bin')
+                shims_path = File.join(dot_autoproj, "bin")
 
                 version_arg = []
                 version_arg << "_#{bundler_version}_" if bundler_version
 
                 result = system(
                     clean_env,
-                    Gem.ruby, bundler, *version_arg, 'install',
+                    Gem.ruby, bundler, *version_arg, "install",
                     "--gemfile=#{autoproj_gemfile_path}",
                     "--shebang=#{Gem.ruby}",
                     "--binstubs=#{shims_path}",
@@ -448,7 +454,7 @@ module Autoproj
                 end
             ensure
                 self.class.rewrite_shims(shims_path, ruby_executable,
-                    root_dir, autoproj_gemfile_path, gems_gem_home)
+                                         root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
             EXCLUDED_FROM_SHIMS = %w[rake thor].freeze
@@ -456,13 +462,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)
@@ -470,19 +476,19 @@ 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)
 
-                    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
@@ -517,7 +523,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}'
@@ -529,13 +535,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)
@@ -549,12 +555,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}'
@@ -579,15 +585,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
@@ -616,22 +622,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
@@ -652,7 +655,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
@@ -663,16 +666,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}"
@@ -682,12 +685,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}"
@@ -695,7 +699,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)
@@ -705,49 +709,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
@@ -761,27 +765,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