autoproj 2.10.1 → 2.13.0

data/lib/autoproj/os_package_installer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'autoproj/package_managers/manager'
 require 'autoproj/package_managers/unknown_os_manager'
 require 'autoproj/package_managers/shell_script_manager'
@@ -37,7 +39,9 @@ class OSPackageInstaller
         attr_reader :installed_resolved_packages
 
         attr_writer :silent
-        def silent?; @silent end
+        def silent?
+            @silent
+        end
 
         class << self
             attr_accessor :force_osdeps
@@ -60,12 +64,12 @@ def initialize(ws, os_package_resolver, package_managers: PACKAGE_MANAGERS)
 
         # Returns the package manager object for the current OS
         def os_package_manager
-            if !@os_package_manager
+            unless @os_package_manager
                 name = os_package_resolver.os_package_manager
                 @os_package_manager = package_managers[name] ||
-                    PackageManagers::UnknownOSManager.new(ws)
+                                      PackageManagers::UnknownOSManager.new(ws)
             end
-            return @os_package_manager
+            @os_package_manager
         end
 
         # Returns the set of package managers
@@ -75,13 +79,17 @@ def each_manager(&block)
             package_managers.each_value(&block)
         end
 
+        def each_manager_with_name(&block)
+            package_managers.each(&block)
+        end
+
         HANDLE_ALL  = 'all'
         HANDLE_RUBY = 'ruby'
         HANDLE_OS   = 'os'
         HANDLE_NONE = 'none'
 
         def osdeps_mode_option_unsupported_os(config)
-            long_doc =<<-EOT
+            long_doc = <<-EOT
 The software packages that autoproj will have to build may require other
 prepackaged softwares (a.k.a. OS dependencies) to be installed (RubyGems
 packages, packages from your operating system/distribution, ...). Autoproj is
@@ -153,9 +161,9 @@ def osdeps_mode_option_supported_os(config)
             message = [ "Which prepackaged software (a.k.a. 'osdeps') should autoproj install automatically (all, none or a comma-separated list of: os gem pip) ?", long_doc.strip ]
 
             config.declare 'osdeps_mode', 'string',
-                default: 'all',
-                doc: message,
-                lowercase: true
+                           default: 'all',
+                           doc: message,
+                           lowercase: true
         end
 
         def define_osdeps_mode_option
@@ -171,14 +179,14 @@ def osdeps_mode_string_to_value(string)
             modes = []
             user_modes.each do |str|
                 case str
-                when 'all'  then modes.concat(['os', 'gem', 'pip'])
+                when 'all'  then modes.concat(%w[os gem pip])
                 when 'ruby' then modes << 'gem'
                 when 'gem'  then modes << 'gem'
                 when 'pip'  then modes << 'pip'
                 when 'os'   then modes << 'os'
                 when 'none' then
                 else
-                    if package_managers.has_key?(str)
+                    if package_managers.key?(str)
                         modes << str
                     else
                         raise ArgumentError, "#{str} is not a known package handler, known handlers are #{package_managers.keys.sort.join(", ")}"
@@ -442,5 +450,5 @@ def install_manager_packages(manager, package_list, install_only: false, run_pac
             end
         end
     end
-end 
+end
 

data/lib/autoproj/package_definition.rb

@@ -19,7 +19,9 @@ class PackageDefinition
         #
         # If the package is set up, its importer as well as all target
         # directories are properly set, and all {user_blocks} have been called.
-        def setup?; !!@setup end
+        def setup?
+            @setup
+        end
 
         # Sets the {setup?} flag
         attr_writer :setup
@@ -29,10 +31,11 @@ def setup?; !!@setup end
         attr_accessor :vcs
 
         def initialize(autobuild, package_set, file)
-            @autobuild, @package_set, @file =
-                autobuild, package_set, file
+            @autobuild = autobuild
+            @package_set = package_set
+            @file = file
             @user_blocks = []
-            @modes = ['import', 'build']
+            @modes = %w[import build]
             @setup = false
             @vcs = VCSDefinition.none
         end
@@ -44,9 +47,8 @@ def initialize(autobuild, package_set, file)
         #
         # @return [Array<String>]
         def modes
-            @modes + autobuild.utilities.values.
-                find_all { |u| u.enabled? }.
-                map(&:name)
+            @modes + autobuild.utilities
+                     .values.find_all(&:enabled?).map(&:name)
         end
 
         # The package name
@@ -65,9 +67,7 @@ def name
         # @see {user_blocks}
         def add_setup_block(block)
             user_blocks << block
-            if setup?
-                block.call(autobuild)
-            end
+            block.call(autobuild) if setup?
         end
 
         # Whether this package is already checked out
@@ -79,5 +79,24 @@ def checked_out?
         def depends_on(pkg)
             autobuild.depends_on(pkg.autobuild)
         end
+
+        def apply_dependencies_from_manifest
+            manifest = autobuild.description
+            manifest.each_dependency(modes) do |name, is_optional|
+                begin
+                    if is_optional
+                        autobuild.optional_dependency name
+                    else
+                        autobuild.depends_on name
+                    end
+                rescue ConfigError => e
+                    raise PackageNotFound.new(manifest.path),
+                          "manifest #{manifest.path} of #{self.name} from "\
+                          "#{package_set.name} lists '#{name}' as dependency, "\
+                          'but it is neither a normal package nor an osdeps '\
+                          "package. osdeps reports: #{e.message}", e.backtrace
+                end
+            end
+        end
     end
 end

data/lib/autoproj/package_managers/apt_dpkg_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'autoproj/package_managers/debian_version'
 
 module Autoproj
@@ -12,15 +14,17 @@ def initialize(ws, status_file = "/var/lib/dpkg/status")
                 @installed_packages = nil
                 @installed_versions = nil
                 super(ws, true,
-                      %w{apt-get install},
-                      %w{DEBIAN_FRONTEND=noninteractive apt-get install -y})
+                      %w[apt-get install],
+                      %w[DEBIAN_FRONTEND=noninteractive apt-get install -y])
             end
 
             def configure_manager
                 super
-                ws.config.declare 'apt_dpkg_update', 'boolean',
+                ws.config.declare(
+                    'apt_dpkg_update', 'boolean',
                     default: 'yes',
                     doc: ['Would you like autoproj to keep apt packages up-to-date?']
+                )
                 keep_uptodate?
             end
 
@@ -32,7 +36,9 @@ def keep_uptodate=(flag)
                 ws.config.set('apt_dpkg_update', flag, true)
             end
 
-            def self.parse_package_status(installed_packages, installed_versions, paragraph)
+            def self.parse_package_status(
+                installed_packages, installed_versions, paragraph, virtual: true
+            )
                 if paragraph =~ /^Status: install ok installed$/
                     if paragraph =~ /^Package: (.*)$/
                         package_name = $1
@@ -41,38 +47,40 @@ def self.parse_package_status(installed_packages, installed_versions, paragraph)
                             installed_versions[package_name] = DebianVersion.new($1)
                         end
                     end
-                    if paragraph =~ /^Provides: (.*)$/
+                    if virtual && paragraph =~ /^Provides: (.*)$/
                         installed_packages.merge($1.split(',').map(&:strip))
                     end
                 end
             end
 
-            def self.parse_dpkg_status(status_file)
+            def self.parse_dpkg_status(status_file, virtual: true)
                 installed_packages = Set.new
                 installed_versions = {}
                 dpkg_status = File.read(status_file)
                 dpkg_status << "\n"
 
                 dpkg_status = StringScanner.new(dpkg_status)
-                if !dpkg_status.scan(/Package: /)
-                    raise ArgumentError, "expected #{status_file} to have Package: lines but found none"
+                unless dpkg_status.scan(/Package: /)
+                    raise ArgumentError, "expected #{status_file} to have Package: "\
+                                         "lines but found none"
                 end
 
-                while paragraph_end = dpkg_status.scan_until(/Package: /)
+                while (paragraph_end = dpkg_status.scan_until(/Package: /))
                     paragraph = "Package: #{paragraph_end[0..-10]}"
-                    parse_package_status(installed_packages, installed_versions, paragraph)
+                    parse_package_status(installed_packages, installed_versions,
+                                         paragraph, virtual: virtual)
                 end
-                parse_package_status(installed_packages, installed_versions, "Package: #{dpkg_status.rest}")
+                parse_package_status(installed_packages, installed_versions,
+                                     "Package: #{dpkg_status.rest}", virtual: virtual)
                 [installed_packages, installed_versions]
             end
 
             def self.parse_apt_cache_paragraph(paragraph)
                 version = '0'
-                if paragraph =~ /^Package: (.*)$/
-                    package_name = $1
-                    if paragraph =~ /^Version: (.*)$/
-                        version = $1
-                    end
+                if (paragraph_m = /^Package: (.*)$/.match(paragraph))
+                    package_name = paragraph_m[1]
+                    version_m = /^Version: (.*)$/.match(paragraph)
+                    version = version_m[1] if version_m
                 end
                 [package_name, version]
             end
@@ -81,23 +89,24 @@ def self.parse_packages_versions(packages)
                 packages_versions = {}
                 apt_cache_show = `apt-cache show --no-all-versions #{packages.join(' ')}`
                 apt_cache_show = StringScanner.new(apt_cache_show)
-                if !apt_cache_show.scan(/Package: /)
-                    return packages_versions
-                end
+                return packages_versions unless apt_cache_show.scan(/Package: /)
 
-                while paragraph_end = apt_cache_show.scan_until(/Package: /)
+                while (paragraph_end = apt_cache_show.scan_until(/Package: /))
                     paragraph = "Package: #{paragraph_end[0..-10]}"
                     package_name, version = parse_apt_cache_paragraph(paragraph)
                     packages_versions[package_name] = DebianVersion.new(version)
                 end
-                package_name, version = parse_apt_cache_paragraph("Package: #{apt_cache_show.rest}")
+                package_name, version = parse_apt_cache_paragraph(
+                    "Package: #{apt_cache_show.rest}"
+                )
                 packages_versions[package_name] = DebianVersion.new(version)
                 packages_versions
             end
 
             def updated?(package, available_version)
-                # Consider up-to-date if the package is provided by another package (purely virtual)
-                # Ideally, we should check the version of the package that provides it
+                # Consider up-to-date if the package is provided by another
+                # package (purely virtual) Ideally, we should check the version
+                # of the package that provides it
                 return true unless available_version && @installed_versions[package]
 
                 (available_version <= @installed_versions[package])
@@ -105,8 +114,13 @@ def updated?(package, available_version)
 
             # On a dpkg-enabled system, checks if the provided package is installed
             # and returns true if it is the case
-            def installed?(package_name, filter_uptodate_packages: false, install_only: false)
-                @installed_packages, @installed_versions = self.class.parse_dpkg_status(status_file) unless @installed_packages && @installed_versions
+            def installed?(package_name, filter_uptodate_packages: false,
+                                         install_only: false)
+                unless @installed_packages && @installed_versions
+                    @installed_packages, @installed_versions =
+                        self.class.parse_dpkg_status(status_file)
+                end
+
                 if package_name =~ /^(\w[a-z0-9+-.]+)/
                     @installed_packages.include?($1)
                 else
@@ -116,11 +130,18 @@ def installed?(package_name, filter_uptodate_packages: false, install_only: fals
             end
 
             def install(packages, filter_uptodate_packages: false, install_only: false)
-                packages_versions = self.class.parse_packages_versions(packages)
                 if filter_uptodate_packages || install_only
-                    packages = packages.find_all do |package_name|
-                        !installed?(package_name) || (keep_uptodate? && !updated?(package_name, packages_versions[package_name]))
+                    already_installed, missing = packages.partition do |package_name|
+                        installed?(package_name)
+                    end
+
+                    if keep_uptodate? && !install_only
+                        packages_versions = self.class.parse_packages_versions(already_installed)
+                        need_update = already_installed.find_all do |package_name|
+                            !updated?(package_name, packages_versions[package_name])
+                        end
                     end
+                    packages = missing + (need_update || [])
                 end
 
                 if super(packages)

data/lib/autoproj/package_managers/bundler_manager.rb

@@ -24,6 +24,14 @@ def self.with_prerelease(*value)
                 end
             end
 
+            # Directory with cached .gem packages
+            #
+            # The directory must exist, but may be empty.
+            # It is initialized with {BundlerManager.cache_dir}
+            #
+            # @return [String]
+            attr_accessor :cache_dir
+
             # (see Manager#call_while_empty?)
             def call_while_empty?
                 !workspace_configuration_gemfiles.empty?
@@ -45,14 +53,31 @@ def initialize_environment
                 env.add_path 'PATH', File.join(ws.dot_autoproj_dir, 'bin')
                 env.set 'GEM_HOME', config.gems_gem_home
                 env.clear 'GEM_PATH'
+                if (bundler_version = config.bundler_version)
+                    env.set 'BUNDLER_VERSION', bundler_version
+                else
+                    env.clear 'BUNDLER_VERSION'
+                end
 
                 gemfile_path = File.join(ws.prefix_dir, 'gems', 'Gemfile')
-                if File.file?(gemfile_path)
-                    env.set('BUNDLE_GEMFILE', gemfile_path)
+                env.set('BUNDLE_GEMFILE', gemfile_path) if File.file?(gemfile_path)
+
+                if cache_dir && File.exist?(cache_dir)
+                    vendor_dir = File.join(File.dirname(gemfile_path), 'vendor')
+                    FileUtils.mkdir_p vendor_dir
+                    bundler_cache_dir = File.join(vendor_dir, 'cache')
+                    if File.writable?(cache_dir)
+                        create_cache_symlink(cache_dir, bundler_cache_dir)
+                    else
+                        Autoproj.warn "BundlerManager: #{cache_dir} is read-only "\
+                                      "copying the cache instead of symlinking it"
+                        create_cache_copy(cache_dir, bundler_cache_dir)
+                    end
                 end
 
-                Autobuild.programs['bundler'] = File.join(ws.dot_autoproj_dir, 'bin', 'bundle')
-                Autobuild.programs['bundle'] = File.join(ws.dot_autoproj_dir, 'bin', 'bundle')
+                Autobuild.programs['bundler'] =
+                    Autobuild.programs['bundle'] =
+                    File.join(ws.dot_autoproj_dir, 'bin', 'bundle')
 
                 env.init_from_env 'RUBYLIB'
                 env.inherit 'RUBYLIB'
@@ -61,17 +86,20 @@ def initialize_environment
                 original_rubylib =
                     (env['RUBYLIB'] || "").split(File::PATH_SEPARATOR).find_all do |p|
                         !p.start_with?(Bundler.rubygems.gem_dir) &&
-                            !Bundler.rubygems.gem_path.any? { |gem_p| p.start_with?(p) }
+                            Bundler.rubygems.gem_path
+                                   .none? { |gem_p| p.start_with?(gem_p) }
                     end
+
                 # And discover the system's rubylib
-                if system_rubylib = discover_rubylib
+                if (system_rubylib = discover_rubylib)
                     # Do not explicitely add the system rubylib to the
                     # environment, the interpreter will do it for us.
                     #
                     # This allows to use a binstub generated for one of ruby
                     # interpreter version on our workspace
                     env.system_env['RUBYLIB'] = []
-                    env.original_env['RUBYLIB'] = (original_rubylib - system_rubylib).join(File::PATH_SEPARATOR)
+                    env.original_env['RUBYLIB'] = (original_rubylib - system_rubylib)
+                                                  .join(File::PATH_SEPARATOR)
                 end
 
                 ws.config.each_reused_autoproj_installation do |p|
@@ -82,17 +110,135 @@ def initialize_environment
                 prefix_gems = File.join(ws.prefix_dir, "gems")
                 FileUtils.mkdir_p prefix_gems
                 gemfile = File.join(prefix_gems, 'Gemfile')
-                if !File.exist?(gemfile)
+                unless File.exist?(gemfile)
                     Ops.atomic_write(gemfile) do |io|
-                        io.puts "eval_gemfile \"#{File.join(ws.dot_autoproj_dir, 'Gemfile')}\""
+                        dot_autoproj_gemfile = File.join(ws.dot_autoproj_dir, 'Gemfile')
+                        io.puts "eval_gemfile \"#{dot_autoproj_gemfile}\""
                     end
                 end
 
-                if bundle_rubylib = discover_bundle_rubylib(silent_errors: true)
+                if (bundle_rubylib = discover_bundle_rubylib(silent_errors: true))
                     update_env_rubylib(bundle_rubylib, system_rubylib)
                 end
             end
 
+            def create_cache_symlink(cache_dir, bundler_cache_dir)
+                valid = !File.exist?(bundler_cache_dir) ||
+                        File.symlink?(bundler_cache_dir)
+
+                unless valid
+                    Autoproj.warn "cannot use #{cache_dir} as gem cache as "\
+                                  "#{bundler_cache_dir} already exists"
+                    return
+                end
+
+                FileUtils.rm_f bundler_cache_dir
+                FileUtils.ln_s cache_dir, bundler_cache_dir
+            end
+
+            def create_cache_copy(cache_dir, bundler_cache_dir)
+                valid = !File.exist?(bundler_cache_dir) ||
+                        File.directory?(bundler_cache_dir) ||
+                        File.symlink?(bundler_cache_dir)
+
+                unless valid
+                    Autoproj.warn "cannot use #{cache_dir} as gem cache as "\
+                                  "#{bundler_cache_dir} already exists"
+                    return
+                end
+
+                # Gracefully upgrade from the symlinks
+                FileUtils.rm_f bundler_cache_dir if File.symlink?(bundler_cache_dir)
+                FileUtils.mkdir_p bundler_cache_dir
+
+                Dir.glob(File.join(cache_dir, '*.gem')) do |path_src|
+                    path_dest = File.join(bundler_cache_dir, File.basename(path_src))
+                    next if File.exist?(path_dest)
+
+                    FileUtils.cp path_src, path_dest
+                end
+            end
+
+            # Enumerate the per-gem build configurations
+            def self.per_gem_build_config(ws)
+                ws.config.get('bundler.build', {})
+            end
+
+            # Add new build configuration arguments for a given gem
+            #
+            # This is meant to be used from the Autoproj configuration files,
+            # e.g. overrides.rb or package configuration
+            def self.add_build_configuration_for(gem_name, build_config, ws: Autoproj.workspace)
+                c = ws.config.get('bundler.build', {})
+                c[gem_name] = [c[gem_name], build_config].compact.join(" ")
+                ws.config.set('bundler.build', c)
+            end
+
+            # Set the build configuration for the given gem
+            #
+            # This is meant to be used from the Autoproj configuration files,
+            # e.g. overrides.rb or package configuration
+            def self.configure_build_for(gem_name, build_config, ws: Autoproj.workspace)
+                c = ws.config.get('bundler.build', {})
+                c[gem_name] = build_config
+                ws.config.set('bundler.build', c)
+            end
+
+            # Removes build configuration flags for the given gem
+            #
+            # This is meant to be used from the Autoproj configuration files,
+            # e.g. overrides.rb or package configuration
+            def self.remove_build_configuration_for(gem_name, ws: Autoproj.workspace)
+                c = ws.config.get('bundler.build', {})
+                c.delete(gem_name)
+                ws.config.set('bundler.build', c)
+            end
+
+            # @api private
+            #
+            # Apply configured per-gem build configuration options
+            #
+            # @param [Workspace] ws the workspace whose bundler configuration
+            #   should be updated
+            # @return [void]
+            def self.apply_build_config(ws)
+                root_dir = File.join(ws.prefix_dir, 'gems')
+                current_config_path = File.join(root_dir, ".bundle", "config")
+                current_config =
+                    if File.file?(current_config_path)
+                        File.readlines(current_config_path)
+                    else
+                        []
+                    end
+
+                build_config = {}
+                per_gem_build_config(ws).each do |name, conf|
+                    build_config[name.upcase] = conf
+                end
+
+                new_config = current_config.map do |line|
+                    next(line) unless (m = line.match(/BUNDLE_BUILD__(.*): "(.*)"$/))
+                    next unless (desired_config = build_config.delete(m[1]))
+
+                    if m[2] != desired_config
+                        "BUNDLE_BUILD__#{m[1]}: \"#{desired_config}\""
+                    else
+                        line
+                    end
+                end.compact
+
+                build_config.each do |name, config|
+                    new_config << "BUNDLE_BUILD__#{name}: \"#{config}\""
+                end
+
+                if new_config != current_config
+                    FileUtils.mkdir_p File.dirname(current_config_path)
+                    File.open(current_config_path, 'w') do |io|
+                        io.write new_config.join
+                    end
+                end
+            end
+
             # @api private
             #
             # Update RUBYLIB to add the gems that are part of the bundler
@@ -103,7 +249,8 @@ def initialize_environment
             # @param [Array<String>] system_rubylib the rubylib entries that are
             #   set by the underlying ruby interpreter itself
             def update_env_rubylib(bundle_rubylib, system_rubylib = discover_rubylib)
-                current = (ws.env.resolved_env['RUBYLIB'] || '').split(File::PATH_SEPARATOR) + system_rubylib
+                current = (ws.env.resolved_env['RUBYLIB'] || '')
+                          .split(File::PATH_SEPARATOR) + system_rubylib
                 (bundle_rubylib - current).each do |p|
                     ws.env.add_path('RUBYLIB', p)
                 end
@@ -128,7 +275,7 @@ def parse_package_entry(entry)
             end
 
             class NotCleanState < RuntimeError; end
-            
+
             # @api private
             #
             # Create backup files matching a certain file mapping
@@ -138,9 +285,7 @@ class NotCleanState < RuntimeError; end
             #   file might not exist.
             def backup_files(mapping)
                 mapping.each do |file, backup_file|
-                    if File.file?(file)
-                        FileUtils.cp file, backup_file
-                    end
+                    FileUtils.cp file, backup_file if File.file?(file)
                 end
             end
 
@@ -151,9 +296,7 @@ def backup_files(mapping)
             # @param (see #backup_file)
             def backup_restore(mapping)
                 mapping.each do |file, backup_file|
-                    if File.file?(backup_file)
-                        FileUtils.cp backup_file, file
-                    end
+                    FileUtils.cp backup_file, file if File.file?(backup_file)
                 end
             end
 
@@ -163,34 +306,36 @@ def backup_restore(mapping)
             #
             # @param (see #backup_file)
             def backup_clean(mapping)
-                mapping.each do |file, backup_file|
-                    if File.file?(backup_file)
-                        FileUtils.rm backup_file
-                    end
+                mapping.each do |_file, backup_file|
+                    FileUtils.rm backup_file if File.file?(backup_file)
                 end
             end
 
-            def self.run_bundler_install(ws, gemfile, *options, update: true, binstubs: nil,
-			gem_home: ws.config.gems_gem_home,
-			gem_path: ws.config.gems_install_path)
-                if update && File.file?("#{gemfile}.lock")
-                    FileUtils.rm "#{gemfile}.lock"
-                end
+            def self.run_bundler_install(
+                ws, gemfile, *options,
+                update: true, binstubs: nil,
+                bundler_version: ws.config.bundler_version,
+                gem_home: ws.config.gems_gem_home,
+                gem_path: ws.config.gems_install_path
+            )
+                FileUtils.rm "#{gemfile}.lock" if update && File.file?("#{gemfile}.lock")
 
                 options << '--path' << gem_path
                 options << "--shebang" << Gem.ruby
-                if binstubs
-                    options << "--binstubs" << binstubs
-                end
+                options << "--binstubs" << binstubs if binstubs
+
+                apply_build_config(ws)
 
                 connections = Set.new
-                run_bundler(ws, 'install', *options, gem_home: gem_home, gemfile: gemfile) do |line|
+                run_bundler(ws, 'install', *options,
+                            bundler_version: bundler_version,
+                            gem_home: gem_home, gemfile: gemfile) do |line|
                     case line
                     when /Installing (.*)/
                         Autobuild.message "  bundler: installing #{$1}"
                     when /Fetching.*from (.*)/
                         host = $1.gsub(/\.+$/, '')
-                        if !connections.include?(host)
+                        unless connections.include?(host)
                             Autobuild.message "  bundler: connected to #{host}"
                             connections << host
                         end
@@ -198,32 +343,49 @@ def self.run_bundler_install(ws, gemfile, *options, update: true, binstubs: nil,
                 end
             end
 
-            def self.bundle_gem_path(ws, gem_name, gem_home: nil, gemfile: nil)
+            def self.bundle_gem_path(ws, gem_name,
+                                     bundler_version: ws.config.bundler_version,
+                                     gem_home: nil, gemfile: nil)
                 path = String.new
-                PackageManagers::BundlerManager.run_bundler(ws, 'show', gem_name, gem_home: gem_home, gemfile: gemfile) do |line|
-                    path << line
-                end
+                run_bundler(
+                    ws, 'show', gem_name,
+                    bundler_version: bundler_version, gem_home: gem_home,
+                    gemfile: gemfile) { |line| path << line }
                 path.chomp
             end
 
-            def self.run_bundler(ws, *commandline, gem_home: nil, gemfile: nil)
-                Bundler.with_clean_env do
+            def self.default_bundler(ws)
+                File.join(ws.dot_autoproj_dir, 'bin', 'bundle')
+            end
+
+            def self.run_bundler(ws, *commandline,
+                                 bundler_version: ws.config.bundler_version,
+                                 gem_home: ws.config.gems_gem_home,
+                                 gemfile: default_gemfile_path(ws))
+                bundle = Autobuild.programs['bundle'] || default_bundler(ws)
+
+                Autoproj.bundler_with_unbundled_env do
+                    bundler_version_env =
+                        if bundler_version
+                            { 'BUNDLER_VERSION' => bundler_version }
+                        else
+                            {}
+                        end
                     target_env = Hash[
                         'GEM_HOME' => gem_home,
                         'GEM_PATH' => nil,
                         'BUNDLE_GEMFILE' => gemfile,
                         'RUBYOPT' => nil,
-                        'RUBYLIB' => rubylib_for_bundler
-                    ]
-                    ws.run 'autoproj', 'osdeps',
-                        Autobuild.tool('bundle'), *commandline,
-                        working_directory: File.dirname(gemfile), env: target_env do |line|
-                            yield(line) if block_given?
-                        end
+                        'RUBYLIB' => rubylib_for_bundler,
+                    ].merge(bundler_version_env)
+                    ws.run('autoproj', 'osdeps',
+                           bundle, *commandline,
+                           working_directory: File.dirname(gemfile),
+                           env: target_env) { |line| yield(line) if block_given? }
                 end
             end
 
-            # Parse the contents of a gemfile into a set of 
+            # Parse the contents of a gemfile into a set of
             def merge_gemfiles(*path, unlock: [])
                 gems_remotes = Set.new
                 dependencies = Hash.new do |h, k|
@@ -237,9 +399,11 @@ def merge_gemfiles(*path, unlock: [])
                     bundler_def =
                         begin Bundler::Dsl.evaluate(gemfile, nil, [])
                         rescue Exception => e
-                            cleaned_message = e.message.
-                                gsub(/There was an error parsing([^:]+)/, "Error in gem definitions").
-                                gsub(/#  from.*/, '')
+                            cleaned_message = e
+                                .message
+                                .gsub(/There was an error parsing([^:]+)/,
+                                      "Error in gem definitions")
+                                .gsub(/#  from.*/, '')
                             raise ConfigError, cleaned_message
                         end
                     gems_remotes |= bundler_def.send(:sources).rubygems_remotes.to_set
@@ -259,17 +423,17 @@ def merge_gemfiles(*path, unlock: [])
                 contents = []
                 gems_remotes.each do |g|
                     g = g.to_s
-                    if g.end_with?('/')
-                        g = g[0..-2]
-                    end
-                    contents << "source '#{g.to_s}'"
+                    g = g[0..-2] if g.end_with?('/')
+                    contents << "source '#{g}'"
                 end
-                valid_keys = %w{group groups git path glob name branch ref tag require submodules platform platforms type source install_if}
+                valid_keys = %w[group groups git path glob name branch ref tag
+                                require submodules platform platforms type
+                                source install_if]
                 dependencies.each do |group_name, by_platform|
                     contents << "group :#{group_name} do"
                     by_platform.each do |platform_name, deps|
                         deps = deps.values.sort_by(&:name)
-                        if !platform_name.empty?
+                        unless platform_name.empty?
                             contents << "  platform :#{platform_name} do"
                             platform_indent = "  "
                         end
@@ -279,13 +443,12 @@ def merge_gemfiles(*path, unlock: [])
                                 options.delete_if { |k, _| !valid_keys.include?(k) }
                                 options = options.map { |k, v| "#{k}: \"#{v}\"" }
                             end
-                            contents << ["  #{platform_indent}gem \"#{d.name}\", \"#{d.requirement}\"", *options].join(", ")
-                        end
-                        if !platform_name.empty?
-                            contents << "  end"
+                            contents << ["  #{platform_indent}gem \"#{d.name}\",
+                                         \"#{d.requirement}\"", *options].join(', ')
                         end
+                        contents << '  end' unless platform_name.empty?
                     end
-                    contents << "end"
+                    contents << 'end'
                 end
                 contents.join("\n")
             end
@@ -293,20 +456,25 @@ def merge_gemfiles(*path, unlock: [])
             def workspace_configuration_gemfiles
                 gemfiles = []
                 ws.manifest.each_package_set do |source|
-                    if source.local_dir && File.file?(pkg_set_gemfile = File.join(source.local_dir, 'Gemfile'))
+                    pkg_set_gemfile = File.join(source.local_dir, 'Gemfile')
+                    if source.local_dir && File.file?(pkg_set_gemfile)
                         gemfiles << pkg_set_gemfile
                     end
                 end
                 # In addition, look into overrides.d
-                Dir.glob(File.join(ws.overrides_dir, "*.gemfile")) do |overrides_gemfile_path|
-                    gemfiles << overrides_gemfile_path
+                Dir.glob(File.join(ws.overrides_dir, "*.gemfile")) do |overrides_gemfile|
+                    gemfiles << overrides_gemfile
                 end
                 gemfiles
             end
 
+            def self.default_gemfile_path(ws)
+                File.join(ws.prefix_dir, 'gems', 'Gemfile')
+            end
+
             def install(gems, filter_uptodate_packages: false, install_only: false)
-                root_dir     = File.join(ws.prefix_dir, 'gems')
-                gemfile_path = File.join(root_dir, 'Gemfile')
+                gemfile_path = self.class.default_gemfile_path(ws)
+                root_dir = File.dirname(gemfile_path)
                 gemfile_lock_path = "#{gemfile_path}.lock"
                 backups = Hash[
                     gemfile_path => "#{gemfile_path}.orig",
@@ -316,9 +484,10 @@ def install(gems, filter_uptodate_packages: false, install_only: false)
                 # Back up the existing gemfile, we'll restore it if something is
                 # wrong to avoid leaving bundler in an inconsistent state
                 backup_files(backups)
-                if !File.file?("#{gemfile_path}.orig")
+                unless File.file?("#{gemfile_path}.orig")
                     Ops.atomic_write("#{gemfile_path}.orig") do |io|
-                        io.puts "eval_gemfile \"#{File.join(ws.dot_autoproj_dir, 'Gemfile')}\""
+                        dot_autoproj_gemfile = File.join(ws.dot_autoproj_dir, 'Gemfile')
+                        io.puts "eval_gemfile \"#{dot_autoproj_gemfile}\""
                     end
                 end
 
@@ -330,7 +499,7 @@ def install(gems, filter_uptodate_packages: false, install_only: false)
                 gemfile_contents = Tempfile.open 'autoproj-gemfile' do |io|
                     gems.sort.each do |name|
                         name, version = parse_package_entry(name)
-                        io.puts "gem \"#{name}\", \"#{version || ">= 0"}\""
+                        io.puts "gem \"#{name}\", \"#{version || '>= 0'}\""
                     end
                     io.flush
                     gemfiles.unshift io.path
@@ -340,7 +509,9 @@ def install(gems, filter_uptodate_packages: false, install_only: false)
                 end
 
                 FileUtils.mkdir_p root_dir
-                if updated = (!File.exist?(gemfile_path) || File.read(gemfile_path) != gemfile_contents)
+                updated = (!File.exist?(gemfile_path) ||
+                           File.read(gemfile_path) != gemfile_contents)
+                if updated
                     Ops.atomic_write(gemfile_path) do |io|
                         io.puts "ruby \"#{RUBY_VERSION}\" if respond_to?(:ruby)"
                         io.puts gemfile_contents
@@ -350,24 +521,25 @@ def install(gems, filter_uptodate_packages: false, install_only: false)
                 options = Array.new
                 binstubs_path = File.join(root_dir, 'bin')
                 if updated || !install_only || !File.file?("#{gemfile_path}.lock")
-                    self.class.run_bundler_install ws, gemfile_path, *options,
-                        binstubs: binstubs_path
+                    self.class.run_bundler_install(ws, gemfile_path, *options,
+                                                   binstubs: binstubs_path)
                 end
 
-                if bundle_rubylib = discover_bundle_rubylib
+                if (bundle_rubylib = discover_bundle_rubylib)
                     update_env_rubylib(bundle_rubylib)
                 else
-                    raise NotCleanState, "bundler executed successfully, but the result was not in a clean state"
+                    raise NotCleanState, "bundler executed successfully, "\
+                                         "but the result was not in a clean state"
                 end
-
             rescue Exception
-                Autoproj.warn "saved the new Gemfile in #{gemfile_path}.FAILED and restored the last Gemfile version"
+                Autoproj.warn "saved the new Gemfile in #{gemfile_path}.FAILED "\
+                              "and restored the last Gemfile version"
                 FileUtils.cp gemfile_path, "#{gemfile_path}.FAILED"
                 backup_restore(backups)
                 raise
             ensure
                 if binstubs_path
-                    FileUtils.rm_f File.join(binstubs_path, 'bundle') 
+                    FileUtils.rm_f File.join(binstubs_path, 'bundle')
                     FileUtils.rm_f File.join(binstubs_path, 'bundler')
                 end
                 backup_clean(backups)
@@ -376,14 +548,14 @@ def install(gems, filter_uptodate_packages: false, install_only: false)
             def discover_rubylib
                 require 'bundler'
                 Tempfile.open 'autoproj-rubylib' do |io|
-                    result = Bundler.clean_system(
+                    result = Autoproj.bundler_unbundled_system(
                         Hash['RUBYLIB' => nil],
                         Autobuild.tool('ruby'), '-e', 'puts $LOAD_PATH',
                         out: io,
                         err: '/dev/null')
                     if result
                         io.rewind
-                        io.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
+                        io.readlines.map(&:chomp).find_all { |l| !l.empty? }
                     end
                 end
             end
@@ -397,25 +569,23 @@ def discover_bundle_rubylib(silent_errors: false)
                 require 'bundler'
                 gemfile = File.join(ws.prefix_dir, 'gems', 'Gemfile')
                 silent_redirect = Hash.new
-                if silent_errors
-                    silent_redirect[:err] = :close
-                end
+                silent_redirect[:err] = :close if silent_errors
                 env = ws.env.resolved_env
                 Tempfile.open 'autoproj-rubylib' do |io|
-                    result = Bundler.clean_system(
+                    result = Autoproj.bundler_unbundled_system(
                         Hash['GEM_HOME' => env['GEM_HOME'], 'GEM_PATH' => env['GEM_PATH'],
                              'BUNDLE_GEMFILE' => gemfile, 'RUBYOPT' => nil,
                              'RUBYLIB' => self.class.rubylib_for_bundler],
-                        Autobuild.tool('ruby'), '-rbundler/setup', '-e', 'puts $LOAD_PATH',
+                        Autobuild.tool('ruby'), '-rbundler/setup',
+                        '-e', 'puts $LOAD_PATH',
                         out: io, **silent_redirect)
-                        
+
                     if result
                         io.rewind
-                        io.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
+                        io.readlines.map(&:chomp).find_all { |l| !l.empty? }
                     end
                 end
             end
         end
     end
 end
-