BlueGit

timfa bluegit

Files

bluegit / internal / server / mr_page.go

mr_page.go

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