BlueGit

timfa bluegit

Files

bluegit / internal / server / mr_page.go

mr_page.go

feat: geef de merge-request-pagina een header en widget
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed 0892d994 History
mr_page.go 14.4 KiB Download Raw
1package server
2
3import (
4 "context"
5 "html/template"
6 "net/http"
7 "sort"
8 "strconv"
9 "strings"
10 "time"
11
12 "gitlab.com/Timfa/bluegit/internal/access"
13 "gitlab.com/Timfa/bluegit/internal/gitrepo"
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15 "gitlab.com/Timfa/bluegit/internal/markdown"
16 "gitlab.com/Timfa/bluegit/internal/store"
17)
18
19func (s *Server) compare(w http.ResponseWriter, r *http.Request) {
20 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
21 if !ok {
22 return
23 }
24 v := s.repoView(w, r, repo, role, "branch.compare")
25 v.Title = s.tr(r, "branch.compare")
26 v.Page = "compare"
27 v.Wide = true
28 s.fillBranchChoices(r, &v, repo)
29 from := safeRev(r.URL.Query().Get("from"), repo.DefaultBranch)
30 to := safeRev(r.URL.Query().Get("to"), "")
31 s.fillCompare(r, &v, repo, from, to)
32 s.render(w, "compare", v)
33}
34
35func (s *Server) newMR(w http.ResponseWriter, r *http.Request) {
36 _, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
37 if !ok {
38 return
39 }
40 if !role.CanWriteCode() {
41 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
42 return
43 }
44 v := s.repoView(w, r, repo, role, "mr.create")
45 v.Title = s.tr(r, "mr.create")
46 v.Page = "newmr"
47 v.Wide = true
48 s.fillBranchChoices(r, &v, repo)
49 source := safeRev(r.URL.Query().Get("source"), "")
50 target := safeRev(r.URL.Query().Get("target"), repo.DefaultBranch)
51 if source == "" {
52 for _, b := range v.Branches {
53 if b.Name != target {
54 source = b.Name
55 break
56 }
57 }
58 }
59 s.fillCompare(r, &v, repo, target, source)
60 v.CompareFrom = source
61 v.CompareTo = target
62 s.fillTpl(r, repo, "mr", &v.FormBody, &v.TplPick, &v.DescTpls)
63 s.render(w, "newmr", v)
64}
65
66func (s *Server) previewMarkdown(w http.ResponseWriter, r *http.Request) {
67 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
68 if !ok || !s.csrfOK(w, r) {
69 return
70 }
71 if u.ID == 0 {
72 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
73 return
74 }
75 body := r.FormValue("body")
76 if len(body) > 20000 {
77 body = body[:20000]
78 }
79 w.Header().Set("Content-Type", "text/html; charset=utf-8")
80 _, _ = w.Write([]byte(markdown.RenderTasks(body, "", "", "/"+repo.FullPath(), markdown.Tasks{Count: s.tr(r, "tpl.tasks")})))
81}
82
83func (s *Server) updateMR(w http.ResponseWriter, r *http.Request) {
84 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
85 if !ok || !s.csrfOK(w, r) {
86 return
87 }
88 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
89 if err != nil {
90 http.NotFound(w, r)
91 return
92 }
93 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
94 if _, err := s.opUpdateMR(r.Context(), u, repo, n, r.FormValue("title"), r.FormValue("description"), r.FormValue("labels")); !s.uiOK(w, r, back, err) {
95 return
96 }
97 s.redirect(w, r, back, s.tr(r, "flash.mrUpdated"), "")
98}
99
100func (s *Server) finishMR(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, u store.User) {
101 canText := mr.Status == "open" && u.ID != 0 && (u.ID == mr.AuthorID || v.CanWrite)
102 v.DescHTML = template.HTML(markdown.RenderTasks(mr.Description, "", "", "/"+repo.FullPath(), s.taskOpt(r, v.CSRF, repo, "mr", strconv.FormatInt(mr.Number, 10), canText)))
103 v.Labels = splitLabels(mr.Labels)
104 v.CanEditMR = canText
105 switch r.URL.Query().Get("tab") {
106 case "commits", "pipelines", "changes":
107 v.Tab = r.URL.Query().Get("tab")
108 default:
109 v.Tab = "overview"
110 }
111 s.fillCompare(r, v, repo, mr.TargetBranch, mr.SourceBranch)
112 raw, _ := s.Store.ListNotes(r.Context(), mr.ID)
113 rows := buildNoteRows(raw, s.langOf(r), noteRender{
114 RepoPath: "/" + repo.FullPath(), Post: repoURL(repo) + "/-/tasks", CSRF: v.CSRF,
115 Count: s.tr(r, "tpl.tasks"), Toggle: s.tr(r, "tpl.toggle"), ViewerID: u.ID,
116 })
117 v.Notes = stampNotes(v.CommitDiff, rows)
118 s.fillTimeline(r, v, repo, mr, rows)
119 s.fillMRBanner(r, v, repo, mr)
120}
121
122func (s *Server) fillBranchChoices(r *http.Request, v *View, repo store.Repo) {
123 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
124 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
125 for _, name := range names {
126 v.Branches = append(v.Branches, BranchRow{Name: name, Default: name == repo.DefaultBranch})
127 }
128 tags, _ := gitrepo.Tags(r.Context(), s.Git, dir)
129 for _, name := range tags {
130 v.Tags = append(v.Tags, TagRow{Name: name})
131 }
132}
133
134// fillCompare vult commits (from..to) en de three-dot diff (from...to).
135func (s *Server) fillCompare(r *http.Request, v *View, repo store.Repo, from, to string) {
136 v.CompareFrom = from
137 v.CompareTo = to
138 if from == "" || to == "" || from == to {
139 return
140 }
141 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
142 commits, err := gitrepo.Log(r.Context(), s.Git, dir, from+".."+to, 50)
143 if err == nil && len(commits) > 0 {
144 v.Commits = s.presentCommits(r.Context(), repo.ID, commits, s.langOf(r))
145 if len(commits) == 1 {
146 v.FormTitle = commits[0].Subject
147 }
148 }
149 if v.FormTitle == "" {
150 v.FormTitle = s.tr(r, "mr.mergeTitle", to, from)
151 }
152 files, err := gitrepo.ComparePatch(r.Context(), s.Git, dir, from, to)
153 if err == nil {
154 v.CommitDiff = presentCommitDiff(repo.FullPath(), to, nil, files)
155 }
156 if stat, err := gitrepo.DiffStat(r.Context(), s.Git, dir, from, to); err == nil {
157 v.Diff = stat
158 }
159}
160
161func (s *Server) fillTimeline(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest, rows []NoteRow) {
162 lang := s.langOf(r)
163 known := map[string]store.User{}
164 who := func(name string) (string, string) {
165 shown, _, url := s.actorOf(r, name, known)
166 return shown, url
167 }
168 opened, openedURL := who(mr.Author)
169 items := []TimelineItem{{
170 Kind: "opened", Actor: opened, ActorURL: openedURL, Text: s.tr(r, "mr.opened"),
171 When: i18n.FormatDate(lang, mr.CreatedAt), At: mr.CreatedAt, Rank: 0,
172 }}
173 events, _ := s.Store.ListMREvents(r.Context(), mr.ID)
174 for _, e := range events {
175 key := mrEventKey(e.Kind)
176 if key == "" {
177 continue
178 }
179 actor, actorURL := who(e.Actor)
180 body := e.Body
181 if e.Kind == "merged" && shaLike(strings.TrimSpace(body)) {
182 body = ""
183 }
184 items = append(items, TimelineItem{
185 Kind: e.Kind, Actor: actor, ActorURL: actorURL, Text: s.tr(r, key), Body: body,
186 When: i18n.FormatDate(lang, e.CreatedAt), At: e.CreatedAt, Rank: 2,
187 })
188 }
189 revs, _ := s.Store.ListReviews(r.Context(), mr.ID)
190 for _, rev := range revs {
191 actor, actorURL := who(rev.Username)
192 items = append(items, TimelineItem{
193 Kind: "review", Actor: actor, ActorURL: actorURL, Text: s.tr(r, "rev."+rev.Status),
194 When: i18n.FormatDate(lang, rev.UpdatedAt), At: rev.UpdatedAt, Rank: 3,
195 })
196 }
197 pipes, _ := s.Store.PipelinesForMR(r.Context(), repo.ID, mr.ID)
198 for _, p := range pipes {
199 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
200 status := displayStatus(p.Status, jobs)
201 label := s.tr(r, "pipe."+status)
202 row := s.pipeRow(r, lang, repo, p, known, s.queueRanks(r.Context()))
203 v.PipeRows = append(v.PipeRows, row)
204 items = append(items, TimelineItem{
205 Kind: "pipeline", Actor: row.Actor, ActorURL: row.ActorURL,
206 Text: s.tr(r, "mr.pipeEvent", p.ID, label),
207 URL: repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10),
208 When: i18n.FormatDate(lang, p.CreatedAt), At: p.CreatedAt, Rank: 1,
209 })
210 }
211 for _, n := range rows {
212 if n.ParentID != 0 {
213 continue
214 }
215 item := TimelineItem{
216 ID: n.ID, Kind: "comment", Actor: n.Author, ActorURL: n.AuthorURL, Text: s.tr(r, "mr.commented"),
217 HTML: n.HTML, When: n.When, At: n.At, Rank: 4,
218 }
219 for _, rp := range n.Replies {
220 item.Replies = append(item.Replies, TimelineItem{Actor: rp.Author, ActorURL: rp.AuthorURL, HTML: rp.HTML, When: rp.When})
221 }
222 items = append(items, item)
223 }
224 sort.SliceStable(items, func(i, j int) bool {
225 if items[i].At.Equal(items[j].At) {
226 return items[i].Rank < items[j].Rank
227 }
228 return items[i].At.Before(items[j].At)
229 })
230 v.Timeline = items
231}
232
233func mrEventKey(kind string) string {
234 switch kind {
235 case "pushed":
236 return "mr.pushed"
237 case "retitled":
238 return "mr.retitled"
239 case "relabeled":
240 return "mr.relabeled"
241 case "merged":
242 return "mr.mergedEvent"
243 case "forced":
244 return "mr.forcedEvent"
245 case "closed":
246 return "mr.closedEvent"
247 case "reopened":
248 return "mr.reopenedEvent"
249 default:
250 return ""
251 }
252}
253
254func stampNotes(diff *CommitDiff, rows []NoteRow) []NoteRow {
255 placed := map[int64]bool{}
256 if diff != nil {
257 for i := range diff.Files {
258 for j := range diff.Files[i].Lines {
259 ln := &diff.Files[i].Lines[j]
260 if ln.New == 0 {
261 continue
262 }
263 for _, note := range rows {
264 if note.ParentID != 0 {
265 continue
266 }
267 if note.Path == diff.Files[i].Path && note.End == ln.New {
268 ln.Notes = append(ln.Notes, note)
269 placed[note.ID] = true
270 }
271 }
272 }
273 }
274 }
275 var general []NoteRow
276 for _, note := range rows {
277 if note.ParentID != 0 {
278 continue
279 }
280 if note.Path == "" || !placed[note.ID] {
281 general = append(general, note)
282 }
283 }
284 return general
285}
286
287func splitLabels(raw string) []string {
288 var out []string
289 for _, part := range strings.Split(raw, ",") {
290 part = strings.TrimSpace(part)
291 if part != "" {
292 out = append(out, part)
293 }
294 }
295 return out
296}
297
298func normalizeLabels(raw string) string {
299 return strings.Join(splitLabels(raw), ", ")
300}
301
302func (s *Server) recordMRPushes(repo store.Repo, user store.User, branch, before, after string) {
303 if s.StoragePath() == "" || branch == "" || after == "" {
304 return
305 }
306 ctx := context.Background()
307 mrs, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)
308 if err != nil || len(mrs) == 0 {
309 return
310 }
311 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
312 rev := after
313 limit := 1
314 if before != "" && strings.Trim(before, "0") != "" {
315 rev = before + ".." + after
316 limit = 20
317 }
318 subjects, err := gitrepo.Subjects(ctx, s.Git, dir, rev, limit)
319 if err != nil || len(subjects) == 0 {
320 return
321 }
322 body := strings.Join(subjects, "\n")
323 for _, mr := range mrs {
324 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "pushed", body)
325 }
326}
327
328// MRBanner is the header and the counts on a merge request.
329type MRBanner struct {
330 State, StateLabel string
331 WhenLabel string
332 Author, AuthorURL, Avatar string
333 Initial string
334 CommitPhrase string
335 NCommits, NPipes, NChanges int
336 MergedBy, MergedByURL string
337 MergedDate string
338 MergeSHA, MergeShort string
339}
340
341func (s *Server) fillMRBanner(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest) {
342 lang := s.langOf(r)
343 state := mr.Status
344 if state == "" {
345 state = "open"
346 }
347 label := s.tr(r, "mr.state."+state)
348 if label == "mr.state."+state {
349 label = state
350 }
351 b := &MRBanner{State: state, StateLabel: label}
352 when := mr.CreatedAt
353 whenKey := "mr.when.created"
354 var merger string
355 var mergeAt time.Time
356 var mergeSHA string
357 events, _ := s.Store.ListMREvents(r.Context(), mr.ID)
358 for _, e := range events {
359 if e.Kind != "merged" {
360 continue
361 }
362 merger = e.Actor
363 mergeAt = e.CreatedAt
364 if shaLike(strings.TrimSpace(e.Body)) {
365 mergeSHA = strings.TrimSpace(e.Body)
366 }
367 }
368 switch state {
369 case "merged":
370 whenKey = "mr.when.merged"
371 if !mergeAt.IsZero() {
372 when = mergeAt
373 } else if !mr.UpdatedAt.IsZero() {
374 when = mr.UpdatedAt
375 }
376 b.MergedDate = i18n.FormatDate(lang, when)
377 if merger != "" {
378 b.MergedBy = merger
379 if u, err := s.Store.UserByUsername(r.Context(), merger); err == nil && u.ID != 0 {
380 b.MergedBy = u.Username
381 b.MergedByURL = "/users/" + u.Username
382 }
383 }
384 if mergeSHA == "" {
385 mergeSHA = s.mergeCommitSHA(r.Context(), repo, mr)
386 }
387 if shaLike(mergeSHA) {
388 b.MergeSHA = mergeSHA
389 b.MergeShort = mergeSHA
390 if len(mergeSHA) > 8 {
391 b.MergeShort = mergeSHA[:8]
392 }
393 }
394 case "closed":
395 whenKey = "mr.when.closed"
396 if !mr.UpdatedAt.IsZero() {
397 when = mr.UpdatedAt
398 }
399 }
400 b.WhenLabel = s.tr(r, whenKey, i18n.Ago(lang, when.Unix()))
401 if mr.Author != "" {
402 b.Author = mr.Author
403 b.Initial = initialOf(mr.Author)
404 if u, err := s.Store.UserByUsername(r.Context(), mr.Author); err == nil && u.ID != 0 {
405 b.Author = u.Username
406 b.AuthorURL = "/users/" + u.Username
407 b.Avatar = u.AvatarURL
408 b.Initial = initialOf(u.Username)
409 }
410 }
411 n := s.commitCount(r.Context(), repo, mr.TargetBranch, mr.SourceBranch)
412 if state == "merged" && shaLike(mergeSHA) && (n == 0 || len(v.Commits) == 0 || v.CommitDiff == nil || len(v.CommitDiff.Files) == 0) {
413 if brought := s.fillFromMergeCommit(r, v, repo, mergeSHA); n == 0 && brought > 0 {
414 n = brought
415 }
416 }
417 b.NCommits = n
418 if n == 1 {
419 b.CommitPhrase = s.tr(r, "count.commit.one", n)
420 } else {
421 b.CommitPhrase = s.tr(r, "count.commit.many", n)
422 }
423 b.NPipes = len(v.PipeRows)
424 if v.CommitDiff != nil {
425 b.NChanges = len(v.CommitDiff.Files)
426 }
427 v.Banner = b
428}
429
430func (s *Server) commitCount(ctx context.Context, repo store.Repo, from, to string) int {
431 if s.Git == "" || s.StoragePath() == "" || from == "" || to == "" || from == to {
432 return 0
433 }
434 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
435 n, err := strconv.Atoi(gitOne(ctx, s.Git, dir, "rev-list", "--count", from+".."+to))
436 if err != nil || n < 0 {
437 return 0
438 }
439 return n
440}
441
442// fillFromMergeCommit vult commits en diff vanuit de merge-commit als de bronbranch
443// al in het doel zit of inmiddels weg is. Het aantal is wat die commit binnenbracht.
444func (s *Server) fillFromMergeCommit(r *http.Request, v *View, repo store.Repo, sha string) int {
445 if s.Git == "" || s.StoragePath() == "" {
446 return 0
447 }
448 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
449 parents := strings.Fields(gitOne(r.Context(), s.Git, dir, "rev-list", "--parents", "-n", "1", sha))
450 if len(parents) < 3 {
451 return 0
452 }
453 base, tip := parents[1], parents[2]
454 n, err := strconv.Atoi(gitOne(r.Context(), s.Git, dir, "rev-list", "--count", base+".."+tip))
455 if err != nil || n < 0 {
456 n = 0
457 }
458 if len(v.Commits) == 0 {
459 if commits, err := gitrepo.Log(r.Context(), s.Git, dir, base+".."+tip, 50); err == nil && len(commits) > 0 {
460 v.Commits = s.presentCommits(r.Context(), repo.ID, commits, s.langOf(r))
461 }
462 }
463 if v.CommitDiff == nil || len(v.CommitDiff.Files) == 0 {
464 if files, err := gitrepo.ComparePatch(r.Context(), s.Git, dir, base, tip); err == nil && len(files) > 0 {
465 v.CommitDiff = presentCommitDiff(repo.FullPath(), tip, nil, files)
466 }
467 }
468 return n
469}
470
471func (s *Server) mergeCommitSHA(ctx context.Context, repo store.Repo, mr store.MergeRequest) string {
472 if s.Git == "" || s.StoragePath() == "" || mr.SourceBranch == "" || mr.TargetBranch == "" {
473 return ""
474 }
475 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
476 needle := "Merge branch '" + mr.SourceBranch + "'"
477 return gitOne(ctx, s.Git, dir, "log", "-1", "--format=%H", "-F", "--grep="+needle, "refs/heads/"+mr.TargetBranch)
478}
479
480func shaLike(s string) bool {
481 if len(s) < 7 || len(s) > 40 {
482 return false
483 }
484 for _, c := range s {
485 if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
486 return false
487 }
488 }
489 return true
490}