Files
summercms/modules/cabana/mail_diff.go
Jakub Zych 83f76cc3f7 feat(cabana): mail layouts and partials screens with reset, drift and custom layouts
- Layouts and partials controllers with catalog scoping, reset action and File version diff
- Custom layout create/delete with in-use refusal; meta.deletable and customized/outdated row states
- List schema golden fixtures updated for the two new row-state message keys

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-13 12:33:20 +01:00

125 lines
3.4 KiB
Go

package cabana
// diffKind is what one line of a line diff is.
type diffKind int
const (
// diffCtx is a line both sides have.
diffCtx diffKind = iota
// diffAdd is a line only the new side has.
diffAdd
// diffDel is a line only the old side has.
diffDel
// diffGap stands for unchanged lines left out between two hunks.
diffGap
)
// diffLine is one line of a line diff.
type diffLine struct {
Kind diffKind
Text string
}
// diffMaxLines caps each side of a line diff: above it no diff is computed
// (the LCS table grows with the product of the sides), and the File version
// tab shows the file content alone.
const diffMaxLines = 2000
// lineDiff is the unified line diff from a (old) to b (new) with context
// unchanged lines around each change, computed with a longest common
// subsequence over the lines after trimming the common prefix and suffix.
// Unchanged runs longer than twice the context are cut to a diffGap line. It
// returns nil when the sides are equal and when either side has more than
// diffMaxLines lines.
func lineDiff(a, b []string, context int) []diffLine {
if len(a) > diffMaxLines || len(b) > diffMaxLines {
return nil
}
if context < 0 {
context = 0
}
prefix := 0
for prefix < len(a) && prefix < len(b) && a[prefix] == b[prefix] {
prefix++
}
suffix := 0
for suffix < len(a)-prefix && suffix < len(b)-prefix && a[len(a)-1-suffix] == b[len(b)-1-suffix] {
suffix++
}
if prefix == len(a) && prefix == len(b) {
return nil
}
ma, mb := a[prefix:len(a)-suffix], b[prefix:len(b)-suffix]
n, m := len(ma), len(mb)
// lcs[i*(m+1)+j] is the LCS length of ma[i:] and mb[j:]; both sides are
// capped at diffMaxLines, so the value fits in 16 bits.
lcs := make([]uint16, (n+1)*(m+1))
at := func(i, j int) uint16 { return lcs[i*(m+1)+j] }
for i := n - 1; i >= 0; i-- {
for j := m - 1; j >= 0; j-- {
switch {
case ma[i] == mb[j]:
lcs[i*(m+1)+j] = at(i+1, j+1) + 1
case at(i+1, j) >= at(i, j+1):
lcs[i*(m+1)+j] = at(i+1, j)
default:
lcs[i*(m+1)+j] = at(i, j+1)
}
}
}
full := make([]diffLine, 0, len(a)+len(b))
for _, line := range a[:prefix] {
full = append(full, diffLine{Kind: diffCtx, Text: line})
}
i, j := 0, 0
for i < n || j < m {
switch {
case i < n && j < m && ma[i] == mb[j]:
full = append(full, diffLine{Kind: diffCtx, Text: ma[i]})
i++
j++
case j < m && (i == n || at(i, j+1) > at(i+1, j)):
full = append(full, diffLine{Kind: diffAdd, Text: mb[j]})
j++
default:
full = append(full, diffLine{Kind: diffDel, Text: ma[i]})
i++
}
}
for _, line := range a[len(a)-suffix:] {
full = append(full, diffLine{Kind: diffCtx, Text: line})
}
return hunks(full, context)
}
// hunks keeps the changed lines of a full diff and up to context unchanged
// lines on each side of them; every other run of unchanged lines becomes
// one diffGap line, except at the start and the end, where it is dropped.
func hunks(full []diffLine, context int) []diffLine {
keep := make([]bool, len(full))
for idx, line := range full {
if line.Kind == diffCtx {
continue
}
for k := idx - context; k <= idx+context; k++ {
if k >= 0 && k < len(full) {
keep[k] = true
}
}
}
out := make([]diffLine, 0, len(full))
gap := false
for idx, line := range full {
if keep[idx] {
if gap && len(out) > 0 {
out = append(out, diffLine{Kind: diffGap})
}
gap = false
out = append(out, line)
continue
}
gap = true
}
return out
}