arg

README

go-arg

Struct-based argument parsing for Go

Declare command line arguments for your program by defining a struct.

var args struct {
	Foo string
	Bar bool
}
arg.MustParse(&args)
fmt.Println(args.Foo, args.Bar)

$ ./example --foo=hello --bar
hello true

Installation

go get github.com/alexflint/go-arg

Required arguments

var args struct {
	ID      int `arg:"required"`
	Timeout time.Duration
}
arg.MustParse(&args)

$ ./example
Usage: example --id ID [--timeout TIMEOUT]
error: --id is required

Positional arguments

var args struct {
	Input   string   `arg:"positional"`
	Output  []string `arg:"positional"`
}
arg.MustParse(&args)
fmt.Println("Input:", args.Input)
fmt.Println("Output:", args.Output)

$ ./example src.txt x.out y.out z.out
Input: src.txt
Output: [x.out y.out z.out]

Environment variables

var args struct {
	Workers int `arg:"env"`
}
arg.MustParse(&args)
fmt.Println("Workers:", args.Workers)

$ WORKERS=4 ./example
Workers: 4

$ WORKERS=4 ./example --workers=6
Workers: 6

You can also override the name of the environment variable:

var args struct {
	Workers int `arg:"env:NUM_WORKERS"`
}
arg.MustParse(&args)
fmt.Println("Workers:", args.Workers)

$ NUM_WORKERS=4 ./example
Workers: 4

You can provide multiple values using the CSV (RFC 4180) format:

var args struct {
    Workers []int `arg:"env"`
}
arg.MustParse(&args)
fmt.Println("Workers:", args.Workers)

$ WORKERS='1,99' ./example
Workers: [1 99]

Usage strings

var args struct {
	Input    string   `arg:"positional"`
	Output   []string `arg:"positional"`
	Verbose  bool     `arg:"-v,--verbose" help:"verbosity level"`
	Dataset  string   `help:"dataset to use"`
	Optimize int      `arg:"-O" help:"optimization level"`
}
arg.MustParse(&args)

$ ./example -h
Usage: [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] [--help] INPUT [OUTPUT [OUTPUT ...]]

Positional arguments:
  INPUT
  OUTPUT

Options:
  --verbose, -v            verbosity level
  --dataset DATASET        dataset to use
  --optimize OPTIMIZE, -O OPTIMIZE
                           optimization level
  --help, -h               print this help message

Default values

var args struct {
	Foo string `default:"abc"`
	Bar bool
}
arg.MustParse(&args)

Default values (before v1.2)

var args struct {
	Foo string
	Bar bool
}
arg.Foo = "abc"
arg.MustParse(&args)

Combining command line options, environment variables, and default values

You can combine command line arguments, environment variables, and default values. Command line arguments take precedence over environment variables, which take precedence over default values. This means that we check whether a certain option was provided on the command line, then if not, we check for an environment variable (only if an env tag was provided), then if none is found, we check for a default tag containing a default value.

var args struct {
    Test  string `arg:"-t,env:TEST" default:"something"`
}
arg.MustParse(&args)

Ignoring environment variables and/or default values

The values in an existing structure can be kept in-tact by ignoring environment variables and/or default values.

var args struct {
    Test  string `arg:"-t,env:TEST" default:"something"`
}

p, err := arg.NewParser(arg.Config{
    IgnoreEnv: true,
    IgnoreDefault: true,
}, &args)

err = p.Parse(os.Args)

Arguments with multiple values

var args struct {
	Database string
	IDs      []int64
}
arg.MustParse(&args)
fmt.Printf("Fetching the following IDs from %s: %q", args.Database, args.IDs)

./example -database foo -ids 1 2 3
Fetching the following IDs from foo: [1 2 3]

Arguments that can be specified multiple times, mixed with positionals

var args struct {
    Commands  []string `arg:"-c,separate"`
    Files     []string `arg:"-f,separate"`
    Databases []string `arg:"positional"`
}
arg.MustParse(&args)

./example -c cmd1 db1 -f file1 db2 -c cmd2 -f file2 -f file3 db3 -c cmd3
Commands: [cmd1 cmd2 cmd3]
Files [file1 file2 file3]
Databases [db1 db2 db3]

Arguments with keys and values

var args struct {
	UserIDs map[string]int
}
arg.MustParse(&args)
fmt.Println(args.UserIDs)

./example --userids john=123 mary=456
map[john:123 mary:456]

Custom validation

var args struct {
	Foo string
	Bar string
}
p := arg.MustParse(&args)
if args.Foo == "" && args.Bar == "" {
	p.Fail("you must provide either --foo or --bar")
}

./example
Usage: samples [--foo FOO] [--bar BAR]
error: you must provide either --foo or --bar

Version strings

type args struct {
	...
}

func (args) Version() string {
	return "someprogram 4.3.0"
}

func main() {
	var args args
	arg.MustParse(&args)
}

$ ./example --version
someprogram 4.3.0

Overriding option names

var args struct {
	Short        string `arg:"-s"`
	Long         string `arg:"--custom-long-option"`
	ShortAndLong string `arg:"-x,--my-option"`
	OnlyShort    string `arg:"-o,--"`
}
arg.MustParse(&args)

$ ./example --help
Usage: example [-o ONLYSHORT] [--short SHORT] [--custom-long-option CUSTOM-LONG-OPTION] [--my-option MY-OPTION]

Options:
  --short SHORT, -s SHORT
  --custom-long-option CUSTOM-LONG-OPTION
  --my-option MY-OPTION, -x MY-OPTION
  -o ONLYSHORT
  --help, -h             display this help and exit

Embedded structs

The fields of embedded structs are treated just like regular fields:

type DatabaseOptions struct {
	Host     string
	Username string
	Password string
}

type LogOptions struct {
	LogFile string
	Verbose bool
}

func main() {
	var args struct {
		DatabaseOptions
		LogOptions
	}
	arg.MustParse(&args)
}

As usual, any field tagged with arg:"-" is ignored.

Supported types

The following types may be used as arguments:

• built-in integer types: int, int8, int16, int32, int64, byte, rune
• built-in floating point types: float32, float64
• strings
• booleans
• URLs represented as url.URL
• time durations represented as time.Duration
• email addresses represented as mail.Address
• MAC addresses represented as net.HardwareAddr
• pointers to any of the above
• slices of any of the above
• maps using any of the above as keys and values
• any type that implements encoding.TextUnmarshaler

Custom parsing

Implement encoding.TextUnmarshaler to define your own parsing logic.

// Accepts command line arguments of the form "head.tail"
type NameDotName struct {
	Head, Tail string
}

func (n *NameDotName) UnmarshalText(b []byte) error {
	s := string(b)
	pos := strings.Index(s, ".")
	if pos == -1 {
		return fmt.Errorf("missing period in %s", s)
	}
	n.Head = s[:pos]
	n.Tail = s[pos+1:]
	return nil
}

func main() {
	var args struct {
		Name NameDotName
	}
	arg.MustParse(&args)
	fmt.Printf("%#v\n", args.Name)
}

$ ./example --name=foo.bar
main.NameDotName{Head:"foo", Tail:"bar"}

$ ./example --name=oops
Usage: example [--name NAME]
error: error processing --name: missing period in "oops"

Custom parsing with default values

Implement encoding.TextMarshaler to define your own default value strings:

// Accepts command line arguments of the form "head.tail"
type NameDotName struct {
	Head, Tail string
}

func (n *NameDotName) UnmarshalText(b []byte) error {
	// same as previous example
}

// this is only needed if you want to display a default value in the usage string
func (n *NameDotName) MarshalText() ([]byte, error) {
	return []byte(fmt.Sprintf("%s.%s", n.Head, n.Tail)), nil
}

func main() {
	var args struct {
		Name NameDotName `default:"file.txt"`
	}
	arg.MustParse(&args)
	fmt.Printf("%#v\n", args.Name)
}

$ ./example --help
Usage: test [--name NAME]

Options:
  --name NAME [default: file.txt]
  --help, -h             display this help and exit

$ ./example
main.NameDotName{Head:"file", Tail:"txt"}

Custom placeholders

Introduced in version 1.3.0

Use the placeholder tag to control which placeholder text is used in the usage text.

var args struct {
	Input    string   `arg:"positional" placeholder:"SRC"`
	Output   []string `arg:"positional" placeholder:"DST"`
	Optimize int      `arg:"-O" help:"optimization level" placeholder:"LEVEL"`
	MaxJobs  int      `arg:"-j" help:"maximum number of simultaneous jobs" placeholder:"N"`
}
arg.MustParse(&args)

$ ./example -h
Usage: example [--optimize LEVEL] [--maxjobs N] SRC [DST [DST ...]]

Positional arguments:
  SRC
  DST

Options:
  --optimize LEVEL, -O LEVEL
                         optimization level
  --maxjobs N, -j N      maximum number of simultaneous jobs
  --help, -h             display this help and exit

Description strings

A descriptive message can be added at the top of the help text by implementing a Description function that returns a string.

type args struct {
	Foo string
}

func (args) Description() string {
	return "this program does this and that"
}

func main() {
	var args args
	arg.MustParse(&args)
}

$ ./example -h
this program does this and that
Usage: example [--foo FOO]

Options:
  --foo FOO
  --help, -h             display this help and exit

Similarly an epilogue can be added at the end of the help text by implementing the Epilogue function.

type args struct {
	Foo string
}

func (args) Epilogue() string {
	return "For more information visit github.com/alexflint/go-arg"
}

func main() {
	var args args
	arg.MustParse(&args)
}

$ ./example -h
Usage: example [--foo FOO]

Options:
  --foo FOO
  --help, -h             display this help and exit

For more information visit github.com/alexflint/go-arg

Subcommands

Introduced in version 1.1.0

Subcommands are commonly used in tools that wish to group multiple functions into a single program. An example is the git tool:

$ git checkout [arguments specific to checking out code]
$ git commit [arguments specific to committing]
$ git push [arguments specific to pushing]

The strings "checkout", "commit", and "push" are different from simple positional arguments because the options available to the user change depending on which subcommand they choose.

This can be implemented with go-arg as follows:

type CheckoutCmd struct {
	Branch string `arg:"positional"`
	Track  bool   `arg:"-t"`
}
type CommitCmd struct {
	All     bool   `arg:"-a"`
	Message string `arg:"-m"`
}
type PushCmd struct {
	Remote      string `arg:"positional"`
	Branch      string `arg:"positional"`
	SetUpstream bool   `arg:"-u"`
}
var args struct {
	Checkout *CheckoutCmd `arg:"subcommand:checkout"`
	Commit   *CommitCmd   `arg:"subcommand:commit"`
	Push     *PushCmd     `arg:"subcommand:push"`
	Quiet    bool         `arg:"-q"` // this flag is global to all subcommands
}

arg.MustParse(&args)

switch {
case args.Checkout != nil:
	fmt.Printf("checkout requested for branch %s\n", args.Checkout.Branch)
case args.Commit != nil:
	fmt.Printf("commit requested with message \"%s\"\n", args.Commit.Message)
case args.Push != nil:
	fmt.Printf("push requested from %s to %s\n", args.Push.Branch, args.Push.Remote)
}

Some additional rules apply when working with subcommands:

• The subcommand tag can only be used with fields that are pointers to structs
• Any struct that contains a subcommand must not contain any positionals

This package allows to have a program that accepts subcommands, but also does something else when no subcommands are specified. If on the other hand you want the program to terminate when no subcommands are specified, the recommended way is:

p := arg.MustParse(&args)
if p.Subcommand() == nil {
    p.Fail("missing subcommand")
}

API Documentation

https://godoc.org/github.com/alexflint/go-arg

Rationale

There are many command line argument parsing libraries for Go, including one in the standard library, so why build another?

The flag library that ships in the standard library seems awkward to me. Positional arguments must preceed options, so ./prog x --foo=1 does what you expect but ./prog --foo=1 x does not. It also does not allow arguments to have both long (--foo) and short (-f) forms.

Many third-party argument parsing libraries are great for writing sophisticated command line interfaces, but feel to me like overkill for a simple script with a few flags.

The idea behind go-arg is that Go already has an excellent way to describe data structures using structs, so there is no need to develop additional levels of abstraction. Instead of one API to specify which arguments your program accepts, and then another API to get the values of those arguments, go-arg replaces both with a single struct.

Backward compatibility notes

Earlier versions of this library required the help text to be part of the arg tag. This is still supported but is now deprecated. Instead, you should use a separate help tag, described above, which removes most of the limits on the text you can write. In particular, you will need to use the new help tag if your help text includes any commas.

Documentation

Overview

Package arg parses command line arguments using the fields from a struct.

For example,

var args struct {
	Iter int
	Debug bool
}
arg.MustParse(&args)

defines two command line arguments, which can be set using any of

./example --iter=1 --debug  // debug is a boolean flag so its value is set to true
./example -iter 1           // debug defaults to its zero value (false)
./example --debug=true      // iter defaults to its zero value (zero)

The fastest way to see how to use go-arg is to read the examples below.

Fields can be bool, string, any float type, or any signed or unsigned integer type. They can also be slices of any of the above, or slices of pointers to any of the above.

Tags can be specified using the `arg` and `help` tag names:

var args struct {
	Input string   `arg:"positional"`
	Log string     `arg:"positional,required"`
	Debug bool     `arg:"-d" help:"turn on debug mode"`
	RealMode bool  `arg:"--real"
	Wr io.Writer   `arg:"-"`
}

Any tag string that starts with a single hyphen is the short form for an argument (e.g. `./example -d`), and any tag string that starts with two hyphens is the long form for the argument (instead of the field name).

Other valid tag strings are `positional` and `required`.

Fields can be excluded from processing with `arg:"-"`.

Example

This example demonstrates basic usage

// These are the args you would pass in on the command line
os.Args = split("./example --foo=hello --bar")

var args struct {
	Foo string
	Bar bool
}
MustParse(&args)
fmt.Println(args.Foo, args.Bar)

Output:

hello true

Example (AllSupportedTypes)

// These are the args you would pass in on the command line
os.Args = []string{}

var args struct {
	Bool     bool
	Byte     byte
	Rune     rune
	Int      int
	Int8     int8
	Int16    int16
	Int32    int32
	Int64    int64
	Float32  float32
	Float64  float64
	String   string
	Duration time.Duration
	URL      url.URL
	Email    mail.Address
	MAC      net.HardwareAddr
}

// go-arg supports each of the types above, as well as pointers to any of
// the above and slices of any of the above. It also supports any types that
// implements encoding.TextUnmarshaler.

MustParse(&args)

Example (DefaultValues)

This example demonstrates arguments that have default values

// These are the args you would pass in on the command line
os.Args = split("./example")

var args struct {
	Foo string `default:"abc"`
}
MustParse(&args)
fmt.Println(args.Foo)

Output:

abc

Example (EnvVarOnly)

os.Args = split("./example")
_ = os.Setenv("AUTH_KEY", "my_key")

defer os.Unsetenv("AUTH_KEY")

var args struct {
	AuthKey string `arg:"--,env:AUTH_KEY"`
}

MustParse(&args)

fmt.Println(args.AuthKey)

Output:

my_key

Example (EnvVarOnlyShouldIgnoreFlag)

os.Args = split("./example --=my_key")

var args struct {
	AuthKey string `arg:"--,env:AUTH_KEY"`
}

err := Parse(&args)

fmt.Println(err)

Output:

unknown argument --=my_key

Example (EnvVarOnlyShouldIgnoreShortFlag)

os.Args = split("./example -=my_key")

var args struct {
	AuthKey string `arg:"--,env:AUTH_KEY"`
}

err := Parse(&args)

fmt.Println(err)

Output:

unknown argument -=my_key

Example (ErrorText)

This example shows the error string generated by go-arg when an invalid option is provided

// These are the args you would pass in on the command line
os.Args = split("./example --optimize INVALID")

var args struct {
	Input    string   `arg:"positional,required"`
	Output   []string `arg:"positional"`
	Verbose  bool     `arg:"-v" help:"verbosity level"`
	Dataset  string   `help:"dataset to use"`
	Optimize int      `arg:"-O,help:optimization level"`
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

Output:

Usage: example [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] INPUT [OUTPUT [OUTPUT ...]]
error: error processing --optimize: strconv.ParseInt: parsing "INVALID": invalid syntax

Example (ErrorTextForSubcommand)

This example shows the error string generated by go-arg when an invalid option is provided

// These are the args you would pass in on the command line
os.Args = split("./example get --count INVALID")

type getCmd struct {
	Count int
}

var args struct {
	Get *getCmd `arg:"subcommand"`
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

Output:

Usage: example get [--count COUNT]
error: error processing --count: strconv.ParseInt: parsing "INVALID": invalid syntax

Example (HelpPlaceholder)

This example shows the usage string generated by go-arg with customized placeholders

// These are the args you would pass in on the command line
os.Args = split("./example --help")

var args struct {
	Input    string   `arg:"positional,required" placeholder:"SRC"`
	Output   []string `arg:"positional" placeholder:"DST"`
	Optimize int      `arg:"-O" help:"optimization level" placeholder:"LEVEL"`
	MaxJobs  int      `arg:"-j" help:"maximum number of simultaneous jobs" placeholder:"N"`
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

Example (HelpText)

This example shows the usage string generated by go-arg

// These are the args you would pass in on the command line
os.Args = split("./example --help")

var args struct {
	Input    string   `arg:"positional,required"`
	Output   []string `arg:"positional"`
	Verbose  bool     `arg:"-v" help:"verbosity level"`
	Dataset  string   `help:"dataset to use"`
	Optimize int      `arg:"-O,--optim" help:"optimization level"`
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

Output:

Usage: example [--verbose] [--dataset DATASET] [--optim OPTIM] INPUT [OUTPUT [OUTPUT ...]]

Positional arguments:
  INPUT
  OUTPUT

Options:
  --verbose, -v          verbosity level
  --dataset DATASET      dataset to use
  --optim OPTIM, -O OPTIM
                         optimization level
  --help, -h             display this help and exit

Example (HelpTextWhenUsingSubcommand)

This example shows the usage string generated by go-arg when using subcommands

// These are the args you would pass in on the command line
os.Args = split("./example get --help")

type getCmd struct {
	Item string `arg:"positional,required" help:"item to fetch"`
}

type listCmd struct {
	Format string `help:"output format"`
	Limit  int
}

var args struct {
	Verbose bool
	Get     *getCmd  `arg:"subcommand" help:"fetch an item and print it"`
	List    *listCmd `arg:"subcommand" help:"list available items"`
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

Output:

Usage: example get ITEM

Positional arguments:
  ITEM                   item to fetch

Global options:
  --verbose
  --help, -h             display this help and exit

Example (HelpTextWithSubcommand)

This example shows the usage string generated by go-arg when using subcommands

// These are the args you would pass in on the command line
os.Args = split("./example --help")

type getCmd struct {
	Item string `arg:"positional" help:"item to fetch"`
}

type listCmd struct {
	Format string `help:"output format"`
	Limit  int
}

var args struct {
	Verbose bool
	Get     *getCmd  `arg:"subcommand" help:"fetch an item and print it"`
	List    *listCmd `arg:"subcommand" help:"list available items"`
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

Output:

Usage: example [--verbose] <command> [<args>]

Options:
  --verbose
  --help, -h             display this help and exit

Commands:
  get                    fetch an item and print it
  list                   list available items

Example (MappingWithCommas)

This example demonstrates arguments with keys and values separated by commas

// The args you would pass in on the command line
os.Args = split("./example --values one=two,three=four")

var args struct {
	Values commaSeparated
}
MustParse(&args)
fmt.Println(args.Values.M)

Output:

map[one:two three:four]

Example (Mappings)

This example demonstrates arguments with keys and values

// The args you would pass in on the command line
os.Args = split("./example --userids john=123 mary=456")

var args struct {
	UserIDs map[string]int
}
MustParse(&args)
fmt.Println(args.UserIDs)

Output:

map[john:123 mary:456]

Example (MultipleMixed)

This eample demonstrates multiple value arguments that can be mixed with other arguments.

os.Args = split("./example -c cmd1 db1 -f file1 db2 -c cmd2 -f file2 -f file3 db3 -c cmd3")
var args struct {
	Commands  []string `arg:"-c,separate"`
	Files     []string `arg:"-f,separate"`
	Databases []string `arg:"positional"`
}
MustParse(&args)
fmt.Println("Commands:", args.Commands)
fmt.Println("Files:", args.Files)
fmt.Println("Databases:", args.Databases)

Output:

Commands: [cmd1 cmd2 cmd3]
Files: [file1 file2 file3]
Databases: [db1 db2 db3]

Example (MultipleValues)

This example demonstrates arguments that have multiple values

// The args you would pass in on the command line
os.Args = split("./example --database localhost --ids 1 2 3")

var args struct {
	Database string
	IDs      []int64
}
MustParse(&args)
fmt.Printf("Fetching the following IDs from %s: %v", args.Database, args.IDs)

Output:

Fetching the following IDs from localhost: [1 2 3]

Example (PositionalArguments)

This example demonstrates positional arguments

// These are the args you would pass in on the command line
os.Args = split("./example in out1 out2 out3")

var args struct {
	Input  string   `arg:"positional"`
	Output []string `arg:"positional"`
}
MustParse(&args)
fmt.Println("In:", args.Input)
fmt.Println("Out:", args.Output)

Output:

In: in
Out: [out1 out2 out3]

Example (RequiredArguments)

This example demonstrates arguments that are required

// These are the args you would pass in on the command line
os.Args = split("./example --foo=abc --bar")

var args struct {
	Foo string `arg:"required"`
	Bar bool
}
MustParse(&args)
fmt.Println(args.Foo, args.Bar)

Output:

abc true

Example (Subcommand)

This example demonstrates use of subcommands

// These are the args you would pass in on the command line
os.Args = split("./example commit -a -m what-this-commit-is-about")

type CheckoutCmd struct {
	Branch string `arg:"positional"`
	Track  bool   `arg:"-t"`
}
type CommitCmd struct {
	All     bool   `arg:"-a"`
	Message string `arg:"-m"`
}
type PushCmd struct {
	Remote      string `arg:"positional"`
	Branch      string `arg:"positional"`
	SetUpstream bool   `arg:"-u"`
}
var args struct {
	Checkout *CheckoutCmd `arg:"subcommand:checkout"`
	Commit   *CommitCmd   `arg:"subcommand:commit"`
	Push     *PushCmd     `arg:"subcommand:push"`
	Quiet    bool         `arg:"-q"` // this flag is global to all subcommands
}

// This is only necessary when running inside golang's runnable example harness
mustParseExit = func(int) {}
mustParseOut = os.Stdout

MustParse(&args)

switch {
case args.Checkout != nil:
	fmt.Printf("checkout requested for branch %s\n", args.Checkout.Branch)
case args.Commit != nil:
	fmt.Printf("commit requested with message \"%s\"\n", args.Commit.Message)
case args.Push != nil:
	fmt.Printf("push requested from %s to %s\n", args.Push.Branch, args.Push.Remote)
}

Output:

commit requested with message "what-this-commit-is-about"

Example (WriteHelpForSubcommand)

This example shows how to print help for an explicit subcommand

// These are the args you would pass in on the command line
os.Args = split("./example get --help")

type getCmd struct {
	Item string `arg:"positional" help:"item to fetch"`
}

type listCmd struct {
	Format string `help:"output format"`
	Limit  int
}

var args struct {
	Verbose bool
	Get     *getCmd  `arg:"subcommand" help:"fetch an item and print it"`
	List    *listCmd `arg:"subcommand" help:"list available items"`
}

// This is only necessary when running inside golang's runnable example harness
exit := func(int) {}

p, err := NewParser(Config{Exit: exit}, &args)
if err != nil {
	fmt.Println(err)
	os.Exit(1)
}

err = p.WriteHelpForSubcommand(os.Stdout, "list")
if err != nil {
	fmt.Println(err)
	os.Exit(1)
}

Output:

Usage: example list [--format FORMAT] [--limit LIMIT]

Options:
  --format FORMAT        output format
  --limit LIMIT

Global options:
  --verbose
  --help, -h             display this help and exit

Example (WriteHelpForSubcommandNested)

This example shows how to print help for a subcommand that is nested several levels deep

// These are the args you would pass in on the command line
os.Args = split("./example get --help")

type mostNestedCmd struct {
	Item string
}

type nestedCmd struct {
	MostNested *mostNestedCmd `arg:"subcommand"`
}

type topLevelCmd struct {
	Nested *nestedCmd `arg:"subcommand"`
}

var args struct {
	TopLevel *topLevelCmd `arg:"subcommand"`
}

// This is only necessary when running inside golang's runnable example harness
exit := func(int) {}

p, err := NewParser(Config{Exit: exit}, &args)
if err != nil {
	fmt.Println(err)
	os.Exit(1)
}

err = p.WriteHelpForSubcommand(os.Stdout, "toplevel", "nested", "mostnested")
if err != nil {
	fmt.Println(err)
	os.Exit(1)
}

Output:

Usage: example toplevel nested mostnested [--item ITEM]

Options:
  --item ITEM
  --help, -h             display this help and exit

Index

• Variables
• func Parse(dest ...interface{}) error
• type Config
• type Described
• type Epilogued
• type Parser
  • func MustParse(dest ...interface{}) *Parser
  • func NewParser(config Config, dests ...interface{}) (*Parser, error)
  • func (p *Parser) Fail(msg string)
  • func (p *Parser) FailSubcommand(msg string, subcommand ...string) error
  • func (p *Parser) MustParse(args []string)
  • func (p *Parser) Parse(args []string) error
  • func (p *Parser) Subcommand() interface{}
  • func (p *Parser) SubcommandNames() []string
  • func (p *Parser) WriteHelp(w io.Writer)
  • func (p *Parser) WriteHelpForSubcommand(w io.Writer, subcommand ...string) error
  • func (p *Parser) WriteUsage(w io.Writer)
  • func (p *Parser) WriteUsageForSubcommand(w io.Writer, subcommand ...string) error
• type Versioned

Examples

• Package
• Package (AllSupportedTypes)
• Package (DefaultValues)
• Package (EnvVarOnly)
• Package (EnvVarOnlyShouldIgnoreFlag)
• Package (EnvVarOnlyShouldIgnoreShortFlag)
• Package (ErrorText)
• Package (ErrorTextForSubcommand)
• Package (HelpPlaceholder)
• Package (HelpText)
• Package (HelpTextWhenUsingSubcommand)
• Package (HelpTextWithSubcommand)
• Package (MappingWithCommas)
• Package (Mappings)
• Package (MultipleMixed)
• Package (MultipleValues)
• Package (PositionalArguments)
• Package (RequiredArguments)
• Package (Subcommand)
• Package (WriteHelpForSubcommand)
• Package (WriteHelpForSubcommandNested)

Variables

var ErrHelp = errors.New("help requested by user")

ErrHelp indicates that the builtin -h or --help were provided

var ErrVersion = errors.New("version requested by user")

ErrVersion indicates that the builtin --version was provided

Functions

func Parse

func Parse(dest ...interface{}) error

Parse processes command line arguments and stores them in dest

Types

type Config

type Config struct {
	// Program is the name of the program used in the help text
	Program string

	// IgnoreEnv instructs the library not to read environment variables
	IgnoreEnv bool

	// IgnoreDefault instructs the library not to reset the variables to the
	// default values, including pointers to sub commands
	IgnoreDefault bool

	// StrictSubcommands intructs the library not to allow global commands after
	// subcommand
	StrictSubcommands bool

	// Exit is called to terminate the process with an error code (defaults to os.Exit)
	Exit func(int)

	// Out is where help text, usage text, and failure messages are printed (defaults to os.Stdout)
	Out io.Writer
}

Config represents configuration options for an argument parser

type Described

type Described interface {
	// Description returns the string that will be printed on a line by itself
	// at the top of the help message.
	Description() string
}

Described is the interface that the destination struct should implement to make a description string appear at the top of the help message.

type Epilogued

type Epilogued interface {
	// Epilogue returns the string that will be printed on a line by itself
	// at the end of the help message.
	Epilogue() string
}

Epilogued is the interface that the destination struct should implement to add an epilogue string at the bottom of the help message.

type Parser

type Parser struct {
	// contains filtered or unexported fields
}

Parser represents a set of command line options with destination values

func MustParse

func MustParse(dest ...interface{}) *Parser

MustParse processes command line arguments and exits upon failure

func NewParser

func NewParser(config Config, dests ...interface{}) (*Parser, error)

NewParser constructs a parser from a list of destination structs

func (*Parser) Fail

func (p *Parser) Fail(msg string)

Fail prints usage information to stderr and exits with non-zero status

func (*Parser) FailSubcommand

func (p *Parser) FailSubcommand(msg string, subcommand ...string) error

FailSubcommand prints usage information for a specified subcommand to stderr, then exits with non-zero status. To write usage information for a top-level subcommand, provide just the name of that subcommand. To write usage information for a subcommand that is nested under another subcommand, provide a sequence of subcommand names starting with the top-level subcommand and so on down the tree.

func (*Parser) MustParse

func (p *Parser) MustParse(args []string)

func (*Parser) Parse

func (p *Parser) Parse(args []string) error

Parse processes the given command line option, storing the results in the field of the structs from which NewParser was constructed

func (*Parser) Subcommand

func (p *Parser) Subcommand() interface{}

Subcommand returns the user struct for the subcommand selected by the command line arguments most recently processed by the parser. The return value is always a pointer to a struct. If no subcommand was specified then it returns the top-level arguments struct. If no command line arguments have been processed by this parser then it returns nil.

func (*Parser) SubcommandNames

func (p *Parser) SubcommandNames() []string

SubcommandNames returns the sequence of subcommands specified by the user. If no subcommands were given then it returns an empty slice.

func (*Parser) WriteHelp

func (p *Parser) WriteHelp(w io.Writer)

WriteHelp writes the usage string followed by the full help string for each option

func (*Parser) WriteHelpForSubcommand

func (p *Parser) WriteHelpForSubcommand(w io.Writer, subcommand ...string) error

WriteHelpForSubcommand writes the usage string followed by the full help string for a specified subcommand. To write help for a top-level subcommand, provide just the name of that subcommand. To write help for a subcommand that is nested under another subcommand, provide a sequence of subcommand names starting with the top-level subcommand and so on down the tree.

func (*Parser) WriteUsage

func (p *Parser) WriteUsage(w io.Writer)

WriteUsage writes usage information to the given writer

func (*Parser) WriteUsageForSubcommand

func (p *Parser) WriteUsageForSubcommand(w io.Writer, subcommand ...string) error

WriteUsageForSubcommand writes the usage information for a specified subcommand. To write usage information for a top-level subcommand, provide just the name of that subcommand. To write usage information for a subcommand that is nested under another subcommand, provide a sequence of subcommand names starting with the top-level subcommand and so on down the tree.

type Versioned

type Versioned interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	Version() string
}

Versioned is the interface that the destination struct should implement to make a version string appear at the top of the help message.