refactor: add CommandInfo pointer to UnknownOptionError

Author: steverusso

cli.go

@@ -125,7 +125,7 @@ type InputInfo struct {
 	Versioner Versioner
 }
 
-// ValueParser describes any function that takes a string and returns some type or an
+// ValueParser describes any function that takes a string and returns some value or an
 // error. This is the signature of any input value parser. See [ParseBool], [ParseInt],
 // and the other provided parsers for some examples.
 type ValueParser = func(string) (any, error)
@@ -400,7 +400,7 @@ func parse(c *CommandInfo, p *Command, args []string) error {
 				optName := arg[charIdx]
 				optInfo := lookupOptionByShortName(c, optName)
 				if optInfo == nil {
-					return UnknownOptionError{Name: "-" + string(arg[charIdx])}
+					return UnknownOptionError{Cmd: c, Name: "-" + string(arg[charIdx])}
 				}
 
 				// If this is another bool option, the raw value will be empty. If this is
@@ -482,7 +482,7 @@ func parse(c *CommandInfo, p *Command, args []string) error {
 			}
 		}
 		if optInfo == nil {
-			return UnknownOptionError{Name: args[i]}
+			return UnknownOptionError{Cmd: c, Name: args[i]}
 		}
 
 		var rawValue string
@@ -516,8 +516,6 @@ func parse(c *CommandInfo, p *Command, args []string) error {
 		p.Inputs = append(p.Inputs, pi)
 	}
 
-	var errMissingOpts error
-
 	// check that all required options were provided
 	var missing []string
 	for i := range c.Opts {
@@ -533,6 +531,7 @@ func parse(c *CommandInfo, p *Command, args []string) error {
 			}
 		}
 	}
+	var errMissingOpts error
 	if len(missing) > 0 {
 		errMissingOpts = MissingOptionsError{Names: missing}
 
@@ -650,10 +649,13 @@ func (usce UnknownSubcmdError) Error() string {
 	return "unknown subcommand '" + usce.Name + "'"
 }
 
-type UnknownOptionError struct{ Name string }
+type UnknownOptionError struct {
+	Cmd  *CommandInfo
+	Name string
+}
 
 func (uoe UnknownOptionError) Error() string {
-	return "unknown option '" + uoe.Name + "'"
+	return strings.Join(uoe.Cmd.Path, " ") + ": unknown option '" + uoe.Name + "'"
 }
 
 type MissingOptionValueError struct{ Name string }

cli_test.go

@@ -26,18 +26,20 @@ func TestParsing(t *testing.T) {
 		variations []testInputOutput
 	}
 
-	for _, tt := range []testCase{
-		{
-			// no positional args or subcommands
-			// errors for missing required opts
-			name: "options_only",
-			cmd: NewCmd("optsonly").
-				Opt(NewBoolOpt("aa")).
-				Opt(NewOpt("bb").ShortOnly('b')).
-				Opt(NewOpt("cc").Required()).
-				Opt(NewOpt("dd").Default("v4")).
-				Opt(NewOpt("ee")),
-			variations: []testInputOutput{
+	for _, tt := range []*testCase{
+		func() *testCase {
+			tc := testCase{
+				// no positional args or subcommands
+				// errors for missing required opts
+				name: "options_only",
+				cmd: NewCmd("optsonly").
+					Opt(NewBoolOpt("aa")).
+					Opt(NewOpt("bb").ShortOnly('b')).
+					Opt(NewOpt("cc").Required()).
+					Opt(NewOpt("dd").Default("v4")).
+					Opt(NewOpt("ee")),
+			}
+			tc.variations = []testInputOutput{
 				{
 					Case: ttCase(),
 					args: []string{"-b", "v2", "--aa", "--cc=v3"},
@@ -56,15 +58,15 @@ func TestParsing(t *testing.T) {
 				}, {
 					Case:   ttCase(),
 					args:   []string{"-z"},
-					expErr: UnknownOptionError{Name: "-z"},
+					expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "-z"},
 				}, {
 					Case:   ttCase(),
 					args:   []string{"--zz=abc"},
-					expErr: UnknownOptionError{Name: "--zz=abc"},
+					expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "--zz=abc"},
 				}, {
 					Case:   ttCase(),
 					args:   []string{"--bb", "B"},
-					expErr: UnknownOptionError{Name: "--bb"},
+					expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "--bb"},
 				}, {
 					Case:   ttCase(),
 					args:   []string{"--dd"},
@@ -74,8 +76,9 @@ func TestParsing(t *testing.T) {
 					args:   []string{"-b"},
 					expErr: MissingOptionValueError{Name: "b"},
 				},
-			},
-		}, {
+			}
+			return &tc
+		}(), {
 			// all provided parsers with defaults
 			name: "provided_parsers",
 			cmd: NewCmd("pp").
@@ -392,14 +395,16 @@ func TestParsing(t *testing.T) {
 					},
 				},
 			},
-		}, {
-			// stacking / bunching short options and their values
-			name: "shortstacks",
-			cmd: NewCmd("shst").
-				Opt(NewBoolOpt("bb").Short('b')).
-				Opt(NewOpt("aa").Short('a')).
-				Opt(NewBoolOpt("cc").Short('c')),
-			variations: []testInputOutput{
+		}, func() *testCase {
+			tc := testCase{
+				// stacking / bunching short options and their values
+				name: "shortstacks",
+				cmd: NewCmd("shst").
+					Opt(NewBoolOpt("bb").Short('b')).
+					Opt(NewOpt("aa").Short('a')).
+					Opt(NewBoolOpt("cc").Short('c')),
+			}
+			tc.variations = []testInputOutput{
 				{
 					Case: ttCase(),
 					args: []string{"-bc"},
@@ -472,7 +477,7 @@ func TestParsing(t *testing.T) {
 				}, {
 					Case:   ttCase(),
 					args:   []string{"-bz"},
-					expErr: UnknownOptionError{Name: "-z"},
+					expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "-z"},
 				}, {
 					Case: ttCase(),
 					args: []string{"-aa", "v"},
@@ -483,8 +488,9 @@ func TestParsing(t *testing.T) {
 						Surplus: []string{"v"},
 					},
 				},
-			},
-		}, {
+			}
+			return &tc
+		}(), {
 			// versioning (on just the top level for now)
 			// using the builder method for a custom versioner
 			name: "versioning",
@@ -531,37 +537,43 @@ func TestParsing(t *testing.T) {
 					expErr: HelpOrVersionRequested{Msg: "(devel)\n"},
 				},
 			},
-		}, {
+		}, func() *testCase {
 			// versioning (on just the top level for now)
 			// using the constructor for a version option but leaving out a short name
-			name: "versioning",
-			cmd:  NewCmd("cmd").Opt(NewVersionOpt(0, "version", VersionOptConfig{})),
-			variations: []testInputOutput{
+			tc := testCase{
+				name: "versioning",
+				cmd:  NewCmd("cmd").Opt(NewVersionOpt(0, "version", VersionOptConfig{})),
+			}
+			tc.variations = []testInputOutput{
 				{
 					Case:   ttCase(),
 					args:   []string{"--version"},
 					expErr: HelpOrVersionRequested{Msg: "(devel)\n"},
 				},
-				{Case: ttCase(), args: []string{"-v"}, expErr: UnknownOptionError{Name: "-v"}},
-				{Case: ttCase(), args: []string{"-V"}, expErr: UnknownOptionError{Name: "-V"}},
-			},
-		}, {
+				{Case: ttCase(), args: []string{"-v"}, expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "-v"}},
+				{Case: ttCase(), args: []string{"-V"}, expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "-V"}},
+			}
+			return &tc
+		}(), func() *testCase {
 			// versioning (on just the top level for now)
 			// using the constructor for a version option but leaving out a long name
-			name: "versioning",
-			cmd:  NewCmd("cmd").Opt(NewVersionOpt('Z', "", VersionOptConfig{})),
-			variations: []testInputOutput{
+			tc := testCase{
+				name: "versioning",
+				cmd:  NewCmd("cmd").Opt(NewVersionOpt('Z', "", VersionOptConfig{})),
+			}
+			tc.variations = []testInputOutput{
 				{
 					Case:   ttCase(),
 					args:   []string{"-Z"},
 					expErr: HelpOrVersionRequested{Msg: "(devel)\n"},
 				}, {
 					Case:   ttCase(),
 					args:   []string{"--version"},
-					expErr: UnknownOptionError{Name: "--version"},
+					expErr: UnknownOptionError{Cmd: &tc.cmd, Name: "--version"},
 				},
-			},
-		},
+			}
+			return &tc
+		}(),
 	} {
 		for tioIdx, tio := range tt.variations {
 			t.Run(fmt.Sprintf("%s %d", tt.name, tioIdx), func(t *testing.T) {

examples_test.go

@@ -50,7 +50,7 @@ func ExampleInputInfo_ShortOnly() {
 	fmt.Println(err)
 	// Output:
 	// hello
-	// unknown option '--flag'
+	// cli.test: unknown option '--flag'
 }
 
 func ExampleInputInfo_Help() {