From 96853a4e2c2716ef0059db31d147ab7e42a89d93 Mon Sep 17 00:00:00 2001
From: Rajat Jindal <rajatjindal83@gmail.com>
Date: Fri, 30 Mar 2018 12:27:50 -0700
Subject: [PATCH] Add support for ignoring parse errors

---
 command.go      |  10 +++++
 command_test.go | 105 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 115 insertions(+)

diff --git a/command.go b/command.go
index 15b811279..34d1bf367 100644
--- a/command.go
+++ b/command.go
@@ -27,6 +27,9 @@ import (
 	flag "github.com/spf13/pflag"
 )
 
+// FParseErrWhitelist configures Flag parse errors to be ignored
+type FParseErrWhitelist flag.ParseErrorsWhitelist
+
 // Command is just that, a command for your application.
 // E.g.  'go run ...' - 'run' is the command. Cobra requires
 // you to define the usage and description as part of your command
@@ -137,6 +140,9 @@ type Command struct {
 	// TraverseChildren parses flags on all parents before executing child command.
 	TraverseChildren bool
 
+	//FParseErrWhitelist flag parse errors to be ignored
+	FParseErrWhitelist FParseErrWhitelist
+
 	// commands is the list of commands supported by this program.
 	commands []*Command
 	// parent is a parent command for this command.
@@ -1463,6 +1469,10 @@ func (c *Command) ParseFlags(args []string) error {
 	}
 	beforeErrorBufLen := c.flagErrorBuf.Len()
 	c.mergePersistentFlags()
+
+	//do it here after merging all flags and just before parse
+	c.Flags().ParseErrorsWhitelist = flag.ParseErrorsWhitelist(c.FParseErrWhitelist)
+
 	err := c.Flags().Parse(args)
 	// Print warnings if they occurred (e.g. deprecated flag messages).
 	if c.flagErrorBuf.Len()-beforeErrorBufLen > 0 && err == nil {
diff --git a/command_test.go b/command_test.go
index d874a9a51..ccee031de 100644
--- a/command_test.go
+++ b/command_test.go
@@ -1626,3 +1626,108 @@ func TestCalledAs(t *testing.T) {
 		t.Run(name, tc.test)
 	}
 }
+
+func TestFParseErrWhitelistBackwardCompatibility(t *testing.T) {
+	c := &Command{Use: "c", Run: emptyRun}
+	c.Flags().BoolP("boola", "a", false, "a boolean flag")
+
+	output, err := executeCommand(c, "c", "-a", "--unknown", "flag")
+	if err == nil {
+		t.Error("expected unknown flag error")
+	}
+	checkStringContains(t, output, "unknown flag: --unknown")
+}
+
+func TestFParseErrWhitelistSameCommand(t *testing.T) {
+	c := &Command{
+		Use: "c",
+		Run: emptyRun,
+		FParseErrWhitelist: FParseErrWhitelist{
+			UnknownFlags: true,
+		},
+	}
+	c.Flags().BoolP("boola", "a", false, "a boolean flag")
+
+	_, err := executeCommand(c, "c", "-a", "--unknown", "flag")
+	if err != nil {
+		t.Error("unexpected error: ", err)
+	}
+}
+
+func TestFParseErrWhitelistParentCommand(t *testing.T) {
+	root := &Command{
+		Use: "root",
+		Run: emptyRun,
+		FParseErrWhitelist: FParseErrWhitelist{
+			UnknownFlags: true,
+		},
+	}
+
+	c := &Command{
+		Use: "child",
+		Run: emptyRun,
+	}
+	c.Flags().BoolP("boola", "a", false, "a boolean flag")
+
+	root.AddCommand(c)
+
+	output, err := executeCommand(root, "child", "-a", "--unknown", "flag")
+	if err == nil {
+		t.Error("expected unknown flag error")
+	}
+	checkStringContains(t, output, "unknown flag: --unknown")
+}
+
+func TestFParseErrWhitelistChildCommand(t *testing.T) {
+	root := &Command{
+		Use: "root",
+		Run: emptyRun,
+	}
+
+	c := &Command{
+		Use: "child",
+		Run: emptyRun,
+		FParseErrWhitelist: FParseErrWhitelist{
+			UnknownFlags: true,
+		},
+	}
+	c.Flags().BoolP("boola", "a", false, "a boolean flag")
+
+	root.AddCommand(c)
+
+	_, err := executeCommand(root, "child", "-a", "--unknown", "flag")
+	if err != nil {
+		t.Error("unexpected error: ", err.Error())
+	}
+}
+
+func TestFParseErrWhitelistSiblingCommand(t *testing.T) {
+	root := &Command{
+		Use: "root",
+		Run: emptyRun,
+	}
+
+	c := &Command{
+		Use: "child",
+		Run: emptyRun,
+		FParseErrWhitelist: FParseErrWhitelist{
+			UnknownFlags: true,
+		},
+	}
+	c.Flags().BoolP("boola", "a", false, "a boolean flag")
+
+	s := &Command{
+		Use: "sibling",
+		Run: emptyRun,
+	}
+	s.Flags().BoolP("boolb", "b", false, "a boolean flag")
+
+	root.AddCommand(c)
+	root.AddCommand(s)
+
+	output, err := executeCommand(root, "sibling", "-b", "--unknown", "flag")
+	if err == nil {
+		t.Error("expected unknown flag error")
+	}
+	checkStringContains(t, output, "unknown flag: --unknown")
+}