Package cli

func main() {
  cli.NewApp().Run(os.Args)
}

func main() {
  app := cli.NewApp()
  app.Name = "greet"
  app.Usage = "say a greeting"
  app.Action = func(c *cli.Context) {
    println("Greetings")
  }

  app.Run(os.Args)
}

Variables

The text template for the Default help topic. cli.go uses text/template to render templates. You can render custom help text by setting this variable.

var AppHelpTemplate = `NAME:
   {{.Name}} - {{.Usage}}

USAGE:
   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
   {{if .Version}}{{if not .HideVersion}}
VERSION:
   {{.Version}}
   {{end}}{{end}}{{if len .Authors}}
AUTHOR(S):
   {{range .Authors}}{{ . }}{{end}}
   {{end}}{{if .Commands}}
COMMANDS:{{range .Categories}}{{if .Name}}
  {{.Name}}{{ ":" }}{{end}}{{range .Commands}}
    {{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}{{end}}
{{end}}{{end}}{{if .Flags}}
GLOBAL OPTIONS:
   {{range .Flags}}{{.}}
   {{end}}{{end}}{{if .Copyright }}
COPYRIGHT:
   {{.Copyright}}
   {{end}}
`

This flag enables bash-completion for all commands and subcommands

var BashCompletionFlag = BoolFlag{
    Name: "generate-bash-completion",
}

The text template for the command help topic. cli.go uses text/template to render templates. You can render custom help text by setting this variable.

var CommandHelpTemplate = `NAME:
   {{.HelpName}} - {{.Usage}}

USAGE:
   {{.HelpName}}{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Category}}

CATEGORY:
   {{.Category}}{{end}}{{if .Description}}

DESCRIPTION:
   {{.Description}}{{end}}{{if .Flags}}

OPTIONS:
   {{range .Flags}}{{.}}
   {{end}}{{ end }}
`

This flag prints the help for all commands and subcommands Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand unless HideHelp is set to true)

var HelpFlag = BoolFlag{
    Name:  "help, h",
    Usage: "show help",
}

var HelpPrinter helpPrinter = printHelp

The text template for the subcommand help topic. cli.go uses text/template to render templates. You can render custom help text by setting this variable.

var SubcommandHelpTemplate = `NAME:
   {{.HelpName}} - {{.Usage}}

USAGE:
   {{.HelpName}} command{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}

COMMANDS:{{range .Categories}}{{if .Name}}
  {{.Name}}{{ ":" }}{{end}}{{range .Commands}}
    {{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}{{end}}
{{end}}{{if .Flags}}
OPTIONS:
   {{range .Flags}}{{.}}
   {{end}}{{end}}
`

This flag prints the version for the application

var VersionFlag = BoolFlag{
    Name:  "version",
    Usage: "print the version",
}

Prints version for the App

var VersionPrinter = printVersion

func DefaultAppComplete ¶

func DefaultAppComplete(c *Context)

Prints the list of subcommands as the default app completion method

func ShowAppHelp ¶

func ShowAppHelp(c *Context)

func ShowCommandCompletions ¶

func ShowCommandCompletions(ctx *Context, command string)

Prints the custom completions for a given command

func ShowCommandHelp ¶

func ShowCommandHelp(ctx *Context, command string)

Prints help for the given command

func ShowCompletions ¶

func ShowCompletions(c *Context)

Prints the lists of commands within a given context

func ShowSubcommandHelp ¶

func ShowSubcommandHelp(c *Context)

Prints help for the given subcommand

func ShowVersion ¶

func ShowVersion(c *Context)

Prints the version number of the App

type App ¶

App is the main structure of a cli application. It is recommended that an app be created with the cli.NewApp() function

type App struct {
    // The name of the program. Defaults to path.Base(os.Args[0])
    Name string
    // Full name of command for help, defaults to Name
    HelpName string
    // Description of the program.
    Usage string
    // Text to override the USAGE section of help
    UsageText string
    // Description of the program argument format.
    ArgsUsage string
    // Version of the program
    Version string
    // List of commands to execute
    Commands []Command
    // List of flags to parse
    Flags []Flag
    // Boolean to enable bash completion commands
    EnableBashCompletion bool
    // Boolean to hide built-in help command
    HideHelp bool
    // Boolean to hide built-in version flag and the VERSION section of help
    HideVersion bool

    // An action to execute when the bash-completion flag is set
    BashComplete func(context *Context)
    // An action to execute before any subcommands are run, but after the context is ready
    // If a non-nil error is returned, no subcommands are run
    Before func(context *Context) error
    // An action to execute after any subcommands are run, but after the subcommand has finished
    // It is run even if Action() panics
    After func(context *Context) error
    // The action to execute when no subcommands are specified
    Action func(context *Context)
    // Execute this function if the proper command cannot be found
    CommandNotFound func(context *Context, command string)
    // Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
    // This function is able to replace the original error messages.
    // If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
    OnUsageError func(context *Context, err error, isSubcommand bool) error
    // Compilation date
    Compiled time.Time
    // List of all authors who contributed
    Authors []Author
    // Copyright of the binary if any
    Copyright string
    // Name of Author (Note: Use App.Authors, this is deprecated)
    Author string
    // Email of Author (Note: Use App.Authors, this is deprecated)
    Email string
    // Writer writer to write output to
    Writer io.Writer
    // contains filtered or unexported fields
}

func NewApp ¶

func NewApp() *App

Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.

func (*App) Categories ¶

func (a *App) Categories() CommandCategories

Returnes the array containing all the categories with the commands they contain

func (*App) Command ¶

func (a *App) Command(name string) *Command

Returns the named command on App. Returns nil if the command does not exist

func (*App) Run ¶

func (a *App) Run(arguments []string) (err error)

Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination

// set args for examples sake
os.Args = []string{"greet", "--name", "Jeremy"}

app := NewApp()
app.Name = "greet"
app.Flags = []Flag{
    StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
}
app.Action = func(c *Context) {
    fmt.Printf("Hello %v\n", c.String("name"))
}
app.UsageText = "app [first_arg] [second_arg]"
app.Author = "Harrison"
app.Email = "harrison@lolwut.com"
app.Authors = []Author{Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
app.Run(os.Args)

Hello Jeremy

// set args for examples sake
os.Args = []string{"greet", "--generate-bash-completion"}

app := NewApp()
app.Name = "greet"
app.EnableBashCompletion = true
app.Commands = []Command{
    {
        Name:        "describeit",
        Aliases:     []string{"d"},
        Usage:       "use it to see a description",
        Description: "This is how we describe describeit the function",
        Action: func(c *Context) {
            fmt.Printf("i like to describe things")
        },
    }, {
        Name:        "next",
        Usage:       "next example",
        Description: "more stuff to see when generating bash completion",
        Action: func(c *Context) {
            fmt.Printf("the next example")
        },
    },
}

app.Run(os.Args)

describeit
d
next
help
h

// set args for examples sake
os.Args = []string{"greet", "h", "describeit"}

app := NewApp()
app.Name = "greet"
app.Flags = []Flag{
    StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
}
app.Commands = []Command{
    {
        Name:        "describeit",
        Aliases:     []string{"d"},
        Usage:       "use it to see a description",
        Description: "This is how we describe describeit the function",
        Action: func(c *Context) {
            fmt.Printf("i like to describe things")
        },
    },
}
app.Run(os.Args)

NAME:
   greet describeit - use it to see a description

USAGE:
   greet describeit [arguments...]

DESCRIPTION:
   This is how we describe describeit the function

// set args for examples sake
os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
app := NewApp()
app.Name = "say"
app.Commands = []Command{
    {
        Name:        "hello",
        Aliases:     []string{"hi"},
        Usage:       "use it to see a description",
        Description: "This is how we describe hello the function",
        Subcommands: []Command{
            {
                Name:        "english",
                Aliases:     []string{"en"},
                Usage:       "sends a greeting in english",
                Description: "greets someone in english",
                Flags: []Flag{
                    StringFlag{
                        Name:  "name",
                        Value: "Bob",
                        Usage: "Name of the person to greet",
                    },
                },
                Action: func(c *Context) {
                    fmt.Println("Hello,", c.String("name"))
                },
            },
        },
    },
}

app.Run(os.Args)

Hello, Jeremy

func (*App) RunAndExitOnError ¶

func (a *App) RunAndExitOnError()

Another entry point to the cli app, takes care of passing arguments and error handling

func (*App) RunAsSubcommand ¶

func (a *App) RunAsSubcommand(ctx *Context) (err error)

Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags

type Args ¶

type Args []string

func (Args) First ¶

func (a Args) First() string

Returns the first argument, or else a blank string

func (Args) Get ¶

func (a Args) Get(n int) string

Returns the nth argument, or else a blank string

func (Args) Present ¶

func (a Args) Present() bool

Checks if there are any arguments present

func (Args) Swap ¶

func (a Args) Swap(from, to int) error

Swaps arguments at the given indexes

func (Args) Tail ¶

func (a Args) Tail() []string

Return the rest of the arguments (not the first one) or else an empty string slice

type Author ¶

Author represents someone who has contributed to a cli project.

type Author struct {
    Name  string // The Authors name
    Email string // The Authors email
}

func (Author) String ¶

func (a Author) String() string

String makes Author comply to the Stringer interface, to allow an easy print in the templating process

type BoolFlag ¶

BoolFlag is a switch that defaults to false

type BoolFlag struct {
    Name        string
    Usage       string
    EnvVar      string
    Destination *bool
}

func (BoolFlag) Apply ¶

func (f BoolFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (BoolFlag) GetName ¶

func (f BoolFlag) GetName() string

func (BoolFlag) String ¶

func (f BoolFlag) String() string

String returns a readable representation of this value (for usage defaults)

type BoolTFlag ¶

BoolTFlag this represents a boolean flag that is true by default, but can still be set to false by --some-flag=false

type BoolTFlag struct {
    Name        string
    Usage       string
    EnvVar      string
    Destination *bool
}

func (BoolTFlag) Apply ¶

func (f BoolTFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (BoolTFlag) GetName ¶

func (f BoolTFlag) GetName() string

func (BoolTFlag) String ¶

func (f BoolTFlag) String() string

String returns a readable representation of this value (for usage defaults)

type Command ¶

Command is a subcommand for a cli.App.

type Command struct {
    // The name of the command
    Name string
    // short name of the command. Typically one character (deprecated, use `Aliases`)
    ShortName string
    // A list of aliases for the command
    Aliases []string
    // A short description of the usage of this command
    Usage string
    // Custom text to show on USAGE section of help
    UsageText string
    // A longer explanation of how the command works
    Description string
    // A short description of the arguments of this command
    ArgsUsage string
    // The category the command is part of
    Category string
    // The function to call when checking for bash command completions
    BashComplete func(context *Context)
    // An action to execute before any sub-subcommands are run, but after the context is ready
    // If a non-nil error is returned, no sub-subcommands are run
    Before func(context *Context) error
    // An action to execute after any subcommands are run, but before the subcommand has finished
    // It is run even if Action() panics
    After func(context *Context) error
    // The function to call when this command is invoked
    Action func(context *Context)
    // Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
    // This function is able to replace the original error messages.
    // If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
    OnUsageError func(context *Context, err error) error
    // List of child commands
    Subcommands Commands
    // List of flags to parse
    Flags []Flag
    // Treat all flags as normal arguments if true
    SkipFlagParsing bool
    // Boolean to hide built-in help command
    HideHelp bool

    // Full name of command for help, defaults to full command name, including parent commands.
    HelpName string
    // contains filtered or unexported fields
}

func (Command) FullName ¶

func (c Command) FullName() string

Returns the full name of the command. For subcommands this ensures that parent commands are part of the command path

func (Command) HasName ¶

func (c Command) HasName(name string) bool

Returns true if Command.Name or Command.ShortName matches given name

func (Command) Names ¶

func (c Command) Names() []string

func (Command) Run ¶

func (c Command) Run(ctx *Context) (err error)

Invokes the command given the context, parses ctx.Args() to generate command-specific flags

type CommandCategories ¶

type CommandCategories []*CommandCategory

func (CommandCategories) AddCommand ¶

func (c CommandCategories) AddCommand(category string, command Command) CommandCategories

func (CommandCategories) Len ¶

func (c CommandCategories) Len() int

func (CommandCategories) Less ¶

func (c CommandCategories) Less(i, j int) bool

func (CommandCategories) Swap ¶

func (c CommandCategories) Swap(i, j int)

type CommandCategory ¶

type CommandCategory struct {
    Name     string
    Commands Commands
}

type Commands ¶

type Commands []Command

type Context ¶

Context is a type that is passed through to each Handler action in a cli application. Context can be used to retrieve context-specific Args and parsed command-line options.

type Context struct {
    App     *App
    Command Command
    // contains filtered or unexported fields
}

func NewContext ¶

func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context

Creates a new context. For use in when invoking an App or Command action.

func (*Context) Args ¶

func (c *Context) Args() Args

Returns the command line arguments associated with the context.

func (*Context) Bool ¶

func (c *Context) Bool(name string) bool

Looks up the value of a local bool flag, returns false if no bool flag exists

func (*Context) BoolT ¶

func (c *Context) BoolT(name string) bool

Looks up the value of a local boolT flag, returns false if no bool flag exists

func (*Context) Duration ¶

func (c *Context) Duration(name string) time.Duration

Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists

func (*Context) FlagNames ¶

func (c *Context) FlagNames() (names []string)

Returns a slice of flag names used in this context.

func (*Context) Float64 ¶

func (c *Context) Float64(name string) float64

Looks up the value of a local float64 flag, returns 0 if no float64 flag exists

func (*Context) Generic ¶

func (c *Context) Generic(name string) interface{}

Looks up the value of a local generic flag, returns nil if no generic flag exists

func (*Context) GlobalBool ¶

func (c *Context) GlobalBool(name string) bool

Looks up the value of a global bool flag, returns false if no bool flag exists

func (*Context) GlobalDuration ¶

func (c *Context) GlobalDuration(name string) time.Duration

Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists

func (*Context) GlobalFlagNames ¶

func (c *Context) GlobalFlagNames() (names []string)

Returns a slice of global flag names used by the app.

func (*Context) GlobalGeneric ¶

func (c *Context) GlobalGeneric(name string) interface{}

Looks up the value of a global generic flag, returns nil if no generic flag exists

func (*Context) GlobalInt ¶

func (c *Context) GlobalInt(name string) int

Looks up the value of a global int flag, returns 0 if no int flag exists

func (*Context) GlobalIntSlice ¶

func (c *Context) GlobalIntSlice(name string) []int

Looks up the value of a global int slice flag, returns nil if no int slice flag exists

func (*Context) GlobalIsSet ¶

func (c *Context) GlobalIsSet(name string) bool

Determines if the global flag was actually set

func (*Context) GlobalString ¶

func (c *Context) GlobalString(name string) string

Looks up the value of a global string flag, returns "" if no string flag exists

func (*Context) GlobalStringSlice ¶

func (c *Context) GlobalStringSlice(name string) []string

Looks up the value of a global string slice flag, returns nil if no string slice flag exists

func (*Context) Int ¶

func (c *Context) Int(name string) int

Looks up the value of a local int flag, returns 0 if no int flag exists

func (*Context) IntSlice ¶

func (c *Context) IntSlice(name string) []int

Looks up the value of a local int slice flag, returns nil if no int slice flag exists

func (*Context) IsSet ¶

func (c *Context) IsSet(name string) bool

Determines if the flag was actually set

func (*Context) NArg ¶

func (c *Context) NArg() int

Returns the number of the command line arguments.

func (*Context) NumFlags ¶

func (c *Context) NumFlags() int

Returns the number of flags set

func (*Context) Parent ¶

func (c *Context) Parent() *Context

Returns the parent context, if any

func (*Context) String ¶

func (c *Context) String(name string) string

Looks up the value of a local string flag, returns "" if no string flag exists

func (*Context) StringSlice ¶

func (c *Context) StringSlice(name string) []string

Looks up the value of a local string slice flag, returns nil if no string slice flag exists

type DurationFlag ¶

DurationFlag is a flag that takes a duration specified in Go's duration format: https://golang.org/pkg/time/#ParseDuration

type DurationFlag struct {
    Name        string
    Value       time.Duration
    Usage       string
    EnvVar      string
    Destination *time.Duration
}

func (DurationFlag) Apply ¶

func (f DurationFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (DurationFlag) GetName ¶

func (f DurationFlag) GetName() string

func (DurationFlag) String ¶

func (f DurationFlag) String() string

String returns a readable representation of this value (for usage defaults)

type Flag ¶

Flag is a common interface related to parsing flags in cli. For more advanced flag parsing techniques, it is recommended that this interface be implemented.

type Flag interface {
    fmt.Stringer
    // Apply Flag settings to the given flag set
    Apply(*flag.FlagSet)
    GetName() string
}

type Float64Flag ¶

Float64Flag is a flag that takes an float value Errors if the value provided cannot be parsed

type Float64Flag struct {
    Name        string
    Value       float64
    Usage       string
    EnvVar      string
    Destination *float64
}

func (Float64Flag) Apply ¶

func (f Float64Flag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (Float64Flag) GetName ¶

func (f Float64Flag) GetName() string

func (Float64Flag) String ¶

func (f Float64Flag) String() string

String returns the usage

type Generic ¶

Generic is a generic parseable type identified by a specific flag

type Generic interface {
    Set(value string) error
    String() string
}

type GenericFlag ¶

GenericFlag is the flag type for types implementing Generic

type GenericFlag struct {
    Name   string
    Value  Generic
    Usage  string
    EnvVar string
}

func (GenericFlag) Apply ¶

func (f GenericFlag) Apply(set *flag.FlagSet)

Apply takes the flagset and calls Set on the generic flag with the value provided by the user for parsing by the flag

func (GenericFlag) FormatValueHelp ¶

func (f GenericFlag) FormatValueHelp() string

func (GenericFlag) GetName ¶

func (f GenericFlag) GetName() string

func (GenericFlag) String ¶

func (f GenericFlag) String() string

String returns the string representation of the generic flag to display the help text to the user (uses the String() method of the generic flag to show the value)

type IntFlag ¶

IntFlag is a flag that takes an integer Errors if the value provided cannot be parsed

type IntFlag struct {
    Name        string
    Value       int
    Usage       string
    EnvVar      string
    Destination *int
}

func (IntFlag) Apply ¶

func (f IntFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (IntFlag) GetName ¶

func (f IntFlag) GetName() string

func (IntFlag) String ¶

func (f IntFlag) String() string

String returns the usage

type IntSlice ¶

StringSlice is an opaque type for []int to satisfy flag.Value

type IntSlice []int

func (*IntSlice) Set ¶

func (f *IntSlice) Set(value string) error

Set parses the value into an integer and appends it to the list of values

func (*IntSlice) String ¶

func (f *IntSlice) String() string

String returns a readable representation of this value (for usage defaults)

func (*IntSlice) Value ¶

func (f *IntSlice) Value() []int

Value returns the slice of ints set by this flag

type IntSliceFlag ¶

IntSliceFlag is an int flag that can be specified multiple times on the command-line

type IntSliceFlag struct {
    Name   string
    Value  *IntSlice
    Usage  string
    EnvVar string
}

func (IntSliceFlag) Apply ¶

func (f IntSliceFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (IntSliceFlag) GetName ¶

func (f IntSliceFlag) GetName() string

func (IntSliceFlag) String ¶

func (f IntSliceFlag) String() string

String returns the usage

type MultiError ¶

type MultiError struct {
    Errors []error
}

func NewMultiError ¶

func NewMultiError(err ...error) MultiError

func (MultiError) Error ¶

func (m MultiError) Error() string

type StringFlag ¶

StringFlag represents a flag that takes as string value

type StringFlag struct {
    Name        string
    Value       string
    Usage       string
    EnvVar      string
    Destination *string
}

func (StringFlag) Apply ¶

func (f StringFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (StringFlag) FormatValueHelp ¶

func (f StringFlag) FormatValueHelp() string

func (StringFlag) GetName ¶

func (f StringFlag) GetName() string

func (StringFlag) String ¶

func (f StringFlag) String() string

String returns the usage

type StringSlice ¶

StringSlice is an opaque type for []string to satisfy flag.Value

type StringSlice []string

func (*StringSlice) Set ¶

func (f *StringSlice) Set(value string) error

Set appends the string value to the list of values

func (*StringSlice) String ¶

func (f *StringSlice) String() string

String returns a readable representation of this value (for usage defaults)

func (*StringSlice) Value ¶

func (f *StringSlice) Value() []string

Value returns the slice of strings set by this flag

type StringSliceFlag ¶

StringSlice is a string flag that can be specified multiple times on the command-line

type StringSliceFlag struct {
    Name   string
    Value  *StringSlice
    Usage  string
    EnvVar string
}

func (StringSliceFlag) Apply ¶

func (f StringSliceFlag) Apply(set *flag.FlagSet)

Apply populates the flag given the flag set and environment

func (StringSliceFlag) GetName ¶

func (f StringSliceFlag) GetName() string

func (StringSliceFlag) String ¶

func (f StringSliceFlag) String() string

String returns the usage

Subdirectories