mirror of
https://github.com/jesseduffield/lazygit.git
synced 2024-12-10 11:10:18 +02:00
756 lines
28 KiB
Go
756 lines
28 KiB
Go
package flaggy
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// Subcommand represents a subcommand which contains a set of child
|
|
// subcommands along with a set of flags relevant to it. Parsing
|
|
// runs until a subcommand is detected by matching its name and
|
|
// position. Once a matching subcommand is found, the next set
|
|
// of parsing occurs within that matched subcommand.
|
|
type Subcommand struct {
|
|
Name string
|
|
ShortName string
|
|
Description string
|
|
Position int // the position of this subcommand, not including flags
|
|
Subcommands []*Subcommand
|
|
Flags []*Flag
|
|
PositionalFlags []*PositionalValue
|
|
ParsedValues []parsedValue // a list of values and positionals parsed
|
|
AdditionalHelpPrepend string // additional prepended message when Help is displayed
|
|
AdditionalHelpAppend string // additional appended message when Help is displayed
|
|
Used bool // indicates this subcommand was found and parsed
|
|
Hidden bool // indicates this subcommand should be hidden from help
|
|
}
|
|
|
|
// NewSubcommand creates a new subcommand that can have flags or PositionalFlags
|
|
// added to it. The position starts with 1, not 0
|
|
func NewSubcommand(name string) *Subcommand {
|
|
if len(name) == 0 {
|
|
fmt.Fprintln(os.Stderr, "Error creating subcommand (NewSubcommand()). No subcommand name was specified.")
|
|
exitOrPanic(2)
|
|
}
|
|
newSC := &Subcommand{
|
|
Name: name,
|
|
}
|
|
return newSC
|
|
}
|
|
|
|
// parseAllFlagsFromArgs parses the non-positional flags such as -f or -v=value
|
|
// out of the supplied args and returns the resulting positional items in order,
|
|
// all the flag names found (without values), a bool to indicate if help was
|
|
// requested, and any errors found during parsing
|
|
func (sc *Subcommand) parseAllFlagsFromArgs(p *Parser, args []string) ([]string, bool, error) {
|
|
|
|
var positionalOnlyArguments []string
|
|
var helpRequested bool // indicates the user has supplied -h and we
|
|
// should render help if we are the last subcommand
|
|
|
|
// indicates we should skip the next argument, like when parsing a flag
|
|
// that separates key and value by space
|
|
var skipNext bool
|
|
|
|
// endArgfound indicates that a -- was found and everything
|
|
// remaining should be added to the trailing arguments slices
|
|
var endArgFound bool
|
|
|
|
// find all the normal flags (not positional) and parse them out
|
|
for i, a := range args {
|
|
|
|
debugPrint("parsing arg:", a)
|
|
|
|
// evaluate if there is a following arg to avoid panics
|
|
var nextArgExists bool
|
|
var nextArg string
|
|
if len(args)-1 >= i+1 {
|
|
nextArgExists = true
|
|
nextArg = args[i+1]
|
|
}
|
|
|
|
// if end arg -- has been found, just add everything to TrailingArguments
|
|
if endArgFound {
|
|
if !p.trailingArgumentsExtracted {
|
|
p.TrailingArguments = append(p.TrailingArguments, a)
|
|
}
|
|
continue
|
|
}
|
|
|
|
// skip this run if specified
|
|
if skipNext {
|
|
skipNext = false
|
|
debugPrint("skipping flag because it is an arg:", a)
|
|
continue
|
|
}
|
|
|
|
// parse the flag into its name for consideration without dashes
|
|
flagName := parseFlagToName(a)
|
|
|
|
// if the flag being passed is version or v and the option to display
|
|
// version with version flags, then display version
|
|
if p.ShowVersionWithVersionFlag {
|
|
if flagName == versionFlagLongName {
|
|
p.ShowVersionAndExit()
|
|
}
|
|
}
|
|
|
|
// if the show Help on h flag option is set, then show Help when h or Help
|
|
// is passed as an option
|
|
if p.ShowHelpWithHFlag {
|
|
if flagName == helpFlagShortName || flagName == helpFlagLongName {
|
|
// Ensure this is the last subcommand passed so we give the correct
|
|
// help output
|
|
helpRequested = true
|
|
continue
|
|
}
|
|
}
|
|
|
|
// determine what kind of flag this is
|
|
argType := determineArgType(a)
|
|
|
|
// strip flags from arg
|
|
// debugPrint("Parsing flag named", a, "of type", argType)
|
|
|
|
// depending on the flag type, parse the key and value out, then apply it
|
|
switch argType {
|
|
case argIsFinal:
|
|
// debugPrint("Arg", i, "is final:", a)
|
|
endArgFound = true
|
|
case argIsPositional:
|
|
// debugPrint("Arg is positional or subcommand:", a)
|
|
// this positional argument into a slice of their own, so that
|
|
// we can determine if its a subcommand or positional value later
|
|
positionalOnlyArguments = append(positionalOnlyArguments, a)
|
|
// track this as a parsed value with the subcommand
|
|
sc.addParsedPositionalValue(a)
|
|
case argIsFlagWithSpace: // a flag with a space. ex) -k v or --key value
|
|
a = parseFlagToName(a)
|
|
|
|
// debugPrint("Arg", i, "is flag with space:", a)
|
|
// parse next arg as value to this flag and apply to subcommand flags
|
|
// if the flag is a bool flag, then we check for a following positional
|
|
// and skip it if necessary
|
|
if flagIsBool(sc, p, a) {
|
|
debugPrint(sc.Name, "bool flag", a, "next var is:", nextArg)
|
|
// set the value in this subcommand and its root parser
|
|
valueSet, err := setValueForParsers(a, "true", p, sc)
|
|
|
|
// if an error occurs, just return it and quit parsing
|
|
if err != nil {
|
|
return []string{}, false, err
|
|
}
|
|
|
|
// log all values parsed by this subcommand. We leave the value blank
|
|
// because the bool value had no explicit true or false supplied
|
|
if valueSet {
|
|
sc.addParsedFlag(a, "")
|
|
}
|
|
|
|
// we've found and set a standalone bool flag, so we move on to the next
|
|
// argument in the list of arguments
|
|
continue
|
|
}
|
|
|
|
skipNext = true
|
|
// debugPrint(sc.Name, "NOT bool flag", a)
|
|
|
|
// if the next arg was not found, then show a Help message
|
|
if !nextArgExists {
|
|
p.ShowHelpWithMessage("Expected a following arg for flag " + a + ", but it did not exist.")
|
|
exitOrPanic(2)
|
|
}
|
|
valueSet, err := setValueForParsers(a, nextArg, p, sc)
|
|
if err != nil {
|
|
return []string{}, false, err
|
|
}
|
|
|
|
// log all parsed values in the subcommand
|
|
if valueSet {
|
|
sc.addParsedFlag(a, nextArg)
|
|
}
|
|
case argIsFlagWithValue: // a flag with an equals sign. ex) -k=v or --key=value
|
|
// debugPrint("Arg", i, "is flag with value:", a)
|
|
a = parseFlagToName(a)
|
|
|
|
// parse flag into key and value and apply to subcommand flags
|
|
key, val := parseArgWithValue(a)
|
|
|
|
// set the value in this subcommand and its root parser
|
|
valueSet, err := setValueForParsers(key, val, p, sc)
|
|
if err != nil {
|
|
return []string{}, false, err
|
|
}
|
|
|
|
// log all values parsed by the subcommand
|
|
if valueSet {
|
|
sc.addParsedFlag(a, val)
|
|
}
|
|
}
|
|
}
|
|
|
|
return positionalOnlyArguments, helpRequested, nil
|
|
}
|
|
|
|
// findAllParsedValues finds all values parsed by all subcommands and this
|
|
// subcommand and its child subcommands
|
|
func (sc *Subcommand) findAllParsedValues() []parsedValue {
|
|
parsedValues := sc.ParsedValues
|
|
for _, sc := range sc.Subcommands {
|
|
// skip unused subcommands
|
|
if !sc.Used {
|
|
continue
|
|
}
|
|
parsedValues = append(parsedValues, sc.findAllParsedValues()...)
|
|
}
|
|
return parsedValues
|
|
}
|
|
|
|
// parse causes the argument parser to parse based on the supplied []string.
|
|
// depth specifies the non-flag subcommand positional depth. A slice of flags
|
|
// and subcommands parsed is returned so that the parser can ultimately decide
|
|
// if there were any unexpected values supplied by the user
|
|
func (sc *Subcommand) parse(p *Parser, args []string, depth int) error {
|
|
|
|
debugPrint("- Parsing subcommand", sc.Name, "with depth of", depth, "and args", args)
|
|
|
|
// if a command is parsed, its used
|
|
sc.Used = true
|
|
debugPrint("used subcommand", sc.Name, sc.ShortName)
|
|
if len(sc.Name) > 0 {
|
|
sc.addParsedPositionalValue(sc.Name)
|
|
}
|
|
if len(sc.ShortName) > 0 {
|
|
sc.addParsedPositionalValue(sc.ShortName)
|
|
}
|
|
|
|
// as subcommands are used, they become the context of the parser. This helps
|
|
// us understand how to display help based on which subcommand is being used
|
|
p.subcommandContext = sc
|
|
|
|
// ensure that help and version flags are not used if the parser has the
|
|
// built-in help and version flags enabled
|
|
if p.ShowHelpWithHFlag {
|
|
sc.ensureNoConflictWithBuiltinHelp()
|
|
}
|
|
if p.ShowVersionWithVersionFlag {
|
|
sc.ensureNoConflictWithBuiltinVersion()
|
|
}
|
|
|
|
// Parse the normal flags out of the argument list and return the positionals
|
|
// (subcommands and positional values), along with the flags used.
|
|
// Then the flag values are applied to the parent parser and the current
|
|
// subcommand being parsed.
|
|
positionalOnlyArguments, helpRequested, err := sc.parseAllFlagsFromArgs(p, args)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// indicate that trailing arguments have been extracted, so that they aren't
|
|
// appended a second time
|
|
p.trailingArgumentsExtracted = true
|
|
|
|
// loop over positional values and look for their matching positional
|
|
// parameter, or their positional command. If neither are found, then
|
|
// we throw an error
|
|
var parsedArgCount int
|
|
for pos, v := range positionalOnlyArguments {
|
|
|
|
// the first relative positional argument will be human natural at position 1
|
|
// but offset for the depth of relative commands being parsed for currently.
|
|
relativeDepth := pos - depth + 1
|
|
// debugPrint("Parsing positional only position", relativeDepth, "with value", v)
|
|
|
|
if relativeDepth < 1 {
|
|
// debugPrint(sc.Name, "skipped value:", v)
|
|
continue
|
|
}
|
|
parsedArgCount++
|
|
|
|
// determine subcommands and parse them by positional value and name
|
|
for _, cmd := range sc.Subcommands {
|
|
// debugPrint("Subcommand being compared", relativeDepth, "==", cmd.Position, "and", v, "==", cmd.Name, "==", cmd.ShortName)
|
|
if relativeDepth == cmd.Position && (v == cmd.Name || v == cmd.ShortName) {
|
|
debugPrint("Decending into positional subcommand", cmd.Name, "at relativeDepth", relativeDepth, "and absolute depth", depth+1)
|
|
return cmd.parse(p, args, depth+parsedArgCount) // continue recursive positional parsing
|
|
}
|
|
}
|
|
|
|
// determine positional args and parse them by positional value and name
|
|
var foundPositional bool
|
|
for _, val := range sc.PositionalFlags {
|
|
if relativeDepth == val.Position {
|
|
debugPrint("Found a positional value at relativePos:", relativeDepth, "value:", v)
|
|
|
|
// set original value for help output
|
|
val.defaultValue = *val.AssignmentVar
|
|
|
|
// defrerence the struct pointer, then set the pointer property within it
|
|
*val.AssignmentVar = v
|
|
// debugPrint("set positional to value", *val.AssignmentVar)
|
|
foundPositional = true
|
|
val.Found = true
|
|
break
|
|
}
|
|
}
|
|
|
|
// if there aren't any positional flags but there are subcommands that
|
|
// were not used, display a useful message with subcommand options.
|
|
if !foundPositional && p.ShowHelpOnUnexpected {
|
|
debugPrint("No positional at position", relativeDepth)
|
|
var foundSubcommandAtDepth bool
|
|
for _, cmd := range sc.Subcommands {
|
|
if cmd.Position == relativeDepth {
|
|
foundSubcommandAtDepth = true
|
|
}
|
|
}
|
|
|
|
// if there is a subcommand here but it was not specified, display them all
|
|
// as a suggestion to the user before exiting.
|
|
if foundSubcommandAtDepth {
|
|
// determine which name to use in upcoming help output
|
|
fmt.Fprintln(os.Stderr, sc.Name+":", "No subcommand or positional value found at position", strconv.Itoa(relativeDepth)+".")
|
|
var output string
|
|
for _, cmd := range sc.Subcommands {
|
|
if cmd.Hidden {
|
|
continue
|
|
}
|
|
output = output + " " + cmd.Name
|
|
}
|
|
// if there are available subcommands, let the user know
|
|
if len(output) > 0 {
|
|
output = strings.TrimLeft(output, " ")
|
|
fmt.Println("Available subcommands:", output)
|
|
}
|
|
exitOrPanic(2)
|
|
}
|
|
|
|
// if there were not any flags or subcommands at this position at all, then
|
|
// throw an error (display Help if necessary)
|
|
p.ShowHelpWithMessage("Unexpected argument: " + v)
|
|
exitOrPanic(2)
|
|
}
|
|
}
|
|
|
|
// if help was requested and we should show help when h is passed,
|
|
if helpRequested && p.ShowHelpWithHFlag {
|
|
p.ShowHelp()
|
|
exitOrPanic(0)
|
|
}
|
|
|
|
// find any positionals that were not used on subcommands that were
|
|
// found and throw help (unknown argument) in the global parse or subcommand
|
|
for _, pv := range p.PositionalFlags {
|
|
if pv.Required && !pv.Found {
|
|
p.ShowHelpWithMessage("Required global positional variable " + pv.Name + " not found at position " + strconv.Itoa(pv.Position))
|
|
exitOrPanic(2)
|
|
}
|
|
}
|
|
for _, pv := range sc.PositionalFlags {
|
|
if pv.Required && !pv.Found {
|
|
p.ShowHelpWithMessage("Required positional of subcommand " + sc.Name + " named " + pv.Name + " not found at position " + strconv.Itoa(pv.Position))
|
|
exitOrPanic(2)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// addParsedFlag makes it easy to append flag values parsed by the subcommand
|
|
func (sc *Subcommand) addParsedFlag(key string, value string) {
|
|
sc.ParsedValues = append(sc.ParsedValues, newParsedValue(key, value, false))
|
|
}
|
|
|
|
// addParsedPositionalValue makes it easy to append positionals parsed by the
|
|
// subcommand
|
|
func (sc *Subcommand) addParsedPositionalValue(value string) {
|
|
sc.ParsedValues = append(sc.ParsedValues, newParsedValue("", value, true))
|
|
}
|
|
|
|
// FlagExists lets you know if the flag name exists as either a short or long
|
|
// name in the (sub)command
|
|
func (sc *Subcommand) FlagExists(name string) bool {
|
|
|
|
for _, f := range sc.Flags {
|
|
if f.HasName(name) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// AttachSubcommand adds a possible subcommand to the Parser.
|
|
func (sc *Subcommand) AttachSubcommand(newSC *Subcommand, relativePosition int) {
|
|
|
|
// assign the depth of the subcommand when its attached
|
|
newSC.Position = relativePosition
|
|
|
|
// ensure no subcommands at this depth with this name
|
|
for _, other := range sc.Subcommands {
|
|
if newSC.Position == other.Position {
|
|
if newSC.Name != "" {
|
|
if newSC.Name == other.Name {
|
|
log.Panicln("Unable to add subcommand because one already exists at position" + strconv.Itoa(newSC.Position) + " with name " + other.Name)
|
|
}
|
|
}
|
|
if newSC.ShortName != "" {
|
|
if newSC.ShortName == other.ShortName {
|
|
log.Panicln("Unable to add subcommand because one already exists at position" + strconv.Itoa(newSC.Position) + " with name " + other.ShortName)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ensure no positionals at this depth
|
|
for _, other := range sc.PositionalFlags {
|
|
if newSC.Position == other.Position {
|
|
log.Panicln("Unable to add subcommand because a positional value already exists at position " + strconv.Itoa(newSC.Position) + ": " + other.Name)
|
|
}
|
|
}
|
|
|
|
sc.Subcommands = append(sc.Subcommands, newSC)
|
|
}
|
|
|
|
// add is a "generic" to add flags of any type. Checks the supplied parent
|
|
// parser to ensure that the user isn't setting version or help flags that
|
|
// conflict with the built-in help and version flag behavior.
|
|
func (sc *Subcommand) add(assignmentVar interface{}, shortName string, longName string, description string) {
|
|
|
|
// if the flag is already used, throw an error
|
|
for _, existingFlag := range sc.Flags {
|
|
if longName != "" && existingFlag.LongName == longName {
|
|
log.Panicln("Flag " + longName + " added to subcommand " + sc.Name + " but the name is already assigned.")
|
|
}
|
|
if shortName != "" && existingFlag.ShortName == shortName {
|
|
log.Panicln("Flag " + shortName + " added to subcommand " + sc.Name + " but the short name is already assigned.")
|
|
}
|
|
}
|
|
|
|
newFlag := Flag{
|
|
AssignmentVar: assignmentVar,
|
|
ShortName: shortName,
|
|
LongName: longName,
|
|
Description: description,
|
|
}
|
|
sc.Flags = append(sc.Flags, &newFlag)
|
|
}
|
|
|
|
// String adds a new string flag
|
|
func (sc *Subcommand) String(assignmentVar *string, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// StringSlice adds a new slice of strings flag
|
|
// Specify the flag multiple times to fill the slice
|
|
func (sc *Subcommand) StringSlice(assignmentVar *[]string, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Bool adds a new bool flag
|
|
func (sc *Subcommand) Bool(assignmentVar *bool, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// BoolSlice adds a new slice of bools flag
|
|
// Specify the flag multiple times to fill the slice
|
|
func (sc *Subcommand) BoolSlice(assignmentVar *[]bool, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// ByteSlice adds a new slice of bytes flag
|
|
// Specify the flag multiple times to fill the slice. Takes hex as input.
|
|
func (sc *Subcommand) ByteSlice(assignmentVar *[]byte, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Duration adds a new time.Duration flag.
|
|
// Input format is described in time.ParseDuration().
|
|
// Example values: 1h, 1h50m, 32s
|
|
func (sc *Subcommand) Duration(assignmentVar *time.Duration, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// DurationSlice adds a new time.Duration flag.
|
|
// Input format is described in time.ParseDuration().
|
|
// Example values: 1h, 1h50m, 32s
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) DurationSlice(assignmentVar *[]time.Duration, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Float32 adds a new float32 flag.
|
|
func (sc *Subcommand) Float32(assignmentVar *float32, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Float32Slice adds a new float32 flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) Float32Slice(assignmentVar *[]float32, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Float64 adds a new float64 flag.
|
|
func (sc *Subcommand) Float64(assignmentVar *float64, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Float64Slice adds a new float64 flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) Float64Slice(assignmentVar *[]float64, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int adds a new int flag
|
|
func (sc *Subcommand) Int(assignmentVar *int, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// IntSlice adds a new int slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) IntSlice(assignmentVar *[]int, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt adds a new uint flag
|
|
func (sc *Subcommand) UInt(assignmentVar *uint, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UIntSlice adds a new uint slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) UIntSlice(assignmentVar *[]uint, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt64 adds a new uint64 flag
|
|
func (sc *Subcommand) UInt64(assignmentVar *uint64, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt64Slice adds a new uint64 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) UInt64Slice(assignmentVar *[]uint64, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt32 adds a new uint32 flag
|
|
func (sc *Subcommand) UInt32(assignmentVar *uint32, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt32Slice adds a new uint32 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) UInt32Slice(assignmentVar *[]uint32, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt16 adds a new uint16 flag
|
|
func (sc *Subcommand) UInt16(assignmentVar *uint16, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt16Slice adds a new uint16 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) UInt16Slice(assignmentVar *[]uint16, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt8 adds a new uint8 flag
|
|
func (sc *Subcommand) UInt8(assignmentVar *uint8, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// UInt8Slice adds a new uint8 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) UInt8Slice(assignmentVar *[]uint8, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int64 adds a new int64 flag.
|
|
func (sc *Subcommand) Int64(assignmentVar *int64, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int64Slice adds a new int64 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) Int64Slice(assignmentVar *[]int64, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int32 adds a new int32 flag
|
|
func (sc *Subcommand) Int32(assignmentVar *int32, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int32Slice adds a new int32 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) Int32Slice(assignmentVar *[]int32, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int16 adds a new int16 flag
|
|
func (sc *Subcommand) Int16(assignmentVar *int16, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int16Slice adds a new int16 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) Int16Slice(assignmentVar *[]int16, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int8 adds a new int8 flag
|
|
func (sc *Subcommand) Int8(assignmentVar *int8, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// Int8Slice adds a new int8 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) Int8Slice(assignmentVar *[]int8, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// IP adds a new net.IP flag.
|
|
func (sc *Subcommand) IP(assignmentVar *net.IP, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// IPSlice adds a new int8 slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) IPSlice(assignmentVar *[]net.IP, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// HardwareAddr adds a new net.HardwareAddr flag.
|
|
func (sc *Subcommand) HardwareAddr(assignmentVar *net.HardwareAddr, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// HardwareAddrSlice adds a new net.HardwareAddr slice flag.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) HardwareAddrSlice(assignmentVar *[]net.HardwareAddr, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// IPMask adds a new net.IPMask flag. IPv4 Only.
|
|
func (sc *Subcommand) IPMask(assignmentVar *net.IPMask, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// IPMaskSlice adds a new net.HardwareAddr slice flag. IPv4 only.
|
|
// Specify the flag multiple times to fill the slice.
|
|
func (sc *Subcommand) IPMaskSlice(assignmentVar *[]net.IPMask, shortName string, longName string, description string) {
|
|
sc.add(assignmentVar, shortName, longName, description)
|
|
}
|
|
|
|
// AddPositionalValue adds a positional value to the subcommand. the
|
|
// relativePosition starts at 1 and is relative to the subcommand it belongs to
|
|
func (sc *Subcommand) AddPositionalValue(assignmentVar *string, name string, relativePosition int, required bool, description string) {
|
|
|
|
// ensure no other positionals are at this depth
|
|
for _, other := range sc.PositionalFlags {
|
|
if relativePosition == other.Position {
|
|
log.Panicln("Unable to add positional value because one already exists at position: " + strconv.Itoa(relativePosition))
|
|
}
|
|
}
|
|
|
|
// ensure no subcommands at this depth
|
|
for _, other := range sc.Subcommands {
|
|
if relativePosition == other.Position {
|
|
log.Panicln("Unable to add positional value a subcommand already exists at position: " + strconv.Itoa(relativePosition))
|
|
}
|
|
}
|
|
|
|
newPositionalValue := PositionalValue{
|
|
Name: name,
|
|
Position: relativePosition,
|
|
AssignmentVar: assignmentVar,
|
|
Required: required,
|
|
Description: description,
|
|
defaultValue: *assignmentVar,
|
|
}
|
|
sc.PositionalFlags = append(sc.PositionalFlags, &newPositionalValue)
|
|
}
|
|
|
|
// SetValueForKey sets the value for the specified key. If setting a bool
|
|
// value, then send "true" or "false" as strings. The returned bool indicates
|
|
// that a value was set.
|
|
func (sc *Subcommand) SetValueForKey(key string, value string) (bool, error) {
|
|
|
|
// debugPrint("Looking to set key", key, "to value", value)
|
|
// check for and assign flags that match the key
|
|
for _, f := range sc.Flags {
|
|
// debugPrint("Evaluating string flag", f.ShortName, "==", key, "||", f.LongName, "==", key)
|
|
if f.ShortName == key || f.LongName == key {
|
|
// debugPrint("Setting string value for", key, "to", value)
|
|
f.identifyAndAssignValue(value)
|
|
return true, nil
|
|
}
|
|
}
|
|
|
|
// debugPrint(sc.Name, "was unable to find a key named", key, "to set to value", value)
|
|
return false, nil
|
|
}
|
|
|
|
// ensureNoConflictWithBuiltinHelp ensures that the flags on this subcommand do
|
|
// not conflict with the builtin help flags (-h or --help). Exits the program
|
|
// if a conflict is found.
|
|
func (sc *Subcommand) ensureNoConflictWithBuiltinHelp() {
|
|
for _, f := range sc.Flags {
|
|
if f.LongName == helpFlagLongName {
|
|
sc.exitBecauseOfHelpFlagConflict(f.LongName)
|
|
}
|
|
if f.LongName == helpFlagShortName {
|
|
sc.exitBecauseOfHelpFlagConflict(f.LongName)
|
|
}
|
|
if f.ShortName == helpFlagLongName {
|
|
sc.exitBecauseOfHelpFlagConflict(f.ShortName)
|
|
}
|
|
if f.ShortName == helpFlagShortName {
|
|
sc.exitBecauseOfHelpFlagConflict(f.ShortName)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ensureNoConflictWithBuiltinVersion ensures that the flags on this subcommand do
|
|
// not conflict with the builtin version flag (--version). Exits the program
|
|
// if a conflict is found.
|
|
func (sc *Subcommand) ensureNoConflictWithBuiltinVersion() {
|
|
for _, f := range sc.Flags {
|
|
if f.LongName == versionFlagLongName {
|
|
sc.exitBecauseOfVersionFlagConflict(f.LongName)
|
|
}
|
|
if f.ShortName == versionFlagLongName {
|
|
sc.exitBecauseOfVersionFlagConflict(f.ShortName)
|
|
}
|
|
}
|
|
}
|
|
|
|
// exitBecauseOfVersionFlagConflict exits the program with a message about how to prevent
|
|
// flags being defined from conflicting with the builtin flags.
|
|
func (sc *Subcommand) exitBecauseOfVersionFlagConflict(flagName string) {
|
|
fmt.Println(`Flag with name '` + flagName + `' conflicts with the internal --version flag in flaggy.
|
|
|
|
You must either change the flag's name, or disable flaggy's internal version
|
|
flag with 'flaggy.DefaultParser.ShowVersionWithVersionFlag = false'. If you are using
|
|
a custom parser, you must instead set '.ShowVersionWithVersionFlag = false' on it.`)
|
|
exitOrPanic(1)
|
|
}
|
|
|
|
// exitBecauseOfHelpFlagConflict exits the program with a message about how to prevent
|
|
// flags being defined from conflicting with the builtin flags.
|
|
func (sc *Subcommand) exitBecauseOfHelpFlagConflict(flagName string) {
|
|
fmt.Println(`Flag with name '` + flagName + `' conflicts with the internal --help or -h flag in flaggy.
|
|
|
|
You must either change the flag's name, or disable flaggy's internal help
|
|
flag with 'flaggy.DefaultParser.ShowHelpWithHFlag = false'. If you are using
|
|
a custom parser, you must instead set '.ShowHelpWithHFlag = false' on it.`)
|
|
exitOrPanic(1)
|
|
}
|