BlueGit

timfa bluegit

Files

bluegit / internal / server / mr_page.go

mr_page.go

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