Implement a much nicer diff view (#100)

* Implement a much nicer diff view

* Tweak colours

* Update tests

* Tweak TestRender to be less fragile

Author: FollowTheProcess

.golangci.yml

@@ -43,7 +43,7 @@ linters:
     - varnamelen # Lots of false positives of things that are fine
     - wrapcheck # Not every error must be wrapped
     - wsl # Very aggressive, some of this I like but tend to do anyway
-    - wsl_v5 # As above, just newer version
+    - mnd # Magic numbers are fine, context makes them clear
 
   exclusions:
     presets:
@@ -58,9 +58,6 @@ linters:
           - gosec # Tests don't need security stuff
           - goconst # Nah
 
-    paths:
-      - internal/diff
-
   settings:
     cyclop:
       max-complexity: 20

go.mod

@@ -1,15 +1,15 @@
 module go.followtheprocess.codes/test
 
-go 1.25.0
+go 1.26
 
 require (
-	go.followtheprocess.codes/hue v1.0.0
+	go.followtheprocess.codes/hue v1.1.0
 	go.followtheprocess.codes/snapshot v0.9.1
 	golang.org/x/tools v0.43.0
 )
 
 require (
 	go.yaml.in/yaml/v4 v4.0.0-rc.3 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/term v0.41.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/term v0.42.0 // indirect
 )

go.sum

@@ -1,12 +1,12 @@
-go.followtheprocess.codes/hue v1.0.0 h1:0fYXAGR1o+w7Vja+Q+iVtqeEP3/CE6ET/pniyl8e9yo=
-go.followtheprocess.codes/hue v1.0.0/go.mod h1:gSn5xK6KJapih+eFgQk3woo1qg3/rx9XSrAanUIuDr8=
+go.followtheprocess.codes/hue v1.1.0 h1:bPq21YLdWxQ0ki4lIvXCYtgutaGaDUYaSIENDdrrlNQ=
+go.followtheprocess.codes/hue v1.1.0/go.mod h1:VnCeVmYESGmX7fZJSFs59u8G+5zseCwGdFiJGHCFg4o=
 go.followtheprocess.codes/snapshot v0.9.1 h1:q90k4ZsV4WNrJkAXo6gLqYLgE3RipnzSOXU5o5Moyts=
 go.followtheprocess.codes/snapshot v0.9.1/go.mod h1:IKWetABJnYaG6rZAsINXAc6rB0TxoxdysBC3R2HvwWo=
 go.yaml.in/yaml/v4 v4.0.0-rc.3 h1:3h1fjsh1CTAPjW7q/EMe+C8shx5d8ctzZTrLcs/j8Go=
 go.yaml.in/yaml/v4 v4.0.0-rc.3/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
-golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
+golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
 golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
 golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=

internal/diff/chardiff_test.go

@@ -0,0 +1,287 @@
+package diff_test
+
+import (
+	"strings"
+	"testing"
+
+	"go.followtheprocess.codes/test/internal/diff"
+)
+
+func TestCharDiff(t *testing.T) {
+	tests := []struct {
+		name             string
+		removed          []byte
+		added            []byte
+		wantAllUnchanged bool // if true, expect all segments Changed:false (identical inputs)
+		wantHasChanged   bool // if true, expect at least one Changed:true segment on either side
+	}{
+		{
+			name:             "identical lines - all segments unchanged",
+			removed:          []byte("hello world\n"),
+			added:            []byte("hello world\n"),
+			wantAllUnchanged: true,
+		},
+		{
+			name:           "completely different",
+			removed:        []byte("abc\n"),
+			added:          []byte("xyz\n"),
+			wantHasChanged: true,
+		},
+		{
+			name:           "prefix change",
+			removed:        []byte("foobar\n"),
+			added:          []byte("bazbar\n"),
+			wantHasChanged: true,
+		},
+		{
+			name:           "suffix change",
+			removed:        []byte("hello world\n"),
+			added:          []byte("hello earth\n"),
+			wantHasChanged: true,
+		},
+		{
+			name:           "middle change",
+			removed:        []byte("hello world bye\n"),
+			added:          []byte("hello earth bye\n"),
+			wantHasChanged: true,
+		},
+		{
+			name:           "unicode",
+			removed:        []byte("héllo wörld\n"),
+			added:          []byte("héllo earth\n"),
+			wantHasChanged: true,
+		},
+		{
+			name:           "empty removed",
+			removed:        []byte(""),
+			added:          []byte("new content\n"),
+			wantHasChanged: true,
+		},
+		{
+			name:           "empty added",
+			removed:        []byte("old content\n"),
+			added:          []byte(""),
+			wantHasChanged: true,
+		},
+		{
+			name:             "both empty",
+			removed:          []byte(""),
+			added:            []byte(""),
+			wantAllUnchanged: true,
+		},
+		{
+			name:           "trailing newline preserved",
+			removed:        []byte("line\n"),
+			added:          []byte("changed\n"),
+			wantHasChanged: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := diff.CharDiff(tt.removed, tt.added)
+
+			assertJoinInvariant(t, result, tt.removed, tt.added)
+
+			if tt.wantAllUnchanged {
+				assertNoneChanged(t, result.Removed, "removed")
+				assertNoneChanged(t, result.Added, "added")
+			}
+
+			if tt.wantHasChanged {
+				if !anyChanged(result.Removed) && !anyChanged(result.Added) {
+					t.Error("CharDiff on differing inputs should produce at least one Changed segment")
+				}
+			}
+		})
+	}
+}
+
+// TestCharDiffCapTriggers verifies the > 500 rune safety cap produces a single-segment fallback.
+func TestCharDiffCapTriggers(t *testing.T) {
+	long := []byte(strings.Repeat("a", 501) + "\n")
+	other := []byte(strings.Repeat("b", 501) + "\n")
+
+	result := diff.CharDiff(long, other)
+
+	if len(result.Removed) != 1 {
+		t.Errorf("expected 1 removed segment for >500 rune input, got %d", len(result.Removed))
+	}
+
+	if len(result.Added) != 1 {
+		t.Errorf("expected 1 added segment for >500 rune input, got %d", len(result.Added))
+	}
+
+	if !result.Removed[0].Changed {
+		t.Error("expected removed fallback segment to be Changed:true")
+	}
+
+	if !result.Added[0].Changed {
+		t.Error("expected added fallback segment to be Changed:true")
+	}
+}
+
+// TestCharDiffNewlineNotHighlighted asserts that the trailing newline is never included in a
+// Changed segment. A highlighted \n causes the ANSI background colour to bleed onto the next
+// terminal line when rendered.
+func TestCharDiffNewlineNotHighlighted(t *testing.T) {
+	tests := []struct {
+		name    string
+		removed []byte
+		added   []byte
+	}{
+		{
+			name:    "suffix added",
+			removed: []byte("hello\n"),
+			added:   []byte("hello world\n"),
+		},
+		{
+			name:    "inline change with trailing newline",
+			removed: []byte("\treturn \"Hello, \" + name\n"),
+			added:   []byte("\treturn \"Hello, \" + name + \"!\"\n"),
+		},
+		{
+			name:    "completely different lines",
+			removed: []byte("abc\n"),
+			added:   []byte("xyz\n"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := diff.CharDiff(tt.removed, tt.added)
+
+			for i, seg := range result.Removed {
+				if seg.Changed && len(seg.Text) > 0 && seg.Text[len(seg.Text)-1] == '\n' {
+					t.Errorf("removed segment[%d] is Changed=true but ends with \\n; highlight would bleed onto next terminal line", i)
+				}
+			}
+
+			for i, seg := range result.Added {
+				if seg.Changed && len(seg.Text) > 0 && seg.Text[len(seg.Text)-1] == '\n' {
+					t.Errorf("added segment[%d] is Changed=true but ends with \\n; highlight would bleed onto next terminal line", i)
+				}
+			}
+		})
+	}
+}
+
+// TestCharDiffNotSameForDifferent verifies that differing inputs produce at least one Changed segment.
+func TestCharDiffNotSameForDifferent(t *testing.T) {
+	result := diff.CharDiff([]byte("hello\n"), []byte("world\n"))
+
+	hasChanged := false
+
+	for _, seg := range result.Removed {
+		if seg.Changed {
+			hasChanged = true
+			break
+		}
+	}
+
+	if !hasChanged {
+		for _, seg := range result.Added {
+			if seg.Changed {
+				hasChanged = true
+				break
+			}
+		}
+	}
+
+	if !hasChanged {
+		t.Error("CharDiff on different inputs should produce at least one Changed segment")
+	}
+}
+
+// BenchmarkCharDiff benchmarks the CharDiff function.
+func BenchmarkCharDiff(b *testing.B) {
+	removed := []byte("the quick brown fox jumps over the lazy dog\n")
+	added := []byte("the quick brown cat jumps over the lazy frog\n")
+
+	b.ResetTimer()
+
+	for b.Loop() {
+		diff.CharDiff(removed, added)
+	}
+}
+
+// FuzzCharDiff verifies CharDiff never panics, terminates, and produces segments
+// whose concatenation equals the original input on each side.
+func FuzzCharDiff(f *testing.F) {
+	f.Add([]byte("hello\n"), []byte("hello\n"))
+	f.Add([]byte("a\n"), []byte("b\n"))
+	f.Add([]byte("the quick brown fox\n"), []byte("the quick brown cat\n"))
+	f.Add([]byte(strings.Repeat("a", 10)+"\n"), []byte(strings.Repeat("b", 10)+"\n"))
+	f.Add([]byte("héllo\n"), []byte("wörld\n"))
+	f.Add([]byte(""), []byte("content\n"))
+	f.Add([]byte("content\n"), []byte(""))
+
+	f.Fuzz(func(t *testing.T, removed, added []byte) {
+		result := diff.CharDiff(removed, added)
+
+		// Invariant: segments must join back to original input.
+		if joinSegments(result.Removed) != string(removed) {
+			t.Fatalf("removed segments join = %q, want %q", joinSegments(result.Removed), string(removed))
+		}
+
+		if joinSegments(result.Added) != string(added) {
+			t.Fatalf("added segments join = %q, want %q", joinSegments(result.Added), string(added))
+		}
+
+		// Invariant: identical inputs → all segments Changed:false.
+		if string(removed) == string(added) {
+			for i, seg := range result.Removed {
+				if seg.Changed {
+					t.Fatalf("removed segment[%d] Changed=true for identical inputs", i)
+				}
+			}
+
+			for i, seg := range result.Added {
+				if seg.Changed {
+					t.Fatalf("added segment[%d] Changed=true for identical inputs", i)
+				}
+			}
+		}
+	})
+}
+
+func assertJoinInvariant(t *testing.T, result diff.InlineChange, removed, added []byte) {
+	t.Helper()
+
+	if got := joinSegments(result.Removed); got != string(removed) {
+		t.Errorf("removed segments join = %q, want %q", got, string(removed))
+	}
+
+	if got := joinSegments(result.Added); got != string(added) {
+		t.Errorf("added segments join = %q, want %q", got, string(added))
+	}
+}
+
+func assertNoneChanged(t *testing.T, segs []diff.Segment, side string) {
+	t.Helper()
+
+	for i, seg := range segs {
+		if seg.Changed {
+			t.Errorf("%s segment[%d] Changed=true, want false for identical inputs", side, i)
+		}
+	}
+}
+
+func anyChanged(segs []diff.Segment) bool {
+	for _, s := range segs {
+		if s.Changed {
+			return true
+		}
+	}
+
+	return false
+}
+
+func joinSegments(segs []diff.Segment) string {
+	var sb strings.Builder
+	for _, s := range segs {
+		sb.Write(s.Text)
+	}
+
+	return sb.String()
+}