internal/control/feedline.go

  1package control
  2
  3import (
  4	"encoding/json"
  5	"fmt"
  6	"slices"
  7	"strings"
  8	"time"
  9
 10	"gitbay.org/gitbay/internal/store"
 11)
 12
 13// FeedLine is one activity entry, already phrased and linked.
 14type FeedLine struct {
 15	Actor string
 16	Verb  string // "opened issue", "merged", "ran 2 jobs on"
 17	Ref   string // "#12", "!35", "v0.4.0", a short sha
 18	Repo  string
 19	URL   string
 20	When  string    // the stored timestamp, for anything still reading it raw
 21	WhenT time.Time // parsed from When, for ago/whenT rendering
 22	State string    // a build run's combined status; empty for anything else
 23	Jobs  []string  // job names folded into a build run
 24	// Extra is trailing detail shown after the ref: the label list on a
 25	// labelled event, empty for everything else.
 26	Extra string
 27	sha   string // the commit a build event fired on, for fold-matching
 28}
 29
 30// Sentence renders the line the way the CLI shows it: "<actor> <verb>
 31// <repo><ref>" for an issue or MR ("krz/gitbay#1"), "<repo> <ref>" for a
 32// tag, job or sha, with Extra (a label list) appended when set.
 33func (l FeedLine) Sentence() string {
 34	ref := l.Ref
 35	if ref != "" && ref[0] != '#' && ref[0] != '!' {
 36		ref = " " + ref
 37	}
 38	s := fmt.Sprintf("%s %s %s%s", l.Actor, l.Verb, l.Repo, ref)
 39	if l.Extra != "" {
 40		s += " " + l.Extra
 41	}
 42	return s
 43}
 44
 45// termCells is a feed line as a screen row shows it: when, who, what,
 46// where, and how a build came out, so the outcome and the reference can
 47// carry their colours.
 48func (l FeedLine) termCells(c *Ctx) []cell {
 49	ref := l.Ref
 50	if ref != "" && ref[0] != '#' && ref[0] != '!' {
 51		ref = " " + ref
 52	}
 53	detail := cText(l.Extra)
 54	verb := l.Verb
 55	if l.State != "" {
 56		verb = strings.TrimSuffix(verb, " "+l.State)
 57		detail = cState(l.State)
 58	}
 59	return []cell{cAge(l.When), cText(l.Actor), cText(verb), cLink(l.Repo+ref, c.siteURL(strings.TrimPrefix(l.URL, "/"))), detail}
 60}
 61
 62// FeedLines turns stored events into readable lines. An unknown kind
 63// still shows: the feed says what happened even for events added later.
 64// Build events on the same commit, adjacent in the input, fold into one
 65// "run" line (D04): its State is the worst of the folded jobs' outcomes,
 66// via WorstStatus — the same rule the builds tab uses for a run's status.
 67// A repeated job name ends the line and starts the next, so a scheduled
 68// job firing daily on an unchanged tip reads as one line a day rather than
 69// "ran 9 jobs on" one commit (#240). groupRuns separates its runs by
 70// created_at instead; these events are recorded when a build finishes, one
 71// per job, so there is no queue moment here to key on. The cost is that
 72// the oldest scheduled line on a commit folds in the push's jobs, which
 73// have not been seen yet on that line.
 74func FeedLines(events []store.FeedEvent) []FeedLine {
 75	out := make([]FeedLine, 0, len(events))
 76	statuses := make([][]string, 0, len(events))
 77	for _, e := range events {
 78		var d struct {
 79			Number int64    `json:"number"`
 80			Job    string   `json:"job"`
 81			Tag    string   `json:"tag"`
 82			SHA    string   `json:"sha"`
 83			Labels []string `json:"labels"`
 84		}
 85		json.Unmarshal([]byte(e.Data), &d)
 86		kind, rest, _ := strings.Cut(e.Kind, ".")
 87
 88		if kind == "build" && d.SHA != "" {
 89			if n := len(out); n > 0 && out[n-1].sha == d.SHA && out[n-1].Repo == e.RepoPath &&
 90				!slices.Contains(out[n-1].Jobs, d.Job) {
 91				i := n - 1
 92				out[i].Jobs = append(out[i].Jobs, d.Job)
 93				statuses[i] = append(statuses[i], rest)
 94				out[i].Verb = fmt.Sprintf("ran %d jobs on", len(out[i].Jobs))
 95				out[i].Ref = fmt.Sprintf("%.10s", d.SHA)
 96				out[i].URL = fmt.Sprintf("/%s/commit/%s", e.RepoPath, d.SHA)
 97				out[i].State = WorstStatus(statuses[i])
 98				continue
 99			}
100		}
101
102		l := FeedLine{Actor: e.Actor, Repo: e.RepoPath, When: e.CreatedAt, WhenT: parseEventTime(e.CreatedAt)}
103		if l.Actor == "" {
104			l.Actor = "gitbay"
105		}
106		var st []string
107		switch kind {
108		case "issue":
109			l.Verb, l.Ref = issueVerb(rest), fmt.Sprintf("#%d", d.Number)
110			l.URL = fmt.Sprintf("/%s/issues/%d", e.RepoPath, d.Number)
111			if rest == "labeled" {
112				l.Extra = strings.Join(d.Labels, ", ")
113			}
114		case "mr":
115			l.Verb, l.Ref = mrVerb(rest), fmt.Sprintf("!%d", d.Number)
116			l.URL = fmt.Sprintf("/%s/mrs/%d", e.RepoPath, d.Number)
117			if rest == "labeled" {
118				l.Extra = strings.Join(d.Labels, ", ")
119			}
120		case "build":
121			l.Verb, l.Ref = "build "+rest, d.Job
122			l.URL = fmt.Sprintf("/%s/builds/%d", e.RepoPath, d.Number)
123			if d.SHA != "" {
124				l.sha = d.SHA
125				l.Jobs = []string{d.Job}
126				l.State = rest
127				st = []string{rest}
128			}
129		case "release":
130			l.Verb, l.Ref = "released", d.Tag
131			l.URL = fmt.Sprintf("/%s/releases", e.RepoPath)
132		case "repo":
133			l.Verb = "repository " + rest
134			l.URL = "/" + e.RepoPath
135		default:
136			l.Verb = e.Kind
137			l.URL = "/" + e.RepoPath
138		}
139		out = append(out, l)
140		statuses = append(statuses, st)
141	}
142	return out
143}
144
145// runStatusPriority orders WorstStatus's worst-first check: a run reads
146// as its least finished or least successful build.
147var runStatusPriority = []string{"failure", "cancelled", "running", "pending"}
148
149// WorstStatus is the worst of a set of build statuses, success only when
150// every one of them is. It backs both the builds tab's combinedStatus and
151// FeedLines' folded build run (D04). A status outside runStatusPriority (a
152// future state such as "skipped") is still not "success": it is returned
153// unchanged rather than falling through and reading as green.
154func WorstStatus(statuses []string) string {
155	has := map[string]bool{}
156	for _, s := range statuses {
157		has[s] = true
158	}
159	for _, s := range runStatusPriority {
160		if has[s] {
161			return s
162		}
163	}
164	for _, s := range statuses {
165		if s != "success" {
166			return s
167		}
168	}
169	return "success"
170}
171
172// parseEventTime parses a stored RFC3339 timestamp for ago/whenT
173// rendering; an unparseable value (or none) comes back zero rather than
174// guessing.
175func parseEventTime(s string) time.Time {
176	t, err := time.Parse(time.RFC3339Nano, s)
177	if err != nil {
178		return time.Time{}
179	}
180	return t
181}
182
183func issueVerb(s string) string {
184	switch s {
185	case "created":
186		return "opened issue"
187	case "closed":
188		return "closed issue"
189	case "reopened":
190		return "reopened issue"
191	case "commented":
192		return "commented on"
193	case "labeled":
194		return "labelled"
195	}
196	return "issue " + s
197}
198
199func mrVerb(s string) string {
200	switch s {
201	case "created":
202		return "opened merge request"
203	case "merged":
204		return "merged"
205	case "commented":
206		return "commented on"
207	case "closed":
208		return "closed merge request"
209	case "labeled":
210		return "labelled"
211	}
212	return "merge request " + s
213}