.github/workflows/size-labeler.yml

@@ -0,0 +1,33 @@
+# Reference: https://github.com/CodelyTV/pr-size-labeler
+
+name: size-labeler
+
+on: [pull_request_target]
+
+permissions:
+  contents: read
+
+jobs:
+  size-labeler:
+    permissions:
+      pull-requests: write  # for codelytv/pr-size-labeler to add labels & comment on PRs
+    runs-on: ubuntu-latest
+    name: Label the PR size
+    steps:
+      - uses: codelytv/pr-size-labeler@v1.8.1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          xs_label: 'size/XS'
+          xs_max_size: '10'
+          s_label: 'size/S'
+          s_max_size: '24'
+          m_label: 'size/M'
+          m_max_size: '99'
+          l_label: 'size/L'
+          l_max_size: '200'
+          xl_label: 'size/XL'
+          fail_if_xl: 'false'
+          message_if_xl: >
+            'This PR exceeds the recommended size of 200 lines.
+            Please make sure you are NOT addressing multiple issues with one PR.
+            Note this PR might be rejected due to its size.’

.github/workflows/test.yml

@@ -67,8 +67,6 @@ jobs:
         - 20
         - 21
         - 22
-        - 23
-        - 24
     name: '${{ matrix.platform }} | 1.${{ matrix.go }}.x'
     runs-on: ${{ matrix.platform }}-latest
     steps:

README.md

@@ -1,5 +1,4 @@
-
-![cobra logo](https://github.com/user-attachments/assets/cbc3adf8-0dff-46e9-a88d-5e2d971c169e)
+![cobra logo](assets/CobraMain.png)
 
 Cobra is a library for creating powerful modern CLI applications.
 
@@ -106,7 +105,7 @@ go install github.com/spf13/cobra-cli@latest
 
 For complete details on using the Cobra-CLI generator, please read [The Cobra Generator README](https://github.com/spf13/cobra-cli/blob/main/README.md)
 
-For complete details on using the Cobra library, please read [The Cobra User Guide](site/content/user_guide.md).
+For complete details on using the Cobra library, please read the [The Cobra User Guide](site/content/user_guide.md).
 
 # License
 

SECURITY.md

@@ -1,105 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-The `cobra` maintainers take security issues seriously and
-we appreciate your efforts to _**responsibly**_ disclose your findings.
-We will make every effort to swiftly respond and address concerns.
-
-To report a security vulnerability:
-
-1. **DO NOT** create a public GitHub issue for the vulnerability!
-2. **DO NOT** create a public GitHub Pull Request with a fix for the vulnerability!
-3. Send an email to `cobra-security@googlegroups.com`.
-4. Include the following details in your report:
-   - Description of the vulnerability
-   - Steps to reproduce
-   - Potential impact of the vulnerability (to your downstream project, to the Go ecosystem, etc.)
-   - Any potential mitigations you've already identified
-5. Allow up to 7 days for an initial response.
-   You should receive an acknowledgment of your report and an estimated timeline for a fix.
-6. (Optional) If you have a fix and would like to contribute your patch, please work
-   directly with the maintainers via `cobra-security@googlegroups.com` to
-   coordinate pushing the patch to GitHub, cutting a new release, and disclosing the change.
-
-## Response Process
-
-When a security vulnerability report is received, the `cobra` maintainers will:
-
-1. Confirm receipt of the vulnerability report within 7 days.
-2. Assess the report to determine if it constitutes a security vulnerability.
-3. If confirmed, assign the vulnerability a severity level and create a timeline for addressing it.
-4. Develop and test a fix.
-5. Patch the vulnerability and make a new GitHub release: the maintainers will coordinate disclosure with the reporter.
-6. Create a new GitHub Security Advisory to inform the broader Go ecosystem
-
-## Disclosure Policy
-
-The `cobra` maintainers follow a coordinated disclosure process:
-
-1. Security vulnerabilities will be addressed as quickly as possible.
-2. A CVE (Common Vulnerabilities and Exposures) identifier will be requested for significant vulnerabilities
-   that are within `cobra` itself.
-3. Once a fix is ready, the maintainers will:
-   - Release a new version containing the fix.
-   - Update the security advisory with details about the vulnerability.
-   - Credit the reporter (unless they wish to remain anonymous).
-   - Credit the fixer (unless they wish to remain anonymous, this may be the same as the reporter).
-   - Announce the vulnerability through appropriate channels
-     (GitHub Security Advisory, mailing lists, GitHub Releases, etc.)
-
-## Supported Versions
-
-Security fixes will typically only be released for the most recent major release.
-
-## Upstream Security Issues
-
-`cobra` generally will not accept vulnerability reports that originate in upstream
-dependencies. I.e., if there is a problem in Go code that `cobra` depends on,
-it is best to engage that project's maintainers and owners.
-
-This security policy primarily pertains only to `cobra` itself but if you believe you've
-identified a problem that originates in an upstream dependency and is being widely
-distributed by `cobra`, please follow the disclosure procedure above: the `cobra`
-maintainers will work with you to determine the severity and ecosystem impact.
-
-## Security Updates and CVEs
-
-Information about known security vulnerabilities and CVEs affecting `cobra` will
-be published as GitHub Security Advisories at
-https://github.com/spf13/cobra/security/advisories.
-
-All users are encouraged to watch the repository and upgrade promptly when
-security releases are published.
-
-## `cobra` Security Best Practices for Users
-
-When using `cobra` in your CLIs, the `cobra` maintainers recommend the following:
-
-1. Always use the latest version of `cobra`.
-2. [Use Go modules](https://go.dev/blog/using-go-modules) for dependency management.
-3. Always use the latest possible version of Go.
-
-## Security Best Practices for Contributors
-
-When contributing to `cobra`:
-
-1. Be mindful of security implications when adding new features or modifying existing ones.
-2. Be aware of `cobra`'s extremely large reach: it is used in nearly every Go CLI
-   (like Kubernetes, Docker, Prometheus, etc. etc.)
-3. Write tests that explicitly cover edge cases and potential issues.
-4. If you discover a security issue while working on `cobra`, please report it
-   following the process above rather than opening a public pull request or issue that
-   addresses the vulnerability.
-5. Take personal sec-ops seriously and secure your GitHub account: use [two-factor authentication](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa),
-   [sign your commits with a GPG or SSH key](https://docs.github.com/en/authentication/managing-commit-signature-verification/about-commit-signature-verification),
-   etc.
-
-## Acknowledgments
-
-The `cobra` maintainers would like to thank all security researchers and
-community members who help keep cobra, its users, and the entire Go ecosystem secure through responsible disclosures!!
-
----
-
-*This security policy is inspired by the [Open Web Application Security Project (OWASP)](https://owasp.org/) guidelines and security best practices.*

active_help.go

@@ -35,7 +35,7 @@ const (
 // This function can be called multiple times before and/or after completions are added to
 // the array.  Each time this function is called with the same array, the new
 // ActiveHelp line will be shown below the previous ones when completion is triggered.
-func AppendActiveHelp(compArray []Completion, activeHelpStr string) []Completion {
+func AppendActiveHelp(compArray []string, activeHelpStr string) []string {
 	return append(compArray, fmt.Sprintf("%s%s", activeHelpMarker, activeHelpStr))
 }
 

bash_completionsV2.go

@@ -146,7 +146,7 @@ __%[1]s_process_completion_results() {
 
     if (((directive & shellCompDirectiveFilterFileExt) != 0)); then
         # File extension filtering
-        local fullFilter="" filter filteringCmd
+        local fullFilter filter filteringCmd
 
         # Do not use quotes around the $completions variable or else newline
         # characters will be kept.
@@ -177,63 +177,11 @@ __%[1]s_process_completion_results() {
     __%[1]s_handle_special_char "$cur" =
 
     # Print the activeHelp statements before we finish
-    __%[1]s_handle_activeHelp
-}
-
-__%[1]s_handle_activeHelp() {
-    # Print the activeHelp statements
     if ((${#activeHelp[*]} != 0)); then
-        if [ -z $COMP_TYPE ]; then
-            # Bash v3 does not set the COMP_TYPE variable.
         printf "\n";
         printf "%%s\n" "${activeHelp[@]}"
         printf "\n"
-            __%[1]s_reprint_commandLine
-            return
-        fi
 
-        # Only print ActiveHelp on the second TAB press
-        if [ $COMP_TYPE -eq 63 ]; then
-            printf "\n"
-            printf "%%s\n" "${activeHelp[@]}"
-
-            if ((${#COMPREPLY[*]} == 0)); then
-                # When there are no completion choices from the program, file completion
-                # may kick in if the program has not disabled it; in such a case, we want
-                # to know if any files will match what the user typed, so that we know if
-                # there will be completions presented, so that we know how to handle ActiveHelp.
-                # To find out, we actually trigger the file completion ourselves;
-                # the call to _filedir will fill COMPREPLY if files match.
-                if (((directive & shellCompDirectiveNoFileComp) == 0)); then
-                    __%[1]s_debug "Listing files"
-                    _filedir
-                fi
-            fi
-
-            if ((${#COMPREPLY[*]} != 0)); then
-                # If there are completion choices to be shown, print a delimiter.
-                # Re-printing the command-line will automatically be done
-                # by the shell when it prints the completion choices.
-                printf -- "--"
-            else
-                # When there are no completion choices at all, we need
-                # to re-print the command-line since the shell will
-                # not be doing it itself.
-                __%[1]s_reprint_commandLine
-            fi
-        elif [ $COMP_TYPE -eq 37 ] || [ $COMP_TYPE -eq 42 ]; then
-            # For completion type: menu-complete/menu-complete-backward and insert-completions
-            # the completions are immediately inserted into the command-line, so we first
-            # print the activeHelp message and reprint the command-line since the shell won't.
-            printf "\n"
-            printf "%%s\n" "${activeHelp[@]}"
-
-            __%[1]s_reprint_commandLine
-        fi
-    fi
-}
-
-__%[1]s_reprint_commandLine() {
         # The prompt format is only available from bash 4.4.
         # We test if it is available before using it.
         if (x=${PS1@P}) 2> /dev/null; then
@@ -243,6 +191,7 @@ __%[1]s_reprint_commandLine() {
             # text the user had typed, it is workable enough.
             printf "%%s" "${COMP_LINE[@]}"
         fi
+    fi
 }
 
 # Separate activeHelp lines from real completions.
@@ -252,8 +201,6 @@ __%[1]s_extract_activeHelp() {
     local endIndex=${#activeHelpMarker}
 
     while IFS='' read -r comp; do
-        [[ -z $comp ]] && continue
-
         if [[ ${comp:0:endIndex} == $activeHelpMarker ]]; then
             comp=${comp:endIndex}
             __%[1]s_debug "ActiveHelp found: $comp"
@@ -276,21 +223,16 @@ __%[1]s_handle_completion_types() {
         # If the user requested inserting one completion at a time, or all
         # completions at once on the command-line we must remove the descriptions.
         # https://github.com/spf13/cobra/issues/1508
-
-        # If there are no completions, we don't need to do anything
-        (( ${#completions[@]} == 0 )) && return 0
-
-        local tab=$'\t'
-
-        # Strip any description and escape the completion to handled special characters
-        IFS=$'\n' read -ra completions -d '' < <(printf "%%q\n" "${completions[@]%%%%$tab*}")
-
+        local tab=$'\t' comp
+        while IFS='' read -r comp; do
+            [[ -z $comp ]] && continue
+            # Strip any description
+            comp=${comp%%%%$tab*}
             # Only consider the completions that match
-        IFS=$'\n' read -ra COMPREPLY -d '' < <(IFS=$'\n'; compgen -W "${completions[*]}" -- "${cur}")
-
-        # compgen looses the escaping so we need to escape all completions again since they will
-        # all be inserted on the command-line.
-        IFS=$'\n' read -ra COMPREPLY -d '' < <(printf "%%q\n" "${COMPREPLY[@]}")
+            if [[ $comp == "$cur"* ]]; then
+                COMPREPLY+=("$comp")
+            fi
+        done < <(printf "%%s\n" "${completions[@]}")
         ;;
 
     *)
@@ -301,25 +243,11 @@ __%[1]s_handle_completion_types() {
 }
 
 __%[1]s_handle_standard_completion_case() {
-    local tab=$'\t'
-
-    # If there are no completions, we don't need to do anything
-    (( ${#completions[@]} == 0 )) && return 0
+    local tab=$'\t' comp
 
     # Short circuit to optimize if we don't have descriptions
     if [[ "${completions[*]}" != *$tab* ]]; then
-        # First, escape the completions to handle special characters
-        IFS=$'\n' read -ra completions -d '' < <(printf "%%q\n" "${completions[@]}")
-        # Only consider the completions that match what the user typed
-        IFS=$'\n' read -ra COMPREPLY -d '' < <(IFS=$'\n'; compgen -W "${completions[*]}" -- "${cur}")
-
-        # compgen looses the escaping so, if there is only a single completion, we need to
-        # escape it again because it will be inserted on the command-line.  If there are multiple
-        # completions, we don't want to escape them because they will be printed in a list
-        # and we don't want to show escape characters in that list.
-        if (( ${#COMPREPLY[@]} == 1 )); then
-            COMPREPLY[0]=$(printf "%%q" "${COMPREPLY[0]}")
-        fi
+        IFS=$'\n' read -ra COMPREPLY -d '' < <(compgen -W "${completions[*]}" -- "$cur")
         return 0
     fi
 
@@ -328,39 +256,23 @@ __%[1]s_handle_standard_completion_case() {
     # Look for the longest completion so that we can format things nicely
     while IFS='' read -r compline; do
         [[ -z $compline ]] && continue
-
-        # Before checking if the completion matches what the user typed,
-        # we need to strip any description and escape the completion to handle special
-        # characters because those escape characters are part of what the user typed.
-        # Don't call "printf" in a sub-shell because it will be much slower
-        # since we are in a loop.
-        printf -v comp "%%q" "${compline%%%%$tab*}" &>/dev/null || comp=$(printf "%%q" "${compline%%%%$tab*}")
-
+        # Strip any description before checking the length
+        comp=${compline%%%%$tab*}
         # Only consider the completions that match
         [[ $comp == "$cur"* ]] || continue
-
-        # The completions matches.  Add it to the list of full completions including
-        # its description.  We don't escape the completion because it may get printed
-        # in a list if there are more than one and we don't want show escape characters
-        # in that list.
         COMPREPLY+=("$compline")
-
-        # Strip any description before checking the length, and again, don't escape
-        # the completion because this length is only used when printing the completions
-        # in a list and we don't want show escape characters in that list.
-        comp=${compline%%%%$tab*}
         if ((${#comp}>longest)); then
             longest=${#comp}
         fi
     done < <(printf "%%s\n" "${completions[@]}")
 
-    # If there is a single completion left, remove the description text and escape any special characters
+    # If there is a single completion left, remove the description text
     if ((${#COMPREPLY[*]} == 1)); then
         __%[1]s_debug "COMPREPLY[0]: ${COMPREPLY[0]}"
-        COMPREPLY[0]=$(printf "%%q" "${COMPREPLY[0]%%%%$tab*}")
-        __%[1]s_debug "Removed description from single completion, which is now: ${COMPREPLY[0]}"
-    else
-        # Format the descriptions
+        comp="${COMPREPLY[0]%%%%$tab*}"
+        __%[1]s_debug "Removed description from single completion, which is now: ${comp}"
+        COMPREPLY[0]=$comp
+    else # Format the descriptions
         __%[1]s_format_comp_descriptions $longest
     fi
 }

cobra.go

@@ -176,16 +176,12 @@ func rpad(s string, padding int) string {
 	return fmt.Sprintf(formattedString, s)
 }
 
-func tmpl(text string) *tmplFunc {
-	return &tmplFunc{
-		tmpl: text,
-		fn: func(w io.Writer, data interface{}) error {
+// tmpl executes the given template text on data, writing the result to w.
+func tmpl(w io.Writer, text string, data interface{}) error {
 	t := template.New("top")
 	t.Funcs(templateFuncs)
 	template.Must(t.Parse(text))
 	return t.Execute(w, data)
-		},
-	}
 }
 
 // ld compares two strings and returns the levenshtein distance between them.

cobra_test.go

@@ -15,11 +15,6 @@
 package cobra
 
 import (
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
 	"testing"
 	"text/template"
 )
@@ -227,75 +222,3 @@ func TestRpad(t *testing.T) {
 		})
 	}
 }
-
-// TestDeadcodeElimination checks that a simple program using cobra in its
-// default configuration is linked taking full advantage of the linker's
-// deadcode elimination step.
-//
-// If reflect.Value.MethodByName/reflect.Value.Method are reachable the
-// linker will not always be able to prove that exported methods are
-// unreachable, making deadcode elimination less effective. Using
-// text/template and html/template makes reflect.Value.MethodByName
-// reachable.
-// Since cobra can use text/template templates this test checks that in its
-// default configuration that code path can be proven to be unreachable by
-// the linker.
-//
-// See also: https://github.com/spf13/cobra/pull/1956
-func TestDeadcodeElimination(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("go tool nm fails on windows")
-	}
-
-	// check that a simple program using cobra in its default configuration is
-	// linked with deadcode elimination enabled.
-	const (
-		dirname  = "test_deadcode"
-		progname = "test_deadcode_elimination"
-	)
-	_ = os.Mkdir(dirname, 0770)
-	defer os.RemoveAll(dirname)
-	filename := filepath.Join(dirname, progname+".go")
-	err := os.WriteFile(filename, []byte(`package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-var rootCmd = &cobra.Command{
-	Version: "1.0",
-	Use:     "example_program",
-	Short:   "example_program - test fixture to check that deadcode elimination is allowed",
-	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("hello world")
-	},
-	Aliases: []string{"alias1", "alias2"},
-	Example: "stringer --help",
-}
-
-func main() {
-	if err := rootCmd.Execute(); err != nil {
-		fmt.Fprintf(os.Stderr, "Whoops. There was an error while executing your CLI '%s'", err)
-		os.Exit(1)
-	}
-}
-`), 0600)
-	if err != nil {
-		t.Fatalf("could not write test program: %v", err)
-	}
-	buf, err := exec.Command("go", "build", filename).CombinedOutput()
-	if err != nil {
-		t.Fatalf("could not compile test program: %s", string(buf))
-	}
-	defer os.Remove(progname)
-	buf, err = exec.Command("go", "tool", "nm", progname).CombinedOutput()
-	if err != nil {
-		t.Fatalf("could not run go tool nm: %v", err)
-	}
-	if strings.Contains(string(buf), "MethodByName") {
-		t.Error("compiled programs contains MethodByName symbol")
-	}
-}

command.go

@@ -33,9 +33,6 @@ import (
 const (
 	FlagSetByCobraAnnotation     = "cobra_annotation_flag_set_by_cobra"
 	CommandDisplayNameAnnotation = "cobra_annotation_command_display_name"
-
-	helpFlagName    = "help"
-	helpCommandName = "help"
 )
 
 // FParseErrWhitelist configures Flag parse errors to be ignored
@@ -83,11 +80,11 @@ type Command struct {
 	Example string
 
 	// ValidArgs is list of all valid non-flag arguments that are accepted in shell completions
-	ValidArgs []Completion
+	ValidArgs []string
 	// ValidArgsFunction is an optional function that provides valid non-flag arguments for shell completion.
 	// It is a dynamic version of using ValidArgs.
 	// Only one of ValidArgs and ValidArgsFunction can be used for a command.
-	ValidArgsFunction CompletionFunc
+	ValidArgsFunction func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
 
 	// Expected arguments
 	Args PositionalArgs
@@ -171,12 +168,12 @@ type Command struct {
 	// usageFunc is usage func defined by user.
 	usageFunc func(*Command) error
 	// usageTemplate is usage template defined by user.
-	usageTemplate *tmplFunc
+	usageTemplate string
 	// flagErrorFunc is func defined by user and it's called when the parsing of
 	// flags returns an error.
 	flagErrorFunc func(*Command, error) error
 	// helpTemplate is help template defined by user.
-	helpTemplate *tmplFunc
+	helpTemplate string
 	// helpFunc is help func defined by user.
 	helpFunc func(*Command, []string)
 	// helpCommand is command with usage 'help'. If it's not defined by user,
@@ -189,7 +186,7 @@ type Command struct {
 	completionCommandGroupID string
 
 	// versionTemplate is the version template defined by user.
-	versionTemplate *tmplFunc
+	versionTemplate string
 
 	// errPrefix is the error message prefix defined by user.
 	errPrefix string
@@ -284,7 +281,6 @@ func (c *Command) SetArgs(a []string) {
 
 // SetOutput sets the destination for usage and error messages.
 // If output is nil, os.Stderr is used.
-//
 // Deprecated: Use SetOut and/or SetErr instead
 func (c *Command) SetOutput(output io.Writer) {
 	c.outWriter = output
@@ -316,11 +312,7 @@ func (c *Command) SetUsageFunc(f func(*Command) error) {
 
 // SetUsageTemplate sets usage template. Can be defined by Application.
 func (c *Command) SetUsageTemplate(s string) {
-	if s == "" {
-		c.usageTemplate = nil
-		return
-	}
-	c.usageTemplate = tmpl(s)
+	c.usageTemplate = s
 }
 
 // SetFlagErrorFunc sets a function to generate an error when flag parsing
@@ -356,20 +348,12 @@ func (c *Command) SetCompletionCommandGroupID(groupID string) {
 
 // SetHelpTemplate sets help template to be used. Application can use it to set custom template.
 func (c *Command) SetHelpTemplate(s string) {
-	if s == "" {
-		c.helpTemplate = nil
-		return
-	}
-	c.helpTemplate = tmpl(s)
+	c.helpTemplate = s
 }
 
 // SetVersionTemplate sets version template to be used. Application can use it to set custom template.
 func (c *Command) SetVersionTemplate(s string) {
-	if s == "" {
-		c.versionTemplate = nil
-		return
-	}
-	c.versionTemplate = tmpl(s)
+	c.versionTemplate = s
 }
 
 // SetErrPrefix sets error message prefix to be used. Application can use it to set custom prefix.
@@ -450,8 +434,7 @@ func (c *Command) UsageFunc() (f func(*Command) error) {
 	}
 	return func(c *Command) error {
 		c.mergePersistentFlags()
-		fn := c.getUsageTemplateFunc()
-		err := fn(c.OutOrStderr(), c)
+		err := tmpl(c.OutOrStderr(), c.UsageTemplate(), c)
 		if err != nil {
 			c.PrintErrln(err)
 		}
@@ -459,19 +442,6 @@ func (c *Command) UsageFunc() (f func(*Command) error) {
 	}
 }
 
-// getUsageTemplateFunc returns the usage template function for the command
-// going up the command tree if necessary.
-func (c *Command) getUsageTemplateFunc() func(w io.Writer, data interface{}) error {
-	if c.usageTemplate != nil {
-		return c.usageTemplate.fn
-	}
-
-	if c.HasParent() {
-		return c.parent.getUsageTemplateFunc()
-	}
-	return defaultUsageFunc
-}
-
 // Usage puts out the usage for the command.
 // Used when a user provides invalid input.
 // Can be defined by user by overriding UsageFunc.
@@ -490,30 +460,15 @@ func (c *Command) HelpFunc() func(*Command, []string) {
 	}
 	return func(c *Command, a []string) {
 		c.mergePersistentFlags()
-		fn := c.getHelpTemplateFunc()
 		// The help should be sent to stdout
 		// See https://github.com/spf13/cobra/issues/1002
-		err := fn(c.OutOrStdout(), c)
+		err := tmpl(c.OutOrStdout(), c.HelpTemplate(), c)
 		if err != nil {
 			c.PrintErrln(err)
 		}
 	}
 }
 
-// getHelpTemplateFunc returns the help template function for the command
-// going up the command tree if necessary.
-func (c *Command) getHelpTemplateFunc() func(w io.Writer, data interface{}) error {
-	if c.helpTemplate != nil {
-		return c.helpTemplate.fn
-	}
-
-	if c.HasParent() {
-		return c.parent.getHelpTemplateFunc()
-	}
-
-	return defaultHelpFunc
-}
-
 // Help puts out the help for the command.
 // Used when a user calls help [command].
 // Can be defined by user by overriding HelpFunc.
@@ -588,55 +543,71 @@ func (c *Command) NamePadding() int {
 }
 
 // UsageTemplate returns usage template for the command.
-// This function is kept for backwards-compatibility reasons.
 func (c *Command) UsageTemplate() string {
-	if c.usageTemplate != nil {
-		return c.usageTemplate.tmpl
+	if c.usageTemplate != "" {
+		return c.usageTemplate
 	}
 
 	if c.HasParent() {
 		return c.parent.UsageTemplate()
 	}
-	return defaultUsageTemplate
+	return `Usage:{{if .Runnable}}
+  {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}}
+  {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}}
+
+Aliases:
+  {{.NameAndAliases}}{{end}}{{if .HasExample}}
+
+Examples:
+{{.Example}}{{end}}{{if .HasAvailableSubCommands}}{{$cmds := .Commands}}{{if eq (len .Groups) 0}}
+
+Available Commands:{{range $cmds}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{else}}{{range $group := .Groups}}
+
+{{.Title}}{{range $cmds}}{{if (and (eq .GroupID $group.ID) (or .IsAvailableCommand (eq .Name "help")))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if not .AllChildCommandsHaveGroup}}
+
+Additional Commands:{{range $cmds}}{{if (and (eq .GroupID "") (or .IsAvailableCommand (eq .Name "help")))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
+
+Flags:
+{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
+
+Global Flags:
+{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
+
+Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
+  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
+
+Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
+`
 }
 
 // HelpTemplate return help template for the command.
-// This function is kept for backwards-compatibility reasons.
 func (c *Command) HelpTemplate() string {
-	if c.helpTemplate != nil {
-		return c.helpTemplate.tmpl
+	if c.helpTemplate != "" {
+		return c.helpTemplate
 	}
 
 	if c.HasParent() {
 		return c.parent.HelpTemplate()
 	}
-	return defaultHelpTemplate
+	return `{{with (or .Long .Short)}}{{. | trimTrailingWhitespaces}}
+
+{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}`
 }
 
 // VersionTemplate return version template for the command.
-// This function is kept for backwards-compatibility reasons.
 func (c *Command) VersionTemplate() string {
-	if c.versionTemplate != nil {
-		return c.versionTemplate.tmpl
+	if c.versionTemplate != "" {
+		return c.versionTemplate
 	}
 
 	if c.HasParent() {
 		return c.parent.VersionTemplate()
 	}
-	return defaultVersionTemplate
-}
-
-// getVersionTemplateFunc returns the version template function for the command
-// going up the command tree if necessary.
-func (c *Command) getVersionTemplateFunc() func(w io.Writer, data interface{}) error {
-	if c.versionTemplate != nil {
-		return c.versionTemplate.fn
-	}
-
-	if c.HasParent() {
-		return c.parent.getVersionTemplateFunc()
-	}
-	return defaultVersionFunc
+	return `{{with .Name}}{{printf "%s " .}}{{end}}{{printf "version %s" .Version}}
+`
 }
 
 // ErrPrefix return error message prefix for the command
@@ -923,7 +894,7 @@ func (c *Command) execute(a []string) (err error) {
 
 	// If help is called, regardless of other flags, return we want help.
 	// Also say we need help if the command isn't runnable.
-	helpVal, err := c.Flags().GetBool(helpFlagName)
+	helpVal, err := c.Flags().GetBool("help")
 	if err != nil {
 		// should be impossible to get here as we always declare a help
 		// flag in InitDefaultHelpFlag()
@@ -943,8 +914,7 @@ func (c *Command) execute(a []string) (err error) {
 			return err
 		}
 		if versionVal {
-			fn := c.getVersionTemplateFunc()
-			err := fn(c.OutOrStdout(), c)
+			err := tmpl(c.OutOrStdout(), c.VersionTemplate(), c)
 			if err != nil {
 				c.Println(err)
 			}
@@ -1098,6 +1068,12 @@ func (c *Command) ExecuteC() (cmd *Command, err error) {
 
 	// initialize help at the last point to allow for user overriding
 	c.InitDefaultHelpCmd()
+	// initialize completion at the last point to allow for user overriding
+	c.InitDefaultCompletionCmd()
+
+	// Now that all commands have been created, let's make sure all groups
+	// are properly created also
+	c.checkCommandGroups()
 
 	args := c.args
 
@@ -1106,16 +1082,9 @@ func (c *Command) ExecuteC() (cmd *Command, err error) {
 		args = os.Args[1:]
 	}
 
-	// initialize the __complete command to be used for shell completion
+	// initialize the hidden command to be used for shell completion
 	c.initCompleteCmd(args)
 
-	// initialize the default completion command
-	c.InitDefaultCompletionCmd(args...)
-
-	// Now that all commands have been created, let's make sure all groups
-	// are properly created also
-	c.checkCommandGroups()
-
 	var flags []string
 	if c.TraverseChildren {
 		cmd, flags, err = c.Traverse(args)
@@ -1218,16 +1187,16 @@ func (c *Command) checkCommandGroups() {
 // If c already has help flag, it will do nothing.
 func (c *Command) InitDefaultHelpFlag() {
 	c.mergePersistentFlags()
-	if c.Flags().Lookup(helpFlagName) == nil {
+	if c.Flags().Lookup("help") == nil {
 		usage := "help for "
-		name := c.DisplayName()
+		name := c.displayName()
 		if name == "" {
 			usage += "this command"
 		} else {
 			usage += name
 		}
-		c.Flags().BoolP(helpFlagName, "h", false, usage)
-		_ = c.Flags().SetAnnotation(helpFlagName, FlagSetByCobraAnnotation, []string{"true"})
+		c.Flags().BoolP("help", "h", false, usage)
+		_ = c.Flags().SetAnnotation("help", FlagSetByCobraAnnotation, []string{"true"})
 	}
 }
 
@@ -1246,7 +1215,7 @@ func (c *Command) InitDefaultVersionFlag() {
 		if c.Name() == "" {
 			usage += "this command"
 		} else {
-			usage += c.DisplayName()
+			usage += c.Name()
 		}
 		if c.Flags().ShorthandLookup("v") == nil {
 			c.Flags().BoolP("version", "v", false, usage)
@@ -1270,9 +1239,9 @@ func (c *Command) InitDefaultHelpCmd() {
 			Use:   "help [command]",
 			Short: "Help about any command",
 			Long: `Help provides help for any command in the application.
-Simply type ` + c.DisplayName() + ` help [path to command] for full details.`,
-			ValidArgsFunction: func(c *Command, args []string, toComplete string) ([]Completion, ShellCompDirective) {
-				var completions []Completion
+Simply type ` + c.displayName() + ` help [path to command] for full details.`,
+			ValidArgsFunction: func(c *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
+				var completions []string
 				cmd, _, e := c.Root().Find(args)
 				if e != nil {
 					return nil, ShellCompDirectiveNoFileComp
@@ -1284,7 +1253,7 @@ Simply type ` + c.DisplayName() + ` help [path to command] for full details.`,
 				for _, subCmd := range cmd.Commands() {
 					if subCmd.IsAvailableCommand() || subCmd == cmd.helpCommand {
 						if strings.HasPrefix(subCmd.Name(), toComplete) {
-							completions = append(completions, CompletionWithDesc(subCmd.Name(), subCmd.Short))
+							completions = append(completions, fmt.Sprintf("%s\t%s", subCmd.Name(), subCmd.Short))
 						}
 					}
 				}
@@ -1296,11 +1265,6 @@ Simply type ` + c.DisplayName() + ` help [path to command] for full details.`,
 					c.Printf("Unknown help topic %#q\n", args)
 					CheckErr(c.Root().Usage())
 				} else {
-					// FLow the context down to be used in help text
-					if cmd.ctx == nil {
-						cmd.ctx = c.ctx
-					}
-
 					cmd.InitDefaultHelpFlag()    // make possible 'help' flag to be shown
 					cmd.InitDefaultVersionFlag() // make possible 'version' flag to be shown
 					CheckErr(cmd.Help())
@@ -1466,12 +1430,10 @@ func (c *Command) CommandPath() string {
 	if c.HasParent() {
 		return c.Parent().CommandPath() + " " + c.Name()
 	}
-	return c.DisplayName()
+	return c.displayName()
 }
 
-// DisplayName returns the name to display in help text. Returns command Name()
-// If CommandDisplayNameAnnoation is not set
-func (c *Command) DisplayName() string {
+func (c *Command) displayName() string {
 	if displayName, ok := c.Annotations[CommandDisplayNameAnnotation]; ok {
 		return displayName
 	}
@@ -1481,7 +1443,7 @@ func (c *Command) DisplayName() string {
 // UseLine puts out the full usage for a given command (including parents).
 func (c *Command) UseLine() string {
 	var useline string
-	use := strings.Replace(c.Use, c.Name(), c.DisplayName(), 1)
+	use := strings.Replace(c.Use, c.Name(), c.displayName(), 1)
 	if c.HasParent() {
 		useline = c.parent.CommandPath() + " " + use
 	} else {
@@ -1687,7 +1649,7 @@ func (c *Command) GlobalNormalizationFunc() func(f *flag.FlagSet, name string) f
 // to this command (local and persistent declared here and by all parents).
 func (c *Command) Flags() *flag.FlagSet {
 	if c.flags == nil {
-		c.flags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+		c.flags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 		if c.flagErrorBuf == nil {
 			c.flagErrorBuf = new(bytes.Buffer)
 		}
@@ -1702,7 +1664,7 @@ func (c *Command) Flags() *flag.FlagSet {
 func (c *Command) LocalNonPersistentFlags() *flag.FlagSet {
 	persistentFlags := c.PersistentFlags()
 
-	out := flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+	out := flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 	c.LocalFlags().VisitAll(func(f *flag.Flag) {
 		if persistentFlags.Lookup(f.Name) == nil {
 			out.AddFlag(f)
@@ -1717,7 +1679,7 @@ func (c *Command) LocalFlags() *flag.FlagSet {
 	c.mergePersistentFlags()
 
 	if c.lflags == nil {
-		c.lflags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+		c.lflags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 		if c.flagErrorBuf == nil {
 			c.flagErrorBuf = new(bytes.Buffer)
 		}
@@ -1745,7 +1707,7 @@ func (c *Command) InheritedFlags() *flag.FlagSet {
 	c.mergePersistentFlags()
 
 	if c.iflags == nil {
-		c.iflags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+		c.iflags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 		if c.flagErrorBuf == nil {
 			c.flagErrorBuf = new(bytes.Buffer)
 		}
@@ -1774,7 +1736,7 @@ func (c *Command) NonInheritedFlags() *flag.FlagSet {
 // PersistentFlags returns the persistent FlagSet specifically set in the current command.
 func (c *Command) PersistentFlags() *flag.FlagSet {
 	if c.pflags == nil {
-		c.pflags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+		c.pflags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 		if c.flagErrorBuf == nil {
 			c.flagErrorBuf = new(bytes.Buffer)
 		}
@@ -1787,9 +1749,9 @@ func (c *Command) PersistentFlags() *flag.FlagSet {
 func (c *Command) ResetFlags() {
 	c.flagErrorBuf = new(bytes.Buffer)
 	c.flagErrorBuf.Reset()
-	c.flags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+	c.flags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 	c.flags.SetOutput(c.flagErrorBuf)
-	c.pflags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+	c.pflags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 	c.pflags.SetOutput(c.flagErrorBuf)
 
 	c.lflags = nil
@@ -1906,7 +1868,7 @@ func (c *Command) mergePersistentFlags() {
 // If c.parentsPflags == nil, it makes new.
 func (c *Command) updateParentsPflags() {
 	if c.parentsPflags == nil {
-		c.parentsPflags = flag.NewFlagSet(c.DisplayName(), flag.ContinueOnError)
+		c.parentsPflags = flag.NewFlagSet(c.displayName(), flag.ContinueOnError)
 		c.parentsPflags.SetOutput(c.flagErrorBuf)
 		c.parentsPflags.SortFlags = false
 	}
@@ -1932,141 +1894,3 @@ func commandNameMatches(s string, t string) bool {
 
 	return s == t
 }
-
-// tmplFunc holds a template and a function that will execute said template.
-type tmplFunc struct {
-	tmpl string
-	fn   func(io.Writer, interface{}) error
-}
-
-var defaultUsageTemplate = `Usage:{{if .Runnable}}
-  {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}}
-  {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}}
-
-Aliases:
-  {{.NameAndAliases}}{{end}}{{if .HasExample}}
-
-Examples:
-{{.Example}}{{end}}{{if .HasAvailableSubCommands}}{{$cmds := .Commands}}{{if eq (len .Groups) 0}}
-
-Available Commands:{{range $cmds}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
-  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{else}}{{range $group := .Groups}}
-
-{{.Title}}{{range $cmds}}{{if (and (eq .GroupID $group.ID) (or .IsAvailableCommand (eq .Name "help")))}}
-  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if not .AllChildCommandsHaveGroup}}
-
-Additional Commands:{{range $cmds}}{{if (and (eq .GroupID "") (or .IsAvailableCommand (eq .Name "help")))}}
-  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
-
-Flags:
-{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
-
-Global Flags:
-{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
-
-Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
-  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
-
-Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
-`
-
-// defaultUsageFunc is equivalent to executing defaultUsageTemplate. The two should be changed in sync.
-func defaultUsageFunc(w io.Writer, in interface{}) error {
-	c := in.(*Command)
-	fmt.Fprint(w, "Usage:")
-	if c.Runnable() {
-		fmt.Fprintf(w, "\n  %s", c.UseLine())
-	}
-	if c.HasAvailableSubCommands() {
-		fmt.Fprintf(w, "\n  %s [command]", c.CommandPath())
-	}
-	if len(c.Aliases) > 0 {
-		fmt.Fprintf(w, "\n\nAliases:\n")
-		fmt.Fprintf(w, "  %s", c.NameAndAliases())
-	}
-	if c.HasExample() {
-		fmt.Fprintf(w, "\n\nExamples:\n")
-		fmt.Fprintf(w, "%s", c.Example)
-	}
-	if c.HasAvailableSubCommands() {
-		cmds := c.Commands()
-		if len(c.Groups()) == 0 {
-			fmt.Fprintf(w, "\n\nAvailable Commands:")
-			for _, subcmd := range cmds {
-				if subcmd.IsAvailableCommand() || subcmd.Name() == helpCommandName {
-					fmt.Fprintf(w, "\n  %s %s", rpad(subcmd.Name(), subcmd.NamePadding()), subcmd.Short)
-				}
-			}
-		} else {
-			for _, group := range c.Groups() {
-				fmt.Fprintf(w, "\n\n%s", group.Title)
-				for _, subcmd := range cmds {
-					if subcmd.GroupID == group.ID && (subcmd.IsAvailableCommand() || subcmd.Name() == helpCommandName) {
-						fmt.Fprintf(w, "\n  %s %s", rpad(subcmd.Name(), subcmd.NamePadding()), subcmd.Short)
-					}
-				}
-			}
-			if !c.AllChildCommandsHaveGroup() {
-				fmt.Fprintf(w, "\n\nAdditional Commands:")
-				for _, subcmd := range cmds {
-					if subcmd.GroupID == "" && (subcmd.IsAvailableCommand() || subcmd.Name() == helpCommandName) {
-						fmt.Fprintf(w, "\n  %s %s", rpad(subcmd.Name(), subcmd.NamePadding()), subcmd.Short)
-					}
-				}
-			}
-		}
-	}
-	if c.HasAvailableLocalFlags() {
-		fmt.Fprintf(w, "\n\nFlags:\n")
-		fmt.Fprint(w, trimRightSpace(c.LocalFlags().FlagUsages()))
-	}
-	if c.HasAvailableInheritedFlags() {
-		fmt.Fprintf(w, "\n\nGlobal Flags:\n")
-		fmt.Fprint(w, trimRightSpace(c.InheritedFlags().FlagUsages()))
-	}
-	if c.HasHelpSubCommands() {
-		fmt.Fprintf(w, "\n\nAdditional help topics:")
-		for _, subcmd := range c.Commands() {
-			if subcmd.IsAdditionalHelpTopicCommand() {
-				fmt.Fprintf(w, "\n  %s %s", rpad(subcmd.CommandPath(), subcmd.CommandPathPadding()), subcmd.Short)
-			}
-		}
-	}
-	if c.HasAvailableSubCommands() {
-		fmt.Fprintf(w, "\n\nUse \"%s [command] --help\" for more information about a command.", c.CommandPath())
-	}
-	fmt.Fprintln(w)
-	return nil
-}
-
-var defaultHelpTemplate = `{{with (or .Long .Short)}}{{. | trimTrailingWhitespaces}}
-
-{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}`
-
-// defaultHelpFunc is equivalent to executing defaultHelpTemplate. The two should be changed in sync.
-func defaultHelpFunc(w io.Writer, in interface{}) error {
-	c := in.(*Command)
-	usage := c.Long
-	if usage == "" {
-		usage = c.Short
-	}
-	usage = trimRightSpace(usage)
-	if usage != "" {
-		fmt.Fprintln(w, usage)
-		fmt.Fprintln(w)
-	}
-	if c.Runnable() || c.HasSubCommands() {
-		fmt.Fprint(w, c.UsageString())
-	}
-	return nil
-}
-
-var defaultVersionTemplate = `{{with .DisplayName}}{{printf "%s " .}}{{end}}{{printf "version %s" .Version}}
-`
-
-// defaultVersionFunc is equivalent to executing defaultVersionTemplate. The two should be changed in sync.
-func defaultVersionFunc(w io.Writer, in interface{}) error {
-	c := in.(*Command)
-	_, err := fmt.Fprintf(w, "%s version %s\n", c.DisplayName(), c.Version)
-	return err
-}

command_test.go

@@ -372,7 +372,6 @@ func TestAliasPrefixMatching(t *testing.T) {
 func TestPlugin(t *testing.T) {
 	cmd := &Command{
 		Use:  "kubectl-plugin",
-		Version: "1.0.0",
 		Args: NoArgs,
 		Annotations: map[string]string{
 			CommandDisplayNameAnnotation: "kubectl plugin",
@@ -387,14 +386,12 @@ func TestPlugin(t *testing.T) {
 
 	checkStringContains(t, cmdHelp, "kubectl plugin [flags]")
 	checkStringContains(t, cmdHelp, "help for kubectl plugin")
-	checkStringContains(t, cmdHelp, "version for kubectl plugin")
 }
 
-// TestPluginWithSubCommands checks usage as plugin with sub commands.
+// TestPlugin checks usage as plugin with sub commands.
 func TestPluginWithSubCommands(t *testing.T) {
 	rootCmd := &Command{
 		Use:  "kubectl-plugin",
-		Version: "1.0.0",
 		Args: NoArgs,
 		Annotations: map[string]string{
 			CommandDisplayNameAnnotation: "kubectl plugin",
@@ -411,7 +408,6 @@ func TestPluginWithSubCommands(t *testing.T) {
 
 	checkStringContains(t, rootHelp, "kubectl plugin [command]")
 	checkStringContains(t, rootHelp, "help for kubectl plugin")
-	checkStringContains(t, rootHelp, "version for kubectl plugin")
 	checkStringContains(t, rootHelp, "kubectl plugin [command] --help")
 
 	childHelp, err := executeCommand(rootCmd, "sub", "-h")
@@ -1018,49 +1014,6 @@ func TestSetHelpCommand(t *testing.T) {
 	}
 }
 
-func TestSetHelpTemplate(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	rootCmd.SetHelpTemplate("WORKS {{.UseLine}}")
-
-	// Call the help on the root command and check the new template is used
-	got, err := executeCommand(rootCmd, "--help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	expected := "WORKS " + rootCmd.UseLine()
-	if got != expected {
-		t.Errorf("Expected %q, got %q", expected, got)
-	}
-
-	// Call the help on the child command and check
-	// the new template is inherited from the parent
-	got, err = executeCommand(rootCmd, "child", "--help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	expected = "WORKS " + childCmd.UseLine()
-	if got != expected {
-		t.Errorf("Expected %q, got %q", expected, got)
-	}
-
-	// Reset the root command help template and make sure
-	// it falls back to the default
-	rootCmd.SetHelpTemplate("")
-	got, err = executeCommand(rootCmd, "--help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if !strings.Contains(got, "Usage:") {
-		t.Errorf("Expected to contain %q, got %q", "Usage:", got)
-	}
-}
-
 func TestHelpFlagExecuted(t *testing.T) {
 	rootCmd := &Command{Use: "root", Long: "Long description", Run: emptyRun}
 
@@ -1126,45 +1079,6 @@ func TestHelpExecutedOnNonRunnableChild(t *testing.T) {
 	checkStringContains(t, output, childCmd.Long)
 }
 
-func TestSetUsageTemplate(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	rootCmd.SetUsageTemplate("WORKS {{.UseLine}}")
-
-	// Trigger the usage on the root command and check the new template is used
-	got, err := executeCommand(rootCmd, "--invalid")
-	if err == nil {
-		t.Errorf("Expected error but did not get one")
-	}
-
-	expected := "WORKS " + rootCmd.UseLine()
-	checkStringContains(t, got, expected)
-
-	// Trigger the usage on the child command and check
-	// the new template is inherited from the parent
-	got, err = executeCommand(rootCmd, "child", "--invalid")
-	if err == nil {
-		t.Errorf("Expected error but did not get one")
-	}
-
-	expected = "WORKS " + childCmd.UseLine()
-	checkStringContains(t, got, expected)
-
-	// Reset the root command usage template and make sure
-	// it falls back to the default
-	rootCmd.SetUsageTemplate("")
-	got, err = executeCommand(rootCmd, "--invalid")
-	if err == nil {
-		t.Errorf("Expected error but did not get one")
-	}
-
-	if !strings.Contains(got, "Usage:") {
-		t.Errorf("Expected to contain %q, got %q", "Usage:", got)
-	}
-}
-
 func TestVersionFlagExecuted(t *testing.T) {
 	rootCmd := &Command{Use: "root", Version: "1.0.0", Run: emptyRun}
 
@@ -1176,24 +1090,6 @@ func TestVersionFlagExecuted(t *testing.T) {
 	checkStringContains(t, output, "root version 1.0.0")
 }
 
-func TestVersionFlagExecutedDiplayName(t *testing.T) {
-	rootCmd := &Command{
-		Use:     "kubectl-plugin",
-		Version: "1.0.0",
-		Annotations: map[string]string{
-			CommandDisplayNameAnnotation: "kubectl plugin",
-		},
-		Run: emptyRun,
-	}
-
-	output, err := executeCommand(rootCmd, "--version", "arg1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, "kubectl plugin version 1.0.0")
-}
-
 func TestVersionFlagExecutedWithNoName(t *testing.T) {
 	rootCmd := &Command{Version: "1.0.0", Run: emptyRun}
 
@@ -2921,34 +2817,3 @@ func TestUnknownFlagShouldReturnSameErrorRegardlessOfArgPosition(t *testing.T) {
 		})
 	}
 }
-
-func TestHelpFuncExecuted(t *testing.T) {
-	helpText := "Long description"
-
-	// Create a context that will be unique, not just the background context
-	//nolint:golint,staticcheck // We can safely use a basic type as key in tests.
-	executionCtx := context.WithValue(context.Background(), "testKey", "123")
-
-	child := &Command{Use: "child", Run: emptyRun}
-	child.SetHelpFunc(func(cmd *Command, args []string) {
-		_, err := cmd.OutOrStdout().Write([]byte(helpText))
-		if err != nil {
-			t.Error(err)
-		}
-
-		// Test for https://github.com/spf13/cobra/issues/2240
-		if cmd.Context() != executionCtx {
-			t.Error("Context doesn't equal the execution context")
-		}
-	})
-
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	rootCmd.AddCommand(child)
-
-	output, err := executeCommandWithContext(executionCtx, rootCmd, "help", "child")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, helpText)
-}

completions.go

@@ -35,7 +35,7 @@ const (
 )
 
 // Global map of flag completion functions. Make sure to use flagCompletionMutex before you try to read and write from it.
-var flagCompletionFunctions = map[*pflag.Flag]CompletionFunc{}
+var flagCompletionFunctions = map[*pflag.Flag]func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective){}
 
 // lock for reading and writing from flagCompletionFunctions
 var flagCompletionMutex = &sync.RWMutex{}
@@ -117,50 +117,22 @@ type CompletionOptions struct {
 	HiddenDefaultCmd bool
 }
 
-// Completion is a string that can be used for completions
-//
-// two formats are supported:
-//   - the completion choice
-//   - the completion choice with a textual description (separated by a TAB).
-//
-// [CompletionWithDesc] can be used to create a completion string with a textual description.
-//
-// Note: Go type alias is used to provide a more descriptive name in the documentation, but any string can be used.
-type Completion = string
-
-// CompletionFunc is a function that provides completion results.
-type CompletionFunc = func(cmd *Command, args []string, toComplete string) ([]Completion, ShellCompDirective)
-
-// CompletionWithDesc returns a [Completion] with a description by using the TAB delimited format.
-func CompletionWithDesc(choice string, description string) Completion {
-	return choice + "\t" + description
-}
-
 // NoFileCompletions can be used to disable file completion for commands that should
 // not trigger file completions.
-//
-// This method satisfies [CompletionFunc].
-// It can be used with [Command.RegisterFlagCompletionFunc] and for [Command.ValidArgsFunction].
-func NoFileCompletions(cmd *Command, args []string, toComplete string) ([]Completion, ShellCompDirective) {
+func NoFileCompletions(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
 	return nil, ShellCompDirectiveNoFileComp
 }
 
 // FixedCompletions can be used to create a completion function which always
 // returns the same results.
-//
-// This method returns a function that satisfies [CompletionFunc]
-// It can be used with [Command.RegisterFlagCompletionFunc] and for [Command.ValidArgsFunction].
-func FixedCompletions(choices []Completion, directive ShellCompDirective) CompletionFunc {
-	return func(cmd *Command, args []string, toComplete string) ([]Completion, ShellCompDirective) {
+func FixedCompletions(choices []string, directive ShellCompDirective) func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
+	return func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
 		return choices, directive
 	}
 }
 
 // RegisterFlagCompletionFunc should be called to register a function to provide completion for a flag.
-//
-// You can use pre-defined completion functions such as [FixedCompletions] or [NoFileCompletions],
-// or you can define your own.
-func (c *Command) RegisterFlagCompletionFunc(flagName string, f CompletionFunc) error {
+func (c *Command) RegisterFlagCompletionFunc(flagName string, f func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)) error {
 	flag := c.Flag(flagName)
 	if flag == nil {
 		return fmt.Errorf("RegisterFlagCompletionFunc: flag '%s' does not exist", flagName)
@@ -176,7 +148,7 @@ func (c *Command) RegisterFlagCompletionFunc(flagName string, f CompletionFunc)
 }
 
 // GetFlagCompletionFunc returns the completion function for the given flag of the command, if available.
-func (c *Command) GetFlagCompletionFunc(flagName string) (CompletionFunc, bool) {
+func (c *Command) GetFlagCompletionFunc(flagName string) (func(*Command, []string, string) ([]string, ShellCompDirective), bool) {
 	flag := c.Flag(flagName)
 	if flag == nil {
 		return nil, false
@@ -298,15 +270,7 @@ func (c *Command) initCompleteCmd(args []string) {
 	}
 }
 
-// SliceValue is a reduced version of [pflag.SliceValue]. It is used to detect
-// flags that accept multiple values and therefore can provide completion
-// multiple times.
-type SliceValue interface {
-	// GetSlice returns the flag value list as an array of strings.
-	GetSlice() []string
-}
-
-func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCompDirective, error) {
+func (c *Command) getCompletions(args []string) (*Command, []string, ShellCompDirective, error) {
 	// The last argument, which is not completely typed by the user,
 	// should not be part of the list of arguments
 	toComplete := args[len(args)-1]
@@ -334,7 +298,7 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 	}
 	if err != nil {
 		// Unable to find the real command. E.g., <program> someInvalidCmd <TAB>
-		return c, []Completion{}, ShellCompDirectiveDefault, fmt.Errorf("unable to find a command for arguments: %v", trimmedArgs)
+		return c, []string{}, ShellCompDirectiveDefault, fmt.Errorf("unable to find a command for arguments: %v", trimmedArgs)
 	}
 	finalCmd.ctx = c.ctx
 
@@ -364,7 +328,7 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 
 	// Parse the flags early so we can check if required flags are set
 	if err = finalCmd.ParseFlags(finalArgs); err != nil {
-		return finalCmd, []Completion{}, ShellCompDirectiveDefault, fmt.Errorf("Error while parsing flags from args %v: %s", finalArgs, err.Error())
+		return finalCmd, []string{}, ShellCompDirectiveDefault, fmt.Errorf("Error while parsing flags from args %v: %s", finalArgs, err.Error())
 	}
 
 	realArgCount := finalCmd.Flags().NArg()
@@ -376,14 +340,14 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 	if flagErr != nil {
 		// If error type is flagCompError and we don't want flagCompletion we should ignore the error
 		if _, ok := flagErr.(*flagCompError); !(ok && !flagCompletion) {
-			return finalCmd, []Completion{}, ShellCompDirectiveDefault, flagErr
+			return finalCmd, []string{}, ShellCompDirectiveDefault, flagErr
 		}
 	}
 
 	// Look for the --help or --version flags.  If they are present,
 	// there should be no further completions.
 	if helpOrVersionFlagPresent(finalCmd) {
-		return finalCmd, []Completion{}, ShellCompDirectiveNoFileComp, nil
+		return finalCmd, []string{}, ShellCompDirectiveNoFileComp, nil
 	}
 
 	// We only remove the flags from the arguments if DisableFlagParsing is not set.
@@ -412,11 +376,11 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 				return finalCmd, subDir, ShellCompDirectiveFilterDirs, nil
 			}
 			// Directory completion
-			return finalCmd, []Completion{}, ShellCompDirectiveFilterDirs, nil
+			return finalCmd, []string{}, ShellCompDirectiveFilterDirs, nil
 		}
 	}
 
-	var completions []Completion
+	var completions []string
 	var directive ShellCompDirective
 
 	// Enforce flag groups before doing flag completions
@@ -435,14 +399,10 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 		// If we have not found any required flags, only then can we show regular flags
 		if len(completions) == 0 {
 			doCompleteFlags := func(flag *pflag.Flag) {
-				_, acceptsMultiple := flag.Value.(SliceValue)
-				acceptsMultiple = acceptsMultiple ||
+				if !flag.Changed ||
 					strings.Contains(flag.Value.Type(), "Slice") ||
-					strings.Contains(flag.Value.Type(), "Array") ||
-					strings.HasPrefix(flag.Value.Type(), "stringTo")
-
-				if !flag.Changed || acceptsMultiple {
-					// If the flag is not already present, or if it can be specified multiple times (Array, Slice, or stringTo)
+					strings.Contains(flag.Value.Type(), "Array") {
+					// If the flag is not already present, or if it can be specified multiple times (Array or Slice)
 					// we suggest it as a completion
 					completions = append(completions, getFlagNameCompletions(flag, toComplete)...)
 				}
@@ -502,7 +462,7 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 				for _, subCmd := range finalCmd.Commands() {
 					if subCmd.IsAvailableCommand() || subCmd == finalCmd.helpCommand {
 						if strings.HasPrefix(subCmd.Name(), toComplete) {
-							completions = append(completions, CompletionWithDesc(subCmd.Name(), subCmd.Short))
+							completions = append(completions, fmt.Sprintf("%s\t%s", subCmd.Name(), subCmd.Short))
 						}
 						directive = ShellCompDirectiveNoFileComp
 					}
@@ -547,7 +507,7 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 	}
 
 	// Find the completion function for the flag or command
-	var completionFn CompletionFunc
+	var completionFn func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
 	if flag != nil && flagCompletion {
 		flagCompletionMutex.RLock()
 		completionFn = flagCompletionFunctions[flag]
@@ -558,7 +518,7 @@ func (c *Command) getCompletions(args []string) (*Command, []Completion, ShellCo
 	if completionFn != nil {
 		// Go custom completion defined for this flag or command.
 		// Call the registered completion function to get the completions.
-		var comps []Completion
+		var comps []string
 		comps, directive = completionFn(finalCmd, finalArgs, toComplete)
 		completions = append(completions, comps...)
 	}
@@ -571,23 +531,23 @@ func helpOrVersionFlagPresent(cmd *Command) bool {
 		len(versionFlag.Annotations[FlagSetByCobraAnnotation]) > 0 && versionFlag.Changed {
 		return true
 	}
-	if helpFlag := cmd.Flags().Lookup(helpFlagName); helpFlag != nil &&
+	if helpFlag := cmd.Flags().Lookup("help"); helpFlag != nil &&
 		len(helpFlag.Annotations[FlagSetByCobraAnnotation]) > 0 && helpFlag.Changed {
 		return true
 	}
 	return false
 }
 
-func getFlagNameCompletions(flag *pflag.Flag, toComplete string) []Completion {
+func getFlagNameCompletions(flag *pflag.Flag, toComplete string) []string {
 	if nonCompletableFlag(flag) {
-		return []Completion{}
+		return []string{}
 	}
 
-	var completions []Completion
+	var completions []string
 	flagName := "--" + flag.Name
 	if strings.HasPrefix(flagName, toComplete) {
 		// Flag without the =
-		completions = append(completions, CompletionWithDesc(flagName, flag.Usage))
+		completions = append(completions, fmt.Sprintf("%s\t%s", flagName, flag.Usage))
 
 		// Why suggest both long forms: --flag and --flag= ?
 		// This forces the user to *always* have to type either an = or a space after the flag name.
@@ -599,20 +559,20 @@ func getFlagNameCompletions(flag *pflag.Flag, toComplete string) []Completion {
 		// if len(flag.NoOptDefVal) == 0 {
 		// 	// Flag requires a value, so it can be suffixed with =
 		// 	flagName += "="
-		// 	completions = append(completions, CompletionWithDesc(flagName, flag.Usage))
+		// 	completions = append(completions, fmt.Sprintf("%s\t%s", flagName, flag.Usage))
 		// }
 	}
 
 	flagName = "-" + flag.Shorthand
 	if len(flag.Shorthand) > 0 && strings.HasPrefix(flagName, toComplete) {
-		completions = append(completions, CompletionWithDesc(flagName, flag.Usage))
+		completions = append(completions, fmt.Sprintf("%s\t%s", flagName, flag.Usage))
 	}
 
 	return completions
 }
 
-func completeRequireFlags(finalCmd *Command, toComplete string) []Completion {
-	var completions []Completion
+func completeRequireFlags(finalCmd *Command, toComplete string) []string {
+	var completions []string
 
 	doCompleteRequiredFlags := func(flag *pflag.Flag) {
 		if _, present := flag.Annotations[BashCompOneRequiredFlag]; present {
@@ -727,8 +687,8 @@ func checkIfFlagCompletion(finalCmd *Command, args []string, lastArg string) (*p
 // 1- the feature has been explicitly disabled by the program,
 // 2- c has no subcommands (to avoid creating one),
 // 3- c already has a 'completion' command provided by the program.
-func (c *Command) InitDefaultCompletionCmd(args ...string) {
-	if c.CompletionOptions.DisableDefaultCmd {
+func (c *Command) InitDefaultCompletionCmd() {
+	if c.CompletionOptions.DisableDefaultCmd || !c.HasSubCommands() {
 		return
 	}
 
@@ -741,16 +701,6 @@ func (c *Command) InitDefaultCompletionCmd(args ...string) {
 
 	haveNoDescFlag := !c.CompletionOptions.DisableNoDescFlag && !c.CompletionOptions.DisableDescriptions
 
-	// Special case to know if there are sub-commands or not.
-	hasSubCommands := false
-	for _, cmd := range c.commands {
-		if cmd.Name() != ShellCompRequestCmd && cmd.Name() != helpCommandName {
-			// We found a real sub-command (not 'help' or '__complete')
-			hasSubCommands = true
-			break
-		}
-	}
-
 	completionCmd := &Command{
 		Use:   compCmdName,
 		Short: "Generate the autocompletion script for the specified shell",
@@ -764,22 +714,6 @@ See each sub-command's help for details on how to use the generated script.
 	}
 	c.AddCommand(completionCmd)
 
-	if !hasSubCommands {
-		// If the 'completion' command will be the only sub-command,
-		// we only create it if it is actually being called.
-		// This avoids breaking programs that would suddenly find themselves with
-		// a subcommand, which would prevent them from accepting arguments.
-		// We also create the 'completion' command if the user is triggering
-		// shell completion for it (prog __complete completion '')
-		subCmd, cmdArgs, err := c.Find(args)
-		if err != nil || subCmd.Name() != compCmdName &&
-			!(subCmd.Name() == ShellCompRequestCmd && len(cmdArgs) > 1 && cmdArgs[0] == compCmdName) {
-			// The completion command is not being called or being completed so we remove it.
-			c.RemoveCommand(completionCmd)
-			return
-		}
-	}
-
 	out := c.OutOrStdout()
 	noDesc := c.CompletionOptions.DisableDescriptions
 	shortDesc := "Generate the autocompletion script for %s"

completions_test.go

@@ -671,29 +671,6 @@ func TestFlagNameCompletionInGoWithDesc(t *testing.T) {
 	}
 }
 
-// customMultiString is a custom Value type that accepts multiple values,
-// but does not include "Slice" or "Array" in its "Type" string.
-type customMultiString []string
-
-var _ SliceValue = (*customMultiString)(nil)
-
-func (s *customMultiString) String() string {
-	return fmt.Sprintf("%v", *s)
-}
-
-func (s *customMultiString) Set(v string) error {
-	*s = append(*s, v)
-	return nil
-}
-
-func (s *customMultiString) Type() string {
-	return "multi string"
-}
-
-func (s *customMultiString) GetSlice() []string {
-	return *s
-}
-
 func TestFlagNameCompletionRepeat(t *testing.T) {
 	rootCmd := &Command{
 		Use: "root",
@@ -716,8 +693,6 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 	sliceFlag := rootCmd.Flags().Lookup("slice")
 	rootCmd.Flags().BoolSliceP("bslice", "b", nil, "bool slice flag")
 	bsliceFlag := rootCmd.Flags().Lookup("bslice")
-	rootCmd.Flags().VarP(&customMultiString{}, "multi", "m", "multi string flag")
-	multiFlag := rootCmd.Flags().Lookup("multi")
 
 	// Test that flag names are not repeated unless they are an array or slice
 	output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--first", "1", "--")
@@ -731,7 +706,6 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"--array",
 		"--bslice",
 		"--help",
-		"--multi",
 		"--second",
 		"--slice",
 		":4",
@@ -754,7 +728,6 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"--array",
 		"--bslice",
 		"--help",
-		"--multi",
 		"--slice",
 		":4",
 		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
@@ -764,7 +737,7 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 	}
 
 	// Test that flag names are not repeated unless they are an array or slice
-	output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--slice", "1", "--slice=2", "--array", "val", "--bslice", "true", "--multi", "val", "--")
+	output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--slice", "1", "--slice=2", "--array", "val", "--bslice", "true", "--")
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -772,14 +745,12 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 	sliceFlag.Changed = false
 	arrayFlag.Changed = false
 	bsliceFlag.Changed = false
-	multiFlag.Changed = false
 
 	expected = strings.Join([]string{
 		"--array",
 		"--bslice",
 		"--first",
 		"--help",
-		"--multi",
 		"--second",
 		"--slice",
 		":4",
@@ -797,7 +768,6 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 	// Reset the flag for the next command
 	sliceFlag.Changed = false
 	arrayFlag.Changed = false
-	multiFlag.Changed = false
 
 	expected = strings.Join([]string{
 		"--array",
@@ -808,8 +778,6 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"-f",
 		"--help",
 		"-h",
-		"--multi",
-		"-m",
 		"--second",
 		"-s",
 		"--slice",
@@ -829,7 +797,6 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 	// Reset the flag for the next command
 	sliceFlag.Changed = false
 	arrayFlag.Changed = false
-	multiFlag.Changed = false
 
 	expected = strings.Join([]string{
 		"-a",
@@ -2465,7 +2432,7 @@ func TestDefaultCompletionCmd(t *testing.T) {
 		Run:  emptyRun,
 	}
 
-	// Test that when there are no sub-commands, the completion command is not created if it is not called directly.
+	// Test that no completion command is created if there are not other sub-commands
 	assertNoErr(t, rootCmd.Execute())
 	for _, cmd := range rootCmd.commands {
 		if cmd.Name() == compCmdName {
@@ -2474,17 +2441,6 @@ func TestDefaultCompletionCmd(t *testing.T) {
 		}
 	}
 
-	// Test that when there are no sub-commands, the completion command is created when it is called directly.
-	_, err := executeCommand(rootCmd, compCmdName)
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	// Reset the arguments
-	rootCmd.args = nil
-	// Remove completion command for the next test
-	removeCompCmd(rootCmd)
-
-	// Add a sub-command
 	subCmd := &Command{
 		Use: "sub",
 		Run: emptyRun,
@@ -2606,42 +2562,6 @@ func TestDefaultCompletionCmd(t *testing.T) {
 
 func TestCompleteCompletion(t *testing.T) {
 	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-
-	// Test that when there are no sub-commands, the 'completion' command is not completed
-	// (because it is not created).
-	output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "completion")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	expected := strings.Join([]string{
-		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
-
-	if output != expected {
-		t.Errorf("expected: %q, got: %q", expected, output)
-	}
-
-	// Test that when there are no sub-commands, completion can be triggered for the default
-	// 'completion' command
-	output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "completion", "")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	expected = strings.Join([]string{
-		"bash",
-		"fish",
-		"powershell",
-		"zsh",
-		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
-
-	if output != expected {
-		t.Errorf("expected: %q, got: %q", expected, output)
-	}
-
-	// Add a sub-command
 	subCmd := &Command{
 		Use: "sub",
 		Run: emptyRun,
@@ -2649,12 +2569,12 @@ func TestCompleteCompletion(t *testing.T) {
 	rootCmd.AddCommand(subCmd)
 
 	// Test sub-commands of the completion command
-	output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "completion", "")
+	output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "completion", "")
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
 
-	expected = strings.Join([]string{
+	expected := strings.Join([]string{
 		"bash",
 		"fish",
 		"powershell",
@@ -2885,99 +2805,13 @@ func TestCompleteWithRootAndLegacyArgs(t *testing.T) {
 		"arg1",
 		"arg2",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
-	}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
 	}
 }
 
-func TestCompletionFuncCompatibility(t *testing.T) {
-	t.Run("validate signature", func(t *testing.T) {
-		t.Run("format with []string", func(t *testing.T) {
-			var userComp func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
-
-			// check against new signature
-			var _ CompletionFunc = userComp
-
-			// check Command accepts
-			cmd := Command{
-				ValidArgsFunction: userComp,
-			}
-
-			_ = cmd.RegisterFlagCompletionFunc("foo", userComp)
-		})
-
-		t.Run("format with []Completion", func(t *testing.T) {
-			var userComp func(cmd *Command, args []string, toComplete string) ([]Completion, ShellCompDirective)
-
-			// check against new signature
-			var _ CompletionFunc = userComp
-
-			// check Command accepts
-			cmd := Command{
-				ValidArgsFunction: userComp,
-			}
-
-			_ = cmd.RegisterFlagCompletionFunc("foo", userComp)
-		})
-
-		t.Run("format with CompletionFunc", func(t *testing.T) {
-			var userComp CompletionFunc
-
-			// check helper against old signature
-			var _ func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) = userComp
-			var _ func(cmd *Command, args []string, toComplete string) ([]Completion, ShellCompDirective) = userComp
-
-			// check Command accepts
-			cmd := Command{
-				ValidArgsFunction: userComp,
-			}
-
-			_ = cmd.RegisterFlagCompletionFunc("foo", userComp)
-		})
-	})
-
-	t.Run("user defined completion helper", func(t *testing.T) {
-		t.Run("type helper", func(t *testing.T) {
-			// This is a type that may have been defined by the user of the library
-			// This replicates the issue https://github.com/docker/cli/issues/5827
-			// https://github.com/docker/cli/blob/b6e7eba4470ecdca460e4b63270fba8179674ad6/cli/command/completion/functions.go#L18
-			type UserCompletionTypeHelper func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
-
-			var userComp UserCompletionTypeHelper
-
-			// Here we are validating the existing type validates the CompletionFunc type
-			var _ CompletionFunc = userComp
-
-			cmd := Command{
-				ValidArgsFunction: userComp,
-			}
-
-			_ = cmd.RegisterFlagCompletionFunc("foo", userComp)
-		})
-
-		t.Run("type alias helper", func(t *testing.T) {
-			// This is a type that may have been defined by the user of the library
-			// This replicates the possible fix that was tried here https://github.com/docker/cli/pull/5828
-			// https://github.com/docker/cli/blob/ae3d4db9f658259dace9dee515718be7c1b1f517/cli/command/completion/functions.go#L18
-			type UserCompletionTypeAliasHelper = func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
-
-			var userComp UserCompletionTypeAliasHelper
-
-			// Here we are validating the existing type validates the CompletionFunc type
-			var _ CompletionFunc = userComp
-
-			cmd := Command{
-				ValidArgsFunction: userComp,
-			}
-
-			_ = cmd.RegisterFlagCompletionFunc("foo", userComp)
-		})
-	})
-}
-
 func TestFixedCompletions(t *testing.T) {
 	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
 	choices := []string{"apple", "banana", "orange"}
@@ -3005,56 +2839,6 @@ func TestFixedCompletions(t *testing.T) {
 	}
 }
 
-func TestFixedCompletionsWithCompletionHelpers(t *testing.T) {
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	// here we are mixing string, [Completion] and [CompletionWithDesc]
-	choices := []string{"apple", Completion("banana"), CompletionWithDesc("orange", "orange are orange")}
-	childCmd := &Command{
-		Use:               "child",
-		ValidArgsFunction: FixedCompletions(choices, ShellCompDirectiveNoFileComp),
-		Run:               emptyRun,
-	}
-	rootCmd.AddCommand(childCmd)
-
-	t.Run("completion with description", func(t *testing.T) {
-		output, err := executeCommand(rootCmd, ShellCompRequestCmd, "child", "a")
-		if err != nil {
-			t.Errorf("Unexpected error: %v", err)
-		}
-
-		expected := strings.Join([]string{
-			"apple",
-			"banana",
-			"orange\torange are orange", // this one has the description as expected with [ShellCompRequestCmd] flag
-			":4",
-			"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
-		}, "\n")
-
-		if output != expected {
-			t.Errorf("expected: %q, got: %q", expected, output)
-		}
-	})
-
-	t.Run("completion with no description", func(t *testing.T) {
-		output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "child", "a")
-		if err != nil {
-			t.Errorf("Unexpected error: %v", err)
-		}
-
-		expected := strings.Join([]string{
-			"apple",
-			"banana",
-			"orange", // the description is absent as expected with [ShellCompNoDescRequestCmd] flag
-			":4",
-			"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
-		}, "\n")
-
-		if output != expected {
-			t.Errorf("expected: %q, got: %q", expected, output)
-		}
-	})
-}
-
 func TestCompletionForGroupedFlags(t *testing.T) {
 	getCmd := func() *Command {
 		rootCmd := &Command{
@@ -3925,94 +3709,3 @@ func TestDisableDescriptions(t *testing.T) {
 		})
 	}
 }
-
-// A test to make sure the InitDefaultCompletionCmd function works as expected
-// in case a project calls it directly.
-func TestInitDefaultCompletionCmd(t *testing.T) {
-
-	testCases := []struct {
-		desc          string
-		hasChildCmd   bool
-		args          []string
-		expectCompCmd bool
-	}{
-		{
-			desc:          "no child command and not calling the completion command",
-			hasChildCmd:   false,
-			args:          []string{"somearg"},
-			expectCompCmd: false,
-		},
-		{
-			desc:          "no child command but calling the completion command",
-			hasChildCmd:   false,
-			args:          []string{"completion"},
-			expectCompCmd: true,
-		},
-		{
-			desc:          "no child command but calling __complete on the root command",
-			hasChildCmd:   false,
-			args:          []string{"__complete", ""},
-			expectCompCmd: false,
-		},
-		{
-			desc:          "no child command but calling __complete on the completion command",
-			hasChildCmd:   false,
-			args:          []string{"__complete", "completion", ""},
-			expectCompCmd: true,
-		},
-		{
-			desc:          "with child command",
-			hasChildCmd:   true,
-			args:          []string{"child"},
-			expectCompCmd: true,
-		},
-		{
-			desc:          "no child command not passing args",
-			hasChildCmd:   false,
-			args:          nil,
-			expectCompCmd: false,
-		},
-		{
-			desc:          "with child command not passing args",
-			hasChildCmd:   true,
-			args:          nil,
-			expectCompCmd: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.desc, func(t *testing.T) {
-			rootCmd := &Command{Use: "root", Run: emptyRun}
-			childCmd := &Command{Use: "child", Run: emptyRun}
-
-			expectedNumSubCommands := 0
-			if tc.hasChildCmd {
-				rootCmd.AddCommand(childCmd)
-				expectedNumSubCommands++
-			}
-
-			if tc.expectCompCmd {
-				expectedNumSubCommands++
-			}
-
-			if len(tc.args) > 0 && tc.args[0] == "__complete" {
-				expectedNumSubCommands++
-			}
-
-			// Setup the __complete command to mimic real world scenarios
-			rootCmd.initCompleteCmd(tc.args)
-
-			// Call the InitDefaultCompletionCmd function directly
-			if tc.args == nil {
-				rootCmd.InitDefaultCompletionCmd()
-			} else {
-				rootCmd.InitDefaultCompletionCmd(tc.args...)
-			}
-
-			// Check if the completion command was added
-			if len(rootCmd.Commands()) != expectedNumSubCommands {
-				t.Errorf("Expected %d subcommands, got %d", expectedNumSubCommands, len(rootCmd.Commands()))
-			}
-		})
-	}
-}

doc/man_docs_test.go

@@ -18,6 +18,7 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
@@ -141,6 +142,9 @@ func TestGenManSeeAlso(t *testing.T) {
 	if err := assertLineFound(scanner, ".SH SEE ALSO"); err != nil {
 		t.Fatalf("Couldn't find SEE ALSO section header: %v", err)
 	}
+	if err := assertNextLineEquals(scanner, ".PP"); err != nil {
+		t.Fatalf("First line after SEE ALSO wasn't break-indent: %v", err)
+	}
 	if err := assertNextLineEquals(scanner, `\fBroot-bbb(1)\fP, \fBroot-ccc(1)\fP`); err != nil {
 		t.Fatalf("Second line after SEE ALSO wasn't correct: %v", err)
 	}
@@ -164,7 +168,7 @@ func TestManPrintFlagsHidesShortDeprecated(t *testing.T) {
 func TestGenManTree(t *testing.T) {
 	c := &cobra.Command{Use: "do [OPTIONS] arg1 arg2"}
 	header := &GenManHeader{Section: "2"}
-	tmpdir, err := os.MkdirTemp("", "test-gen-man-tree")
+	tmpdir, err := ioutil.TempDir("", "test-gen-man-tree")
 	if err != nil {
 		t.Fatalf("Failed to create tmpdir: %s", err.Error())
 	}
@@ -215,7 +219,7 @@ func assertNextLineEquals(scanner *bufio.Scanner, expectedLine string) error {
 }
 
 func BenchmarkGenManToFile(b *testing.B) {
-	file, err := os.CreateTemp("", "")
+	file, err := ioutil.TempFile("", "")
 	if err != nil {
 		b.Fatal(err)
 	}

doc/md_docs_test.go

@@ -16,6 +16,7 @@ package doc
 
 import (
 	"bytes"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
@@ -93,7 +94,7 @@ func TestGenMdNoTag(t *testing.T) {
 
 func TestGenMdTree(t *testing.T) {
 	c := &cobra.Command{Use: "do [OPTIONS] arg1 arg2"}
-	tmpdir, err := os.MkdirTemp("", "test-gen-md-tree")
+	tmpdir, err := ioutil.TempDir("", "test-gen-md-tree")
 	if err != nil {
 		t.Fatalf("Failed to create tmpdir: %v", err)
 	}
@@ -109,7 +110,7 @@ func TestGenMdTree(t *testing.T) {
 }
 
 func BenchmarkGenMarkdownToFile(b *testing.B) {
-	file, err := os.CreateTemp("", "")
+	file, err := ioutil.TempFile("", "")
 	if err != nil {
 		b.Fatal(err)
 	}

doc/rest_docs_test.go

@@ -16,6 +16,7 @@ package doc
 
 import (
 	"bytes"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
@@ -80,7 +81,7 @@ func TestGenRSTNoTag(t *testing.T) {
 func TestGenRSTTree(t *testing.T) {
 	c := &cobra.Command{Use: "do [OPTIONS] arg1 arg2"}
 
-	tmpdir, err := os.MkdirTemp("", "test-gen-rst-tree")
+	tmpdir, err := ioutil.TempDir("", "test-gen-rst-tree")
 	if err != nil {
 		t.Fatalf("Failed to create tmpdir: %s", err.Error())
 	}
@@ -96,7 +97,7 @@ func TestGenRSTTree(t *testing.T) {
 }
 
 func BenchmarkGenReSTToFile(b *testing.B) {
-	file, err := os.CreateTemp("", "")
+	file, err := ioutil.TempFile("", "")
 	if err != nil {
 		b.Fatal(err)
 	}

doc/yaml_docs_test.go

@@ -17,6 +17,7 @@ package doc
 import (
 	"bytes"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
@@ -57,7 +58,7 @@ func TestGenYamlNoTag(t *testing.T) {
 func TestGenYamlTree(t *testing.T) {
 	c := &cobra.Command{Use: "do [OPTIONS] arg1 arg2"}
 
-	tmpdir, err := os.MkdirTemp("", "test-gen-yaml-tree")
+	tmpdir, err := ioutil.TempDir("", "test-gen-yaml-tree")
 	if err != nil {
 		t.Fatalf("Failed to create tmpdir: %s", err.Error())
 	}
@@ -84,7 +85,7 @@ func TestGenYamlDocRunnable(t *testing.T) {
 }
 
 func BenchmarkGenYamlToFile(b *testing.B) {
-	file, err := os.CreateTemp("", "")
+	file, err := ioutil.TempFile("", "")
 	if err != nil {
 		b.Fatal(err)
 	}

go.mod

@@ -3,8 +3,8 @@ module github.com/spf13/cobra
 go 1.15
 
 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.6
+	github.com/cpuguy83/go-md2man/v2 v2.0.4
 	github.com/inconshreveable/mousetrap v1.1.0
-	github.com/spf13/pflag v1.0.6
+	github.com/spf13/pflag v1.0.5
 	gopkg.in/yaml.v3 v3.0.1
 )

go.sum

@@ -1,11 +1,11 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=
-github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
-github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

powershell_completions.go

@@ -162,10 +162,7 @@ filter __%[1]s_escapeStringWithSpecialChars {
         if (-Not $Description) {
             $Description = " "
         }
-        New-Object -TypeName PSCustomObject -Property @{
-            Name = "$Name"
-            Description = "$Description"
-        }
+        @{Name="$Name";Description="$Description"}
     }
 
 
@@ -243,12 +240,7 @@ filter __%[1]s_escapeStringWithSpecialChars {
                     __%[1]s_debug "Only one completion left"
 
                     # insert space after value
-                    $CompletionText = $($comp.Name | __%[1]s_escapeStringWithSpecialChars) + $Space
-                    if ($ExecutionContext.SessionState.LanguageMode -eq "FullLanguage"){
-                        [System.Management.Automation.CompletionResult]::new($CompletionText, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
-                    } else {
-                        $CompletionText
-                    }
+                    [System.Management.Automation.CompletionResult]::new($($comp.Name | __%[1]s_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
 
                 } else {
                     # Add the proper number of spaces to align the descriptions
@@ -263,12 +255,7 @@ filter __%[1]s_escapeStringWithSpecialChars {
                         $Description = "  ($($comp.Description))"
                     }
 
-                    $CompletionText = "$($comp.Name)$Description"
-                    if ($ExecutionContext.SessionState.LanguageMode -eq "FullLanguage"){
-                        [System.Management.Automation.CompletionResult]::new($CompletionText, "$($comp.Name)$Description", 'ParameterValue', "$($comp.Description)")
-                    } else {
-                        $CompletionText
-                    }
+                    [System.Management.Automation.CompletionResult]::new("$($comp.Name)$Description", "$($comp.Name)$Description", 'ParameterValue', "$($comp.Description)")
                 }
              }
 
@@ -277,13 +264,7 @@ filter __%[1]s_escapeStringWithSpecialChars {
                 # insert space after value
                 # MenuComplete will automatically show the ToolTip of
                 # the highlighted value at the bottom of the suggestions.
-
-                $CompletionText = $($comp.Name | __%[1]s_escapeStringWithSpecialChars) + $Space
-                if ($ExecutionContext.SessionState.LanguageMode -eq "FullLanguage"){
-                    [System.Management.Automation.CompletionResult]::new($CompletionText, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
-                } else {
-                    $CompletionText
-                }
+                [System.Management.Automation.CompletionResult]::new($($comp.Name | __%[1]s_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
             }
 
             # TabCompleteNext and in case we get something unknown
@@ -291,13 +272,7 @@ filter __%[1]s_escapeStringWithSpecialChars {
                 # Like MenuComplete but we don't want to add a space here because
                 # the user need to press space anyway to get the completion.
                 # Description will not be shown because that's not possible with TabCompleteNext
-
-                $CompletionText = $($comp.Name | __%[1]s_escapeStringWithSpecialChars)
-                if ($ExecutionContext.SessionState.LanguageMode -eq "FullLanguage"){
-                    [System.Management.Automation.CompletionResult]::new($CompletionText, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
-                } else {
-                    $CompletionText
-                }
+                [System.Management.Automation.CompletionResult]::new($($comp.Name | __%[1]s_escapeStringWithSpecialChars), "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
             }
         }
 

site/content/active_help.md

@@ -3,29 +3,27 @@
 Active Help is a framework provided by Cobra which allows a program to define messages (hints, warnings, etc) that will be printed during program usage.  It aims to make it easier for your users to learn how to use your program.  If configured by the program, Active Help is printed when the user triggers shell completion.
 
 For example, 
-
-```console
-$ helm repo add [tab]
+```
+bash-5.1$ helm repo add [tab]
 You must choose a name for the repo you are adding.
 
-$ bin/helm package [tab]
+bash-5.1$ bin/helm package [tab]
 Please specify the path to the chart to package
 
-$ bin/helm package [tab][tab]
+bash-5.1$ bin/helm package [tab][tab]
 bin/    internal/    scripts/    pkg/     testdata/
 ```
 
 **Hint**: A good place to use Active Help messages is when the normal completion system does not provide any suggestions. In such cases, Active Help nicely supplements the normal shell completions to guide the user in knowing what is expected by the program.
-
 ## Supported shells
 
 Active Help is currently only supported for the following shells:
-- Bash (using [bash completion V2](completions/_index.md#bash-completion-v2) only). Note that bash 4.4 or higher is required for the prompt to appear when an Active Help message is printed.
+- Bash (using [bash completion V2](shell_completions.md#bash-completion-v2) only). Note that bash 4.4 or higher is required for the prompt to appear when an Active Help message is printed.
 - Zsh
 
 ## Adding Active Help messages
 
-As Active Help uses the shell completion system, the implementation of Active Help messages is done by enhancing custom dynamic completions.  If you are not familiar with dynamic completions, please refer to [Shell Completions](completions/_index.md).
+As Active Help uses the shell completion system, the implementation of Active Help messages is done by enhancing custom dynamic completions.  If you are not familiar with dynamic completions, please refer to [Shell Completions](shell_completions.md).
 
 Adding Active Help is done through the use of the `cobra.AppendActiveHelp(...)` function, where the program repeatedly adds Active Help messages to the list of completions.  Keep reading for details.
 
@@ -41,8 +39,8 @@ cmd := &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) error {
 		return addRepo(args)
 	},
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-		var comps []cobra.Completion
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		var comps []string
 		if len(args) == 0 {
 			comps = cobra.AppendActiveHelp(comps, "You must choose a name for the repo you are adding")
 		} else if len(args) == 1 {
@@ -54,28 +52,24 @@ cmd := &cobra.Command{
 	},
 }
 ```
-
 The example above defines the completions (none, in this specific example) as well as the Active Help messages for the `helm repo add` command.  It yields the following behavior:
-
-```console
-$ helm repo add [tab]
+```
+bash-5.1$ helm repo add [tab]
 You must choose a name for the repo you are adding
 
-$ helm repo add grafana [tab]
+bash-5.1$ helm repo add grafana [tab]
 You must specify the URL for the repo you are adding
 
-$ helm repo add grafana https://grafana.github.io/helm-charts [tab]
+bash-5.1$ helm repo add grafana https://grafana.github.io/helm-charts [tab]
 This command does not take any more arguments
 ```
-
 **Hint**: As can be seen in the above example, a good place to use Active Help messages is when the normal completion system does not provide any suggestions. In such cases, Active Help nicely supplements the normal shell completions.
 
 ### Active Help for flags
 
 Providing Active Help for flags is done in the same fashion as for nouns, but using the completion function registered for the flag.  For example:
-
 ```go
-_ = cmd.RegisterFlagCompletionFunc("version", func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+_ = cmd.RegisterFlagCompletionFunc("version", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) != 2 {
 			return cobra.AppendActiveHelp(nil, "You must first specify the chart to install before the --version flag can be completed"), cobra.ShellCompDirectiveNoFileComp
 		}
@@ -83,12 +77,11 @@ _ = cmd.RegisterFlagCompletionFunc("version", func(cmd *cobra.Command, args []st
 	})
 ```
 The example above prints an Active Help message when not enough information was given by the user to complete the `--version` flag.
-
-```console
-$ bin/helm install myrelease --version 2.0.[tab]
+```
+bash-5.1$ bin/helm install myrelease --version 2.0.[tab]
 You must first specify the chart to install before the --version flag can be completed
 
-$ bin/helm install myrelease bitnami/solr --version 2.0.[tab][tab]
+bash-5.1$ bin/helm install myrelease bitnami/solr --version 2.0.[tab][tab]
 2.0.1  2.0.2  2.0.3
 ```
 
@@ -110,12 +103,11 @@ Active Help configuration using the `cobra.GetActiveHelpConfig(cmd)` function an
 should or should not be added (instead of reading the environment variable directly).
 
 For example:
-
 ```go
-ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	activeHelpLevel := cobra.GetActiveHelpConfig(cmd)
 
-	var comps []cobra.Completion
+	var comps []string
 	if len(args) == 0 {
 		if activeHelpLevel != "off"  {
 			comps = cobra.AppendActiveHelp(comps, "You must choose a name for the repo you are adding")
@@ -132,13 +124,11 @@ ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([
 	return comps, cobra.ShellCompDirectiveNoFileComp
 },
 ```
-
 **Note 1**: If the `<PROGRAM>_ACTIVE_HELP` environment variable is set to the string "0", Cobra will automatically disable all Active Help output (even if some output was specified by the program using the `cobra.AppendActiveHelp(...)` function).  Using "0" can simplify your code in situations where you want to blindly disable Active Help without having to call `cobra.GetActiveHelpConfig(cmd)` explicitly.
 
 **Note 2**: If a user wants to disable Active Help for every single program based on Cobra, she can set the environment variable `COBRA_ACTIVE_HELP` to "0".  In this case `cobra.GetActiveHelpConfig(cmd)` will return "0" no matter what the variable `<PROGRAM>_ACTIVE_HELP` is set to.
 
 **Note 3**: If the user does not set `<PROGRAM>_ACTIVE_HELP` or `COBRA_ACTIVE_HELP` (which will be a common case), the default value for the Active Help configuration returned by `cobra.GetActiveHelpConfig(cmd)` will be the empty string. 
-
 ## Active Help with Cobra's default completion command
 
 Cobra provides a default `completion` command for programs that wish to use it.
@@ -148,11 +138,10 @@ details for your users.
 
 ## Debugging Active Help
 
-Debugging your Active Help code is done in the same way as debugging your dynamic completion code, which is with Cobra's hidden `__complete` command.  Please refer to [debugging shell completion](completions/_index.md#debugging) for details.
+Debugging your Active Help code is done in the same way as debugging your dynamic completion code, which is with Cobra's hidden `__complete` command.  Please refer to [debugging shell completion](shell_completions.md#debugging) for details.
 
 When debugging with the `__complete` command, if you want to specify different Active Help configurations, you should use the active help environment variable.  That variable is named `<PROGRAM>_ACTIVE_HELP` where any non-ASCII-alphanumeric characters are replaced by an `_`.  For example, we can test deactivating some Active Help as shown below:
-
-```console
+```
 $ HELM_ACTIVE_HELP=1 bin/helm __complete install wordpress bitnami/h<ENTER>
 bitnami/haproxy
 bitnami/harbor

site/content/completions/_index.md

@@ -8,8 +8,7 @@ The currently supported shells are:
 - PowerShell
 
 Cobra will automatically provide your program with a fully functional `completion` command,
-similarly to how it provides the `help` command. If there are no other subcommands, the
-default `completion` command will be hidden, but still functional.
+similarly to how it provides the `help` command.
 
 ## Creating your own completion command
 
@@ -178,7 +177,7 @@ cmd := &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) {
 		RunGet(args[0])
 	},
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		if len(args) != 0 {
 			return nil, cobra.ShellCompDirectiveNoFileComp
 		}
@@ -212,7 +211,7 @@ ShellCompDirectiveNoFileComp
 
 // Indicates that the returned completions should be used as file extension filters.
 // For example, to complete only files of the form *.json or *.yaml:
-//    return []cobra.Completion{"yaml", "json"}, cobra.ShellCompDirectiveFilterFileExt
+//    return []string{"yaml", "json"}, ShellCompDirectiveFilterFileExt
 // For flags, using MarkFlagFilename() and MarkPersistentFlagFilename()
 // is a shortcut to using this directive explicitly.
 //
@@ -220,13 +219,13 @@ ShellCompDirectiveFilterFileExt
 
 // Indicates that only directory names should be provided in file completion.
 // For example:
-//    return nil, cobra.ShellCompDirectiveFilterDirs
+//    return nil, ShellCompDirectiveFilterDirs
 // For flags, using MarkFlagDirname() is a shortcut to using this directive explicitly.
 //
 // To request directory names within another directory, the returned completions
 // should specify a single directory name within which to search. For example,
 // to complete directories within "themes/":
-//    return []cobra.Completion{"themes"}, cobra.ShellCompDirectiveFilterDirs
+//    return []string{"themes"}, ShellCompDirectiveFilterDirs
 //
 ShellCompDirectiveFilterDirs
 
@@ -260,7 +259,7 @@ Calling the `__complete` command directly allows you to run the Go debugger to t
 ```go
 // Prints to the completion script debug file (if BASH_COMP_DEBUG_FILE
 // is set to a file path) and optionally prints to stderr.
-cobra.CompDebug(msg string, printToStdErr bool)
+cobra.CompDebug(msg string, printToStdErr bool) {
 cobra.CompDebugln(msg string, printToStdErr bool)
 
 // Prints to the completion script debug file (if BASH_COMP_DEBUG_FILE
@@ -294,8 +293,8 @@ As for nouns, Cobra provides a way of defining dynamic completion of flags.  To
 
 ```go
 flagName := "output"
-cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	return []cobra.Completion{"json", "table", "yaml"}, cobra.ShellCompDirectiveDefault
+cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return []string{"json", "table", "yaml"}, cobra.ShellCompDirectiveDefault
 })
 ```
 Notice that calling `RegisterFlagCompletionFunc()` is done through the `command` with which the flag is associated.  In our example this dynamic completion will give results like so:
@@ -328,8 +327,8 @@ cmd.MarkFlagFilename(flagName, "yaml", "json")
 or
 ```go
 flagName := "output"
-cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	return []cobra.Completion{"yaml", "json"}, cobra.ShellCompDirectiveFilterFileExt})
+cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return []string{"yaml", "json"}, ShellCompDirectiveFilterFileExt})
 ```
 
 ### Limit flag completions to directory names
@@ -342,15 +341,15 @@ cmd.MarkFlagDirname(flagName)
 or
 ```go
 flagName := "output"
-cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
+cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	return nil, cobra.ShellCompDirectiveFilterDirs
 })
 ```
 To limit completions of flag values to directory names *within another directory* you can use a combination of `RegisterFlagCompletionFunc()` and `ShellCompDirectiveFilterDirs` like so:
 ```go
 flagName := "output"
-cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	return []cobra.Completion{"themes"}, cobra.ShellCompDirectiveFilterDirs
+cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return []string{"themes"}, cobra.ShellCompDirectiveFilterDirs
 })
 ```
 ### Descriptions for completions
@@ -371,21 +370,15 @@ $ helm s[tab]
 search  (search for a keyword in charts)  show  (show information of a chart)  status  (displays the status of the named release)
 ```
 
-Cobra allows you to add descriptions to your own completions.  Simply add the description text after each completion, following a `\t` separator. Cobra provides the helper function `CompletionWithDesc(string, string)` to create a completion with a description. This technique applies to completions returned by `ValidArgs`, `ValidArgsFunction` and `RegisterFlagCompletionFunc()`.  For example:
+Cobra allows you to add descriptions to your own completions.  Simply add the description text after each completion, following a `\t` separator.  This technique applies to completions returned by `ValidArgs`, `ValidArgsFunction` and `RegisterFlagCompletionFunc()`.  For example:
 ```go
-ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
-	return []cobra.Completion{
-		cobra.CompletionWithDesc("harbor", "An image registry"),
-		cobra.CompletionWithDesc("thanos", "Long-term metrics")
-		}, cobra.ShellCompDirectiveNoFileComp
+ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return []string{"harbor\tAn image registry", "thanos\tLong-term metrics"}, cobra.ShellCompDirectiveNoFileComp
 }}
 ```
 or
 ```go
-ValidArgs: []cobra.Completion{
-	cobra.CompletionWithDesc("bash", "Completions for bash"),
-	cobra.CompletionWithDesc("zsh", "Completions for zsh")
-	}
+ValidArgs: []string{"bash\tCompletions for bash", "zsh\tCompletions for zsh"}
 ```
 
 If you don't want to show descriptions in the completions, you can add `--no-descriptions` to the default `completion` command to disable them, like:

site/content/docgen/md.md

@@ -35,7 +35,7 @@ package main
 
 import (
 	"log"
-	"io"
+	"io/ioutil"
 	"os"
 
 	"k8s.io/kubernetes/pkg/kubectl/cmd"
@@ -45,7 +45,7 @@ import (
 )
 
 func main() {
-	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, io.Discard, io.Discard)
+	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
 	err := doc.GenMarkdownTree(kubectl, "./")
 	if err != nil {
 		log.Fatal(err)

site/content/docgen/rest.md

@@ -35,7 +35,7 @@ package main
 
 import (
 	"log"
-	"io"
+	"io/ioutil"
 	"os"
 
 	"k8s.io/kubernetes/pkg/kubectl/cmd"
@@ -45,7 +45,7 @@ import (
 )
 
 func main() {
-	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, io.Discard, io.Discard)
+	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
 	err := doc.GenReSTTree(kubectl, "./")
 	if err != nil {
 		log.Fatal(err)

site/content/docgen/yaml.md

@@ -34,7 +34,7 @@ This program can actually generate docs for the kubectl command in the kubernete
 package main
 
 import (
-	"io"
+	"io/ioutil"
 	"log"
 	"os"
 
@@ -45,7 +45,7 @@ import (
 )
 
 func main() {
-	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, io.Discard, io.Discard)
+	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
 	err := doc.GenYamlTree(kubectl, "./")
 	if err != nil {
 		log.Fatal(err)

site/content/projects_using_cobra.md

@@ -3,12 +3,10 @@
 - [Allero](https://github.com/allero-io/allero)
 - [Arewefastyet](https://benchmark.vitess.io)
 - [Arduino CLI](https://github.com/arduino/arduino-cli)
-- [Azion](https://github.com/aziontech/azion)
 - [Bleve](https://blevesearch.com/)
 - [Cilium](https://cilium.io/)
 - [CloudQuery](https://github.com/cloudquery/cloudquery)
 - [CockroachDB](https://www.cockroachlabs.com/)
-- [Conduit](https://github.com/conduitio/conduit)
 - [Constellation](https://github.com/edgelesssys/constellation)
 - [Cosmos SDK](https://github.com/cosmos/cosmos-sdk)
 - [Datree](https://github.com/datreeio/datree)

site/content/user_guide.md

@@ -3,7 +3,7 @@
 While you are welcome to provide your own organization, typically a Cobra-based
 application will follow the following organizational structure:
 
-```console
+```test
   ▾ appName/
     ▾ cmd/
         add.go
@@ -18,7 +18,9 @@ In a Cobra app, typically the main.go file is very bare. It serves one purpose:
 ```go
 package main
 
-import "{pathToYourApp}/cmd"
+import (
+  "{pathToYourApp}/cmd"
+)
 
 func main() {
   cmd.Execute()
@@ -146,7 +148,9 @@ In a Cobra app, typically the main.go file is very bare. It serves one purpose:
 ```go
 package main
 
-import "{pathToYourApp}/cmd"
+import (
+  "{pathToYourApp}/cmd"
+)
 
 func main() {
   cmd.Execute()
@@ -193,7 +197,7 @@ its own go package.
 The suggested approach is for the parent command to use `AddCommand` to add its most immediate
 subcommands. For example, consider the following directory structure:
 
-```console
+```text
 ├── cmd
 │   ├── root.go
 │   └── sub1
@@ -504,7 +508,6 @@ create' is called.  Every command will automatically have the '--help' flag adde
 The following output is automatically generated by Cobra. Nothing beyond the
 command and flag definitions are needed.
 
-```console
     $ cobra-cli help
 
     Cobra is a CLI library for Go that empowers applications.
@@ -528,7 +531,7 @@ Flags:
           --viper            use Viper for configuration
 
     Use "cobra-cli [command] --help" for more information about a command.
-```
+
 
 Help is just a command like any other. There is no special logic or behavior
 around it. In fact, you can provide your own if you want.
@@ -554,9 +557,6 @@ cmd.SetHelpTemplate(s string)
 
 The latter two will also apply to any children commands.
 
-Note that templates specified with `SetHelpTemplate` are evaluated using
-`text/template` which can increase the size of the compiled executable.
-
 ## Usage Message
 
 When the user provides an invalid flag or invalid command, Cobra responds by
@@ -566,7 +566,6 @@ showing the user the 'usage'.
 You may recognize this from the help above. That's because the default help
 embeds the usage as part of its output.
 
-```console
     $ cobra-cli --invalid
     Error: unknown flag: --invalid
     Usage:
@@ -586,10 +585,8 @@ Flags:
           --viper            use Viper for configuration
 
     Use "cobra [command] --help" for more information about a command.
-```
 
 ### Defining your own usage
-
 You can provide your own usage function or template for Cobra to use.
 Like help, the function and template are overridable through public methods:
 
@@ -598,9 +595,6 @@ cmd.SetUsageFunc(f func(*Command) error)
 cmd.SetUsageTemplate(s string)
 ```
 
-Note that templates specified with `SetUsageTemplate` are evaluated using
-`text/template` which can increase the size of the compiled executable.
-
 ## Version Flag
 
 Cobra adds a top-level '--version' flag if the Version field is set on the root command.
@@ -608,9 +602,6 @@ Running an application with the '--version' flag will print the version to stdou
 the version template. The template can be customized using the
 `cmd.SetVersionTemplate(s string)` function.
 
-Note that templates specified with `SetVersionTemplate` are evaluated using
-`text/template` which can increase the size of the compiled executable.
-
 ## Error Message Prefix
 
 Cobra prints an error message when receiving a non-nil error value.
@@ -710,7 +701,7 @@ Set `EnableTraverseRunHooks` global variable to `true` if you want to execute al
 
 Cobra will print automatic suggestions when "unknown command" errors happen. This allows Cobra to behave similarly to the `git` command when a typo happens. For example:
 
-```console
+```
 $ hugo srever
 Error: unknown command "srever" for "hugo"
 
@@ -737,7 +728,7 @@ command.SuggestionsMinimumDistance = 1
 You can also explicitly set names for which a given command will be suggested using the `SuggestFor` attribute. This allows suggestions for strings that are not close in terms of string distance, but make sense in your set of commands but for which
 you don't want aliases. Example:
 
-```console
+```bash
 $ kubectl remove
 Error: unknown command "remove" for "kubectl"
 
@@ -802,7 +793,7 @@ func main() {
 
 Example run as a kubectl plugin:
 
-```console
+```bash
 $ kubectl myplugin
 Usage:
   kubectl myplugin [command]