mirror of
https://github.com/spf13/cobra
synced 2024-06-25 05:09:10 +00:00
Rename BashCompDirectives to ShellCompDirectives (#1082)
Since the completion directives will be used for all shells, and that these names will be consumed by users, this is a more appropriate name. Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
This commit is contained in:
Marc Khouzam
GitHub
parent
b80aeb17fc
commit
b84ef40338
|
|
@ -344,7 +344,7 @@ __%[1]s_handle_word()
|
|||
__%[1]s_handle_word
|
||||
}
|
||||
|
||||
`, name, CompRequestCmd, BashCompDirectiveError, BashCompDirectiveNoSpace, BashCompDirectiveNoFileComp))
|
||||
`, name, ShellCompRequestCmd, ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp))
|
||||
}
|
||||
|
||||
func writePostscript(buf *bytes.Buffer, name string) {
|
||||
|
|
|
|||
|
|
@ -128,11 +128,11 @@ cmd := &cobra.Command{
|
|||
RunE: func(cmd *cobra.Command, args []string) {
|
||||
RunGet(args[0])
|
||||
},
|
||||
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.BashCompDirective) {
|
||||
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
|
||||
if len(args) != 0 {
|
||||
return nil, cobra.BashCompDirectiveNoFileComp
|
||||
return nil, cobra.ShellCompDirectiveNoFileComp
|
||||
}
|
||||
return getReleasesFromCluster(toComplete), cobra.BashCompDirectiveNoFileComp
|
||||
return getReleasesFromCluster(toComplete), cobra.ShellCompDirectiveNoFileComp
|
||||
},
|
||||
}
|
||||
```
|
||||
|
|
@ -143,20 +143,20 @@ Notice we put the `ValidArgsFunction` on the `status` subcommand. Let's assume t
|
|||
# helm status [tab][tab]
|
||||
harbor notary rook thanos
|
||||
```
|
||||
You may have noticed the use of `cobra.BashCompDirective`. These directives are bit fields allowing to control some shell completion behaviors for your particular completion. You can combine them with the bit-or operator such as `cobra.BashCompDirectiveNoSpace | cobra.BashCompDirectiveNoFileComp`
|
||||
You may have noticed the use of `cobra.ShellCompDirective`. These directives are bit fields allowing to control some shell completion behaviors for your particular completion. You can combine them with the bit-or operator such as `cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp`
|
||||
```go
|
||||
// Indicates an error occurred and completions should be ignored.
|
||||
BashCompDirectiveError
|
||||
ShellCompDirectiveError
|
||||
// Indicates that the shell should not add a space after the completion,
|
||||
// even if there is a single completion provided.
|
||||
BashCompDirectiveNoSpace
|
||||
ShellCompDirectiveNoSpace
|
||||
// Indicates that the shell should not provide file completion even when
|
||||
// no completion is provided.
|
||||
// This currently does not work for zsh or bash < 4
|
||||
BashCompDirectiveNoFileComp
|
||||
ShellCompDirectiveNoFileComp
|
||||
// Indicates that the shell will perform its default behavior after completions
|
||||
// have been provided (this implies !BashCompDirectiveNoSpace && !BashCompDirectiveNoFileComp).
|
||||
BashCompDirectiveDefault
|
||||
// have been provided (this implies !ShellCompDirectiveNoSpace && !ShellCompDirectiveNoFileComp).
|
||||
ShellCompDirectiveDefault
|
||||
```
|
||||
|
||||
When using the `ValidArgsFunction`, Cobra will call your registered function after having parsed all flags and arguments provided in the command-line. You therefore don't need to do this parsing yourself. For example, when a user calls `helm status --namespace my-rook-ns [tab][tab]`, Cobra will call your registered `ValidArgsFunction` after having parsed the `--namespace` flag, as it would have done when calling the `RunE` function.
|
||||
|
|
@ -168,7 +168,7 @@ Cobra achieves dynamic completions written in Go through the use of a hidden com
|
|||
# helm __complete status har<ENTER>
|
||||
harbor
|
||||
:4
|
||||
Completion ended with directive: BashCompDirectiveNoFileComp # This is on stderr
|
||||
Completion ended with directive: ShellCompDirectiveNoFileComp # This is on stderr
|
||||
```
|
||||
***Important:*** If the noun to complete is empty, you must pass an empty parameter to the `__complete` command:
|
||||
```bash
|
||||
|
|
@ -178,7 +178,7 @@ notary
|
|||
rook
|
||||
thanos
|
||||
:4
|
||||
Completion ended with directive: BashCompDirectiveNoFileComp # This is on stderr
|
||||
Completion ended with directive: ShellCompDirectiveNoFileComp # This is on stderr
|
||||
```
|
||||
Calling the `__complete` command directly allows you to run the Go debugger to troubleshoot your code. You can also add printouts to your code; Cobra provides the following functions to use for printouts in Go completion code:
|
||||
```go
|
||||
|
|
@ -307,8 +307,8 @@ To provide a Go function that Cobra will execute when it needs the list of compl
|
|||
|
||||
```go
|
||||
flagName := "output"
|
||||
cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.BashCompDirective) {
|
||||
return []string{"json", "table", "yaml"}, cobra.BashCompDirectiveDefault
|
||||
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:
|
||||
|
|
@ -327,7 +327,7 @@ json
|
|||
table
|
||||
yaml
|
||||
:4
|
||||
Completion ended with directive: BashCompDirectiveNoFileComp # This is on stderr
|
||||
Completion ended with directive: ShellCompDirectiveNoFileComp # This is on stderr
|
||||
```
|
||||
***Important:*** You should **not** leave traces that print to stdout in your completion code as they will be interpreted as completion choices by the completion script. Instead, use the cobra-provided debugging traces functions mentioned in the above section.
|
||||
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ type Command struct {
|
|||
// ValidArgsFunction is an optional function that provides valid non-flag arguments for bash completion.
|
||||
// It is a dynamic version of using ValidArgs.
|
||||
// Only one of ValidArgs and ValidArgsFunction can be used for a command.
|
||||
ValidArgsFunction func(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective)
|
||||
ValidArgsFunction func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
|
||||
|
||||
// Expected arguments
|
||||
Args PositionalArgs
|
||||
|
|
|
|||
|
|
@ -9,37 +9,37 @@ import (
|
|||
"github.com/spf13/pflag"
|
||||
)
|
||||
|
||||
// CompRequestCmd is the name of the hidden command that is used to request
|
||||
// ShellCompRequestCmd is the name of the hidden command that is used to request
|
||||
// completion results from the program. It is used by the shell completion script.
|
||||
const CompRequestCmd = "__complete"
|
||||
const ShellCompRequestCmd = "__complete"
|
||||
|
||||
// Global map of flag completion functions.
|
||||
var flagCompletionFunctions = map[*pflag.Flag]func(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective){}
|
||||
var flagCompletionFunctions = map[*pflag.Flag]func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective){}
|
||||
|
||||
// BashCompDirective is a bit map representing the different behaviors the shell
|
||||
// ShellCompDirective is a bit map representing the different behaviors the shell
|
||||
// can be instructed to have once completions have been provided.
|
||||
type BashCompDirective int
|
||||
type ShellCompDirective int
|
||||
|
||||
const (
|
||||
// BashCompDirectiveError indicates an error occurred and completions should be ignored.
|
||||
BashCompDirectiveError BashCompDirective = 1 << iota
|
||||
// ShellCompDirectiveError indicates an error occurred and completions should be ignored.
|
||||
ShellCompDirectiveError ShellCompDirective = 1 << iota
|
||||
|
||||
// BashCompDirectiveNoSpace indicates that the shell should not add a space
|
||||
// ShellCompDirectiveNoSpace indicates that the shell should not add a space
|
||||
// after the completion even if there is a single completion provided.
|
||||
BashCompDirectiveNoSpace
|
||||
ShellCompDirectiveNoSpace
|
||||
|
||||
// BashCompDirectiveNoFileComp indicates that the shell should not provide
|
||||
// ShellCompDirectiveNoFileComp indicates that the shell should not provide
|
||||
// file completion even when no completion is provided.
|
||||
// This currently does not work for zsh or bash < 4
|
||||
BashCompDirectiveNoFileComp
|
||||
ShellCompDirectiveNoFileComp
|
||||
|
||||
// BashCompDirectiveDefault indicates to let the shell perform its default
|
||||
// ShellCompDirectiveDefault indicates to let the shell perform its default
|
||||
// behavior after completions have been provided.
|
||||
BashCompDirectiveDefault BashCompDirective = 0
|
||||
ShellCompDirectiveDefault ShellCompDirective = 0
|
||||
)
|
||||
|
||||
// RegisterFlagCompletionFunc should be called to register a function to provide completion for a flag.
|
||||
func (c *Command) RegisterFlagCompletionFunc(flagName string, f func(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective)) 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)
|
||||
|
|
@ -52,23 +52,23 @@ func (c *Command) RegisterFlagCompletionFunc(flagName string, f func(cmd *Comman
|
|||
}
|
||||
|
||||
// Returns a string listing the different directive enabled in the specified parameter
|
||||
func (d BashCompDirective) string() string {
|
||||
func (d ShellCompDirective) string() string {
|
||||
var directives []string
|
||||
if d&BashCompDirectiveError != 0 {
|
||||
directives = append(directives, "BashCompDirectiveError")
|
||||
if d&ShellCompDirectiveError != 0 {
|
||||
directives = append(directives, "ShellCompDirectiveError")
|
||||
}
|
||||
if d&BashCompDirectiveNoSpace != 0 {
|
||||
directives = append(directives, "BashCompDirectiveNoSpace")
|
||||
if d&ShellCompDirectiveNoSpace != 0 {
|
||||
directives = append(directives, "ShellCompDirectiveNoSpace")
|
||||
}
|
||||
if d&BashCompDirectiveNoFileComp != 0 {
|
||||
directives = append(directives, "BashCompDirectiveNoFileComp")
|
||||
if d&ShellCompDirectiveNoFileComp != 0 {
|
||||
directives = append(directives, "ShellCompDirectiveNoFileComp")
|
||||
}
|
||||
if len(directives) == 0 {
|
||||
directives = append(directives, "BashCompDirectiveDefault")
|
||||
directives = append(directives, "ShellCompDirectiveDefault")
|
||||
}
|
||||
|
||||
if d > BashCompDirectiveError+BashCompDirectiveNoSpace+BashCompDirectiveNoFileComp {
|
||||
return fmt.Sprintf("ERROR: unexpected BashCompDirective value: %d", d)
|
||||
if d > ShellCompDirectiveError+ShellCompDirectiveNoSpace+ShellCompDirectiveNoFileComp {
|
||||
return fmt.Sprintf("ERROR: unexpected ShellCompDirective value: %d", d)
|
||||
}
|
||||
return strings.Join(directives, ", ")
|
||||
}
|
||||
|
|
@ -76,14 +76,14 @@ func (d BashCompDirective) string() string {
|
|||
// Adds a special hidden command that can be used to request custom completions.
|
||||
func (c *Command) initCompleteCmd(args []string) {
|
||||
completeCmd := &Command{
|
||||
Use: fmt.Sprintf("%s [command-line]", CompRequestCmd),
|
||||
Use: fmt.Sprintf("%s [command-line]", ShellCompRequestCmd),
|
||||
DisableFlagsInUseLine: true,
|
||||
Hidden: true,
|
||||
DisableFlagParsing: true,
|
||||
Args: MinimumNArgs(1),
|
||||
Short: "Request shell completion choices for the specified command-line",
|
||||
Long: fmt.Sprintf("%[2]s is a special command that is used by the shell completion logic\n%[1]s",
|
||||
"to request completion choices for the specified command-line.", CompRequestCmd),
|
||||
"to request completion choices for the specified command-line.", ShellCompRequestCmd),
|
||||
Run: func(cmd *Command, args []string) {
|
||||
finalCmd, completions, directive, err := cmd.getCompletions(args)
|
||||
if err != nil {
|
||||
|
|
@ -98,8 +98,8 @@ func (c *Command) initCompleteCmd(args []string) {
|
|||
fmt.Fprintln(finalCmd.OutOrStdout(), comp)
|
||||
}
|
||||
|
||||
if directive > BashCompDirectiveError+BashCompDirectiveNoSpace+BashCompDirectiveNoFileComp {
|
||||
directive = BashCompDirectiveDefault
|
||||
if directive > ShellCompDirectiveError+ShellCompDirectiveNoSpace+ShellCompDirectiveNoFileComp {
|
||||
directive = ShellCompDirectiveDefault
|
||||
}
|
||||
|
||||
// As the last printout, print the completion directive for the completion script to parse.
|
||||
|
|
@ -114,7 +114,7 @@ func (c *Command) initCompleteCmd(args []string) {
|
|||
}
|
||||
c.AddCommand(completeCmd)
|
||||
subCmd, _, err := c.Find(args)
|
||||
if err != nil || subCmd.Name() != CompRequestCmd {
|
||||
if err != nil || subCmd.Name() != ShellCompRequestCmd {
|
||||
// Only create this special command if it is actually being called.
|
||||
// This reduces possible side-effects of creating such a command;
|
||||
// for example, having this command would cause problems to a
|
||||
|
|
@ -124,7 +124,7 @@ func (c *Command) initCompleteCmd(args []string) {
|
|||
}
|
||||
}
|
||||
|
||||
func (c *Command) getCompletions(args []string) (*Command, []string, BashCompDirective, error) {
|
||||
func (c *Command) getCompletions(args []string) (*Command, []string, ShellCompDirective, error) {
|
||||
var completions []string
|
||||
|
||||
// The last argument, which is not completely typed by the user,
|
||||
|
|
@ -136,7 +136,7 @@ func (c *Command) getCompletions(args []string) (*Command, []string, BashCompDir
|
|||
finalCmd, finalArgs, err := c.Root().Find(trimmedArgs)
|
||||
if err != nil {
|
||||
// Unable to find the real command. E.g., <program> someInvalidCmd <TAB>
|
||||
return c, completions, BashCompDirectiveDefault, fmt.Errorf("Unable to find a command for arguments: %v", trimmedArgs)
|
||||
return c, completions, ShellCompDirectiveDefault, fmt.Errorf("Unable to find a command for arguments: %v", trimmedArgs)
|
||||
}
|
||||
|
||||
var flag *pflag.Flag
|
||||
|
|
@ -146,13 +146,13 @@ func (c *Command) getCompletions(args []string) (*Command, []string, BashCompDir
|
|||
flag, finalArgs, toComplete, err = checkIfFlagCompletion(finalCmd, finalArgs, toComplete)
|
||||
if err != nil {
|
||||
// Error while attempting to parse flags
|
||||
return finalCmd, completions, BashCompDirectiveDefault, err
|
||||
return finalCmd, completions, ShellCompDirectiveDefault, err
|
||||
}
|
||||
}
|
||||
|
||||
// Parse the flags and extract the arguments to prepare for calling the completion function
|
||||
if err = finalCmd.ParseFlags(finalArgs); err != nil {
|
||||
return finalCmd, completions, BashCompDirectiveDefault, fmt.Errorf("Error while parsing flags from args %v: %s", finalArgs, err.Error())
|
||||
return finalCmd, completions, ShellCompDirectiveDefault, fmt.Errorf("Error while parsing flags from args %v: %s", finalArgs, err.Error())
|
||||
}
|
||||
|
||||
// We only remove the flags from the arguments if DisableFlagParsing is not set.
|
||||
|
|
@ -162,7 +162,7 @@ func (c *Command) getCompletions(args []string) (*Command, []string, BashCompDir
|
|||
}
|
||||
|
||||
// Find the completion function for the flag or command
|
||||
var completionFn func(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective)
|
||||
var completionFn func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective)
|
||||
if flag != nil {
|
||||
completionFn = flagCompletionFunctions[flag]
|
||||
} else {
|
||||
|
|
@ -170,7 +170,7 @@ func (c *Command) getCompletions(args []string) (*Command, []string, BashCompDir
|
|||
}
|
||||
if completionFn == nil {
|
||||
// Go custom completion not supported/needed for this flag or command
|
||||
return finalCmd, completions, BashCompDirectiveDefault, nil
|
||||
return finalCmd, completions, ShellCompDirectiveDefault, nil
|
||||
}
|
||||
|
||||
// Call the registered completion function to get the completions
|
||||
|
|
|
|||
|
|
@ -6,9 +6,9 @@ import (
|
|||
"testing"
|
||||
)
|
||||
|
||||
func validArgsFunc(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective) {
|
||||
func validArgsFunc(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
|
||||
if len(args) != 0 {
|
||||
return nil, BashCompDirectiveNoFileComp
|
||||
return nil, ShellCompDirectiveNoFileComp
|
||||
}
|
||||
|
||||
var completions []string
|
||||
|
|
@ -17,12 +17,12 @@ func validArgsFunc(cmd *Command, args []string, toComplete string) ([]string, Ba
|
|||
completions = append(completions, comp)
|
||||
}
|
||||
}
|
||||
return completions, BashCompDirectiveDefault
|
||||
return completions, ShellCompDirectiveDefault
|
||||
}
|
||||
|
||||
func validArgsFunc2(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective) {
|
||||
func validArgsFunc2(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
|
||||
if len(args) != 0 {
|
||||
return nil, BashCompDirectiveNoFileComp
|
||||
return nil, ShellCompDirectiveNoFileComp
|
||||
}
|
||||
|
||||
var completions []string
|
||||
|
|
@ -31,7 +31,7 @@ func validArgsFunc2(cmd *Command, args []string, toComplete string) ([]string, B
|
|||
completions = append(completions, comp)
|
||||
}
|
||||
}
|
||||
return completions, BashCompDirectiveDefault
|
||||
return completions, ShellCompDirectiveDefault
|
||||
}
|
||||
|
||||
func TestValidArgsFuncSingleCmd(t *testing.T) {
|
||||
|
|
@ -42,7 +42,7 @@ func TestValidArgsFuncSingleCmd(t *testing.T) {
|
|||
}
|
||||
|
||||
// Test completing an empty string
|
||||
output, err := executeCommand(rootCmd, CompRequestCmd, "")
|
||||
output, err := executeCommand(rootCmd, ShellCompRequestCmd, "")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -51,14 +51,14 @@ func TestValidArgsFuncSingleCmd(t *testing.T) {
|
|||
"one",
|
||||
"two",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Check completing with a prefix
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -66,7 +66,7 @@ func TestValidArgsFuncSingleCmd(t *testing.T) {
|
|||
expected = strings.Join([]string{
|
||||
"two",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
|
|
@ -86,14 +86,14 @@ func TestValidArgsFuncSingleCmdInvalidArg(t *testing.T) {
|
|||
}
|
||||
|
||||
// Check completing with wrong number of args
|
||||
output, err := executeCommand(rootCmd, CompRequestCmd, "unexpectedArg", "t")
|
||||
output, err := executeCommand(rootCmd, ShellCompRequestCmd, "unexpectedArg", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
||||
expected := strings.Join([]string{
|
||||
":4",
|
||||
"Completion ended with directive: BashCompDirectiveNoFileComp", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
|
|
@ -115,7 +115,7 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
|
|||
rootCmd.AddCommand(child1Cmd, child2Cmd)
|
||||
|
||||
// Test completion of first sub-command with empty argument
|
||||
output, err := executeCommand(rootCmd, CompRequestCmd, "child1", "")
|
||||
output, err := executeCommand(rootCmd, ShellCompRequestCmd, "child1", "")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -124,14 +124,14 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
|
|||
"one",
|
||||
"two",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Test completion of first sub-command with a prefix to complete
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "child1", "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "child1", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -139,28 +139,28 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
|
|||
expected = strings.Join([]string{
|
||||
"two",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Check completing with wrong number of args
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "child1", "unexpectedArg", "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "child1", "unexpectedArg", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
||||
expected = strings.Join([]string{
|
||||
":4",
|
||||
"Completion ended with directive: BashCompDirectiveNoFileComp", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Test completion of second sub-command with empty argument
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "child2", "")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "child2", "")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -169,13 +169,13 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
|
|||
"three",
|
||||
"four",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "child2", "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "child2", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -183,21 +183,21 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
|
|||
expected = strings.Join([]string{
|
||||
"three",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Check completing with wrong number of args
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "child2", "unexpectedArg", "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "child2", "unexpectedArg", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
||||
expected = strings.Join([]string{
|
||||
":4",
|
||||
"Completion ended with directive: BashCompDirectiveNoFileComp", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
|
|
@ -215,7 +215,7 @@ func TestValidArgsFuncAliases(t *testing.T) {
|
|||
rootCmd.AddCommand(child)
|
||||
|
||||
// Test completion of first sub-command with empty argument
|
||||
output, err := executeCommand(rootCmd, CompRequestCmd, "son", "")
|
||||
output, err := executeCommand(rootCmd, ShellCompRequestCmd, "son", "")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -224,14 +224,14 @@ func TestValidArgsFuncAliases(t *testing.T) {
|
|||
"one",
|
||||
"two",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Test completion of first sub-command with a prefix to complete
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "daughter", "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "daughter", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -239,21 +239,21 @@ func TestValidArgsFuncAliases(t *testing.T) {
|
|||
expected = strings.Join([]string{
|
||||
"two",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Check completing with wrong number of args
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "son", "unexpectedArg", "t")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "son", "unexpectedArg", "t")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
||||
expected = strings.Join([]string{
|
||||
":4",
|
||||
"Completion ended with directive: BashCompDirectiveNoFileComp", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
|
|
@ -297,28 +297,28 @@ func TestFlagCompletionInGo(t *testing.T) {
|
|||
Run: emptyRun,
|
||||
}
|
||||
rootCmd.Flags().IntP("introot", "i", -1, "help message for flag introot")
|
||||
rootCmd.RegisterFlagCompletionFunc("introot", func(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective) {
|
||||
rootCmd.RegisterFlagCompletionFunc("introot", func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
|
||||
completions := []string{}
|
||||
for _, comp := range []string{"1", "2", "10"} {
|
||||
if strings.HasPrefix(comp, toComplete) {
|
||||
completions = append(completions, comp)
|
||||
}
|
||||
}
|
||||
return completions, BashCompDirectiveDefault
|
||||
return completions, ShellCompDirectiveDefault
|
||||
})
|
||||
rootCmd.Flags().String("filename", "", "Enter a filename")
|
||||
rootCmd.RegisterFlagCompletionFunc("filename", func(cmd *Command, args []string, toComplete string) ([]string, BashCompDirective) {
|
||||
rootCmd.RegisterFlagCompletionFunc("filename", func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
|
||||
completions := []string{}
|
||||
for _, comp := range []string{"file.yaml", "myfile.json", "file.xml"} {
|
||||
if strings.HasPrefix(comp, toComplete) {
|
||||
completions = append(completions, comp)
|
||||
}
|
||||
}
|
||||
return completions, BashCompDirectiveNoSpace | BashCompDirectiveNoFileComp
|
||||
return completions, ShellCompDirectiveNoSpace | ShellCompDirectiveNoFileComp
|
||||
})
|
||||
|
||||
// Test completing an empty string
|
||||
output, err := executeCommand(rootCmd, CompRequestCmd, "--introot", "")
|
||||
output, err := executeCommand(rootCmd, ShellCompRequestCmd, "--introot", "")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -328,14 +328,14 @@ func TestFlagCompletionInGo(t *testing.T) {
|
|||
"2",
|
||||
"10",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Check completing with a prefix
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "--introot", "1")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "--introot", "1")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -344,14 +344,14 @@ func TestFlagCompletionInGo(t *testing.T) {
|
|||
"1",
|
||||
"10",
|
||||
":0",
|
||||
"Completion ended with directive: BashCompDirectiveDefault", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Test completing an empty string
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "--filename", "")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "--filename", "")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -361,14 +361,14 @@ func TestFlagCompletionInGo(t *testing.T) {
|
|||
"myfile.json",
|
||||
"file.xml",
|
||||
":6",
|
||||
"Completion ended with directive: BashCompDirectiveNoSpace, BashCompDirectiveNoFileComp", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
}
|
||||
|
||||
// Check completing with a prefix
|
||||
output, err = executeCommand(rootCmd, CompRequestCmd, "--filename", "f")
|
||||
output, err = executeCommand(rootCmd, ShellCompRequestCmd, "--filename", "f")
|
||||
if err != nil {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
|
|
@ -377,7 +377,7 @@ func TestFlagCompletionInGo(t *testing.T) {
|
|||
"file.yaml",
|
||||
"file.xml",
|
||||
":6",
|
||||
"Completion ended with directive: BashCompDirectiveNoSpace, BashCompDirectiveNoFileComp", ""}, "\n")
|
||||
"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", ""}, "\n")
|
||||
|
||||
if output != expected {
|
||||
t.Errorf("expected: %q, got: %q", expected, output)
|
||||
|
|
|
|||
Loading…
Reference in a new issue