merges pull request by twmb/diff@c86783d24e76297f7a20a548c4e7ec4e9e93f9fb with minor changes

Author: mb0

README.md

@@ -8,7 +8,7 @@ The algorithm is described by Eugene Myers in
 
 Example
 -------
-You can use diff.Ints and diff.Runes
+You can use diff.Ints, diff.Runes, diff.Strings, and diff.Bytes
 
     diff.Runes([]rune("sögen"), []rune("mögen")) // returns []Changes{{0,0,1,1}}
 
@@ -27,4 +27,8 @@ and call
     m := &MixedInput{..}
     diff.Diff(len(m.A), len(m.B), m)
 
+Also has granularity functions to merge changes that are close by.
+
+    diff.GranularStrings("emtire", "umpire", 1) // returns []Changes{{0,0,3,3}}
+
 Documentation at http://godoc.org/github.com/mb0/diff

diff.go

@@ -13,6 +13,15 @@ type Data interface {
 	Equal(i, j int) bool
 }
 
+// ByteStrings returns the differences of two strings in bytes.
+func ByteStrings(a, b string) []Change {
+	return Diff(len(a), len(b), &strings{a, b})
+}
+
+type strings struct{ a, b string }
+
+func (d *strings) Equal(i, j int) bool { return d.a[i] == d.b[j] }
+
 // Bytes returns the difference of two byte slices
 func Bytes(a, b []byte) []Change {
 	return Diff(len(a), len(b), &bytes{a, b})
@@ -40,6 +49,31 @@ type runes struct{ a, b []rune }
 
 func (d *runes) Equal(i, j int) bool { return d.a[i] == d.b[j] }
 
+// Granular merges neighboring changes smaller than the specified granularity.
+// The changes must be ordered by ascending positions as returned by this package.
+func Granular(granularity int, changes []Change) []Change {
+	if len(changes) == 0 {
+		return changes
+	}
+	gap := 0
+	for i := 1; i < len(changes); i++ {
+		curr := changes[i]
+		prev := changes[i-gap-1]
+		// same as curr.B-(prev.B+prev.Ins); consistency is key
+		if curr.A-(prev.A+prev.Del) <= granularity {
+			// merge changes:
+			curr = Change{
+				A: prev.A, B: prev.B, // start at same spot
+				Del: curr.A - prev.A + curr.Del, // from first to end of second
+				Ins: curr.B - prev.B + curr.Ins, // from first to end of second
+			}
+			gap++
+		}
+		changes[i-gap] = curr
+	}
+	return changes[:len(changes)-gap : len(changes)-gap]
+}
+
 // Diff returns the differences of data.
 // data.Equal is called repeatedly with 0<=i<n and 0<=j<m
 func Diff(n, m int, data Data) []Change {

diff_test.go

@@ -2,63 +2,64 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package diff
+package diff_test
 
 import (
+	"github.com/mb0/diff"
 	"testing"
 )
 
 type testcase struct {
 	name string
 	a, b []int
-	res  []Change
+	res  []diff.Change
 }
 
 var tests = []testcase{
 	{"shift",
 		[]int{1, 2, 3},
 		[]int{0, 1, 2, 3},
-		[]Change{{0, 0, 0, 1}},
+		[]diff.Change{{0, 0, 0, 1}},
 	},
 	{"push",
 		[]int{1, 2, 3},
 		[]int{1, 2, 3, 4},
-		[]Change{{3, 3, 0, 1}},
+		[]diff.Change{{3, 3, 0, 1}},
 	},
 	{"unshift",
 		[]int{0, 1, 2, 3},
 		[]int{1, 2, 3},
-		[]Change{{0, 0, 1, 0}},
+		[]diff.Change{{0, 0, 1, 0}},
 	},
 	{"pop",
 		[]int{1, 2, 3, 4},
 		[]int{1, 2, 3},
-		[]Change{{3, 3, 1, 0}},
+		[]diff.Change{{3, 3, 1, 0}},
 	},
 	{"all changed",
 		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
 		[]int{10, 11, 12, 13, 14},
-		[]Change{
+		[]diff.Change{
 			{0, 0, 10, 5},
 		},
 	},
 	{"all same",
 		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
 		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-		[]Change{},
+		[]diff.Change{},
 	},
 	{"wrap",
 		[]int{1},
 		[]int{0, 1, 2, 3},
-		[]Change{
+		[]diff.Change{
 			{0, 0, 0, 1},
 			{1, 2, 0, 2},
 		},
 	},
 	{"snake",
 		[]int{0, 1, 2, 3, 4, 5},
 		[]int{1, 2, 3, 4, 5, 6},
-		[]Change{
+		[]diff.Change{
 			{0, 0, 1, 0},
 			{6, 5, 0, 1},
 		},
@@ -69,7 +70,7 @@ var tests = []testcase{
 	{"paper fig. 1",
 		[]int{1, 2, 3, 1, 2, 2, 1},
 		[]int{3, 2, 1, 2, 1, 3},
-		[]Change{
+		[]diff.Change{
 			{0, 0, 1, 1},
 			{2, 2, 1, 0},
 			{5, 4, 1, 0},
@@ -80,7 +81,7 @@ var tests = []testcase{
 
 func TestDiffAB(t *testing.T) {
 	for _, test := range tests {
-		res := Ints(test.a, test.b)
+		res := diff.Ints(test.a, test.b)
 		if len(res) != len(test.res) {
 			t.Error(test.name, "expected length", len(test.res), "for", res)
 			continue
@@ -95,36 +96,87 @@ func TestDiffAB(t *testing.T) {
 
 func TestDiffBA(t *testing.T) {
 	// interesting: fig.1 Diff(b, a) results in the same path as `diff -d a b`
-	tests[len(tests)-1].res = []Change{
+	tests[len(tests)-1].res = []diff.Change{
 		{0, 0, 2, 0},
 		{3, 1, 1, 0},
 		{5, 2, 0, 1},
 		{7, 5, 0, 1},
 	}
 	for _, test := range tests {
-		res := Ints(test.b, test.a)
+		res := diff.Ints(test.b, test.a)
 		if len(res) != len(test.res) {
 			t.Error(test.name, "expected length", len(test.res), "for", res)
 			continue
 		}
 		for i, c := range test.res {
 			// flip change data also
-			rc := Change{c.B, c.A, c.Ins, c.Del}
+			rc := diff.Change{c.B, c.A, c.Ins, c.Del}
 			if rc != res[i] {
 				t.Error(test.name, "expected ", rc, "got", res[i])
 			}
 		}
 	}
 }
 
+func diffsEqual(a, b []diff.Change) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := 0; i < len(a); i++ {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestGranularStrings(t *testing.T) {
+	a := "abcdefghijklmnopqrstuvwxyza"
+	b := "AbCdeFghiJklmnOpqrstUvwxyzab"
+	// each iteration of i increases granularity and will absorb one more lower-letter-followed-by-upper-letters sequence
+	changesI := [][]diff.Change{
+		{{0, 0, 1, 1}, {2, 2, 1, 1}, {5, 5, 1, 1}, {9, 9, 1, 1}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
+		{{0, 0, 3, 3}, {5, 5, 1, 1}, {9, 9, 1, 1}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
+		{{0, 0, 6, 6}, {9, 9, 1, 1}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
+		{{0, 0, 10, 10}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
+		{{0, 0, 15, 15}, {20, 20, 1, 1}, {27, 27, 0, 1}},
+		{{0, 0, 21, 21}, {27, 27, 0, 1}},
+		{{0, 0, 27, 28}},
+	}
+	for i := 0; i < len(changesI); i++ {
+		diffs := diff.Granular(i, diff.ByteStrings(a, b))
+		if !diffsEqual(diffs, changesI[i]) {
+			t.Errorf("expected %v, got %v", diffs, changesI[i])
+		}
+	}
+}
+
 func TestDiffRunes(t *testing.T) {
-	d := &runes{
-		[]rune("brown fox jumps over the lazy dog"),
-		[]rune("brwn faax junps ovver the lay dago"),
+	a := []rune("brown fox jumps over the lazy dog")
+	b := []rune("brwn faax junps ovver the lay dago")
+	res := diff.Runes(a, b)
+	echange := []diff.Change{
+		{2, 2, 1, 0},
+		{7, 6, 1, 2},
+		{12, 12, 1, 1},
+		{18, 18, 0, 1},
+		{27, 28, 1, 0},
+		{31, 31, 0, 2},
+		{32, 34, 1, 0},
 	}
-	n, m := len(d.a), len(d.b)
-	res := Diff(n, m, d)
-	echange := []Change{
+	for i, c := range res {
+		t.Log(c)
+		if c != echange[i] {
+			t.Error("expected", echange[i], "got", c)
+		}
+	}
+}
+
+func TestDiffByteStrings(t *testing.T) {
+	a := "brown fox jumps over the lazy dog"
+	b := "brwn faax junps ovver the lay dago"
+	res := diff.ByteStrings(a, b)
+	echange := []diff.Change{
 		{2, 2, 1, 0},
 		{7, 6, 1, 2},
 		{12, 12, 1, 1},
@@ -141,19 +193,47 @@ func TestDiffRunes(t *testing.T) {
 	}
 }
 
+type ints struct{ a, b []int }
+
+func (d *ints) Equal(i, j int) bool { return d.a[i] == d.b[j] }
 func BenchmarkDiff(b *testing.B) {
 	t := tests[len(tests)-1]
 	d := &ints{t.a, t.b}
 	n, m := len(d.a), len(d.b)
 	for i := 0; i < b.N; i++ {
-		Diff(n, m, d)
+		diff.Diff(n, m, d)
+	}
+}
+
+func BenchmarkInts(b *testing.B) {
+	t := tests[len(tests)-1]
+	d1 := t.a
+	d2 := t.b
+	for i := 0; i < b.N; i++ {
+		diff.Ints(d1, d2)
 	}
 }
 
 func BenchmarkDiffRunes(b *testing.B) {
-	d := &runes{[]rune("1231221"), []rune("321213")}
-	n, m := len(d.a), len(d.b)
+	d1 := []rune("1231221")
+	d2 := []rune("321213")
+	for i := 0; i < b.N; i++ {
+		diff.Runes(d1, d2)
+	}
+}
+
+func BenchmarkDiffBytes(b *testing.B) {
+	d1 := []byte("lorem ipsum dolor sit amet consectetur")
+	d2 := []byte("lorem lovesum daenerys targaryen ami consecteture")
+	for i := 0; i < b.N; i++ {
+		diff.Bytes(d1, d2)
+	}
+}
+
+func BenchmarkDiffByteStrings(b *testing.B) {
+	d1 := "lorem ipsum dolor sit amet consectetur"
+	d2 := "lorem lovesum daenerys targaryen ami consecteture"
 	for i := 0; i < b.N; i++ {
-		Diff(n, m, d)
+		diff.ByteStrings(d1, d2)
 	}
 }

example_test.go

@@ -9,23 +9,25 @@ import (
 	"github.com/mb0/diff"
 )
 
-var names = map[string]int{
-	"one":   1,
-	"two":   2,
-	"three": 3,
-}
-
 // Diff on inputs with different representations
 type MixedInput struct {
 	A []int
 	B []string
 }
 
+var names map[string]int
+
 func (m *MixedInput) Equal(a, b int) bool {
 	return m.A[a] == names[m.B[b]]
 }
 
-func ExampleInterface() {
+func ExampleDiff() {
+	names = map[string]int{
+		"one":   1,
+		"two":   2,
+		"three": 3,
+	}
+
 	m := &MixedInput{
 		[]int{1, 2, 3, 1, 2, 2, 1},
 		[]string{"three", "two", "one", "two", "one", "three"},
@@ -34,4 +36,22 @@ func ExampleInterface() {
 	for _, c := range changes {
 		fmt.Println("change at", c.A, c.B)
 	}
+	// Output:
+	// change at 0 0
+	// change at 2 2
+	// change at 5 4
+	// change at 7 5
+}
+
+func ExampleGranularStrings() {
+	a := "hElLo!"
+	b := "hello!"
+	changes := diff.Granular(5, diff.ByteStrings(a, b)) // ignore small gaps in differences
+	for l := len(changes) - 1; l >= 0; l-- {
+		change := changes[l]
+		b = b[:change.B] + "|" + b[change.B:change.B+change.Ins] + "|" + b[change.B+change.Ins:]
+	}
+	fmt.Println(b)
+	// Output:
+	// h|ell|o!
 }