From 97edb745c94a2bc4456dea5510ee153db45ab636 Mon Sep 17 00:00:00 2001 From: Quentin Nerden Date: Tue, 14 Nov 2017 22:30:42 +0100 Subject: [PATCH] Add zsh completion and docs --- cmd/minikube/cmd/completion.go | 199 +++++++++++++++++++++++++++++++-- 1 file changed, 189 insertions(+), 10 deletions(-) diff --git a/cmd/minikube/cmd/completion.go b/cmd/minikube/cmd/completion.go index 10905003eef0..4b2bd715c632 100644 --- a/cmd/minikube/cmd/completion.go +++ b/cmd/minikube/cmd/completion.go @@ -17,6 +17,7 @@ limitations under the License. package cmd import ( + "bytes" "fmt" "io" "os" @@ -27,20 +28,24 @@ import ( ) const longDescription = ` - Outputs minikube shell completion for the given shell (bash) + Outputs minikube shell completion for the given shell (bash or zsh) This depends on the bash-completion binary. Example installation instructions: OS X: $ brew install bash-completion $ source $(brew --prefix)/etc/bash_completion - $ minikube completion bash > ~/.minikube-completion + $ minikube completion bash > ~/.minikube-completion # for bash users + $ minikube completion zsh > ~/.minikube-completion # for zsh users $ source ~/.minikube-completion Ubuntu: $ apt-get install bash-completion $ source /etc/bash-completion - $ source <(minikube completion bash) + $ source <(minikube completion bash) # for bash users + $ source <(minikube completion bash) # for zsh users Additionally, you may want to output the completion to a file and source in your .bashrc + + Note for zsh users: [1] zsh completions are only supported in versions of zsh >= 5.2 ` const boilerPlate = ` @@ -61,21 +66,28 @@ const boilerPlate = ` var completionCmd = &cobra.Command{ Use: "completion SHELL", - Short: "Outputs minikube shell completion for the given shell (bash)", + Short: "Outputs minikube shell completion for the given shell (bash or zsh)", Long: longDescription, Run: func(cmd *cobra.Command, args []string) { if len(args) != 1 { fmt.Println("Usage: minikube completion SHELL") os.Exit(1) } - if args[0] != "bash" { - fmt.Println("Only bash is supported for minikube completion") + if args[0] != "bash" && args[0] != "zsh" { + fmt.Println("Only bash and zsh are supported for minikube completion") os.Exit(1) + } else if args[0] == "bash" { + err := GenerateBashCompletion(os.Stdout, cmd.Parent()) + if err != nil { + cmdutil.MaybeReportErrorAndExit(err) + } + } else { + err := GenerateZshCompletion(os.Stdout, cmd.Parent()) + if err != nil { + cmdutil.MaybeReportErrorAndExit(err) + } } - err := GenerateBashCompletion(os.Stdout, cmd.Parent()) - if err != nil { - cmdutil.MaybeReportErrorAndExit(err) - } + }, } @@ -93,6 +105,173 @@ func GenerateBashCompletion(w io.Writer, cmd *cobra.Command) error { return nil } +func GenerateZshCompletion(out io.Writer, cmd *cobra.Command) error { + zsh_initialization := ` +__minikube_bash_source() { + alias shopt=':' + alias _expand=_bash_expand + alias _complete=_bash_comp + emulate -L sh + setopt kshglob noshglob braceexpand + source "$@" +} +__minikube_type() { + # -t is not supported by zsh + if [ "$1" == "-t" ]; then + shift + # fake Bash 4 to disable "complete -o nospace". Instead + # "compopt +-o nospace" is used in the code to toggle trailing + # spaces. We don't support that, but leave trailing spaces on + # all the time + if [ "$1" = "__minikube_compopt" ]; then + echo builtin + return 0 + fi + fi + type "$@" +} +__minikube_compgen() { + local completions w + completions=( $(compgen "$@") ) || return $? + # filter by given word as prefix + while [[ "$1" = -* && "$1" != -- ]]; do + shift + shift + done + if [[ "$1" == -- ]]; then + shift + fi + for w in "${completions[@]}"; do + if [[ "${w}" = "$1"* ]]; then + echo "${w}" + fi + done +} +__minikube_compopt() { + true # don't do anything. Not supported by bashcompinit in zsh +} +__minikube_declare() { + if [ "$1" == "-F" ]; then + whence -w "$@" + else + builtin declare "$@" + fi +} +__minikube_ltrim_colon_completions() +{ + if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then + # Remove colon-word prefix from COMPREPLY items + local colon_word=${1%${1##*:}} + local i=${#COMPREPLY[*]} + while [[ $((--i)) -ge 0 ]]; do + COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"} + done + fi +} +__minikube_get_comp_words_by_ref() { + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[${COMP_CWORD}-1]}" + words=("${COMP_WORDS[@]}") + cword=("${COMP_CWORD[@]}") +} +__minikube_filedir() { + local RET OLD_IFS w qw + __debug "_filedir $@ cur=$cur" + if [[ "$1" = \~* ]]; then + # somehow does not work. Maybe, zsh does not call this at all + eval echo "$1" + return 0 + fi + OLD_IFS="$IFS" + IFS=$'\n' + if [ "$1" = "-d" ]; then + shift + RET=( $(compgen -d) ) + else + RET=( $(compgen -f) ) + fi + IFS="$OLD_IFS" + IFS="," __debug "RET=${RET[@]} len=${#RET[@]}" + for w in ${RET[@]}; do + if [[ ! "${w}" = "${cur}"* ]]; then + continue + fi + if eval "[[ \"\${w}\" = *.$1 || -d \"\${w}\" ]]"; then + qw="$(__minikube_quote "${w}")" + if [ -d "${w}" ]; then + COMPREPLY+=("${qw}/") + else + COMPREPLY+=("${qw}") + fi + fi + done +} +__minikube_quote() { + if [[ $1 == \'* || $1 == \"* ]]; then + # Leave out first character + printf %q "${1:1}" + else + printf %q "$1" + fi +} +autoload -U +X bashcompinit && bashcompinit +# use word boundary patterns for BSD or GNU sed +LWORD='[[:<:]]' +RWORD='[[:>:]]' +if sed --help 2>&1 | grep -q GNU; then + LWORD='\<' + RWORD='\>' +fi +__minikube_convert_bash_to_zsh() { + sed \ + -e 's/declare -F/whence -w/' \ + -e 's/_get_comp_words_by_ref "\$@"/_get_comp_words_by_ref "\$*"/' \ + -e 's/local \([a-zA-Z0-9_]*\)=/local \1; \1=/' \ + -e 's/flags+=("\(--.*\)=")/flags+=("\1"); two_word_flags+=("\1")/' \ + -e 's/must_have_one_flag+=("\(--.*\)=")/must_have_one_flag+=("\1")/' \ + -e "s/${LWORD}_filedir${RWORD}/__minikube_filedir/g" \ + -e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__minikube_get_comp_words_by_ref/g" \ + -e "s/${LWORD}__ltrim_colon_completions${RWORD}/__minikube_ltrim_colon_completions/g" \ + -e "s/${LWORD}compgen${RWORD}/__minikube_compgen/g" \ + -e "s/${LWORD}compopt${RWORD}/__minikube_compopt/g" \ + -e "s/${LWORD}declare${RWORD}/__minikube_declare/g" \ + -e "s/\\\$(type${RWORD}/\$(__minikube_type/g" \ + <<'BASH_COMPLETION_EOF' +` + + _, err := out.Write([]byte(boilerPlate)) + if err != nil { + return err + } + + _, err = out.Write([]byte(zsh_initialization)) + if err != nil { + return err + } + + buf := new(bytes.Buffer) + err = cmd.GenBashCompletion(buf) + if err != nil { + return errors.Wrap(err, "Error generating zsh completion") + } + _, err = out.Write(buf.Bytes()) + if err != nil { + return err + } + + zsh_tail := ` +BASH_COMPLETION_EOF +} +__minikube_bash_source <(__minikube_convert_bash_to_zsh) +` + _, err = out.Write([]byte(zsh_tail)) + if err != nil { + return err + } + + return nil +} + func init() { RootCmd.AddCommand(completionCmd) }