object_writer: support different hashes

When we write an object, we'll need to know its hash in order to compute
the proper value.  Let's pass the caller the hash algorithm as well
as the writer to write to.

We don't need a generic set of options here because we're not likely to
gain additional options that affect our parsing of the object.  This is
the first format change in many years, so we can defer adding more
complex options until we need them.

Author: bk2204

object_db.go

@@ -294,7 +294,7 @@ func (d *ObjectDatabase) encodeBuffer(object Object, buf io.ReadWriter) (sha []b
 	}
 	defer d.cleanup(tmp)
 
-	to := NewObjectWriter(tmp)
+	to := NewObjectWriter(tmp, d.Hasher())
 	if _, err = to.WriteHeader(object.Type(), int64(cn)); err != nil {
 		return nil, 0, err
 	}

object_writer.go

@@ -2,7 +2,6 @@ package gitobj
 
 import (
 	"compress/zlib"
-	"crypto/sha1"
 	"fmt"
 	"hash"
 	"io"
@@ -50,18 +49,20 @@ func (n *nopCloser) Close() error {
 }
 
 // NewObjectWriter returns a new *ObjectWriter instance that drains incoming
-// writes into the io.Writer given, "w".
-func NewObjectWriter(w io.Writer) *ObjectWriter {
-	return NewObjectWriteCloser(&nopCloser{w})
+// writes into the io.Writer given, "w".  "hash" is a hash instance from the
+// ObjectDatabase'e Hash method.
+func NewObjectWriter(w io.Writer, hash hash.Hash) *ObjectWriter {
+	return NewObjectWriteCloser(&nopCloser{w}, hash)
 }
 
 // NewObjectWriter returns a new *ObjectWriter instance that drains incoming
-// writes into the io.Writer given, "w".
+// writes into the io.Writer given, "w".  "sum" is a hash instance from the
+// ObjectDatabase'e Hash method.
 //
 // Upon closing, it calls the given Close() function of the io.WriteCloser.
-func NewObjectWriteCloser(w io.WriteCloser) *ObjectWriter {
+func NewObjectWriteCloser(w io.WriteCloser, sum hash.Hash) *ObjectWriter {
 	zw := zlib.NewWriter(w)
-	sum := sha1.New()
+	sum.Reset()
 
 	return &ObjectWriter{
 		w:   io.MultiWriter(zw, sum),

object_writer_test.go

@@ -3,8 +3,11 @@ package gitobj
 import (
 	"bytes"
 	"compress/zlib"
+	"crypto/sha1"
+	"crypto/sha256"
 	"encoding/hex"
 	"errors"
+	"hash"
 	"io"
 	"io/ioutil"
 	"sync/atomic"
@@ -16,7 +19,7 @@ import (
 func TestObjectWriterWritesHeaders(t *testing.T) {
 	var buf bytes.Buffer
 
-	w := NewObjectWriter(&buf)
+	w := NewObjectWriter(&buf, sha1.New())
 
 	n, err := w.WriteHeader(BlobObjectType, 1)
 	assert.Equal(t, 7, n)
@@ -35,25 +38,40 @@ func TestObjectWriterWritesHeaders(t *testing.T) {
 }
 
 func TestObjectWriterWritesData(t *testing.T) {
-	var buf bytes.Buffer
+	testCases := []struct {
+		h   hash.Hash
+		sha string
+	}{
+		{
+			sha1.New(), "56a6051ca2b02b04ef92d5150c9ef600403cb1de",
+		},
+		{
+			sha256.New(), "36456d9b87f21fc54ed5babf1222a9ab0fbbd0c4ad239a7933522d5e4447049c",
+		},
+	}
 
-	w := NewObjectWriter(&buf)
-	w.WriteHeader(BlobObjectType, 1)
+	for _, test := range testCases {
+		var buf bytes.Buffer
 
-	n, err := w.Write([]byte{0x31})
-	assert.Equal(t, 1, n)
-	assert.Nil(t, err)
+		w := NewObjectWriter(&buf, test.h)
+		w.WriteHeader(BlobObjectType, 1)
 
-	assert.Nil(t, w.Close())
+		n, err := w.Write([]byte{0x31})
+		assert.Equal(t, 1, n)
+		assert.Nil(t, err)
 
-	r, err := zlib.NewReader(&buf)
-	assert.Nil(t, err)
+		assert.Nil(t, w.Close())
 
-	all, err := ioutil.ReadAll(r)
-	assert.Nil(t, err)
-	assert.Equal(t, []byte("blob 1\x001"), all)
+		r, err := zlib.NewReader(&buf)
+		assert.Nil(t, err)
 
-	assert.Nil(t, r.Close())
+		all, err := ioutil.ReadAll(r)
+		assert.Nil(t, err)
+		assert.Equal(t, []byte("blob 1\x001"), all)
+
+		assert.Nil(t, r.Close())
+		assert.Equal(t, test.sha, hex.EncodeToString(w.Sha()))
+	}
 }
 
 func TestObjectWriterPanicsOnWritesWithoutHeader(t *testing.T) {
@@ -64,7 +82,7 @@ func TestObjectWriterPanicsOnWritesWithoutHeader(t *testing.T) {
 		assert.Equal(t, "gitobj: cannot write data without header", err)
 	}()
 
-	w := NewObjectWriter(new(bytes.Buffer))
+	w := NewObjectWriter(new(bytes.Buffer), sha1.New())
 	w.Write(nil)
 }
 
@@ -76,19 +94,27 @@ func TestObjectWriterPanicsOnMultipleHeaderWrites(t *testing.T) {
 		assert.Equal(t, "gitobj: cannot write headers more than once", err)
 	}()
 
-	w := NewObjectWriter(new(bytes.Buffer))
+	w := NewObjectWriter(new(bytes.Buffer), sha1.New())
 	w.WriteHeader(BlobObjectType, 1)
 	w.WriteHeader(TreeObjectType, 2)
 }
 
 func TestObjectWriterKeepsTrackOfHash(t *testing.T) {
-	w := NewObjectWriter(new(bytes.Buffer))
+	w := NewObjectWriter(new(bytes.Buffer), sha1.New())
 	n, err := w.WriteHeader(BlobObjectType, 1)
 
 	assert.Nil(t, err)
 	assert.Equal(t, 7, n)
 
 	assert.Equal(t, "bb6ca78b66403a67c6281df142de5ef472186283", hex.EncodeToString(w.Sha()))
+
+	w = NewObjectWriter(new(bytes.Buffer), sha256.New())
+	n, err = w.WriteHeader(BlobObjectType, 1)
+
+	assert.Nil(t, err)
+	assert.Equal(t, 7, n)
+
+	assert.Equal(t, "3a68c454a6eb75cc55bda147a53756f0f581497eb80b9b67156fb8a8d3931cd7", hex.EncodeToString(w.Sha()))
 }
 
 type WriteCloserFn struct {
@@ -109,7 +135,7 @@ func TestObjectWriterCallsClose(t *testing.T) {
 			atomic.AddUint32(&calls, 1)
 			return expected
 		},
-	})
+	}, sha1.New())
 
 	got := w.Close()