fetch default branch of a repo (#3)

* added check for main branch if master isn't found

* added code to fetch default branch for a repo, changed execute method's signature to return command output

* fixed main_test.go

* changed regex to extract default branch and fixed  main_test.go

* added multiwriter for Stdout to capture response

Author: krishnakowshik

cmd-git.go

@@ -4,41 +4,58 @@ package main
 
 import (
 	"fmt"
+	"regexp"
 )
 
 type gitRepo struct {
 	url string
 	dir string
 }
 
-func gitCmd(args ...string) error {
-	code := execute("git", args...)
+var re = regexp.MustCompile(`.*HEAD branch: (.*)\n`) // regex to extract default branch name of a repo
+
+func gitCmd(args ...string) (string, error) {
+	output, code := execute("git", args...)
 	if code != 0 {
-		return fmt.Errorf("git failed: exit code %d", code)
+		return "", fmt.Errorf("git failed: exit code %d", code)
 	}
-	return nil
+	return output, nil
 }
 
 func gitOpenDir(url, dir string) (repo, error) {
-	err := gitCmd("-C", dir, "rev-parse")
+	_, err := gitCmd("-C", dir, "rev-parse")
 	return &gitRepo{url: url, dir: dir}, err
 }
 
 func gitCloneDir(url, dir string) (repo, error) {
-	err := gitCmd("clone", "https://"+url, dir)
+	_, err := gitCmd("clone", "https://"+url, dir)
 	return &gitRepo{url: url, dir: dir}, err
 }
 
 func (r *gitRepo) Checkout(rev string) error {
-	if err := gitCmd("-C", r.dir, "checkout", "master"); err != nil {
+	output, err := gitCmd("-C", r.dir, "remote", "show", "origin")
+	if err != nil {
+		return err
+	}
+	defaultBranch := extractBranch(output)
+	if _, err := gitCmd("-C", r.dir, "checkout", defaultBranch); err != nil {
 		return err
 	}
 	if rev == "" || rev == latestRev {
 		rev = "HEAD"
 	}
-	return gitCmd("-C", r.dir, "checkout", "-q", rev)
+	_, err = gitCmd("-C", r.dir, "checkout", "-q", rev)
+	return err
 }
 
 func (r *gitRepo) Fetch() error {
-	return gitCmd("-C", r.dir, "pull")
+	_, err := gitCmd("-C", r.dir, "pull")
+	return err
+}
+
+func extractBranch(output string) string {
+	if !re.MatchString(output) {
+		return "master"
+	}
+	return re.FindStringSubmatch(output)[1]
 }

main.go

@@ -1,9 +1,11 @@
 package main
 
 import (
+	"bytes"
 	"crypto/md5"
 	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
 	"os"
@@ -179,20 +181,22 @@ func expandDirs(dirs []string) []string {
 }
 
 // execute runs a command with the provided arguments, using current stdio, and
-// returns command exit status (zero on success).
-func execute(exe string, args ...string) int {
+// returns command output and exit status (zero on success).
+func execute(exe string, args ...string) (string, int) {
 	cmd := exec.Command(exe, args...)
+	var stdoutBuf bytes.Buffer
 	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
+	cmd.Stdout = io.MultiWriter(os.Stdout, &stdoutBuf)
 	cmd.Stderr = os.Stderr
 	if err := cmd.Run(); err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
 			if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
-				return status.ExitStatus()
+				return "", status.ExitStatus()
 			}
 		}
 	}
-	return 0
+	output := string(stdoutBuf.Bytes())
+	return output, 0
 }
 
 // cacheDir returns a path to the local user cache using XDG base directory
@@ -262,10 +266,11 @@ func runProtoc() int {
 
 	files = expandDirs(files)
 	if len(files) == 0 {
-		return execute(protocExePath, args...)
+		_, err := execute(protocExePath, args...)
+		return err
 	}
 	for _, f := range files {
-		if exitCode := execute(protocExePath, append(args, f)...); exitCode != 0 {
+		if _, exitCode := execute(protocExePath, append(args, f)...); exitCode != 0 {
 			return exitCode
 		}
 	}

main_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"runtime"
 	"testing"
 )
@@ -10,13 +11,65 @@ func TestExecute(t *testing.T) {
 		t.Skip()
 	}
 
-	if exit := execute("true"); exit != 0 {
+	if _, exit := execute("true"); exit != 0 {
 		t.Fatal(exit)
 	}
-	if exit := execute("false"); exit != 1 {
+	if _, exit := execute("false"); exit != 1 {
 		t.Fatal(exit)
 	}
-	if exit := execute("sh", "-c", "exit 42"); exit != 42 {
+	if _, exit := execute("sh", "-c", "exit 42"); exit != 42 {
 		t.Fatal(exit)
 	}
 }
+func Test_extractBranchMaster(t *testing.T) {
+	output := `* remote origin
+  Fetch URL: git@github.com:foo/bar.git
+  Push  URL: git@github.com:foo/bar.git
+  HEAD branch: master
+  Remote branch:
+    master tracked
+  Local branch configured for 'git pull':
+    master merges with remote master
+  Local ref configured for 'git push':
+    master pushes to master (up to date)
+`
+	branch := extractBranch(output)
+	if branch != "master" {
+		t.Fatal("failed extracting branch")
+	}
+}
+func Test_extractBranchMain(t *testing.T) {
+	output := `* remote origin
+  Fetch URL: git@github.com:foo/bar.git
+  Push  URL: git@github.com:foo/bar.git
+  HEAD branch: main
+  Remote branch:
+    master tracked
+  Local branch configured for 'git pull':
+    master merges with remote master
+  Local ref configured for 'git push':
+    master pushes to master (up to date)
+`
+	branch := extractBranch(output)
+	fmt.Println("branch is ", branch)
+	if branch != "main" {
+		t.Fatal("failed extracting branch")
+	}
+}
+func Test_extractBranchDefaultMasterBranch(t *testing.T) {
+	output := `* remote origin
+  Fetch URL: git@github.com:foo/bar.git
+  Push  URL: git@github.com:foo/bar.git
+  HEAD branch:
+  Remote branch:
+    master tracked
+  Local branch configured for 'git pull':
+    master merges with remote master
+  Local ref configured for 'git push':
+    master pushes to master (up to date)
+`
+	branch := extractBranch(output)
+	if branch != "master" {
+		t.Fatal("failed extracting branch")
+	}
+}