Improve conflict error detection

Conflict errors are now represented by an exported type that is
compatible with errors.Is instead of using the method defined on
ApplyError. This makes the tests slightly cleaner and should be more
idiomatic for clients.

Author: bluekeyes

gitdiff/apply.go

@@ -5,10 +5,31 @@ import (
 	"io"
 )
 
-type conflictError string
+// Conflict indicates an apply failed due to a conflict between the patch and
+// the source content.
+//
+// Users can test if an error was caused by a conflict by using errors.Is with
+// an empty Conflict:
+//
+//     if errors.Is(err, &Conflict{}) {
+//	       // handle conflict
+//     }
+//
+type Conflict struct {
+	msg string
+}
 
-func (e conflictError) Error() string {
-	return "conflict: " + string(e)
+func (c *Conflict) Error() string {
+	return "conflict: " + c.msg
+}
+
+// Is implements error matching for Conflict. Passing an empty instance of
+// Conflict always returns true.
+func (c *Conflict) Is(other error) bool {
+	if other, ok := other.(*Conflict); ok {
+		return other.msg == "" || other.msg == c.msg
+	}
+	return false
 }
 
 // ApplyError wraps an error that occurs during patch application with
@@ -29,13 +50,6 @@ func (e *ApplyError) Unwrap() error {
 	return e.err
 }
 
-// Conflict returns true if the error is due to a conflict between the fragment
-// and the source data.
-func (e *ApplyError) Conflict() bool {
-	_, ok := e.err.(conflictError)
-	return ok
-}
-
 func (e *ApplyError) Error() string {
 	return fmt.Sprintf("%v", e.err)
 }
@@ -152,7 +166,7 @@ func applyTextLine(dst io.Writer, src string, line Line) (err error) {
 	switch line.Op {
 	case OpContext, OpDelete:
 		if src != line.Line {
-			return conflictError("fragment line does not match src line")
+			return &Conflict{"fragment line does not match src line"}
 		}
 	}
 	switch line.Op {
@@ -176,9 +190,9 @@ func copyLines(dst io.Writer, src LineReader, limit int64) (string, int64, error
 			return line, n, err
 		case n > limit:
 			if limit < 0 {
-				return "", n, conflictError("cannot create new file from non-empty src")
+				return "", n, &Conflict{"cannot create new file from non-empty src"}
 			}
-			return "", n, conflictError("fragment overlaps with an applied fragment")
+			return "", n, &Conflict{"fragment overlaps with an applied fragment"}
 		case err != nil:
 			if err == io.EOF {
 				err = io.ErrUnexpectedEOF

gitdiff/apply_test.go

@@ -2,9 +2,10 @@ package gitdiff
 
 import (
 	"bytes"
+	"errors"
+	"io"
 	"io/ioutil"
 	"path/filepath"
-	"strings"
 	"testing"
 )
 
@@ -15,7 +16,7 @@ func TestTextFragmentApplyStrict(t *testing.T) {
 		PatchFile string
 		DstFile   string
 
-		Err string
+		Err error
 	}{
 		"createFile": {File: "text_fragment_new"},
 		"deleteFile": {File: "text_fragment_delete_all"},
@@ -34,27 +35,27 @@ func TestTextFragmentApplyStrict(t *testing.T) {
 		"errorShortSrcBefore": {
 			SrcFile:   "text_fragment_error",
 			PatchFile: "text_fragment_error_short_src_before",
-			Err:       "unexpected EOF",
+			Err:       io.ErrUnexpectedEOF,
 		},
 		"errorShortSrc": {
 			SrcFile:   "text_fragment_error",
 			PatchFile: "text_fragment_error_short_src",
-			Err:       "unexpected EOF",
+			Err:       io.ErrUnexpectedEOF,
 		},
 		"errorContextConflict": {
 			SrcFile:   "text_fragment_error",
 			PatchFile: "text_fragment_error_context_conflict",
-			Err:       "conflict",
+			Err:       &Conflict{},
 		},
 		"errorDeleteConflict": {
 			SrcFile:   "text_fragment_error",
 			PatchFile: "text_fragment_error_delete_conflict",
-			Err:       "conflict",
+			Err:       &Conflict{},
 		},
 		"errorNewFile": {
 			SrcFile:   "text_fragment_error",
 			PatchFile: "text_fragment_error_new_file",
-			Err:       "conflict",
+			Err:       &Conflict{},
 		},
 	}
 
@@ -75,7 +76,7 @@ func TestTextFragmentApplyStrict(t *testing.T) {
 			patch := loadFile(test.PatchFile, test.File, "patch")
 
 			var result []byte
-			if test.Err == "" {
+			if test.Err == nil {
 				result = loadFile(test.DstFile, test.File, "dst")
 			}
 
@@ -88,12 +89,12 @@ func TestTextFragmentApplyStrict(t *testing.T) {
 
 			var dst bytes.Buffer
 			err = frag.ApplyStrict(&dst, NewLineReader(bytes.NewReader(src), 0))
-			if test.Err != "" {
+			if test.Err != nil {
 				if err == nil {
 					t.Fatalf("expected error applying fragment, but got nil")
 				}
-				if !strings.Contains(err.Error(), test.Err) {
-					t.Fatalf("incorrect apply error: expected %q, actual %q", test.Err, err.Error())
+				if !errors.Is(err, test.Err) {
+					t.Fatalf("incorrect apply error: expected: %T (%v), actual: %T (%v)", test.Err, test.Err, err, err)
 				}
 				return
 			}