// Test if the named flag is a boolean flag. func isBooleanFlag(name string, f *flag.FlagSet) bool { flag := f.Lookup(name) if flag == nil { return false } return flag.Value.Type() == "bool" }
func manPrintFlags(out *bytes.Buffer, flags *pflag.FlagSet) { flags.VisitAll(func(flag *pflag.Flag) { if len(flag.Deprecated) > 0 || flag.Hidden { return } format := "" if len(flag.Shorthand) > 0 { format = "**-%s**, **--%s**" } else { format = "%s**--%s**" } if len(flag.NoOptDefVal) > 0 { format = format + "[" } if flag.Value.Type() == "string" { // put quotes on the value format = format + "=%q" } else { format = format + "=%s" } if len(flag.NoOptDefVal) > 0 { format = format + "]" } format = format + "\n\t%s\n\n" fmt.Fprintf(out, format, flag.Shorthand, flag.Name, flag.DefValue, flag.Usage) }) }
func rktFlagUsages(flagSet *pflag.FlagSet) string { x := new(bytes.Buffer) flagSet.VisitAll(func(flag *pflag.Flag) { if len(flag.Deprecated) > 0 || flag.Hidden { return } format := "" if len(flag.Shorthand) > 0 && len(flag.ShorthandDeprecated) == 0 { format = " -%s, --%s" } else { format = " %s --%s" } if len(flag.NoOptDefVal) > 0 { format = format + "[" } if flag.Value.Type() == "string" { // put quotes on the value format = format + "=%q" } else { format = format + "=%s" } if len(flag.NoOptDefVal) > 0 { format = format + "]" } format = format + "\t%s\n" shorthand := flag.Shorthand fmt.Fprintf(x, format, shorthand, flag.Name, flag.DefValue, flag.Usage) }) return x.String() }
// Test if the named flag is a boolean flag. func isBooleanShortFlag(name string, f *flag.FlagSet) bool { result := false f.VisitAll(func(f *flag.Flag) { if f.Shorthand == name && f.Value.Type() == "bool" { result = true } }) return result }
func InstallDeprecatedSkipVerify(flagset *pflag.FlagSet, flags *SecFlags) { sv := &skipVerify{ flags: flags, } svFlag := flagset.VarPF(sv, "insecure-skip-verify", "", "DEPRECATED") svFlag.DefValue = "false" svFlag.NoOptDefVal = "true" svFlag.Hidden = true svFlag.Deprecated = "please use --insecure-options." }
// parseApps looks through the args for support of per-app argument lists delimited with "--" and "---". // Between per-app argument lists flags.Parse() is called using the supplied FlagSet. // Anything not consumed by flags.Parse() and not found to be a per-app argument list is treated as an image. // allowAppArgs controls whether "--" prefixed per-app arguments will be accepted or not. func parseApps(al *apps.Apps, args []string, flags *pflag.FlagSet, allowAppArgs bool) error { nAppsLastAppArgs := al.Count() // valid args here may either be: // not-"--"; flags handled by *flags or an image specifier // "--"; app arguments begin // "---"; conclude app arguments // between "--" and "---" pairs anything is permitted. inAppArgs := false for i := 0; i < len(args); i++ { a := args[i] if inAppArgs { switch a { case "---": // conclude this app's args inAppArgs = false default: // keep appending to this app's args app := al.Last() app.Args = append(app.Args, a) } } else { switch a { case "--": if !allowAppArgs { return fmt.Errorf("app arguments unsupported") } // begin app's args inAppArgs = true // catch some likely mistakes if nAppsLastAppArgs == al.Count() { if al.Count() == 0 { return fmt.Errorf("an image is required before any app arguments") } return fmt.Errorf("only one set of app arguments allowed per image") } nAppsLastAppArgs = al.Count() case "---": // ignore triple dashes since they aren't images // TODO(vc): I don't think ignoring this is appropriate, probably should error; it implies malformed argv. // "---" is not an image separator, it's an optional argument list terminator. // encountering it outside of inAppArgs is likely to be "--" typoed default: // consume any potential inter-app flags if err := flags.Parse(args[i:]); err != nil { return err } nInterFlags := (len(args[i:]) - flags.NArg()) if nInterFlags > 0 { // XXX(vc): flag.Parse() annoyingly consumes the "--", reclaim it here if necessary if args[i+nInterFlags-1] == "--" { nInterFlags-- } // advance past what flags.Parse() consumed i += nInterFlags - 1 // - 1 because of i++ } else { // flags.Parse() didn't want this arg, treat as image al.Create(a) } } } } return al.Validate() }
// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists. // Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error { return flags.SetAnnotation(name, BashCompFilenameExt, extensions) }
// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists. func MarkFlagRequired(flags *pflag.FlagSet, name string) error { return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"}) }
// addStage1ImageFlag adds a flag for specifying custom stage1 image // path func addStage1ImageFlag(flags *pflag.FlagSet) { flags.String(stage1ImageFlagName, defaultStage1Image, stage1ImageFlagHelp()) }