From 3b03fe6864afa7c6ff2d977e9fda7bd77c39f1fc Mon Sep 17 00:00:00 2001 From: chrislovecnm Date: Sat, 22 Apr 2017 11:55:51 -0600 Subject: [PATCH] zsh autocompletion and updating docs --- cmd/kops/completion.go | 219 +++++++++++++++++++++++++++++++++--- docs/cli/kops_completion.md | 48 +++++++- 2 files changed, 247 insertions(+), 20 deletions(-) diff --git a/cmd/kops/completion.go b/cmd/kops/completion.go index 40bf648d64f6e..061a61ec514b5 100644 --- a/cmd/kops/completion.go +++ b/cmd/kops/completion.go @@ -20,6 +20,7 @@ import ( "fmt" "io" + "bytes" "github.com/spf13/cobra" "k8s.io/kops/cmd/kops/util" ) @@ -40,19 +41,61 @@ const boilerPlate = ` # limitations under the License. ` +var ( + completion_shells = map[string]func(out io.Writer, cmd *cobra.Command) error{ + "bash": runCompletionBash, + "zsh": runCompletionZsh, + } +) + type CompletionOptions struct { Shell string } var ( - longDescription = `Output shell completion code for the given shell (bash). + longDescription = ` + +Output shell completion code for the specified shell (bash or zsh). +The shell code must be evalutated to provide interactive +completion of kops commands. This can be done by sourcing it from +the .bash_profile. -This command prints shell code which must be evaluation to provide interactive -completion of kops commands.` +Note: this requires the bash-completion framework, which is not installed +by default on Mac. This can be installed by using homebrew: + $ brew install bash-completion + +Once installed, bash_completion must be evaluated. This can be done by adding the +following line to the .bash_profile + + $ source $(brew --prefix)/etc/bash_completion + +Note for zsh users: [1] zsh completions are only supported in versions of zsh >= 5.2` example = ` -# load in the kops completion code for bash (depends on the bash-completion framework). -source <(kops completion bash)` + +# Install bash completion on a Mac using homebrew + +$ brew install bash-completion + +$ printf " +# Bash completion support +source $(brew --prefix)/etc/bash_completion +" >> $HOME/.bash_profile + source $HOME/.bash_profile + # Load the kops completion code for bash into the current shell + source <(kops completion bash) + # Write bash completion code to a file and source if from .bash_profile + kops completion bash > ~/.kops/completion.bash.inc + printf " + +# kops shell completion +'$HOME/.kops/completion.bash.inc' +" >> $HOME/.bash_profile + +$ source $HOME/.bash_profile + +# Load the kops completion code for zsh[1] into the current shell +source <(kops completion zsh)` ) func NewCmdCompletion(f *util.Factory, out io.Writer) *cobra.Command { @@ -60,7 +103,7 @@ func NewCmdCompletion(f *util.Factory, out io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "completion", - Short: "Output shell completion code for the given shell (bash).", + Short: "Output shell completion code for the given shell (bash or zsh).", Long: longDescription, Example: example, Run: func(cmd *cobra.Command, args []string) { @@ -78,6 +121,7 @@ func NewCmdCompletion(f *util.Factory, out io.Writer) *cobra.Command { func RunCompletion(f *util.Factory, cmd *cobra.Command, args []string, out io.Writer, c *CompletionOptions) error { if len(args) != 0 { + if c.Shell != "" { return fmt.Errorf("cannot specify shell both as a flag and a positional argument") } @@ -88,19 +132,166 @@ func RunCompletion(f *util.Factory, cmd *cobra.Command, args []string, out io.Wr return fmt.Errorf("shell is required") } - if c.Shell != "bash" { - return fmt.Errorf("only bash shell is supported for kops completion") + run, found := completion_shells[args[0]] + if !found { + return fmt.Errorf("Unsupported shell type %q.", args[0]) } - _, err := out.Write([]byte(boilerPlate)) - if err != nil { + if _, err := out.Write([]byte(boilerPlate)); err != nil { return err } - err = rootCommand.cobraCommand.GenBashCompletion(out) - if err != nil { - return err - } + return run(out, cmd.Parent()) +} + +func runCompletionBash(out io.Writer, cmd *cobra.Command) error { + return cmd.GenBashCompletion(out) +} +func runCompletionZsh(out io.Writer, cmd *cobra.Command) error { + zsh_initialization := ` +__kops_bash_source() { + alias shopt=':' + alias _expand=_bash_expand + alias _complete=_bash_comp + emulate -L sh + setopt kshglob noshglob braceexpand + source "$@" +} +__kops_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" = "__kops_compopt" ]; then + echo builtin + return 0 + fi + fi + type "$@" +} +__kops_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 +} +__kops_compopt() { + true # don't do anything. Not supported by bashcompinit in zsh +} +__kops_declare() { + if [ "$1" == "-F" ]; then + whence -w "$@" + else + builtin declare "$@" + fi +} +__kops_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 +} +__kops_get_comp_words_by_ref() { + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[${COMP_CWORD}-1]}" + words=("${COMP_WORDS[@]}") + cword=("${COMP_CWORD[@]}") +} +__kops_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="$(__kops_quote "${w}")" + if [ -d "${w}" ]; then + COMPREPLY+=("${qw}/") + else + COMPREPLY+=("${qw}") + fi + fi + done +} +__kops_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 +__kops_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}/__kops_filedir/g" \ + -e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__kops_get_comp_words_by_ref/g" \ + -e "s/${LWORD}__ltrim_colon_completions${RWORD}/__kops_ltrim_colon_completions/g" \ + -e "s/${LWORD}compgen${RWORD}/__kops_compgen/g" \ + -e "s/${LWORD}compopt${RWORD}/__kops_compopt/g" \ + -e "s/${LWORD}declare${RWORD}/__kops_declare/g" \ + -e "s/\\\$(type${RWORD}/\$(__kops_type/g" \ + <<'BASH_COMPLETION_EOF' +` + out.Write([]byte(zsh_initialization)) + + buf := new(bytes.Buffer) + cmd.GenBashCompletion(buf) + out.Write(buf.Bytes()) + + zsh_tail := ` +BASH_COMPLETION_EOF +} +__kops_bash_source <(__kops_convert_bash_to_zsh) +` + out.Write([]byte(zsh_tail)) return nil } diff --git a/docs/cli/kops_completion.md b/docs/cli/kops_completion.md index bf5af1feb2272..d78c5cdafc814 100644 --- a/docs/cli/kops_completion.md +++ b/docs/cli/kops_completion.md @@ -1,14 +1,28 @@ ## kops completion -Output shell completion code for the given shell (bash) +Output shell completion code for the given shell (bash or zsh). ### Synopsis -Output shell completion code for the given shell (bash). -This command prints shell code which must be evaluation to provide interactive -completion of kops commands. + +Output shell completion code for the specified shell (bash or zsh). +The shell code must be evalutated to provide interactive +completion of kops commands. This can be done by sourcing it from +the .bash_profile. + +Note: this requires the bash-completion framework, which is not installed +by default on Mac. This can be installed by using homebrew: + + $ brew install bash-completion + +Once installed, bash_completion must be evaluated. This can be done by adding the +following line to the .bash_profile + + $ source $(brew --prefix)/etc/bash_completion + +Note for zsh users: [1] zsh completions are only supported in versions of zsh >= 5.2 ``` kops completion @@ -18,8 +32,30 @@ kops completion ``` -# load in the kops completion code for bash (depends on the bash-completion framework). -source <(kops completion bash) + +# Install bash completion on a Mac using homebrew + +$ brew install bash-completion + +$ printf " +# Bash completion support +source $(brew --prefix)/etc/bash_completion +" >> $HOME/.bash_profile + source $HOME/.bash_profile + # Load the kops completion code for bash into the current shell + source <(kops completion bash) + # Write bash completion code to a file and source if from .bash_profile + kops completion bash > ~/.kops/completion.bash.inc + printf " + +# kops shell completion +'$HOME/.kops/completion.bash.inc' +" >> $HOME/.bash_profile + +$ source $HOME/.bash_profile + +# Load the kops completion code for zsh[1] into the current shell +source <(kops completion zsh) ``` ### Options