.tools: Run 'go vet ...' on each commit

Instead of just checking the tip, run 'go vet ...' on each commit in
the series.  This makes sure we catch errors with earlier commits even
if they were fixed by subsequent commits.

The bulk of the complexity here is checking out a previous commit's
tree to a temporary directory, which is handled by the new
GitCheckoutTree.  I'd expect Git to be able to checkout an arbitrary
tree to an arbitrary directory, but strangely it doesn't seem to be
able to do that without side effects involving HEAD or the index.
Instead, I call 'git archive ...' and pipe the results into tar to do
the unpacking.  You *can* unpack an archive using native Go, but there
didn't seem to be a convenient tar.Reader.Extract(directory string)
method.  Shelling out to tar seemed more robust than writing a few
dozen lines of Go, so that's what I've done.  I'd expect shelling out
is less portable, but we really only need this to run on Travis'
Ubuntu environment [1].  We can work out a more portable approach
if/when we need to support this script on a system without a
compatible 'tar' command.

[1]: http://docs.travis-ci.com/user/ci-environment/#Virtualization-environments

Signed-off-by: W. Trevor King <wking@tremily.us>

Author: wking

.tools/validate.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
+	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -39,6 +41,9 @@ var DefaultRules = []ValidateRule{
 		return vr
 	},
 	// TODO add something for the cleanliness of the c.Subject
+	func(c CommitEntry) (vr ValidateResult) {
+		return ExecTree(c, "go", "vet", "./...")
+	},
 }
 
 var (
@@ -229,3 +234,75 @@ func GitHeadCommit() (string, error) {
 	}
 	return strings.TrimSpace(string(output)), nil
 }
+
+// GitCheckoutTree extracts the tree associated with the given commit
+// to the given directory.  Unlike 'git checkout ...', it does not
+// alter the HEAD.
+func GitCheckoutTree(commit string, directory string) error {
+	pipeReader, pipeWriter := io.Pipe()
+	gitCmd := exec.Command("git", "archive", commit)
+	gitCmd.Stdout = pipeWriter
+	gitCmd.Stderr = os.Stderr
+	tarCmd := exec.Command("tar", "-xC", directory)
+	tarCmd.Stdin = pipeReader
+	tarCmd.Stderr = os.Stderr
+	err := gitCmd.Start()
+	if err != nil {
+		return err
+	}
+	defer gitCmd.Process.Kill()
+	err = tarCmd.Start()
+	if err != nil {
+		return err
+	}
+	defer tarCmd.Process.Kill()
+	err = gitCmd.Wait()
+	if err != nil {
+		return err
+	}
+	err = pipeWriter.Close()
+	if err != nil {
+		return err
+	}
+	err = tarCmd.Wait()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// ExecTree executes a command in a checkout of the commit's tree,
+// wrapping any errors in a ValidateResult object.
+func ExecTree(c CommitEntry, args ...string) (vr ValidateResult) {
+	vr.CommitEntry = c
+	err := execTree(c, args...)
+	if err == nil {
+		vr.Pass = true
+		vr.Msg = strings.Join(args, " ")
+	} else {
+		vr.Pass = false
+		vr.Msg = fmt.Sprintf("%s : %s", strings.Join(args, " "), err.Error())
+	}
+	return vr
+}
+
+// execTree executes a command in a checkout of the commit's tree
+func execTree(c CommitEntry, args ...string) error {
+	dir, err := ioutil.TempDir("", "go-validate-")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(dir)
+	err = GitCheckoutTree(c["commit"], dir)
+	if err != nil {
+		return err
+	}
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Dir = dir
+	cmd.Stderr = os.Stderr
+	err = cmd.Run()
+	if err != nil {
+		return err
+	}
+	return nil
+}

.travis.yml

@@ -12,7 +12,6 @@ before_install:
 install: true
 
 script:
-  - go vet -x ./...
   - $HOME/gopath/bin/golint ./...
   - go run .tools/validate.go -range ${TRAVIS_COMMIT_RANGE}