From bb0a94132d0a4873014a0ed5bb4ac91dfb13ccd4 Mon Sep 17 00:00:00 2001 From: knrt10 Date: Fri, 28 Aug 2020 17:37:59 +0530 Subject: [PATCH] Add autocomplete for bash and zsh for lokoctl Fixes #18 Signed-off-by: knrt10 --- cli/cmd/completion.go | 257 ++++++++++++++++++ .../helm.sh/helm/v3/cmd/helm/require/args.go | 88 ++++++ vendor/modules.txt | 1 + 3 files changed, 346 insertions(+) create mode 100644 cli/cmd/completion.go create mode 100644 vendor/helm.sh/helm/v3/cmd/helm/require/args.go diff --git a/cli/cmd/completion.go b/cli/cmd/completion.go new file mode 100644 index 000000000..2184c6a59 --- /dev/null +++ b/cli/cmd/completion.go @@ -0,0 +1,257 @@ +// Copyright 2020 The Lokomotive Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cmd + +import ( + "io" + "os" + + "github.com/spf13/cobra" + "helm.sh/helm/v3/cmd/helm/require" +) + +const completionDesc = ` +Generate autocompletions script for Lokoctl for the specified shell (bash or zsh). +` + +const bashCompDesc = ` +Generate the autocompletion script for Lokoctl for the bash shell. + +To load completions in your current shell session: +$ source <(lokoctl completion bash) + +To load completions for every new session, execute once: +Linux: + $ lokoctl completion bash > /etc/bash_completion.d/lokoctl && exec $SHELL +MacOS: + $ lokoctl completion bash > /usr/local/etc/bash_completion.d/lokoctl && exec $SHELL +` + +const zshCompDesc = ` +Generate the autocompletion script for Lokoctl for the zsh shell. + +To load completions in your current shell session: +$ source <(lokoctl completion zsh) + +To load completions for every new session, execute once: +$ lokoctl completion zsh > "${fpath[1]}/_lokoctl" && exec $SHELL +` + +func newCompletionCmd(out io.Writer) *cobra.Command { + cmd := &cobra.Command{ + Use: "completion", + Short: "generate autocompletions script for the specified shell", + Long: completionDesc, + Args: require.NoArgs, + ValidArgsFunction: noCompletions, // Disable file completion + } + + bash := &cobra.Command{ + Use: "bash", + Short: "generate autocompletions script for bash", + Long: bashCompDesc, + Args: require.NoArgs, + DisableFlagsInUseLine: true, + ValidArgsFunction: noCompletions, + RunE: func(cmd *cobra.Command, args []string) error { + return runCompletionBash(out, cmd) + }, + } + + zsh := &cobra.Command{ + Use: "zsh", + Short: "generate autocompletions script for zsh", + Long: zshCompDesc, + Args: require.NoArgs, + DisableFlagsInUseLine: true, + ValidArgsFunction: noCompletions, + RunE: func(cmd *cobra.Command, args []string) error { + return runCompletionZsh(out, cmd) + }, + } + + cmd.AddCommand(bash, zsh) + + return cmd +} + +func runCompletionBash(out io.Writer, cmd *cobra.Command) error { + return cmd.Root().GenBashCompletion(out) +} + +func runCompletionZsh(out io.Writer, cmd *cobra.Command) error { //nolint:funlen + zshInitialization := `#compdef lokoctl +__lokoctl_bash_source() { + alias shopt=':' + alias _expand=_bash_expand + alias _complete=_bash_comp + emulate -L sh + setopt kshglob noshglob braceexpand + source "$@" +} +__lokoctl_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" = "__lokoctl_compopt" ]; then + echo builtin + return 0 + fi + fi + type "$@" +} +__lokoctl_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 + # Use printf instead of echo beause it is possible that + # the value to print is -n, which would be interpreted + # as a flag to echo + printf "%s\n" "${w}" + fi + done +} +__lokoctl_compopt() { + true # don't do anything. Not supported by bashcompinit in zsh +} +__lokoctl_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 +} +__lokoctl_get_comp_words_by_ref() { + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[${COMP_CWORD}-1]}" + words=("${COMP_WORDS[@]}") + cword=("${COMP_CWORD[@]}") +} +__lokoctl_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="$(__lokoctl_quote "${w}")" + if [ -d "${w}" ]; then + COMPREPLY+=("${qw}/") + else + COMPREPLY+=("${qw}") + fi + fi + done +} +__lokoctl_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\|BusyBox'; then + LWORD='\<' + RWORD='\>' +fi +__lokoctl_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}/__lokoctl_filedir/g" \ + -e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__lokoctl_get_comp_words_by_ref/g" \ + -e "s/${LWORD}__ltrim_colon_completions${RWORD}/__lokoctl_ltrim_colon_completions/g" \ + -e "s/${LWORD}compgen${RWORD}/__lokoctl_compgen/g" \ + -e "s/${LWORD}compopt${RWORD}/__lokoctl_compopt/g" \ + -e "s/${LWORD}declare${RWORD}/builtin declare/g" \ + -e "s/\\\$(type${RWORD}/\$(__lokoctl_type/g" \ + -e 's/aliashash\["\(.\{1,\}\)"\]/aliashash[\1]/g' \ + -e 's/FUNCNAME/funcstack/g' \ + <<'BASH_COMPLETION_EOF' +` + + _, err := out.Write([]byte(zshInitialization)) + if err != nil { + return err + } + + err = runCompletionBash(out, cmd) + if err != nil { + return err + } + + zshTail := ` +BASH_COMPLETION_EOF +} +__lokoctl_bash_source <(__lokoctl_convert_bash_to_zsh) +` + + _, err = out.Write([]byte(zshTail)) + if err != nil { + return err + } + + return nil +} + +// noCompletions is used to disable file completion. +func noCompletions(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { + return nil, cobra.ShellCompDirectiveNoFileComp +} + +func init() { //nolint:gochecknoinits + RootCmd.AddCommand(newCompletionCmd(os.Stdout)) +} diff --git a/vendor/helm.sh/helm/v3/cmd/helm/require/args.go b/vendor/helm.sh/helm/v3/cmd/helm/require/args.go new file mode 100644 index 000000000..cfa8a0169 --- /dev/null +++ b/vendor/helm.sh/helm/v3/cmd/helm/require/args.go @@ -0,0 +1,88 @@ +/* +Copyright The Helm Authors. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package require + +import ( + "github.com/pkg/errors" + "github.com/spf13/cobra" +) + +// NoArgs returns an error if any args are included. +func NoArgs(cmd *cobra.Command, args []string) error { + if len(args) > 0 { + return errors.Errorf( + "%q accepts no arguments\n\nUsage: %s", + cmd.CommandPath(), + cmd.UseLine(), + ) + } + return nil +} + +// ExactArgs returns an error if there are not exactly n args. +func ExactArgs(n int) cobra.PositionalArgs { + return func(cmd *cobra.Command, args []string) error { + if len(args) != n { + return errors.Errorf( + "%q requires %d %s\n\nUsage: %s", + cmd.CommandPath(), + n, + pluralize("argument", n), + cmd.UseLine(), + ) + } + return nil + } +} + +// MaximumNArgs returns an error if there are more than N args. +func MaximumNArgs(n int) cobra.PositionalArgs { + return func(cmd *cobra.Command, args []string) error { + if len(args) > n { + return errors.Errorf( + "%q accepts at most %d %s\n\nUsage: %s", + cmd.CommandPath(), + n, + pluralize("argument", n), + cmd.UseLine(), + ) + } + return nil + } +} + +// MinimumNArgs returns an error if there is not at least N args. +func MinimumNArgs(n int) cobra.PositionalArgs { + return func(cmd *cobra.Command, args []string) error { + if len(args) < n { + return errors.Errorf( + "%q requires at least %d %s\n\nUsage: %s", + cmd.CommandPath(), + n, + pluralize("argument", n), + cmd.UseLine(), + ) + } + return nil + } +} + +func pluralize(word string, n int) string { + if n == 1 { + return word + } + return word + "s" +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 8ae88d736..e2c11f906 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -469,6 +469,7 @@ gopkg.in/tomb.v1 # gopkg.in/yaml.v2 v2.2.8 gopkg.in/yaml.v2 # helm.sh/helm/v3 v3.1.2 => github.com/kinvolk/helm/v3 v3.2.2-0.20200526121938-305e0b796fc9 +helm.sh/helm/v3/cmd/helm/require helm.sh/helm/v3/internal/experimental/registry helm.sh/helm/v3/internal/fileutil helm.sh/helm/v3/internal/ignore