cobra

package
v1.1.4 Latest Latest
Warning

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

 Go to latest Published: Mar 14, 2016 License: Apache-2.0, Apache-2.0 Imports: 16 Imported by: 0

README

cobra logo

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:

Build Status CircleCI status

cobra

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 mean app server?)
  • Automatic help generation for commands and flags
  • Automatic detailed help for app help [command]
  • Automatic help flag recognition of -h, --help, etc.
  • Automatically generated bash autocomplete for your application
  • Automatically generated man pages for your application
  • Command aliases so you can change things without breaking them
  • 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 serve --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:

type Command struct {
    Use string // The one-line usage message.
    Short string // The short description shown in the 'help' output.
    Long string // The long message shown in the 'help <this-command>' output.
    Run func(cmd *Command, args []string) // Run runs the command.
}

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:

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() {
	if err := cmd.RootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(-1)
	}
}

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 init github.com/spf13/newAppName
cobra add

Once an application is initialized Cobra can create additional commands for you. Let's say you created an app and you wanted the following commands for it:

  • app serve
  • app config
  • app config create

In your project directory (where your main.go file is) you would run the following:

cobra add serve
cobra add config
cobra add create -p 'configCmd'

Once you have run these four commands you would have an app structure that would look like:

  ▾ app/
    ▾ cmd/
        serve.go
        config.go
        create.go
      main.go

at this point you can run go run main.go and it would run your app. go run main.go serve, go run main.go config, go run main.go config create along with go run main.go help serve, etc would all work.

Obviously you haven't added your own code to these yet, the commands are ready for you to give them their tasks. Have fun.

Configuring the cobra generator

The cobra generator will be easier to use if you provide a simple configuration file which will help you eliminate providing a bunch of repeated information in flags over and over.

an example ~/.cobra.yaml file:

author: Steve Francia <spf@spf13.com>
license: MIT

Manually implementing Cobra

To manually implement cobra you need to create a bare main.go file and a RootCmd file. You will optionally provide additional commands as you see fit.

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:

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
	},
}

You will additionally define flags and handle configuration in your init() function.

for example cmd/root.go:

func init() {
	cobra.OnInitialize(initConfig)
	RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")
	RootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/")
	RootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution")
	RootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "Name of license for the project (can provide `licensetext` in config)")
	RootCmd.PersistentFlags().Bool("viper", true, "Use Viper for configuration")
	viper.BindPFlag("author", RootCmd.PersistentFlags().Lookup("author"))
	viper.BindPFlag("projectbase", RootCmd.PersistentFlags().Lookup("projectbase"))
	viper.BindPFlag("useViper", RootCmd.PersistentFlags().Lookup("viper"))
	viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")
	viper.SetDefault("license", "apache")
}
Create your main.go

With the root command you need to have your main function execute it. Execute should be run on the root for clarity, though it can be called on any command.

In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra.

package main

import "{pathToYourApp}/cmd"

func main() {
	if err := cmd.RootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(-1)
	}
}
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 (
	"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")
	},
}
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.

RootCmd.AddCommand(versionCmd)
Remove a command from its parent

Removing a command is not a common action in simple programs, but it allows 3rd parties to customize an existing command tree.

In this example, we remove the existing VersionCmd command of an existing root command, and we replace it with our own version:

mainlib.RootCmd.RemoveCommand(mainlib.VersionCmd)
mainlib.RootCmd.AddCommand(versionCmd)

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.

RootCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")

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.
            `,
		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.
            `,
		Run: func(cmd *cobra.Command, args []string) {
			fmt.Println("Print: " + strings.Join(args, " "))
		},
	}

	var cmdTimes = &cobra.Command{
		Use:   "times [# times] [string to echo]",
		Short: "Echo anything to the screen more times",
		Long: `echo things multiple times back to the user by providing
            a count and a string.`,
		Run: func(cmd *cobra.Command, args []string) {
			for i := 0; i < echoTimes; i++ {
				fmt.Println("Echo: " + strings.Join(args, " "))
			}
		},
	}

	cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")

	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.

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

hugo is the main command, used to build your Hugo site.

Hugo is a Fast and Flexible Static Site Generator
built with love by spf13 and friends in Go.

Complete documentation is available at http://gohugo.io/.

Usage:
  hugo [flags]
  hugo [command]

Available Commands:
  server          Hugo runs its own webserver to render the files
  version         Print the version number of Hugo
  config          Print the site configuration
  check           Check content in the source directory
  benchmark       Benchmark hugo by building a site a number of times.
  convert         Convert your content to different formats
  new             Create new content for your site
  list            Listing out various types of content
  undraft         Undraft changes the content's draft status from 'True' to 'False'
  genautocomplete Generate shell autocompletion script for Hugo
  gendoc          Generate Markdown documentation for the Hugo CLI.
  genman          Generate man page for Hugo
  import          Import your site from others.

Flags:
  -b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/
  -D, --buildDrafts[=false]: include content marked as draft
  -F, --buildFuture[=false]: include content with publishdate in the future
      --cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
      --canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL
      --config="": config file (default is path/config.yaml|json|toml)
  -d, --destination="": filesystem path to write files to
      --disableRSS[=false]: Do not build RSS files
      --disableSitemap[=false]: Do not build Sitemap file
      --editor="": edit new content with this editor, if provided
      --ignoreCache[=false]: Ignores the cache directory for reading but still writes to it
      --log[=false]: Enable Logging
      --logFile="": Log File path (if set, logging enabled automatically)
      --noTimes[=false]: Don't sync modification time of files
      --pluralizeListTitles[=true]: Pluralize titles in lists using inflect
      --preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")
  -s, --source="": filesystem path to read files relative from
      --stepAnalysis[=false]: display memory and timing of different steps of the program
  -t, --theme="": theme to use (located in /themes/THEMENAME/)
      --uglyURLs[=false]: if true, use /filename.html instead of /filename/
  -v, --verbose[=false]: verbose output
      --verboseLog[=false]: verbose logging
  -w, --watch[=false]: watch filesystem for changes and recreate as needed

Use "hugo [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 you own template for the default command to use.

The default help command is

func (c *Command) initHelp() {
	if c.helpCommand == nil {
		c.helpCommand = &Command{
			Use:   "help [command]",
			Short: "Help about any command",
			Long: `Help provides help for any command in the application.
        Simply type ` + c.Name() + ` help [path to command] for full details.`,
			Run: c.HelpFunc(),
		}
	}
	c.AddCommand(c.helpCommand)
}

You can provide your own command, function or template through the following methods:

command.SetHelpCommand(cmd *Command)

command.SetHelpFunc(f func(*Command, []string))

command.SetHelpTemplate(s string)

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.

Usage:
  hugo [flags]
  hugo [command]

Available Commands:
  server          Hugo runs its own webserver to render the files
  version         Print the version number of Hugo
  config          Print the site configuration
  check           Check content in the source directory
  benchmark       Benchmark hugo by building a site a number of times.
  convert         Convert your content to different formats
  new             Create new content for your site
  list            Listing out various types of content
  undraft         Undraft changes the content's draft status from 'True' to 'False'
  genautocomplete Generate shell autocompletion script for Hugo
  gendoc          Generate Markdown documentation for the Hugo CLI.
  genman          Generate man page for Hugo
  import          Import your site from others.

Flags:
  -b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/
  -D, --buildDrafts[=false]: include content marked as draft
  -F, --buildFuture[=false]: include content with publishdate in the future
      --cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/
      --canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL
      --config="": config file (default is path/config.yaml|json|toml)
  -d, --destination="": filesystem path to write files to
      --disableRSS[=false]: Do not build RSS files
      --disableSitemap[=false]: Do not build Sitemap file
      --editor="": edit new content with this editor, if provided
      --ignoreCache[=false]: Ignores the cache directory for reading but still writes to it
      --log[=false]: Enable Logging
      --logFile="": Log File path (if set, logging enabled automatically)
      --noTimes[=false]: Don't sync modification time of files
      --pluralizeListTitles[=true]: Pluralize titles in lists using inflect
      --preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")
  -s, --source="": filesystem path to read files relative from
      --stepAnalysis[=false]: display memory and timing of different steps of the program
  -t, --theme="": theme to use (located in /themes/THEMENAME/)
      --uglyURLs[=false]: if true, use /filename.html instead of /filename/
  -v, --verbose[=false]: verbose output
      --verboseLog[=false]: verbose logging
  -w, --watch[=false]: watch filesystem for changes and recreate as needed
Defining your own usage

You can provide your own usage function or template for Cobra to use.

The default usage function is:

return func(c *Command) error {
	err := tmpl(c.Out(), c.UsageTemplate(), c)
	return err
}

Like help, the function and template are overridable through public methods:

command.SetUsageFunc(f func(*Command) error)

command.SetUsageTemplate(s string)

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:

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.Print("\n")
	rootCmd.SetArgs([]string{"sub", "arg1", "arg2"})
	_ = rootCmd.Execute()
}

Alternative Error Handling

Cobra also has functions where the return signature is an error. This allows for errors to bubble up to the top, providing a way to handle the errors in one location. The current list of functions that return an error is:

  • PersistentPreRunE
  • PreRunE
  • RunE
  • PostRunE
  • PersistentPostRunE

Example Usage using RunE:

package main

import (
	"errors"
	"log"

	"github.com/spf13/cobra"
)

func main() {
	var rootCmd = &cobra.Command{
		Use:   "hugo",
		Short: "Hugo is a very fast static site generator",
		Long: `A Fast and Flexible Static Site Generator built with
                love by spf13 and friends in Go.
                Complete documentation is available at http://hugo.spf13.com`,
		RunE: func(cmd *cobra.Command, args []string) error {
			// Do Stuff Here
			return errors.New("some random error")
		},
	}

	if err := rootCmd.Execute(); err != nil {
		log.Fatal(err)
	}
}

Suggestions when "unknown command" happens

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 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
command.DebugFlags()

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 and ovrclk clusters:launch.

ToDo

  • Launch proper documentation site

Contributing

  1. Fork it
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create new Pull Request

Contributors

Names in no particular order:

License

Cobra is released under the Apache 2.0 license. See LICENSE.txt

Bitdeli Badge

Documentation

Overview

Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces. In addition to providing an interface, Cobra simultaneously provides a controller to organize your application code.

Index

Examples

Constants

View Source 
const (
	BashCompFilenameExt     = "cobra_annotation_bash_completion_filename_extentions"
	BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag"
	BashCompSubdirsInDir    = "cobra_annotation_bash_completion_subdirs_in_dir"
)

Variables

View Source 
var EnablePrefixMatching bool = false

automatic prefix matching can be a dangerous thing to automatically enable in CLI tools. Set this to true to enable it

View Source 
var EnableWindowsMouseTrap bool = true

enables an information splash screen on Windows if the CLI is started from explorer.exe.

View Source 
var MousetrapHelpText string = `This is a command line tool

You need to open cmd.exe and run it from there.
`

Functions

func AddTemplateFunc added in v1.0.7 

func AddTemplateFunc(name string, tmplFunc interface{})

AddTemplateFunc adds a template function that's available to Usage and Help template generation.

func AddTemplateFuncs added in v1.0.7 

func AddTemplateFuncs(tmplFuncs template.FuncMap)

AddTemplateFuncs adds multiple template functions availalble to Usage and Help template generation.

func Eq 

func Eq(a interface{}, b interface{}) bool

Eq takes two types and checks whether they are equal. Supported types are int and string. Unsupported types will panic.

func GenMan added in v1.0.7 

func GenMan(cmd *Command, header *GenManHeader, out *bytes.Buffer)

GenMan will call cmd.GenMan(header, out)

func GenManTree added in v1.0.7 

func GenManTree(cmd *Command, header *GenManHeader, dir string)

GenManTree will call cmd.GenManTree(header, dir)

func GenMarkdown added in v0.4.4 

func GenMarkdown(cmd *Command, out *bytes.Buffer)

func GenMarkdownCustom added in v1.0.1 

func GenMarkdownCustom(cmd *Command, out *bytes.Buffer, linkHandler func(string) string)

func GenMarkdownTree added in v0.4.4 

func GenMarkdownTree(cmd *Command, dir string)

func GenMarkdownTreeCustom added in v1.0.1 

func GenMarkdownTreeCustom(cmd *Command, dir string, filePrepender func(string) string, linkHandler func(string) string)

func Gt 

func Gt(a interface{}, b interface{}) bool

Gt takes two types and checks whether the first type is greater than the second. In case of types Arrays, Chans, Maps and Slices, Gt will compare their lengths. Ints are compared directly while strings are first parsed as ints and then compared.

func MarkFlagFilename added in v1.0.1 

func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error

MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists. Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.

func MarkFlagRequired added in v1.0.1 

func MarkFlagRequired(flags *pflag.FlagSet, name string) error

MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists.

func OnInitialize 

func OnInitialize(y ...func())

OnInitialize takes a series of func() arguments and appends them to a slice of func().

Types

type Command 

type Command struct {

	// The one-line usage message.
	Use string
	// An array of aliases that can be used instead of the first word in Use.
	Aliases []string
	// An array of command names for which this command will be suggested - similar to aliases but only suggests.
	SuggestFor []string
	// The short description shown in the 'help' output.
	Short string
	// The long message shown in the 'help <this-command>' output.
	Long string
	// Examples of how to use the command
	Example string
	// List of all valid non-flag arguments, used for bash completions *TODO* actually validate these
	ValidArgs []string
	// Custom functions used by the bash autocompletion generator
	BashCompletionFunction string
	// Is this command deprecated and should print this string when used?
	Deprecated string
	// Is this command hidden and should NOT show up in the list of available commands?
	Hidden bool

	// SilenceErrors is an option to quiet errors down stream
	SilenceErrors bool
	// Silence Usage is an option to silence usage when an error occurs.
	SilenceUsage bool
	// The *Run functions are executed in the following order:
	//   * PersistentPreRun()
	//   * PreRun()
	//   * Run()
	//   * PostRun()
	//   * PersistentPostRun()
	// All functions get the same args, the arguments after the command name
	// PersistentPreRun: children of this command will inherit and execute
	PersistentPreRun func(cmd *Command, args []string)
	// PersistentPreRunE: PersistentPreRun but returns an error
	PersistentPreRunE func(cmd *Command, args []string) error
	// PreRun: children of this command will not inherit.
	PreRun func(cmd *Command, args []string)
	// PreRunE: PreRun but returns an error
	PreRunE func(cmd *Command, args []string) error
	// Run: Typically the actual work function. Most commands will only implement this
	Run func(cmd *Command, args []string)
	// RunE: Run but returns an error
	RunE func(cmd *Command, args []string) error
	// PostRun: run after the Run command.
	PostRun func(cmd *Command, args []string)
	// PostRunE: PostRun but returns an error
	PostRunE func(cmd *Command, args []string) error
	// PersistentPostRun: children of this command will inherit and execute after PostRun
	PersistentPostRun func(cmd *Command, args []string)
	// PersistentPostRunE: PersistentPostRun but returns an error
	PersistentPostRunE func(cmd *Command, args []string) error
	// DisableAutoGenTag remove
	DisableAutoGenTag bool

	// Disable the suggestions based on Levenshtein distance that go along with 'unknown command' messages
	DisableSuggestions bool
	// If displaying suggestions, allows to set the minimum levenshtein distance to display, must be > 0
	SuggestionsMinimumDistance int
	// contains filtered or unexported fields
}

Command is just that, a command for your application. eg. 'go run' ... 'run' is the command. Cobra requires you to define the usage and description as part of your command definition to ensure usability.

func (*Command) AddCommand 

func (c *Command) AddCommand(cmds ...*Command)

AddCommand adds one or more commands to this parent command.

func (*Command) ArgsLenAtDash added in v1.0.7 

func (c *Command) ArgsLenAtDash() int

ArgsLenAtDash will return the length of f.Args at the moment when a -- was found during arg parsing. This allows your program to know which args were before the -- and which came after. (Description from https://godoc.org/github.com/spf13/pflag#FlagSet.ArgsLenAtDash).

func (*Command) CommandPath 

func (c *Command) CommandPath() string

CommandPath returns the full path to this command.

func (*Command) CommandPathPadding 

func (c *Command) CommandPathPadding() int

func (*Command) Commands 

func (c *Command) Commands() []*Command

Commands returns a slice of child commands.

func (*Command) DebugFlags 

func (c *Command) DebugFlags()

For use in determining which flags have been assigned to which commands and which persist

func (*Command) Execute 

func (c *Command) Execute() error

Call execute to use the args (os.Args[1:] by default) and run through the command tree finding appropriate matches for commands and then corresponding flags.

func (*Command) ExecuteC added in v1.1.1 

func (c *Command) ExecuteC() (cmd *Command, err error)

func (*Command) Find 

func (c *Command) Find(args []string) (*Command, []string, error)

find the target command given the args and command tree Meant to be run on the highest node. Only searches down.

func (*Command) Flag 

func (c *Command) Flag(name string) (flag *flag.Flag)

Climbs up the command tree looking for matching flag

func (*Command) Flags 

func (c *Command) Flags() *flag.FlagSet

Get the complete FlagSet that applies to this command (local and persistent declared here and by all parents)

func (*Command) GenBashCompletion added in v0.4.4 

func (cmd *Command) GenBashCompletion(out *bytes.Buffer)

func (*Command) GenBashCompletionFile added in v0.4.4 

func (cmd *Command) GenBashCompletionFile(filename string) error

func (*Command) GenMan added in v1.0.7 

func (cmd *Command) GenMan(header *GenManHeader, out *bytes.Buffer)

GenMan will generate a man page for the given command in the out buffer. The header argument may be nil, however obviously out may not.

Example 
package main

import (
	"bytes"
	"fmt"

	"github.com/spf13/cobra"
)

func main() {
	cmd := &cobra.Command{
		Use:   "test",
		Short: "my test program",
	}
	header := &cobra.GenManHeader{
		Title:   "MINE",
		Section: "3",
	}
	out := new(bytes.Buffer)
	cmd.GenMan(header, out)
	fmt.Print(out.String())
}

Output:

func (*Command) GenManTree added in v1.0.7 

func (cmd *Command) GenManTree(header *GenManHeader, dir string)

GenManTree will generate a man page for this command and all decendants in the directory given. The header may be nil. This function may not work correctly if your command names have - in them. If you have `cmd` with two subcmds, `sub` and `sub-third`. And `sub` has a subcommand called `third` it is undefined which help output will be in the file `cmd-sub-third.1`.

Example 
package main

import (
	"github.com/spf13/cobra"
)

func main() {
	cmd := &cobra.Command{
		Use:   "test",
		Short: "my test program",
	}
	header := &cobra.GenManHeader{
		Title:   "MINE",
		Section: "3",
	}
	cmd.GenManTree(header, "/tmp")
}

Output:

func (*Command) GenMarkdown added in v1.0.7 

func (cmd *Command) GenMarkdown(out *bytes.Buffer)

func (*Command) GenMarkdownCustom added in v1.0.7 

func (cmd *Command) GenMarkdownCustom(out *bytes.Buffer, linkHandler func(string) string)

func (*Command) GenMarkdownTree added in v1.0.7 

func (cmd *Command) GenMarkdownTree(dir string)

func (*Command) GenMarkdownTreeCustom added in v1.0.7 

func (cmd *Command) GenMarkdownTreeCustom(dir string, filePrepender func(string) string, linkHandler func(string) string)

func (*Command) GlobalNormalizationFunc added in v1.0.1 

func (c *Command) GlobalNormalizationFunc() func(f *flag.FlagSet, name string) flag.NormalizedName

GlobalNormalizationFunc returns the global normalization function or nil if doesn't exists

func (*Command) HasAlias 

func (c *Command) HasAlias(s string) bool

Determine if a given string is an alias of the command.

func (*Command) HasAvailableSubCommands added in v1.0.7 

func (c *Command) HasAvailableSubCommands() bool

HasAvailableSubCommands determines if a command has available sub commands that need to be shown in the usage/help default template under 'available commands'

func (*Command) HasExample added in v0.4.1 

func (c *Command) HasExample() bool

func (*Command) HasFlags 

func (c *Command) HasFlags() bool

Does the command contain any flags (local plus persistent from the entire structure)

func (*Command) HasHelpSubCommands added in v0.4.4 

func (c *Command) HasHelpSubCommands() bool

HasHelpSubCommands determines if a command has any avilable 'help' sub commands that need to be shown in the usage/help default template under 'additional help topics'

func (*Command) HasInheritedFlags added in v0.4.3 

func (c *Command) HasInheritedFlags() bool

func (*Command) HasLocalFlags added in v0.2.2 

func (c *Command) HasLocalFlags() bool

Does the command has flags specifically declared locally

func (*Command) HasParent 

func (c *Command) HasParent() bool

Determine if the command is a child command

func (*Command) HasPersistentFlags 

func (c *Command) HasPersistentFlags() bool

Does the command contain persistent flags

func (*Command) HasSubCommands 

func (c *Command) HasSubCommands() bool

Determine if the command has children commands

func (*Command) Help 

func (c *Command) Help() error

Output the help for the command Used when a user calls help [command] by the default HelpFunc in the commander

func (*Command) HelpFunc 

func (c *Command) HelpFunc() func(*Command, []string)

HelpFunc returns either the function set by SetHelpFunc for this command or a parent, or it returns a function which calls c.Help()

func (*Command) HelpTemplate 

func (c *Command) HelpTemplate() string

func (*Command) InheritedFlags added in v0.4.1 

func (c *Command) InheritedFlags() *flag.FlagSet

All Flags which were inherited from parents commands

func (*Command) IsAvailableCommand added in v1.0.7 

func (c *Command) IsAvailableCommand() bool

IsAvailableCommand determines if a command is available as a non-help command (this includes all non deprecated/hidden commands)

func (*Command) IsHelpCommand added in v1.0.5 

func (c *Command) IsHelpCommand() bool

IsHelpCommand determines if a command is a 'help' command; a help command is determined by the fact that it is NOT runnable/hidden/deprecated, and has no sub commands that are runnable/hidden/deprecated

func (*Command) LocalFlags added in v0.2.2 

func (c *Command) LocalFlags() *flag.FlagSet

Get the local FlagSet specifically set in the current command

func (*Command) MarkFlagFilename added in v1.0.1 

func (cmd *Command) MarkFlagFilename(name string, extensions ...string) error

MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists. Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.

func (*Command) MarkFlagRequired added in v0.4.4 

func (cmd *Command) MarkFlagRequired(name string) error

MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag, if it exists.

func (*Command) MarkPersistentFlagFilename added in v1.1.1 

func (cmd *Command) MarkPersistentFlagFilename(name string, extensions ...string) error

MarkPersistentFlagFilename adds the BashCompFilenameExt annotation to the named persistent flag, if it exists. Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.

func (*Command) MarkPersistentFlagRequired added in v1.1.1 

func (cmd *Command) MarkPersistentFlagRequired(name string) error

MarkPersistentFlagRequired adds the BashCompOneRequiredFlag annotation to the named persistent flag, if it exists.

func (*Command) Name 

func (c *Command) Name() string

Name returns the command's name: the first word in the use line.

func (*Command) NameAndAliases 

func (c *Command) NameAndAliases() string

func (*Command) NamePadding added in v0.4.1 

func (c *Command) NamePadding() int

func (*Command) NonInheritedFlags added in v0.4.1 

func (c *Command) NonInheritedFlags() *flag.FlagSet

All Flags which were not inherited from parent commands

func (*Command) Out 

func (c *Command) Out() io.Writer

func (*Command) Parent 

func (c *Command) Parent() *Command

func (*Command) ParseFlags 

func (c *Command) ParseFlags(args []string) (err error)

Parses persistent flag tree & local flags

func (*Command) PersistentFlags 

func (c *Command) PersistentFlags() *flag.FlagSet

Get the Persistent FlagSet specifically set in the current command

func (*Command) Print 

func (c *Command) Print(i ...interface{})

Convenience method to Print to the defined output

func (*Command) Printf 

func (c *Command) Printf(format string, i ...interface{})

Convenience method to Printf to the defined output

func (*Command) Println 

func (c *Command) Println(i ...interface{})

Convenience method to Println to the defined output

func (*Command) RemoveCommand added in v0.4.3 

func (c *Command) RemoveCommand(cmds ...*Command)

AddCommand removes one or more commands from a parent command.

func (*Command) ResetCommands 

func (c *Command) ResetCommands()

Used for testing

func (*Command) ResetFlags 

func (c *Command) ResetFlags()

For use in testing

func (*Command) Root 

func (c *Command) Root() *Command

func (*Command) Runnable 

func (c *Command) Runnable() bool

Determine if the command is itself runnable

func (*Command) SetArgs 

func (c *Command) SetArgs(a []string)

os.Args[1:] by default, if desired, can be overridden particularly useful when testing.

func (*Command) SetGlobalNormalizationFunc added in v1.0.1 

func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string) flag.NormalizedName)

SetGlobalNormalizationFunc sets a normalization function to all flag sets and also to child commands. The user should not have a cyclic dependency on commands.

func (*Command) SetHelpCommand 

func (c *Command) SetHelpCommand(cmd *Command)

func (*Command) SetHelpFunc 

func (c *Command) SetHelpFunc(f func(*Command, []string))

Can be defined by Application

func (*Command) SetHelpTemplate 

func (c *Command) SetHelpTemplate(s string)

Can be defined by Application

func (*Command) SetOutput 

func (c *Command) SetOutput(output io.Writer)

SetOutput sets the destination for usage and error messages. If output is nil, os.Stderr is used.

func (*Command) SetUsageFunc 

func (c *Command) SetUsageFunc(f func(*Command) error)

Usage can be defined by application

func (*Command) SetUsageTemplate 

func (c *Command) SetUsageTemplate(s string)

Can be defined by Application

func (*Command) SuggestionsFor added in v1.0.7 

func (c *Command) SuggestionsFor(typedName string) []string

func (*Command) Usage 

func (c *Command) Usage() error

Output the usage for the command Used when a user provides invalid input Can be defined by user by overriding UsageFunc

func (*Command) UsageFunc 

func (c *Command) UsageFunc() (f func(*Command) error)

func (*Command) UsagePadding 

func (c *Command) UsagePadding() int

func (*Command) UsageString 

func (c *Command) UsageString() string

func (*Command) UsageTemplate 

func (c *Command) UsageTemplate() string

func (*Command) UseLine 

func (c *Command) UseLine() string

The full usage for a given command (including parents)

func (*Command) VisitParents added in v1.1.1 

func (c *Command) VisitParents(fn func(*Command))

type GenManHeader added in v1.0.7 

type GenManHeader struct {
	Title   string
	Section string
	Date    *time.Time

	Source string
	Manual string
	// contains filtered or unexported fields
}

GenManHeader is a lot like the .TH header at the start of man pages. These include the title, section, date, source, and manual. We will use the current time if Date if unset and will use "Auto generated by spf13/cobra" if the Source is unset.

Source Files

View all Source files

Directories

Path Synopsis
cmd

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.