Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Add PassUnknownFlagsToArgs to allow get unknown flags via Args() #338

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Add PassUnknownFlagsToArgs to allow get unknown flags via Args() #338

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
62 changes: 60 additions & 2 deletions flag.go
View file
Open in desktop
Expand Up @@ -128,6 +128,11 @@ const (
type ParseErrorsWhitelist struct {
// UnknownFlags will ignore unknown flags errors and continue parsing rest of the flags
UnknownFlags bool
// PassUnknownFlagsToArgs will treat unknown flags as non-flag arguments.
// Combined shorthand flags mixed with known ones and unknown ones results
// combined flags only with unknown ones.
// E.g. -fghi results -gh if only `f` and `i` are known.
PassUnknownFlagsToArgs bool
}

// NormalizedName is a flag name that has been normalized according to rules
Expand Down Expand Up @@ -956,6 +961,17 @@ func stripUnknownFlagValue(args []string) []string {
return nil
}

// errUnknownFlag is used for internal unknown flag handling.
type unknownFlagError struct {
// UnknownFlags is flags that are unknown and unprocessed.
// It depends on the context whether this has a prefix like '-' or '--'.
UnknownFlags string
}

func (e *unknownFlagError) Error() string {
return fmt.Sprintf("unknown flag: %v", e.UnknownFlags)
}

func (f *FlagSet) parseLongArg(s string, args []string, fn parseFunc) (a []string, err error) {
a = args
name := s[2:]
Expand All @@ -974,6 +990,11 @@ func (f *FlagSet) parseLongArg(s string, args []string, fn parseFunc) (a []strin
f.usage()
return a, ErrHelp
case f.ParseErrorsWhitelist.UnknownFlags:
if f.ParseErrorsWhitelist.PassUnknownFlagsToArgs {
return a, &unknownFlagError{
UnknownFlags: s,
}
}
// --unknown=unknownval arg ...
// we do not want to lose arg in this case
if len(split) >= 2 {
Expand Down Expand Up @@ -1033,6 +1054,18 @@ func (f *FlagSet) parseSingleShortArg(shorthands string, args []string, fn parse
// we do not want to lose arg in this case
if len(shorthands) > 2 && shorthands[1] == '=' {
outShorts = ""
if f.ParseErrorsWhitelist.PassUnknownFlagsToArgs {
err = &unknownFlagError{
UnknownFlags: shorthands,
}
}
return
}

if f.ParseErrorsWhitelist.PassUnknownFlagsToArgs {
err = &unknownFlagError{
UnknownFlags: shorthands[0:1],
}
return
}

Expand Down Expand Up @@ -1080,14 +1113,32 @@ func (f *FlagSet) parseSingleShortArg(shorthands string, args []string, fn parse
func (f *FlagSet) parseShortArg(s string, args []string, fn parseFunc) (a []string, err error) {
a = args
shorthands := s[1:]
var errUnknownFlagAll *unknownFlagError

// "shorthands" can be a series of shorthand letters of flags (e.g. "-vvv").
for len(shorthands) > 0 {
shorthands, a, err = f.parseSingleShortArg(shorthands, args, fn)
if err != nil {
return
if errUnknownFlag, ok := err.(*unknownFlagError); ok {
// this means f.ParseErrorsWhitelist.UnknownFlags
// and f.ParseErrorsWhitelist.PassUnknownFlagsToArgs are set.
if errUnknownFlagAll != nil {
errUnknownFlagAll.UnknownFlags = errUnknownFlagAll.UnknownFlags +
errUnknownFlag.UnknownFlags
} else {
errUnknownFlagAll = &unknownFlagError{
UnknownFlags: "-" + errUnknownFlag.UnknownFlags,
}
}
err = nil
} else {
return
}
}
}
if errUnknownFlagAll != nil {
err = errUnknownFlagAll
}

return
}
Expand Down Expand Up @@ -1117,7 +1168,14 @@ func (f *FlagSet) parseArgs(args []string, fn parseFunc) (err error) {
args, err = f.parseShortArg(s, args, fn)
}
if err != nil {
return
if errUnknownFlag, ok := err.(*unknownFlagError); ok {
// this means f.ParseErrorsWhitelist.UnknownFlags
// and f.ParseErrorsWhitelist.PassUnknownFlagsToArgs are set.
f.args = append(f.args, errUnknownFlag.UnknownFlags)
err = nil
} else {
return
}
}
}
return
Expand Down
110 changes: 110 additions & 0 deletions flag_test.go
View file
Open in desktop
Expand Up @@ -480,6 +480,112 @@ func testParseWithUnknownFlags(f *FlagSet, t *testing.T) {
}
}

func testParseWithUnknownFlagsAndPassToArgs(f *FlagSet, t *testing.T) {
if f.Parsed() {
t.Fatal("f.Parse() = true before Parse")
}
f.ParseErrorsWhitelist.UnknownFlags = true
f.ParseErrorsWhitelist.PassUnknownFlagsToArgs = true
f.SetInterspersed(true)

f.BoolP("boola", "a", false, "bool value")
f.BoolP("boolb", "b", false, "bool2 value")
f.BoolP("boolc", "c", false, "bool3 value")
f.BoolP("boold", "d", false, "bool4 value")
f.BoolP("boole", "e", false, "bool4 value")
f.StringP("stringa", "s", "0", "string value")
f.StringP("stringz", "z", "0", "string value")
f.StringP("stringx", "x", "0", "string value")
f.StringP("stringy", "y", "0", "string value")
f.StringP("stringo", "o", "0", "string value")
f.Lookup("stringx").NoOptDefVal = "1"
args := []string{
"-ab",
// -f and -g is unknown
"-fcgs=xx",
"--stringz=something",
"--unknown1",
"unknown1Value",
"-d=true",
"-x",
"--unknown2=unknown2Value",
"-u=unknown3Value",
"-p",
"unknown4Value",
"-q", //another unknown with bool value
"-y",
"ee",
"--unknown7=unknown7value",
"--stringo=ovalue",
"--unknown8=unknown8value",
"--boole",
"--unknown6",
"",
"-uuuuu",
"",
"--unknown10",
"--unknown11",
"arg0",
"arg1",
}
want := []string{
"boola", "true",
"boolb", "true",
"boolc", "true",
"stringa", "xx",
"stringz", "something",
"boold", "true",
"stringx", "1",
"stringy", "ee",
"stringo", "ovalue",
"boole", "true",
}
wantArgs := []string{
"-fg",
"--unknown1",
"unknown1Value",
"--unknown2=unknown2Value",
"-u=unknown3Value",
"-p",
"unknown4Value",
"-q", //another unknown with bool value
"--unknown7=unknown7value",
"--unknown8=unknown8value",
"--unknown6",
"",
"-uuuuu",
"",
"--unknown10",
"--unknown11",
"arg0",
"arg1",
}
got := []string{}
store := func(flag *Flag, value string) error {
got = append(got, flag.Name)
if len(value) > 0 {
got = append(got, value)
}
return nil
}
if err := f.ParseAll(args, store); err != nil {
t.Errorf("expected no error, got %s", err)
}
if !f.Parsed() {
t.Errorf("f.Parse() = false after Parse")
}
if !reflect.DeepEqual(got, want) {
t.Errorf("f.ParseAll() fail to restore the args")
t.Errorf("Got: %v", got)
t.Errorf("Want: %v", want)
}
if !reflect.DeepEqual(f.Args(), wantArgs) {
t.Errorf("f.ParseAll() fail to restore the args")
t.Errorf("Got: %v", f.Args())
t.Errorf("Want: %v", wantArgs)
}
}

func TestShorthand(t *testing.T) {
f := NewFlagSet("shorthand", ContinueOnError)
if f.Parsed() {
Expand Down Expand Up @@ -591,6 +697,10 @@ func TestIgnoreUnknownFlags(t *testing.T) {
testParseWithUnknownFlags(GetCommandLine(), t)
}

func TestIgnoreUnknownFlagsAndPassToArgs(t *testing.T) {
ResetForTesting(func() { t.Error("bad parse") })
testParseWithUnknownFlagsAndPassToArgs(GetCommandLine(), t)
}
func TestFlagSetParse(t *testing.T) {
testParse(NewFlagSet("test", ContinueOnError), t)
}
Expand Down