autoproj 2.7.1 → 2.8.0

data/lib/autoproj/shell_completion.rb

@@ -0,0 +1,164 @@
+require 'autoproj/cli/main'
+require 'erb'
+
+module Autoproj
+    # Generates shell completion for code for a given Thor subclass
+    class ShellCompletion
+        # The CLI
+        attr_reader :cli
+        # The command name
+        attr_reader :name
+        # A hash describing the CLI
+        attr_reader :cli_metadata
+
+        TEMPLATES_DIR = File.join(File.dirname(__FILE__), 'templates')
+
+        def initialize(name = 'autoproj', cli: Autoproj::CLI::Main, command: nil)
+            @cli = cli
+            @name = name
+
+            generate_metadata
+            return unless command
+            @cli_metadata = subcommand_by_name(*command)
+            @cli_metadata[:name] = "__#{name}"
+        end
+
+        def generate_metadata
+            @cli_metadata = { name: "__#{name}",
+                              description: nil,
+                              options: [],
+                              subcommands: subcommand_metadata(cli) }
+
+            setup_completion_functions
+            populate_help_subcommands
+        end
+
+        def setup_completion_functions
+            %w[which exec].each do |command|
+                setup_executable_completion(subcommand_by_name(command))
+            end
+
+            %w[cache manifest].each do |command|
+                setup_file_completion(subcommand_by_name(command))
+            end
+
+            # TODO: investigate how to handle 'plugin' subcommands completion,
+            # leaving disabled for now
+            # TODO: reset subcommand needs a custom completer,
+            # leaving disabled for now
+            # TODO: log subcommand needs a custom completer,
+            # leaving disabled for now
+            ['bootstrap', 'envsh', 'reconfigure', 'reset', 'log', 'query',
+             'switch-config', %w[global register], %w[global status],
+             %w[plugin install], %w[plugin remove], %w[plugin list]].each do |command|
+                disable_completion(subcommand_by_name(*command))
+            end
+        end
+
+        def generate
+            template_file = File.join(TEMPLATES_DIR, self.class::MAIN_FUNCTION_TEMPLATE)
+            erb = File.read(template_file)
+            ::ERB.new(erb, nil, '-').result(binding)
+        end
+
+        def subcommand_by_name(*name, metadata: cli_metadata)
+            subcommand = metadata
+
+            name.each do |subcommand_name|
+                subcommand = subcommand[:subcommands].find do |s|
+                    s[:name] == subcommand_name
+                end
+            end
+            subcommand
+        end
+
+        def populate_help_subcommands(command_metadata = cli_metadata)
+            help_subcommand = subcommand_by_name('help',
+                                                 metadata: command_metadata)
+
+            if help_subcommand
+                help_subcommand[:options] = []
+                disable_completion(help_subcommand)
+            end
+
+            command_metadata[:subcommands].each do |subcommand|
+                next if subcommand[:name] == 'help'
+                populate_help_subcommands(subcommand)
+                next unless help_subcommand
+                help_subcommand[:subcommands] << { name: subcommand[:name],
+                                                   aliases: [],
+                                                   description: subcommand[:description],
+                                                   options: [],
+                                                   subcommands: [] }
+            end
+        end
+
+        def render_subcommand_function(subcommand, options = {})
+            prefix = options[:prefix] || []
+            source = []
+
+            prefix = (prefix + [subcommand[:name]])
+            function_name = prefix.join('_')
+            depth = prefix.size + 1
+
+            template_file = File.join(TEMPLATES_DIR, self.class::SUBCOMMAND_FUNCTION_TEMPLATE)
+            erb = ::ERB.new(File.read(template_file), nil, '-')
+
+            source << erb.result(binding)
+            subcommand[:subcommands].each do |subcommand|
+                source << render_subcommand_function(subcommand, prefix: prefix)
+            end
+            source.join("\n").strip + "\n"
+        end
+
+        def subcommand_metadata(cli)
+            result = []
+            cli.all_commands.reject { |_, t| t.hidden? }.each do |(name, command)|
+                aliases = cli.map.select do |_, original_name|
+                    name == original_name
+                end.map(&:first)
+                result << generate_command_metadata(cli, name, command, aliases)
+            end
+            result
+        end
+
+        def generate_command_metadata(cli, name, command, aliases)
+            subcommands = if (subcommand_class = cli.subcommand_classes[name])
+                              subcommand_metadata(subcommand_class)
+                          else
+                              []
+                          end
+
+            info = { name: hyphenate(name),
+                     aliases: aliases.map { |a| hyphenate(a) },
+                     usage: command.usage,
+                     description: command.description,
+                     options: options_metadata(cli.class_options) +
+                              options_metadata(command.options),
+                     subcommands: subcommands }
+
+            if subcommands.empty?
+                setup_package_completion(info)
+            else
+                info[:options] = []
+                disable_completion(info)
+            end
+            info
+        end
+
+        def options_metadata(options)
+            options.reject { |_, option| option.hide }.map do |_, option|
+                names = ["--#{hyphenate(option.name)}"]
+                names += ["--no-#{hyphenate(option.name)}"] if option.boolean?
+                names += option.aliases.map { |a| "-#{hyphenate(a)}" }
+
+                { names: names,
+                  description: option.description }
+            end
+        end
+
+        def hyphenate(s)
+            s.to_s.tr('_', '-')
+        end
+    end
+end

data/lib/autoproj/templates/helpers.bash.erb

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+
+function acd {
+    local pkg_path
+    pkg_path=$(autoproj locate $1)
+
+    if [ $? != 0 ]; then
+      return 1
+    else
+      pkg_path=$(echo $pkg_path | tail -1)
+      cd $pkg_path
+      return 0
+    fi
+}
+
+type -p _get_comp_words_by_ref || return 1
+
+_autoproj_installed_packages() {
+    local packages="`ruby 2>/dev/null <<EOF
+begin
+    require 'autoproj'
+
+    path = Autoproj.workspace.installation_manifest_path
+    manifest = Autoproj::InstallationManifest.new(path)
+
+    manifest.load
+    manifest.each_package { |pkg| puts pkg.name }
+rescue
+end
+EOF`"
+
+    COMPREPLY=( $( compgen -W "$packages" -- "$cur" ) )
+}
+
+_autoproj_subcommands() {
+        local subcommands="$1"
+
+        local counter=$((command_pos + 1))
+        while [ "$counter" -lt "$cword" ]; do
+                case "${words[$counter]}" in
+                        $(_autoproj_to_extglob "$subcommands") )
+                                subcommand_pos=$counter
+                                local subcommand=${words[$counter]}
+                                local completions_func=_autoproj_${command}_${subcommand//-/_}
+                                declare -F "$completions_func" >/dev/null && "$completions_func"
+                                return 0
+                                ;;
+                esac
+                (( counter++ ))
+        done
+        return 1
+}
+
+_autoproj_to_alternatives() {
+        local parts=( $1 )
+        local IFS='|'
+        echo "${parts[*]}"
+}
+
+_autoproj_to_extglob() {
+        local extglob=$( _autoproj_to_alternatives "$1" )
+        echo "@($extglob)"
+}
+
+_acd()
+{
+    local cur prev words cword
+    _get_comp_words_by_ref -n : cur prev words cword
+    case "$cword" in
+        1)
+            _autoproj_installed_packages
+            ;;
+        *)
+            COMPREPLY=()
+            ;;
+    esac
+}
+
+complete -F _acd acd

data/lib/autoproj/templates/helpers.zsh.erb

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+function acd {
+    local pkg_path
+    pkg_path=$(autoproj locate $1)
+
+    if [ $? != 0 ]; then
+      return 1
+    else
+      pkg_path=$(echo $pkg_path | tail -1)
+      cd $pkg_path
+      return 0
+    fi
+}
+
+_autoproj_installed_packages() {
+    ruby 2>/dev/null <<EOF | while IFS= read -r; do packages+=("$REPLY"); done
+
+begin
+    require 'autoproj'
+
+    path = Autoproj.workspace.installation_manifest_path
+    manifest = Autoproj::InstallationManifest.new(path)
+
+    manifest.load
+    manifest.each_package { |pkg| puts pkg.name }
+rescue
+end
+EOF
+
+    compadd -a packages
+}
+
+_acd () {
+  _arguments -s "1:package:_autoproj_installed_packages"
+}
+
+compdef _acd acd

data/lib/autoproj/templates/main.bash.erb

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+
+__<%= name %>_<%= name %>()
+{
+    __<%= name %>
+}
+
+_<%= name %>()
+{
+    local cur prev words cword
+    local command='<%= name %>'
+    local counter=1
+
+    _get_comp_words_by_ref -n : cur prev words cword
+
+    while [ "$counter" -lt "$cword" ]; do
+        case "${words[$counter]}" in
+            -*)
+                break
+                ;;
+            *)
+                command="${words[$counter]}"
+                break
+                ;;
+        esac
+        (( counter++ ))
+    done
+
+    local completions_func=__<%= name %>_${command//-/_}
+    $completions_func
+}
+
+<%= render_subcommand_function(cli_metadata) %>
+
+complete -F _<%= name %> <%= name %>

data/lib/autoproj/templates/main.zsh.erb

@@ -0,0 +1,9 @@
+#!/usr/bin/env zsh
+
+_<%= name %>() {
+  __<%= name %>
+}
+
+<%= render_subcommand_function(cli_metadata) %>
+
+compdef _<%= name %> <%= name %>

data/lib/autoproj/templates/subcommand.bash.erb

@@ -0,0 +1,50 @@
+<%- if subcommand[:subcommands].any? %>
+<%= function_name %>() {
+    local subcommands="
+        <%- subcommand[:subcommands].each do |subcommand| -%>
+        <%= subcommand[:name] %>
+        <%- subcommand[:aliases].each do |_alias| -%>
+        <%= _alias %>
+        <%- end -%>
+        <%- end -%>
+    "
+
+    local options="
+        <%- subcommand[:options].each do |option| -%>
+        <%- option[:names].each do |name| -%>
+        <%= name %>
+        <%- end -%>
+        <%- end -%>
+    "
+
+    _autoproj_subcommands "$subcommands" && return
+
+    case "$cur" in
+        -*)
+            COMPREPLY=( $( compgen -W "$options" -- "$cur" ) )
+            ;;
+        *)
+            COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
+            ;;
+    esac
+}
+<%- else %>
+<%= function_name %>() {
+    local options="
+        <%- subcommand[:options].each do |option| -%>
+        <%- option[:names].each do |name| -%>
+        <%= name %>
+        <%- end -%>
+        <%- end -%>
+    "
+
+    case "$cur" in
+        -*)
+            COMPREPLY=($(compgen -W "$options" -- ${cur}))
+            ;;
+        *)
+            <%= subcommand[:completer] %>
+            ;;
+    esac
+}
+<%- end %>

data/lib/autoproj/templates/subcommand.zsh.erb

@@ -0,0 +1,51 @@
+<%- if subcommand[:subcommands].any? %>
+<%= function_name %>() {
+  readonly local DEPTH=<%= depth %>
+
+  case $CURRENT in
+    $DEPTH)
+      _arguments \
+        <%- subcommand[:options].each do |option| -%>
+        <%= escape_option_names(option[:names]) %><%= quote(bracket(option[:description])) if option[:description] %> \
+        <%- end -%>
+        '*: :->subcommands'
+
+      case $state in
+        subcommands)
+          _values \
+            'subcommand' \
+            <%- subcommand[:subcommands].each do |subcommand| -%>
+            <%= quote(subcommand[:name] + bracket(subcommand[:description])) %> \
+            <%- subcommand[:aliases].each do |_alias| -%>
+            <%= quote(_alias + bracket(subcommand[:description])) %> \
+            <%- end -%>
+            <%- end -%>
+            ;
+          ;;
+      esac
+      ;;
+    *)
+      case $words[$DEPTH] in
+        <%- subcommand[:subcommands].each do |subcommand| -%>
+        <%= subcommand[:name] %>)
+          <%= function_name %>_<%= subcommand[:name] %>
+          ;;
+        <%- subcommand[:aliases].each do |_alias| -%>
+        <%= _alias %>)
+          <%= function_name %>_<%= subcommand[:name] %>
+          ;;
+        <%- end -%>
+        <%- end -%>
+      esac
+      ;;
+  esac
+}
+<%- else %>
+<%= function_name %>() {
+  _arguments \
+    <%- subcommand[:options].each do |option| -%>
+    <%= escape_option_names(option[:names]) %><%= quote(bracket(option[:description])) if option[:description] %> \
+    <%- end -%>
+    '*:arg:<%= subcommand[:completer] -%>'
+}
+<%- end %>

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "2.7.1"
+    VERSION = "2.8.0"
 end

data/lib/autoproj/workspace.rb

@@ -1,7 +1,18 @@
+require 'autoproj/ops/loader'
+require 'xdg'
+
 module Autoproj
     class Workspace < Ops::Loader
+        # The workspace root as a string
+        #
+        # New code should prefer {#root_path}
         attr_reader :root_dir
 
+        # The workspace root
+        #
+        # This should be used rather than {#root_dir} in new code
+        attr_reader :root_path
+
         attr_accessor :config
         attr_reader :env
 
@@ -42,6 +53,7 @@ def initialize(root_dir,
                        os_package_resolver: OSPackageResolver.new,
                        package_managers: OSPackageInstaller::PACKAGE_MANAGERS)
             @root_dir = root_dir
+            @root_path = Pathname.new(root_dir)
             @ruby_version_keyword = "ruby#{RUBY_VERSION.split('.')[0, 2].join("")}"
             @osdep_suffixes = Array.new
 
@@ -286,6 +298,7 @@ def setup
             setup_ruby_version_handling
             migrate_bundler_and_autoproj_gem_layout
             load_config
+            register_workspace
             rewrite_shims
             autodetect_operating_system
             config.validate_ruby_executable
@@ -347,7 +360,8 @@ def install_ruby_shims
         def rewrite_shims
             gemfile  = File.join(dot_autoproj_dir, 'Gemfile')
             binstubs = File.join(dot_autoproj_dir, 'bin')
-            Ops::Install.rewrite_shims(binstubs, config.ruby_executable, root_dir, gemfile, config.gems_gem_home)
+            Ops::Install.rewrite_shims(binstubs, config.ruby_executable,
+                root_dir, gemfile, config.gems_gem_home)
         end
 
         def update_bundler
@@ -435,7 +449,7 @@ def set_as_main_workspace
             if block_given?
                 begin
                     yield
-                ensure 
+                ensure
                     clear_main_workspace
                 end
             end
@@ -457,24 +471,89 @@ def load_main_initrb
             load_if_present(local_source, config_dir, "init.rb")
         end
 
+        def self.find_path(xdg_var, xdg_path, home_path)
+            home_dir = begin Dir.home
+                       rescue ArgumentError
+                           return
+                       end
+
+            xdg_path  = File.join(XDG[xdg_var].to_path, 'autoproj', xdg_path)
+            home_path = File.join(home_dir, home_path)
+
+            if File.exist?(xdg_path)
+                xdg_path
+            elsif File.exist?(home_path)
+                home_path
+            else
+                xdg_path
+            end
+        end
+
+        def self.find_user_config_path(xdg_path, home_path = xdg_path)
+            find_path('CONFIG_HOME', xdg_path, home_path)
+        end
+
+        def self.rcfile_path
+            find_user_config_path('rc', '.autoprojrc')
+        end
+
+        def self.find_user_data_path(xdg_path, home_path = xdg_path)
+            find_path('DATA_HOME', xdg_path, File.join('.autoproj', home_path))
+        end
+
+        def self.find_user_cache_path(xdg_path, home_path = xdg_path)
+            find_path('CACHE_HOME', xdg_path, File.join('.autoproj', home_path))
+        end
+
+        RegisteredWorkspace = Struct.new :root_dir, :prefix_dir, :build_dir
+
+        def self.registered_workspaces
+            path = find_user_data_path('workspaces.yml')
+            if File.file?(path)
+                yaml = (YAML.load(File.read(path)) || [])
+                fields = RegisteredWorkspace.members.map(&:to_s)
+                yaml.map do |h|
+                    values = h.values_at(*fields)
+                    RegisteredWorkspace.new(*values)
+                end.compact
+            else
+                []
+            end
+        end
+
+        def self.save_registered_workspaces(workspaces)
+            workspaces = workspaces.map do |w|
+                Hash['root_dir' => w.root_dir,
+                     'prefix_dir' => w.prefix_dir,
+                     'build_dir' => w.build_dir]
+            end
+
+            path = find_user_data_path('workspaces.yml')
+            FileUtils.mkdir_p(File.dirname(path))
+            Ops.atomic_write(path) do |io|
+                io.write YAML.dump(workspaces)
+            end
+        end
+
+        def register_workspace
+            current_workspaces = Workspace.registered_workspaces
+            existing = current_workspaces.find { |w| w.root_dir == root_dir }
+            if existing
+                existing.prefix_dir = prefix_dir
+                existing.build_dir  = build_dir
+            else
+                current_workspaces << self
+            end
+            Workspace.save_registered_workspaces(current_workspaces)
+        end
+
         # Loads the .autoprojrc file
         #
         # This is included in {setup}
         def load_autoprojrc
             set_as_main_workspace
-
-            # Load the user-wide autoproj RC file
-            home_dir =
-                begin Dir.home
-                rescue ArgumentError
-                end
-
-            if home_dir
-                rcfile = File.join(home_dir, '.autoprojrc')
-                if File.file?(rcfile)
-                    Kernel.load rcfile
-                end
-            end
+            rcfile = Workspace.rcfile_path
+            Kernel.load(rcfile) if File.file?(rcfile)
         end
 
         def load_package_sets(only_local: false,
@@ -507,7 +586,7 @@ def load_packages(selection = manifest.default_packages(false), options = Hash.n
         def load_all_available_package_manifests
             manifest.load_all_available_package_manifests
         end
-        
+
         def setup_all_package_directories
             # Override the package directories from our reused installations
             imported_packages = Set.new
@@ -561,7 +640,7 @@ def setup_package_directories(pkg)
             pkg.doc_target_dir = File.join(prefix_dir, 'doc', pkg_name)
             pkg.logdir = File.join(pkg.prefix, "log")
         end
-        
+
         def compute_builddir(pkg)
             # If we're given an absolute build dir, we have to append the
             # package name to it to make it unique
@@ -735,7 +814,7 @@ def register_package(package, block = nil, package_set = manifest.main_package_s
         # `cmd` is not executable. Otherwise, looks for an executable named
         # `cmd` in PATH and returns it, or raises if it cannot be found. The
         # exception contains a more detailed reason for failure
-        # 
+        #
         #
         # @param [String] cmd
         # @return [String] the resolved program
@@ -761,4 +840,3 @@ def self.env
         workspace.env
     end
 end
-