spf13--cobra/README.md

878 lines
29 KiB
Markdown
Raw Normal View History

2015-11-02 15:53:04 +00:00
![cobra logo](https://cloud.githubusercontent.com/assets/173412/10886352/ad566232-814f-11e5-9cd0-aa101788c117.png)
2013-09-03 22:45:49 +00:00
Cobra is both a library for creating powerful modern CLI applications as well as a program to generate applications and command files.
Many of the most widely used Go projects are built using Cobra including:
* [Kubernetes](http://kubernetes.io/)
* [Hugo](http://gohugo.io)
2015-11-06 10:00:25 +00:00
* [rkt](https://github.com/coreos/rkt)
2016-01-06 07:25:13 +00:00
* [etcd](https://github.com/coreos/etcd)
* [Docker (distribution)](https://github.com/docker/distribution)
* [OpenShift](https://www.openshift.com/)
* [Delve](https://github.com/derekparker/delve)
* [GopherJS](http://www.gopherjs.org/)
2015-10-29 19:31:43 +00:00
* [CockroachDB](http://www.cockroachlabs.com/)
* [Bleve](http://www.blevesearch.com/)
* [ProjectAtomic (enterprise)](http://www.projectatomic.io/)
* [Parse (CLI)](https://parse.com/)
2016-02-08 22:02:55 +00:00
* [GiantSwarm's swarm](https://github.com/giantswarm/cli)
* [Nanobox](https://github.com/nanobox-io/nanobox)/[Nanopack](https://github.com/nanopack)
2013-09-03 22:45:49 +00:00
[![Build Status](https://travis-ci.org/spf13/cobra.svg "Travis CI status")](https://travis-ci.org/spf13/cobra)
2015-11-15 05:46:43 +00:00
[![CircleCI status](https://circleci.com/gh/spf13/cobra.png?circle-token=:circle-token "CircleCI status")](https://circleci.com/gh/spf13/cobra)
2013-09-24 21:08:47 +00:00
2015-11-03 15:07:00 +00:00
![cobra](https://cloud.githubusercontent.com/assets/173412/10911369/84832a8e-8212-11e5-9f82-cc96660a4794.gif)
2015-11-02 15:55:33 +00:00
2015-11-19 03:56:25 +00:00
# Overview
2013-09-03 22:45:49 +00:00
Cobra is a library providing a simple interface to create powerful modern CLI
interfaces similar to git & go tools.
Cobra is also an application that will generate your application scaffolding to rapidly
2015-11-15 05:46:43 +00:00
develop a Cobra-based application.
2013-09-03 22:45:49 +00:00
Cobra provides:
2015-11-15 05:46:43 +00:00
* Easy subcommand-based CLIs: `app server`, `app fetch`, etc.
* Fully POSIX-compliant flags (including short & long versions)
* Nested subcommands
* Global, local and cascading flags
* Easy generation of applications & commands with `cobra create appname` & `cobra add cmdname`
2015-11-15 05:46:43 +00:00
* Intelligent suggestions (`app srver`... did you mean `app server`?)
* Automatic help generation for commands and flags
* Automatic detailed help for `app help [command]`
* Automatic help flag recognition of `-h`, `--help`, etc.
* Automatically generated bash autocomplete for your application
* Automatically generated man pages for your application
* Command aliases so you can change things without breaking them
2015-11-15 05:46:43 +00:00
* The flexibilty to define your own help, usage, etc.
* Optional tight integration with [viper](http://github.com/spf13/viper) for 12-factor apps
2013-09-03 22:45:49 +00:00
2013-11-05 17:40:10 +00:00
Cobra has an exceptionally clean interface and simple design without needless
constructors or initialization methods.
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
Applications built with Cobra commands are designed to be as user-friendly as
2014-06-17 16:32:27 +00:00
possible. Flags can be placed before or after the command (as long as a
confusing space isnt provided). Both short and long flags can be used. A
2015-11-19 03:56:25 +00:00
command need not even be fully typed. Help is automatically generated and
available for the application or for a specific command using either the help
command or the `--help` flag.
2014-06-17 16:32:27 +00:00
2015-11-19 03:56:25 +00:00
# Concepts
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
Cobra is built on a structure of commands, arguments & flags.
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
**Commands** represent actions, **Args** are things and **Flags** are modifiers for those actions.
The best applications will read like sentences when used. Users will know how
to use the application because they will natively understand how to use it.
The pattern to follow is
2015-11-19 03:56:25 +00:00
`APPNAME VERB NOUN --ADJECTIVE.`
or
`APPNAME COMMAND ARG --FLAG`
A few good real world examples may better illustrate this point.
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
In the following example, 'server' is a command, and 'port' is a flag:
2013-09-03 22:45:49 +00:00
2015-12-08 09:17:31 +00:00
> hugo server --port=1313
2015-11-19 03:56:25 +00:00
In this command we are telling Git to clone the url bare.
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
> git clone URL --bare
## Commands
2013-09-03 22:45:49 +00:00
Command is the central point of the application. Each interaction that
the application supports will be contained in a Command. A command can
have children commands and optionally run an action.
2015-11-15 05:46:43 +00:00
In the example above, 'server' is the command.
2013-09-03 22:45:49 +00:00
2013-11-05 17:40:10 +00:00
A Command has the following structure:
2015-11-15 05:46:43 +00:00
```go
type Command struct {
Use string // The one-line usage message.
Short string // The short description shown in the 'help' output.
Long string // The long message shown in the 'help <this-command>' output.
Run func(cmd *Command, args []string) // Run runs the command.
}
```
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
## Flags
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
A Flag is a way to modify the behavior of a command. Cobra supports
fully POSIX-compliant flags as well as the Go [flag package](https://golang.org/pkg/flag/).
2014-01-12 05:34:06 +00:00
A Cobra command can define flags that persist through to children commands
2013-11-05 17:40:10 +00:00
and flags that are only available to that command.
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
In the example above, 'port' is the flag.
2013-09-03 22:45:49 +00:00
2013-11-05 17:40:10 +00:00
Flag functionality is provided by the [pflag
2015-06-05 17:02:54 +00:00
library](https://github.com/ogier/pflag), a fork of the flag standard library
2015-11-15 05:46:43 +00:00
which maintains the same interface while adding POSIX compliance.
2013-11-05 17:40:10 +00:00
2013-09-03 22:45:49 +00:00
## Usage
2013-11-05 17:40:10 +00:00
Cobra works by creating a set of commands and then organizing them into a tree.
The tree defines the structure of the application.
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
Once each command is defined with its corresponding flags, then the
2013-11-05 17:40:10 +00:00
tree is assigned to the commander which is finally executed.
2015-11-19 03:56:25 +00:00
# Installing
2015-11-15 05:46:43 +00:00
Using Cobra is easy. First, use `go get` to install the latest version
of the library. This command will install the `cobra` generator executible
along with the library:
2013-09-03 22:45:49 +00:00
> go get -v github.com/spf13/cobra/cobra
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
Next, include Cobra in your application:
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
```go
import "github.com/spf13/cobra"
```
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
# Getting Started
While you are welcome to provide your own organization, typically a Cobra based
application will follow the following organizational structure.
```
▾ appName/
▾ cmd/
add.go
your.go
commands.go
here.go
main.go
```
In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra.
```go
package main
import "{pathToYourApp}/cmd"
func main() {
if err := cmd.RootCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(-1)
}
2015-11-19 03:56:25 +00:00
}
```
## Using the Cobra Generator
Cobra provides its own program that will create your application and add any
2015-11-19 03:56:25 +00:00
commands you want. It's the easiest way to incorporate Cobra into your application.
### cobra init
The `cobra init [yourApp]` command will create your initial application code
for you. It is a very powerful application that will populate your program with
the right structure so you can immediately enjoy all the benefits of Cobra. It
will also automatically apply the license you specify to your application.
Cobra init is pretty smart. You can provide it a full path, or simply a path
similar to what is expected in the import.
```
cobra init github.com/spf13/newAppName
```
### cobra add
Once an application is initialized Cobra can create additional commands for you.
Let's say you created an app and you wanted the following commands for it:
* app serve
* app config
* app config create
In your project directory (where your main.go file is) you would run the following:
```
cobra add serve
cobra add config
cobra add create -p 'configCmd'
```
2015-12-09 07:48:54 +00:00
Once you have run these three commands you would have an app structure that would look like:
2015-11-19 03:56:25 +00:00
```
▾ app/
▾ cmd/
serve.go
config.go
create.go
main.go
```
at this point you can run `go run main.go` and it would run your app. `go run
main.go serve`, `go run main.go config`, `go run main.go config create` along
with `go run main.go help serve`, etc would all work.
Obviously you haven't added your own code to these yet, the commands are ready
for you to give them their tasks. Have fun.
### Configuring the cobra generator
The cobra generator will be easier to use if you provide a simple configuration
file which will help you eliminate providing a bunch of repeated information in
flags over and over.
an example ~/.cobra.yaml file:
```yaml
author: Steve Francia <spf@spf13.com>
license: MIT
```
## Manually implementing Cobra
To manually implement cobra you need to create a bare main.go file and a RootCmd file.
You will optionally provide additional commands as you see fit.
2013-11-05 17:40:10 +00:00
### Create the root command
2013-09-03 22:45:49 +00:00
2013-11-05 17:40:10 +00:00
The root command represents your binary itself.
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
#### Manually create rootCmd
2013-11-05 17:40:10 +00:00
Cobra doesn't require any special constructors. Simply create your commands.
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
Ideally you place this in app/cmd/root.go:
```go
2015-11-19 03:56:25 +00:00
var RootCmd = &cobra.Command{
Use: "hugo",
Short: "Hugo is a very fast static site generator",
Long: `A Fast and Flexible Static Site Generator built with
2013-11-05 17:40:10 +00:00
love by spf13 and friends in Go.
Complete documentation is available at http://hugo.spf13.com`,
Run: func(cmd *cobra.Command, args []string) {
// Do Stuff Here
},
}
```
2013-09-03 22:45:49 +00:00
2015-11-19 03:56:25 +00:00
You will additionally define flags and handle configuration in your init() function.
for example cmd/root.go:
```go
func init() {
cobra.OnInitialize(initConfig)
RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")
RootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/")
RootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution")
RootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "Name of license for the project (can provide `licensetext` in config)")
RootCmd.PersistentFlags().Bool("viper", true, "Use Viper for configuration")
viper.BindPFlag("author", RootCmd.PersistentFlags().Lookup("author"))
viper.BindPFlag("projectbase", RootCmd.PersistentFlags().Lookup("projectbase"))
viper.BindPFlag("useViper", RootCmd.PersistentFlags().Lookup("viper"))
viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")
viper.SetDefault("license", "apache")
}
```
### Create your main.go
With the root command you need to have your main function execute it.
Execute should be run on the root for clarity, though it can be called on any command.
In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra.
```go
package main
import "{pathToYourApp}/cmd"
func main() {
if err := cmd.RootCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(-1)
}
2015-11-19 03:56:25 +00:00
}
```
2013-11-05 17:40:10 +00:00
### Create additional commands
2013-09-24 20:52:33 +00:00
2015-11-19 03:56:25 +00:00
Additional commands can be defined and typically are each given their own file
inside of the cmd/ directory.
If you wanted to create a version command you would create cmd/version.go and
populate it with the following:
2013-11-05 17:40:10 +00:00
```go
2015-11-19 03:56:25 +00:00
package cmd
import (
"github.com/spf13/cobra"
)
func init() {
RootCmd.AddCommand(versionCmd)
}
var versionCmd = &cobra.Command{
Use: "version",
Short: "Print the version number of Hugo",
Long: `All software has versions. This is Hugo's`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")
},
}
```
2013-11-05 17:40:10 +00:00
### Attach command to its parent
2015-11-19 03:56:25 +00:00
If you notice in the above example we attach the command to its parent. In
2015-11-19 03:56:25 +00:00
this case the parent is the rootCmd. In this example we are attaching it to the
root, but commands can be attached at any level.
```go
RootCmd.AddCommand(versionCmd)
```
### Remove a command from its parent
Removing a command is not a common action in simple programs, but it allows 3rd
parties to customize an existing command tree.
In this example, we remove the existing `VersionCmd` command of an existing
root command, and we replace it with our own version:
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
```go
2015-11-19 03:56:25 +00:00
mainlib.RootCmd.RemoveCommand(mainlib.VersionCmd)
mainlib.RootCmd.AddCommand(versionCmd)
2015-11-15 05:46:43 +00:00
```
2013-11-05 17:40:10 +00:00
2015-11-19 03:56:25 +00:00
## Working with Flags
Flags provide modifiers to control how the action command operates.
2013-11-05 17:40:10 +00:00
### Assign flags to a command
2014-12-19 03:41:49 +00:00
Since the flags are defined and used in different locations, we need to
define a variable outside with the correct scope to assign the flag to
work with.
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
```go
var Verbose bool
var Source string
```
2013-11-05 17:40:10 +00:00
There are two different approaches to assign a flag.
2015-11-19 03:56:25 +00:00
### Persistent Flags
2013-11-05 17:40:10 +00:00
A flag can be 'persistent' meaning that this flag will be available to the
command it's assigned to as well as every command under that command. For
2015-11-15 05:46:43 +00:00
global flags, assign a flag as a persistent flag on the root.
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
```go
2015-11-19 03:56:25 +00:00
RootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")
2015-11-15 05:46:43 +00:00
```
2013-11-05 17:40:10 +00:00
2015-11-19 03:56:25 +00:00
### Local Flags
2013-11-05 17:40:10 +00:00
A flag can also be assigned locally which will only apply to that specific command.
2015-11-15 05:46:43 +00:00
```go
2015-11-19 03:56:25 +00:00
RootCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")
2015-11-15 05:46:43 +00:00
```
2015-03-13 03:40:00 +00:00
2013-09-24 20:52:33 +00:00
## Example
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
In the example below, we have defined three commands. Two are at the top level
2013-11-05 17:40:10 +00:00
and one (cmdTimes) is a child of one of the top commands. In this case the root
2014-08-06 00:28:49 +00:00
is not executable meaning that a subcommand is required. This is accomplished
2013-11-05 17:40:10 +00:00
by not providing a 'Run' for the 'rootCmd'.
We have only defined one flag for a single command.
More documentation about flags is available at https://github.com/spf13/pflag
2015-11-15 05:46:43 +00:00
```go
package main
2013-11-05 17:40:10 +00:00
import (
"fmt"
"strings"
2013-09-03 22:45:49 +00:00
"github.com/spf13/cobra"
)
2013-09-03 22:45:49 +00:00
func main() {
var echoTimes int
2013-09-03 22:45:49 +00:00
var cmdPrint = &cobra.Command{
Use: "print [string to print]",
Short: "Print anything to the screen",
Long: `print is for printing anything back to the screen.
2013-09-24 20:45:20 +00:00
For many years people have printed back to the screen.
`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("Print: " + strings.Join(args, " "))
},
}
var cmdEcho = &cobra.Command{
Use: "echo [string to echo]",
Short: "Echo anything to the screen",
Long: `echo is for echoing anything back.
2013-09-24 20:45:20 +00:00
Echo works a lot like print, except it has a child command.
`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("Print: " + strings.Join(args, " "))
},
}
var cmdTimes = &cobra.Command{
Use: "times [# times] [string to echo]",
Short: "Echo anything to the screen more times",
Long: `echo things multiple times back to the user by providing
2013-09-24 20:45:20 +00:00
a count and a string.`,
Run: func(cmd *cobra.Command, args []string) {
for i := 0; i < echoTimes; i++ {
fmt.Println("Echo: " + strings.Join(args, " "))
}
},
}
cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")
2013-11-05 17:40:10 +00:00
var rootCmd = &cobra.Command{Use: "app"}
rootCmd.AddCommand(cmdPrint, cmdEcho)
cmdEcho.AddCommand(cmdTimes)
rootCmd.Execute()
}
```
2015-11-15 05:46:43 +00:00
For a more complete example of a larger application, please checkout [Hugo](http://gohugo.io/).
2013-11-05 17:40:10 +00:00
## The Help Command
Cobra automatically adds a help command to your application when you have subcommands.
2015-11-15 05:46:43 +00:00
This will be called when a user runs 'app help'. Additionally, help will also
support all other commands as input. Say, for instance, you have a command called
'create' without any additional configuration; Cobra will work when 'app help
create' is called. Every command will automatically have the '--help' flag added.
2013-11-05 17:40:10 +00:00
### Example
2015-11-15 05:46:43 +00:00
The following output is automatically generated by Cobra. Nothing beyond the
2013-11-05 17:40:10 +00:00
command and flag definitions are needed.
> hugo help
2015-11-15 05:46:43 +00:00
hugo is the main command, used to build your Hugo site.
2015-11-15 05:46:43 +00:00
Hugo is a Fast and Flexible Static Site Generator
built with love by spf13 and friends in Go.
2015-11-15 05:46:43 +00:00
Complete documentation is available at http://gohugo.io/.
2013-11-05 17:40:10 +00:00
Usage:
hugo [flags]
hugo [command]
2013-11-05 17:40:10 +00:00
Available Commands:
2015-11-15 05:46:43 +00:00
server Hugo runs its own webserver to render the files
version Print the version number of Hugo
config Print the site configuration
check Check content in the source directory
benchmark Benchmark hugo by building a site a number of times.
convert Convert your content to different formats
new Create new content for your site
list Listing out various types of content
undraft Undraft changes the content's draft status from 'True' to 'False'
genautocomplete Generate shell autocompletion script for Hugo
gendoc Generate Markdown documentation for the Hugo CLI.
genman Generate man page for Hugo
import Import your site from others.
2015-11-15 05:46:43 +00:00
Flags:
-b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/
-D, --buildDrafts[=false]: include content marked as draft
-F, --buildFuture[=false]: include content with publishdate in the future
--cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
--canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL
2013-11-05 17:40:10 +00:00
--config="": config file (default is path/config.yaml|json|toml)
-d, --destination="": filesystem path to write files to
2015-11-15 05:46:43 +00:00
--disableRSS[=false]: Do not build RSS files
--disableSitemap[=false]: Do not build Sitemap file
--editor="": edit new content with this editor, if provided
--ignoreCache[=false]: Ignores the cache directory for reading but still writes to it
--log[=false]: Enable Logging
--logFile="": Log File path (if set, logging enabled automatically)
--noTimes[=false]: Don't sync modification time of files
--pluralizeListTitles[=true]: Pluralize titles in lists using inflect
--preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")
2013-11-05 17:40:10 +00:00
-s, --source="": filesystem path to read files relative from
2015-11-15 05:46:43 +00:00
--stepAnalysis[=false]: display memory and timing of different steps of the program
-t, --theme="": theme to use (located in /themes/THEMENAME/)
--uglyURLs[=false]: if true, use /filename.html instead of /filename/
-v, --verbose[=false]: verbose output
--verboseLog[=false]: verbose logging
-w, --watch[=false]: watch filesystem for changes and recreate as needed
2015-11-15 05:46:43 +00:00
Use "hugo [command] --help" for more information about a command.
2013-11-05 17:40:10 +00:00
Help is just a command like any other. There is no special logic or behavior
2015-11-15 05:46:43 +00:00
around it. In fact, you can provide your own if you want.
2013-11-05 17:40:10 +00:00
### Defining your own help
2016-02-06 16:38:32 +00:00
You can provide your own Help command or your own template for the default command to use.
2013-11-05 17:40:10 +00:00
The default help command is
2013-11-05 17:40:10 +00:00
```go
func (c *Command) initHelp() {
if c.helpCommand == nil {
c.helpCommand = &Command{
Use: "help [command]",
Short: "Help about any command",
Long: `Help provides help for any command in the application.
2013-11-05 17:40:10 +00:00
Simply type ` + c.Name() + ` help [path to command] for full details.`,
Run: c.HelpFunc(),
}
}
c.AddCommand(c.helpCommand)
}
```
2013-09-03 22:45:49 +00:00
2015-11-15 05:46:43 +00:00
You can provide your own command, function or template through the following methods:
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
```go
command.SetHelpCommand(cmd *Command)
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
command.SetHelpFunc(f func(*Command, []string))
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
command.SetHelpTemplate(s string)
```
2013-11-05 17:40:10 +00:00
The latter two will also apply to any children commands.
## Usage
2015-11-15 05:46:43 +00:00
When the user provides an invalid flag or invalid command, Cobra responds by
showing the user the 'usage'.
2013-11-05 17:40:10 +00:00
### Example
2014-06-17 16:32:27 +00:00
You may recognize this from the help above. That's because the default help
2015-11-15 05:46:43 +00:00
embeds the usage as part of its output.
2013-11-05 17:40:10 +00:00
Usage:
hugo [flags]
hugo [command]
2013-11-05 17:40:10 +00:00
Available Commands:
2015-11-15 05:46:43 +00:00
server Hugo runs its own webserver to render the files
2014-06-17 16:28:42 +00:00
version Print the version number of Hugo
2015-11-15 05:46:43 +00:00
config Print the site configuration
2014-06-17 16:28:42 +00:00
check Check content in the source directory
2015-11-15 05:46:43 +00:00
benchmark Benchmark hugo by building a site a number of times.
convert Convert your content to different formats
new Create new content for your site
list Listing out various types of content
undraft Undraft changes the content's draft status from 'True' to 'False'
genautocomplete Generate shell autocompletion script for Hugo
gendoc Generate Markdown documentation for the Hugo CLI.
genman Generate man page for Hugo
import Import your site from others.
2015-11-15 05:46:43 +00:00
Flags:
-b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/
-D, --buildDrafts[=false]: include content marked as draft
-F, --buildFuture[=false]: include content with publishdate in the future
--cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
--canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL
2013-11-05 17:40:10 +00:00
--config="": config file (default is path/config.yaml|json|toml)
-d, --destination="": filesystem path to write files to
2015-11-15 05:46:43 +00:00
--disableRSS[=false]: Do not build RSS files
--disableSitemap[=false]: Do not build Sitemap file
--editor="": edit new content with this editor, if provided
--ignoreCache[=false]: Ignores the cache directory for reading but still writes to it
--log[=false]: Enable Logging
--logFile="": Log File path (if set, logging enabled automatically)
--noTimes[=false]: Don't sync modification time of files
--pluralizeListTitles[=true]: Pluralize titles in lists using inflect
--preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")
2013-11-05 17:40:10 +00:00
-s, --source="": filesystem path to read files relative from
2015-11-15 05:46:43 +00:00
--stepAnalysis[=false]: display memory and timing of different steps of the program
-t, --theme="": theme to use (located in /themes/THEMENAME/)
--uglyURLs[=false]: if true, use /filename.html instead of /filename/
-v, --verbose[=false]: verbose output
--verboseLog[=false]: verbose logging
-w, --watch[=false]: watch filesystem for changes and recreate as needed
2013-11-05 17:40:10 +00:00
### Defining your own usage
2015-11-15 05:46:43 +00:00
You can provide your own usage function or template for Cobra to use.
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
The default usage function is:
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
```go
return func(c *Command) error {
err := tmpl(c.Out(), c.UsageTemplate(), c)
return err
}
```
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
Like help, the function and template are overridable through public methods:
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
```go
command.SetUsageFunc(f func(*Command) error)
2013-11-05 17:40:10 +00:00
2015-11-15 05:46:43 +00:00
command.SetUsageTemplate(s string)
```
2013-11-05 17:40:10 +00:00
## PreRun or PostRun Hooks
It is possible to run functions before or after the main `Run` function of your command. The `PersistentPreRun` and `PreRun` functions will be executed before `Run`. `PersistentPostRun` and `PostRun` will be executed after `Run`. The `Persistent*Run` functions will be inherrited by children if they do not declare their own. These function are run in the following order:
- `PersistentPreRun`
- `PreRun`
- `Run`
- `PostRun`
- `PersistentPostRun`
2015-11-15 05:46:43 +00:00
An example of two commands which use all of these features is below. When the subcommand is executed, it will run the root command's `PersistentPreRun` but not the root command's `PersistentPostRun`:
```go
package main
import (
"fmt"
"github.com/spf13/cobra"
)
func main() {
var rootCmd = &cobra.Command{
Use: "root [sub]",
Short: "My root command",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside rootCmd PersistentPreRun with args: %v\n", args)
},
PreRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside rootCmd PreRun with args: %v\n", args)
},
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside rootCmd Run with args: %v\n", args)
},
PostRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside rootCmd PostRun with args: %v\n", args)
},
PersistentPostRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside rootCmd PersistentPostRun with args: %v\n", args)
},
}
var subCmd = &cobra.Command{
Use: "sub [no options!]",
2015-11-15 05:46:43 +00:00
Short: "My subcommand",
PreRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside subCmd PreRun with args: %v\n", args)
},
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside subCmd Run with args: %v\n", args)
},
PostRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside subCmd PostRun with args: %v\n", args)
},
PersistentPostRun: func(cmd *cobra.Command, args []string) {
fmt.Printf("Inside subCmd PersistentPostRun with args: %v\n", args)
},
}
rootCmd.AddCommand(subCmd)
rootCmd.SetArgs([]string{""})
_ = rootCmd.Execute()
fmt.Print("\n")
rootCmd.SetArgs([]string{"sub", "arg1", "arg2"})
_ = rootCmd.Execute()
}
```
## Alternative Error Handling
Cobra also has functions where the return signature is an error. This allows for errors to bubble up to the top,
providing a way to handle the errors in one location. The current list of functions that return an error is:
* PersistentPreRunE
* PreRunE
* RunE
* PostRunE
* PersistentPostRunE
If you would like to silence the default `error` and `usage` output in favor of your own, you can set `SilenceUsage`
and `SilenceErrors` to `false` on the command. A child command respects these flags if they are set on the parent
command.
**Example Usage using RunE:**
```go
package main
import (
"errors"
"log"
"github.com/spf13/cobra"
)
func main() {
var rootCmd = &cobra.Command{
Use: "hugo",
Short: "Hugo is a very fast static site generator",
Long: `A Fast and Flexible Static Site Generator built with
love by spf13 and friends in Go.
Complete documentation is available at http://hugo.spf13.com`,
RunE: func(cmd *cobra.Command, args []string) error {
// Do Stuff Here
return errors.New("some random error")
},
}
if err := rootCmd.Execute(); err != nil {
log.Fatal(err)
}
}
```
## Suggestions when "unknown command" happens
2015-11-15 05:46:43 +00:00
Cobra will print automatic suggestions when "unknown command" errors happen. This allows Cobra to behave similarly to the `git` command when a typo happens. For example:
```
$ hugo srever
2015-11-15 05:46:43 +00:00
Error: unknown command "srever" for "hugo"
Did you mean this?
2015-11-15 05:46:43 +00:00
server
Run 'hugo --help' for usage.
```
2015-11-15 05:46:43 +00:00
Suggestions are automatic based on every subcommand registered and use an implementation of [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance). Every registered command that matches a minimum distance of 2 (ignoring case) will be displayed as a suggestion.
If you need to disable suggestions or tweak the string distance in your command, use:
2015-11-15 05:46:43 +00:00
```go
command.DisableSuggestions = true
```
or
2015-11-15 05:46:43 +00:00
```go
command.SuggestionsMinimumDistance = 1
```
You can also explicitly set names for which a given command will be suggested using the `SuggestFor` attribute. This allows suggestions for strings that are not close in terms of string distance, but makes sense in your set of commands and for some which you don't want aliases. Example:
```
2015-11-15 05:46:43 +00:00
$ kubectl remove
Error: unknown command "remove" for "kubectl"
Did you mean this?
2015-11-15 05:46:43 +00:00
delete
2015-11-15 05:46:43 +00:00
Run 'kubectl help' for usage.
```
2015-11-15 05:46:43 +00:00
## Generating Markdown-formatted documentation for your command
Auto generation of markdown docs! An example from the kubernetes project, for the `kubectl config` command, which as subcommands, and flags, and all sorts of stuff, it will generate markdown like so: config modifies .kubeconfig files config modifies .kubeconfig files using subcommands like "kubectl config set current-context my-context" ``` kubectl config SUBCOMMAND ``` ``` --envvar=false: use the .kubeconfig from $KUBECONFIG --global=false: use the .kubeconfig from /home/username -h, --help=false: help for config --kubeconfig="": use a particular .kubeconfig file --local=false: use the .kubeconfig in the current directory ``` ``` --alsologtostderr=false: log to standard error as well as files --api-version="": The API version to use when talking to the server -a, --auth-path="": Path to the auth info file. If missing, prompt the user. Only used if using https. --certificate-authority="": Path to a cert. file for the certificate authority. --client-certificate="": Path to a client key file for TLS. --client-key="": Path to a client key file for TLS. --cluster="": The name of the kubeconfig cluster to use --context="": The name of the kubeconfig context to use --insecure-skip-tls-verify=false: If true, the server's certificate will not be checked for validity. This will make your HTTPS connections insecure. --log_backtrace_at=:0: when logging hits line file:N, emit a stack trace --log_dir=: If non-empty, write log files in this directory --log_flush_frequency=5s: Maximum number of seconds between log flushes --logtostderr=true: log to standard error instead of files --match-server-version=false: Require server version to match client version --namespace="": If present, the namespace scope for this CLI request. --password="": Password for basic authentication to the API server. -s, --server="": The address and port of the Kubernetes API server --stderrthreshold=2: logs at or above this threshold go to stderr --token="": Bearer token for authentication to the API server. --user="": The name of the kubeconfig user to use --username="": Username for basic authentication to the API server. --v=0: log level for V logs --validate=false: If true, use a schema to validate the input before sending it --vmodule=: comma-separated list of pattern=N settings for file-filtered logging ``` * [kubectl](kubectl.md) - kubectl controls the Kubernetes cluster manager * [kubectl config set](kubectl_config_set.md) - Sets an individual value in a .kubeconfig file * [kubectl config set-cluster](kubectl_config_set-cluster.md) - Sets a cluster entry in .kubeconfig * [kubectl config set-context](kubectl_config_set-context.md) - Sets a context entry in .kubeconfig * [kubectl config set-credentials](kubectl_config_set-credentials.md) - Sets a user entry in .kubeconfig * [kubectl config unset](kubectl_config_unset.md) - Unsets an individual value in a .kubeconfig file * [kubectl config use-context](kubectl_config_use-context.md) - Sets the current-context in a .kubeconfig file * [kubectl config view](kubectl_config_view.md) - displays merged .kubeconfig settings or a specified .kubeconfig file.
2015-04-07 03:38:51 +00:00
Cobra can generate a Markdown-formatted document based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Markdown Docs](doc/md_docs.md).
Auto generation of markdown docs! An example from the kubernetes project, for the `kubectl config` command, which as subcommands, and flags, and all sorts of stuff, it will generate markdown like so: config modifies .kubeconfig files config modifies .kubeconfig files using subcommands like "kubectl config set current-context my-context" ``` kubectl config SUBCOMMAND ``` ``` --envvar=false: use the .kubeconfig from $KUBECONFIG --global=false: use the .kubeconfig from /home/username -h, --help=false: help for config --kubeconfig="": use a particular .kubeconfig file --local=false: use the .kubeconfig in the current directory ``` ``` --alsologtostderr=false: log to standard error as well as files --api-version="": The API version to use when talking to the server -a, --auth-path="": Path to the auth info file. If missing, prompt the user. Only used if using https. --certificate-authority="": Path to a cert. file for the certificate authority. --client-certificate="": Path to a client key file for TLS. --client-key="": Path to a client key file for TLS. --cluster="": The name of the kubeconfig cluster to use --context="": The name of the kubeconfig context to use --insecure-skip-tls-verify=false: If true, the server's certificate will not be checked for validity. This will make your HTTPS connections insecure. --log_backtrace_at=:0: when logging hits line file:N, emit a stack trace --log_dir=: If non-empty, write log files in this directory --log_flush_frequency=5s: Maximum number of seconds between log flushes --logtostderr=true: log to standard error instead of files --match-server-version=false: Require server version to match client version --namespace="": If present, the namespace scope for this CLI request. --password="": Password for basic authentication to the API server. -s, --server="": The address and port of the Kubernetes API server --stderrthreshold=2: logs at or above this threshold go to stderr --token="": Bearer token for authentication to the API server. --user="": The name of the kubeconfig user to use --username="": Username for basic authentication to the API server. --v=0: log level for V logs --validate=false: If true, use a schema to validate the input before sending it --vmodule=: comma-separated list of pattern=N settings for file-filtered logging ``` * [kubectl](kubectl.md) - kubectl controls the Kubernetes cluster manager * [kubectl config set](kubectl_config_set.md) - Sets an individual value in a .kubeconfig file * [kubectl config set-cluster](kubectl_config_set-cluster.md) - Sets a cluster entry in .kubeconfig * [kubectl config set-context](kubectl_config_set-context.md) - Sets a context entry in .kubeconfig * [kubectl config set-credentials](kubectl_config_set-credentials.md) - Sets a user entry in .kubeconfig * [kubectl config unset](kubectl_config_unset.md) - Unsets an individual value in a .kubeconfig file * [kubectl config use-context](kubectl_config_use-context.md) - Sets the current-context in a .kubeconfig file * [kubectl config view](kubectl_config_view.md) - displays merged .kubeconfig settings or a specified .kubeconfig file.
2015-04-07 03:38:51 +00:00
2015-08-18 22:33:41 +00:00
## Generating man pages for your command
Cobra can generate a man page based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Man Docs](doc/man_docs.md).
2015-08-18 22:33:41 +00:00
## Generating bash completions for your command
2015-11-15 05:46:43 +00:00
Cobra can generate a bash-completion file. If you add more information to your command, these completions can be amazingly powerful and flexible. Read more about it in [Bash Completions](bash_completions.md).
2013-11-05 17:40:10 +00:00
2014-06-17 16:32:27 +00:00
## Debugging
2015-11-15 05:46:43 +00:00
Cobra provides a DebugFlags method on a command which, when called, will print
out everything Cobra knows about the flags for each command.
2014-06-17 16:32:27 +00:00
### Example
2015-11-15 05:46:43 +00:00
```go
command.DebugFlags()
```
2014-06-17 16:32:27 +00:00
2013-09-03 22:45:49 +00:00
## Release Notes
2014-06-17 16:32:27 +00:00
* **0.9.0** June 17, 2014
* flags can appears anywhere in the args (provided they are unambiguous)
* --help prints usage screen for app or command
* Prefix matching for commands
* Cleaner looking help and usage output
* Extensive test suite
2013-11-05 17:40:10 +00:00
* **0.8.0** Nov 5, 2013
* Reworked interface to remove commander completely
* Command now primary structure
* No initialization needed
* Usage & Help templates & functions definable at any level
* Updated Readme
2013-09-24 20:45:20 +00:00
* **0.7.0** Sept 24, 2013
* Needs more eyes
* Test suite
* Support for automatic error messages
* Support for help command
* Support for printing to any io.Writer instead of os.Stderr
* Support for persistent flags which cascade down tree
* Ready for integration into Hugo
2013-09-03 22:45:49 +00:00
* **0.1.0** Sept 3, 2013
* Implement first draft
2015-11-09 01:30:09 +00:00
## Extensions
Libraries for extending Cobra:
2015-11-15 05:46:43 +00:00
* [cmdns](https://github.com/gosuri/cmdns): Enables name spacing a command's immediate children. It provides an alternative way to structure subcommands, similar to `heroku apps:create` and `ovrclk clusters:launch`.
2015-11-09 01:30:09 +00:00
2013-09-24 20:45:20 +00:00
## ToDo
* Launch proper documentation site
2013-09-03 22:45:49 +00:00
## Contributing
1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request
## Contributors
Names in no particular order:
* [spf13](https://github.com/spf13),
[eparis](https://github.com/eparis),
[bep](https://github.com/bep), and many more!
2013-09-03 22:45:49 +00:00
## License
2014-05-05 00:01:50 +00:00
Cobra is released under the Apache 2.0 license. See [LICENSE.txt](https://github.com/spf13/cobra/blob/master/LICENSE.txt)
2014-01-02 17:58:43 +00:00
[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/spf13/cobra/trend.png)](https://bitdeli.com/free "Bitdeli Badge")