Gain insights into writing professional command-line programs in Go. Delve into structuring Go programs, writing idiomatic code, testing effectively, and impressing users and managers.

write professional command  - line programs in Go.png

data.tar.gz

Go run main.go

Run main.sh

Run go test

Run go test2

GoLive

GoLiveTesting

Multi-git-Custom

Pre+main-v0.2

Main_to_cmd

Run go test-Coverage

Ginkgo

Ginkgo-BDD

Ginkgo-e2e

Cobra

Cobra-NoInstall

Cobra-NoInstall-FullApp

Final_Cobra_Multi-git

Viper

Viper-etcd

Viper-Cobra

SelfUpdating

Make

Special build

Embedding_Data

Go run main.go-Simple

In this course you will learn why Go is an awesome language for writing command-line programs. You will learn how to structure your Go programs, how to write idiomatic Go code, how to test your programs and how to amaze your users, peers and managers. 

The focus is on command-line programs in order to keep the course down to earth, but most of the principles and best practices you will learn apply to any Go program.

Write Professional Command-line Programs in Go

The Cobra generator is another good way to utilize Cobra if you want to benefit from its established best practices and conventions.

# What is the Cobra generator?

The generator is a command-line program that comes with Cobra. You can install it using the go tool

```
$ go get github.com/spf13/cobra/cobra/...
```

After you install Cobra it should be on your path. Try it out in the terminal below. Just type `cobra`



As you can see, the `cobra` program has two primary commands other than `help`:
1. `init`
2. `add`

# How does the Cobra generator work?

The Cobra generator works by generating directories and files for you that follow best practices. As you probably guessed, the Cobra generator is itself a Cobra CLI application. It follows the standard structure, having a root command and two actual commands for `init` and `add`.

It's a good idea to dive in a little deeper as it is a great example of using Cobra from the Cobra developer. The code is available here: 

https://github.com/spf13/cobra/blob/master/cobra

Here is a snippet from the root command:

```
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)
}
``` 
  
It initializes Cobra with an `initConfig()` function, sets up some persistent flags for the root command (these will be available to all sub-commands), and configures Viper. Viper is a configuration library, which will introduce later in the course.

This should look familiar. The actual generation of the various files is based on Go text templates. You can find all the templates here: https://github.com/spf13/cobra/blob/master/cobra/tpl/main.go

This file contains three templates:
- [MainTemplate](https://github.com/spf13/cobra/blob/master/cobra/tpl/main.go#L3): for the main.go file of the generated application
- [RootTemplate](https://github.com/spf13/cobra/blob/master/cobra/tpl/main.go#L18): for the root.go root command of the generated application
- [AddCommandTemplate](https://github.com/spf13/cobra/blob/master/cobra/tpl/main.go#L110): for sub-commands of the generated application

When you run `cobra init` the main.go and the root command are generated using the corresponding templates. When you run `cobra add`, the requested subcommand is added.

Here is the code to generate a sub-command:

```
var (
  packageName string
  parentName  string

  addCmd = &cobra.Command{
    Use:     "add [command name]",
    Aliases: []string{"command"},
    Short:   "Add a command to a Cobra Application",
    Long: `Add (cobra add) will create a new command, with a license and
the appropriate structure for a Cobra-based CLI application,
and register it to its parent (default rootCmd).
If you want your command to be public, pass in the command name
with an initial uppercase letter.
Example: cobra add server -> resulting in a new cmd/server.go`,

    Run: func(cmd *cobra.Command, args []string) {
      if len(args) < 1 {
        er("add needs a name for the command")
      }

      wd, err := os.Getwd()
      if err != nil {
        er(err)
      }

      commandName := validateCmdName(args[0])
      command := &Command{
        CmdName:   commandName,
        CmdParent: parentName,
        Project: &Project{
          AbsolutePath: wd,
          Legal:        getLicense(),
          Copyright:    copyrightLine(),
        },
      }

      err = command.Create()
      if err != nil {
        er(err)
      }

      fmt.Printf("%s created at %s\n", command.CmdName, command.AbsolutePath)
    },
  }
)
```

Cobra also uses a helpers module in the `cmd` package that provides some utility. Check it out here:

https://github.com/spf13/cobra/blob/master/cobra/cmd/helpers.go

Okay. Now you understand how it works, but when should you use it?

# When should you use the Cobra generator

The Cobra generator is especially useful in these situations:

1. You're starting from scratch and don't have strong opinions on application structure
2. You or your organization create a lot of Go CLI programs and need consistency
3. You want to create your own CLI skeleton generator

Let's address them one by one.

The Cobra generator can save you time if you start from scratch. It's not much in terms of code, but if you're not sure about how to structure your application then you can just go ahead and follow the Cobra style.

If you create a lot of CLI applications, using the Cobra generator ensures they all follow the same structure, which is useful for people reviewing and maintaining all those programs. Of course, the time-saving benefits of starting with a skeleton multiply the more CLI programs you write.

Finally, if you want to build a custom CLI generator you can start from the Cobra generator and adapt or extend it.

There are cases where you shouldn't use the Cobra generator:

1. You already have an existing application and you just want to add Cobra command-line parsing
2. You start from scratch, but have your ideas of how to structure your application

In the next lesson we will generate an application with the Cobra generator.

You'll learn about the Cobra generator and use the Cobra generator to generate an application skeleton from scratch in this lesson.

Understanding the Cobra Generator

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Understanding the Cobra Generator

What is the Cobra generator?