package main

import (
    "fmt"

    "github.com/karrick/golf"
)

func main() {
    // 'Type' functions are exactly like their corresponding functions from
    // the 'flag' standard library. However the length of the argument string
    // determines whether a single or double-hyphen prefix is used to change
    // its value. When this argument is a single rune long string then a
    // single-hyphen prefix is used to change its value, for example, "V" will
    // configure the parser to associate '-V' with the option. Otherwise a
    // double-hyphen prefix is used to change its value, for example,
    // "version" will configure the parser to associate '--version' with the
    // option.
    optType1 := golf.Bool("b", false, "can take a one rune flag name and return a variable pointer")
    otpType2 := golf.String("id", "", "can also take a multiple rune flag name and return a variable pointer")

    // 'TypeP' functions take two arguments. The first argument is a rune to
    // be associated with a single-hyphen prefix, for example, '-V'. The
    // second argument is a string to be associated with a double-hyphen
    // prefix, for example, '--version'.
    optTypeP := golf.DurationP('d', "duration", 0, "takes a one rune and a multiple rune flag name and returns a pointer to a variable")

    // The difference between 'Type' and 'TypeVar' is 'Type' returns a pointer
    // to a variable, whereas 'TypeVar' accepts a pointer to a variable.
    var optTypeVar float64
    golf.FloatVar(&optTypeVar, "f", 6.02e-23, "optTypeVar takes a pointer to a variable and a single flag")

    // For completeness, a 'TypeVarP' set of functions is also provided.
    var optTypeVarP int64
    golf.Int64VarP(&optTypeVarP, 'i', "int64", 13, "optTypeVarP takes a pointer to a variable, a rune, and a string")

    // After the options have been declared, the `golf.Parse()` function will
    // parse the command line options from `os.Args`.
    golf.Parse()

    // Notice that the returned 'Type' and 'TypeP' functions return a pointer
    // that must be referenced in order to obtain the value.
    fmt.Println("optType: ", *optType1)
    fmt.Println("optTypeP: ", *optTypeP)

    // In contrast, the 'TypeVar' and 'TypeVarP' functions accept a pointer to
    // the variable for the library to store its value, and accessing the
    // value does not require a pointer dereference.
    fmt.Println("optTypeVar: ", optTypeVar)
    fmt.Println("optTypeVarP: ", optTypeVarP)
}

package main

import (
    "errors"
    "fmt"
    "os"
    "path/filepath"

    "github.com/karrick/golf"
)

func main() {
    // As a reminder, the first argument provided is the name of the
    // program. Therefore if there is only a single command line argument,
    // then the caller did not provide a sub-command.
    if len(os.Args) == 1 {
        bail(errors.New("missing sub-command"))
    }

    // os.Args[0]:  The string used to invoke the program.
    subCommand := os.Args[1]      // The sub-command.
    subCommandArgs := os.Args[2:] // Arguments to the sub-command.

    switch subCommand {
    case "foo":
        foo(subCommandArgs)
    case "bar":
        bar(subCommandArgs)
    default:
        bail(fmt.Errorf("sub-command not recognized: %q", subCommand))
    }
}

func foo(args []string) {
    // Declare and configure a parser to handle the command line options for
    // the 'foo' sub-command.
    var p golf.Parser
    optBool := p.WithBool("b", false, "some bool")
    optDuration := p.WithDurationP('d', "duration", 0, "some duration")

    // After the parser has been configured, use it to parse the command line
    // arguments provided to this function.
    err := p.Parse(args)
    if err != nil {
        bail(err)
    }

    // Do the sub-command operation with the arguments.
    fmt.Println("optBool:", *optBool)
    fmt.Println("optDuration:", *optDuration)

    // The 'Args' method returns a slice of strings that were not consumed by
    // the Parser variables.
    for i, arg := range p.Args() {
        fmt.Fprintf(os.Stderr, "# %d: %s\n", i, arg)
    }
}

func bar(args []string) {
    // Declare and configure a parser to handle the command line options for
    // the 'bar' sub-command.
    var p golf.Parser
    optInt := p.WithInt("i", 0, "some int")
    optString := p.WithString("s", "", "some string")

    // After the parser has been configured, use it to parse the command line
    // arguments provided to this function.
    err := p.Parse(args)
    if err != nil {
        bail(err)
    }

    // Do the sub-command operation with the arguments.
    fmt.Println("optInt:", *optInt)
    fmt.Println("optString:", *optString)

    // The 'Args' method returns a slice of strings that were not consumed by
    // the Parser variables.
    for i, arg := range p.Args() {
        fmt.Fprintf(os.Stderr, "# %d: %s\n", i, arg)
    }
}

func bail(err error) {
    basename := filepath.Base(os.Args[0])
    fmt.Fprintf(os.Stderr, "%s: %s\n", basename, err)
    fmt.Fprintf(os.Stderr, "USAGE %s foo [-b] [-d DURATION]\n", basename)
    fmt.Fprintf(os.Stderr, "USAGE %s bar [-i INT] [-s STRING]\n", basename)
    os.Exit(2)
}

optRaw := golf.BoolP('r', "raw", false, "Display raw output")
optServer := golf.StringP('s', "server", "", "Send query to specified server")
optTheshold := golf.FloatP('t', "threshold", 0, "Set minimum threshold")
optVerbose := golf.BoolP('v', "verbose", false, "Display verbose output")
golf.Parse()