cli

package module
Version: v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 22, 2013 License: MIT Imports: 6 Imported by: 0

README

Build Status

cli.go

cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.

Overview

Command line apps are usually so tiny that there is absolutely no reason why your code should not be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.

This is where cli.go comes into play. cli.go makes command line programming fun, organized, and expressive!

Installation

Make sure you have the a working Go environment (go 1.1 is required). See the install instructions.

To install cli.go, simply run:

$ go get github.com/codegangsta/cli

Make sure your PATH includes to the $GOPATH/bin directory so your commands can be easily used:

export PATH=$PATH:$GOPATH/bin

Getting Started

One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in main().

package main

import "os"
import "github.com/codegangsta/cli"

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

This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:

package main

import "os"
import "github.com/codegangsta/cli"

func main() {
  app := cli.NewApp()
  app.Name = "boom"
  app.Usage = "make an explosive entrance"
  app.Action = func(c *cli.Context) {
    println("boom! I say!")
  }
  
  app.Run(os.Args)
}

Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.

Example

Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!

/* greet.go */
package main

import "os"
import "github.com/codegangsta/cli"

func main() {
  app := cli.NewApp()
  app.Name = "greet"
  app.Usage = "fight the loneliness!"
  app.Action = func(c *cli.Context) {
    println("Hello friend!")
  }
  
  app.Run(os.Args)
}

Install our command to the $GOPATH/bin directory:

$ go install

Finally run our new command:

$ greet
Hello friend!

cli.go also generates some bitchass help text:

$ greet help
NAME:
    greet - fight the loneliness!

USAGE:
    greet [global options] command [command options] [arguments...]

VERSION:
    0.0.0

COMMANDS:
    help, h  Shows a list of commands or help for one command

GLOBAL OPTIONS
    --version	Shows version information
Arguments

You can lookup arguments by calling the Args function on cli.Context.

...
app.Action = func(c *cli.Context) {
  println("Hello", c.Args()[0])
}
...
Flags

Setting and querying flags is simple.

...
app.Flags = []cli.Flag {
  cli.StringFlag{"lang", "english", "language for the greeting"},
}
app.Action = func(c *cli.Context) {
  if c.String("lang") == "spanish" {
    println("Hola", c.Args()[0])
  } else {
    println("Hello", c.Args()[0])
  }
}
...
Subcommands

Subcommands can be defined for a more git-like command line app.

...
app.Commands = []cli.Command{
  {
    Name:      "add",
    ShortName: "a",
    Usage:     "add a task to the list",
    Action: func(c *cli.Context) {
      println("added task: ", c.Args()[0])
    },
  },
  {
    Name:      "complete",
    ShortName: "c",
    Usage:     "complete a task on the list",
    Action: func(c *cli.Context) {
      println("completed task: ", c.Args()[0])
    },
  },
}
...

About

cli.go is written by none other than the Code Gangsta

Documentation

Overview

Package cli provides a minimal framework for creating and organizing command line Go applications. cli is designed to be easy to understand and write, the most simple cli application can be written as follows:

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

Of course this application does not do much, so let's make this an actual application:

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)
}
Example
package main

import (
	"os"

	"github.com/codegangsta/cli"
)

func main() {
	app := cli.NewApp()
	app.Name = "todo"
	app.Usage = "task list on the command line"
	app.Commands = []cli.Command{
		{
			Name:      "add",
			ShortName: "a",
			Usage:     "add a task to the list",
			Action: func(c *cli.Context) {
				println("added task: ", c.Args()[0])
			},
		},
		{
			Name:      "complete",
			ShortName: "c",
			Usage:     "complete a task on the list",
			Action: func(c *cli.Context) {
				println("completed task: ", c.Args()[0])
			},
		},
	}

	app.Run(os.Args)
}
Output:

Index

Examples

Constants

This section is empty.

Variables

View Source
var AppHelpTemplate = `` /* 296-byte string literal not displayed */

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.

View Source
var CommandHelpTemplate = `` /* 174-byte string literal not displayed */

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.

Functions

This section is empty.

Types

type App

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
	// List of flags to parse
	Flags []Flag
	// The action to execute when no subcommands are specified
	Action func(context *Context)
}
Example
package main

import (
	"fmt"
	"os"

	"github.com/codegangsta/cli"
)

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

	app := cli.NewApp()
	app.Name = "greet"
	app.Flags = []cli.Flag{
		cli.StringFlag{"name", "bob", "a name to say"},
	}
	app.Action = func(c *cli.Context) {
		fmt.Printf("Hello %v\n", c.String("name"))
	}
	app.Run(os.Args)
}
Output:

Hello Jeremy

func NewApp

func NewApp() *App

func (*App) Run

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

type BoolFlag

type BoolFlag struct {
	Name  string
	Usage string
}

func (BoolFlag) Apply

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

func (BoolFlag) String

func (f BoolFlag) String() string

type Command

type Command struct {
	Name        string
	ShortName   string
	Usage       string
	Description string
	Action      func(context *Context)
	Flags       []Flag
}

func (Command) HasName

func (c Command) HasName(name string) bool

func (Command) Run

func (c Command) Run(ctx *Context)

type Context

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

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.

func NewContext

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

func (*Context) Args

func (c *Context) Args() []string

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) 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) 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) 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) 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) String

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

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

type Flag

type Flag interface {
	fmt.Stringer
	Apply(*flag.FlagSet)
}

type IntFlag

type IntFlag struct {
	Name  string
	Value int
	Usage string
}

func (IntFlag) Apply

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

func (IntFlag) String

func (f IntFlag) String() string

type StringFlag

type StringFlag struct {
	Name  string
	Value string
	Usage string
}

func (StringFlag) Apply

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

func (StringFlag) String

func (f StringFlag) String() string

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL