package server
import (
"html"
"html/template"
"net/url"
"sort"
"strconv"
"strings"
"gitlab.com/Timfa/bluegit/internal/gitrepo"
"gitlab.com/Timfa/bluegit/internal/highlight"
)
// largeChange is het aantal toegevoegde en verwijderde regels waarna een diff dicht blijft.
const largeChange = 200
// CommitDiff is de diff van één commit.
type CommitDiff struct {
Parents []ParentSHA
Files []CommitFile
Tree []CommitTreeRow
Added, Deleted, FilesN int
}
// ParentSHA is een parent van de commit.
type ParentSHA struct {
SHA, Short string
}
// CommitFile is één gewijzigd bestand, in unified en side-by-side vorm.
type CommitFile struct {
Path, OldPath, Status, Anchor, FileURL string
Added, Deleted int
Binary, Collapsed, HasBody bool
Lines []CommitLine
Pairs []CommitPair
}
// CommitLine is één unified diffregel. HTML is al geëscaped.
type CommitLine struct {
Kind string
Old int
New int
HTML template.HTML
Notes []NoteRow
}
// CommitPair is één rij in de naast-elkaar-weergave.
type CommitPair struct {
Hunk string
LKind, RKind string
LNo, RNo int
LHTML, RHTML template.HTML
}
// CommitTreeRow is een map of bestand in de boom.
type CommitTreeRow struct {
Name, Path, Anchor, Status, Icon string
Dir bool
Depth, Added, Deleted int
}
func presentCommitDiff(repoPath, sha string, parents []string, files []gitrepo.PatchFile) *CommitDiff {
d := &CommitDiff{}
for _, p := range parents {
if !safeSHA(p) {
continue
}
d.Parents = append(d.Parents, ParentSHA{SHA: p, Short: shortSHA(p)})
}
parent := ""
if len(d.Parents) > 0 {
parent = d.Parents[0].SHA
}
seen := map[string]int{}
for _, f := range files {
if f.Path == "" {
continue
}
cf := CommitFile{
Path: f.Path, OldPath: f.OldPath, Status: f.Status,
Added: f.Added, Deleted: f.Deleted, Binary: f.Binary,
Anchor: diffAnchor(f.Path, seen),
Collapsed: !f.Binary && f.Added+f.Deleted > largeChange,
}
linkPath := f.Path
linkRev := sha
if f.Status == "deleted" {
linkPath = f.Path
linkRev = parent
}
if linkRev != "" {
cf.FileURL = blobLink(repoPath, linkRev, linkPath)
}
if f.Binary || len(f.Lines) > 0 {
cf.HasBody = true
}
if !f.Binary && len(f.Lines) > 0 {
name := f.Path
if f.Status == "deleted" {
name = f.Path
}
painter := highlight.NewPainter(name)
for _, ln := range f.Lines {
row := CommitLine{Kind: ln.Kind, Old: ln.Old, New: ln.New}
if ln.Kind == "hunk" {
row.HTML = template.HTML(html.EscapeString(ln.Text))
} else {
row.HTML = template.HTML(painter.Line(ln.Text))
}
cf.Lines = append(cf.Lines, row)
}
cf.Pairs = pairDiff(cf.Lines)
}
d.Added += cf.Added
d.Deleted += cf.Deleted
d.Files = append(d.Files, cf)
}
d.FilesN = len(d.Files)
d.Tree = commitTree(d.Files)
return d
}
func pairDiff(lines []CommitLine) []CommitPair {
var out []CommitPair
for i := 0; i < len(lines); {
ln := lines[i]
if ln.Kind == "hunk" {
out = append(out, CommitPair{Hunk: html.UnescapeString(string(ln.HTML))})
i++
continue
}
if ln.Kind == "ctx" {
out = append(out, CommitPair{
LKind: "ctx", RKind: "ctx", LNo: ln.Old, RNo: ln.New, LHTML: ln.HTML, RHTML: ln.HTML,
})
i++
continue
}
var dels, adds []CommitLine
for i < len(lines) && lines[i].Kind == "del" {
dels = append(dels, lines[i])
i++
}
for i < len(lines) && lines[i].Kind == "add" {
adds = append(adds, lines[i])
i++
}
n := len(dels)
if len(adds) > n {
n = len(adds)
}
for k := 0; k < n; k++ {
p := CommitPair{}
if k < len(dels) {
p.LKind = "del"
p.LNo = dels[k].Old
p.LHTML = dels[k].HTML
}
if k < len(adds) {
p.RKind = "add"
p.RNo = adds[k].New
p.RHTML = adds[k].HTML
}
out = append(out, p)
}
}
return out
}
func diffAnchor(path string, seen map[string]int) string {
var b strings.Builder
b.WriteString("diff-")
for _, r := range path {
switch {
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '-', r == '_':
b.WriteRune(r)
default:
b.WriteByte('-')
}
}
base := b.String()
n := seen[base]
seen[base]++
if n == 0 {
return base
}
return base + "-" + strconv.Itoa(n)
}
func blobLink(repoPath, rev, path string) string {
parts := strings.Split(path, "/")
for i, p := range parts {
parts[i] = url.PathEscape(p)
}
return "/" + repoPath + "/-/blob/" + strings.Join(parts, "/") + "?rev=" + url.QueryEscape(rev)
}
func commitTree(files []CommitFile) []CommitTreeRow {
root := &treeNode{kids: map[string]*treeNode{}}
for i := range files {
f := &files[i]
parts := strings.Split(f.Path, "/")
cur := root
acc := ""
for j, part := range parts {
if acc == "" {
acc = part
} else {
acc += "/" + part
}
n := cur.kids[part]
if n == nil {
n = &treeNode{name: part, path: acc, kids: map[string]*treeNode{}}
cur.kids[part] = n
cur.order = append(cur.order, part)
}
if j == len(parts)-1 {
n.file = f
} else {
n.dir = true
}
cur = n
}
}
var rows []CommitTreeRow
var walk func(n *treeNode, depth int)
walk = func(n *treeNode, depth int) {
names := append([]string(nil), n.order...)
sort.Slice(names, func(i, j int) bool {
a, b := n.kids[names[i]], n.kids[names[j]]
aDir := a.dir && a.file == nil
bDir := b.dir && b.file == nil
if aDir != bDir {
return aDir
}
return strings.ToLower(a.name) < strings.ToLower(b.name)
})
for _, name := range names {
child := n.kids[name]
shown := depth
if shown > 8 {
shown = 8
}
if child.dir && child.file == nil {
rows = append(rows, CommitTreeRow{
Name: child.name, Path: child.path, Dir: true, Depth: shown, Icon: "dir",
})
walk(child, depth+1)
continue
}
f := child.file
rows = append(rows, CommitTreeRow{
Name: child.name, Path: f.Path, Anchor: f.Anchor, Status: f.Status,
Depth: shown, Added: f.Added, Deleted: f.Deleted, Icon: fileIcon(child.name, "blob"),
})
}
}
walk(root, 0)
return rows
}
type treeNode struct {
name, path string
dir bool
file *CommitFile
kids map[string]*treeNode
order []string
}