...
import ("gopkg.in/urfave/cli.v2" // imports as package "cli"
)
...

...
import ("gopkg.in/urfave/cli.v1" // imports as package "cli"
)
...

package mainimport ("os""github.com/urfave/cli"
)func main() {cli.NewApp().Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Name = "boom"app.Usage = "make an explosive entrance"app.Action = func(c *cli.Context) error {fmt.Println("boom! I say!")return nil}app.Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Name = "greet"app.Usage = "fight the loneliness!"app.Action = func(c *cli.Context) error {fmt.Println("Hello friend!")return nil}app.Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Action = func(c *cli.Context) error {fmt.Printf("Hello %q", c.Args().Get(0))return nil}app.Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag {cli.StringFlag{Name: "lang",Value: "english",Usage: "language for the greeting",},}app.Action = func(c *cli.Context) error {name := "Nefertiti"if c.NArg() > 0 {name = c.Args().Get(0)}if c.String("lang") == "spanish" {fmt.Println("Hola", name)} else {fmt.Println("Hello", name)}return nil}app.Run(os.Args)
}

package mainimport ("os""fmt""github.com/urfave/cli"
)func main() {var language stringapp := cli.NewApp()app.Flags = []cli.Flag {cli.StringFlag{Name:        "lang",Value:       "english",Usage:       "language for the greeting",Destination: &language,},}app.Action = func(c *cli.Context) error {name := "someone"if c.NArg() > 0 {name = c.Args()[0]}if language == "spanish" {fmt.Println("Hola", name)} else {fmt.Println("Hello", name)}return nil}app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag{cli.StringFlag{Name:  "config, c",Usage: "Load configuration from `FILE`",},}app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag {cli.StringFlag{Name: "lang, l",Value: "english",Usage: "language for the greeting",},}app.Run(os.Args)
}

package mainimport ("os""sort""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag {cli.StringFlag{Name: "lang, l",Value: "english",Usage: "Language for the greeting",},cli.StringFlag{Name: "config, c",Usage: "Load configuration from `FILE`",},}app.Commands = []cli.Command{{Name:    "complete",Aliases: []string{"c"},Usage:   "complete a task on the list",Action:  func(c *cli.Context) error {return nil},},{Name:    "add",Aliases: []string{"a"},Usage:   "add a task to the list",Action:  func(c *cli.Context) error {return nil},},}sort.Sort(cli.FlagsByName(app.Flags))sort.Sort(cli.CommandsByName(app.Commands))app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag {cli.StringFlag{Name: "lang, l",Value: "english",Usage: "language for the greeting",EnvVar: "APP_LANG",},}app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag {cli.StringFlag{Name: "lang, l",Value: "english",Usage: "language for the greeting",EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",},}app.Run(os.Args)
}

  altsrc.NewIntFlag(cli.IntFlag{Name: "test"})

  command.Before = altsrc.InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))

package notmainimport ("fmt""os""github.com/urfave/cli""github.com/urfave/cli/altsrc"
)func main() {app := cli.NewApp()flags := []cli.Flag{altsrc.NewIntFlag(cli.IntFlag{Name: "test"}),cli.StringFlag{Name: "load"},}app.Action = func(c *cli.Context) error {fmt.Println("yaml ist rad")return nil}app.Before = altsrc.InitInputSourceWithContext(flags, altsrc.NewYamlSourceFromFlagFunc("load"))app.Flags = flagsapp.Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Commands = []cli.Command{{Name:    "add",Aliases: []string{"a"},Usage:   "add a task to the list",Action:  func(c *cli.Context) error {fmt.Println("added task: ", c.Args().First())return nil},},{Name:    "complete",Aliases: []string{"c"},Usage:   "complete a task on the list",Action:  func(c *cli.Context) error {fmt.Println("completed task: ", c.Args().First())return nil},},{Name:        "template",Aliases:     []string{"t"},Usage:       "options for task templates",Subcommands: []cli.Command{{Name:  "add",Usage: "add a new template",Action: func(c *cli.Context) error {fmt.Println("new task template: ", c.Args().First())return nil},},{Name:  "remove",Usage: "remove an existing template",Action: func(c *cli.Context) error {fmt.Println("removed task template: ", c.Args().First())return nil},},},},}app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Commands = []cli.Command{{Name: "noop",},{Name:     "add",Category: "template",},{Name:     "remove",Category: "template",},}app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {app := cli.NewApp()app.Flags = []cli.Flag{cli.BoolTFlag{Name:  "ginger-crouton",Usage: "is it in the soup?",},}app.Action = func(ctx *cli.Context) error {if !ctx.Bool("ginger-crouton") {return cli.NewExitError("it is not in the soup", 86)}return nil}app.Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)func main() {tasks := []string{"cook", "clean", "laundry", "eat", "sleep", "code"}app := cli.NewApp()app.EnableBashCompletion = trueapp.Commands = []cli.Command{{Name:  "complete",Aliases: []string{"c"},Usage: "complete a task on the list",Action: func(c *cli.Context) error {fmt.Println("completed task: ", c.Args().First())return nil},BashComplete: func(c *cli.Context) {// This will complete if no args are passedif c.NArg() > 0 {return}for _, t := range tasks {fmt.Println(t)}},},}app.Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {cli.BashCompletionFlag = cli.BoolFlag{Name:   "compgen",Hidden: true,}app := cli.NewApp()app.EnableBashCompletion = trueapp.Commands = []cli.Command{{Name: "wat",},}app.Run(os.Args)
}

package mainimport ("fmt""io""os""github.com/urfave/cli"
)func main() {// EXAMPLE: Append to an existing templatecli.AppHelpTemplate = fmt.Sprintf(`%s

WEBSITE: http://awesometown.example.com

SUPPORT: support@awesometown.example.com

`, cli.AppHelpTemplate)// EXAMPLE: Override a templatecli.AppHelpTemplate = `NAME:
   {{.Name}} - {{.Usage}}
USAGE:
   {{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
   {{if len .Authors}}
AUTHOR:
   {{range .Authors}}{{ . }}{{end}}
   {{end}}{{if .Commands}}
COMMANDS:
{{range .Commands}}{{if not .HideHelp}}   {{join .Names ", "}}{{ "\t"}}{{.Usage}}{{ "\n" }}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
GLOBAL OPTIONS:
   {{range .VisibleFlags}}{{.}}
   {{end}}{{end}}{{if .Copyright }}
COPYRIGHT:
   {{.Copyright}}
   {{end}}{{if .Version}}
VERSION:
   {{.Version}}
   {{end}}
`// EXAMPLE: Replace the `HelpPrinter` funccli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {fmt.Println("Ha HA.  I pwnd the help!!1")}cli.NewApp().Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {cli.HelpFlag = cli.BoolFlag{Name: "halp, haaaaalp",Usage: "HALP",EnvVar: "SHOW_HALP,HALPPLZ",}cli.NewApp().Run(os.Args)
}

package mainimport ("os""github.com/urfave/cli"
)func main() {cli.VersionFlag = cli.BoolFlag{Name: "print-version, V",Usage: "print only the version",}app := cli.NewApp()app.Name = "partay"app.Version = "19.99.0"app.Run(os.Args)
}

package mainimport ("fmt""os""github.com/urfave/cli"
)var (Revision = "fafafaf"
)func main() {cli.VersionPrinter = func(c *cli.Context) {fmt.Printf("version=%s revision=%s\n", c.App.Version, Revision)}app := cli.NewApp()app.Name = "partay"app.Version = "19.99.0"app.Run(os.Args)
}

package mainimport ("errors""flag""fmt""io""io/ioutil""os""time""github.com/urfave/cli"
)func init() {cli.AppHelpTemplate += "\nCUSTOMIZED: you bet ur muffins\n"cli.CommandHelpTemplate += "\nYMMV\n"cli.SubcommandHelpTemplate += "\nor something\n"cli.HelpFlag = cli.BoolFlag{Name: "halp"}cli.BashCompletionFlag = cli.BoolFlag{Name: "compgen", Hidden: true}cli.VersionFlag = cli.BoolFlag{Name: "print-version, V"}cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {fmt.Fprintf(w, "best of luck to you\n")}cli.VersionPrinter = func(c *cli.Context) {fmt.Fprintf(c.App.Writer, "version=%s\n", c.App.Version)}cli.OsExiter = func(c int) {fmt.Fprintf(cli.ErrWriter, "refusing to exit %d\n", c)}cli.ErrWriter = ioutil.Discardcli.FlagStringer = func(fl cli.Flag) string {return fmt.Sprintf("\t\t%s", fl.GetName())}
}type hexWriter struct{}func (w *hexWriter) Write(p []byte) (int, error) {for _, b := range p {fmt.Printf("%x", b)}fmt.Printf("\n")return len(p), nil
}type genericType struct{s string
}func (g *genericType) Set(value string) error {g.s = valuereturn nil
}func (g *genericType) String() string {return g.s
}func main() {app := cli.NewApp()app.Name = "kənˈtrīv"app.Version = "19.99.0"app.Compiled = time.Now()app.Authors = []cli.Author{cli.Author{Name:  "Example Human",Email: "human@example.com",},}app.Copyright = "(c) 1999 Serious Enterprise"app.HelpName = "contrive"app.Usage = "demonstrate available API"app.UsageText = "contrive - demonstrating the available API"app.ArgsUsage = "[args and such]"app.Commands = []cli.Command{cli.Command{Name:        "doo",Aliases:     []string{"do"},Category:    "motion",Usage:       "do the doo",UsageText:   "doo - does the dooing",Description: "no really, there is a lot of dooing to be done",ArgsUsage:   "[arrgh]",Flags: []cli.Flag{cli.BoolFlag{Name: "forever, forevvarr"},},Subcommands: cli.Commands{cli.Command{Name:   "wop",Action: wopAction,},},SkipFlagParsing: false,HideHelp:        false,Hidden:          false,HelpName:        "doo!",BashComplete: func(c *cli.Context) {fmt.Fprintf(c.App.Writer, "--better\n")},Before: func(c *cli.Context) error {fmt.Fprintf(c.App.Writer, "brace for impact\n")return nil},After: func(c *cli.Context) error {fmt.Fprintf(c.App.Writer, "did we lose anyone?\n")return nil},Action: func(c *cli.Context) error {c.Command.FullName()c.Command.HasName("wop")c.Command.Names()c.Command.VisibleFlags()fmt.Fprintf(c.App.Writer, "dodododododoodododddooooododododooo\n")if c.Bool("forever") {c.Command.Run(c)}return nil},OnUsageError: func(c *cli.Context, err error, isSubcommand bool) error {fmt.Fprintf(c.App.Writer, "for shame\n")return err},},}app.Flags = []cli.Flag{cli.BoolFlag{Name: "fancy"},cli.BoolTFlag{Name: "fancier"},cli.DurationFlag{Name: "howlong, H", Value: time.Second * 3},cli.Float64Flag{Name: "howmuch"},cli.GenericFlag{Name: "wat", Value: &genericType{}},cli.Int64Flag{Name: "longdistance"},cli.Int64SliceFlag{Name: "intervals"},cli.IntFlag{Name: "distance"},cli.IntSliceFlag{Name: "times"},cli.StringFlag{Name: "dance-move, d"},cli.StringSliceFlag{Name: "names, N"},cli.UintFlag{Name: "age"},cli.Uint64Flag{Name: "bigage"},}app.EnableBashCompletion = trueapp.HideHelp = falseapp.HideVersion = falseapp.BashComplete = func(c *cli.Context) {fmt.Fprintf(c.App.Writer, "lipstick\nkiss\nme\nlipstick\nringo\n")}app.Before = func(c *cli.Context) error {fmt.Fprintf(c.App.Writer, "HEEEERE GOES\n")return nil}app.After = func(c *cli.Context) error {fmt.Fprintf(c.App.Writer, "Phew!\n")return nil}app.CommandNotFound = func(c *cli.Context, command string) {fmt.Fprintf(c.App.Writer, "Thar be no %q here.\n", command)}app.OnUsageError = func(c *cli.Context, err error, isSubcommand bool) error {if isSubcommand {return err}fmt.Fprintf(c.App.Writer, "WRONG: %#v\n", err)return nil}app.Action = func(c *cli.Context) error {cli.DefaultAppComplete(c)cli.HandleExitCoder(errors.New("not an exit coder, though"))cli.ShowAppHelp(c)cli.ShowCommandCompletions(c, "nope")cli.ShowCommandHelp(c, "also-nope")cli.ShowCompletions(c)cli.ShowSubcommandHelp(c)cli.ShowVersion(c)categories := c.App.Categories()categories.AddCommand("sounds", cli.Command{Name: "bloop",})for _, category := range c.App.Categories() {fmt.Fprintf(c.App.Writer, "%s\n", category.Name)fmt.Fprintf(c.App.Writer, "%#v\n", category.Commands)fmt.Fprintf(c.App.Writer, "%#v\n", category.VisibleCommands())}fmt.Printf("%#v\n", c.App.Command("doo"))if c.Bool("infinite") {c.App.Run([]string{"app", "doo", "wop"})}if c.Bool("forevar") {c.App.RunAsSubcommand(c)}c.App.Setup()fmt.Printf("%#v\n", c.App.VisibleCategories())fmt.Printf("%#v\n", c.App.VisibleCommands())fmt.Printf("%#v\n", c.App.VisibleFlags())fmt.Printf("%#v\n", c.Args().First())if len(c.Args()) > 0 {fmt.Printf("%#v\n", c.Args()[1])}fmt.Printf("%#v\n", c.Args().Present())fmt.Printf("%#v\n", c.Args().Tail())set := flag.NewFlagSet("contrive", 0)nc := cli.NewContext(c.App, set, c)fmt.Printf("%#v\n", nc.Args())fmt.Printf("%#v\n", nc.Bool("nope"))fmt.Printf("%#v\n", nc.BoolT("nerp"))fmt.Printf("%#v\n", nc.Duration("howlong"))fmt.Printf("%#v\n", nc.Float64("hay"))fmt.Printf("%#v\n", nc.Generic("bloop"))fmt.Printf("%#v\n", nc.Int64("bonk"))fmt.Printf("%#v\n", nc.Int64Slice("burnks"))fmt.Printf("%#v\n", nc.Int("bips"))fmt.Printf("%#v\n", nc.IntSlice("blups"))fmt.Printf("%#v\n", nc.String("snurt"))fmt.Printf("%#v\n", nc.StringSlice("snurkles"))fmt.Printf("%#v\n", nc.Uint("flub"))fmt.Printf("%#v\n", nc.Uint64("florb"))fmt.Printf("%#v\n", nc.GlobalBool("global-nope"))fmt.Printf("%#v\n", nc.GlobalBoolT("global-nerp"))fmt.Printf("%#v\n", nc.GlobalDuration("global-howlong"))fmt.Printf("%#v\n", nc.GlobalFloat64("global-hay"))fmt.Printf("%#v\n", nc.GlobalGeneric("global-bloop"))fmt.Printf("%#v\n", nc.GlobalInt("global-bips"))fmt.Printf("%#v\n", nc.GlobalIntSlice("global-blups"))fmt.Printf("%#v\n", nc.GlobalString("global-snurt"))fmt.Printf("%#v\n", nc.GlobalStringSlice("global-snurkles"))fmt.Printf("%#v\n", nc.FlagNames())fmt.Printf("%#v\n", nc.GlobalFlagNames())fmt.Printf("%#v\n", nc.GlobalIsSet("wat"))fmt.Printf("%#v\n", nc.GlobalSet("wat", "nope"))fmt.Printf("%#v\n", nc.NArg())fmt.Printf("%#v\n", nc.NumFlags())fmt.Printf("%#v\n", nc.Parent())nc.Set("wat", "also-nope")ec := cli.NewExitError("ohwell", 86)fmt.Fprintf(c.App.Writer, "%d", ec.ExitCode())fmt.Printf("made it!\n")return ec}if os.Getenv("HEXY") != "" {app.Writer = &hexWriter{}app.ErrWriter = &hexWriter{}}app.Metadata = map[string]interface{}{"layers":     "many","explicable": false,"whatever-values": 19.99,}app.Run(os.Args)
}func wopAction(c *cli.Context) error {fmt.Fprintf(c.App.Writer, ":wave: over here, eh\n")return nil
}