autoproj 2.7.1 → 2.8.0

data/lib/autoproj/cli/build.rb

@@ -13,7 +13,7 @@ def validate_options(selected_packages, options)
                     options[:deps] = false
                 end
                 if options[:deps].nil?
-                    options[:deps] = 
+                    options[:deps] =
                         !(options[:rebuild] || options[:force])
                 end
                 return selected_packages, options
@@ -78,11 +78,10 @@ def run(selected_packages, options)
                 Autobuild.do_build = true
                 ops.build_packages(source_packages, parallel: parallel)
                 Autobuild.apply(source_packages, "autoproj-build", ['install'])
+                Main.run_post_command_hook(:build, ws, source_packages: source_packages)
             ensure
                 export_env_sh
             end
         end
     end
 end
-
-

data/lib/autoproj/cli/main.rb

@@ -2,6 +2,8 @@
 require 'tty/color'
 require 'autoproj/cli/main_test'
 require 'autoproj/cli/main_plugin'
+require 'autoproj/cli/main_global'
+require 'autoproj/cli'
 require 'autoproj/reporter'
 
 module Autoproj
@@ -9,6 +11,12 @@ module CLI
         def self.basic_setup
             Encoding.default_internal = Encoding::UTF_8
             Encoding.default_external = Encoding::UTF_8
+
+            argv = ARGV.find_all { |arg| arg != "--no-plugins" }
+            if argv.size == ARGV.size
+                Autoproj::CLI.load_plugins
+            end
+            argv
         end
 
         class Main < Thor
@@ -26,6 +34,44 @@ class Main < Thor
             stop_on_unknown_option! :exec
             check_unknown_options!  except: :exec
 
+            # @api private
+            #
+            # Run hooks defined for a given hook name
+            def self.run_post_command_hook(hook_name, ws, **args)
+                @post_command_hooks[hook_name].each do |hook|
+                    hook.call(ws, args)
+                end
+            end
+
+            # Register a hook that should be called at a given event
+            #
+            # @overload register_post_command_hook(:update)
+            #   @yieldparam [Workspace] ws
+            #   @yieldparam [Hash] params
+            #
+            #   Hook called after an update operation (from the CLI, either
+            #   update or osdeps)
+            #
+            #   The params contain :source_packages and :osdeps_packages,
+            #   respectively the list of names of the source and osdeps packages
+            #   selected for the update operation (NOT the list of packages
+            #   actually updated)
+            #
+            # @overload register_post_command_hook(:build)
+            #   @yieldparam [Workspace] ws
+            #   @yieldparam [Hash] params
+            #
+            #   Hook called after a build operation (from the CLI, build)
+            #
+            #   The params contain :source_packages, the list of names of the
+            #   source and osdeps packages selected for the update operation (NOT
+            #   the list of packages actually updated)
+            def self.register_post_command_hook(hook_name, &block)
+                @post_command_hooks[hook_name.to_sym] << block
+            end
+
+            @post_command_hooks = Hash.new { |h, k| h[k] = Array.new }
+
             no_commands do
                 def default_report_on_package_failures
                     if options[:debug]
@@ -79,7 +125,7 @@ def bootstrap(*args)
                 run_autoproj_cli(:bootstrap, :Bootstrap, Hash[], *args)
             end
 
-            desc 'envsh', 'update the env.sh file'
+            desc 'envsh', 'update the environment files'
             def envsh
                 run_autoproj_cli(:envsh, :Envsh, Hash[])
             end
@@ -163,7 +209,7 @@ def update(*packages)
                     report_options[:on_package_failures] = :report
                 end
 
-                run_autoproj_cli(:update, :Update, report_options, *packages)
+                run_autoproj_cli(:update, :Update, report_options, *packages, run_hook: true)
             end
 
             desc 'build [PACKAGES]', 'build packages'
@@ -466,6 +512,9 @@ def install_stage2(root_dir, *vars)
             desc 'plugin', 'interface to manage autoproj plugins'
             subcommand 'plugin', MainPlugin
 
+            desc 'global', 'global management of the known workspaces'
+            subcommand 'global', MainGlobal
+
             desc 'patch', 'applies patches necessary for the selected package',
                 hide: true
             def patch(*packages)
@@ -518,3 +567,4 @@ def which(cmd)
         end
     end
 end
+

data/lib/autoproj/cli/main_global.rb

@@ -0,0 +1,39 @@
+module Autoproj
+    module CLI
+        class MainGlobal < Thor
+            namespace 'global'
+
+            desc 'register', 'register the current workspace'
+            def register
+                require 'autoproj'
+                ws = Workspace.default
+                ws.load_config
+                ws.register_workspace
+            end
+
+            desc 'status', 'display information about the known workspaces'
+            def status
+                require 'autoproj'
+                ws = Workspace.registered_workspaces
+                fields = Workspace::RegisteredWorkspace.members.map(&:to_s)
+                format_w = fields.map(&:length).max + 1
+                format = "%-#{format_w}s %s (%s)"
+                blocks = ws.map do |w|
+                    %w[root_dir prefix_dir build_dir].map do |name|
+                        dir = w.public_send(name)
+                        if dir.start_with?('/')
+                            status = if File.directory?(dir)
+                                         Autobuild.color('present', :green)
+                                     else
+                                         Autobuild.color('absent', :yellow)
+                                     end
+
+                            format(format, "#{name}:", dir, status)
+                        end
+                    end.compact.join("\n")
+                end
+                puts blocks.join("---\n")
+            end
+        end
+    end
+end

data/lib/autoproj/cli/osdeps.rb

@@ -29,8 +29,9 @@ def run(user_selection, update: true, **options)
                     run_package_managers_without_packages: true,
                     install_only: !update)
                 export_env_sh(shell_helpers: shell_helpers)
+                Main.run_post_command_hook(:update, ws, source_packages: [],
+                    osdep_packages: osdep_packages)
             end
         end
     end
 end
-

data/lib/autoproj/cli/update.rb

@@ -66,7 +66,7 @@ def validate_options(selection, options)
                 return selection, options
             end
 
-            def run(selected_packages, options)
+            def run(selected_packages, run_hook: false, **options)
                 ws.manifest.accept_unavailable_osdeps = !options[:osdeps]
                 ws.setup
                 ws.autodetect_operating_system(force: true)
@@ -127,6 +127,18 @@ def run(selected_packages, options)
                     ws.install_os_packages(osdep_packages, **osdeps_options)
                 end
 
+                if run_hook
+                    if options[:osdeps]
+                        CLI::Main.run_post_command_hook(:update, ws,
+                            source_packages: source_packages,
+                            osdep_packages: osdep_packages)
+                    else
+                        CLI::Main.run_post_command_hook(:update, ws,
+                            source_packages: source_packages,
+                            osdep_packages: [])
+                    end
+                end
+
                 export_env_sh
 
                 if !options[:auto_exclude]

data/lib/autoproj/configuration.rb

@@ -344,7 +344,7 @@ def apply_autobuild_configuration
                 end
             end
         end
-        
+
         # A cache directory for autobuild's importers
         def importer_cache_dir
             get('importer_cache_dir', nil)
@@ -367,6 +367,18 @@ def prefix_dir
             get('prefix', 'install')
         end
 
+        # Sets the shells used in this workspace.
+        def user_shells=(shells)
+            set('user_shells', shells, true)
+        end
+
+        # The shells used in this workspace.
+        #
+        # @return [Array<String>]
+        def user_shells
+            get('user_shells', [])
+        end
+
         # Defines the temporary area in which packages should put their build
         # files
         #
@@ -433,7 +445,7 @@ def randomize_layout=(value)
             'test' => false]
 
         # The configuration key that should be used to store the utility
-        # enable/disable information 
+        # enable/disable information
         #
         # @param [String] the utility name
         # @return [String] the config key

data/lib/autoproj/environment.rb

@@ -24,38 +24,55 @@ def export_env_sh(subdir = nil, options = Hash.new)
             options = validate_options options,
                 shell_helpers: true
 
-            filename = if subdir
-                   File.join(root_dir, subdir, ENV_FILENAME)
-               else
-                   File.join(root_dir, ENV_FILENAME)
-               end
-
             shell_dir = File.expand_path(File.join("..", "..", "shell"), File.dirname(__FILE__))
-            if options[:shell_helpers]
-                source_after(File.join(shell_dir, "autoproj_sh"))
-            end
+            completion_dir = File.join(shell_dir, 'completion')
+            env_updated = false
 
-            existing_content =
-                begin File.read(filename)
-                rescue SystemCallError
+            (['sh'] + Autoproj.workspace.config.user_shells).to_set.each do |shell|
+                env_filename = if shell == 'sh'
+                                   ENV_FILENAME
+                               else
+                                   (Pathname(ENV_FILENAME).sub_ext '').to_s.concat(".#{shell}")
+                               end
+
+                filename = if subdir
+                    File.join(root_dir, subdir, env_filename)
+                else
+                    File.join(root_dir, env_filename)
                 end
 
-            StringIO.open(new_content = String.new, 'w') do |io|
-                if inherit?
-                    io.write <<-EOF
-                    if test -n "$AUTOPROJ_CURRENT_ROOT" && test "$AUTOPROJ_CURRENT_ROOT" != "#{root_dir}"; then
-                        echo "the env.sh from $AUTOPROJ_CURRENT_ROOT is already loaded. Start a new shell before sourcing this one"
-                        return
-                    fi
-                    EOF
+                helper = File.join(shell_dir, "autoproj_#{shell}")
+                if options[:shell_helpers]
+                    source_after(helper, shell: shell) if File.file?(helper)
+                    %w[alocate alog amake aup autoproj].each do |tool|
+                        completion_file = File.join(completion_dir, "#{tool}_#{shell}")
+                        source_after(completion_file, shell: shell) if File.file?(completion_file)
+                    end
                 end
-                super(io)
-            end
 
-            if new_content != existing_content
-                Ops.atomic_write(filename) { |io| io.write new_content }
-                true
+                existing_content =
+                    begin File.read(filename)
+                    rescue SystemCallError
+                    end
+
+                StringIO.open(new_content = String.new, 'w') do |io|
+                    if inherit?
+                        io.write <<-EOF
+                        if test -n "$AUTOPROJ_CURRENT_ROOT" && test "$AUTOPROJ_CURRENT_ROOT" != "#{root_dir}"; then
+                            echo "the env.sh from $AUTOPROJ_CURRENT_ROOT is already loaded. Start a new shell before sourcing this one"
+                            return
+                        fi
+                        EOF
+                    end
+                    super(io, shell: shell)
+                end
+
+                if new_content != existing_content
+                    Ops.atomic_write(filename) { |io| io.write new_content }
+                    env_updated = true
+                end
             end
+            env_updated
         end
     end
 
@@ -76,16 +93,16 @@ def self.env_add_path(name, *value)
         env.add_path(name, *value)
     end
     # @deprecated call Autoproj.env.source_after instead
-    def self.env_source_file(file)
-        env.source_after(file)
+    def self.env_source_file(file, shell: 'sh')
+        env.source_after(file, shell: shell)
     end
     # @deprecated call Autoproj.env.source_after instead
-    def self.env_source_after(file)
-        env.source_after(file)
+    def self.env_source_after(file, shell: 'sh')
+        env.source_after(file, shell: shell)
     end
     # @deprecated call Autoproj.env.source_before instead
-    def self.env_source_before(file)
-        env.source_before(file)
+    def self.env_source_before(file, shell: 'sh')
+        env.source_before(file, shell: shell)
     end
     # @deprecated call Autoproj.env.inherit instead
     def self.env_inherit(*names)

data/lib/autoproj/ops/install.rb

@@ -47,13 +47,15 @@ def initialize(root_dir)
 
                 load_config
                 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"
+                    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"
                 end
                 @ruby_executable = config['ruby_executable']
                 @local = false
 
-                default_gem_path = File.join(Dir.home, '.autoproj', 'gems')
-                @gems_install_path     = default_gem_path
+                install_gems_in_gem_user_dir
             end
 
             def env_for_child
@@ -132,13 +134,15 @@ def gem_path_suffix
             #
             # They are installed in a versioned subdirectory of this path, e.g.
             # {#gem_path_suffix}.
-            # 
+            #
             # @return [String]
             attr_reader :gems_install_path
             # The GEM_HOME under which the workspace's gems should be installed
-            # 
+            #
             # @return [String]
-            def gems_gem_home; File.join(gems_install_path, gem_path_suffix) end
+            def gems_gem_home
+                File.join(gems_install_path, gem_path_suffix)
+            end
             # Sets where the workspace's gems should be installed
             #
             # @param [String] path the absolute path that should be given to
@@ -147,17 +151,41 @@ def gems_gem_home; File.join(gems_install_path, gem_path_suffix) end
             def gems_install_path=(path)
                 @gems_install_path = path
             end
+
+            private def xdg_var(varname, default)
+                if (env = ENV[varname]) && !env.empty?
+                    env
+                else
+                    default
+                end
+            end
+
             # Install autoproj in Gem's default user dir
             def install_gems_in_gem_user_dir
-                @gems_install_path = File.join(Gem.user_home, '.gem')
+                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')
+                @gems_install_path =
+                    if File.directory?(xdg_default_gem_path)
+                        xdg_default_gem_path
+                    elsif File.directory?(default_gem_path)
+                        default_gem_path
+                    else
+                        xdg_default_gem_path
+                    end
             end
 
             # Whether autoproj should prefer OS-independent packages over their
             # OS-packaged equivalents (e.g. the thor gem vs. the ruby-thor
             # Debian package)
-            def prefer_indep_over_os_packages?; @prefer_indep_over_os_packages end
+            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 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']
@@ -165,7 +193,7 @@ def self.guess_gem_program
 
                 candidates = ['gem']
                 if ruby_bin =~ /^ruby(.+)$/
-                    candidates.unshift "gem#{$1}" 
+                    candidates.unshift "gem#{$1}"
                 end
 
                 candidates.each do |gem_name|
@@ -173,7 +201,8 @@ def self.guess_gem_program
                         return gem_full_path
                     end
                 end
-                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
+                raise ArgumentError, "cannot find a gem program "\
+                    "(tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
             end
 
             # The content of the default {#gemfile}
@@ -197,39 +226,48 @@ def parse_options(args = ARGV)
                     opt.on '--skip-stage2', 'do not run the stage2 install' do
                         @skip_stage2 = true
                     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 |color|
+                    opt.on '--[no-]progress', 'do not use progress output (enabled by "\
+                        "default if the terminal supports it)' do |color|
                         if color then autoproj_options << "--progress"
                         else autoproj_options << '--no-progress'
                         end
@@ -262,9 +300,11 @@ def install_bundler(gem_program, silent: false)
 
                 result = system(
                     env_for_child.merge('GEM_HOME' => gems_gem_home),
-                    Gem.ruby, gem_program, 'install', '--env-shebang', '--no-document', '--no-format-executable', '--clear-sources', '--source', gem_source,
-                        *local,
-                        "--bindir=#{File.join(gems_gem_home, 'bin')}", 'bundler', **redirection)
+                    Gem.ruby, gem_program, 'install',
+                        '--env-shebang', '--no-document', '--no-format-executable',
+                        '--clear-sources', '--source', gem_source,
+                        *local, "--bindir=#{File.join(gems_gem_home, 'bin')}",
+                        'bundler', **redirection)
 
                 if !result
                     STDERR.puts "FATAL: failed to install bundler in #{gems_gem_home}"
@@ -275,14 +315,15 @@ def install_bundler(gem_program, silent: false)
                 if File.exist?(bundler_path)
                     bundler_path
                 else
-                    STDERR.puts "gem install bundler returned successfully, but still cannot find bundler in #{bundler_path}"
+                    STDERR.puts "gem install bundler returned successfully, but still "\
+                        "cannot find bundler in #{bundler_path}"
                     nil
                 end
             end
 
             def install_autoproj(bundler)
-                # Force bundler to update. If the user does not want this, let him specify a
-                # Gemfile with tighter version constraints
+                # 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
@@ -294,6 +335,7 @@ def install_autoproj(bundler)
                 opts << '--local' if local?
                 opts << "--path=#{gems_install_path}"
                 shims_path = File.join(dot_autoproj, 'bin')
+
                 result = system(clean_env,
                     Gem.ruby, bundler, 'install',
                         "--gemfile=#{autoproj_gemfile_path}",
@@ -306,12 +348,14 @@ def install_autoproj(bundler)
                     exit 1
                 end
             ensure
-                self.class.rewrite_shims(shims_path, ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home)
+                self.class.rewrite_shims(shims_path, ruby_executable,
+                    root_dir, autoproj_gemfile_path, gems_gem_home)
             end
 
             EXCLUDED_FROM_SHIMS = %w{rake thor}
 
-            def self.rewrite_shims(shim_path, ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home)
+            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|
                     io.puts "#! /bin/sh"
@@ -319,10 +363,9 @@ def self.rewrite_shims(shim_path, ruby_executable, root_dir, autoproj_gemfile_pa
                 end
                 FileUtils.chmod 0755, File.join(shim_path, 'ruby')
 
-                FileUtils.touch File.join(shim_path, 'bundler')
-                FileUtils.touch File.join(shim_path, 'bundle')
                 Dir.glob(File.join(shim_path, '*')) do |bin_script|
-                    next if !File.file?(bin_script)
+                    next unless File.file?(bin_script)
+
                     bin_name = File.basename(bin_script)
                     if EXCLUDED_FROM_SHIMS.include?(bin_name)
                         FileUtils.rm_f bin_script
@@ -332,19 +375,46 @@ def self.rewrite_shims(shim_path, ruby_executable, root_dir, autoproj_gemfile_pa
 
                     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'
-                            io.puts shim_bundler(ruby_executable, autoproj_gemfile_path, gems_gem_home)
+                            io.puts shim_bundler(bin_script_lines, ruby_executable,
+                                autoproj_gemfile_path, gems_gem_home)
                         else
-                            load_line = bin_script_lines.grep(/load Gem.bin_path/).first
-                            io.puts shim_script(ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home, load_line)
+                            io.puts shim_script(bin_script_lines, ruby_executable, root_dir,
+                                autoproj_gemfile_path, gems_gem_home)
                         end
                     end
                     FileUtils.chmod 0755, bin_shim
                 end
             end
 
-            def self.shim_bundler(ruby_executable, autoproj_gemfile_path, gems_gem_home)
+            def self.new_style_bundler_binstub?(script_lines)
+                script_lines.any? { |l| l =~ /This file was generated by Bundler/ }
+            end
+
+            def self.has_autoproj_preamble?(script_lines)
+                script_lines.any? { |l| l =~ /Autoproj generated preamble/ }
+            end
+
+            def self.shim_bundler(script_lines, ruby_executable, autoproj_gemfile_path, gems_gem_home)
+                return shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home) \
+                    unless new_style_bundler_binstub?(script_lines)
+
+                script_lines.insert(1, <<-RESTART_BUNDLER)
+# Autoproj generated preamble
+if defined?(Bundler)
+    Bundler.with_clean_env do
+        exec($0, *ARGV)
+    end
+end
+ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
+                RESTART_BUNDLER
+                script_lines.join
+            end
+
+            def self.shim_bundler_old(ruby_executable, autoproj_gemfile_path, gems_gem_home)
 "#! #{ruby_executable}
 
 if defined?(Bundler)
@@ -360,8 +430,35 @@ def self.shim_bundler(ruby_executable, autoproj_gemfile_path, gems_gem_home)
 
 load Gem.bin_path('bundler', 'bundler')"
             end
-            
-            def self.shim_script(ruby_executable, root_dir, autoproj_gemfile_path, gems_gem_home, load_line)
+
+            def self.shim_script(script_lines, ruby_executable, root_dir,
+                    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) \
+                    unless new_style
+
+                script_lines.insert(1, <<-AUTOPROJ_PREAMBLE)
+# Autoproj generated preamble, v1
+if defined?(Bundler)
+    Bundler.with_clean_env do
+        exec(Hash['RUBYLIB' => nil], $0, *ARGV)
+    end
+elsif ENV['RUBYLIB']
+    exec(Hash['RUBYLIB' => nil], $0, *ARGV)
+end
+
+ENV['BUNDLE_GEMFILE'] = '#{autoproj_gemfile_path}'
+ENV['AUTOPROJ_CURRENT_ROOT'] = '#{root_dir}'
+                AUTOPROJ_PREAMBLE
+                return script_lines.join
+            end
+
+            def self.shim_script_old(ruby_executable, root_dir, autoproj_gemfile_path,
+                gems_gem_home, load_line)
 "#! #{ruby_executable}
 
 if defined?(Bundler)
@@ -423,9 +520,10 @@ def save_gemfile
                     "if File.file?(config_path)",
                     "    require 'yaml'",
                     "    config = YAML.load(File.read(config_path)) || Hash.new",
-                    "    (config['plugins'] || Hash.new).each do |plugin_name, (version, options)|",
-                    "        gem plugin_name, version, **options",
-                    "    end",
+                    "    (config['plugins'] || Hash.new).",
+                    "        each do |plugin_name, (version, options)|",
+                    "            gem plugin_name, version, **options",
+                    "        end",
                     "end"
                 ].join("\n")
 
@@ -439,7 +537,8 @@ def save_gemfile
 
 
             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)
@@ -463,7 +562,8 @@ def gem_bindir
                 #
                 # So, we're calling 'gem' as a subcommand to discovery the
                 # actual bindir
-                bindir = IO.popen(env_for_child, [Gem.ruby, '-e', 'puts "#{Gem.user_dir}/bin"']).read
+                bindir = IO.popen(env_for_child,
+                    [Gem.ruby, '-e', 'puts "#{Gem.user_dir}/bin"']).read
                 if bindir
                     @gem_bindir = bindir.chomp
                 else
@@ -473,7 +573,9 @@ def gem_bindir
 
             def install
                 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"
+                    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
@@ -503,7 +605,7 @@ def install
 
             def load_config
                 v1_config_path = File.join(root_dir, 'autoproj', 'config.yml')
-                
+
                 config = Hash.new
                 if File.file?(v1_config_path)
                     config.merge!(YAML.load(File.read(v1_config_path)) || Hash.new)
@@ -517,7 +619,10 @@ def load_config
                 ruby_executable = File.join(ruby_bindir, ruby)
                 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"
+                        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"
                     end
                 else
                     config['ruby_executable'] = ruby_executable
@@ -576,18 +681,19 @@ def stage2(*vars)
                 save_env_sh(*vars)
                 puts "running 'autoproj envsh' to generate a proper env.sh"
                 if !system(Gem.ruby, autoproj_path, 'envsh', *autoproj_options)
-                    STDERR.puts "failed to run autoproj envsh on the newly installed autoproj (#{autoproj_path})"
+                    STDERR.puts "failed to run autoproj envsh on the newly installed "\
+                        "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')
-                    STDERR.puts "failed to run autoproj osdeps on the newly installed autoproj (#{autoproj_path})"
+                    STDERR.puts "failed to run autoproj osdeps on the newly installed "\
+                        "autoproj (#{autoproj_path})"
                     exit 1
                 end
             end
         end
     end
 end
-