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 `add` subcommand

Cobra is all about defining sub-commands. Let's start with the `add` subcommand. It will be defined in the `cmd/add.go` file:

```
package cmd

import (
	"fmt"
	"gigi/calc/pkg/calc"
	"github.com/spf13/cobra"
	"strconv"
)

var check bool

var addCmd = &cobra.Command{
	Use:   "add",
	Short: "Add two integers",
	Long:  `Add two integers a and b; result = a + b`,
	Args:  cobra.ExactArgs(2),
	Run: func(cmd *cobra.Command, args []string) {
		var a, b int
		var err error
		a, err = strconv.Atoi(args[0])
		if err != nil {
			panic("Arguments to `add` must be integers")
		}
		b, err = strconv.Atoi(args[1])
		if err != nil {
			panic("Arguments to `add` must be integers")
		}

		result := calc.Add(a, b, check)
		fmt.Println(result)
	},
}
```

Let's review its `Run` function. The signature includes the command itself, which functions the same way as a method receiver and a slice of arguments. The implementation converts the arguments to integers, panicking if they can't be converted. Then they call the calc's `Add()` function package and prints the result:

```
Run: func(cmd *cobra.Command, args []string) {
		var a, b int
		var err error
		a, err = strconv.Atoi(args[0])
		if err != nil {
			panic("Arguments to `add` must be integers")
		}
		b, err = strconv.Atoi(args[1])
		if err != nil {
			panic("Arguments to `add` must be integers")
		}

		result := calc.Add(a, b, check)
		fmt.Println(result)
	},
```

This is very similar to the root command, except that it has a Run function. In fact, all Cobra commands are the same. The fact that one command is the root command and the other subcommands or sub-subcommands is determined when wiring the commands together.


# The `subtract` sub-command

The `subtract` sub-command follows the exact same pattern:

```
package cmd

import (
	"fmt"
	"gigi/calc/pkg/calc"
	"github.com/spf13/cobra"
	"strconv"
)

var check bool

var subtractCmd = &cobra.Command{
	Use:   "subtract",
	Short: "Substract one integer from another",
	Long:  `Substract one integer a from another integer b; result = a -b`,
	Args:  cobra.ExactArgs(2),
	Run: func(cmd *cobra.Command, args []string) {
		var a, b int
		var err error
		a, err = strconv.Atoi(args[0])
		if err != nil {
			panic("Arguments to `subtract` must be integers")
		}
		b, err = strconv.Atoi(args[1])
		if err != nil {
			panic("Arguments to `subtract` must be integers")
		}

		result := calc.Subtract(a, b, check)
		fmt.Println(result)
	},
}
```

Now that we have subcommand, let's wire them together.

# Wiring commands

Wiring commands is very simple. To make command B and subcommand of command A, we just add B to A. The question is where to do this. One place to do this is in one central place to connect all the commands. Another approach, which I chose here, is to have each subcommand add itself to the root command. I defined for each subcommand an `init()` function that does the job. Here is the init() function of the `Add` command defined in `cmd/add.go`:

```
func init() {
	rootCmd.AddCommand(addCmd)
}
```

Don't be confused by `AddCommand()` and `addCmd`. The former is the method Cobra provides to wire up sub-commands. The latter is our calculator's command to add to integer, which is a Cobra command called `addComd`.


The `init()` function of the Subtract subcommand in `cmd/subtract.go` is virtually identical, except it connects the `Subtract` command to the root command:

```
func init() {
	rootCmd.AddCommand(subtractCmd)
}
```


But, who is calling this `init()` function and when? Well, `init()` functions are a special Go feature. All the `init()` functions in a package are executed by Go, itself after all the package variables have been initialized and most importantly before the `main()` function runs. This means that when `main()` runs all our subcommands are already wired up and ready.

At this point, our subcommands are connected to our root command. 

> Run the following application to see the effect of the added subcommands.


In this lesson, we’ll define two sub-commands for the calculator application: the `add` and `subtract` commands which look very similar and can serve as a pattern to define additional sub-commands. Then, we'll connect the subcommands to the root command.

Working with Cobra - The Sub-commands

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Working with Cobra - The Sub-commands

The `add` subcommand

Working with Cobra - The Sub-commands

The add subcommand

The `add` subcommand