autoproj 2.7.1 → 2.8.0

data/bin/autoproj_install

@@ -57,13 +57,15 @@ module Autoproj
 
                 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
@@ -142,13 +144,15 @@ module Autoproj
             #
             # 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
@@ -157,17 +161,41 @@ module Autoproj
             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']
@@ -175,7 +203,7 @@ module Autoproj
 
                 candidates = ['gem']
                 if ruby_bin =~ /^ruby(.+)$/
-                    candidates.unshift "gem#{$1}" 
+                    candidates.unshift "gem#{$1}"
                 end
 
                 candidates.each do |gem_name|
@@ -183,7 +211,8 @@ module Autoproj
                         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}
@@ -207,39 +236,48 @@ module Autoproj
                     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
@@ -272,9 +310,11 @@ module Autoproj
 
                 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}"
@@ -285,14 +325,15 @@ module Autoproj
                 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
@@ -304,6 +345,7 @@ module Autoproj
                 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}",
@@ -316,12 +358,14 @@ module Autoproj
                     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"
@@ -329,10 +373,9 @@ module Autoproj
                 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
@@ -342,19 +385,46 @@ module Autoproj
 
                     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)
@@ -370,8 +440,35 @@ Gem.paths = Hash['GEM_HOME' => '#{gems_gem_home}', 'GEM_PATH' => '']
 
 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)
@@ -433,9 +530,10 @@ require 'bundler/setup'
                     "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")
 
@@ -449,7 +547,8 @@ require 'bundler/setup'
 
 
             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)
@@ -473,7 +572,8 @@ require 'bundler/setup'
                 #
                 # 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
@@ -483,7 +583,9 @@ require 'bundler/setup'
 
             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
@@ -513,7 +615,7 @@ require 'bundler/setup'
 
             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)
@@ -527,7 +629,10 @@ require 'bundler/setup'
                 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
@@ -586,14 +691,16 @@ require 'bundler/setup'
                 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
@@ -602,7 +709,6 @@ require 'bundler/setup'
 end
 
 
-
 ENV.delete('BUNDLE_GEMFILE')
 ENV.delete('RUBYLIB')
 ops = Autoproj::Ops::Install.new(Dir.pwd)

data/lib/autoproj/autobuild_extensions/dsl.rb

@@ -105,6 +105,11 @@ def self.package_handler_for(full_path)
             end
             toplevel_dir ||= find_topmost_directory_containing(full_path, 'CMakeLists.txt')
 
+            manifest_xml = File.join(toplevel_dir, 'manifest.xml')
+            package_xml = File.join(toplevel_dir, 'package.xml')
+            if File.file?(package_xml) && !File.file?(manifest_xml)
+                return "catkin_package", toplevel_dir
+            end
             return "cmake_package", toplevel_dir
         elsif dir = find_topmost_directory_containing(full_path, "Rakefile") ||
             find_topmost_directory_containing(full_path, "lib/*.rb")

data/lib/autoproj/bash_completion.rb

@@ -0,0 +1,26 @@
+require 'autoproj/shell_completion'
+
+module Autoproj
+    # This class generates shell completion for code for a given Thor subclasss
+    class BashCompletion < ShellCompletion
+        MAIN_FUNCTION_TEMPLATE = 'main.bash.erb'
+        SUBCOMMAND_FUNCTION_TEMPLATE = 'subcommand.bash.erb'
+
+        def setup_file_completion(metadata)
+            metadata[:completer] = '_filedir'
+        end
+
+        def setup_executable_completion(metadata)
+            metadata[:completer] = 'COMPREPLY=( $( compgen -d -c -- "$cur" ) )'
+        end
+
+        def setup_package_completion(metadata)
+            metadata[:completer] = '_autoproj_installed_packages'
+        end
+
+        def disable_completion(metadata)
+            metadata[:completer] = nil
+        end
+    end
+end
+

data/lib/autoproj/cli/base.rb

@@ -9,7 +9,7 @@ class Base
             include Ops::Tools
 
             # The underlying workspace
-            # 
+            #
             # @return [Workspace]
             attr_reader :ws
 
@@ -85,7 +85,7 @@ def resolve_user_selection(selected_packages, **options)
                         if handler
                             Autoproj.message "  auto-adding #{srcdir} using the #{handler.gsub(/_package/, '')} package handler"
                             srcdir = File.expand_path(srcdir)
-                            relative_to_root = Pathname.new(srcdir).relative_path_from(Pathname.new(ws.root_dir))
+                            relative_to_root = Pathname.new(srcdir).relative_path_from(Pathname.new(ws.source_dir))
                             pkg = ws.in_package_set(ws.manifest.main_package_set, ws.manifest.file) do
                                 send(handler, relative_to_root.to_s, workspace: ws)
                             end
@@ -213,9 +213,9 @@ def notify_env_sh_updated
                 return if @env_sh_updated.nil?
 
                 if @env_sh_updated
-                    Autoproj.message "  updated: #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
+                    Autoproj.message "  updated environment", :green
                 else
-                    Autoproj.message "  left unchanged: #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
+                    Autoproj.message "  environment already up-to-date", :green
                 end
             end
         end