run 'go get -u; make revendor'

Signed-off-by: Stephan Renatus <srenatus@chef.io>

vendor/github.com/kylelemons/godebug/diff/diff.go

@@ -31,6 +31,10 @@ type Chunk struct {
 	Equal   []string
 }
 
+func (c *Chunk) empty() bool {
+	return len(c.Added) == 0 && len(c.Deleted) == 0 && len(c.Equal) == 0
+}
+
 // Diff returns a string containing a line-by-line unified diff of the linewise
 // changes required to make A into B.  Each line is prefixed with '+', '-', or
 // ' ' to indicate if it should be added, removed, or is correct respectively.
@@ -58,76 +62,125 @@ func Diff(A, B string) string {
 // DiffChunks uses an O(D(N+M)) shortest-edit-script algorithm
 // to compute the edits required from A to B and returns the
 // edit chunks.
-func DiffChunks(A, B []string) []Chunk {
+func DiffChunks(a, b []string) []Chunk {
 	// algorithm: http://www.xmailserver.org/diff2.pdf
 
-	N, M := len(A), len(B)
-	MAX := N + M
-	V := make([]int, 2*MAX+1)
-	Vs := make([][]int, 0, 8)
+	// We'll need these quantities a lot.
+	alen, blen := len(a), len(b) // M, N
 
-	var D int
+	// At most, it will require len(a) deletions and len(b) additions
+	// to transform a into b.
+	maxPath := alen + blen // MAX
+	if maxPath == 0 {
+		// degenerate case: two empty lists are the same
+		return nil
+	}
+
+	// Store the endpoint of the path for diagonals.
+	// We store only the a index, because the b index on any diagonal
+	// (which we know during the loop below) is aidx-diag.
+	// endpoint[maxPath] represents the 0 diagonal.
+	//
+	// Stated differently:
+	// endpoint[d] contains the aidx of a furthest reaching path in diagonal d
+	endpoint := make([]int, 2*maxPath+1) // V
+
+	saved := make([][]int, 0, 8) // Vs
+	save := func() {
+		dup := make([]int, len(endpoint))
+		copy(dup, endpoint)
+		saved = append(saved, dup)
+	}
+
+	var editDistance int // D
 dLoop:
-	for D = 0; D <= MAX; D++ {
-		for k := -D; k <= D; k += 2 {
-			var x int
-			if k == -D || (k != D && V[MAX+k-1] < V[MAX+k+1]) {
-				x = V[MAX+k+1]
-			} else {
-				x = V[MAX+k-1] + 1
+	for editDistance = 0; editDistance <= maxPath; editDistance++ {
+		// The 0 diag(onal) represents equality of a and b.  Each diagonal to
+		// the left is numbered one lower, to the right is one higher, from
+		// -alen to +blen.  Negative diagonals favor differences from a,
+		// positive diagonals favor differences from b.  The edit distance to a
+		// diagonal d cannot be shorter than d itself.
+		//
+		// The iterations of this loop cover either odds or evens, but not both,
+		// If odd indices are inputs, even indices are outputs and vice versa.
+		for diag := -editDistance; diag <= editDistance; diag += 2 { // k
+			var aidx int // x
+			switch {
+			case diag == -editDistance:
+				// This is a new diagonal; copy from previous iter
+				aidx = endpoint[maxPath-editDistance+1] + 0
+			case diag == editDistance:
+				// This is a new diagonal; copy from previous iter
+				aidx = endpoint[maxPath+editDistance-1] + 1
+			case endpoint[maxPath+diag+1] > endpoint[maxPath+diag-1]:
+				// diagonal d+1 was farther along, so use that
+				aidx = endpoint[maxPath+diag+1] + 0
+			default:
+				// diagonal d-1 was farther (or the same), so use that
+				aidx = endpoint[maxPath+diag-1] + 1
 			}
-			y := x - k
-			for x < N && y < M && A[x] == B[y] {
-				x++
-				y++
+			// On diagonal d, we can compute bidx from aidx.
+			bidx := aidx - diag // y
+			// See how far we can go on this diagonal before we find a difference.
+			for aidx < alen && bidx < blen && a[aidx] == b[bidx] {
+				aidx++
+				bidx++
 			}
-			V[MAX+k] = x
-			if x >= N && y >= M {
-				Vs = append(Vs, append(make([]int, 0, len(V)), V...))
+			// Store the end of the current edit chain.
+			endpoint[maxPath+diag] = aidx
+			// If we've found the end of both inputs, we're done!
+			if aidx >= alen && bidx >= blen {
+				save() // save the final path
 				break dLoop
 			}
 		}
-		Vs = append(Vs, append(make([]int, 0, len(V)), V...))
+		save() // save the current path
 	}
-	if D == 0 {
+	if editDistance == 0 {
 		return nil
 	}
-	chunks := make([]Chunk, D+1)
+	chunks := make([]Chunk, editDistance+1)
 
-	x, y := N, M
-	for d := D; d > 0; d-- {
-		V := Vs[d]
-		k := x - y
-		insert := k == -d || (k != d && V[MAX+k-1] < V[MAX+k+1])
+	x, y := alen, blen
+	for d := editDistance; d > 0; d-- {
+		endpoint := saved[d]
+		diag := x - y
+		insert := diag == -d || (diag != d && endpoint[maxPath+diag-1] < endpoint[maxPath+diag+1])
 
-		x1 := V[MAX+k]
+		x1 := endpoint[maxPath+diag]
 		var x0, xM, kk int
 		if insert {
-			kk = k + 1
-			x0 = V[MAX+kk]
+			kk = diag + 1
+			x0 = endpoint[maxPath+kk]
 			xM = x0
 		} else {
-			kk = k - 1
-			x0 = V[MAX+kk]
+			kk = diag - 1
+			x0 = endpoint[maxPath+kk]
 			xM = x0 + 1
 		}
 		y0 := x0 - kk
 
 		var c Chunk
 		if insert {
-			c.Added = B[y0:][:1]
+			c.Added = b[y0:][:1]
 		} else {
-			c.Deleted = A[x0:][:1]
+			c.Deleted = a[x0:][:1]
 		}
 		if xM < x1 {
-			c.Equal = A[xM:][:x1-xM]
+			c.Equal = a[xM:][:x1-xM]
 		}
 
 		x, y = x0, y0
 		chunks[d] = c
 	}
 	if x > 0 {
-		chunks[0].Equal = A[:x]
+		chunks[0].Equal = a[:x]
+	}
+	if chunks[0].empty() {
+		chunks = chunks[1:]
+	}
+	if len(chunks) == 0 {
+		return nil
 	}
 	return chunks
 }