BlueGit

timfa bluegit

Files

bluegit / internal / gitrepo / repo.go

repo.go

feat: geef de branches- en tagspagina de GitLab-opbouw
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed caf2e1c8 History
repo.go 22.2 KiB Download Raw
1// Package gitrepo legt bare repositories op schijf en praat met de git-binary.
2package gitrepo
3
4import (
5 "bufio"
6 "bytes"
7 "context"
8 "fmt"
9 "io"
10 "os"
11 "os/exec"
12 "path/filepath"
13 "sort"
14 "strconv"
15 "strings"
16
17 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/i18n"
19 "gitlab.com/Timfa/bluegit/internal/names"
20)
21
22// Dir is de bare repository op de datadisk.
23func Dir(storage, owner, name string) string {
24 return filepath.Join(storage, "repos", owner, name+".git")
25}
26
27// Init maakt een lege bare repository en zet de pre-receive-hook.
28func Init(gitBin, dir, defaultBranch, hookBinary string) error {
29 if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil {
30 return err
31 }
32 if _, err := run(context.Background(), gitBin, nil, "init", "--bare", "--initial-branch", defaultBranch, dir); err != nil {
33 return err
34 }
35 for _, kv := range [][2]string{
36 {"http.receivepack", "true"},
37 {"http.uploadpack", "true"},
38 {"receive.denyCurrentBranch", "ignore"},
39 } {
40 if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil {
41 return err
42 }
43 }
44 return InstallHook(dir, hookBinary)
45}
46
47// InstallHook schrijft hooks/pre-receive. Die roept deze binary aan.
48func InstallHook(dir, hookBinary string) error {
49 if hookBinary == "" {
50 return fmt.Errorf("hook-binary ontbreekt")
51 }
52 path := filepath.Join(dir, "hooks", "pre-receive")
53 body := "#!/bin/sh\nset -eu\nexec " + shellQuote(hookBinary) + " hook pre-receive\n"
54 if err := os.WriteFile(path, []byte(body), 0o755); err != nil {
55 return err
56 }
57 return nil
58}
59
60func shellQuote(s string) string {
61 return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
62}
63
64// PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen
65// weigert de hook, zodat een push buiten BlueGit om niet slaagt.
66func PushEnv(role access.Role, patterns, tagPatterns []string) []string {
67 return []string{
68 "BLUEGIT_ROLE=" + string(role),
69 "BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"),
70 "BLUEGIT_PROTECTED_TAGS=" + strings.Join(tagPatterns, "\n"),
71 }
72}
73
74// ReadUpdates leest de regels van een pre-receive-hook.
75func ReadUpdates(r io.Reader) ([]access.RefUpdate, error) {
76 sc := bufio.NewScanner(r)
77 var out []access.RefUpdate
78 for sc.Scan() {
79 line := strings.TrimSpace(sc.Text())
80 if line == "" {
81 continue
82 }
83 parts := strings.Fields(line)
84 if len(parts) != 3 {
85 return nil, fmt.Errorf("onverwachte hookregel %q", line)
86 }
87 out = append(out, access.RefUpdate{Old: parts[0], New: parts[1], Ref: parts[2]})
88 }
89 return out, sc.Err()
90}
91
92// EvaluatePush is wat `bluegit hook pre-receive` doet.
93func EvaluatePush(role access.Role, patterns, tagPatterns []string, r io.Reader) error {
94 if role == "" {
95 return fmt.Errorf("push geweigerd: geen BlueGit-rol")
96 }
97 ups, err := ReadUpdates(r)
98 if err != nil {
99 return err
100 }
101 return access.AuthorizeUpdates(role, patterns, tagPatterns, ups)
102}
103
104// Commit is één commit voor de webinterface.
105type Commit struct {
106 SHA string
107 Short string
108 Author string
109 Email string
110 Date string
111 Unix int64
112 Subject string
113 Body string
114}
115
116// Entry is een bestand of map in een tree.
117type Entry struct {
118 Mode string
119 Type string
120 SHA string
121 Name string
122}
123
124// Log geeft de nieuwste commits.
125func Log(ctx context.Context, gitBin, dir, rev string, limit int) ([]Commit, error) {
126 if rev == "" {
127 rev = "HEAD"
128 }
129 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", fmt.Sprintf("-n%d", limit), rev)
130 if err != nil {
131 if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") {
132 return nil, nil
133 }
134 return nil, err
135 }
136 return parseLog(out), nil
137}
138
139func parseLog(out string) []Commit {
140 var commits []Commit
141 for _, rec := range strings.Split(out, "\x1e") {
142 rec = strings.TrimSpace(rec)
143 if rec == "" {
144 continue
145 }
146 parts := strings.Split(rec, "\x1f")
147 if len(parts) < 6 {
148 continue
149 }
150 c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Date: parts[3], Subject: parts[5]}
151 c.Unix, _ = strconv.ParseInt(parts[4], 10, 64)
152 if len(c.SHA) >= 10 {
153 c.Short = c.SHA[:10]
154 }
155 if len(parts) > 6 {
156 c.Body = strings.TrimSpace(parts[6])
157 }
158 commits = append(commits, c)
159 }
160 return commits
161}
162
163// Message is een commitbericht. Merge is waar bij twee of meer ouders.
164type Message struct {
165 Subject string
166 Body string
167 Author string
168 Email string
169 Merge bool
170}
171
172// Messages leest hooguit limit berichten, oudste eerst.
173func Messages(ctx context.Context, gitBin, dir, rev string, limit int) ([]Message, error) {
174 if rev == "" {
175 rev = "HEAD"
176 }
177 if limit < 1 {
178 limit = 1
179 }
180 if limit > 100 {
181 limit = 100
182 }
183 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--reverse", "--format=%an%x1f%ae%x1f%P%x1f%s%x1f%b%x1e", "--date=short", fmt.Sprintf("-n%d", limit), rev)
184 if err != nil {
185 if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") {
186 return nil, nil
187 }
188 return nil, err
189 }
190 return parseMessages(out), nil
191}
192
193func parseMessages(out string) []Message {
194 var msgs []Message
195 for _, rec := range strings.Split(out, "\x1e") {
196 rec = strings.TrimSpace(rec)
197 if rec == "" {
198 continue
199 }
200 parts := strings.Split(rec, "\x1f")
201 if len(parts) < 4 {
202 continue
203 }
204 m := Message{Author: parts[0], Email: parts[1], Subject: parts[3]}
205 m.Merge = len(strings.Fields(parts[2])) > 1
206 if len(parts) > 4 {
207 m.Body = strings.TrimSpace(parts[4])
208 }
209 msgs = append(msgs, m)
210 }
211 return msgs
212}
213
214// Show leest één commit.
215func Show(ctx context.Context, gitBin, dir, sha string) (Commit, error) {
216 list, err := Log(ctx, gitBin, dir, sha, 1)
217 if err != nil {
218 return Commit{}, err
219 }
220 if len(list) == 0 {
221 return Commit{}, fmt.Errorf("commit niet gevonden")
222 }
223 return list[0], nil
224}
225
226// Tree leest een map. path is relatief en mag leeg zijn.
227func Tree(ctx context.Context, gitBin, dir, rev, rel string) ([]Entry, error) {
228 spec := rev
229 if rel != "" {
230 spec = rev + ":" + rel
231 }
232 out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", spec)
233 if err != nil {
234 return nil, err
235 }
236 var entries []Entry
237 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
238 if line == "" {
239 continue
240 }
241 // mode type sha\tname
242 tab := strings.SplitN(line, "\t", 2)
243 if len(tab) != 2 {
244 continue
245 }
246 head := strings.Fields(tab[0])
247 if len(head) != 3 {
248 continue
249 }
250 entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]})
251 }
252 return entries, nil
253}
254
255// Blob leest een tekstbestand, afgekapt op max bytes. binary is waar als
256// het bestand een NUL bevat.
257func Blob(ctx context.Context, gitBin, dir, rev, rel string, max int) (text string, binary bool, err error) {
258 out, err := run(ctx, gitBin, nil, "-C", dir, "show", rev+":"+rel)
259 if err != nil {
260 return "", false, err
261 }
262 if strings.Contains(out, "\x00") {
263 return "", true, nil
264 }
265 if len(out) > max {
266 out = out[:max] + "\n… afgekapt"
267 }
268 return out, false, nil
269}
270
271// Branches geeft lokale branchnamen.
272func Branches(ctx context.Context, gitBin, dir string) ([]string, error) {
273 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/heads")
274 if err != nil {
275 return nil, err
276 }
277 var names []string
278 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
279 if line != "" {
280 names = append(names, line)
281 }
282 }
283 return names, nil
284}
285
286// HasCommit meldt of sha een commit in deze repository is.
287func HasCommit(ctx context.Context, gitBin, dir, sha string) bool {
288 out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-t", sha)
289 return err == nil && strings.TrimSpace(out) == "commit"
290}
291
292// Refs geeft refnaam → sha.
293func Refs(ctx context.Context, gitBin, dir string) (map[string]string, error) {
294 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(objectname) %(refname)")
295 if err != nil {
296 return nil, err
297 }
298 m := map[string]string{}
299 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
300 if line == "" {
301 continue
302 }
303 parts := strings.SplitN(line, " ", 2)
304 if len(parts) == 2 {
305 m[parts[1]] = parts[0]
306 }
307 }
308 return m, nil
309}
310
311// Touch geeft per pad de nieuwste commit uit de recente geschiedenis.
312// Mappen erven de nieuwste commit van een bestand erin.
313func Touch(ctx context.Context, gitBin, dir, rev string) (map[string]Commit, error) {
314 if rev == "" {
315 rev = "HEAD"
316 }
317 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--format=%H%x1f%an%x1f%at%x1f%s", "--name-only", "-n", "400", rev)
318 if err != nil {
319 if emptyHistory(err) {
320 return map[string]Commit{}, nil
321 }
322 return nil, err
323 }
324 m := map[string]Commit{}
325 var cur Commit
326 have := false
327 for _, line := range strings.Split(out, "\n") {
328 if strings.Contains(line, "\x1f") {
329 parts := strings.Split(line, "\x1f")
330 if len(parts) < 4 {
331 continue
332 }
333 cur = Commit{SHA: parts[0], Author: parts[1], Subject: parts[3]}
334 cur.Unix, _ = strconv.ParseInt(parts[2], 10, 64)
335 if len(cur.SHA) >= 10 {
336 cur.Short = cur.SHA[:10]
337 }
338 have = true
339 continue
340 }
341 line = strings.TrimSpace(line)
342 if line == "" || !have {
343 continue
344 }
345 notePath(m, line, cur)
346 }
347 return m, nil
348}
349
350func notePath(m map[string]Commit, path string, c Commit) {
351 for path != "" && path != "." {
352 if _, ok := m[path]; !ok {
353 m[path] = c
354 }
355 i := strings.LastIndex(path, "/")
356 if i < 0 {
357 return
358 }
359 path = path[:i]
360 }
361}
362
363func emptyHistory(err error) bool {
364 msg := err.Error()
365 return strings.Contains(msg, "does not have any commits") || strings.Contains(msg, "bad default revision") || strings.Contains(msg, "ambiguous argument")
366}
367
368// Stats telt commits op rev, lokale branches en tags.
369func Stats(ctx context.Context, gitBin, dir, rev string) (commits, branches, tags int, err error) {
370 if rev == "" {
371 rev = "HEAD"
372 }
373 out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--count", rev)
374 if err != nil {
375 if emptyHistory(err) {
376 return 0, 0, 0, nil
377 }
378 return 0, 0, 0, err
379 }
380 commits, _ = strconv.Atoi(strings.TrimSpace(out))
381 names, err := Branches(ctx, gitBin, dir)
382 if err != nil {
383 return commits, 0, 0, err
384 }
385 branches = len(names)
386 out, err = run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags")
387 if err != nil {
388 return commits, branches, 0, err
389 }
390 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
391 if line != "" {
392 tags++
393 }
394 }
395 return commits, branches, tags, nil
396}
397
398// Tags geeft tagnamen.
399func Tags(ctx context.Context, gitBin, dir string) ([]string, error) {
400 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags")
401 if err != nil {
402 return nil, err
403 }
404 var names []string
405 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
406 if line != "" {
407 names = append(names, line)
408 }
409 }
410 return names, nil
411}
412
413// TagInfo is één git-tag voor de webinterface.
414type TagInfo struct {
415 Name string
416 Annotated bool
417 Message string
418 CommitSHA string
419 CommitSubject string
420 Unix int64
421}
422
423// ListTags geeft alle tags, nieuwste eerst.
424func ListTags(ctx context.Context, gitBin, dir string) ([]TagInfo, error) {
425 const format = "%(refname:short)\n%(objecttype)\n%(objectname)\n%(*objectname)\n%(creatordate:unix)\n%(subject)\n%(*subject)\nBLUEGIT-END"
426 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--sort=-creatordate", "--format="+format, "refs/tags")
427 if err != nil {
428 return nil, err
429 }
430 lines := strings.Split(out, "\n")
431 if len(lines) > 0 && lines[len(lines)-1] == "" {
432 lines = lines[:len(lines)-1]
433 }
434 var tags []TagInfo
435 for i := 0; i+7 < len(lines); i += 8 {
436 if lines[i+7] != "BLUEGIT-END" {
437 continue
438 }
439 unix, _ := strconv.ParseInt(strings.TrimSpace(lines[i+4]), 10, 64)
440 tag := TagInfo{Name: lines[i], Unix: unix}
441 if lines[i+1] == "tag" {
442 tag.Annotated = true
443 tag.CommitSHA = lines[i+3]
444 tag.CommitSubject = lines[i+6]
445 if tag.CommitSHA == "" {
446 tag.CommitSHA = lines[i+2]
447 }
448 if tag.CommitSubject == "" {
449 tag.CommitSubject = lines[i+5]
450 }
451 msg, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(contents)", "refs/tags/"+tag.Name)
452 if err != nil {
453 return nil, err
454 }
455 tag.Message = strings.TrimSpace(msg)
456 } else {
457 tag.CommitSHA = lines[i+2]
458 tag.CommitSubject = lines[i+5]
459 }
460 if tag.Name != "" {
461 tags = append(tags, tag)
462 }
463 }
464 sort.SliceStable(tags, func(i, j int) bool {
465 if tags[i].Unix != tags[j].Unix {
466 return tags[i].Unix > tags[j].Unix
467 }
468 return tags[i].Name < tags[j].Name
469 })
470 return tags, nil
471}
472
473// CreateTag zet een tag op een branch of commit. Een leeg bericht blijft licht.
474func CreateTag(ctx context.Context, gitBin, dir, name, rev, message, author, email string) error {
475 if err := names.ValidTag(name); err != nil {
476 return err
477 }
478 sha, err := resolveCommit(ctx, gitBin, dir, rev)
479 if err != nil {
480 return err
481 }
482 if HasTag(ctx, gitBin, dir, name) {
483 return i18n.E("err.tagExists", name)
484 }
485 message = strings.TrimSpace(message)
486 if len(message) > 5000 {
487 return i18n.E("err.tagLong")
488 }
489 home, err := os.MkdirTemp(dir, "home-")
490 if err != nil {
491 return classifyGit(err)
492 }
493 defer os.RemoveAll(home)
494 env := CommandEnv(author, email, home, home)
495 if message == "" {
496 _, err = run(ctx, gitBin, env, "-C", dir, "tag", name, sha)
497 return err
498 }
499 _, err = run(ctx, gitBin, env, "-C", dir, "tag", "-a", name, sha, "-m", message)
500 return err
501}
502
503// DeleteTag verwijdert een bestaande tag.
504func DeleteTag(ctx context.Context, gitBin, dir, name string) error {
505 if err := usableTag(name); err != nil {
506 return err
507 }
508 if !HasTag(ctx, gitBin, dir, name) {
509 return i18n.E("err.tagMissing", name)
510 }
511 _, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-d", "--", name)
512 return err
513}
514
515// HasTag meldt of refs/tags/name bestaat.
516func HasTag(ctx context.Context, gitBin, dir, name string) bool {
517 if err := usableTag(name); err != nil {
518 return false
519 }
520 _, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "-q", "--verify", "--end-of-options", "refs/tags/"+name)
521 return err == nil
522}
523
524// Archive schrijft een zip of tar.gz van de tag naar w.
525func Archive(ctx context.Context, w io.Writer, gitBin, dir, prefix, name, format string) error {
526 if err := usableTag(name); err != nil {
527 return err
528 }
529 if !HasTag(ctx, gitBin, dir, name) {
530 return i18n.E("err.tagMissing", name)
531 }
532 return ArchiveAt(ctx, w, gitBin, dir, prefix, name, format)
533}
534
535// ArchiveAt schrijft een zip of tar.gz van een bestaande revisie.
536// rev is een tagnaam of refs/heads/….
537func ArchiveAt(ctx context.Context, w io.Writer, gitBin, dir, prefix, rev, format string) error {
538 if format != "zip" && format != "tar.gz" {
539 return i18n.E("err.notFound")
540 }
541 if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
542 return i18n.E("err.notFound")
543 }
544 if gitBin == "" {
545 gitBin = "git"
546 }
547 if prefix != "" && !strings.HasSuffix(prefix, "/") {
548 prefix += "/"
549 }
550 cmd := exec.CommandContext(ctx, gitBin, "-C", dir, "archive", "--format="+format, "--prefix="+prefix, rev)
551 cmd.Stdout = w
552 var stderr bytes.Buffer
553 cmd.Stderr = &stderr
554 if err := cmd.Run(); err != nil {
555 msg := strings.TrimSpace(stderr.String())
556 if msg == "" {
557 msg = err.Error()
558 }
559 return fmt.Errorf("%s", msg)
560 }
561 return nil
562}
563
564func resolveCommit(ctx context.Context, gitBin, dir, rev string) (string, error) {
565 rev = strings.TrimSpace(rev)
566 if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
567 return "", i18n.E("err.tagRef", rev)
568 }
569 out, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "--verify", "--end-of-options", rev+"^{commit}")
570 if err != nil {
571 return "", i18n.E("err.tagRef", rev)
572 }
573 return strings.TrimSpace(out), nil
574}
575
576func usableTag(name string) error {
577 if name == "" || len(name) > 200 || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") || strings.Contains(name, "//") || strings.Contains(name, "@{") || strings.ContainsAny(name, " \t\r\n\\~^:?*[") {
578 return i18n.E("err.tag", name)
579 }
580 return nil
581}
582
583// TreeAll leest de hele boom. Name is het pad vanaf de root.
584func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) {
585 if rev == "" {
586 rev = "HEAD"
587 }
588 out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", "-r", "-t", rev)
589 if err != nil {
590 if emptyHistory(err) {
591 return nil, nil
592 }
593 return nil, err
594 }
595 return parseTree(out), nil
596}
597
598func parseTree(out string) []Entry {
599 var entries []Entry
600 for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
601 if line == "" {
602 continue
603 }
604 tab := strings.SplitN(line, "\t", 2)
605 if len(tab) != 2 {
606 continue
607 }
608 head := strings.Fields(tab[0])
609 if len(head) != 3 {
610 continue
611 }
612 entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]})
613 }
614 return entries
615}
616
617// LastCommit is de nieuwste commit die path heeft geraakt. Leeg pad is de tip.
618func LastCommit(ctx context.Context, gitBin, dir, rev, path string) (Commit, error) {
619 if rev == "" {
620 rev = "HEAD"
621 }
622 args := []string{"-C", dir, "log", "-1", "--format=%H%x1f%an%x1f%ae%x1f%at%x1f%s", rev}
623 if path != "" {
624 args = append(args, "--", path)
625 }
626 out, err := run(ctx, gitBin, nil, args...)
627 if err != nil {
628 if emptyHistory(err) {
629 return Commit{}, nil
630 }
631 return Commit{}, err
632 }
633 line := strings.TrimSpace(out)
634 parts := strings.Split(line, "\x1f")
635 if len(parts) < 5 {
636 return Commit{}, nil
637 }
638 c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Subject: parts[4]}
639 c.Unix, _ = strconv.ParseInt(parts[3], 10, 64)
640 if len(c.SHA) >= 10 {
641 c.Short = c.SHA[:10]
642 }
643 return c, nil
644}
645
646// BlobSize is de grootte in bytes.
647func BlobSize(ctx context.Context, gitBin, dir, rev, rel string) (int64, error) {
648 out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-s", rev+":"+rel)
649 if err != nil {
650 return 0, err
651 }
652 return strconv.ParseInt(strings.TrimSpace(out), 10, 64)
653}
654
655// PushedCommit is een commit die met een push nieuw bereikbaar werd.
656type PushedCommit struct {
657 SHA string
658 Email string
659 Name string
660 Unix int64
661}
662
663// CommitsSince geeft commits die newSHA bereikt en old niet.
664// Een lege of nul-old is de hele geschiedenis van newSHA.
665func CommitsSince(ctx context.Context, gitBin, dir, old, newSHA string) ([]PushedCommit, error) {
666 if newSHA == "" || allZero(newSHA) {
667 return nil, nil
668 }
669 args := []string{"-C", dir, "log", "--format=%H%x1f%ae%x1f%an%x1f%at", newSHA}
670 if old != "" && !allZero(old) {
671 args = append(args, "--not", old)
672 }
673 out, err := run(ctx, gitBin, nil, args...)
674 if err != nil {
675 if emptyHistory(err) {
676 return nil, nil
677 }
678 return nil, err
679 }
680 var commits []PushedCommit
681 for _, line := range strings.Split(out, "\n") {
682 line = strings.TrimSpace(line)
683 if line == "" || !strings.Contains(line, "\x1f") {
684 continue
685 }
686 parts := strings.Split(line, "\x1f")
687 if len(parts) < 4 {
688 continue
689 }
690 c := PushedCommit{SHA: parts[0], Email: parts[1], Name: parts[2]}
691 c.Unix, _ = strconv.ParseInt(parts[3], 10, 64)
692 commits = append(commits, c)
693 }
694 return commits, nil
695}
696
697func allZero(sha string) bool {
698 return strings.Trim(sha, "0") == ""
699}
700
701// RangeLog geeft de commits die newSHA bereikt en old niet, nieuwste eerst.
702// Een lege of nul-old is de geschiedenis van newSHA.
703func RangeLog(ctx context.Context, gitBin, dir, old, newSHA string) ([]Commit, error) {
704 if newSHA == "" || allZero(newSHA) {
705 return nil, nil
706 }
707 args := []string{"-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", newSHA}
708 if old != "" && !allZero(old) {
709 args = append(args, "--not", old)
710 }
711 out, err := run(ctx, gitBin, nil, args...)
712 if err != nil {
713 if emptyHistory(err) {
714 return nil, nil
715 }
716 return nil, err
717 }
718 return parseLog(out), nil
719}
720
721// BranchOfRef haalt de branch uit refs/heads/… .
722func BranchOfRef(ref string) (string, bool) {
723 const p = "refs/heads/"
724 if strings.HasPrefix(ref, p) && len(ref) > len(p) {
725 return ref[len(p):], true
726 }
727 return "", false
728}
729
730// Merge voegt source samen in target en pusht het resultaat.
731// squash maakt één gewone commit met message in plaats van een merge-commit.
732// De push gaat door de hook, dus role en patterns moeten kloppen.
733func Merge(ctx context.Context, gitBin, bare, work, source, target, author, email, message string, squash bool, role access.Role, patterns []string) error {
734 repo, env, err := prepareWork(work, author, email)
735 if err != nil {
736 return classifyGit(err)
737 }
738 if _, err := run(ctx, gitBin, env, "clone", bare, repo); err != nil {
739 return classifyGit(err)
740 }
741 if _, err := run(ctx, gitBin, env, "-C", repo, "checkout", target); err != nil {
742 return classifyGit(fmt.Errorf("doelbranch %s: %w", target, err))
743 }
744 // De kloon heeft de bron alleen als origin/<branch>, niet als lokale branch.
745 if squash {
746 if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--squash", "origin/"+source); err != nil {
747 return i18n.E("err.mergeConflict")
748 }
749 if _, err := run(ctx, gitBin, env, "-C", repo, "commit", "-m", message); err != nil {
750 return classifyGit(err)
751 }
752 } else if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--no-ff", "--no-edit", "-m", message, "origin/"+source); err != nil {
753 return i18n.E("err.mergeConflict")
754 }
755 pushEnv := append(append([]string{}, env...), PushEnv(role, patterns, nil)...)
756 if _, err := run(ctx, gitBin, pushEnv, "-C", repo, "push", "origin", target); err != nil {
757 return classifyGit(err)
758 }
759 return nil
760}
761
762// Tag zet een annotated tag op sha.
763func Tag(ctx context.Context, gitBin, dir, tag, sha, message string) error {
764 _, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-a", tag, sha, "-m", message)
765 return err
766}
767
768// DiffStat is een korte vergelijking tussen twee branches.
769func DiffStat(ctx context.Context, gitBin, dir, target, source string) (string, error) {
770 out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--oneline", target+".."+source)
771 if err != nil {
772 return "", err
773 }
774 return strings.TrimSpace(out), nil
775}
776
777func run(ctx context.Context, bin string, env []string, args ...string) (string, error) {
778 if bin == "" {
779 bin = "git"
780 }
781 cmd := exec.CommandContext(ctx, bin, args...)
782 if env != nil {
783 cmd.Env = env
784 }
785 var stdout, stderr bytes.Buffer
786 cmd.Stdout = &stdout
787 cmd.Stderr = &stderr
788 if err := cmd.Run(); err != nil {
789 msg := strings.TrimSpace(stderr.String())
790 if msg == "" {
791 msg = err.Error()
792 }
793 return "", fmt.Errorf("%s", msg)
794 }
795 return stdout.String(), nil
796}