README
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:
Overview
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 develop a Cobra-based application.
Cobra provides:
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
Intelligent suggestions (
app srver
... did you meanapp 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
The flexibilty to define your own help, usage, etc.
Optional tight integration with viper for 12-factor apps
Cobra has an exceptionally clean interface and simple design without needless constructors or initialization methods.
Applications built with Cobra commands are designed to be as user-friendly as possible. Flags can be placed before or after the command (as long as a confusing space isn’t provided). Both short and long flags can be used. A 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.
Concepts
Cobra is built on a structure of commands, arguments & flags.
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 APPNAME VERB NOUN --ADJECTIVE.
or APPNAME COMMAND ARG --FLAG
A few good real world examples may better illustrate this point.
In the following example, 'server' is a command, and 'port' is a flag:
hugo server --port=1313
In this command we are telling Git to clone the url bare.
git clone URL --bare
Commands
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.
In the example above, 'server' is the command.
A Command has the following structure:
Flags
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. A Cobra command can define flags that persist through to children commands and flags that are only available to that command.
In the example above, 'port' is the flag.
Flag functionality is provided by the pflag library, a fork of the flag standard library which maintains the same interface while adding POSIX compliance.
Usage
Cobra works by creating a set of commands and then organizing them into a tree. The tree defines the structure of the application.
Once each command is defined with its corresponding flags, then the tree is assigned to the commander which is finally executed.
Installing
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:
go get -v github.com/spf13/cobra/cobra
Next, include Cobra in your application:
Getting Started
While you are welcome to provide your own organization, typically a Cobra based application will follow the following organizational structure.
In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra.
Using the Cobra Generator
Cobra provides its own program that will create your application and add any 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 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:
Once you have run these three commands you would have an app structure that would look like:
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:
You can specify no license by setting license
to none
or you can specify a custom license:
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.
Create the root command
The root command represents your binary itself.
Manually create rootCmd
Cobra doesn't require any special constructors. Simply create your commands.
Ideally you place this in app/cmd/root.go:
You will additionally define flags and handle configuration in your init() function.
for example cmd/root.go:
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.
Create additional commands
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:
Attach command to its parent
If you notice in the above example we attach the command to its parent. In 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.
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:
Working with Flags
Flags provide modifiers to control how the action command operates.
Assign flags to a command
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.
There are two different approaches to assign a flag.
Persistent Flags
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 global flags, assign a flag as a persistent flag on the root.
Local Flags
A flag can also be assigned locally which will only apply to that specific command.
Example
In the example below, we have defined three commands. Two are at the top level and one (cmdTimes) is a child of one of the top commands. In this case the root is not executable meaning that a subcommand is required. This is accomplished 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
For a more complete example of a larger application, please checkout Hugo.
The Help Command
Cobra automatically adds a help command to your application when you have subcommands. 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.
Example
The following output is automatically generated by Cobra. Nothing beyond the command and flag definitions are needed.
hugo help
Help is just a command like any other. There is no special logic or behavior around it. In fact, you can provide your own if you want.
Defining your own help
You can provide your own Help command or your own template for the default command to use.
The default help command is
You can provide your own command, function or template through the following methods:
The latter two will also apply to any children commands.
Usage
When the user provides an invalid flag or invalid command, Cobra responds by showing the user the 'usage'.
Example
You may recognize this from the help above. That's because the default help embeds the usage as part of its output.
Defining your own usage
You can provide your own usage function or template for Cobra to use.
The default usage function is:
Like help, the function and template are overridable through public methods:
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
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
:
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:
Suggestions when "unknown command" happens
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:
Suggestions are automatic based on every subcommand registered and use an implementation of 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:
or
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:
Generating Markdown-formatted documentation for your command
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.
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.
Generating bash completions for your command
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.
Debugging
Cobra provides a ‘DebugFlags’ method on a command which, when called, will print out everything Cobra knows about the flags for each command.
Example
Release Notes
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
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
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
0.1.0 Sept 3, 2013
Implement first draft
Extensions
Libraries for extending Cobra:
cmdns: Enables name spacing a command's immediate children. It provides an alternative way to structure subcommands, similar to
heroku apps:create
andovrclk clusters:launch
.
ToDo
Launch proper documentation site
Contributing
Fork it
Create your feature branch (
git checkout -b my-new-feature
)Commit your changes (
git commit -am 'Add some feature'
)Push to the branch (
git push origin my-new-feature
)Create new Pull Request
Contributors
Names in no particular order:
License
Cobra is released under the Apache 2.0 license. See LICENSE.txt
Last updated