// Package desctpl leest beschrijvingssjablonen uit de standaardbranch // en vult de variabelen van een merge request in. package desctpl import ( "context" "regexp" "sort" "strings" "gitlab.com/Timfa/bluegit/internal/gitrepo" ) // Template is één Markdown-bestand zonder het achtervoegsel .md. type Template struct { Name string Body string } // Commit is een bericht op de bronbranch, oudste eerst. type Commit struct { Subject string Body string Author string Email string Merge bool } // Vars zijn de waarden voor %{...} bij het aanmaken van een merge request. type Vars struct { Source string Target string Commits []Commit } const hugeBody = 10000 var ( closesBranch = regexp.MustCompile(`^(\d+)-`) coAuthor = regexp.MustCompile(`(?m)^Co-authored-by: .+$`) ) // List leest .bluegit/_templates en valt terug op .gitlab/. // Een gelijke naam uit .bluegit wint. kind is issue of mr. // Ontbreken beide mappen, dan is de lijst leeg. Dat is geen fout en er wordt niets aangemaakt. func List(ctx context.Context, gitBin, dir, rev, kind string) ([]Template, error) { sub, err := subdir(kind) if err != nil { return nil, err } found := map[string]Template{} var order []string for _, root := range []string{".bluegit", ".gitlab"} { entries, err := gitrepo.Tree(ctx, gitBin, dir, rev, root+"/"+sub) if err != nil { continue } for _, e := range entries { if e.Type != "blob" || !strings.HasSuffix(e.Name, ".md") { continue } name := strings.TrimSuffix(e.Name, ".md") if !validName(name) { continue } if _, ok := found[name]; ok { continue } text, binary, err := gitrepo.Blob(ctx, gitBin, dir, rev, root+"/"+sub+"/"+e.Name, 100000) if err != nil || binary { continue } if len(text) > 20000 { text = text[:20000] } found[name] = Template{Name: name, Body: text} order = append(order, name) } } list := make([]Template, 0, len(order)) for _, name := range order { list = append(list, found[name]) } sort.SliceStable(list, func(i, j int) bool { di := strings.EqualFold(list[i].Name, "Default") dj := strings.EqualFold(list[j].Name, "Default") if di != dj { return di } return strings.ToLower(list[i].Name) < strings.ToLower(list[j].Name) }) return list, nil } // Find zoekt een sjabloon op naam. Een hoofdletterverschil telt alleen als er één kandidaat is. func Find(list []Template, name string) (Template, bool) { name = strings.TrimSpace(name) if name == "" { return Template{}, false } for _, t := range list { if t.Name == name { return t, true } } var hit Template n := 0 for _, t := range list { if strings.EqualFold(t.Name, name) { hit = t n++ } } if n == 1 { return hit, true } return Template{}, false } // Default is Default.md, ongeacht hoofdletters. Een exacte naam wint. func Default(list []Template) (Template, bool) { var loose Template looseOK := false for _, t := range list { if t.Name == "Default" { return t, true } if !looseOK && strings.EqualFold(t.Name, "Default") { loose = t looseOK = true } } return loose, looseOK } // Expand vervangt de variabelen. Een merge-commit en een heel lang bericht // tellen niet mee voor de commitlijsten. Er worden hooguit 100 commits gebruikt. func Expand(body string, v Vars) string { commits := v.Commits if len(commits) > 100 { commits = commits[:100] } repl := map[string]string{ "%{source_branch}": v.Source, "%{target_branch}": v.Target, "%{first_commit}": firstCommit(commits), "%{all_commits}": allCommits(commits), "%{co_authored_by}": coAuthored(commits), "%{first_multiline_commit}": firstMultiline(commits), "%{closes_issue}": closesIssue(v.Source), } for token, value := range repl { body = strings.ReplaceAll(body, token, value) } return body } func closesIssue(branch string) string { m := closesBranch.FindStringSubmatch(branch) if m == nil { return "" } return "Closes #" + m[1] } func usable(c Commit) bool { return !c.Merge && len(c.Subject) <= hugeBody && len(c.Body) <= hugeBody } func message(c Commit) string { if c.Body == "" { return c.Subject } return c.Subject + "\n\n" + c.Body } func firstCommit(commits []Commit) string { for _, c := range commits { if usable(c) { return message(c) } } return "" } func firstMultiline(commits []Commit) string { for _, c := range commits { if usable(c) && c.Body != "" { return message(c) } } return "" } func allCommits(commits []Commit) string { var parts []string for _, c := range commits { if !usable(c) { continue } parts = append(parts, message(c)) } return strings.Join(parts, "\n\n") } func coAuthored(commits []Commit) string { seen := map[string]bool{} var lines []string for _, c := range commits { if len(c.Body) > hugeBody { continue } for _, line := range coAuthor.FindAllString(c.Body, -1) { if seen[line] { continue } seen[line] = true lines = append(lines, line) } } return strings.Join(lines, "\n") } func subdir(kind string) (string, error) { switch kind { case "issue": return "issue_templates", nil case "mr": return "merge_request_templates", nil default: return "", errKind } } type kindError struct{} func (kindError) Error() string { return "onbekend sjabloon" } var errKind kindError func validName(name string) bool { if name == "" || name == "." || name == ".." { return false } return !strings.ContainsAny(name, "/\\") }