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 init appname
&cobra add cmdname
- Intelligent suggestions (
app srver
… did you meanapp server
?) - Automatic help generation for commands and flags
- Automatic help flag recognition of
-h
,--help
, etc. - Automatically generated shell autocomplete for your application (bash, zsh, fish, powershell)
- Automatically generated man pages for your application
- Command aliases so you can change things without breaking them
- The flexibility to define your own help, usage, etc.
- Optional tight integration with viper for 12-factor apps
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 read like sentences when used, and as a result, users intuitively know how to interact with them.
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.
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.
Installing
Using Cobra is easy. First, use go get
to install the latest version
of the library. This command will install the cobra
generator executable
along with the library and its dependencies:
go get -u github.com/spf13/cobra
Next, include Cobra in your application:
import "github.com/spf13/cobra"
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.
package main
import (
"{pathToYourApp}/cmd"
)
func main() {
cmd.Execute()
}
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.
Here you can find more information about it.
Using the Cobra Library
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 rootCmd
Cobra doesn't require any special constructors. Simply create your commands.
Ideally you place this in app/cmd/root.go:
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`,
Run: func(cmd *cobra.Command, args []string) {
// Do Stuff Here
},
}
func Execute() {
if err := rootCmd.Execute(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
You will additionally define flags and handle configuration in your init() function.
For example cmd/root.go:
package cmd
import (
"fmt"
"os"
homedir "github.com/mitchellh/go-homedir"
"github.com/spf13/cobra"
"github.com/spf13/viper"
)
var (
// Used for flags.
cfgFile string
userLicense string
rootCmd = &cobra.Command{
Use: "cobra",
Short: "A generator for Cobra based Applications",
Long: `Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
}
)
// Execute executes the root command.
func Execute() error {
return rootCmd.Execute()
}
func init() {
cobra.OnInitialize(initConfig)
rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")
rootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "author name for copyright attribution")
rootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "name of license for the project")
rootCmd.PersistentFlags().Bool("viper", true, "use Viper for configuration")
viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))
viper.BindPFlag("useViper", rootCmd.PersistentFlags().Lookup("viper"))
viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")
viper.SetDefault("license", "apache")
rootCmd.AddCommand(addCmd)
rootCmd.AddCommand(initCmd)
}
func er(msg interface{}) {
fmt.Println("Error:", msg)
os.Exit(1)
}
func initConfig() {
if cfgFile != "" {
// Use config file from the flag.
viper.SetConfigFile(cfgFile)
} else {
// Find home directory.
home, err := homedir.Dir()
if err != nil {
er(err)
}
// Search config in home directory with name ".cobra" (without extension).
viper.AddConfigPath(home)
viper.SetConfigName(".cobra")
}
viper.AutomaticEnv()
if err := viper.ReadInConfig(); err == nil {
fmt.Println("Using config file:", viper.ConfigFileUsed())
}
}
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.
package main
import (
"{pathToYourApp}/cmd"
)
func main() {
cmd.Execute()
}
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:
package cmd
import (
"fmt"
"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")
},
}
Returning and handling errors
If you wish to return an error to the caller of a command, RunE
can be used.
package cmd
import (
"fmt"
"github.com/spf13/cobra"
)
func init() {
rootCmd.AddCommand(tryCmd)
}
var tryCmd = &cobra.Command{
Use: "try",
Short: "Try and possibly fail at something",
RunE: func(cmd *cobra.Command, args []string) error {
if err := someFunc(); err != nil {
return err
}
return nil
},
}
The error can then be caught at the execute function call.
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.
var Verbose bool
var Source string
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.
rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")
Local Flags
A flag can also be assigned locally, which will only apply to that specific command.
localCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")
Local Flag on Parent Commands
By default, Cobra only parses local flags on the target command, and any local flags on
parent commands are ignored. By enabling Command.TraverseChildren
, Cobra will
parse local flags on each command before executing the target command.
command := cobra.Command{
Use: "print [OPTIONS] [COMMANDS]",
TraverseChildren: true,
}
Bind Flags with Config
You can also bind your flags with viper:
var author string
func init() {
rootCmd.PersistentFlags().StringVar(&author, "author", "YOUR NAME", "Author name for copyright attribution")
viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))
}
In this example, the persistent flag author
is bound with viper
.
Note: the variable author
will not be set to the value from config,
when the --author
flag is not provided by user.
More in viper documentation.
Required flags
Flags are optional by default. If instead you wish your command to report an error when a flag has not been set, mark it as required:
rootCmd.Flags().StringVarP(&Region, "region", "r", "", "AWS region (required)")
rootCmd.MarkFlagRequired("region")
Or, for persistent flags:
rootCmd.PersistentFlags().StringVarP(&Region, "region", "r", "", "AWS region (required)")
rootCmd.MarkPersistentFlagRequired("region")
Positional and Custom Arguments
Validation of positional arguments can be specified using the Args
field
of Command
.
The following validators are built in:
NoArgs
- the command will report an error if there are any positional args.ArbitraryArgs
- the command will accept any args.OnlyValidArgs
- the command will report an error if there are any positional args that are not in theValidArgs
field ofCommand
.MinimumNArgs(int)
- the command will report an error if there are not at least N positional args.MaximumNArgs(int)
- the command will report an error if there are more than N positional args.ExactArgs(int)
- the command will report an error if there are not exactly N positional args.ExactValidArgs(int)
- the command will report an error if there are not exactly N positional args OR if there are any positional args that are not in theValidArgs
field ofCommand
RangeArgs(min, max)
- the command will report an error if the number of args is not between the minimum and maximum number of expected args.
An example of setting the custom validator:
var cmd = &cobra.Command{
Short: "hello",
Args: func(cmd *cobra.Command, args []string) error {
if len(args) < 1 {
return errors.New("requires a color argument")
}
if myapp.IsValidColor(args[0]) {
return nil
}
return fmt.Errorf("invalid color specified: %s", args[0])
},
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("Hello, World!")
},
}
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
package main
import (
"fmt"
"strings"
"github.com/spf13/cobra"
)
func main() {
var echoTimes int
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.
For many years people have printed back to the screen.`,
Args: cobra.MinimumNArgs(1),
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.
Echo works a lot like print, except it has a child command.`,
Args: cobra.MinimumNArgs(1),
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("Echo: " + strings.Join(args, " "))
},
}
var cmdTimes = &cobra.Command{
Use: "times [string to echo]",
Short: "Echo anything to the screen more times",
Long: `echo things multiple times back to the user by providing
a count and a string.`,
Args: cobra.MinimumNArgs(1),
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")
var rootCmd = &cobra.Command{Use: "app"}
rootCmd.AddCommand(cmdPrint, cmdEcho)
cmdEcho.AddCommand(cmdTimes)
rootCmd.Execute()
}
For a more complete example of a larger application, please checkout Hugo.
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.
$ cobra help
Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.
Usage:
cobra [command]
Available Commands:
add Add a command to a Cobra Application
help Help about any command
init Initialize a Cobra Application
Flags:
-a, --author string author name for copyright attribution (default "YOUR NAME")
--config string config file (default is $HOME/.cobra.yaml)
-h, --help help for cobra
-l, --license string name of license for the project
--viper use Viper for configuration (default true)
Use "cobra [command] --help" for more information about a command.
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 with following functions:
cmd.SetHelpCommand(cmd *Command)
cmd.SetHelpFunc(f func(*Command, []string))
cmd.SetHelpTemplate(s string)
The latter two will also apply to any children commands.
Usage Message
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.
$ cobra --invalid
Error: unknown flag: --invalid
Usage:
cobra [command]
Available Commands:
add Add a command to a Cobra Application
help Help about any command
init Initialize a Cobra Application
Flags:
-a, --author string author name for copyright attribution (default "YOUR NAME")
--config string config file (default is $HOME/.cobra.yaml)
-h, --help help for cobra
-l, --license string name of license for the project
--viper use Viper for configuration (default true)
Use "cobra [command] --help" for more information about a command.
Defining your own usage
You can provide your own usage function or template for Cobra to use. Like help, the function and template are overridable through public methods:
cmd.SetUsageFunc(f func(*Command) error)
cmd.SetUsageTemplate(s string)
Version Flag
Cobra adds a top-level ‘–version’ flag if the Version field is set on the root command.
Running an application with the ‘–version’ flag will print the version to stdout using
the version template. The template can be customized using the
cmd.SetVersionTemplate(s string)
function.
PreRun and 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 inherited by children if they do not declare their own. These functions 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
:
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!]",
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.Println()
rootCmd.SetArgs([]string{"sub", "arg1", "arg2"})
rootCmd.Execute()
}
Output:
Inside rootCmd PersistentPreRun with args: []
Inside rootCmd PreRun with args: []
Inside rootCmd Run with args: []
Inside rootCmd PostRun with args: []
Inside rootCmd PersistentPostRun with args: []
Inside rootCmd PersistentPreRun with args: [arg1 arg2]
Inside subCmd PreRun with args: [arg1 arg2]
Inside subCmd Run with args: [arg1 arg2]
Inside subCmd PostRun with args: [arg1 arg2]
Inside subCmd PersistentPostRun with args: [arg1 arg2]
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:
$ hugo srever
Error: unknown command "srever" for "hugo"
Did you mean this?
server
Run 'hugo --help' for usage.
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:
command.DisableSuggestions = true
or
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:
$ kubectl remove
Error: unknown command "remove" for "kubectl"
Did you mean this?
delete
Run 'kubectl help' for usage.
Generating documentation for your command
Cobra can generate documentation based on subcommands, flags, etc. Read more about it in the docs generation documentation.
Generating shell completions
Cobra can generate a shell-completion file for the following shells: Bash, Zsh, Fish, Powershell. If you add more information to your commands, these completions can be amazingly powerful and flexible. Read more about it in Shell Completions.
Shell completions
Cobra can generate shell completions for multiple shells. The currently supported shells are:
- Bash
- Zsh
- Fish
- PowerShell
If you are using the generator you can create a completion command by running
cobra add completion
and then modifying the generated cmd/completion.go
file to look something like this
(writing the shell script to stdout allows the most flexible use):
var completionCmd = &cobra.Command{
Use: "completion [bash|zsh|fish|powershell]",
Short: "Generate completion script",
Long: `To load completions:
Bash:
$ source <(yourprogram completion bash)
# To load completions for each session, execute once:
Linux:
$ yourprogram completion bash > /etc/bash_completion.d/yourprogram
MacOS:
$ yourprogram completion bash > /usr/local/etc/bash_completion.d/yourprogram
Zsh:
# If shell completion is not already enabled in your environment you will need
# to enable it. You can execute the following once:
$ echo "autoload -U compinit; compinit" >> ~/.zshrc
# To load completions for each session, execute once:
$ yourprogram completion zsh > "${fpath[1]}/_yourprogram"
# You will need to start a new shell for this setup to take effect.
Fish:
$ yourprogram completion fish | source
# To load completions for each session, execute once:
$ yourprogram completion fish > ~/.config/fish/completions/yourprogram.fish
`,
DisableFlagsInUseLine: true,
ValidArgs: []string{"bash", "zsh", "fish", "powershell"},
Args: cobra.ExactValidArgs(1),
Run: func(cmd *cobra.Command, args []string) {
switch args[0] {
case "bash":
cmd.Root().GenBashCompletion(os.Stdout)
case "zsh":
cmd.Root().GenZshCompletion(os.Stdout)
case "fish":
cmd.Root().GenFishCompletion(os.Stdout, true)
case "powershell":
cmd.Root().GenPowerShellCompletion(os.Stdout)
}
},
}
Note: The cobra generator may include messages printed to stdout for example if the config file is loaded, this will break the auto complete script so must be removed.
Customizing completions
The generated completion scripts will automatically handle completing commands and flags. However, you can make your completions much more powerful by providing information to complete your program's nouns and flag values.
Completion of nouns
Static completion of nouns
Cobra allows you to provide a pre-defined list of completion choices for your nouns using the ValidArgs
field.
For example, if you want kubectl get [tab][tab]
to show a list of valid “nouns” you have to set them.
Some simplified code from kubectl get
looks like:
validArgs []string = { "pod", "node", "service", "replicationcontroller" }
cmd := &cobra.Command{
Use: "get [(-o|--output=)json|yaml|template|...] (RESOURCE [NAME] | RESOURCE/NAME ...)",
Short: "Display one or many resources",
Long: get_long,
Example: get_example,
Run: func(cmd *cobra.Command, args []string) {
err := RunGet(f, out, cmd, args)
util.CheckErr(err)
},
ValidArgs: validArgs,
}
Notice we put the ValidArgs
field on the get
sub-command. Doing so will give results like:
$ kubectl get [tab][tab]
node pod replicationcontroller service
Aliases for nouns
If your nouns have aliases, you can define them alongside ValidArgs
using ArgAliases
:
argAliases []string = { "pods", "nodes", "services", "svc", "replicationcontrollers", "rc" }
cmd := &cobra.Command{
...
ValidArgs: validArgs,
ArgAliases: argAliases
}
The aliases are not shown to the user on tab completion, but they are accepted as valid nouns by the completion algorithm if entered manually, e.g. in:
$ kubectl get rc [tab][tab]
backend frontend database
Note that without declaring rc
as an alias, the completion algorithm would not know to show the list of
replication controllers following rc
.
Dynamic completion of nouns
In some cases it is not possible to provide a list of completions in advance. Instead, the list of completions must be determined at execution-time. In a similar fashion as for static completions, you can use the ValidArgsFunction
field to provide a Go function that Cobra will execute when it needs the list of completion choices for the nouns of a command. Note that either ValidArgs
or ValidArgsFunction
can be used for a single cobra command, but not both.
Simplified code from helm status
looks like:
cmd := &cobra.Command{
Use: "status RELEASE_NAME",
Short: "Display the status of the named release",
Long: status_long,
RunE: func(cmd *cobra.Command, args []string) {
RunGet(args[0])
},
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
if len(args) != 0 {
return nil, cobra.ShellCompDirectiveNoFileComp
}
return getReleasesFromCluster(toComplete), cobra.ShellCompDirectiveNoFileComp
},
}
Where getReleasesFromCluster()
is a Go function that obtains the list of current Helm releases running on the Kubernetes cluster.
Notice we put the ValidArgsFunction
on the status
sub-command. Let's assume the Helm releases on the cluster are: harbor
, notary
, rook
and thanos
then this dynamic completion will give results like:
$ helm status [tab][tab]
harbor notary rook thanos
You may have noticed the use of cobra.ShellCompDirective
. These directives are bit fields allowing to control some shell completion behaviors for your particular completion. You can combine them with the bit-or operator such as cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
// Indicates that the shell will perform its default behavior after completions
// have been provided (this implies none of the other directives).
ShellCompDirectiveDefault
// Indicates an error occurred and completions should be ignored.
ShellCompDirectiveError
// Indicates that the shell should not add a space after the completion,
// even if there is a single completion provided.
ShellCompDirectiveNoSpace
// Indicates that the shell should not provide file completion even when
// no completion is provided.
ShellCompDirectiveNoFileComp
// Indicates that the returned completions should be used as file extension filters.
// For example, to complete only files of the form *.json or *.yaml:
// return []string{"yaml", "json"}, ShellCompDirectiveFilterFileExt
// For flags, using MarkFlagFilename() and MarkPersistentFlagFilename()
// is a shortcut to using this directive explicitly.
//
ShellCompDirectiveFilterFileExt
// Indicates that only directory names should be provided in file completion.
// For example:
// return nil, ShellCompDirectiveFilterDirs
// For flags, using MarkFlagDirname() is a shortcut to using this directive explicitly.
//
// To request directory names within another directory, the returned completions
// should specify a single directory name within which to search. For example,
// to complete directories within "themes/":
// return []string{"themes"}, ShellCompDirectiveFilterDirs
//
ShellCompDirectiveFilterDirs
Note: When using the ValidArgsFunction
, Cobra will call your registered function after having parsed all flags and arguments provided in the command-line. You therefore don't need to do this parsing yourself. For example, when a user calls helm status --namespace my-rook-ns [tab][tab]
, Cobra will call your registered ValidArgsFunction
after having parsed the --namespace
flag, as it would have done when calling the RunE
function.
Debugging
Cobra achieves dynamic completion through the use of a hidden command called by the completion script. To debug your Go completion code, you can call this hidden command directly:
$ helm __complete status har<ENTER>
harbor
:4
Completion ended with directive: ShellCompDirectiveNoFileComp # This is on stderr
Important: If the noun to complete is empty (when the user has not yet typed any letters of that noun), you must pass an empty parameter to the __complete
command:
$ helm __complete status ""<ENTER>
harbor
notary
rook
thanos
:4
Completion ended with directive: ShellCompDirectiveNoFileComp # This is on stderr
Calling the __complete
command directly allows you to run the Go debugger to troubleshoot your code. You can also add printouts to your code; Cobra provides the following functions to use for printouts in Go completion code:
// Prints to the completion script debug file (if BASH_COMP_DEBUG_FILE
// is set to a file path) and optionally prints to stderr.
cobra.CompDebug(msg string, printToStdErr bool) {
cobra.CompDebugln(msg string, printToStdErr bool)
// Prints to the completion script debug file (if BASH_COMP_DEBUG_FILE
// is set to a file path) and to stderr.
cobra.CompError(msg string)
cobra.CompErrorln(msg string)
Important: You should not leave traces that print directly to stdout in your completion code as they will be interpreted as completion choices by the completion script. Instead, use the cobra-provided debugging traces functions mentioned above.
Completions for flags
Mark flags as required
Most of the time completions will only show sub-commands. But if a flag is required to make a sub-command work, you probably want it to show up when the user types [tab][tab]. You can mark a flag as ‘Required’ like so:
cmd.MarkFlagRequired("pod")
cmd.MarkFlagRequired("container")
and you'll get something like
$ kubectl exec [tab][tab]
-c --container= -p --pod=
Specify dynamic flag completion
As for nouns, Cobra provides a way of defining dynamic completion of flags. To provide a Go function that Cobra will execute when it needs the list of completion choices for a flag, you must register the function using the command.RegisterFlagCompletionFunc()
function.
flagName := "output"
cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
return []string{"json", "table", "yaml"}, cobra.ShellCompDirectiveDefault
})
Notice that calling RegisterFlagCompletionFunc()
is done through the command
with which the flag is associated. In our example this dynamic completion will give results like so:
$ helm status --output [tab][tab]
json table yaml
Debugging
You can also easily debug your Go completion code for flags:
$ helm __complete status --output ""
json
table
yaml
:4
Completion ended with directive: ShellCompDirectiveNoFileComp # This is on stderr
Important: You should not leave traces that print to stdout in your completion code as they will be interpreted as completion choices by the completion script. Instead, use the cobra-provided debugging traces functions mentioned further above.
Specify valid filename extensions for flags that take a filename
To limit completions of flag values to file names with certain extensions you can either use the different MarkFlagFilename()
functions or a combination of RegisterFlagCompletionFunc()
and ShellCompDirectiveFilterFileExt
, like so:
flagName := "output"
cmd.MarkFlagFilename(flagName, "yaml", "json")
or
flagName := "output"
cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
return []string{"yaml", "json"}, ShellCompDirectiveFilterFileExt})
Limit flag completions to directory names
To limit completions of flag values to directory names you can either use the MarkFlagDirname()
functions or a combination of RegisterFlagCompletionFunc()
and ShellCompDirectiveFilterDirs
, like so:
flagName := "output"
cmd.MarkFlagDirname(flagName)
or
flagName := "output"
cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
return nil, cobra.ShellCompDirectiveFilterDirs
})
To limit completions of flag values to directory names within another directory you can use a combination of RegisterFlagCompletionFunc()
and ShellCompDirectiveFilterDirs
like so:
flagName := "output"
cmd.RegisterFlagCompletionFunc(flagName, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
return []string{"themes"}, cobra.ShellCompDirectiveFilterDirs
})
Descriptions for completions
Both zsh
and fish
allow for descriptions to annotate completion choices. For commands and flags, Cobra will provide the descriptions automatically, based on usage information. For example, using zsh:
$ helm s[tab]
search -- search for a keyword in charts
show -- show information of a chart
status -- displays the status of the named release
while using fish:
$ helm s[tab]
search (search for a keyword in charts) show (show information of a chart) status (displays the status of the named release)
Cobra allows you to add annotations to your own completions. Simply add the annotation text after each completion, following a \t
separator. This technique applies to completions returned by ValidArgs
, ValidArgsFunction
and RegisterFlagCompletionFunc()
. For example:
ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
return []string{"harbor\tAn image registry", "thanos\tLong-term metrics"}, cobra.ShellCompDirectiveNoFileComp
}}
or
ValidArgs: []string{"bash\tCompletions for bash", "zsh\tCompletions for zsh"}
Bash
Dependencies
The bash completion script generated by Cobra requires the bash_completion
package. You should update the help text of your completion command to show how to install the bash_completion
package (Kubectl docs)
Aliases
You can also configure bash
aliases for your program and they will also support completions.
alias aliasname=origcommand
complete -o default -F __start_origcommand aliasname
# and now when you run `aliasname` completion will make
# suggestions as it did for `origcommand`.
$ aliasname <tab><tab>
completion firstcommand secondcommand
Bash legacy dynamic completions
For backwards-compatibility, Cobra still supports its bash legacy dynamic completion solution. Please refer to Bash Completions for details.
Zsh
Cobra supports native Zsh completion generated from the root cobra.Command
.
The generated completion script should be put somewhere in your $fpath
and be named
_<yourProgram>
. You will need to start a new shell for the completions to become available.
Zsh supports descriptions for completions. Cobra will provide the description automatically,
based on usage information. Cobra provides a way to completely disable such descriptions by
using GenZshCompletionNoDesc()
or GenZshCompletionFileNoDesc()
. You can choose to make
this a configurable option to your users.
# With descriptions
$ helm s[tab]
search -- search for a keyword in charts
show -- show information of a chart
status -- displays the status of the named release
# Without descriptions
$ helm s[tab]
search show status
Note: Because of backwards-compatibility requirements, we were forced to have a different API to disable completion descriptions between Zsh
and Fish
.
Limitations
- Custom completions implemented in Bash scripting (legacy) are not supported and will be ignored for
zsh
(including the use of theBashCompCustom
flag annotation).- You should instead use
ValidArgsFunction
andRegisterFlagCompletionFunc()
which are portable to the different shells (bash
,zsh
,fish
).
- You should instead use
- The function
MarkFlagCustom()
is not supported and will be ignored forzsh
.- You should instead use
RegisterFlagCompletionFunc()
.
- You should instead use
Zsh completions standardization
Cobra 1.1 standardized its zsh completion support to align it with its other shell completions. Although the API was kept backwards-compatible, some small changes in behavior were introduced. Please refer to Zsh Completions for details.
Fish
Cobra supports native Fish completions generated from the root cobra.Command
. You can use the command.GenFishCompletion()
or command.GenFishCompletionFile()
functions. You must provide these functions with a parameter indicating if the completions should be annotated with a description; Cobra will provide the description automatically based on usage information. You can choose to make this option configurable by your users.
# With descriptions
$ helm s[tab]
search (search for a keyword in charts) show (show information of a chart) status (displays the status of the named release)
# Without descriptions
$ helm s[tab]
search show status
Note: Because of backwards-compatibility requirements, we were forced to have a different API to disable completion descriptions between Zsh
and Fish
.
Limitations
- Custom completions implemented in Bash scripting (legacy) are not supported and will be ignored for
fish
(including the use of theBashCompCustom
flag annotation).- You should instead use
ValidArgsFunction
andRegisterFlagCompletionFunc()
which are portable to the different shells (bash
,zsh
,fish
).
- You should instead use
- The function
MarkFlagCustom()
is not supported and will be ignored forfish
.- You should instead use
RegisterFlagCompletionFunc()
.
- You should instead use
- The following flag completion annotations are not supported and will be ignored for
fish
:BashCompFilenameExt
(filtering by file extension)BashCompSubdirsInDir
(filtering by directory)
- The functions corresponding to the above annotations are consequently not supported and will be ignored for
fish
:MarkFlagFilename()
andMarkPersistentFlagFilename()
(filtering by file extension)MarkFlagDirname()
andMarkPersistentFlagDirname()
(filtering by directory)
- Similarly, the following completion directives are not supported and will be ignored for
fish
:ShellCompDirectiveFilterFileExt
(filtering by file extension)ShellCompDirectiveFilterDirs
(filtering by directory)
PowerShell
Please refer to PowerShell Completions for details.
Bash completions
Please refer to Shell Completions for details.
Bash legacy dynamic completions
For backwards-compatibility, Cobra still supports its legacy dynamic completion solution (described below). Unlike the ValidArgsFunction
solution, the legacy solution will only work for Bash shell-completion and not for other shells. This legacy solution can be used along-side ValidArgsFunction
and RegisterFlagCompletionFunc()
, as long as both solutions are not used for the same command. This provides a path to gradually migrate from the legacy solution to the new solution.
The legacy solution allows you to inject bash functions into the bash completion script. Those bash functions are responsible for providing the completion choices for your own completions.
Some code that works in kubernetes:
const (
bash_completion_func = `__kubectl_parse_get()
{
local kubectl_output out
if kubectl_output=$(kubectl get --no-headers "$1" 2>/dev/null); then
out=($(echo "${kubectl_output}" | awk '{print $1}'))
COMPREPLY=( $( compgen -W "${out[*]}" -- "$cur" ) )
fi
}
__kubectl_get_resource()
{
if [[ ${#nouns[@]} -eq 0 ]]; then
return 1
fi
__kubectl_parse_get ${nouns[${#nouns[@]} -1]}
if [[ $? -eq 0 ]]; then
return 0
fi
}
__kubectl_custom_func() {
case ${last_command} in
kubectl_get | kubectl_describe | kubectl_delete | kubectl_stop)
__kubectl_get_resource
return
;;
*)
;;
esac
}
`)
And then I set that in my command definition:
cmds := &cobra.Command{
Use: "kubectl",
Short: "kubectl controls the Kubernetes cluster manager",
Long: `kubectl controls the Kubernetes cluster manager.
Find more information at https://github.com/GoogleCloudPlatform/kubernetes.`,
Run: runHelp,
BashCompletionFunction: bash_completion_func,
}
The BashCompletionFunction
option is really only valid/useful on the root command. Doing the above will cause __kubectl_custom_func()
(__<command-use>_custom_func()
) to be called when the built in processor was unable to find a solution. In the case of kubernetes a valid command might look something like kubectl get pod [mypod]
. If you type kubectl get pod [tab][tab]
the __kubectl_customc_func()
will run because the cobra.Command only understood “kubectl” and “get.” __kubectl_custom_func()
will see that the cobra.Command is “kubectl_get” and will thus call another helper __kubectl_get_resource()
. __kubectl_get_resource
will look at the ‘nouns’ collected. In our example the only noun will be pod
. So it will call __kubectl_parse_get pod
. __kubectl_parse_get
will actually call out to kubernetes and get any pods. It will then set COMPREPLY
to valid pods!
Similarly, for flags:
annotation := make(map[string][]string)
annotation[cobra.BashCompCustom] = []string{"__kubectl_get_namespaces"}
flag := &pflag.Flag{
Name: "namespace",
Usage: usage,
Annotations: annotation,
}
cmd.Flags().AddFlag(flag)
In addition add the __kubectl_get_namespaces
implementation in the BashCompletionFunction
value, e.g.:
__kubectl_get_namespaces()
{
local template
template="{{ range .items }}{{ .metadata.name }} {{ end }}"
local kubectl_out
if kubectl_out=$(kubectl get -o template --template="${template}" namespace 2>/dev/null); then
COMPREPLY=( $( compgen -W "${kubectl_out}[*]" -- "$cur" ) )
fi
}
Fish completions
Please refer to Shell Completions for details.
PowerShell completions
Cobra can generate PowerShell completion scripts. Users need PowerShell version 5.0 or above, which comes with Windows 10 and can be downloaded separately for Windows 7 or 8.1. They can then write the completions to a file and source this file from their PowerShell profile, which is referenced by the $Profile
environment variable. See Get-Help about_Profiles
for more info about PowerShell profiles.
Note: PowerShell completions have not (yet?) been aligned to Cobra's generic shell completion support. This implies the PowerShell completions are not as rich as for other shells (see What's not yet supported), and may behave slightly differently. They are still very useful for PowerShell users.
What's supported
- Completion for subcommands using their
.Short
description - Completion for non-hidden flags using their
.Name
and.Shorthand
What's not yet supported
- Command aliases
- Required, filename or custom flags (they will work like normal flags)
- Custom completion scripts
Zsh completions
Please refer to Shell Completions for details.
Zsh completions standardization
Cobra 1.1 standardized its zsh completion support to align it with its other shell completions. Although the API was kept backwards-compatible, some small changes in behavior were introduced.
Deprecation summary
See further below for more details on these deprecations.
cmd.MarkZshCompPositionalArgumentFile(pos, []string{})
is no longer needed. It is therefore deprecated and silently ignored.cmd.MarkZshCompPositionalArgumentFile(pos, glob[])
is deprecated and silently ignored.- Instead use
ValidArgsFunction
withShellCompDirectiveFilterFileExt
.
- Instead use
cmd.MarkZshCompPositionalArgumentWords()
is deprecated and silently ignored.- Instead use
ValidArgsFunction
.
- Instead use
Behavioral changes
Noun completion*
Old behavior | New behavior |
---|---|
No file completion by default (opposite of bash) | File completion by default; use ValidArgsFunction with ShellCompDirectiveNoFileComp to turn off file completion on a per-argument basis |
Completion of flag names without the - prefix having been typed |
Flag names are only completed if the user has typed the first - |
cmd.MarkZshCompPositionalArgumentFile(pos, []string{}) used to turn on file completion on a per-argument position basis |
File completion for all arguments by default; cmd.MarkZshCompPositionalArgumentFile() is deprecated and silently ignored |
cmd.MarkZshCompPositionalArgumentFile(pos, glob[]) used to turn on file completion with glob filtering on a per-argument position basis (zsh-specific) |
cmd.MarkZshCompPositionalArgumentFile() is deprecated and silently ignored; use ValidArgsFunction with ShellCompDirectiveFilterFileExt for file extension filtering (not full glob filtering) |
cmd.MarkZshCompPositionalArgumentWords(pos, words[]) used to provide completion choices on a per-argument position basis (zsh-specific) |
cmd.MarkZshCompPositionalArgumentWords() is deprecated and silently ignored; use ValidArgsFunction to achieve the same behavior |
Flag-value completion
Old behavior | New behavior |
---|---|
No file completion by default (opposite of bash) | File completion by default; use RegisterFlagCompletionFunc() with ShellCompDirectiveNoFileComp to turn off file completion |
cmd.MarkFlagFilename(flag, []string{}) and similar used to turn on file completion |
File completion by default; cmd.MarkFlagFilename(flag, []string{}) no longer needed in this context and silently ignored |
cmd.MarkFlagFilename(flag, glob[]) used to turn on file completion with glob filtering (syntax of []string{"*.yaml", "*.yml"} incompatible with bash) |
Will continue to work, however, support for bash syntax is added and should be used instead so as to work for all shells ([]string{"yaml", "yml"} ) |
cmd.MarkFlagDirname(flag) only completes directories (zsh-specific) |
Has been added for all shells |
Completion of a flag name does not repeat, unless flag is of type *Array or *Slice (not supported by bash) |
Retained for zsh and added to fish |
Completion of a flag name does not provide the = form (unlike bash) |
Retained for zsh and added to fish |
Improvements
- Custom completion support (
ValidArgsFunction
andRegisterFlagCompletionFunc()
) - File completion by default if no other completions found
- Handling of required flags
- File extension filtering no longer mutually exclusive with bash usage
- Completion of directory names within another directory
- Support for
=
form of flags
Documentation generation
Options
DisableAutoGenTag
. You may setcmd.DisableAutoGenTag = true
to entirely remove the auto generated string “Auto generated by spf13/cobra…” from any documentation source.
Man Pages
Generating man pages from a cobra command is incredibly easy. An example is as follows:
package main
import (
"log"
"github.com/spf13/cobra"
"github.com/spf13/cobra/doc"
)
func main() {
cmd := &cobra.Command{
Use: "test",
Short: "my test program",
}
header := &doc.GenManHeader{
Title: "MINE",
Section: "3",
}
err := doc.GenManTree(cmd, header, "/tmp")
if err != nil {
log.Fatal(err)
}
}
That will get you a man page /tmp/test.3
Markdown Docs
Generating Markdown pages from a cobra command is incredibly easy. An example is as follows:
package main
import (
"log"
"github.com/spf13/cobra"
"github.com/spf13/cobra/doc"
)
func main() {
cmd := &cobra.Command{
Use: "test",
Short: "my test program",
}
err := doc.GenMarkdownTree(cmd, "/tmp")
if err != nil {
log.Fatal(err)
}
}
That will get you a Markdown document /tmp/test.md
The entire command tree
This program can actually generate docs for the kubectl command in the kubernetes project
package main
import (
"log"
"io/ioutil"
"os"
"k8s.io/kubernetes/pkg/kubectl/cmd"
cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
"github.com/spf13/cobra/doc"
)
func main() {
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
err := doc.GenMarkdownTree(kubectl, "./")
if err != nil {
log.Fatal(err)
}
}
This will generate a whole series of files, one for each command in the tree, in the directory specified (in this case “./")
For a single command
You may wish to have more control over the output, or only generate for a single command, instead of the entire command tree. If this is the case you may prefer to GenMarkdown
instead of GenMarkdownTree
out := new(bytes.Buffer)
err := doc.GenMarkdown(cmd, out)
if err != nil {
log.Fatal(err)
}
This will write the markdown doc for ONLY “cmd” into the out, buffer.
Customize the output
Both GenMarkdown
and GenMarkdownTree
have alternate versions with callbacks to get some control of the output:
func GenMarkdownTreeCustom(cmd *Command, dir string, filePrepender, linkHandler func(string) string) error {
//...
}
func GenMarkdownCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string) string) error {
//...
}
The filePrepender
will prepend the return value given the full filepath to the rendered Markdown file. A common use case is to add front matter to use the generated documentation with Hugo:
const fmTemplate = `---
date: %s
title: "%s"
slug: %s
url: %s
---
`
filePrepender := func(filename string) string {
now := time.Now().Format(time.RFC3339)
name := filepath.Base(filename)
base := strings.TrimSuffix(name, path.Ext(name))
url := "/commands/" + strings.ToLower(base) + "/"
return fmt.Sprintf(fmTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
}
The linkHandler
can be used to customize the rendered internal links to the commands, given a filename:
linkHandler := func(name string) string {
base := strings.TrimSuffix(name, path.Ext(name))
return "/commands/" + strings.ToLower(base) + "/"
}
ReStructured Text Docs
Generating ReST pages from a cobra command is incredibly easy. An example is as follows:
package main
import (
"log"
"github.com/spf13/cobra"
"github.com/spf13/cobra/doc"
)
func main() {
cmd := &cobra.Command{
Use: "test",
Short: "my test program",
}
err := doc.GenReSTTree(cmd, "/tmp")
if err != nil {
log.Fatal(err)
}
}
That will get you a ReST document /tmp/test.rst
The entire command tree
This program can actually generate docs for the kubectl command in the kubernetes project
package main
import (
"log"
"io/ioutil"
"os"
"k8s.io/kubernetes/pkg/kubectl/cmd"
cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
"github.com/spf13/cobra/doc"
)
func main() {
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
err := doc.GenReSTTree(kubectl, "./")
if err != nil {
log.Fatal(err)
}
}
This will generate a whole series of files, one for each command in the tree, in the directory specified (in this case “./")
For a single command
You may wish to have more control over the output, or only generate for a single command, instead of the entire command tree. If this is the case you may prefer to GenReST
instead of GenReSTTree
out := new(bytes.Buffer)
err := doc.GenReST(cmd, out)
if err != nil {
log.Fatal(err)
}
This will write the ReST doc for ONLY “cmd” into the out, buffer.
Customize the output
Both GenReST
and GenReSTTree
have alternate versions with callbacks to get some control of the output:
func GenReSTTreeCustom(cmd *Command, dir string, filePrepender func(string) string, linkHandler func(string, string) string) error {
//...
}
func GenReSTCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string, string) string) error {
//...
}
The filePrepender
will prepend the return value given the full filepath to the rendered ReST file. A common use case is to add front matter to use the generated documentation with Hugo:
const fmTemplate = `---
date: %s
title: "%s"
slug: %s
url: %s
---
`
filePrepender := func(filename string) string {
now := time.Now().Format(time.RFC3339)
name := filepath.Base(filename)
base := strings.TrimSuffix(name, path.Ext(name))
url := "/commands/" + strings.ToLower(base) + "/"
return fmt.Sprintf(fmTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
}
The linkHandler
can be used to customize the rendered links to the commands, given a command name and reference. This is useful while converting rst to html or while generating documentation with tools like Sphinx where :ref:
is used:
// Sphinx cross-referencing format
linkHandler := func(name, ref string) string {
return fmt.Sprintf(":ref:`%s <%s>`", name, ref)
}
Yaml Docs
Generating yaml files from a cobra command is incredibly easy. An example is as follows:
package main
import (
"log"
"github.com/spf13/cobra"
"github.com/spf13/cobra/doc"
)
func main() {
cmd := &cobra.Command{
Use: "test",
Short: "my test program",
}
err := doc.GenYamlTree(cmd, "/tmp")
if err != nil {
log.Fatal(err)
}
}
That will get you a Yaml document /tmp/test.yaml
The entire command tree
This program can actually generate docs for the kubectl command in the kubernetes project
package main
import (
"io/ioutil"
"log"
"os"
"k8s.io/kubernetes/pkg/kubectl/cmd"
cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
"github.com/spf13/cobra/doc"
)
func main() {
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
err := doc.GenYamlTree(kubectl, "./")
if err != nil {
log.Fatal(err)
}
}
This will generate a whole series of files, one for each command in the tree, in the directory specified (in this case “./")
For a single command
You may wish to have more control over the output, or only generate for a single command, instead of the entire command tree. If this is the case you may prefer to GenYaml
instead of GenYamlTree
out := new(bytes.Buffer)
doc.GenYaml(cmd, out)
This will write the yaml doc for ONLY “cmd” into the out, buffer.
Customize the output
Both GenYaml
and GenYamlTree
have alternate versions with callbacks to get some control of the output:
func GenYamlTreeCustom(cmd *Command, dir string, filePrepender, linkHandler func(string) string) error {
//...
}
func GenYamlCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string) string) error {
//...
}
The filePrepender
will prepend the return value given the full filepath to the rendered Yaml file. A common use case is to add front matter to use the generated documentation with Hugo:
const fmTemplate = `---
date: %s
title: "%s"
slug: %s
url: %s
---
`
filePrepender := func(filename string) string {
now := time.Now().Format(time.RFC3339)
name := filepath.Base(filename)
base := strings.TrimSuffix(name, path.Ext(name))
url := "/commands/" + strings.ToLower(base) + "/"
return fmt.Sprintf(fmTemplate, now, strings.Replace(base, "_", " ", -1), base, url)
}
The linkHandler
can be used to customize the rendered internal links to the commands, given a filename:
linkHandler := func(name string) string {
base := strings.TrimSuffix(name, path.Ext(name))
return "/commands/" + strings.ToLower(base) + "/"
}
Contributing to Cobra
Thank you so much for contributing to Cobra. We appreciate your time and help. Here are some guidelines to help you get started.
Code of Conduct
Be kind and respectful to the members of the community. Take time to educate others who are seeking help. Harassment of any kind will not be tolerated.
Questions
If you have questions regarding Cobra, feel free to ask it in the community #cobra Slack channel
Filing a bug or feature
- Before filing an issue, please check the existing issues to see if a similar one was already opened. If there is one already opened, feel free to comment on it.
- If you believe you've found a bug, please provide detailed steps of reproduction, the version of Cobra and anything else you believe will be useful to help troubleshoot it (e.g. OS environment, environment variables, etc…). Also state the current behavior vs. the expected behavior.
- If you'd like to see a feature or an enhancement please open an issue with a clear title and description of what the feature is and why it would be beneficial to the project and its users.
Submitting changes
- CLA: Upon submitting a Pull Request (PR), contributors will be prompted to sign a CLA. Please sign the CLA :slightly_smiling_face:
- Tests: If you are submitting code, please ensure you have adequate tests
for the feature. Tests can be run via
go test ./...
ormake test
. - Since this is golang project, ensure the new code is properly formatted to
ensure code consistency. Run
make all
.
Quick steps to contribute
- Fork the project.
- Download your fork to your PC (
git clone https://github.com/your_username/cobra && cd cobra
) - Create your feature branch (
git checkout -b my-new-feature
) - Make changes and run tests (
make test
) - Add them to staging (
git add .
) - Commit your changes (
git commit -m 'Add some feature'
) - Push to the branch (
git push origin my-new-feature
) - Create new pull request
Cobra Changelog
Pending
- Fix man page doc generation - no auto generated tag when
cmd.DisableAutoGenTag = true
@jpmcb
v1.0.0
Announcing v1.0.0 of Cobra. 🎉
Notable Changes
- Fish completion (including support for Go custom completion) @marckhouzam
- API (urgent): Rename BashCompDirectives to ShellCompDirectives @marckhouzam
- Remove/replace SetOutput on Command - deprecated @jpmcb
- add support for autolabel stale PR @xchapter7x
- Add Labeler Actions @xchapter7x
- Custom completions coded in Go (instead of Bash) @marckhouzam
- Partial Revert of #922 @jharshman
- Add Makefile to project @jharshman
- Correct documentation for InOrStdin @desponda
- Apply formatting to templates @jharshman
- Revert change so help is printed on stdout again @marckhouzam
- Update md2man to v2.0.0 @pdf
- update viper to v1.4.0 @umarcor
- Update cmd/root.go example in README.md @jharshman
Projects using Cobra
- Arduino CLI
- Bleve
- CockroachDB
- Cosmos SDK
- Delve
- Docker (distribution)
- Etcd
- Gardener
- Giant Swarm's gsctl
- Git Bump
- Github CLI
- GitHub Labeler
- Golangci-lint
- GopherJS
- Helm
- Hugo
- Istio
- Kool
- Kubernetes
- Linkerd
- Mattermost-server
- Metal Stack CLI
- Moby (former Docker)
- Nanobox/Nanopack
- OpenShift
- Ory Hydra
- Ory Kratos
- Pouch
- ProjectAtomic (enterprise)
- Prototool
- Random
- Rclone
- Skaffold
- Tendermint
- Twitch CLI
- Werf
License
Cobra is released under the Apache 2.0 license. See LICENSE.txt