From 2f276e301446093e63850fbfef3c81d8f9ed7461 Mon Sep 17 00:00:00 2001
From: Jack Wright <ayax79@gmail.com>
Date: Sun, 27 Nov 2022 13:46:13 -0800
Subject: [PATCH] Incorporating pull request feedback. - Renamed completer to
 be cobra_completer to match docs - Added whitespace after each completion -
 Implemented ShellCompDirectiveError, ShellCompDirectiveNoSpace,
 ShellCompDirectiveNoFileComp - Disabled active help as it isn't supported by
 nushell - Added nushell to the default completion command

---
 completions.go              |  39 +++-
 completions_test.go         | 425 ++++++++++++++++++++++++------------
 nushell_completions.go      |  51 +++--
 nushell_completions_test.go |   2 +-
 4 files changed, 358 insertions(+), 159 deletions(-)

diff --git a/completions.go b/completions.go
index 8fccdaf..fee40e1 100644
--- a/completions.go
+++ b/completions.go
@@ -836,14 +836,47 @@ to your powershell profile.
 				return cmd.Root().GenPowerShellCompletion(out)
 			}
 			return cmd.Root().GenPowerShellCompletionWithDesc(out)
-
 		},
 	}
 	if haveNoDescFlag {
 		powershell.Flags().BoolVar(&noDesc, compCmdNoDescFlagName, compCmdNoDescFlagDefault, compCmdNoDescFlagDesc)
 	}
 
-	completionCmd.AddCommand(bash, zsh, fish, powershell)
+	nushell := &Command{
+		Use:   "nushell",
+		Short: fmt.Sprintf(shortDesc, "nushell"),
+		Long: fmt.Sprintf(`Generate the autocompletion script for nushell.
+
+To configure completions:
+      
+  # 1. Copy the output of the command below:
+  > %[1]s completion nushell 
+
+  # 2. Edit the nushell config file:
+  > config nu
+
+  # 3. Paste above the "let-env config" line.
+
+  # 4. Change the config block's external_completer line to be 
+  external_completer: $cobra_completer
+
+  # 5. You will need to start a new shell for this setup to take effect.
+
+`, c.Root().Name()),
+		Args:              NoArgs,
+		ValidArgsFunction: NoFileCompletions,
+		RunE: func(cmd *Command, args []string) error {
+			if noDesc {
+				return cmd.Root().GenPowerShellCompletion(out)
+			}
+			return cmd.Root().GenPowerShellCompletionWithDesc(out)
+		},
+	}
+	if haveNoDescFlag {
+		nushell.Flags().BoolVar(&noDesc, compCmdNoDescFlagName, compCmdNoDescFlagDefault, compCmdNoDescFlagDesc)
+	}
+
+	completionCmd.AddCommand(bash, zsh, fish, powershell, nushell)
 }
 
 func findFlag(cmd *Command, name string) *pflag.Flag {
@@ -876,7 +909,7 @@ func CompDebug(msg string, printToStdErr bool) {
 	// variable BASH_COMP_DEBUG_FILE to the path of some file to be used.
 	if path := os.Getenv("BASH_COMP_DEBUG_FILE"); path != "" {
 		f, err := os.OpenFile(path,
-			os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+			os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
 		if err == nil {
 			defer f.Close()
 			WriteStringAndCheck(f, msg)
diff --git a/completions_test.go b/completions_test.go
index df153fc..5ee3a00 100644
--- a/completions_test.go
+++ b/completions_test.go
@@ -98,7 +98,8 @@ func TestCmdNameCompletionInGo(t *testing.T) {
 		"help",
 		"secondChild",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -113,7 +114,8 @@ func TestCmdNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"secondChild",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -128,7 +130,8 @@ func TestCmdNameCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -147,7 +150,8 @@ func TestCmdNameCompletionInGo(t *testing.T) {
 		"help\tHelp about any command",
 		"secondChild",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -187,7 +191,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 
 	expected := strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -203,7 +208,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -225,7 +231,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 		"completion",
 		"help",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -247,7 +254,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"childCmd2",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -262,7 +270,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -278,7 +287,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -295,7 +305,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"childCmd2",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -312,7 +323,8 @@ func TestNoCmdNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"childCmd2",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -337,7 +349,8 @@ func TestValidArgsCompletionInGo(t *testing.T) {
 		"two",
 		"three",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -352,7 +365,8 @@ func TestValidArgsCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"one",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -366,7 +380,8 @@ func TestValidArgsCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -400,7 +415,8 @@ func TestValidArgsAndCmdCompletionInGo(t *testing.T) {
 		"one",
 		"two",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -416,7 +432,8 @@ func TestValidArgsAndCmdCompletionInGo(t *testing.T) {
 		"thechild",
 		"two",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -451,7 +468,8 @@ func TestValidArgsFuncAndCmdCompletionInGo(t *testing.T) {
 		"one",
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -467,7 +485,8 @@ func TestValidArgsFuncAndCmdCompletionInGo(t *testing.T) {
 		"thechild",
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -483,7 +502,8 @@ func TestValidArgsFuncAndCmdCompletionInGo(t *testing.T) {
 		"thechild\tThe child command",
 		"two\tThe second",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -517,7 +537,8 @@ func TestFlagNameCompletionInGo(t *testing.T) {
 		"completion",
 		"help",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -537,7 +558,8 @@ func TestFlagNameCompletionInGo(t *testing.T) {
 		"--second",
 		"-s",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -552,7 +574,8 @@ func TestFlagNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"--first",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -573,7 +596,8 @@ func TestFlagNameCompletionInGo(t *testing.T) {
 		"--version",
 		"-v",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -608,7 +632,8 @@ func TestFlagNameCompletionInGoWithDesc(t *testing.T) {
 		"completion\tGenerate the autocompletion script for the specified shell",
 		"help\tHelp about any command",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -628,7 +653,8 @@ func TestFlagNameCompletionInGoWithDesc(t *testing.T) {
 		"--second\tsecond flag",
 		"-s\tsecond flag",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -643,7 +669,8 @@ func TestFlagNameCompletionInGoWithDesc(t *testing.T) {
 	expected = strings.Join([]string{
 		"--first\tfirst flag",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -664,7 +691,8 @@ func TestFlagNameCompletionInGoWithDesc(t *testing.T) {
 		"--version\tversion for childCmd",
 		"-v\tversion for childCmd",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -709,7 +737,8 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"--second",
 		"--slice",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -730,7 +759,8 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"--help",
 		"--slice",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -754,7 +784,8 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"--second",
 		"--slice",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -783,7 +814,8 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 		"--slice",
 		"-l",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -801,7 +833,8 @@ func TestFlagNameCompletionRepeat(t *testing.T) {
 	expected = strings.Join([]string{
 		"-a",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -853,7 +886,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 		"-p",
 		"realArg",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -871,7 +905,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 		"--requiredPersistent",
 		"-p",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -886,7 +921,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"--release",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -905,7 +941,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 		"-s",
 		"subArg",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -922,7 +959,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 		"--subRequired",
 		"-s",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -936,7 +974,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"--subNotRequired",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -955,7 +994,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 		"-p",
 		"realArg",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -977,7 +1017,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 		"-r",
 		"realArg",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -995,7 +1036,8 @@ func TestRequiredFlagNameCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"realArg",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1033,7 +1075,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 
 	expected := strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1047,7 +1090,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"log",
 		":8",
-		"Completion ended with directive: ShellCompDirectiveFilterFileExt", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterFileExt", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1061,7 +1105,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"yaml", "yml",
 		":8",
-		"Completion ended with directive: ShellCompDirectiveFilterFileExt", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterFileExt", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1075,7 +1120,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"yaml", "yml",
 		":8",
-		"Completion ended with directive: ShellCompDirectiveFilterFileExt", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterFileExt", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1089,7 +1135,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"yaml", "yml",
 		":8",
-		"Completion ended with directive: ShellCompDirectiveFilterFileExt", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterFileExt", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1103,7 +1150,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"yaml", "yml",
 		":8",
-		"Completion ended with directive: ShellCompDirectiveFilterFileExt", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterFileExt", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1117,7 +1165,8 @@ func TestFlagFileExtFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"txt",
 		":8",
-		"Completion ended with directive: ShellCompDirectiveFilterFileExt", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterFileExt", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1151,7 +1200,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 
 	expected := strings.Join([]string{
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1164,7 +1214,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1178,7 +1229,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"themes",
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1192,7 +1244,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"themes",
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1206,7 +1259,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"themes",
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1220,7 +1274,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"themes",
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1233,7 +1288,8 @@ func TestFlagDirFilterCompletionInGo(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":16",
-		"Completion ended with directive: ShellCompDirectiveFilterDirs", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveFilterDirs", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1275,7 +1331,8 @@ func TestValidArgsFuncCmdContext(t *testing.T) {
 
 	expected := strings.Join([]string{
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1299,7 +1356,8 @@ func TestValidArgsFuncSingleCmd(t *testing.T) {
 		"one",
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1314,7 +1372,8 @@ func TestValidArgsFuncSingleCmd(t *testing.T) {
 	expected = strings.Join([]string{
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1341,7 +1400,8 @@ func TestValidArgsFuncSingleCmdInvalidArg(t *testing.T) {
 
 	expected := strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1372,7 +1432,8 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
 		"one",
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1387,7 +1448,8 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
 	expected = strings.Join([]string{
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1401,7 +1463,8 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1417,7 +1480,8 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
 		"three",
 		"four",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1431,7 +1495,8 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
 	expected = strings.Join([]string{
 		"three",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1445,7 +1510,8 @@ func TestValidArgsFuncChildCmds(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1472,7 +1538,8 @@ func TestValidArgsFuncAliases(t *testing.T) {
 		"one",
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1487,7 +1554,8 @@ func TestValidArgsFuncAliases(t *testing.T) {
 	expected = strings.Join([]string{
 		"two",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1501,7 +1569,8 @@ func TestValidArgsFuncAliases(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1625,7 +1694,8 @@ func TestFlagCompletionInGo(t *testing.T) {
 		"2",
 		"10",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1641,7 +1711,8 @@ func TestFlagCompletionInGo(t *testing.T) {
 		"1",
 		"10",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1658,7 +1729,8 @@ func TestFlagCompletionInGo(t *testing.T) {
 		"myfile.json",
 		"file.xml",
 		":6",
-		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1674,7 +1746,8 @@ func TestFlagCompletionInGo(t *testing.T) {
 		"file.yaml",
 		"file.xml",
 		":6",
-		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1705,7 +1778,8 @@ func TestValidArgsFuncChildCmdsWithDesc(t *testing.T) {
 		"one\tThe first",
 		"two\tThe second",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1720,7 +1794,8 @@ func TestValidArgsFuncChildCmdsWithDesc(t *testing.T) {
 	expected = strings.Join([]string{
 		"two\tThe second",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1734,7 +1809,8 @@ func TestValidArgsFuncChildCmdsWithDesc(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1750,7 +1826,8 @@ func TestValidArgsFuncChildCmdsWithDesc(t *testing.T) {
 		"three\tThe third",
 		"four\tThe fourth",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1764,7 +1841,8 @@ func TestValidArgsFuncChildCmdsWithDesc(t *testing.T) {
 	expected = strings.Join([]string{
 		"three\tThe third",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1778,7 +1856,8 @@ func TestValidArgsFuncChildCmdsWithDesc(t *testing.T) {
 
 	expected = strings.Join([]string{
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1817,7 +1896,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--help\thelp for child",
 		"--string\ttest string flag",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1833,7 +1913,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1849,7 +1930,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1868,7 +1950,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1884,7 +1967,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1900,7 +1984,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1916,7 +2001,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1932,7 +2018,8 @@ func TestFlagCompletionWithNotInterspersedArgs(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)
@@ -1948,7 +2035,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1964,7 +2052,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"test",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -1982,7 +2071,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 	expected = strings.Join([]string{
 		"--validarg",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2001,7 +2091,8 @@ func TestFlagCompletionWithNotInterspersedArgs(t *testing.T) {
 		"--validarg",
 		"--toComp=ab",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2036,7 +2127,8 @@ func TestFlagCompletionWorksRootCommandAddedAfterFlags(t *testing.T) {
 	expected := strings.Join([]string{
 		"myval",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2188,7 +2280,8 @@ func TestFlagCompletionInGoWithDesc(t *testing.T) {
 		"2\tThe second",
 		"10\tThe tenth",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2204,7 +2297,8 @@ func TestFlagCompletionInGoWithDesc(t *testing.T) {
 		"1\tThe first",
 		"10\tThe tenth",
 		":0",
-		"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveDefault", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2221,7 +2315,8 @@ func TestFlagCompletionInGoWithDesc(t *testing.T) {
 		"myfile.json\tJSON format",
 		"file.xml\tXML format",
 		":6",
-		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2237,7 +2332,8 @@ func TestFlagCompletionInGoWithDesc(t *testing.T) {
 		"file.yaml\tYAML format",
 		"file.xml\tXML format",
 		":6",
-		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2265,7 +2361,8 @@ func TestValidArgsNotValidArgsFunc(t *testing.T) {
 		"one",
 		"two",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2280,7 +2377,8 @@ func TestValidArgsNotValidArgsFunc(t *testing.T) {
 	expected = strings.Join([]string{
 		"two",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2307,7 +2405,8 @@ func TestArgAliasesCompletionInGo(t *testing.T) {
 		"two",
 		"three",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2323,7 +2422,8 @@ func TestArgAliasesCompletionInGo(t *testing.T) {
 		"two",
 		"three",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2338,7 +2438,8 @@ func TestArgAliasesCompletionInGo(t *testing.T) {
 	expected = strings.Join([]string{
 		"trois",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2375,7 +2476,8 @@ func TestCompleteHelp(t *testing.T) {
 		"completion",
 		"help",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2393,7 +2495,8 @@ func TestCompleteHelp(t *testing.T) {
 		"completion",
 		"help", // "<program> help help" is a valid command, so should be completed
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2408,7 +2511,8 @@ func TestCompleteHelp(t *testing.T) {
 	expected = strings.Join([]string{
 		"child3",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2577,10 +2681,12 @@ func TestCompleteCompletion(t *testing.T) {
 	expected := strings.Join([]string{
 		"bash",
 		"fish",
+		"nushell",
 		"powershell",
 		"zsh",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2603,7 +2709,8 @@ func TestCompleteCompletion(t *testing.T) {
 
 		expected = strings.Join([]string{
 			":4",
-			"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+			"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+		}, "\n")
 
 		if output != expected {
 			t.Errorf("expected: %q, got: %q", expected, output)
@@ -2635,7 +2742,8 @@ func TestMultipleShorthandFlagCompletion(t *testing.T) {
 		"foo",
 		"bar",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2651,7 +2759,8 @@ func TestMultipleShorthandFlagCompletion(t *testing.T) {
 		"foo",
 		"bar",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2666,7 +2775,8 @@ func TestMultipleShorthandFlagCompletion(t *testing.T) {
 	expected = strings.Join([]string{
 		"works",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2681,7 +2791,8 @@ func TestMultipleShorthandFlagCompletion(t *testing.T) {
 	expected = strings.Join([]string{
 		"works",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2697,7 +2808,8 @@ func TestMultipleShorthandFlagCompletion(t *testing.T) {
 		"foo",
 		"bar",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2705,7 +2817,6 @@ func TestMultipleShorthandFlagCompletion(t *testing.T) {
 }
 
 func TestCompleteWithDisableFlagParsing(t *testing.T) {
-
 	flagValidArgs := func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {
 		return []string{"--flag", "-f"}, ShellCompDirectiveNoFileComp
 	}
@@ -2738,7 +2849,8 @@ func TestCompleteWithDisableFlagParsing(t *testing.T) {
 		"--flag",
 		"-f",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2760,7 +2872,8 @@ func TestCompleteWithDisableFlagParsing(t *testing.T) {
 		"--nonPersistent",
 		"-n",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2789,7 +2902,8 @@ 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)
@@ -2805,7 +2919,8 @@ 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)
@@ -2832,7 +2947,8 @@ func TestFixedCompletions(t *testing.T) {
 		"banana",
 		"orange",
 		":4",
-		"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")
+		"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+	}, "\n")
 
 	if output != expected {
 		t.Errorf("expected: %q, got: %q", expected, output)
@@ -2878,7 +2994,8 @@ func TestCompletionForGroupedFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"subArg",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "flags in group suggested with - prefix",
@@ -2891,7 +3008,8 @@ func TestCompletionForGroupedFlags(t *testing.T) {
 				"--ingroup3",
 				"--nogroup",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "when flag in group present, other flags in group suggested even without - prefix",
@@ -2901,7 +3019,8 @@ func TestCompletionForGroupedFlags(t *testing.T) {
 				"--ingroup3",
 				"subArg",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "when all flags in group present, flags not suggested without - prefix",
@@ -2909,7 +3028,8 @@ func TestCompletionForGroupedFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"subArg",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "group ignored if some flags not applicable",
@@ -2919,7 +3039,8 @@ func TestCompletionForGroupedFlags(t *testing.T) {
 				"completion",
 				"help",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 	}
 
@@ -3076,7 +3197,8 @@ func TestCompletionForMutuallyExclusiveFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"subArg",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "flags in mutually exclusive group suggested with the - prefix",
@@ -3089,7 +3211,8 @@ func TestCompletionForMutuallyExclusiveFlags(t *testing.T) {
 				"--ingroup3",
 				"--nogroup",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "when flag in mutually exclusive group present, other flags in group not suggested even with the - prefix",
@@ -3100,7 +3223,8 @@ func TestCompletionForMutuallyExclusiveFlags(t *testing.T) {
 				"-h",
 				"--nogroup",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "group ignored if some flags not applicable",
@@ -3111,7 +3235,8 @@ func TestCompletionForMutuallyExclusiveFlags(t *testing.T) {
 				"--ingroup1",
 				"--ingroup2",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 	}
 
@@ -3215,70 +3340,80 @@ func TestCompletionCobraFlags(t *testing.T) {
 				"--version",
 				"-v",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after --help flag",
 			args: []string{"--help", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after -h flag",
 			args: []string{"-h", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after --version flag",
 			args: []string{"--version", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after -v flag",
 			args: []string{"-v", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after --help flag even with other completions",
 			args: []string{"child", "--help", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after -h flag even with other completions",
 			args: []string{"child", "-h", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after --version flag even with other completions",
 			args: []string{"child", "--version", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after -v flag even with other completions",
 			args: []string{"child", "-v", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion after -v flag even with other flag completions",
 			args: []string{"child", "-v", "-"},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "completion after --help flag when created by program",
@@ -3286,7 +3421,8 @@ func TestCompletionCobraFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"extra2",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "completion after -h flag when created by program",
@@ -3294,7 +3430,8 @@ func TestCompletionCobraFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"extra2",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "completion after --version flag when created by program",
@@ -3302,7 +3439,8 @@ func TestCompletionCobraFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"extra2",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "completion after -v flag when created by program",
@@ -3310,14 +3448,16 @@ func TestCompletionCobraFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"extra2",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "completion after --version when only -v flag was created by program",
 			args: []string{"child3", "--version", ""},
 			expectedOutput: strings.Join([]string{
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "completion after -v flag when only -v flag was created by program",
@@ -3325,7 +3465,8 @@ func TestCompletionCobraFlags(t *testing.T) {
 			expectedOutput: strings.Join([]string{
 				"extra3",
 				":4",
-				"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n"),
+				"Completion ended with directive: ShellCompDirectiveNoFileComp", "",
+			}, "\n"),
 		},
 		{
 			desc: "no completion for --help/-h and --version/-v flags when DisableFlagParsing=true",
diff --git a/nushell_completions.go b/nushell_completions.go
index 4363946..3b4e2c6 100644
--- a/nushell_completions.go
+++ b/nushell_completions.go
@@ -16,31 +16,39 @@ package cobra
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"os"
 )
 
 func (c *Command) GenNushellCompletion(w io.Writer) error {
 	buf := new(bytes.Buffer)
-	WriteStringAndCheck(buf, `
+	WriteStringAndCheck(buf, fmt.Sprintf(`
 # An external configurator that works with any cobra based
 # command line application (e.g. kubectl, minikube)
-let cobra_configurator = {|spans| 
+let cobra_completer = {|spans| 
+
+  let ShellCompDirectiveError = %[1]d
+  let ShellCompDirectiveNoSpace = %[2]d
+  let ShellCompDirectiveNoFileComp = %[3]d
+  let ShellCompDirectiveFilterFileExt = %[4]d
+  let ShellCompDirectiveFilterDirs = %[5]d
  
   let cmd = $spans.0
+  let last_span = ($spans | last | str trim)
 
   # skip the first entry in the span (the command) and join the rest of the span to create __complete args
   let cmd_args = ($spans | skip 1 | str join ' ') 
 
   # If the last span entry was empty add "" to the end of the command args
-  let cmd_args = if ($spans | last | str trim | is-empty) {
+  let cmd_args = if ($last_span | is-empty) {
     $'($cmd_args) ""'
   } else {
     $cmd_args
   }
 
-  # The full command to be executed
-  let full_cmd = $'($cmd) __complete ($cmd_args)'
+  # The full command to be executed with active help disable (Nushell does not support active help)
+  let full_cmd = $'($cmd)_ACTIVE_HELP=0 ($cmd) __complete ($cmd_args)'
 
   # Since nushell doesn't have anything like eval, execute in a subshell
   let result = (do -i { nu -c $"'($full_cmd)'" } | complete)
@@ -48,16 +56,33 @@ let cobra_configurator = {|spans|
   # Create a record with all completion related info. 
   # directive and directive_str are for posterity
   let stdout_lines = ($result.stdout | lines)
-  let $completions = ($stdout_lines | drop | parse -r '([\w\-\.:\+]*)\t?(.*)' | rename value description)
+  let directive = ($stdout_lines | last | str trim | str replace ":" "" | into int)
+  let completions = ($stdout_lines | drop | parse -r '([\w\-\.:\+\=]*)\t?(.*)' | rename value description)
 
-  let result = ({
-    completions: $completions
-    directive_str: ($result.stderr)
-    directive: ($stdout_lines | last)
-  })
+  # Add space at the end of each completion
+  let completions = if $directive != $ShellCompDirectiveNoSpace {
+    ($completions | each {|it| {value: $"($it.value) ", description: $it.description}})
+  } else {
+    $completions
+  }
 
-  $result.completions
-}`)
+  if $last_span =~ '=$' {
+    # return flag as part of the completion so that it doesn't get replaced
+    $completions | each {|it| $"($last_span)($it.value)" }
+  } else if $directive == $ShellCompDirectiveNoFileComp {
+    # Allow empty results as this will stop file completion
+    $completions
+  } else if ($completions | is-empty)  or  $directive == $ShellCompDirectiveError {
+    # Not returning null causes file completions to break
+    # Return null if there are no completions or ShellCompDirectiveError 
+    null
+  } else {
+    $completions
+  }
+
+}
+`, ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp,
+		ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs))
 
 	_, err := buf.WriteTo(w)
 	return err
diff --git a/nushell_completions_test.go b/nushell_completions_test.go
index 3e3c36d..b82898a 100644
--- a/nushell_completions_test.go
+++ b/nushell_completions_test.go
@@ -38,7 +38,7 @@ func TestGenNushellCompletion(t *testing.T) {
 	assertNoErr(t, rootCmd.GenNushellCompletion(buf))
 	output := buf.String()
 
-	check(t, output, "let full_cmd = $'($cmd) __complete ($cmd_args)'")
+	check(t, output, "let full_cmd = $'($cmd)_ACTIVE_HELP=0 ($cmd) __complete ($cmd_args)'")
 }
 
 func TestGenNushellCompletionFile(t *testing.T) {