path: root/vendor/github.com/integrii/flaggy/subCommand.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,