autoproj 2.10.2 → 2.11.0

data/lib/autoproj/ops/install.rb

@@ -232,54 +232,54 @@ def parse_options(args = ARGV)
                     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|
+                    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
                     end
-                    opt.on '--version=VERSION_CONSTRAINT', String, 'use the provided "\
-                        "string as a version constraint for autoproj' do |version|
+                    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
                         @gemfile = default_gemfile_contents(version)
                     end
-                    opt.on '--gemfile=PATH', String, 'use the given Gemfile to install "\
-                        "autoproj instead of the default' do |path|
+                    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
                         @gemfile = File.read(path)
                     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|
                         @config.merge!(YAML.load(File.read(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'
                         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'
                         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"
                         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 ConfigError.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/bundler_manager.rb

@@ -47,12 +47,12 @@ def initialize_environment
                 env.clear 'GEM_PATH'
 
                 gemfile_path = File.join(ws.prefix_dir, 'gems', 'Gemfile')
-                if File.file?(gemfile_path)
-                    env.set('BUNDLE_GEMFILE', gemfile_path)
-                end
+                env.set('BUNDLE_GEMFILE', gemfile_path) if File.file?(gemfile_path)
 
-                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'] = File.join(ws.dot_autoproj_dir,
+                                                          'bin', 'bundle')
+                Autobuild.programs['bundle'] = File.join(ws.dot_autoproj_dir,
+                                                         'bin', 'bundle')
 
                 env.init_from_env 'RUBYLIB'
                 env.inherit 'RUBYLIB'
@@ -61,17 +61,19 @@ 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 +84,98 @@ 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
 
+            # 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 +186,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 +212,7 @@ def parse_package_entry(entry)
             end
 
             class NotCleanState < RuntimeError; end
-            
+
             # @api private
             #
             # Create backup files matching a certain file mapping
@@ -138,9 +222,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 +233,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 +243,32 @@ 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,
+                                         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,
+                            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
@@ -200,13 +278,20 @@ def self.run_bundler_install(ws, gemfile, *options, update: true, binstubs: nil,
 
             def self.bundle_gem_path(ws, gem_name, 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
+                PackageManagers::BundlerManager.run_bundler(
+                    ws, 'show', gem_name,
+                    gem_home: gem_home,
+                    gemfile: gemfile) { |line| path << line }
                 path.chomp
             end
 
+            def self.default_bundler(ws)
+                File.join(ws.dot_autoproj_dir, 'bin', 'bundle')
+            end
+
             def self.run_bundler(ws, *commandline, gem_home: nil, gemfile: nil)
+                bundle = Autobuild.programs['bundle'] || default_bundler(ws)
+
                 Bundler.with_clean_env do
                     target_env = Hash[
                         'GEM_HOME' => gem_home,
@@ -215,15 +300,14 @@ def self.run_bundler(ws, *commandline, gem_home: nil, gemfile: nil)
                         '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
+                    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 +321,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 +345,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 +365,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,13 +378,14 @@ 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
@@ -316,9 +402,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 +417,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 +427,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 +439,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)
@@ -383,7 +473,7 @@ def discover_rubylib
                         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 +487,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(
                         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
-