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 }