add contents method for git-cat-file

cmd/git-sg/catfile.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/hex"
+	"fmt"
 	"io"
 	"log"
 	"os"
@@ -19,6 +20,11 @@ type gitCatFileBatch struct {
 	inCloser  io.Closer
 	out       *bufio.Reader
 	outCloser io.Closer
+
+	// readerN is the amount left to read for Read. Note: git-cat-file always
+	// has a trailing new line, so this will always be the size of an object +
+	// 1.
+	readerN int64
 }
 
 func startGitCatFileBatch(dir string) (_ *gitCatFileBatch, err error) {
@@ -74,6 +80,42 @@ func (g *gitCatFileBatch) Info(ref string) (gitCatFileBatchInfo, error) {
 		return gitCatFileBatchInfo{}, err
 	}
 
+	if err := g.discard(); err != nil {
+		g.kill()
+		return gitCatFileBatchInfo{}, err
+	}
+
+	line, err := g.out.ReadSlice('\n')
+	if err != nil {
+		g.kill()
+		return gitCatFileBatchInfo{}, err
+	}
+
+	info, err := parseGitCatFileBatchInfoLine(line)
+	if err != nil {
+		g.kill()
+		return gitCatFileBatchInfo{}, err
+	}
+
+	g.readerN = 0
+
+	return info, nil
+}
+
+func (g *gitCatFileBatch) Contents(ref string) (gitCatFileBatchInfo, error) {
+	g.in.WriteString("contents ")
+	g.in.WriteString(ref)
+	g.in.WriteByte('\n')
+	if err := g.in.Flush(); err != nil {
+		g.kill()
+		return gitCatFileBatchInfo{}, err
+	}
+
+	if err := g.discard(); err != nil {
+		g.kill()
+		return gitCatFileBatchInfo{}, err
+	}
+
 	line, err := g.out.ReadSlice('\n')
 	if err != nil {
 		g.kill()
@@ -86,16 +128,45 @@ func (g *gitCatFileBatch) Info(ref string) (gitCatFileBatchInfo, error) {
 		return gitCatFileBatchInfo{}, err
 	}
 
+	g.readerN = info.Size + 1
+
 	return info, nil
 }
 
+func (g *gitCatFileBatch) Read(p []byte) (n int, err error) {
+	// We avoid reading the final byte (a newline). That will be handled by
+	// discard.
+	if g.readerN <= 1 {
+		return 0, io.EOF
+	}
+	if max := g.readerN - 1; int64(len(p)) > max {
+		p = p[0:max]
+	}
+	n, err = g.out.Read(p)
+	g.readerN -= int64(n)
+	return
+}
+
+// discard should be called before parsing a response to flush out any unread
+// data since the last command.
+func (g *gitCatFileBatch) discard() error {
+	if g.readerN > 0 {
+		n, err := g.out.Discard(int(g.readerN))
+		g.readerN -= int64(n)
+		return err
+	}
+	return nil
+}
+
 // parseGitCatFileBatchInfoLine parses the info line from git-cat-file. It
 // expects the default format of:
 //
 //  <oid> SP <type> SP <size> LF
 func parseGitCatFileBatchInfoLine(line []byte) (gitCatFileBatchInfo, error) {
 	line = bytes.TrimRight(line, "\n")
+	origLine := line
 
+	// PERF this allocates much less than bytes.Split
 	next := func() []byte {
 		i := bytes.IndexByte(line, ' ')
 		if i < 0 {
@@ -113,17 +184,17 @@ func parseGitCatFileBatchInfoLine(line []byte) (gitCatFileBatchInfo, error) {
 	var err error
 	_, err = hex.Decode(info.Hash[:], next())
 	if err != nil {
-		return info, err
+		return info, fmt.Errorf("unexpected git-cat-file --batch info line %q: %w", string(origLine), err)
 	}
 
 	info.Type, err = plumbing.ParseObjectType(string(next()))
 	if err != nil {
-		return info, err
+		return info, fmt.Errorf("unexpected git-cat-file --batch info line %q: %w", string(origLine), err)
 	}
 
 	info.Size, err = strconv.ParseInt(string(next()), 10, 64)
 	if err != nil {
-		return info, err
+		return info, fmt.Errorf("unexpected git-cat-file --batch info line %q: %w", string(origLine), err)
 	}
 
 	return info, nil
@@ -136,6 +207,10 @@ func (g *gitCatFileBatch) Close() (err error) {
 		}
 	}()
 
+	if err := g.discard(); err != nil {
+		return err
+	}
+
 	// This Close will tell git to shutdown
 	if err := g.inCloser.Close(); err != nil {
 		return err

cmd/git-sg/catfile_test.go

@@ -1,6 +1,12 @@
 package main
 
-import "testing"
+import (
+	"io"
+	"testing"
+
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/google/go-cmp/cmp"
+)
 
 func TestInfo(t *testing.T) {
 	p, err := startGitCatFileBatch("")
@@ -21,6 +27,56 @@ func TestInfo(t *testing.T) {
 	}
 }
 
+func TestContents(t *testing.T) {
+	p, err := startGitCatFileBatch("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer p.Close()
+
+	info, err := p.Contents("HEAD")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(info.Hash, info.Type, info.Size)
+
+	b, err := io.ReadAll(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(string(b))
+
+	if len(b) != int(info.Size) {
+		t.Fatalf("amount read (%d) is different to object size (%d)", len(b), info.Size)
+	}
+	if info.Type != plumbing.CommitObject {
+		t.Fatalf("expected HEAD to be a commit, got %s", info.Type)
+	}
+
+	// Now lets fetch the object again via hash and see if it stays the same.
+	info2, err := p.Contents(info.Hash.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if d := cmp.Diff(info, info2); d != "" {
+		t.Fatalf("info changed (-first, +second):\n%s", d)
+	}
+
+	b2, err := io.ReadAll(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if d := cmp.Diff(b, b2); d != "" {
+		t.Fatalf("content changed (-first, +second):\n%s", d)
+	}
+
+	if err := p.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func BenchmarkInfo(b *testing.B) {
 	p, err := startGitCatFileBatch("")
 	if err != nil {