mirror of https://github.com/k3d-io/k3d
iwilltry42
3 years ago
parent
82cdcac8bd
commit
581378feb0
@ -1,28 +0,0 @@ |
||||
language: go |
||||
|
||||
stages: |
||||
- test |
||||
- build |
||||
|
||||
go: |
||||
- 1.12.x |
||||
- 1.13.x |
||||
- tip |
||||
|
||||
env: GO111MODULE=on |
||||
|
||||
before_install: |
||||
- go get -u github.com/kyoh86/richgo |
||||
- go get -u github.com/mitchellh/gox |
||||
- curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin latest |
||||
|
||||
matrix: |
||||
allow_failures: |
||||
- go: tip |
||||
include: |
||||
- stage: build |
||||
go: 1.13.x |
||||
script: make cobra_generator |
||||
|
||||
script: |
||||
- make test |
||||
@ -0,0 +1,302 @@ |
||||
package cobra |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"io" |
||||
"os" |
||||
) |
||||
|
||||
func (c *Command) genBashCompletion(w io.Writer, includeDesc bool) error { |
||||
buf := new(bytes.Buffer) |
||||
genBashComp(buf, c.Name(), includeDesc) |
||||
_, err := buf.WriteTo(w) |
||||
return err |
||||
} |
||||
|
||||
func genBashComp(buf io.StringWriter, name string, includeDesc bool) { |
||||
compCmd := ShellCompRequestCmd |
||||
if !includeDesc { |
||||
compCmd = ShellCompNoDescRequestCmd |
||||
} |
||||
|
||||
WriteStringAndCheck(buf, fmt.Sprintf(`# bash completion V2 for %-36[1]s -*- shell-script -*- |
||||
|
||||
__%[1]s_debug() |
||||
{ |
||||
if [[ -n ${BASH_COMP_DEBUG_FILE:-} ]]; then |
||||
echo "$*" >> "${BASH_COMP_DEBUG_FILE}" |
||||
fi |
||||
} |
||||
|
||||
# Macs have bash3 for which the bash-completion package doesn't include |
||||
# _init_completion. This is a minimal version of that function. |
||||
__%[1]s_init_completion() |
||||
{ |
||||
COMPREPLY=() |
||||
_get_comp_words_by_ref "$@" cur prev words cword |
||||
} |
||||
|
||||
# This function calls the %[1]s program to obtain the completion |
||||
# results and the directive. It fills the 'out' and 'directive' vars. |
||||
__%[1]s_get_completion_results() { |
||||
local requestComp lastParam lastChar args |
||||
|
||||
# Prepare the command to request completions for the program. |
||||
# Calling ${words[0]} instead of directly %[1]s allows to handle aliases |
||||
args=("${words[@]:1}") |
||||
requestComp="${words[0]} %[2]s ${args[*]}" |
||||
|
||||
lastParam=${words[$((${#words[@]}-1))]} |
||||
lastChar=${lastParam:$((${#lastParam}-1)):1} |
||||
__%[1]s_debug "lastParam ${lastParam}, lastChar ${lastChar}" |
||||
|
||||
if [ -z "${cur}" ] && [ "${lastChar}" != "=" ]; then |
||||
# If the last parameter is complete (there is a space following it) |
||||
# We add an extra empty parameter so we can indicate this to the go method. |
||||
__%[1]s_debug "Adding extra empty parameter" |
||||
requestComp="${requestComp} ''" |
||||
fi |
||||
|
||||
# When completing a flag with an = (e.g., %[1]s -n=<TAB>) |
||||
# bash focuses on the part after the =, so we need to remove |
||||
# the flag part from $cur |
||||
if [[ "${cur}" == -*=* ]]; then |
||||
cur="${cur#*=}" |
||||
fi |
||||
|
||||
__%[1]s_debug "Calling ${requestComp}" |
||||
# Use eval to handle any environment variables and such |
||||
out=$(eval "${requestComp}" 2>/dev/null) |
||||
|
||||
# Extract the directive integer at the very end of the output following a colon (:) |
||||
directive=${out##*:} |
||||
# Remove the directive |
||||
out=${out%%:*} |
||||
if [ "${directive}" = "${out}" ]; then |
||||
# There is not directive specified |
||||
directive=0 |
||||
fi |
||||
__%[1]s_debug "The completion directive is: ${directive}" |
||||
__%[1]s_debug "The completions are: ${out[*]}" |
||||
} |
||||
|
||||
__%[1]s_process_completion_results() { |
||||
local shellCompDirectiveError=%[3]d |
||||
local shellCompDirectiveNoSpace=%[4]d |
||||
local shellCompDirectiveNoFileComp=%[5]d |
||||
local shellCompDirectiveFilterFileExt=%[6]d |
||||
local shellCompDirectiveFilterDirs=%[7]d |
||||
|
||||
if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then |
||||
# Error code. No completion. |
||||
__%[1]s_debug "Received error from custom completion go code" |
||||
return |
||||
else |
||||
if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then |
||||
if [[ $(type -t compopt) = "builtin" ]]; then |
||||
__%[1]s_debug "Activating no space" |
||||
compopt -o nospace |
||||
else |
||||
__%[1]s_debug "No space directive not supported in this version of bash" |
||||
fi |
||||
fi |
||||
if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then |
||||
if [[ $(type -t compopt) = "builtin" ]]; then |
||||
__%[1]s_debug "Activating no file completion" |
||||
compopt +o default |
||||
else |
||||
__%[1]s_debug "No file completion directive not supported in this version of bash" |
||||
fi |
||||
fi |
||||
fi |
||||
|
||||
if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then |
||||
# File extension filtering |
||||
local fullFilter filter filteringCmd |
||||
|
||||
# Do not use quotes around the $out variable or else newline |
||||
# characters will be kept. |
||||
for filter in ${out[*]}; do |
||||
fullFilter+="$filter|" |
||||
done |
||||
|
||||
filteringCmd="_filedir $fullFilter" |
||||
__%[1]s_debug "File filtering command: $filteringCmd" |
||||
$filteringCmd |
||||
elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then |
||||
# File completion for directories only |
||||
|
||||
# Use printf to strip any trailing newline |
||||
local subdir |
||||
subdir=$(printf "%%s" "${out[0]}") |
||||
if [ -n "$subdir" ]; then |
||||
__%[1]s_debug "Listing directories in $subdir" |
||||
pushd "$subdir" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1 || return |
||||
else |
||||
__%[1]s_debug "Listing directories in ." |
||||
_filedir -d |
||||
fi |
||||
else |
||||
__%[1]s_handle_standard_completion_case |
||||
fi |
||||
|
||||
__%[1]s_handle_special_char "$cur" : |
||||
__%[1]s_handle_special_char "$cur" = |
||||
} |
||||
|
||||
__%[1]s_handle_standard_completion_case() { |
||||
local tab comp |
||||
tab=$(printf '\t') |
||||
|
||||
local longest=0 |
||||
# Look for the longest completion so that we can format things nicely |
||||
while IFS='' read -r comp; do |
||||
# Strip any description before checking the length |
||||
comp=${comp%%%%$tab*} |
||||
# Only consider the completions that match |
||||
comp=$(compgen -W "$comp" -- "$cur") |
||||
if ((${#comp}>longest)); then |
||||
longest=${#comp} |
||||
fi |
||||
done < <(printf "%%s\n" "${out[@]}") |
||||
|
||||
local completions=() |
||||
while IFS='' read -r comp; do |
||||
if [ -z "$comp" ]; then |
||||
continue |
||||
fi |
||||
|
||||
__%[1]s_debug "Original comp: $comp" |
||||
comp="$(__%[1]s_format_comp_descriptions "$comp" "$longest")" |
||||
__%[1]s_debug "Final comp: $comp" |
||||
completions+=("$comp") |
||||
done < <(printf "%%s\n" "${out[@]}") |
||||
|
||||
while IFS='' read -r comp; do |
||||
COMPREPLY+=("$comp") |
||||
done < <(compgen -W "${completions[*]}" -- "$cur") |
||||
|
||||
# If there is a single completion left, remove the description text |
||||
if [ ${#COMPREPLY[*]} -eq 1 ]; then |
||||
__%[1]s_debug "COMPREPLY[0]: ${COMPREPLY[0]}" |
||||
comp="${COMPREPLY[0]%%%% *}" |
||||
__%[1]s_debug "Removed description from single completion, which is now: ${comp}" |
||||
COMPREPLY=() |
||||
COMPREPLY+=("$comp") |
||||
fi |
||||
} |
||||
|
||||
__%[1]s_handle_special_char() |
||||
{ |
||||
local comp="$1" |
||||
local char=$2 |
||||
if [[ "$comp" == *${char}* && "$COMP_WORDBREAKS" == *${char}* ]]; then |
||||
local word=${comp%%"${comp##*${char}}"} |
||||
local idx=${#COMPREPLY[*]} |
||||
while [[ $((--idx)) -ge 0 ]]; do |
||||
COMPREPLY[$idx]=${COMPREPLY[$idx]#"$word"} |
||||
done |
||||
fi |
||||
} |
||||
|
||||
__%[1]s_format_comp_descriptions() |
||||
{ |
||||
local tab |
||||
tab=$(printf '\t') |
||||
local comp="$1" |
||||
local longest=$2 |
||||
|
||||
# Properly format the description string which follows a tab character if there is one |
||||
if [[ "$comp" == *$tab* ]]; then |
||||
desc=${comp#*$tab} |
||||
comp=${comp%%%%$tab*} |
||||
|
||||
# $COLUMNS stores the current shell width. |
||||
# Remove an extra 4 because we add 2 spaces and 2 parentheses. |
||||
maxdesclength=$(( COLUMNS - longest - 4 )) |
||||
|
||||
# Make sure we can fit a description of at least 8 characters |
||||
# if we are to align the descriptions. |
||||
if [[ $maxdesclength -gt 8 ]]; then |
||||
# Add the proper number of spaces to align the descriptions |
||||
for ((i = ${#comp} ; i < longest ; i++)); do |
||||
comp+=" " |
||||
done |
||||
else |
||||
# Don't pad the descriptions so we can fit more text after the completion |
||||
maxdesclength=$(( COLUMNS - ${#comp} - 4 )) |
||||
fi |
||||
|
||||
# If there is enough space for any description text, |
||||
# truncate the descriptions that are too long for the shell width |
||||
if [ $maxdesclength -gt 0 ]; then |
||||
if [ ${#desc} -gt $maxdesclength ]; then |
||||
desc=${desc:0:$(( maxdesclength - 1 ))} |
||||
desc+="…" |
||||
fi |
||||
comp+=" ($desc)" |
||||
fi |
||||
fi |
||||
|
||||
# Must use printf to escape all special characters |
||||
printf "%%q" "${comp}" |
||||
} |
||||
|
||||
__start_%[1]s() |
||||
{ |
||||
local cur prev words cword split |
||||
|
||||
COMPREPLY=() |
||||
|
||||
# Call _init_completion from the bash-completion package |
||||
# to prepare the arguments properly |
||||
if declare -F _init_completion >/dev/null 2>&1; then |
||||
_init_completion -n "=:" || return |
||||
else |
||||
__%[1]s_init_completion -n "=:" || return |
||||
fi |
||||
|
||||
__%[1]s_debug |
||||
__%[1]s_debug "========= starting completion logic ==========" |
||||
__%[1]s_debug "cur is ${cur}, words[*] is ${words[*]}, #words[@] is ${#words[@]}, cword is $cword" |
||||
|
||||
# The user could have moved the cursor backwards on the command-line. |
||||
# We need to trigger completion from the $cword location, so we need |
||||
# to truncate the command-line ($words) up to the $cword location. |
||||
words=("${words[@]:0:$cword+1}") |
||||
__%[1]s_debug "Truncated words[*]: ${words[*]}," |
||||
|
||||
local out directive |
||||
__%[1]s_get_completion_results |
||||
__%[1]s_process_completion_results |
||||
} |
||||
|
||||
if [[ $(type -t compopt) = "builtin" ]]; then |
||||
complete -o default -F __start_%[1]s %[1]s |
||||
else |
||||
complete -o default -o nospace -F __start_%[1]s %[1]s |
||||
fi |
||||
|
||||
# ex: ts=4 sw=4 et filetype=sh |
||||
`, name, compCmd, |
||||
ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp, |
||||
ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs)) |
||||
} |
||||
|
||||
// GenBashCompletionFileV2 generates Bash completion version 2. |
||||
func (c *Command) GenBashCompletionFileV2(filename string, includeDesc bool) error { |
||||
outFile, err := os.Create(filename) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
defer outFile.Close() |
||||
|
||||
return c.GenBashCompletionV2(outFile, includeDesc) |
||||
} |
||||
|
||||
// GenBashCompletionV2 generates Bash completion file version 2 |
||||
// and writes it to the passed writer. |
||||
func (c *Command) GenBashCompletionV2(w io.Writer, includeDesc bool) error { |
||||
return c.genBashCompletion(w, includeDesc) |
||||
} |
||||
@ -1,12 +1,11 @@ |
||||
module github.com/spf13/cobra |
||||
|
||||
go 1.12 |
||||
go 1.14 |
||||
|
||||
require ( |
||||
github.com/cpuguy83/go-md2man/v2 v2.0.0 |
||||
github.com/inconshreveable/mousetrap v1.0.0 |
||||
github.com/mitchellh/go-homedir v1.1.0 |
||||
github.com/spf13/pflag v1.0.5 |
||||
github.com/spf13/viper v1.7.0 |
||||
github.com/spf13/viper v1.8.1 |
||||
gopkg.in/yaml.v2 v2.4.0 |
||||
) |
||||
|
||||
@ -0,0 +1,637 @@ |
||||
# User Guide |
||||
|
||||
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: initializing Cobra. |
||||
|
||||
```go |
||||
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](https://github.com/spf13/cobra/blob/master/cobra/README.md) 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: |
||||
|
||||
```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: |
||||
|
||||
```go |
||||
package cmd |
||||
|
||||
import ( |
||||
"fmt" |
||||
"os" |
||||
|
||||
"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 initConfig() { |
||||
if cfgFile != "" { |
||||
// Use config file from the flag. |
||||
viper.SetConfigFile(cfgFile) |
||||
} else { |
||||
// Find home directory. |
||||
home, err := os.UserHomeDir() |
||||
cobra.CheckErr(err) |
||||
|
||||
// Search config in home directory with name ".cobra" (without extension). |
||||
viper.AddConfigPath(home) |
||||
viper.SetConfigType("yaml") |
||||
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. |
||||
|
||||
```go |
||||
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: |
||||
|
||||
```go |
||||
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. |
||||
|
||||
```go |
||||
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. |
||||
|
||||
```go |
||||
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. |
||||
|
||||
```go |
||||
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. |
||||
|
||||
```go |
||||
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. |
||||
|
||||
```go |
||||
command := cobra.Command{ |
||||
Use: "print [OPTIONS] [COMMANDS]", |
||||
TraverseChildren: true, |
||||
} |
||||
``` |
||||
|
||||
### Bind Flags with Config |
||||
|
||||
You can also bind your flags with [viper](https://github.com/spf13/viper): |
||||
```go |
||||
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](https://github.com/spf13/viper#working-with-flags). |
||||
|
||||
### 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: |
||||
```go |
||||
rootCmd.Flags().StringVarP(&Region, "region", "r", "", "AWS region (required)") |
||||
rootCmd.MarkFlagRequired("region") |
||||
``` |
||||
|
||||
Or, for persistent flags: |
||||
```go |
||||
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 the `ValidArgs` field of `Command`. |
||||
- `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 the `ValidArgs` field of `Command` |
||||
- `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: |
||||
|
||||
```go |
||||
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 |
||||
|
||||
```go |
||||
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](http://gohugo.io/). |
||||
|
||||
## 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: |
||||
|
||||
```go |
||||
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: |
||||
|
||||
```go |
||||
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`: |
||||
|
||||
```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!]", |
||||
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](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: |
||||
|
||||
```go |
||||
command.DisableSuggestions = true |
||||
``` |
||||
|
||||
or |
||||
|
||||
```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: |
||||
|
||||
``` |
||||
$ 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](doc/README.md). |
||||
|
||||
## 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.md). |
||||
Loading…
Reference in new issue