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

# Analyzing the code

Before considering how to make the code better, let's go over the code piece by piece to understand what it does. There is just one file, `main.go`. The first part just declares the main package and the list of imports. All the packages come from the standard library, and there are no external dependencies here.

```
package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"strings"
	"os/exec"
)
```

There is also just one function, `main()`. That's pretty simple. The first thing the main function does is parse the command-line arguments using the `flag` standard library. There are two arguments: the command it will run and a Boolean flag that determines if errors should be ignored (to keep running on other repos if some repos fail. 

```
func main() {
	command := flag.String("command", "", "The git command")
	ignoreErros := flag.Bool(
		"ignore-errors",
		false,
		"Keep running after error if true")
	flag.Parse()
```

The next part is reading the environment variables and extracting the root of all repositories and the list of repository names. multi-git also checks if the repositories exist and if they are indeed a git repo.

```
	root := os.Getenv("MG_ROOT")
	if root[len(root) - 1] != '/' {
		root += "/"
	}

	repo_names := strings.Split(os.Getenv("MG_REPOS"), ",")
	var repos []string
	// Verify all repos exist and are actually git repos (have .git sub-dir)
	for _, r := range repo_names {
		path := root + r
		_, err := os.Stat(path + "/.git")
		if err != nil {
			log.Fatal(err)
		}
		repos = append(repos, path)
	}
```

The next part prepares the command it will execute and is even documented with a comment.

```
	// Break the git command into components (needed to execute)
	var git_components []string
	for _, component := range strings.Split(*command, " ") {
		git_components = append(git_components, component)
	}
	command_string := "git " + *command
```

Finally, multi-git iterates over all the repositories, executing the command in each one and printing the output. If there was an error and the user didn't ask to ignore errors then multi-git will exit. However, if it needs to ignore errors, it will simply continue to the next repo.

```
	for _, r := range repos {
		// Go to the repo's directory
		os.Chdir(r);

		// Print the command
		fmt.Printf("[%s] %s\n", r, command_string)

		// Execute the command
		out, err := exec.Command("git", git_components...).CombinedOutput()

		// Print the result
		fmt.Println(string(out))

		// Bail out if there was an error and NOT ignoring errors
		if err != nil && !*ignoreErros {
			os.Exit(1)
		}
	}

	fmt.Println("Done.")
}
```


In this lesson, we'll drill down and dissect the code of multi-git to get familiar with how it works. This lesson will also help you identify where and how to improve multi-git in the upcoming lessons.  

Analyzing Multi-git 0.1

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Analyzing Multi-git 0.1

Analyzing the code