commit.go: support multi-line header continuations

When Git wishes to continue one or more of a commit's extra headers on
more than a single line, it writes out the following:

  parent: <SHA-1>
  tree: <SHA-1>
  gpgsig: -----BEGIN PGP SIGNATURE-----
   <signature>
   -----END PGP SIGNATURE-----

Our current parsing implementation does not handle this correctly, based
on a misunderstanding that one line is equivalent to one extra header,
and vice versa.

In fact, the situation presently is even more dire than not parsing the
'gpgsig' header incorrectly: we'll split the signature end ending line
into their own "headers" and in doing so trim off the leading
whitespace. In practice, this means that we can corrupt commits when
round-tripping them in many interesting ways [1].

To address the situation, we do two things:

  1. Teach gitobj that when we are parsing extra headers for a commit,
     _and_ a header line begins with a single whitespace character, we
     are in fact continuing the last known header.

  2. Likewise, teach gitobj that when encoding a commit which has an
     extra header whose value contains a LF character, replace each LF
     with a leading space, to round trip commits of this form
     successfully.

Together, (1) and (2) means that we parse the 'gpgsig' header in the
above example as a _single_ entry in the commit's 'ExtraHeaders' field,
as expected.

[1]: git-lfs/git-lfs#3530

Author: ttaylorr

commit.go

@@ -132,10 +132,23 @@ func (c *Commit) Decode(from io.Reader, size int64) (n int, err error) {
 					c.Committer = ""
 				}
 			default:
-				c.ExtraHeaders = append(c.ExtraHeaders, &ExtraHeader{
-					K: fields[0],
-					V: strings.Join(fields[1:], " "),
-				})
+				if strings.HasPrefix(s.Text(), " ") {
+					idx := len(c.ExtraHeaders) - 1
+					hdr := c.ExtraHeaders[idx]
+
+					// Append the line of text (removing the
+					// leading space) to the last header
+					// that we parsed, adding a newline
+					// between the two.
+					hdr.V = strings.Join(append(
+						[]string{hdr.V}, s.Text()[1:],
+					), "\n")
+				} else {
+					c.ExtraHeaders = append(c.ExtraHeaders, &ExtraHeader{
+						K: fields[0],
+						V: strings.Join(fields[1:], " "),
+					})
+				}
 			}
 		} else {
 			messageParts = append(messageParts, s.Text())
@@ -177,7 +190,8 @@ func (c *Commit) Encode(to io.Writer) (n int, err error) {
 	n = n + n2
 
 	for _, hdr := range c.ExtraHeaders {
-		n3, err := fmt.Fprintf(to, "%s %s\n", hdr.K, hdr.V)
+		n3, err := fmt.Fprintf(to, "%s %s\n",
+			hdr.K, strings.Replace(hdr.V, "\n", "\n ", -1))
 		if err != nil {
 			return n, err
 		}

commit_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCommitReturnsCorrectObjectType(t *testing.T) {
@@ -20,6 +21,8 @@ func TestCommitEncoding(t *testing.T) {
 	author := &Signature{Name: "John Doe", Email: "john@example.com", When: time.Now()}
 	committer := &Signature{Name: "Jane Doe", Email: "jane@example.com", When: time.Now()}
 
+	sig := "-----BEGIN PGP SIGNATURE-----\n<signature>\n-----END PGP SIGNATURE-----"
+
 	c := &Commit{
 		Author:    author.String(),
 		Committer: committer.String(),
@@ -29,6 +32,7 @@ func TestCommitEncoding(t *testing.T) {
 		TreeID: []byte("cccccccccccccccccccc"),
 		ExtraHeaders: []*ExtraHeader{
 			{"foo", "bar"},
+			{"gpgsig", sig},
 		},
 		Message: "initial commit",
 	}
@@ -44,6 +48,9 @@ func TestCommitEncoding(t *testing.T) {
 	assertLine(t, buf, "author %s", author.String())
 	assertLine(t, buf, "committer %s", committer.String())
 	assertLine(t, buf, "foo bar")
+	assertLine(t, buf, "gpgsig -----BEGIN PGP SIGNATURE-----")
+	assertLine(t, buf, " <signature>")
+	assertLine(t, buf, " -----END PGP SIGNATURE-----")
 	assertLine(t, buf, "")
 	assertLine(t, buf, "initial commit")
 
@@ -164,6 +171,41 @@ func TestCommitDecodingWithWhitespace(t *testing.T) {
 	assert.Equal(t, "tree <- initial commit", commit.Message)
 }
 
+func TestCommitDecodingMultilineHeader(t *testing.T) {
+	author := &Signature{Name: "", Email: "john@example.com", When: time.Now()}
+	committer := &Signature{Name: "", Email: "jane@example.com", When: time.Now()}
+
+	treeId := []byte("cccccccccccccccccccc")
+
+	from := new(bytes.Buffer)
+
+	fmt.Fprintf(from, "author %s\n", author)
+	fmt.Fprintf(from, "committer %s\n", committer)
+	fmt.Fprintf(from, "tree %s\n", hex.EncodeToString(treeId))
+	fmt.Fprintf(from, "gpgsig -----BEGIN PGP SIGNATURE-----\n")
+	fmt.Fprintf(from, " <signature>\n")
+	fmt.Fprintf(from, " -----END PGP SIGNATURE-----\n")
+	fmt.Fprintf(from, "\ninitial commit\n")
+
+	flen := from.Len()
+
+	commit := new(Commit)
+	n, err := commit.Decode(from, int64(flen))
+
+	require.Nil(t, err)
+	require.Equal(t, flen, n)
+	require.Len(t, commit.ExtraHeaders, 1)
+
+	hdr := commit.ExtraHeaders[0]
+
+	assert.Equal(t, "gpgsig", hdr.K)
+	assert.EqualValues(t, []string{
+		"-----BEGIN PGP SIGNATURE-----",
+		"<signature>",
+		"-----END PGP SIGNATURE-----"},
+		strings.Split(hdr.V, "\n"))
+}
+
 func assertLine(t *testing.T, buf *bytes.Buffer, wanted string, args ...interface{}) {
 	got, err := buf.ReadString('\n')
 	if err == io.EOF {