Support completion for fish

[sayboras]

Fixes #2996

Testing

Bash completion script

$ fluxctl completion bash
# bash completion for completion                           -*- shell-script -*-

__completion_debug()
{
    if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
        echo "$*" >> "${BASH_COMP_DEBUG_FILE}"
    fi
}

# Homebrew on Macs have version 1.3 of bash-completion which doesn't include
# _init_completion. This is a very minimal version of that function.
__completion_init_completion()
{
    COMPREPLY=()
    _get_comp_words_by_ref "$@" cur prev words cword
}

__completion_index_of_word()
{
    local w word=$1
    shift
    index=0
    for w in "$@"; do
        [[ $w = "$word" ]] && return
        index=$((index+1))
    done
    index=-1
}

__completion_contains_word()
{
    local w word=$1; shift
    for w in "$@"; do
        [[ $w = "$word" ]] && return
    done
    return 1
}

__completion_handle_go_custom_completion()
{
    __completion_debug "${FUNCNAME[0]}: cur is ${cur}, words[*] is ${words[*]}, #words[@] is ${#words[@]}"

    local out requestComp lastParam lastChar comp directive args

    # Prepare the command to request completions for the program.
    # Calling ${words[0]} instead of directly completion allows to handle aliases
    args=("${words[@]:1}")
    requestComp="${words[0]} __completeNoDesc ${args[*]}"

    lastParam=${words[$((${#words[@]}-1))]}
    lastChar=${lastParam:$((${#lastParam}-1)):1}
    __completion_debug "${FUNCNAME[0]}: lastParam ${lastParam}, lastChar ${lastChar}"

    if [ -z "${cur}" ] && [ "${lastChar}" != "=" ]; then
        # If the last parameter is complete (there is a space following it)
        # We add an extra empty parameter so we can indicate this to the go method.
        __completion_debug "${FUNCNAME[0]}: Adding extra empty parameter"
        requestComp="${requestComp} \"\""
    fi

    __completion_debug "${FUNCNAME[0]}: calling ${requestComp}"
    # Use eval to handle any environment variables and such
    out=$(eval "${requestComp}" 2>/dev/null)

    # Extract the directive integer at the very end of the output following a colon (:)
    directive=${out##*:}
    # Remove the directive
    out=${out%:*}
    if [ "${directive}" = "${out}" ]; then
        # There is not directive specified
        directive=0
    fi
    __completion_debug "${FUNCNAME[0]}: the completion directive is: ${directive}"
    __completion_debug "${FUNCNAME[0]}: the completions are: ${out[*]}"

    if [ $((directive & 1)) -ne 0 ]; then
        # Error code.  No completion.
        __completion_debug "${FUNCNAME[0]}: received error from custom completion go code"
        return
    else
        if [ $((directive & 2)) -ne 0 ]; then
            if [[ $(type -t compopt) = "builtin" ]]; then
                __completion_debug "${FUNCNAME[0]}: activating no space"
                compopt -o nospace
            fi
        fi
        if [ $((directive & 4)) -ne 0 ]; then
            if [[ $(type -t compopt) = "builtin" ]]; then
                __completion_debug "${FUNCNAME[0]}: activating no file completion"
                compopt +o default
            fi
        fi

        while IFS='' read -r comp; do
            COMPREPLY+=("$comp")
        done < <(compgen -W "${out[*]}" -- "$cur")
    fi
}

__completion_handle_reply()
{
    __completion_debug "${FUNCNAME[0]}"
    local comp
    case $cur in
        -*)
            if [[ $(type -t compopt) = "builtin" ]]; then
                compopt -o nospace
            fi
            local allflags
            if [ ${#must_have_one_flag[@]} -ne 0 ]; then
                allflags=("${must_have_one_flag[@]}")
            else
                allflags=("${flags[*]} ${two_word_flags[*]}")
            fi
            while IFS='' read -r comp; do
                COMPREPLY+=("$comp")
            done < <(compgen -W "${allflags[*]}" -- "$cur")
            if [[ $(type -t compopt) = "builtin" ]]; then
                [[ "${COMPREPLY[0]}" == *= ]] || compopt +o nospace
            fi

            # complete after --flag=abc
            if [[ $cur == *=* ]]; then
                if [[ $(type -t compopt) = "builtin" ]]; then
                    compopt +o nospace
                fi

                local index flag
                flag="${cur%=*}"
                __completion_index_of_word "${flag}" "${flags_with_completion[@]}"
                COMPREPLY=()
                if [[ ${index} -ge 0 ]]; then
                    PREFIX=""
                    cur="${cur#*=}"
                    ${flags_completion[${index}]}
                    if [ -n "${ZSH_VERSION}" ]; then
                        # zsh completion needs --flag= prefix
                        eval "COMPREPLY=( \"\${COMPREPLY[@]/#/${flag}=}\" )"
                    fi
                fi
            fi
            return 0;
            ;;
    esac

    # check if we are handling a flag with special work handling
    local index
    __completion_index_of_word "${prev}" "${flags_with_completion[@]}"
    if [[ ${index} -ge 0 ]]; then
        ${flags_completion[${index}]}
        return
    fi

    # we are parsing a flag and don't have a special handler, no completion
    if [[ ${cur} != "${words[cword]}" ]]; then
        return
    fi

    local completions
    completions=("${commands[@]}")
    if [[ ${#must_have_one_noun[@]} -ne 0 ]]; then
        completions=("${must_have_one_noun[@]}")
    elif [[ -n "${has_completion_function}" ]]; then
        # if a go completion function is provided, defer to that function
        completions=()
        __completion_handle_go_custom_completion
    fi
    if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then
        completions+=("${must_have_one_flag[@]}")
    fi
    while IFS='' read -r comp; do
        COMPREPLY+=("$comp")
    done < <(compgen -W "${completions[*]}" -- "$cur")

    if [[ ${#COMPREPLY[@]} -eq 0 && ${#noun_aliases[@]} -gt 0 && ${#must_have_one_noun[@]} -ne 0 ]]; then
        while IFS='' read -r comp; do
            COMPREPLY+=("$comp")
        done < <(compgen -W "${noun_aliases[*]}" -- "$cur")
    fi

    if [[ ${#COMPREPLY[@]} -eq 0 ]]; then
		if declare -F __completion_custom_func >/dev/null; then
			# try command name qualified custom func
			__completion_custom_func
		else
			# otherwise fall back to unqualified for compatibility
			declare -F __custom_func >/dev/null && __custom_func
		fi
    fi

    # available in bash-completion >= 2, not always present on macOS
    if declare -F __ltrim_colon_completions >/dev/null; then
        __ltrim_colon_completions "$cur"
    fi

    # If there is only 1 completion and it is a flag with an = it will be completed
    # but we don't want a space after the =
    if [[ "${#COMPREPLY[@]}" -eq "1" ]] && [[ $(type -t compopt) = "builtin" ]] && [[ "${COMPREPLY[0]}" == --*= ]]; then
       compopt -o nospace
    fi
}

# The arguments should be in the form "ext1|ext2|extn"
__completion_handle_filename_extension_flag()
{
    local ext="$1"
    _filedir "@(${ext})"
}

__completion_handle_subdirs_in_dir_flag()
{
    local dir="$1"
    pushd "${dir}" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1 || return
}

__completion_handle_flag()
{
    __completion_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"

    # if a command required a flag, and we found it, unset must_have_one_flag()
    local flagname=${words[c]}
    local flagvalue
    # if the word contained an =
    if [[ ${words[c]} == *"="* ]]; then
        flagvalue=${flagname#*=} # take in as flagvalue after the =
        flagname=${flagname%=*} # strip everything after the =
        flagname="${flagname}=" # but put the = back
    fi
    __completion_debug "${FUNCNAME[0]}: looking for ${flagname}"
    if __completion_contains_word "${flagname}" "${must_have_one_flag[@]}"; then
        must_have_one_flag=()
    fi

    # if you set a flag which only applies to this command, don't show subcommands
    if __completion_contains_word "${flagname}" "${local_nonpersistent_flags[@]}"; then
      commands=()
    fi

    # keep flag value with flagname as flaghash
    # flaghash variable is an associative array which is only supported in bash > 3.
    if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then
        if [ -n "${flagvalue}" ] ; then
            flaghash[${flagname}]=${flagvalue}
        elif [ -n "${words[ $((c+1)) ]}" ] ; then
            flaghash[${flagname}]=${words[ $((c+1)) ]}
        else
            flaghash[${flagname}]="true" # pad "true" for bool flag
        fi
    fi

    # skip the argument to a two word flag
    if [[ ${words[c]} != *"="* ]] && __completion_contains_word "${words[c]}" "${two_word_flags[@]}"; then
			  __completion_debug "${FUNCNAME[0]}: found a flag ${words[c]}, skip the next argument"
        c=$((c+1))
        # if we are looking for a flags value, don't show commands
        if [[ $c -eq $cword ]]; then
            commands=()
        fi
    fi

    c=$((c+1))

}

__completion_handle_noun()
{
    __completion_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"

    if __completion_contains_word "${words[c]}" "${must_have_one_noun[@]}"; then
        must_have_one_noun=()
    elif __completion_contains_word "${words[c]}" "${noun_aliases[@]}"; then
        must_have_one_noun=()
    fi

    nouns+=("${words[c]}")
    c=$((c+1))
}

__completion_handle_command()
{
    __completion_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"

    local next_command
    if [[ -n ${last_command} ]]; then
        next_command="_${last_command}_${words[c]//:/__}"
    else
        if [[ $c -eq 0 ]]; then
            next_command="_completion_root_command"
        else
            next_command="_${words[c]//:/__}"
        fi
    fi
    c=$((c+1))
    __completion_debug "${FUNCNAME[0]}: looking for ${next_command}"
    declare -F "$next_command" >/dev/null && $next_command
}

__completion_handle_word()
{
    if [[ $c -ge $cword ]]; then
        __completion_handle_reply
        return
    fi
    __completion_debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}"
    if [[ "${words[c]}" == -* ]]; then
        __completion_handle_flag
    elif __completion_contains_word "${words[c]}" "${commands[@]}"; then
        __completion_handle_command
    elif [[ $c -eq 0 ]]; then
        __completion_handle_command
    elif __completion_contains_word "${words[c]}" "${command_aliases[@]}"; then
        # aliashash variable is an associative array which is only supported in bash > 3.
        if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then
            words[c]=${aliashash[${words[c]}]}
            __completion_handle_command
        else
            __completion_handle_noun
        fi
    else
        __completion_handle_noun
    fi
    __completion_handle_word
}

_fluxctl_completion()
{
    last_command="fluxctl_completion"

    command_aliases=()

    commands=()

    flags=()
    two_word_flags=()
    local_nonpersistent_flags=()
    flags_with_completion=()
    flags_completion=()

    flags+=("--help")
    flags+=("-h")
    local_nonpersistent_flags+=("--help")
    flags+=("--context=")
    two_word_flags+=("--context")
    flags+=("--k8s-fwd-labels=")
    two_word_flags+=("--k8s-fwd-labels")
    flags+=("--k8s-fwd-ns=")
    two_word_flags+=("--k8s-fwd-ns")
    flags+=("--timeout=")
    two_word_flags+=("--timeout")
    flags+=("--token=")
    two_word_flags+=("--token")
    two_word_flags+=("-t")
    flags+=("--url=")
    two_word_flags+=("--url")
    two_word_flags+=("-u")

    must_have_one_flag=()
    must_have_one_noun=()
    must_have_one_noun+=("bash")
    must_have_one_noun+=("fish")
    must_have_one_noun+=("zsh")
    noun_aliases=()
}

__start_completion()
{
    local cur prev words cword
    declare -A flaghash 2>/dev/null || :
    declare -A aliashash 2>/dev/null || :
    if declare -F _init_completion >/dev/null 2>&1; then
        _init_completion -s || return
    else
        __completion_init_completion -n "=" || return
    fi

    local c=0
    local flags=()
    local two_word_flags=()
    local local_nonpersistent_flags=()
    local flags_with_completion=()
    local flags_completion=()
    local commands=("completion")
    local must_have_one_flag=()
    local must_have_one_noun=()
    local has_completion_function
    local last_command
    local nouns=()

    __completion_handle_word
}

if [[ $(type -t compopt) = "builtin" ]]; then
    complete -o default -F __start_completion completion
else
    complete -o default -o nospace -F __start_completion completion
fi

# ex: ts=4 sw=4 et filetype=sh

Zsh completion script

$ fluxctl completion zsh 
#compdef _fluxctl fluxctl


function _fluxctl {
  local -a commands

  _arguments -C \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:' \
    "1: :->cmnds" \
    "*::arg:->args"

  case $state in
  cmnds)
    commands=(
      "automate:Turn on automatic deployment for a workload."
      "completion:Output shell completion code for the specified shell (bash, zsh, or fish)"
      "deautomate:Turn off automatic deployment for a workload."
      "help:Help about any command"
      "identity:Display SSH public key"
      "install:Print and tweak Kubernetes manifests needed to install Flux in a Cluster"
      "list-images:Show deployed and available images."
      "list-workloads:List workloads currently running in the cluster."
      "lock:Lock a workload, so it cannot be deployed."
      "policy:Manage policies for a workload."
      "release:Release a new version of a workload."
      "save:save workload definitions to local files in cluster-native format"
      "sync:synchronize the cluster with the git repository, now"
      "unlock:Unlock a workload, so it can be deployed."
      "version:Output the version of fluxctl"
    )
    _describe "command" commands
    ;;
  esac

  case "$words[1]" in
  automate)
    _fluxctl_automate
    ;;
  completion)
    _fluxctl_completion
    ;;
  deautomate)
    _fluxctl_deautomate
    ;;
  help)
    _fluxctl_help
    ;;
  identity)
    _fluxctl_identity
    ;;
  install)
    _fluxctl_install
    ;;
  list-images)
    _fluxctl_list-images
    ;;
  list-workloads)
    _fluxctl_list-workloads
    ;;
  lock)
    _fluxctl_lock
    ;;
  policy)
    _fluxctl_policy
    ;;
  release)
    _fluxctl_release
    ;;
  save)
    _fluxctl_save
    ;;
  sync)
    _fluxctl_sync
    ;;
  unlock)
    _fluxctl_unlock
    ;;
  version)
    _fluxctl_version
    ;;
  esac
}

function _fluxctl_automate {
  _arguments \
    '(-m --message)'{-m,--message}'[attach a message to the update]:' \
    '(-n --namespace)'{-n,--namespace}'[Workload namespace]:' \
    '--user[override the user reported as initiating the update]:' \
    '(-v --verbose)'{-v,--verbose}'[include skipped (and ignored, with -vv) workloads in output]' \
    '(-w --workload)'{-w,--workload}'[Workload to automate]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_completion {
  _arguments \
    '(-h --help)'{-h,--help}'[help for completion]' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:' \
    '1: :("zsh" "fish" "bash")'
}

function _fluxctl_deautomate {
  _arguments \
    '(-m --message)'{-m,--message}'[attach a message to the update]:' \
    '(-n --namespace)'{-n,--namespace}'[Workload namespace]:' \
    '--user[override the user reported as initiating the update]:' \
    '(-v --verbose)'{-v,--verbose}'[include skipped (and ignored, with -vv) workloads in output]' \
    '(-w --workload)'{-w,--workload}'[Workload to deautomate]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_help {
  _arguments \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_identity {
  _arguments \
    '(-l --fingerprint)'{-l,--fingerprint}'[Show fingerprint of public key]' \
    '(-r --regenerate)'{-r,--regenerate}'[Generate a new identity]' \
    '(-v --visual)'{-v,--visual}'[Show ASCII art representation with fingerprint (implies -l)]' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_install {
  _arguments \
    '--add-security-context[Ensure security context information is added to the pod specs. Defaults to '\''true'\'']' \
    '--git-branch[Git branch to be used by Flux]:' \
    '--git-email[email to use as git committer]:' \
    '--git-label[Git label to keep track of Flux'\''s sync progress; overrides both --git-sync-tag and --git-notes-ref]:' \
    '*--git-path[relative paths within the Git repo for Flux to locate Kubernetes manifests]:' \
    '--git-readonly[tell flux it has readonly access to the repo]' \
    '--git-url[URL of the Git repository to be used by Flux, e.g. [email protected]:<your username>/flux-get-started]:' \
    '--git-user[username to use as git committer]:' \
    '--manifest-generation[whether to enable manifest generation]' \
    '--namespace[cluster namespace where to install flux]:' \
    '(-o --output-dir)'{-o,--output-dir}'[a directory in which to write individual manifests, rather than printing to stdout]:' \
    '--registry-disable-scanning[do not scan container image registries to fill in the registry cache]' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_list-images {
  _arguments \
    '(-l --limit)'{-l,--limit}'[Number of images to show (0 for all)]:' \
    '(-n --namespace)'{-n,--namespace}'[Namespace]:' \
    '--no-headers[Don'\''t print headers (default print headers)]' \
    '(-o --output-format)'{-o,--output-format}'[Output format (tab or json)]:' \
    '(-w --workload)'{-w,--workload}'[Show images for this workload]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_list-workloads {
  _arguments \
    '(-a --all-namespaces)'{-a,--all-namespaces}'[Query across all namespaces]' \
    '(-c --container)'{-c,--container}'[Filter workloads by container name]:' \
    '(-n --namespace)'{-n,--namespace}'[Confine query to namespace]:' \
    '--no-headers[Don'\''t print headers (default print headers)]' \
    '(-o --output-format)'{-o,--output-format}'[Output format (tab or json)]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_lock {
  _arguments \
    '(-m --message)'{-m,--message}'[attach a message to the update]:' \
    '(-n --namespace)'{-n,--namespace}'[Controller namespace]:' \
    '--user[override the user reported as initiating the update]:' \
    '(-v --verbose)'{-v,--verbose}'[include skipped (and ignored, with -vv) workloads in output]' \
    '(-w --workload)'{-w,--workload}'[Workload to lock]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_policy {
  _arguments \
    '--automate[Automate workload]' \
    '--deautomate[Deautomate workload]' \
    '--lock[Lock workload]' \
    '(-m --message)'{-m,--message}'[attach a message to the update]:' \
    '(-n --namespace)'{-n,--namespace}'[Workload namespace]:' \
    '*--tag[Tag filter container/pattern pairs]:' \
    '--tag-all[Tag filter pattern to apply to all containers]:' \
    '--unlock[Unlock workload]' \
    '--user[override the user reported as initiating the update]:' \
    '(-v --verbose)'{-v,--verbose}'[include skipped (and ignored, with -vv) workloads in output]' \
    '(-w --workload)'{-w,--workload}'[Workload to modify]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_release {
  _arguments \
    '--all[Release all workloads]' \
    '--dry-run[Do not release anything; just report back what would have been done]' \
    '*--exclude[List of workloads to exclude]:' \
    '(-f --force)'{-f,--force}'[Disregard locks and container image filters (has no effect when used with --all or --update-all-images)]' \
    '--interactive[Select interactively which containers to update]' \
    '(-m --message)'{-m,--message}'[attach a message to the update]:' \
    '(-n --namespace)'{-n,--namespace}'[Workload namespace]:' \
    '--update-all-images[Update all images to latest versions]' \
    '(-i --update-image)'{-i,--update-image}'[Update a specific image]:' \
    '--user[override the user reported as initiating the update]:' \
    '(-v --verbose)'{-v,--verbose}'[include skipped (and ignored, with -vv) workloads in output]' \
    '(-w --watch)'{-w,--watch}'[Watch rollout progress during release]' \
    '*--workload[List of workloads to release <namespace>:<kind>/<name>]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_save {
  _arguments \
    '(-o --out)'{-o,--out}'[Output path for exported config; the default. '\''-'\'' indicates stdout; if a directory is given, each item will be saved in a file under the directory]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_sync {
  _arguments \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_unlock {
  _arguments \
    '(-m --message)'{-m,--message}'[attach a message to the update]:' \
    '(-n --namespace)'{-n,--namespace}'[Controller namespace]:' \
    '--user[override the user reported as initiating the update]:' \
    '(-v --verbose)'{-v,--verbose}'[include skipped (and ignored, with -vv) workloads in output]' \
    '(-w --workload)'{-w,--workload}'[Controller to unlock]:' \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

function _fluxctl_version {
  _arguments \
    '--context[The kubeconfig context to use, will use your current selected if not specified]:' \
    '--k8s-fwd-labels[Labels used to select the fluxd pod a port forward should be created for. You can also set the environment variable FLUX_FORWARD_LABELS]:' \
    '--k8s-fwd-ns[Namespace in which fluxd is running, for creating a port forward to access the API. No port forward will be created if a URL or token is given. You can also set the environment variable FLUX_FORWARD_NAMESPACE]:' \
    '--timeout[Global command timeout; you can also set the environment variable FLUX_TIMEOUT]:' \
    '(-t --token)'{-t,--token}'[Weave Cloud authentication token; you can also set the environment variable WEAVE_CLOUD_TOKEN or FLUX_SERVICE_TOKEN]:' \
    '(-u --url)'{-u,--url}'[Base URL of the Flux API (defaults to "https://cloud.weave.works/api/flux" if a token is provided); you can also set the environment variable FLUX_URL]:'
}

fish completion script

$ fluxctl completion fish
# fish completion for completion                           -*- shell-script -*-

function __completion_debug
    set file "$BASH_COMP_DEBUG_FILE"
    if test -n "$file"
        echo "$argv" >> $file
    end
end

function __completion_perform_completion
    __completion_debug "Starting __completion_perform_completion with: $argv"

    set args (string split -- " " "$argv")
    set lastArg "$args[-1]"

    __completion_debug "args: $args"
    __completion_debug "last arg: $lastArg"

    set emptyArg ""
    if test -z "$lastArg"
        __completion_debug "Setting emptyArg"
        set emptyArg \"\"
    end
    __completion_debug "emptyArg: $emptyArg"

    set requestComp "$args[1] __complete $args[2..-1] $emptyArg"
    __completion_debug "Calling $requestComp"

    set results (eval $requestComp 2> /dev/null)
    set comps $results[1..-2]
    set directiveLine $results[-1]

    # For Fish, when completing a flag with an = (e.g., <program> -n=<TAB>)
    # completions must be prefixed with the flag
    set flagPrefix (string match -r -- '-.*=' "$lastArg")

    __completion_debug "Comps: $comps"
    __completion_debug "DirectiveLine: $directiveLine"
    __completion_debug "flagPrefix: $flagPrefix"

    for comp in $comps
        printf "%s%s\n" "$flagPrefix" "$comp"
    end

    printf "%s\n" "$directiveLine"
end

# This function does three things:
# 1- Obtain the completions and store them in the global __completion_comp_results
# 2- Set the __completion_comp_do_file_comp flag if file completion should be performed
#    and unset it otherwise
# 3- Return true if the completion results are not empty
function __completion_prepare_completions
    # Start fresh
    set --erase __completion_comp_do_file_comp
    set --erase __completion_comp_results

    # Check if the command-line is already provided.  This is useful for testing.
    if not set --query __completion_comp_commandLine
        set __completion_comp_commandLine (commandline)
    end
    __completion_debug "commandLine is: $__completion_comp_commandLine"

    set results (__completion_perform_completion "$__completion_comp_commandLine")
    set --erase __completion_comp_commandLine
    __completion_debug "Completion results: $results"

    if test -z "$results"
        __completion_debug "No completion, probably due to a failure"
        # Might as well do file completion, in case it helps
        set --global __completion_comp_do_file_comp 1
        return 0
    end

    set directive (string sub --start 2 $results[-1])
    set --global __completion_comp_results $results[1..-2]

    __completion_debug "Completions are: $__completion_comp_results"
    __completion_debug "Directive is: $directive"

    if test -z "$directive"
        set directive 0
    end

    set compErr (math (math --scale 0 $directive / 1) % 2)
    if test $compErr -eq 1
        __completion_debug "Received error directive: aborting."
        # Might as well do file completion, in case it helps
        set --global __completion_comp_do_file_comp 1
        return 0
    end

    set nospace (math (math --scale 0 $directive / 2) % 2)
    set nofiles (math (math --scale 0 $directive / 4) % 2)

    __completion_debug "nospace: $nospace, nofiles: $nofiles"

    # Important not to quote the variable for count to work
    set numComps (count $__completion_comp_results)
    __completion_debug "numComps: $numComps"

    if test $numComps -eq 1; and test $nospace -ne 0
        # To support the "nospace" directive we trick the shell
        # by outputting an extra, longer completion.
        __completion_debug "Adding second completion to perform nospace directive"
        set --append __completion_comp_results $__completion_comp_results[1].
    end

    if test $numComps -eq 0; and test $nofiles -eq 0
        __completion_debug "Requesting file completion"
        set --global __completion_comp_do_file_comp 1
    end

    # If we don't want file completion, we must return true even if there
    # are no completions found.  This is because fish will perform the last
    # completion command, even if its condition is false, if no other
    # completion command was triggered
    return (not set --query __completion_comp_do_file_comp)
end

# Remove any pre-existing completions for the program since we will be handling all of them
# TODO this cleanup is not sufficient.  Fish completions are only loaded once the user triggers
# them, so the below deletion will not work as it is run too early.  What else can we do?
complete -c completion -e

# The order in which the below two lines are defined is very important so that __completion_prepare_completions
# is called first.  It is __completion_prepare_completions that sets up the __completion_comp_do_file_comp variable.
#
# This completion will be run second as complete commands are added FILO.
# It triggers file completion choices when __completion_comp_do_file_comp is set.
complete -c completion -n 'set --query __completion_comp_do_file_comp'

# This completion will be run first as complete commands are added FILO.
# The call to __completion_prepare_completions will setup both __completion_comp_results abd __completion_comp_do_file_comp.
# It provides the program's completion choices.
complete -c completion -n '__completion_prepare_completions' -f -a '$__completion_comp_results'

[stefanprodan]

LGTM

Thanks @sayboras can you please rebase with master.

[sayboras]

@stefanprodan rebased done, thanks for your review