Add LineReader and StringReader interfaces

LineReader is a wrapper around StringReader that counts line numbers.
This is not currently used by the parser, but will be used by the apply
functions.

Author: bluekeyes

gitdiff/io.go

@@ -0,0 +1,58 @@
+package gitdiff
+
+import (
+	"bufio"
+	"io"
+)
+
+// StringReader is the interface that wraps the ReadString method.
+type StringReader interface {
+	// ReadString reads until the first occurrence of delim in the input,
+	// returning a string containing the data up to and including the
+	// delimiter. If ReadString encounters an error before finding a delimiter,
+	// it returns the data read before the error and the error itself (often
+	// io.EOF). ReadString returns err != nil if and only if the returned data
+	// does not end in delim.
+	ReadString(delim byte) (string, error)
+}
+
+// LineReader is the interface that wraps the ReadLine method.
+type LineReader interface {
+	// ReadLine reads the next full line in the input, returing the the data
+	// including the line ending character(s) and the zero-indexed line number.
+	// If ReadLine encounters an error before reaching the end of the line, it
+	// returns the data read before the error and the error itself (often
+	// io.EOF). ReadLine returns err != nil if and only if the returned data is
+	// not a complete line.
+	//
+	// If the implementation defines other methods for reading the same input,
+	// line numbers may be incorrect if calls to ReadLine are mixed with calls
+	// to other read methods.
+	ReadLine() (string, int, error)
+}
+
+// NewLineReader returns a LineReader for a reader starting at a specific line
+// using the newline character, \n, as a line separator. If r is a
+// StringReader, it is used directly. Otherwise, it is wrapped in a way that
+// may read extra data from the underlying input.
+func NewLineReader(r io.Reader, lineno int) LineReader {
+	sr, ok := r.(StringReader)
+	if !ok {
+		sr = bufio.NewReader(r)
+	}
+	return &lineReader{r: sr, n: lineno}
+}
+
+type lineReader struct {
+	r StringReader
+	n int
+}
+
+func (lr *lineReader) ReadLine() (line string, lineno int, err error) {
+	lineno = lr.n
+	line, err = lr.r.ReadString('\n')
+	if err == nil {
+		lr.n++
+	}
+	return
+}

gitdiff/io_test.go

@@ -0,0 +1,57 @@
+package gitdiff
+
+import (
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestLineReader(t *testing.T) {
+	const content = "first line\nsecond line\nthird line\npartial fourth line"
+
+	t.Run("readLine", func(t *testing.T) {
+		r := NewLineReader(strings.NewReader(content), 0)
+
+		lines := []struct {
+			Data string
+			Err  error
+		}{
+			{"first line\n", nil},
+			{"second line\n", nil},
+			{"third line\n", nil},
+			{"partial fourth line", io.EOF},
+		}
+
+		for i, line := range lines {
+			d, n, err := r.ReadLine()
+			if err != line.Err {
+				if line.Err == nil {
+					t.Fatalf("error reading line: %v", err)
+				} else {
+					t.Fatalf("expected %v while reading line, but got %v", line.Err, err)
+				}
+			}
+			if d != line.Data {
+				t.Errorf("incorrect line data: expected %q, actual %q", line.Data, d)
+			}
+			if n != i {
+				t.Errorf("incorrect line number: expected %d, actual %d", i, n)
+			}
+		}
+	})
+
+	t.Run("readLineOffset", func(t *testing.T) {
+		r := NewLineReader(strings.NewReader(content), 10)
+
+		d, n, err := r.ReadLine()
+		if err != nil {
+			t.Fatalf("error reading line: %v", err)
+		}
+		if d != "first line\n" {
+			t.Errorf("incorrect line data: expected %q, actual %q", "first line\n", d)
+		}
+		if n != 10 {
+			t.Errorf("incorrect line number: expected %d, actual %d", 10, n)
+		}
+	})
+}

gitdiff/parser.go

@@ -4,14 +4,16 @@
 package gitdiff
 
 import (
-	"bufio"
 	"fmt"
 	"io"
 )
 
 // Parse parses a patch with changes to one or more files. Any content before
 // the first file is returned as the second value. If an error occurs while
 // parsing, it returns all files parsed before the error.
+//
+// If r is a LineReader or StringReader, it is used directly. Otherwise, it is
+// wrapped in a way that may read extra data from the underlying input.
 func Parse(r io.Reader) ([]*File, string, error) {
 	p := newParser(r)
 
@@ -67,23 +69,19 @@ func Parse(r io.Reader) ([]*File, string, error) {
 //     - if returning an object, advance to the first line after the object
 // - any exported parsing methods must initialize the parser by calling Next()
 
-type stringReader interface {
-	ReadString(delim byte) (string, error)
-}
-
 type parser struct {
-	r stringReader
+	r LineReader
 
 	eof    bool
 	lineno int64
 	lines  [3]string
 }
 
 func newParser(r io.Reader) *parser {
-	if r, ok := r.(stringReader); ok {
-		return &parser{r: r}
+	if lr, ok := r.(LineReader); ok {
+		return &parser{r: lr}
 	}
-	return &parser{r: bufio.NewReader(r)}
+	return &parser{r: NewLineReader(r, 0)}
 }
 
 // Next advances the parser by one line. It returns any error encountered while
@@ -119,7 +117,7 @@ func (p *parser) shiftLines() (err error) {
 	for i := 0; i < len(p.lines)-1; i++ {
 		p.lines[i] = p.lines[i+1]
 	}
-	p.lines[len(p.lines)-1], err = p.r.ReadString('\n')
+	p.lines[len(p.lines)-1], _, err = p.r.ReadLine()
 	return
 }