Question: how to make flags required

[tleyden]

I'm defining some flags like this:

    follow_sync_gwCmd.PersistentFlags().String("url", "", "Sync Gateway URL")
    follow_sync_gwCmd.MarkPersistentFlagRequired("url")

and even explicitly calling ParseFlags (out of desperation):

    Run: func(cmd *cobra.Command, args []string) {

        if err := cmd.ParseFlags(args); err != nil {
            log.Printf("err: %v", err)
        }
                ...
    },

and calling:

$ go run main.go follow_sync_gw

with no --url flag, but cobra isn't throwing errors.

I was expecting that if I set MarkPersistentFlagRequired but failed to pass the flag on the command line then the command would fail with an error and a usage example.

[apriendeau]

I am not sure that is implemented as it uses, pflag

So there is no direct way unless you do it in PreRun function with an if or switch but I could be wrong but that is how I have handled it in the past.

[eparis]

Really its just a bad name since it was never implemented. It will cause bash completions and things to always suggest that flag, but we aren't enforcing it. You doing it in a PreRunE is a good idea.

[tleyden]

I didn't know about the PreRun function, I'll look into that. Yeah, the name is misleading .. so does that mean calling MarkPersistentFlagRequired has no effect whatsoever?

[apriendeau]

@tleyden use PreRunE 👍

[eparis]

At this time its only effect is on the bash completions :-(

I will try to write a PreRunE which enforces it....

[ApsOps]

MarkFlagRequired and MarkPersistentFlagRequired should enforce the flag IMO. Or the function name should be different at least. I just wasted an hour wondering why it's not working :/

[crux]

just a reminder, if it is required it is an parameter, or argument. If it is and option or flag it is NOT required. That is the very nature of flags and options. Every command line library supporting "required" or mandatory options/flags I would considered broken by design.

[davidcpell]

@crux like the heroku toolbelt which which requires the name of the application you're dealing with to be passed to the -a flag?

[thomaspeitz]

From my point of view it it makes sense to use arguments if there are only a few (1-3) but as soon as you have more mandatory arguments, it makes sense to use flags. Otherwise it is hard to keep the overview.

[0xC0D3D00D]

If you need it I wrote something for this purpose. It could be done better but this does the work. You just need to mark the flags as required and then:

import (
	"errors"
	"github.com/spf13/cobra"
	"github.com/spf13/pflag"
)

func CheckRequiredFlags(flags *pflag.FlagSet) error {
	requiredError := false
	flagName := ""

	flags.VisitAll(func(flag *pflag.Flag) {
		requiredAnnotation := flag.Annotations[cobra.BashCompOneRequiredFlag]
		if len(requiredAnnotation) == 0 {
			return
		}

		flagRequired := requiredAnnotation[0] == "true"

		if flagRequired && !flag.Changed {
			requiredError = true
			flagName = flag.Name
		}
	})

	if requiredError {
		return errors.New("Required flag `" + flagName + "` has not been set")
	}

	return nil
}

Then add these in PreRunE:

...
	PreRunE: func(cmd *cobra.Command, args []string) error {
		return CheckRequiredFlags(cmd.Flags())
	},
...