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

We will compare Cobra with some alternatives ways to parse command-line programs including the built-in ways Go provides as well as other third-party command-line parsing solutions.

# Installing Cobra

First, we need to install Cobra. The official instructions recommend using the following command:

```
go get -u github.com/spf13/cobra/cobra
```

Unfortunately, this hangs indefinitely for me using Go 1.13.1. However, this command works:

```
go get -u github.com/spf13/cobra/cobra/...
```


Try the above commands in the following terminal.


# Cobra as a library

Once Cobra is installed, we can import it as a library into our application:

```
import "github.com/spf13/cobra"
```

At this point, we can start using Cobra's types and functions. We always start by creating a root command, and then we can take it from there and add additional sub-commands and configure them with arguments and flags.

The root command typically goes in `cmd/root.go`. Here is an example root command:

```
var rootCmd = &cobra.Command{
  Use:   "foo",
  Short: "Foo is a cool program",
  Long: `Foo is an extremely cool program.
         It will make your life easier and fun`,
  Run: func(cmd *cobra.Command, args []string) {
    // This is where you implement the command
  },
}

func Execute() {
  if err := rootCmd.Execute(); err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
}
```

The `main.go` file should call the Execute() function of the root command:

```
package main

import (
  "github.com/gigi/foo/cmd"
)

func main() {
  cmd.Execute()
}
```

That's the gist of it. Later, you will see a full-fledged example of building a Cobra command-line program from scratch, but let's check the Cobra application generator first.

# Cobra as an application generator

One of Cobra's user-friendly features is that when you start a program from scratch it can generate your application directory structure, letting you hit the road running.

Start with `cobra init`, and then you can use subsequent `cobra add` commands to add more commands to your application. You can also configure Cobra to control various aspects of the generated code. We will play with the Cobra code generator in a later lesson.

There’s no doubt that Cobra is awesome, but what about other options?

# Other command-line parsing solutions

Out of the box, Go provides two ways for parsing command-line arguments:

1. Roll your own
2. The [flag](https://golang.org/pkg/flag) package

If your program is simple enough and just takes a couple of arguments, then you can directly parse `os.Args` as a slice of strings. If you want a tad more, you can use the `flag` standard library package, which allows you to declare types and add some basic validation. If you recall, multi-git 0.1 uses the flag package.

However, when you get to more complicated command-line programs with nested commands, lots of arguments, and flags for each command, you're better off with something beyond the rudimentary support of the flag package. This is where Cobra shines.

However, if you prefer to look for other alternatives besides Cobra, the Go community is happy to help. There are tens of packages and libraries for command-line parsing. I personally don't see any glaring issues with Cobra that motivate me to switch to another library. 

In case you're curious to check other alternatives, I recommend the awesome-go curated list of command-line parsing libraries: 
https://github.com/avelino/awesome-go#standard-cli


# Conclusion

Cobra is the gold standard when it comes to building command-line programs. It has a lot of strong capabilities, it is well designed, and it is used by many of the most popular Go command-line programs out there.

Let's install Cobra and learn how Cobra can be used either as a library or as an application generator.

Comparing Cobra to Alternatives

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Comparing Cobra to Alternatives