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

# Creating an application skeleton with the Cobra generator

Let's start by creating an application called `calc-app`. We can skip the Viper configuration for now and use no license. Type the following command in the terminal below. You can use your name instead of `Gigi`

```
$ cobra init calc-app --pkg-name calc-app --license=none --viper=false --author= Gigi
```



Type the above command in the terminal below and explore the created `calc-app` directory and its contents.

If you type `tree calc-app` you should see the files and directories Cobra generated:

```
$ tree calc-app
calc-app
├── LICENSE
├── cmd
│   └── root.go
└── main.go
```

The `LICENSE` file is empty in this case, but you can choose another license if you want.

Let's start with `main.go`. It's super simple. It imports the calc-app/cmd package and invokes the Execute() function.

```
package main

import "calc-app/cmd"

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

Here is the root command. The comments are useful to understand how to extend it when adding new commands.

```
package cmd

import (
    ....
)

// rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{
	Use:   "calc-app",
	Short: "A brief description of your application",
	Long: `A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	// Uncomment the following line if your bare application
	// has an action associated with it:
	//	Run: func(cmd *cobra.Command, args []string) { },
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func init() {
	// Here you will define your flags and configuration settings.
	// Cobra supports persistent flags, which, if defined here,
	// will be global for your application.

	// rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.calc-app.yaml)")

	// Cobra also supports local flags, which will only run
	// when this action is called directly.
	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}
```
Let's see how to add subcommands.



Now, let's run the Cobra generator to generate a skeleton for our calculator demo application and examine the generated directory structure and code.

Creating an Application Skeleton With the Cobra Generator

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Creating an Application Skeleton With the Cobra Generator

Creating an application skeleton with the Cobra generator