urfave-cli/app.go

280 lines
5.6 KiB
Go
Raw Normal View History

package cli
import (
"fmt"
"io/ioutil"
"os"
2013-11-15 11:40:18 +00:00
"time"
)
2013-11-01 14:31:37 +00:00
// App is the main structure of a cli application. It is recomended that
// and app be created with the cli.NewApp() function
type App struct {
// The name of the program. Defaults to os.Args[0]
Name string
// Description of the program.
Usage string
// Version of the program
Version string
// List of commands to execute
Commands []Command
2013-07-20 22:50:13 +00:00
// List of flags to parse
Flags []Flag
// Boolean to enable bash completion commands
EnableBashCompletion bool
2014-07-13 13:16:30 +00:00
// Boolean to hide built-in help command
HideHelp bool
2014-11-12 11:38:58 +00:00
// Boolean to hide built-in version flag
HideVersion bool
// An action to execute when the bash-completion flag is set
BashComplete func(context *Context)
2014-01-01 21:00:20 +00:00
// 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
// The action to execute when no subcommands are specified
2013-07-20 22:50:13 +00:00
Action func(context *Context)
// Execute this function if the proper command cannot be found
CommandNotFound func(context *Context, command string)
2013-11-15 11:40:18 +00:00
// Compilation date
Compiled time.Time
// Author
Author string
// Author e-mail
Email string
}
// Tries to find out when this binary was compiled.
// Returns the current time if it fails to find it.
func compileTime() time.Time {
info, err := os.Stat(os.Args[0])
if err != nil {
return time.Now()
}
return info.ModTime()
}
2013-11-01 14:31:37 +00:00
// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
func NewApp() *App {
return &App{
Name: os.Args[0],
Usage: "A new cli application",
Version: "0.0.0",
BashComplete: DefaultAppComplete,
Action: helpCommand.Action,
Compiled: compileTime(),
}
}
2013-11-01 14:31:37 +00:00
// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
2013-11-01 13:23:19 +00:00
func (a *App) Run(arguments []string) error {
2013-07-20 15:44:09 +00:00
// append help to commands
2014-07-13 13:16:30 +00:00
if a.Command(helpCommand.Name) == nil && !a.HideHelp {
a.Commands = append(a.Commands, helpCommand)
2014-07-13 13:16:30 +00:00
a.appendFlag(HelpFlag)
}
//append version/help flags
if a.EnableBashCompletion {
a.appendFlag(BashCompletionFlag)
}
2014-11-12 11:38:58 +00:00
if !a.HideVersion {
a.appendFlag(VersionFlag)
}
2013-07-20 15:44:09 +00:00
// parse flags
2013-07-20 15:21:20 +00:00
set := flagSet(a.Name, a.Flags)
set.SetOutput(ioutil.Discard)
2013-07-24 14:35:45 +00:00
err := set.Parse(arguments[1:])
2013-11-20 08:05:18 +00:00
nerr := normalizeFlags(a.Flags, set)
2014-12-02 17:44:55 +00:00
cerr := checkRequiredFlags(a.Flags, set)
context := NewContext(a, set, set)
2013-11-20 08:05:18 +00:00
if nerr != nil {
fmt.Println(nerr)
2014-12-02 17:44:55 +00:00
fmt.Println("")
2013-11-20 08:05:18 +00:00
ShowAppHelp(context)
fmt.Println("")
return nerr
}
2014-12-02 17:44:55 +00:00
if cerr != nil {
fmt.Println(cerr)
fmt.Println("")
ShowAppHelp(context)
fmt.Println("")
return cerr
}
2013-07-24 14:35:45 +00:00
if err != nil {
fmt.Printf("Incorrect Usage.\n\n")
ShowAppHelp(context)
fmt.Println("")
2013-11-01 13:23:19 +00:00
return err
2013-07-24 14:35:45 +00:00
}
2014-04-10 17:14:13 +00:00
if checkCompletions(context) {
return nil
}
if checkHelp(context) {
return nil
}
if checkVersion(context) {
return nil
}
2013-07-20 15:44:09 +00:00
2014-01-01 21:00:20 +00:00
if a.Before != nil {
err := a.Before(context)
if err != nil {
return err
}
}
args := context.Args()
2013-11-24 13:40:21 +00:00
if args.Present() {
name := args.First()
c := a.Command(name)
if c != nil {
return c.Run(context)
}
}
// Run default Action
a.Action(context)
2013-11-01 13:23:19 +00:00
return nil
}
2014-07-13 16:26:20 +00:00
// Another entry point to the cli app, takes care of passing arguments and error handling
func (a *App) RunAndExitOnError() {
if err := a.Run(os.Args); err != nil {
os.Stderr.WriteString(fmt.Sprintln(err))
os.Exit(1)
}
}
// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
func (a *App) RunAsSubcommand(ctx *Context) error {
// append help to commands
if len(a.Commands) > 0 {
2014-07-13 13:16:30 +00:00
if a.Command(helpCommand.Name) == nil && !a.HideHelp {
a.Commands = append(a.Commands, helpCommand)
2014-07-13 13:16:30 +00:00
a.appendFlag(HelpFlag)
}
}
// append flags
if a.EnableBashCompletion {
a.appendFlag(BashCompletionFlag)
}
// parse flags
set := flagSet(a.Name, a.Flags)
set.SetOutput(ioutil.Discard)
err := set.Parse(ctx.Args().Tail())
nerr := normalizeFlags(a.Flags, set)
2014-12-02 17:44:55 +00:00
cerr := checkRequiredFlags(a.Flags, set)
context := NewContext(a, set, ctx.globalSet)
if nerr != nil {
fmt.Println(nerr)
2014-12-02 17:44:55 +00:00
fmt.Println("")
if len(a.Commands) > 0 {
ShowSubcommandHelp(context)
} else {
ShowCommandHelp(ctx, context.Args().First())
}
fmt.Println("")
return nerr
}
2014-12-02 17:44:55 +00:00
if cerr != nil {
fmt.Println(cerr)
fmt.Println("")
if len(a.Commands) > 0 {
ShowSubcommandHelp(context)
fmt.Println("subcommands")
} else {
ShowCommandHelp(ctx, context.Args().First())
fmt.Println("commands")
}
fmt.Println("")
return cerr
}
if err != nil {
fmt.Printf("Incorrect Usage.\n\n")
ShowSubcommandHelp(context)
return err
}
if checkCompletions(context) {
return nil
}
if len(a.Commands) > 0 {
if checkSubcommandHelp(context) {
return nil
}
} else {
if checkCommandHelp(ctx, context.Args().First()) {
return nil
}
}
if a.Before != nil {
err := a.Before(context)
if err != nil {
return err
}
}
args := context.Args()
if args.Present() {
name := args.First()
c := a.Command(name)
if c != nil {
return c.Run(context)
}
}
// Run default Action
if len(a.Commands) > 0 {
a.Action(context)
} else {
a.Action(ctx)
}
return nil
}
2013-11-01 14:31:37 +00:00
// Returns the named command on App. Returns nil if the command does not exist
func (a *App) Command(name string) *Command {
for _, c := range a.Commands {
if c.HasName(name) {
return &c
}
}
return nil
}
func (a *App) hasFlag(flag Flag) bool {
for _, f := range a.Flags {
if flag == f {
return true
}
}
return false
}
func (a *App) appendFlag(flag Flag) {
if !a.hasFlag(flag) {
a.Flags = append(a.Flags, flag)
}
}