feat: Use structs for CLI-validation errors returned by Cobra. #2266

eth-p · 2025-04-15T07:28:29Z

This pull request converts a bunch of fmt.Errorf errors into structs implementing the error interface.

Similar to #2178, the goal of this pull request is to make it easier for callers of a Cobra command to determine why a command failed without having to resort to regex matching or parsing the error message. This pull request goes a bit further, covering all types of CLI validation-related errors (with the exception of pflag-created ones) and adding methods to get the specific details of the errors.

Giving callers this info enables them to do new things such as:

Printing localized error messages.
Changing how the errors are displayed (e.g. pretty printing, colors).

The error structs added are:

InvalidArgCountError
InvalidArgValueError
UnknownSubcommandError
RequiredFlagError
FlagGroupError

Tests and documentation have been updated as well.

CLAassistant · 2025-04-15T07:28:35Z

All committers have signed the CLA.

ccoVeille · 2025-05-05T12:51:49Z

errors.go

+	if e.atMost == -1 && e.atLeast >= 0 { // MinimumNArgs
+		return fmt.Sprintf("requires at least %d arg(s), only received %d", e.atLeast, len(e.args))
+	}
+
+	if e.atLeast == -1 && e.atMost >= 0 { // MaximumNArgs
+		return fmt.Sprintf("accepts at most %d arg(s), received %d", e.atMost, len(e.args))
+	}
+
+	if e.atLeast == e.atMost && e.atLeast != -1 { // ExactArgs
+		return fmt.Sprintf("accepts %d arg(s), received %d", e.atLeast, len(e.args))
+	}
+
+	// RangeArgs
+	return fmt.Sprintf("accepts between %d and %d arg(s), received %d", e.atLeast, e.atMost, len(e.args))
+}


I assume -1 is the default value when they are not set.

It's not that obvious.

Maybe code could be clearer by inverting the logic

Suggested change

if e.atMost == -1 && e.atLeast >= 0 { // MinimumNArgs

return fmt.Sprintf("requires at least %d arg(s), only received %d", e.atLeast, len(e.args))

}

if e.atLeast == -1 && e.atMost >= 0 { // MaximumNArgs

return fmt.Sprintf("accepts at most %d arg(s), received %d", e.atMost, len(e.args))

}

if e.atLeast == e.atMost && e.atLeast != -1 { // ExactArgs

return fmt.Sprintf("accepts %d arg(s), received %d", e.atLeast, len(e.args))

}

// RangeArgs

return fmt.Sprintf("accepts between %d and %d arg(s), received %d", e.atLeast, e.atMost, len(e.args))

}

if e.atLeast == e.atMost && e.atLeast > 0 { // ExactArgs

return fmt.Sprintf("accepts %d arg(s), received %d", e.atLeast, len(e.args))

}

if e.atMost >= 0 && e.atLeast >= 0 { // RangeArgs

return fmt.Sprintf("accepts between %d and %d arg(s), received %d", e.atLeast, e.atMost, len(e.args))

}

if e.atLeast >= 0 { // MinimumNArgs

return fmt.Sprintf("requires at least %d arg(s), only received %d", e.atLeast, len(e.args))

}

// MaximumNArgs

return fmt.Sprintf("accepts at most %d arg(s), received %d", e.atMost, len(e.args))

}

This is pseudo code written on a phone, but I hope you get the idea

That's much better! Great suggestion, thanks!

ccoVeille · 2025-05-05T12:57:34Z

errors.go

+func (e *UnknownSubcommandError) GetSuggestions() string {
+	return e.suggestions
+}


Here an for other errors, I would have preferred if this method returned a []string

But it would require to rewrite findSuggestions, or at least to split by \n here, but it would be ugly and dirty

That's totally fair. I added another commit to split up findSuggestions into two separate functions, and I changed the error structs to hold suggestions []string and return the suggestions slice instead of the merged string.

The `findSuggestions` function keeps the logic for finding the suggestions, and a new `helpTextForSuggestions` function joins them together into a string. This will allow error structs to return the suggestions as a slice, rather than a string.

eth-p · 2025-05-06T03:25:30Z

Awesome, thanks for the review @ccoVeille!

I rebased the commits against main and applied your suggestions. In hindsight it might have been better to keep them as fixup commits for review purposes, but here's a quick TLDR on what changed since your previous review:

New commit to split up findSuggestions: 8dd7f63
Applied your suggestion to InvalidArgCountError.Error(). I did make a slight change, though:
```
- if e.atLeast == e.atMost && e.atLeast > 0 { // ExactArgs
+ if e.atLeast == e.atMost && e.atLeast >= 0 { // ExactArgs
```
My thoughts were that somebody might do ExactArgs(0), in which case we would want to display the message "accepts 0 arg(s), received N" instead of falling back to the next case and displaying "accepts between 0 and 0 arg(s), received N".

errors.go:

  type InvalidArgValueError struct {
  	cmd         *Command
  	arg         string
- 	suggestions string
+ 	suggestions []string
  }

- func (e *InvalidArgValueError) GetSuggestions() string {
+ func (e *InvalidArgValueError) GetSuggestions() []string {
  	return e.suggestions
  }

  func (e *InvalidArgValueError) Error() string {
- 	return fmt.Sprintf("invalid argument %q for %q%s", e.arg, e.cmd.CommandPath(), e.suggestions)
+ 	return fmt.Sprintf("invalid argument %q for %q%s", e.arg, e.cmd.CommandPath(), helpTextForSuggestions(e.suggestions))
  }

  type UnknownSubcommandError struct {
  	cmd         *Command
  	subcmd      string
- 	suggestions string
+ 	suggestions []string
  }

- func (e *UnknownSubcommandError) GetSuggestions() string {
+ func (e *UnknownSubcommandError) GetSuggestions() []string {
  	return e.suggestions
  }

  func (e *UnknownSubcommandError) Error() string {
- 	return fmt.Sprintf("unknown command %q for %q%s", e.subcmd, e.cmd.CommandPath(), e.suggestions)
+ 	return fmt.Sprintf("unknown command %q for %q%s", e.subcmd, e.cmd.CommandPath(), helpTextForSuggestions(e.suggestions))
  }

  func (e *FlagGroupError) Error() string {
  	switch e.flagGroupType {
  	case FlagsAreRequiredTogether:
  		return fmt.Sprintf("if any flags in the group [%v] are set they must all be set; missing %v", e.flagList, e.problemFlags)
  	case FlagsAreOneRequired:
  		return fmt.Sprintf("at least one of the flags in the group [%v] is required", e.flagList)
  	case FlagsAreMutuallyExclusive:
  		return fmt.Sprintf("if any flags in the group [%v] are set none of the others can be; %v were all set", e.flagList, e.problemFlags)
  	}

+ 	// If the error struct is empty (i.e. wasn't created by Cobra), e.flagGroupType will be an empty string.
+ 	// We don't have a specific message to print, so instead just print the struct contents.
+ 	return fmt.Sprintf("%#v", e)
- 	panic("invalid flagGroupType")
  }

I chose to replace the panic in FlagGroupError.Error() as a precaution. I don't think it's likely that someone would create an empty FlagGroupError and call Error() on it, but just in case, I felt like the better approach was to return something instead of causing a panic later down the line when something eventually tried to get the error string.

errors_test.go:

  func TestInvalidArgValueError_GetSuggestions(t *testing.T) {
- 	expected := "a"
+ 	expected := []string{"a", "b"}
  	err := &InvalidArgValueError{suggestions: expected}

  	got := err.GetSuggestions()
+ 	expectedString := fmt.Sprintf("%#v", expected)
+ 	gotString := fmt.Sprintf("%#v", got)
- 	if expected != gotString {
+ 	if expectedString != got {
  		t.Fatalf("expected %v, got %v", expected, got)
  	}
  }

  func TestUnknownSubcommandError_GetSuggestions(t *testing.T) {
- 	expected := "a"
+ 	expected := []string{"a", "b"}
  	err := &UnknownSubcommandError{suggestions: expected}

  	got := err.GetSuggestions()
+ 	expectedString := fmt.Sprintf("%#v", expected)
+ 	gotString := fmt.Sprintf("%#v", got)
- 	if expected != gotString {
+ 	if expectedString != got {
  		t.Fatalf("expected %v, got %v", expected, got)
  	}
  }

ccoVeille

Please consider these suggestions, and give me feedbacks about them.

I tried to make things easier, and reduce the number of exported struct/constants

ccoVeille · 2025-05-06T05:01:45Z

errors.go

+		return fmt.Sprintf("if any flags in the group [%v] are set none of the others can be; %v were all set", e.flagList, e.problemFlags)
+	}
+
+	panic("invalid flagGroupType")


Didn't you talk about returning an error here?

But maybe, you could take a look at this comment first

feat: Use structs for CLI-validation errors returned by Cobra. #2266 (comment)

Didn't you talk about returning an error here?

I forgot to push that change after rebase, sorry 😅

ccoVeille · 2025-05-06T05:18:51Z

errors.go

+// FlagGroupError is the error returned when mutually-required or
+// mutually-exclusive flags are not properly specified.
+type FlagGroupError struct {
+	cmd           *Command
+	flagList      string
+	flagGroupType FlagGroupType
+	problemFlags  []string
+}
+
+// GetCommand returns the Command that the error occurred in.
+func (e *FlagGroupError) GetCommand() *Command {
+	return e.cmd
+}
+
+// GetFlagList returns the flags in the group.
+func (e *FlagGroupError) GetFlags() []string {
+	return strings.Split(e.flagList, " ")
+}
+
+// GetFlagGroupType returns the type of flag group causing the error.
+//
+// Valid types are:
+//   - FlagsAreMutuallyExclusive for mutually-exclusive flags.
+//   - FlagsAreRequiredTogether for mutually-required flags.
+//   - FlagsAreOneRequired for flags where at least one must be present.
+func (e *FlagGroupError) GetFlagGroupType() FlagGroupType {
+	return e.flagGroupType
+}
+
+// GetProblemFlags returns the flags causing the error.
+//
+// For flag groups where:
+//   - FlagsAreMutuallyExclusive, these are all the flags set.
+//   - FlagsAreRequiredTogether, these are the missing flags.
+//   - FlagsAreOneRequired, this is empty.
+func (e *FlagGroupError) GetProblemFlags() []string {
+	return e.problemFlags
+}
+
+// FlagGroupType identifies which failed validation caused a FlagGroupError.
+type FlagGroupType string
+
+const (
+	FlagsAreMutuallyExclusive FlagGroupType = "if any is set, none of the others can be"
+	FlagsAreRequiredTogether  FlagGroupType = "if any is set, they must all be set"
+	FlagsAreOneRequired       FlagGroupType = "at least one of the flags is required"
+)
+
+// Error implements error.
+func (e *FlagGroupError) Error() string {
+	switch e.flagGroupType {
+	case FlagsAreRequiredTogether:
+		return fmt.Sprintf("if any flags in the group [%v] are set they must all be set; missing %v", e.flagList, e.problemFlags)
+	case FlagsAreOneRequired:
+		return fmt.Sprintf("at least one of the flags in the group [%v] is required", e.flagList)
+	case FlagsAreMutuallyExclusive:
+		return fmt.Sprintf("if any flags in the group [%v] are set none of the others can be; %v were all set", e.flagList, e.problemFlags)
+	}
+
+	panic("invalid flagGroupType")
+}


Here is another implementation logic that could help by implementing Unwrap (please read go std errors package for further information)

It avoids to add more exported types,and help with using errors.Is(err,

Suggested change

// FlagGroupError is the error returned when mutually-required or

// mutually-exclusive flags are not properly specified.

type FlagGroupError struct {

cmd *Command

flagList string

flagGroupType FlagGroupType

problemFlags []string

}

// GetCommand returns the Command that the error occurred in.

func (e *FlagGroupError) GetCommand() *Command {

return e.cmd

}

// GetFlagList returns the flags in the group.

func (e *FlagGroupError) GetFlags() []string {

return strings.Split(e.flagList, " ")

}

// GetFlagGroupType returns the type of flag group causing the error.

//

// Valid types are:

// - FlagsAreMutuallyExclusive for mutually-exclusive flags.

// - FlagsAreRequiredTogether for mutually-required flags.

// - FlagsAreOneRequired for flags where at least one must be present.

func (e *FlagGroupError) GetFlagGroupType() FlagGroupType {

return e.flagGroupType

}

// GetProblemFlags returns the flags causing the error.

//

// For flag groups where:

// - FlagsAreMutuallyExclusive, these are all the flags set.

// - FlagsAreRequiredTogether, these are the missing flags.

// - FlagsAreOneRequired, this is empty.

func (e *FlagGroupError) GetProblemFlags() []string {

return e.problemFlags

}

// FlagGroupType identifies which failed validation caused a FlagGroupError.

type FlagGroupType string

const (

FlagsAreMutuallyExclusive FlagGroupType = "if any is set, none of the others can be"

FlagsAreRequiredTogether FlagGroupType = "if any is set, they must all be set"

FlagsAreOneRequired FlagGroupType = "at least one of the flags is required"

)

// Error implements error.

func (e *FlagGroupError) Error() string {

switch e.flagGroupType {

case FlagsAreRequiredTogether:

return fmt.Sprintf("if any flags in the group [%v] are set they must all be set; missing %v", e.flagList, e.problemFlags)

case FlagsAreOneRequired:

return fmt.Sprintf("at least one of the flags in the group [%v] is required", e.flagList)

case FlagsAreMutuallyExclusive:

return fmt.Sprintf("if any flags in the group [%v] are set none of the others can be; %v were all set", e.flagList, e.problemFlags)

}

panic("invalid flagGroupType")

}

// FlagGroupError is the error returned when mutually-required or

// mutually-exclusive flags are not properly specified.

type FlagGroupError struct {

cmd *Command

flagList string

err error

problemFlags []string

}

// GetCommand returns the Command that the error occurred in.

func (e *FlagGroupError) GetCommand() *Command {

return e.cmd

}

// GetFlagList returns the flags in the group.

func (e *FlagGroupError) GetFlags() []string {

return strings.Split(e.flagList, " ")

}

// Unwrap returns the type of flag group causing the error.

//

// Valid types are:

// - ErrFlagsAreMutuallyExclusive for mutually-exclusive flags.

// - ErrFlagsAreRequiredTogether for mutually-required flags.

// - ErrFlagsAreOneRequired for flags where at least one must be present.

func (e *FlagGroupError) Unwrap() error {

return e.err

}

// GetProblemFlags returns the flags causing the error.

//

// For flag groups where:

// - FlagsAreMutuallyExclusive, these are all the flags set.

// - FlagsAreRequiredTogether, these are the missing flags.

// - FlagsAreOneRequired, this is empty.

func (e *FlagGroupError) GetProblemFlags() []string {

return e.problemFlags

}

var (

ErrFlagsAreMutuallyExclusive = errors.New("if any is set, none of the others can be")

ErrFlagsAreRequiredTogether = errors.New("if any is set, they must all be set")

ErrFlagsAreOneRequired = errors.New("at least one of the flags is required")

)

// Error implements error.

func (e *FlagGroupError) Error() string {

switch {

case errors.Is(err, ErrFlagsAreRequiredTogether):

return fmt.Sprintf("if any flags in the group [%v] are set they must all be set; missing %v", e.flagList, e.problemFlags)

case errors.Is(e.err, ErrFlagsAreOneRequired):

return fmt.Sprintf("at least one of the flags in the group [%v] is required", e.flagList)

case errors.Is(e.err, ErrFlagsAreMutuallyExclusive):

return fmt.Sprintf("if any flags in the group [%v] are set none of the others can be; %v were all set", e.flagList, e.problemFlags)

}

return e.err

}

Good call, yeah. Using errors and errors.Is would be more idiomatic than comparing const strings.

ccoVeille · 2025-05-06T06:15:55Z

flag_groups.go

+		return &FlagGroupError{
+			flagList:      flagList,
+			flagGroupType: FlagsAreRequiredTogether,
+			problemFlags:  unset,


Here and everywhere, I don't see a logic to use a pointer

Suggested change

return &FlagGroupError{

flagList: flagList,

flagGroupType: FlagsAreRequiredTogether,

problemFlags: unset,

return FlagGroupError{

flagList: flagList,

flagGroupType: FlagsAreRequiredTogether,

problemFlags: unset,

It leads to complicated syntax later, and double pointers so you have to do this

var invalidArgCountErr *cobra.InvalidArgCountError if errors.As(err, &invalidArgCountErr) {

When this could be enough

var invalidArgCountErr cobra.InvalidArgCountError if errors.As(err, &invalidArgCountErr) {

I totally agree that it makes the syntax complicated. I'm perfectly happy to change it, but I had a reason for originally choosing to use a pointer receiver for the Error() string method: consistency with how the Go standard library implements error structs*.

A couple examples:

The os/PathError struct, which is used in the example for errors.As.

The json/SyntaxError struct.

The exec/ExecError struct.

A newer recent reason we might want to keep the pointer receivers is for consistency with pflag. When I made the PR to add error structs to that project, it ended up being merged with the pointer-receiver error structs.

*I haven't been able to find any official documentation explaining why the standard library chooses to use pointer receivers for errors, but this Reddit comment explains a compile-time type safety benefit of using them over value receivers.

I know a lot of code in Go standard library are not respecting the Go idiomatic way. So sometimes finding examples in Go code doesn't help much.

Droping @alexandear here.

What do you think about this?

@eth-p you're completely right about os.PathError and others. But I'm sticking to @ccoVeille's approach of returning a non-pointer FlagGroupError as a simpler option.

Other suggestions:

Maybe we should make the FlagGroupError struct unexported (i.e., flagGroupError)? In the future, we can refactor to return a pointer if needed without breaking compatibility.

Should we return error instead of *FlagGroupError?

Fair enough. I just pushed the code with the following changes made:

@ccoVeille's suggestion to make all error structs use value receivers instead of pointer receivers.

@alexandear's suggestion to have validateOneRequiredFlagGroups, validateRequiredFlagGroups, and validateExclusiveFlagGroups return error instead of *FlagGroupError. I had to add a new parameter cmd *Command so those functions could still create a FlagGroupError containing the relevant Command.

Maybe we should make the FlagGroupError struct unexported (i.e., flagGroupError)?

Unfortunately, that would go against the goal for this PR. Adding the error structs is meant to provide a way for callers of Cobra commands to be able to determine the error type and its details without having to parse the error message.

ccoVeille · 2025-05-06T06:18:00Z

site/content/user_guide.md

+  var invalidArgCountErr *cobra.InvalidArgCountError
+  if errors.As(err, &invalidArgCountErr) {


Please read this

#2266 (comment)

ccoVeille · 2025-05-06T06:18:25Z

flag_groups_test.go

+				var flagGroupErr *FlagGroupError
+				if !errors.As(err, &flagGroupErr) {


Please read this

#2266 (comment)

ccoVeille · 2025-05-06T06:19:05Z

flag_groups.go

 	}
 	return nil
 }

-func validateExclusiveFlagGroups(data map[string]map[string]bool) error {
+func validateExclusiveFlagGroups(data map[string]map[string]bool) *FlagGroupError {


Suggested change

func validateExclusiveFlagGroups(data map[string]map[string]bool) *FlagGroupError {

func validateExclusiveFlagGroups(data map[string]map[string]bool) FlagGroupError {

Please read this

#2266 (comment)

ccoVeille · 2025-05-06T06:19:29Z

flag_groups.go

+		return &FlagGroupError{
+			flagList:      flagList,
+			flagGroupType: FlagsAreMutuallyExclusive,
+			problemFlags:  set,
+		}


Suggested change

return &FlagGroupError{

flagList: flagList,

flagGroupType: FlagsAreMutuallyExclusive,

problemFlags: set,

}

return FlagGroupError{

flagList: flagList,

flagGroupType: FlagsAreMutuallyExclusive,

problemFlags: set,

}

Please read this

#2266 (comment)

eth-p · 2025-05-06T08:38:41Z

I implemented your suggestion to use errors.New and errors.Is instead of const strings, and I left a comment explaining why I originally chose to use pointer receivers for the error structs. If you still want me to convert the Error() string functions to value receivers, I can make another set of changes after.

I wasn't able to create fixup commits without causing merge conflicts when squashing them, so here's another diff to summarize this set of changes:

 type FlagGroupError struct {
+	err           error
 	cmd           *Command
 	flagList      string
-	flagGroupType FlagGroupType
 	problemFlags  []string
 }
 
-// FlagGroupType identifies which failed validation caused a FlagGroupError.
-type FlagGroupType string
-
-const (
-	FlagsAreMutuallyExclusive FlagGroupType = "if any is set, none of the others can be"
-	FlagsAreRequiredTogether  FlagGroupType = "if any is set, they must all be set"
-	FlagsAreOneRequired       FlagGroupType = "at least one of the flags is required"
-)
-

+var (
+	// ErrFlagsAreMutuallyExclusive indicates that more than one flag marked by MarkFlagsMutuallyExclusive was provided.
+	ErrFlagsAreMutuallyExclusive = errors.New("if any is set, none of the others can be")
+
+	// ErrFlagsAreRequiredTogether indicates that only one of the flags marked by MarkFlagsRequiredTogether were provided.
+	ErrFlagsAreRequiredTogether = errors.New("if any is set, they must all be set")
+
+	// ErrFlagsAreOneRequired indicates that none of the flags marked by MarkFlagsOneRequired flags were provided.
+	ErrFlagsAreOneRequired = errors.New("at least one of the flags is required")
+)
+

-// GetFlagGroupType returns the type of flag group causing the error.
-// Valid types are:
-//   - FlagsAreMutuallyExclusive for mutually-exclusive flags.
-//   - FlagsAreRequiredTogether for mutually-required flags.
-//   - FlagsAreOneRequired for flags where at least one must be present.
-func (e *FlagGroupError) GetFlagGroupType() FlagGroupType {
-	return e.flagGroupType
-}

+// Unwrap implements errors.Unwrap
+//
+// This returns one of:
+//   - ErrFlagsAreMutuallyExclusive
+//   - ErrFlagsAreRequiredTogether
+//   - ErrFlagsAreOneRequired
+func (e *FlagGroupError) Unwrap() error {
+	return e.err
+}
 
 // Error implements error.
 func (e *FlagGroupError) Error() string {
-	switch e.flagGroupType {
-	case FlagsAreRequiredTogether:
+	switch {
+	case errors.Is(e.err, ErrFlagsAreRequiredTogether):
 		return fmt.Sprintf("if any flags in the group [%v] are set they must all be set; missing %v", e.flagList, e.problemFlags)
-	case FlagsAreOneRequired:
+	case errors.Is(e.err, ErrFlagsAreOneRequired):
 		return fmt.Sprintf("at least one of the flags in the group [%v] is required", e.flagList)
-	case FlagsAreMutuallyExclusive:
+	case errors.Is(e.err, ErrFlagsAreMutuallyExclusive):
 		return fmt.Sprintf("if any flags in the group [%v] are set none of the others can be; %v were all set", e.flagList, e.problemFlags)
 	}
 
-	// If the error struct is empty (i.e. wasn't created by Cobra), e.flagGroupType will be an empty string.
-	// We don't have a specific message to print, so instead just print the struct contents.
+	// If the error struct is empty (i.e. wasn't created by Cobra), e.err will be nil.
+	// We don't have a message to print, so instead just print the struct contents.
 	return fmt.Sprintf("%#v", e)
 }

I left the fmt.Sprintf("%#v") as is, since err can be nil in the same way flagGroupType could be empty, which would've made return e.err.Error() panic.

ccoVeille

I like it.

I feel like it still need some minors adjustment, but I would say, let's wait for @marckhouzam feedbacks. He is the maintainer of cobra. He owns the logic of features.

I don't think there is a need to go further before he comes back to you

ccoVeille · 2025-05-07T18:23:39Z

args_test.go

+func expectErrorAs(err error, target error, t *testing.T) {
+	if err == nil {
+		t.Fatalf("Expected error, got nil")
+	}
+
+	targetType := reflect.TypeOf(target)
+	targetPtr := reflect.New(targetType).Interface() // *SomeError
+	if !errors.As(err, targetPtr) {
+		t.Fatalf("Expected error to be %T, got %T", target, err)
+	}
+}


Why not using simply using this?

Suggested change

func expectErrorAs(err error, target error, t *testing.T) {

if err == nil {

t.Fatalf("Expected error, got nil")

}

targetType := reflect.TypeOf(target)

targetPtr := reflect.New(targetType).Interface() // *SomeError

if !errors.As(err, targetPtr) {

t.Fatalf("Expected error to be %T, got %T", target, err)

}

}

func expectErrorAs(err error, target error, t *testing.T) {

if err == nil {

t.Fatalf("Expected error, got nil")

}

if !errors.As(err, &target) {

t.Fatalf("Expected error to be %T, got %T", target, err)

}

}

Hmm, actually, yeah. Good point. I'll fix it in the next set of changes.

ccoVeille · 2025-05-07T18:23:59Z

args_test.go

+func getCommandName(c *Command) string {
+	if c == nil {
+		return "<nil>"
+	} else {
+		return c.Name()
+	}
+}


Suggested change

func getCommandName(c *Command) string {

if c == nil {

return "<nil>"

} else {

return c.Name()

}

}

func getCommandName(c *Command) string {

if c == nil {

return "<nil>"

}

return c.Name()

}

ccoVeille · 2025-05-07T18:26:07Z

site/content/user_guide.md

+
+  err := rootCmd.Execute()
+
+  var invalidArgCountErr cobra.InvalidArgCountError


Suggested change

var invalidArgCountErr cobra.InvalidArgCountError

var errInvalidArgCount cobra.InvalidArgCountError

ccoVeille · 2025-06-21T15:53:11Z

@marckhouzam could you review this PR ?

cc @caarlos0

caarlos0 · 2025-06-24T18:46:55Z

This would be really useful in some projects I maintain, especially in Fang.

@spf13 @marckhouzam how can I help getting this merged in? :)

spf13 · 2025-07-08T19:57:49Z

@caarlos0 would you be interested in joining the project as a maintainer? Help us evaluate and merge in PRs like this?

caarlos0 · 2025-07-08T20:18:24Z

@spf13 not sure how much time I can put in, but happy to help as much as I can yes! <3

spf13 · 2025-07-08T20:33:37Z

Invited. Welcome to the team.

shadiramadan · 2025-08-01T22:09:55Z

Haha @caarlos0 I found this thread through your comment in Fang!

This is great! I was wondering how I could override the usage errors without simply hiding them!

eth-p changed the title ~~Use structs for CLI-validation errors returned by Cobra.~~ feat: Use structs for CLI-validation errors returned by Cobra. Apr 15, 2025

eth-p mentioned this pull request Apr 22, 2025

feat: Use structs for errors returned by pflag. spf13/pflag#425

Merged

eth-p mentioned this pull request May 5, 2025

Add new type to represent validating required flag error #2274

Open

ccoVeille mentioned this pull request May 5, 2025

args: add new UnknownCommandError type #2178

Open

ccoVeille reviewed May 5, 2025

View reviewed changes

eth-p force-pushed the error-structs branch from a980b4a to e9e4665 Compare May 6, 2025 03:03

ccoVeille reviewed May 6, 2025

View reviewed changes

eth-p force-pushed the error-structs branch 2 times, most recently from 5098ed8 to 355d742 Compare May 6, 2025 08:22

eth-p added 2 commits May 7, 2025 07:41

feat: Use error structs for errors returned in arg validation

4aae22c

feat: Use struct error for errors returned in flag validation

7cc4f93

eth-p force-pushed the error-structs branch from 355d742 to ceb04af Compare May 7, 2025 14:51

eth-p added 3 commits May 7, 2025 07:56

feat: Add getters to error structs

a010bc6

test: Add tests for error structs

d3a8d96

doc: Add user guide section on error structs

4f45711

eth-p force-pushed the error-structs branch from ceb04af to 4f45711 Compare May 7, 2025 14:56

ccoVeille reviewed May 7, 2025

View reviewed changes

		var invalidArgCountErr *cobra.InvalidArgCountError
		if errors.As(err, &invalidArgCountErr) {

		var flagGroupErr *FlagGroupError
		if !errors.As(err, &flagGroupErr) {

	func validateExclusiveFlagGroups(data map[string]map[string]bool) *FlagGroupError {
	func validateExclusiveFlagGroups(data map[string]map[string]bool) FlagGroupError {


		err := rootCmd.Execute()

		var invalidArgCountErr cobra.InvalidArgCountError

	var invalidArgCountErr cobra.InvalidArgCountError
	var errInvalidArgCount cobra.InvalidArgCountError

feat: Use structs for CLI-validation errors returned by Cobra. #2266

Are you sure you want to change the base?

feat: Use structs for CLI-validation errors returned by Cobra. #2266

Uh oh!

Conversation

eth-p commented Apr 15, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

CLAassistant commented Apr 15, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

eth-p commented May 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

ccoVeille left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

eth-p May 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

eth-p commented May 6, 2025

Uh oh!

ccoVeille left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ccoVeille commented Jun 21, 2025

Uh oh!

caarlos0 commented Jun 24, 2025

Uh oh!

spf13 commented Jul 8, 2025

Uh oh!

caarlos0 commented Jul 8, 2025

Uh oh!

spf13 commented Jul 8, 2025

Uh oh!

shadiramadan commented Aug 1, 2025

Uh oh!

Uh oh!

eth-p commented Apr 15, 2025 •

edited

Loading

CLAassistant commented Apr 15, 2025 •

edited

Loading

eth-p commented May 6, 2025 •

edited

Loading

eth-p May 6, 2025 •

edited

Loading