Golang - command line tool Cobra

Cobra

Cobra Is a Go Linguistic CLI frame . It contains a for creating powerful modern CLI The library of the application , And one for rapid generation based on Cobra Tools for applications and command files .

characteristic

• Simple subcommand mode , Such as app server, app fetch wait
• Fully compatible with posix Command line mode
• Nested sub command subcommand
• Support the overall situation , Local , Series connection flags
• Use cobra It's easy to generate applications and commands , Use cobra create appname and cobra add cmdname
• If the command is entered incorrectly , Intelligent advice will be provided , Such as app srver, Will prompt srver No, , Is it right? app server
• Automatic generation commands and flags Help for
• Automatically generate detailed help Information , Such as app help
• Automatic recognition help flag -h,–help
• Auto generate application in bash Command auto complete function
• Automatically generate application man manual
• Command line alias
• Customize help and usage Information
• Optional and viper apps The tight integration of

Concept

Cobra Is based on the command 、 The structure of parameters and signs .
Commands It's for action ,Args It's something ,Flags It's the modifier for these actions .
The best application reads like a sentence . Users will know how to use the application , Because they are born to know how to use it .
for example ：

hugo server --port=1313

Command

Command Is the central point of the application . Every interaction supported by the application is contained in Command in . Commands can have subcommands , You can also operate selectively .

Flag

flag Is a way to modify command behavior .Cobra Fully support compatibility posix The logo and Go Logo pack .Cobra Commands can define flags that run through subcommands , And flags that are only available for this command .
In the example above --port It's a flag

Global identity （Persistent Flags）

Global identity （Persistent Flags） It will act on its specified command and all subcommands of the specified command .

rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")

Local identification （Local Flags）

Local marking （Local Flags） Only works on its specified command .

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

Run Hooks

Can be in the main command run Run the function before or after the function .PersistentPreRun and PreRun The function will be in Run Before execution .persistentpoststrun and poststrun Will be in Run After performing . If the subclass does not declare its own Persistent*Run function , They will be inherited by subclasses . These functions run in the following order :

• PersistentPreRun
• PreRun
• Run
• PostRun
• PersistentPostRun

Example ：

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]