BlueGit

timfa bluegit

feat: voeg een tagspagina per repository toe

Een repository toont tags van nieuw naar oud, met aanmaken, verwijderen,
beschermde patronen en een zip- of tar.gz-download.

Co-authored-by: tim <tim@timfalken.com>

timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa

Authored 2026-10-22 · 3 weeks ago

Hash
2ec9a856e17a025176c59e55e7f0f4bc77924e28
Parent
bdc4d1c5
24 files changed +1184 −44
cmd/bluegit/main.go +6 −5
@@ -159,14 +159,15 @@ func hook(args []string) {
159 159 fmt.Fprintln(os.Stderr, "gebruik: bluegit hook pre-receive")
160 160 os.Exit(2)
161 161 }
162 var patterns []string
162 var patterns, tagPatterns []string
163 163 if raw := os.Getenv("BLUEGIT_PROTECTED"); raw != "" {
164 for _, p := range splitLines(raw) {
165 patterns = append(patterns, p)
166 }
164 patterns = append(patterns, splitLines(raw)...)
165 }
166 if raw := os.Getenv("BLUEGIT_PROTECTED_TAGS"); raw != "" {
167 tagPatterns = append(tagPatterns, splitLines(raw)...)
167 168 }
168 169 role := access.Role(os.Getenv("BLUEGIT_ROLE"))
169 if err := gitrepo.EvaluatePush(role, patterns, os.Stdin); err != nil {
170 if err := gitrepo.EvaluatePush(role, patterns, tagPatterns, os.Stdin); err != nil {
170 171 fmt.Fprintln(os.Stderr, err.Error())
171 172 os.Exit(1)
172 173 }
@@ -159,14 +159,15 @@ func hook(args []string) {
159 fmt.Fprintln(os.Stderr, "gebruik: bluegit hook pre-receive")
159 fmt.Fprintln(os.Stderr, "gebruik: bluegit hook pre-receive")
160 os.Exit(2)
160 os.Exit(2)
161 }
161 }
162 var patterns []string
162 var patterns, tagPatterns []string
163 if raw := os.Getenv("BLUEGIT_PROTECTED"); raw != "" {
163 if raw := os.Getenv("BLUEGIT_PROTECTED"); raw != "" {
164 for _, p := range splitLines(raw) {
164 patterns = append(patterns, splitLines(raw)...)
165 patterns = append(patterns, p)
165 }
166 }
166 if raw := os.Getenv("BLUEGIT_PROTECTED_TAGS"); raw != "" {
167 tagPatterns = append(tagPatterns, splitLines(raw)...)
167 }
168 }
168 role := access.Role(os.Getenv("BLUEGIT_ROLE"))
169 role := access.Role(os.Getenv("BLUEGIT_ROLE"))
169 if err := gitrepo.EvaluatePush(role, patterns, os.Stdin); err != nil {
170 if err := gitrepo.EvaluatePush(role, patterns, tagPatterns, os.Stdin); err != nil {
170 fmt.Fprintln(os.Stderr, err.Error())
171 fmt.Fprintln(os.Stderr, err.Error())
171 os.Exit(1)
172 os.Exit(1)
172 }
173 }
internal/access/access.go +17 −6
@@ -90,7 +90,7 @@ func (r Role) CanWriteCode() bool { return r.AtLeast(RoleDeveloper) }
90 90 // CanManageSecrets geldt alleen voor een beheerder.
91 91 func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) }
92 92
93 // CanManageSettings dekt leden, webhooks, beschermde branches en verwijderen.
93 // CanManageSettings dekt leden, webhooks, beschermde branches en tags, en verwijderen.
94 94 func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) }
95 95
96 96 // CanPushBranch meldt of deze rol naar een branch mag schrijven.
@@ -167,12 +167,23 @@ type RefUpdate struct {
167 167 }
168 168
169 169 // AuthorizeUpdate keurt één ref-update goed of af.
170 // Alleen refs/heads/* kan beschermd zijn. Overige refs (tags, notes)
171 // mag een ontwikkelaar schrijven. Alleen-lezen mag niets schrijven.
172 func AuthorizeUpdate(role Role, patterns []string, u RefUpdate) error {
170 // Een beschermde branch of een tag die op een beschermd patroon past
171 // mag alleen een beheerder schrijven. Alleen-lezen mag niets schrijven.
172 func AuthorizeUpdate(role Role, patterns, tagPatterns []string, u RefUpdate) error {
173 173 if !role.CanWriteCode() {
174 174 return i18n.E("err.hook.nowrite", u.Ref)
175 175 }
176 const tags = "refs/tags/"
177 if strings.HasPrefix(u.Ref, tags) {
178 name := strings.TrimPrefix(u.Ref, tags)
179 if name == "" || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") {
180 return i18n.E("err.tag", name)
181 }
182 if BranchProtected(tagPatterns, name) && !role.CanManageSettings() {
183 return i18n.E("err.hook.tag", name)
184 }
185 return nil
186 }
176 187 const heads = "refs/heads/"
177 188 if !strings.HasPrefix(u.Ref, heads) {
178 189 return nil
@@ -188,12 +199,12 @@ func AuthorizeUpdate(role Role, patterns []string, u RefUpdate) error {
188 199 }
189 200
190 201 // AuthorizeUpdates keurt een hele push goed. De eerste fout stopt.
191 func AuthorizeUpdates(role Role, patterns []string, updates []RefUpdate) error {
202 func AuthorizeUpdates(role Role, patterns, tagPatterns []string, updates []RefUpdate) error {
192 203 if len(updates) == 0 {
193 204 return i18n.E("err.hook.empty")
194 205 }
195 206 for _, u := range updates {
196 if err := AuthorizeUpdate(role, patterns, u); err != nil {
207 if err := AuthorizeUpdate(role, patterns, tagPatterns, u); err != nil {
197 208 return err
198 209 }
199 210 }
@@ -90,7 +90,7 @@ func (r Role) CanWriteCode() bool { return r.AtLeast(RoleDeveloper) }
90// CanManageSecrets geldt alleen voor een beheerder.
90// CanManageSecrets geldt alleen voor een beheerder.
91func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) }
91func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) }
92
92
93// CanManageSettings dekt leden, webhooks, beschermde branches en verwijderen.
93// CanManageSettings dekt leden, webhooks, beschermde branches en tags, en verwijderen.
94func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) }
94func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) }
95
95
96// CanPushBranch meldt of deze rol naar een branch mag schrijven.
96// CanPushBranch meldt of deze rol naar een branch mag schrijven.
@@ -167,12 +167,23 @@ type RefUpdate struct {
167}
167}
168
168
169// AuthorizeUpdate keurt één ref-update goed of af.
169// AuthorizeUpdate keurt één ref-update goed of af.
170// Alleen refs/heads/* kan beschermd zijn. Overige refs (tags, notes)
170// Een beschermde branch of een tag die op een beschermd patroon past
171// mag een ontwikkelaar schrijven. Alleen-lezen mag niets schrijven.
171// mag alleen een beheerder schrijven. Alleen-lezen mag niets schrijven.
172func AuthorizeUpdate(role Role, patterns []string, u RefUpdate) error {
172func AuthorizeUpdate(role Role, patterns, tagPatterns []string, u RefUpdate) error {
173 if !role.CanWriteCode() {
173 if !role.CanWriteCode() {
174 return i18n.E("err.hook.nowrite", u.Ref)
174 return i18n.E("err.hook.nowrite", u.Ref)
175 }
175 }
176 const tags = "refs/tags/"
177 if strings.HasPrefix(u.Ref, tags) {
178 name := strings.TrimPrefix(u.Ref, tags)
179 if name == "" || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") {
180 return i18n.E("err.tag", name)
181 }
182 if BranchProtected(tagPatterns, name) && !role.CanManageSettings() {
183 return i18n.E("err.hook.tag", name)
184 }
185 return nil
186 }
176 const heads = "refs/heads/"
187 const heads = "refs/heads/"
177 if !strings.HasPrefix(u.Ref, heads) {
188 if !strings.HasPrefix(u.Ref, heads) {
178 return nil
189 return nil
@@ -188,12 +199,12 @@ func AuthorizeUpdate(role Role, patterns []string, u RefUpdate) error {
188}
199}
189
200
190// AuthorizeUpdates keurt een hele push goed. De eerste fout stopt.
201// AuthorizeUpdates keurt een hele push goed. De eerste fout stopt.
191func AuthorizeUpdates(role Role, patterns []string, updates []RefUpdate) error {
202func AuthorizeUpdates(role Role, patterns, tagPatterns []string, updates []RefUpdate) error {
192 if len(updates) == 0 {
203 if len(updates) == 0 {
193 return i18n.E("err.hook.empty")
204 return i18n.E("err.hook.empty")
194 }
205 }
195 for _, u := range updates {
206 for _, u := range updates {
196 if err := AuthorizeUpdate(role, patterns, u); err != nil {
207 if err := AuthorizeUpdate(role, patterns, tagPatterns, u); err != nil {
197 return err
208 return err
198 }
209 }
199 }
210 }
internal/access/access_test.go +20 −5
@@ -86,23 +86,38 @@ func TestAuthorizeUpdate(t *testing.T) {
86 86 {Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/feature"},
87 87 {Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1"},
88 88 }
89 if err := AuthorizeUpdates(RoleDeveloper, patterns, dev); err != nil {
89 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, dev); err != nil {
90 90 t.Fatal(err)
91 91 }
92 92 protected := []RefUpdate{{Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/main"}}
93 if err := AuthorizeUpdates(RoleDeveloper, patterns, protected); err == nil {
93 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, protected); err == nil {
94 94 t.Fatal("ontwikkelaar mag main niet aanmaken")
95 95 }
96 if err := AuthorizeUpdates(RoleMaintainer, patterns, protected); err != nil {
96 if err := AuthorizeUpdates(RoleMaintainer, patterns, nil, protected); err != nil {
97 97 t.Fatal(err)
98 98 }
99 if err := AuthorizeUpdates(RoleReadonly, patterns, dev); err == nil {
99 if err := AuthorizeUpdates(RoleReadonly, patterns, nil, dev); err == nil {
100 100 t.Fatal("alleen-lezen mag niet pushen")
101 101 }
102 102 del := []RefUpdate{{Old: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", New: zero, Ref: "refs/heads/main"}}
103 if err := AuthorizeUpdates(RoleDeveloper, patterns, del); err == nil {
103 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, del); err == nil {
104 104 t.Fatal("ontwikkelaar mag main niet verwijderen")
105 105 }
106 tagHit := []RefUpdate{{Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1.2.3"}}
107 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, tagHit); err == nil {
108 t.Fatal("ontwikkelaar mag een beschermde tag niet zetten")
109 }
110 if err := AuthorizeUpdates(RoleMaintainer, nil, []string{"v*"}, tagHit); err != nil {
111 t.Fatal(err)
112 }
113 plain := []RefUpdate{{Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/beta"}}
114 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, plain); err != nil {
115 t.Fatal(err)
116 }
117 delTag := []RefUpdate{{Old: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", New: zero, Ref: "refs/tags/v1"}}
118 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, delTag); err == nil {
119 t.Fatal("ontwikkelaar mag een beschermde tag niet verwijderen")
120 }
106 121 }
107 122
108 123 func TestInjectSecret(t *testing.T) {
@@ -86,23 +86,38 @@ func TestAuthorizeUpdate(t *testing.T) {
86 {Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/feature"},
86 {Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/feature"},
87 {Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1"},
87 {Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1"},
88 }
88 }
89 if err := AuthorizeUpdates(RoleDeveloper, patterns, dev); err != nil {
89 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, dev); err != nil {
90 t.Fatal(err)
90 t.Fatal(err)
91 }
91 }
92 protected := []RefUpdate{{Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/main"}}
92 protected := []RefUpdate{{Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/main"}}
93 if err := AuthorizeUpdates(RoleDeveloper, patterns, protected); err == nil {
93 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, protected); err == nil {
94 t.Fatal("ontwikkelaar mag main niet aanmaken")
94 t.Fatal("ontwikkelaar mag main niet aanmaken")
95 }
95 }
96 if err := AuthorizeUpdates(RoleMaintainer, patterns, protected); err != nil {
96 if err := AuthorizeUpdates(RoleMaintainer, patterns, nil, protected); err != nil {
97 t.Fatal(err)
97 t.Fatal(err)
98 }
98 }
99 if err := AuthorizeUpdates(RoleReadonly, patterns, dev); err == nil {
99 if err := AuthorizeUpdates(RoleReadonly, patterns, nil, dev); err == nil {
100 t.Fatal("alleen-lezen mag niet pushen")
100 t.Fatal("alleen-lezen mag niet pushen")
101 }
101 }
102 del := []RefUpdate{{Old: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", New: zero, Ref: "refs/heads/main"}}
102 del := []RefUpdate{{Old: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", New: zero, Ref: "refs/heads/main"}}
103 if err := AuthorizeUpdates(RoleDeveloper, patterns, del); err == nil {
103 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, del); err == nil {
104 t.Fatal("ontwikkelaar mag main niet verwijderen")
104 t.Fatal("ontwikkelaar mag main niet verwijderen")
105 }
105 }
106 tagHit := []RefUpdate{{Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1.2.3"}}
107 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, tagHit); err == nil {
108 t.Fatal("ontwikkelaar mag een beschermde tag niet zetten")
109 }
110 if err := AuthorizeUpdates(RoleMaintainer, nil, []string{"v*"}, tagHit); err != nil {
111 t.Fatal(err)
112 }
113 plain := []RefUpdate{{Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/beta"}}
114 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, plain); err != nil {
115 t.Fatal(err)
116 }
117 delTag := []RefUpdate{{Old: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", New: zero, Ref: "refs/tags/v1"}}
118 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, delTag); err == nil {
119 t.Fatal("ontwikkelaar mag een beschermde tag niet verwijderen")
120 }
106}
121}
107
122
108func TestInjectSecret(t *testing.T) {
123func TestInjectSecret(t *testing.T) {
internal/gitrepo/repo.go +165 −4
@@ -10,10 +10,13 @@ import (
10 10 "os"
11 11 "os/exec"
12 12 "path/filepath"
13 "sort"
13 14 "strconv"
14 15 "strings"
15 16
16 17 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/i18n"
19 "gitlab.com/Timfa/bluegit/internal/names"
17 20 )
18 21
19 22 // Dir is de bare repository op de datadisk.
@@ -60,10 +63,11 @@ func shellQuote(s string) string {
60 63
61 64 // PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen
62 65 // weigert de hook, zodat een push buiten BlueGit om niet slaagt.
63 func PushEnv(role access.Role, patterns []string) []string {
66 func PushEnv(role access.Role, patterns, tagPatterns []string) []string {
64 67 return []string{
65 68 "BLUEGIT_ROLE=" + string(role),
66 69 "BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"),
70 "BLUEGIT_PROTECTED_TAGS=" + strings.Join(tagPatterns, "\n"),
67 71 }
68 72 }
69 73
@@ -86,7 +90,7 @@ func ReadUpdates(r io.Reader) ([]access.RefUpdate, error) {
86 90 }
87 91
88 92 // EvaluatePush is wat `bluegit hook pre-receive` doet.
89 func EvaluatePush(role access.Role, patterns []string, r io.Reader) error {
93 func EvaluatePush(role access.Role, patterns, tagPatterns []string, r io.Reader) error {
90 94 if role == "" {
91 95 return fmt.Errorf("push geweigerd: geen BlueGit-rol")
92 96 }
@@ -94,7 +98,7 @@ func EvaluatePush(role access.Role, patterns []string, r io.Reader) error {
94 98 if err != nil {
95 99 return err
96 100 }
97 return access.AuthorizeUpdates(role, patterns, ups)
101 return access.AuthorizeUpdates(role, patterns, tagPatterns, ups)
98 102 }
99 103
100 104 // Commit is één commit voor de webinterface.
@@ -355,6 +359,163 @@ func Tags(ctx context.Context, gitBin, dir string) ([]string, error) {
355 359 return names, nil
356 360 }
357 361
362 // TagInfo is één git-tag voor de webinterface.
363 type TagInfo struct {
364 Name string
365 Annotated bool
366 Message string
367 CommitSHA string
368 CommitSubject string
369 Unix int64
370 }
371
372 // ListTags geeft alle tags, nieuwste eerst.
373 func ListTags(ctx context.Context, gitBin, dir string) ([]TagInfo, error) {
374 const format = "%(refname:short)\n%(objecttype)\n%(objectname)\n%(*objectname)\n%(creatordate:unix)\n%(subject)\n%(*subject)\nBLUEGIT-END"
375 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--sort=-creatordate", "--format="+format, "refs/tags")
376 if err != nil {
377 return nil, err
378 }
379 lines := strings.Split(out, "\n")
380 if len(lines) > 0 && lines[len(lines)-1] == "" {
381 lines = lines[:len(lines)-1]
382 }
383 var tags []TagInfo
384 for i := 0; i+7 < len(lines); i += 8 {
385 if lines[i+7] != "BLUEGIT-END" {
386 continue
387 }
388 unix, _ := strconv.ParseInt(strings.TrimSpace(lines[i+4]), 10, 64)
389 tag := TagInfo{Name: lines[i], Unix: unix}
390 if lines[i+1] == "tag" {
391 tag.Annotated = true
392 tag.CommitSHA = lines[i+3]
393 tag.CommitSubject = lines[i+6]
394 if tag.CommitSHA == "" {
395 tag.CommitSHA = lines[i+2]
396 }
397 if tag.CommitSubject == "" {
398 tag.CommitSubject = lines[i+5]
399 }
400 msg, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(contents)", "refs/tags/"+tag.Name)
401 if err != nil {
402 return nil, err
403 }
404 tag.Message = strings.TrimSpace(msg)
405 } else {
406 tag.CommitSHA = lines[i+2]
407 tag.CommitSubject = lines[i+5]
408 }
409 if tag.Name != "" {
410 tags = append(tags, tag)
411 }
412 }
413 sort.SliceStable(tags, func(i, j int) bool {
414 if tags[i].Unix != tags[j].Unix {
415 return tags[i].Unix > tags[j].Unix
416 }
417 return tags[i].Name < tags[j].Name
418 })
419 return tags, nil
420 }
421
422 // CreateTag zet een tag op een branch of commit. Een leeg bericht blijft licht.
423 func CreateTag(ctx context.Context, gitBin, dir, name, rev, message, author, email string) error {
424 if err := names.ValidTag(name); err != nil {
425 return err
426 }
427 sha, err := resolveCommit(ctx, gitBin, dir, rev)
428 if err != nil {
429 return err
430 }
431 if HasTag(ctx, gitBin, dir, name) {
432 return i18n.E("err.tagExists", name)
433 }
434 message = strings.TrimSpace(message)
435 if len(message) > 5000 {
436 return i18n.E("err.tagLong")
437 }
438 env := identityEnv(author, email)
439 if message == "" {
440 _, err = run(ctx, gitBin, env, "-C", dir, "tag", name, sha)
441 return err
442 }
443 _, err = run(ctx, gitBin, env, "-C", dir, "tag", "-a", name, sha, "-m", message)
444 return err
445 }
446
447 // DeleteTag verwijdert een bestaande tag.
448 func DeleteTag(ctx context.Context, gitBin, dir, name string) error {
449 if err := usableTag(name); err != nil {
450 return err
451 }
452 if !HasTag(ctx, gitBin, dir, name) {
453 return i18n.E("err.tagMissing", name)
454 }
455 _, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-d", "--", name)
456 return err
457 }
458
459 // HasTag meldt of refs/tags/name bestaat.
460 func HasTag(ctx context.Context, gitBin, dir, name string) bool {
461 if err := usableTag(name); err != nil {
462 return false
463 }
464 _, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "-q", "--verify", "--end-of-options", "refs/tags/"+name)
465 return err == nil
466 }
467
468 // Archive schrijft een zip of tar.gz van de tag naar w.
469 func Archive(ctx context.Context, w io.Writer, gitBin, dir, prefix, name, format string) error {
470 if err := usableTag(name); err != nil {
471 return err
472 }
473 if !HasTag(ctx, gitBin, dir, name) {
474 return i18n.E("err.tagMissing", name)
475 }
476 kind := format
477 if format != "zip" && format != "tar.gz" {
478 return i18n.E("err.notFound")
479 }
480 if gitBin == "" {
481 gitBin = "git"
482 }
483 if prefix != "" && !strings.HasSuffix(prefix, "/") {
484 prefix += "/"
485 }
486 cmd := exec.CommandContext(ctx, gitBin, "-C", dir, "archive", "--format="+kind, "--prefix="+prefix, name)
487 cmd.Stdout = w
488 var stderr bytes.Buffer
489 cmd.Stderr = &stderr
490 if err := cmd.Run(); err != nil {
491 msg := strings.TrimSpace(stderr.String())
492 if msg == "" {
493 msg = err.Error()
494 }
495 return fmt.Errorf("%s", msg)
496 }
497 return nil
498 }
499
500 func resolveCommit(ctx context.Context, gitBin, dir, rev string) (string, error) {
501 rev = strings.TrimSpace(rev)
502 if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
503 return "", i18n.E("err.tagRef", rev)
504 }
505 out, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "--verify", "--end-of-options", rev+"^{commit}")
506 if err != nil {
507 return "", i18n.E("err.tagRef", rev)
508 }
509 return strings.TrimSpace(out), nil
510 }
511
512 func usableTag(name string) error {
513 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\\~^:?*[") {
514 return i18n.E("err.tag", name)
515 }
516 return nil
517 }
518
358 519 // TreeAll leest de hele boom. Name is het pad vanaf de root.
359 520 func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) {
360 521 if rev == "" {
@@ -506,7 +667,7 @@ func Merge(ctx context.Context, gitBin, bare, work, source, target, author, emai
506 667 if _, err := run(ctx, gitBin, env, "-C", work, "merge", "--no-ff", "--no-edit", "-m", message, source); err != nil {
507 668 return fmt.Errorf("samenvoegen lukt niet, er is een conflict of de branch ontbreekt")
508 669 }
509 pushEnv := append(env, PushEnv(role, patterns)...)
670 pushEnv := append(env, PushEnv(role, patterns, nil)...)
510 671 if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", target); err != nil {
511 672 return err
512 673 }
@@ -10,10 +10,13 @@ import (
10 "os"
10 "os"
11 "os/exec"
11 "os/exec"
12 "path/filepath"
12 "path/filepath"
13 "sort"
13 "strconv"
14 "strconv"
14 "strings"
15 "strings"
15
16
16 "gitlab.com/Timfa/bluegit/internal/access"
17 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/i18n"
19 "gitlab.com/Timfa/bluegit/internal/names"
17)
20)
18
21
19// Dir is de bare repository op de datadisk.
22// Dir is de bare repository op de datadisk.
@@ -60,10 +63,11 @@ func shellQuote(s string) string {
60
63
61// PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen
64// PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen
62// weigert de hook, zodat een push buiten BlueGit om niet slaagt.
65// weigert de hook, zodat een push buiten BlueGit om niet slaagt.
63func PushEnv(role access.Role, patterns []string) []string {
66func PushEnv(role access.Role, patterns, tagPatterns []string) []string {
64 return []string{
67 return []string{
65 "BLUEGIT_ROLE=" + string(role),
68 "BLUEGIT_ROLE=" + string(role),
66 "BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"),
69 "BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"),
70 "BLUEGIT_PROTECTED_TAGS=" + strings.Join(tagPatterns, "\n"),
67 }
71 }
68}
72}
69
73
@@ -86,7 +90,7 @@ func ReadUpdates(r io.Reader) ([]access.RefUpdate, error) {
86}
90}
87
91
88// EvaluatePush is wat `bluegit hook pre-receive` doet.
92// EvaluatePush is wat `bluegit hook pre-receive` doet.
89func EvaluatePush(role access.Role, patterns []string, r io.Reader) error {
93func EvaluatePush(role access.Role, patterns, tagPatterns []string, r io.Reader) error {
90 if role == "" {
94 if role == "" {
91 return fmt.Errorf("push geweigerd: geen BlueGit-rol")
95 return fmt.Errorf("push geweigerd: geen BlueGit-rol")
92 }
96 }
@@ -94,7 +98,7 @@ func EvaluatePush(role access.Role, patterns []string, r io.Reader) error {
94 if err != nil {
98 if err != nil {
95 return err
99 return err
96 }
100 }
97 return access.AuthorizeUpdates(role, patterns, ups)
101 return access.AuthorizeUpdates(role, patterns, tagPatterns, ups)
98}
102}
99
103
100// Commit is één commit voor de webinterface.
104// Commit is één commit voor de webinterface.
@@ -355,6 +359,163 @@ func Tags(ctx context.Context, gitBin, dir string) ([]string, error) {
355 return names, nil
359 return names, nil
356}
360}
357
361
362// TagInfo is één git-tag voor de webinterface.
363type TagInfo struct {
364 Name string
365 Annotated bool
366 Message string
367 CommitSHA string
368 CommitSubject string
369 Unix int64
370}
371
372// ListTags geeft alle tags, nieuwste eerst.
373func ListTags(ctx context.Context, gitBin, dir string) ([]TagInfo, error) {
374 const format = "%(refname:short)\n%(objecttype)\n%(objectname)\n%(*objectname)\n%(creatordate:unix)\n%(subject)\n%(*subject)\nBLUEGIT-END"
375 out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--sort=-creatordate", "--format="+format, "refs/tags")
376 if err != nil {
377 return nil, err
378 }
379 lines := strings.Split(out, "\n")
380 if len(lines) > 0 && lines[len(lines)-1] == "" {
381 lines = lines[:len(lines)-1]
382 }
383 var tags []TagInfo
384 for i := 0; i+7 < len(lines); i += 8 {
385 if lines[i+7] != "BLUEGIT-END" {
386 continue
387 }
388 unix, _ := strconv.ParseInt(strings.TrimSpace(lines[i+4]), 10, 64)
389 tag := TagInfo{Name: lines[i], Unix: unix}
390 if lines[i+1] == "tag" {
391 tag.Annotated = true
392 tag.CommitSHA = lines[i+3]
393 tag.CommitSubject = lines[i+6]
394 if tag.CommitSHA == "" {
395 tag.CommitSHA = lines[i+2]
396 }
397 if tag.CommitSubject == "" {
398 tag.CommitSubject = lines[i+5]
399 }
400 msg, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(contents)", "refs/tags/"+tag.Name)
401 if err != nil {
402 return nil, err
403 }
404 tag.Message = strings.TrimSpace(msg)
405 } else {
406 tag.CommitSHA = lines[i+2]
407 tag.CommitSubject = lines[i+5]
408 }
409 if tag.Name != "" {
410 tags = append(tags, tag)
411 }
412 }
413 sort.SliceStable(tags, func(i, j int) bool {
414 if tags[i].Unix != tags[j].Unix {
415 return tags[i].Unix > tags[j].Unix
416 }
417 return tags[i].Name < tags[j].Name
418 })
419 return tags, nil
420}
421
422// CreateTag zet een tag op een branch of commit. Een leeg bericht blijft licht.
423func CreateTag(ctx context.Context, gitBin, dir, name, rev, message, author, email string) error {
424 if err := names.ValidTag(name); err != nil {
425 return err
426 }
427 sha, err := resolveCommit(ctx, gitBin, dir, rev)
428 if err != nil {
429 return err
430 }
431 if HasTag(ctx, gitBin, dir, name) {
432 return i18n.E("err.tagExists", name)
433 }
434 message = strings.TrimSpace(message)
435 if len(message) > 5000 {
436 return i18n.E("err.tagLong")
437 }
438 env := identityEnv(author, email)
439 if message == "" {
440 _, err = run(ctx, gitBin, env, "-C", dir, "tag", name, sha)
441 return err
442 }
443 _, err = run(ctx, gitBin, env, "-C", dir, "tag", "-a", name, sha, "-m", message)
444 return err
445}
446
447// DeleteTag verwijdert een bestaande tag.
448func DeleteTag(ctx context.Context, gitBin, dir, name string) error {
449 if err := usableTag(name); err != nil {
450 return err
451 }
452 if !HasTag(ctx, gitBin, dir, name) {
453 return i18n.E("err.tagMissing", name)
454 }
455 _, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-d", "--", name)
456 return err
457}
458
459// HasTag meldt of refs/tags/name bestaat.
460func HasTag(ctx context.Context, gitBin, dir, name string) bool {
461 if err := usableTag(name); err != nil {
462 return false
463 }
464 _, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "-q", "--verify", "--end-of-options", "refs/tags/"+name)
465 return err == nil
466}
467
468// Archive schrijft een zip of tar.gz van de tag naar w.
469func Archive(ctx context.Context, w io.Writer, gitBin, dir, prefix, name, format string) error {
470 if err := usableTag(name); err != nil {
471 return err
472 }
473 if !HasTag(ctx, gitBin, dir, name) {
474 return i18n.E("err.tagMissing", name)
475 }
476 kind := format
477 if format != "zip" && format != "tar.gz" {
478 return i18n.E("err.notFound")
479 }
480 if gitBin == "" {
481 gitBin = "git"
482 }
483 if prefix != "" && !strings.HasSuffix(prefix, "/") {
484 prefix += "/"
485 }
486 cmd := exec.CommandContext(ctx, gitBin, "-C", dir, "archive", "--format="+kind, "--prefix="+prefix, name)
487 cmd.Stdout = w
488 var stderr bytes.Buffer
489 cmd.Stderr = &stderr
490 if err := cmd.Run(); err != nil {
491 msg := strings.TrimSpace(stderr.String())
492 if msg == "" {
493 msg = err.Error()
494 }
495 return fmt.Errorf("%s", msg)
496 }
497 return nil
498}
499
500func resolveCommit(ctx context.Context, gitBin, dir, rev string) (string, error) {
501 rev = strings.TrimSpace(rev)
502 if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
503 return "", i18n.E("err.tagRef", rev)
504 }
505 out, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "--verify", "--end-of-options", rev+"^{commit}")
506 if err != nil {
507 return "", i18n.E("err.tagRef", rev)
508 }
509 return strings.TrimSpace(out), nil
510}
511
512func usableTag(name string) error {
513 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\\~^:?*[") {
514 return i18n.E("err.tag", name)
515 }
516 return nil
517}
518
358// TreeAll leest de hele boom. Name is het pad vanaf de root.
519// TreeAll leest de hele boom. Name is het pad vanaf de root.
359func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) {
520func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) {
360 if rev == "" {
521 if rev == "" {
@@ -506,7 +667,7 @@ func Merge(ctx context.Context, gitBin, bare, work, source, target, author, emai
506 if _, err := run(ctx, gitBin, env, "-C", work, "merge", "--no-ff", "--no-edit", "-m", message, source); err != nil {
667 if _, err := run(ctx, gitBin, env, "-C", work, "merge", "--no-ff", "--no-edit", "-m", message, source); err != nil {
507 return fmt.Errorf("samenvoegen lukt niet, er is een conflict of de branch ontbreekt")
668 return fmt.Errorf("samenvoegen lukt niet, er is een conflict of de branch ontbreekt")
508 }
669 }
509 pushEnv := append(env, PushEnv(role, patterns)...)
670 pushEnv := append(env, PushEnv(role, patterns, nil)...)
510 if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", target); err != nil {
671 if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", target); err != nil {
511 return err
672 return err
512 }
673 }
internal/gitrepo/repo_test.go +8 −3
@@ -14,18 +14,23 @@ import (
14 14 func TestEvaluatePush(t *testing.T) {
15 15 var buf bytes.Buffer
16 16 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/main\n")
17 err := EvaluatePush(access.RoleDeveloper, []string{"main"}, &buf)
17 err := EvaluatePush(access.RoleDeveloper, []string{"main"}, nil, &buf)
18 18 if err == nil {
19 19 t.Fatal("ontwikkelaar mag main niet")
20 20 }
21 21 buf.Reset()
22 22 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/feature\n")
23 if err := EvaluatePush(access.RoleDeveloper, []string{"main"}, &buf); err != nil {
23 if err := EvaluatePush(access.RoleDeveloper, []string{"main"}, nil, &buf); err != nil {
24 24 t.Fatal(err)
25 25 }
26 if err := EvaluatePush(access.RoleMaintainer, nil, strings.NewReader("")); err == nil {
26 if err := EvaluatePush(access.RoleMaintainer, nil, nil, strings.NewReader("")); err == nil {
27 27 t.Fatal("lege push")
28 28 }
29 buf.Reset()
30 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/tags/v1\n")
31 if err := EvaluatePush(access.RoleDeveloper, nil, []string{"v*"}, &buf); err == nil {
32 t.Fatal("ontwikkelaar mag v1 niet")
33 }
29 34 }
30 35
31 36 func TestTouchAndStats(t *testing.T) {
@@ -14,18 +14,23 @@ import (
14func TestEvaluatePush(t *testing.T) {
14func TestEvaluatePush(t *testing.T) {
15 var buf bytes.Buffer
15 var buf bytes.Buffer
16 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/main\n")
16 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/main\n")
17 err := EvaluatePush(access.RoleDeveloper, []string{"main"}, &buf)
17 err := EvaluatePush(access.RoleDeveloper, []string{"main"}, nil, &buf)
18 if err == nil {
18 if err == nil {
19 t.Fatal("ontwikkelaar mag main niet")
19 t.Fatal("ontwikkelaar mag main niet")
20 }
20 }
21 buf.Reset()
21 buf.Reset()
22 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/feature\n")
22 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/feature\n")
23 if err := EvaluatePush(access.RoleDeveloper, []string{"main"}, &buf); err != nil {
23 if err := EvaluatePush(access.RoleDeveloper, []string{"main"}, nil, &buf); err != nil {
24 t.Fatal(err)
24 t.Fatal(err)
25 }
25 }
26 if err := EvaluatePush(access.RoleMaintainer, nil, strings.NewReader("")); err == nil {
26 if err := EvaluatePush(access.RoleMaintainer, nil, nil, strings.NewReader("")); err == nil {
27 t.Fatal("lege push")
27 t.Fatal("lege push")
28 }
28 }
29 buf.Reset()
30 buf.WriteString("0000000000000000000000000000000000000000 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/tags/v1\n")
31 if err := EvaluatePush(access.RoleDeveloper, nil, []string{"v*"}, &buf); err == nil {
32 t.Fatal("ontwikkelaar mag v1 niet")
33 }
29}
34}
30
35
31func TestTouchAndStats(t *testing.T) {
36func TestTouchAndStats(t *testing.T) {
internal/gitrepo/suggest.go +1 −1
@@ -148,7 +148,7 @@ func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, ema
148 148 if _, err := run(ctx, gitBin, env, commit...); err != nil {
149 149 return err
150 150 }
151 pushEnv := append(env, PushEnv(role, patterns)...)
151 pushEnv := append(env, PushEnv(role, patterns, nil)...)
152 152 if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", "HEAD:"+branch); err != nil {
153 153 return err
154 154 }
@@ -148,7 +148,7 @@ func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, ema
148 if _, err := run(ctx, gitBin, env, commit...); err != nil {
148 if _, err := run(ctx, gitBin, env, commit...); err != nil {
149 return err
149 return err
150 }
150 }
151 pushEnv := append(env, PushEnv(role, patterns)...)
151 pushEnv := append(env, PushEnv(role, patterns, nil)...)
152 if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", "HEAD:"+branch); err != nil {
152 if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", "HEAD:"+branch); err != nil {
153 return err
153 return err
154 }
154 }
internal/gitrepo/tags_test.go added +127 −0
@@ -0,0 +1,127 @@
1 package gitrepo
2
3 import (
4 "bytes"
5 "context"
6 "os"
7 "os/exec"
8 "path/filepath"
9 "strings"
10 "testing"
11 )
12
13 func TestListCreateDeleteArchive(t *testing.T) {
14 if _, err := exec.LookPath("git"); err != nil {
15 t.Skip("git ontbreekt")
16 }
17 ctx := context.Background()
18 dir := filepath.Join(t.TempDir(), "demo.git")
19 if err := Init("git", dir, "master", "/bin/true"); err != nil {
20 t.Fatal(err)
21 }
22 work := t.TempDir()
23 gitc := func(args ...string) {
24 t.Helper()
25 cmd := exec.Command("git", args...)
26 cmd.Dir = work
27 cmd.Env = append(os.Environ(),
28 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
29 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
30 )
31 if out, err := cmd.CombinedOutput(); err != nil {
32 t.Fatalf("%v: %v\n%s", args, err, out)
33 }
34 }
35 gitc("init", "-b", "master")
36 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo\n"), 0o644); err != nil {
37 t.Fatal(err)
38 }
39 gitc("add", "README.md")
40 cmd := exec.Command("git", "commit", "-m", "eerste commit")
41 cmd.Dir = work
42 cmd.Env = append(os.Environ(),
43 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
44 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
45 "GIT_AUTHOR_DATE=2020-01-02T00:00:00Z", "GIT_COMMITTER_DATE=2020-01-02T00:00:00Z",
46 )
47 if out, err := cmd.CombinedOutput(); err != nil {
48 t.Fatalf("commit: %v\n%s", err, out)
49 }
50 old, err := exec.Command("git", "-C", work, "rev-parse", "HEAD").Output()
51 if err != nil {
52 t.Fatal(err)
53 }
54 oldSHA := strings.TrimSpace(string(old))
55 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("later\n"), 0o644); err != nil {
56 t.Fatal(err)
57 }
58 gitc("add", "README.md")
59 cmd = exec.Command("git", "commit", "-m", "tweede commit")
60 cmd.Dir = work
61 cmd.Env = append(os.Environ(),
62 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
63 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
64 "GIT_AUTHOR_DATE=2021-05-01T00:00:00Z", "GIT_COMMITTER_DATE=2021-05-01T00:00:00Z",
65 )
66 if out, err := cmd.CombinedOutput(); err != nil {
67 t.Fatalf("commit: %v\n%s", err, out)
68 }
69 gitc("remote", "add", "origin", dir)
70 gitc("push", "origin", "master")
71
72 if _, err := run(ctx, "git", os.Environ(), "-C", dir, "tag", "oud", oldSHA); err != nil {
73 t.Fatal(err)
74 }
75 annEnv := append(os.Environ(),
76 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
77 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
78 "GIT_COMMITTER_DATE=2024-03-01T00:00:00Z",
79 )
80 if _, err := run(ctx, "git", annEnv, "-C", dir, "tag", "-a", "v1.2", oldSHA, "-m", "uitgave\nextra regel"); err != nil {
81 t.Fatal(err)
82 }
83
84 tags, err := ListTags(ctx, "git", dir)
85 if err != nil {
86 t.Fatal(err)
87 }
88 if len(tags) != 2 || tags[0].Name != "v1.2" || tags[1].Name != "oud" {
89 t.Fatalf("volgorde %+v", tags)
90 }
91 if !tags[0].Annotated || tags[0].Message != "uitgave\nextra regel" || tags[0].CommitSubject != "eerste commit" || tags[0].CommitSHA != oldSHA {
92 t.Fatalf("annotated %+v", tags[0])
93 }
94 if tags[1].Annotated || tags[1].CommitSubject != "eerste commit" {
95 t.Fatalf("licht %+v", tags[1])
96 }
97
98 if err := CreateTag(ctx, "git", dir, "beta", "master", "", "ada", "ada@example.com"); err != nil {
99 t.Fatal(err)
100 }
101 if err := CreateTag(ctx, "git", dir, "beta", "master", "nog eens", "ada", "ada@example.com"); err == nil {
102 t.Fatal("dubbele tag")
103 }
104 if err := CreateTag(ctx, "git", dir, "nee", "geen-branch", "", "ada", "ada@example.com"); err == nil {
105 t.Fatal("ontbrekende ref")
106 }
107 if err := DeleteTag(ctx, "git", dir, "oud"); err != nil {
108 t.Fatal(err)
109 }
110 if HasTag(ctx, "git", dir, "oud") {
111 t.Fatal("oud bleef staan")
112 }
113
114 var zip, gz bytes.Buffer
115 if err := Archive(ctx, &zip, "git", dir, "demo-v1.2", "v1.2", "zip"); err != nil {
116 t.Fatal(err)
117 }
118 if !bytes.HasPrefix(zip.Bytes(), []byte("PK")) {
119 t.Fatalf("zip %x", zip.Bytes()[:4])
120 }
121 if err := Archive(ctx, &gz, "git", dir, "demo-v1.2", "v1.2", "tar.gz"); err != nil {
122 t.Fatal(err)
123 }
124 if len(gz.Bytes()) < 3 || gz.Bytes()[0] != 0x1f || gz.Bytes()[1] != 0x8b {
125 t.Fatalf("gzip %x", gz.Bytes()[:3])
126 }
127 }
@@ -0,0 +1,127 @@
1package gitrepo
2
3import (
4 "bytes"
5 "context"
6 "os"
7 "os/exec"
8 "path/filepath"
9 "strings"
10 "testing"
11)
12
13func TestListCreateDeleteArchive(t *testing.T) {
14 if _, err := exec.LookPath("git"); err != nil {
15 t.Skip("git ontbreekt")
16 }
17 ctx := context.Background()
18 dir := filepath.Join(t.TempDir(), "demo.git")
19 if err := Init("git", dir, "master", "/bin/true"); err != nil {
20 t.Fatal(err)
21 }
22 work := t.TempDir()
23 gitc := func(args ...string) {
24 t.Helper()
25 cmd := exec.Command("git", args...)
26 cmd.Dir = work
27 cmd.Env = append(os.Environ(),
28 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
29 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
30 )
31 if out, err := cmd.CombinedOutput(); err != nil {
32 t.Fatalf("%v: %v\n%s", args, err, out)
33 }
34 }
35 gitc("init", "-b", "master")
36 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo\n"), 0o644); err != nil {
37 t.Fatal(err)
38 }
39 gitc("add", "README.md")
40 cmd := exec.Command("git", "commit", "-m", "eerste commit")
41 cmd.Dir = work
42 cmd.Env = append(os.Environ(),
43 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
44 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
45 "GIT_AUTHOR_DATE=2020-01-02T00:00:00Z", "GIT_COMMITTER_DATE=2020-01-02T00:00:00Z",
46 )
47 if out, err := cmd.CombinedOutput(); err != nil {
48 t.Fatalf("commit: %v\n%s", err, out)
49 }
50 old, err := exec.Command("git", "-C", work, "rev-parse", "HEAD").Output()
51 if err != nil {
52 t.Fatal(err)
53 }
54 oldSHA := strings.TrimSpace(string(old))
55 if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("later\n"), 0o644); err != nil {
56 t.Fatal(err)
57 }
58 gitc("add", "README.md")
59 cmd = exec.Command("git", "commit", "-m", "tweede commit")
60 cmd.Dir = work
61 cmd.Env = append(os.Environ(),
62 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
63 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
64 "GIT_AUTHOR_DATE=2021-05-01T00:00:00Z", "GIT_COMMITTER_DATE=2021-05-01T00:00:00Z",
65 )
66 if out, err := cmd.CombinedOutput(); err != nil {
67 t.Fatalf("commit: %v\n%s", err, out)
68 }
69 gitc("remote", "add", "origin", dir)
70 gitc("push", "origin", "master")
71
72 if _, err := run(ctx, "git", os.Environ(), "-C", dir, "tag", "oud", oldSHA); err != nil {
73 t.Fatal(err)
74 }
75 annEnv := append(os.Environ(),
76 "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com",
77 "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com",
78 "GIT_COMMITTER_DATE=2024-03-01T00:00:00Z",
79 )
80 if _, err := run(ctx, "git", annEnv, "-C", dir, "tag", "-a", "v1.2", oldSHA, "-m", "uitgave\nextra regel"); err != nil {
81 t.Fatal(err)
82 }
83
84 tags, err := ListTags(ctx, "git", dir)
85 if err != nil {
86 t.Fatal(err)
87 }
88 if len(tags) != 2 || tags[0].Name != "v1.2" || tags[1].Name != "oud" {
89 t.Fatalf("volgorde %+v", tags)
90 }
91 if !tags[0].Annotated || tags[0].Message != "uitgave\nextra regel" || tags[0].CommitSubject != "eerste commit" || tags[0].CommitSHA != oldSHA {
92 t.Fatalf("annotated %+v", tags[0])
93 }
94 if tags[1].Annotated || tags[1].CommitSubject != "eerste commit" {
95 t.Fatalf("licht %+v", tags[1])
96 }
97
98 if err := CreateTag(ctx, "git", dir, "beta", "master", "", "ada", "ada@example.com"); err != nil {
99 t.Fatal(err)
100 }
101 if err := CreateTag(ctx, "git", dir, "beta", "master", "nog eens", "ada", "ada@example.com"); err == nil {
102 t.Fatal("dubbele tag")
103 }
104 if err := CreateTag(ctx, "git", dir, "nee", "geen-branch", "", "ada", "ada@example.com"); err == nil {
105 t.Fatal("ontbrekende ref")
106 }
107 if err := DeleteTag(ctx, "git", dir, "oud"); err != nil {
108 t.Fatal(err)
109 }
110 if HasTag(ctx, "git", dir, "oud") {
111 t.Fatal("oud bleef staan")
112 }
113
114 var zip, gz bytes.Buffer
115 if err := Archive(ctx, &zip, "git", dir, "demo-v1.2", "v1.2", "zip"); err != nil {
116 t.Fatal(err)
117 }
118 if !bytes.HasPrefix(zip.Bytes(), []byte("PK")) {
119 t.Fatalf("zip %x", zip.Bytes()[:4])
120 }
121 if err := Archive(ctx, &gz, "git", dir, "demo-v1.2", "v1.2", "tar.gz"); err != nil {
122 t.Fatal(err)
123 }
124 if len(gz.Bytes()) < 3 || gz.Bytes()[0] != 0x1f || gz.Bytes()[1] != 0x8b {
125 t.Fatalf("gzip %x", gz.Bytes()[:3])
126 }
127}
internal/i18n/catalog.go +28 −0
@@ -124,6 +124,7 @@ var en = map[string]string{
124 124 "tab.mrs": "Merge requests",
125 125 "tab.pipelines": "Pipelines",
126 126 "tab.releases": "Releases",
127 "tab.tags": "Tags",
127 128 "tab.settings": "Settings",
128 129
129 130 "repo.searchFile": "Find file",
@@ -142,6 +143,21 @@ var en = map[string]string{
142 143 "repo.files": "Files",
143 144 "repo.binary": "Binary file.",
144 145 "repo.noTags": "No tags yet.",
146 "tag.search": "Find a tag",
147 "tag.create": "Create tag",
148 "tag.name": "Name",
149 "tag.target": "Branch or commit",
150 "tag.message": "Message",
151 "tag.date": "Date",
152 "tag.commit": "Commit",
153 "tag.annotated": "Annotated",
154 "tag.lightweight": "Lightweight",
155 "tag.release": "Release",
156 "tag.zip": "zip",
157 "tag.tgz": "tar.gz",
158 "tag.delete": "Delete",
159 "tag.confirm": "Delete tag %s?",
160 "tag.noMatch": "No matching tags.",
145 161 "repo.noBranches": "No branches yet.",
146 162 "count.commit.one": "%d commit", "count.commit.many": "%d commits",
147 163 "count.branch.one": "%d branch", "count.branch.many": "%d branches",
@@ -265,12 +281,15 @@ var en = map[string]string{
265 281 "set.general": "General",
266 282 "set.members": "Members",
267 283 "set.branches": "Branches",
284 "set.tags": "Tags",
268 285 "set.secrets": "Secrets",
269 286 "set.webhooks": "Webhooks",
270 287 "set.username": "username",
271 288 "set.pending": "waiting for the first sign-in",
272 289 "set.pattern": "master or release/*",
273 290 "set.protectHint": "Developers cannot push to these branches.",
291 "set.tagPattern": "v*",
292 "set.tagHint": "Developers cannot create or delete these tags.",
274 293 "set.secretName": "Name",
275 294 "set.secretValue": "Value",
276 295 "set.protectedOnly": "Only include on a protected branch",
@@ -321,6 +340,10 @@ var en = map[string]string{
321 340 "flash.memberSaved": "Member saved",
322 341 "flash.memberRemoved": "Member removed",
323 342 "flash.branchOn": "Branch protected",
343 "flash.tagCreated": "Tag created",
344 "flash.tagDeleted": "Tag deleted",
345 "flash.tagOn": "Tag pattern protected",
346 "flash.tagOff": "Tag pattern removed",
324 347 "flash.patternOff": "Pattern removed",
325 348 "flash.secretSaved": "Secret saved",
326 349 "flash.secretRemoved": "Secret removed",
@@ -389,11 +412,16 @@ var en = map[string]string{
389 412 "err.noteEmpty": "a comment is empty",
390 413 "err.mrTitle": "a merge request needs a title",
391 414 "err.tagExists": "tag %s already exists",
415 "err.tagProtected": "tag %s is protected",
416 "err.tagMissing": "tag %s does not exist",
417 "err.tagRef": "branch or commit %q was not found",
418 "err.tagLong": "the message is too long",
392 419 "err.roleMissing": "role is missing",
393 420 "err.roleUnknown": "unknown role %q",
394 421 "err.hook.nowrite": "no write access on %s",
395 422 "err.hook.branch": "invalid branch %q",
396 423 "err.hook.protected": "branch %s is protected; only a maintainer may change it",
424 "err.hook.tag": "tag %s is protected; only a maintainer may change it",
397 425 "err.hook.empty": "empty push",
398 426 "err.secretLen": "a secret name must be 1 to 80 characters",
399 427 "err.secretForm": "secret name %q must match [A-Z][A-Z0-9_]*",
@@ -124,6 +124,7 @@ var en = map[string]string{
124 "tab.mrs": "Merge requests",
124 "tab.mrs": "Merge requests",
125 "tab.pipelines": "Pipelines",
125 "tab.pipelines": "Pipelines",
126 "tab.releases": "Releases",
126 "tab.releases": "Releases",
127 "tab.tags": "Tags",
127 "tab.settings": "Settings",
128 "tab.settings": "Settings",
128
129
129 "repo.searchFile": "Find file",
130 "repo.searchFile": "Find file",
@@ -142,6 +143,21 @@ var en = map[string]string{
142 "repo.files": "Files",
143 "repo.files": "Files",
143 "repo.binary": "Binary file.",
144 "repo.binary": "Binary file.",
144 "repo.noTags": "No tags yet.",
145 "repo.noTags": "No tags yet.",
146 "tag.search": "Find a tag",
147 "tag.create": "Create tag",
148 "tag.name": "Name",
149 "tag.target": "Branch or commit",
150 "tag.message": "Message",
151 "tag.date": "Date",
152 "tag.commit": "Commit",
153 "tag.annotated": "Annotated",
154 "tag.lightweight": "Lightweight",
155 "tag.release": "Release",
156 "tag.zip": "zip",
157 "tag.tgz": "tar.gz",
158 "tag.delete": "Delete",
159 "tag.confirm": "Delete tag %s?",
160 "tag.noMatch": "No matching tags.",
145 "repo.noBranches": "No branches yet.",
161 "repo.noBranches": "No branches yet.",
146 "count.commit.one": "%d commit", "count.commit.many": "%d commits",
162 "count.commit.one": "%d commit", "count.commit.many": "%d commits",
147 "count.branch.one": "%d branch", "count.branch.many": "%d branches",
163 "count.branch.one": "%d branch", "count.branch.many": "%d branches",
@@ -265,12 +281,15 @@ var en = map[string]string{
265 "set.general": "General",
281 "set.general": "General",
266 "set.members": "Members",
282 "set.members": "Members",
267 "set.branches": "Branches",
283 "set.branches": "Branches",
284 "set.tags": "Tags",
268 "set.secrets": "Secrets",
285 "set.secrets": "Secrets",
269 "set.webhooks": "Webhooks",
286 "set.webhooks": "Webhooks",
270 "set.username": "username",
287 "set.username": "username",
271 "set.pending": "waiting for the first sign-in",
288 "set.pending": "waiting for the first sign-in",
272 "set.pattern": "master or release/*",
289 "set.pattern": "master or release/*",
273 "set.protectHint": "Developers cannot push to these branches.",
290 "set.protectHint": "Developers cannot push to these branches.",
291 "set.tagPattern": "v*",
292 "set.tagHint": "Developers cannot create or delete these tags.",
274 "set.secretName": "Name",
293 "set.secretName": "Name",
275 "set.secretValue": "Value",
294 "set.secretValue": "Value",
276 "set.protectedOnly": "Only include on a protected branch",
295 "set.protectedOnly": "Only include on a protected branch",
@@ -321,6 +340,10 @@ var en = map[string]string{
321 "flash.memberSaved": "Member saved",
340 "flash.memberSaved": "Member saved",
322 "flash.memberRemoved": "Member removed",
341 "flash.memberRemoved": "Member removed",
323 "flash.branchOn": "Branch protected",
342 "flash.branchOn": "Branch protected",
343 "flash.tagCreated": "Tag created",
344 "flash.tagDeleted": "Tag deleted",
345 "flash.tagOn": "Tag pattern protected",
346 "flash.tagOff": "Tag pattern removed",
324 "flash.patternOff": "Pattern removed",
347 "flash.patternOff": "Pattern removed",
325 "flash.secretSaved": "Secret saved",
348 "flash.secretSaved": "Secret saved",
326 "flash.secretRemoved": "Secret removed",
349 "flash.secretRemoved": "Secret removed",
@@ -389,11 +412,16 @@ var en = map[string]string{
389 "err.noteEmpty": "a comment is empty",
412 "err.noteEmpty": "a comment is empty",
390 "err.mrTitle": "a merge request needs a title",
413 "err.mrTitle": "a merge request needs a title",
391 "err.tagExists": "tag %s already exists",
414 "err.tagExists": "tag %s already exists",
415 "err.tagProtected": "tag %s is protected",
416 "err.tagMissing": "tag %s does not exist",
417 "err.tagRef": "branch or commit %q was not found",
418 "err.tagLong": "the message is too long",
392 "err.roleMissing": "role is missing",
419 "err.roleMissing": "role is missing",
393 "err.roleUnknown": "unknown role %q",
420 "err.roleUnknown": "unknown role %q",
394 "err.hook.nowrite": "no write access on %s",
421 "err.hook.nowrite": "no write access on %s",
395 "err.hook.branch": "invalid branch %q",
422 "err.hook.branch": "invalid branch %q",
396 "err.hook.protected": "branch %s is protected; only a maintainer may change it",
423 "err.hook.protected": "branch %s is protected; only a maintainer may change it",
424 "err.hook.tag": "tag %s is protected; only a maintainer may change it",
397 "err.hook.empty": "empty push",
425 "err.hook.empty": "empty push",
398 "err.secretLen": "a secret name must be 1 to 80 characters",
426 "err.secretLen": "a secret name must be 1 to 80 characters",
399 "err.secretForm": "secret name %q must match [A-Z][A-Z0-9_]*",
427 "err.secretForm": "secret name %q must match [A-Z][A-Z0-9_]*",
internal/i18n/catalog_lang.go +84 −0
@@ -130,6 +130,7 @@ var nl = map[string]string{
130 130 "tab.mrs": "Merge requests",
131 131 "tab.pipelines": "Pipelines",
132 132 "tab.releases": "Releases",
133 "tab.tags": "Tags",
133 134 "tab.settings": "Instellingen",
134 135 "repo.searchFile": "Bestand zoeken",
135 136 "repo.code": "Code",
@@ -147,6 +148,21 @@ var nl = map[string]string{
147 148 "repo.files": "Bestanden",
148 149 "repo.binary": "Binair bestand.",
149 150 "repo.noTags": "Nog geen tags.",
151 "tag.search": "Zoek een tag",
152 "tag.create": "Tag aanmaken",
153 "tag.name": "Naam",
154 "tag.target": "Branch of commit",
155 "tag.message": "Bericht",
156 "tag.date": "Datum",
157 "tag.commit": "Commit",
158 "tag.annotated": "Met bericht",
159 "tag.lightweight": "Zonder bericht",
160 "tag.release": "Release",
161 "tag.zip": "zip",
162 "tag.tgz": "tar.gz",
163 "tag.delete": "Verwijderen",
164 "tag.confirm": "Tag %s verwijderen?",
165 "tag.noMatch": "Geen passende tags.",
150 166 "repo.noBranches": "Nog geen branches.",
151 167 "count.commit.one": "%d commit",
152 168 "count.commit.many": "%d commits",
@@ -269,12 +285,15 @@ var nl = map[string]string{
269 285 "set.general": "Algemeen",
270 286 "set.members": "Leden",
271 287 "set.branches": "Branches",
288 "set.tags": "Tags",
272 289 "set.secrets": "Geheimen",
273 290 "set.webhooks": "Webhooks",
274 291 "set.username": "gebruikersnaam",
275 292 "set.pending": "wacht op eerste aanmelding",
276 293 "set.pattern": "master of release/*",
277 294 "set.protectHint": "Ontwikkelaars kunnen niet naar deze branches pushen.",
295 "set.tagPattern": "v*",
296 "set.tagHint": "Ontwikkelaars kunnen deze tags niet aanmaken of verwijderen.",
278 297 "set.secretName": "Naam",
279 298 "set.secretValue": "Waarde",
280 299 "set.protectedOnly": "Alleen meesturen op een beschermde branch",
@@ -322,6 +341,10 @@ var nl = map[string]string{
322 341 "flash.memberSaved": "Lid opgeslagen",
323 342 "flash.memberRemoved": "Lid verwijderd",
324 343 "flash.branchOn": "Branch beschermd",
344 "flash.tagCreated": "Tag aangemaakt",
345 "flash.tagDeleted": "Tag verwijderd",
346 "flash.tagOn": "Tagpatroon beschermd",
347 "flash.tagOff": "Tagpatroon verwijderd",
325 348 "flash.patternOff": "Patroon verwijderd",
326 349 "flash.secretSaved": "Geheim opgeslagen",
327 350 "flash.secretRemoved": "Geheim verwijderd",
@@ -388,11 +411,16 @@ var nl = map[string]string{
388 411 "err.noteEmpty": "een reactie is leeg",
389 412 "err.mrTitle": "een merge request heeft een titel nodig",
390 413 "err.tagExists": "tag %s bestaat al",
414 "err.tagProtected": "tag %s is beschermd",
415 "err.tagMissing": "tag %s bestaat niet",
416 "err.tagRef": "branch of commit %q is niet gevonden",
417 "err.tagLong": "het bericht is te lang",
391 418 "err.roleMissing": "rol ontbreekt",
392 419 "err.roleUnknown": "onbekende rol %q",
393 420 "err.hook.nowrite": "geen schrijfrechten op %s",
394 421 "err.hook.branch": "ongeldige branch %q",
395 422 "err.hook.protected": "branch %s is beschermd; alleen een beheerder mag die wijzigen",
423 "err.hook.tag": "tag %s is beschermd; alleen een beheerder mag die wijzigen",
396 424 "err.hook.empty": "lege push",
397 425 "err.secretLen": "geheimnaam moet 1 tot 80 tekens zijn",
398 426 "err.secretForm": "geheimnaam %q moet [A-Z][A-Z0-9_]* zijn",
@@ -704,6 +732,7 @@ var de = map[string]string{
704 732 "tab.mrs": "Merge Requests",
705 733 "tab.pipelines": "Pipelines",
706 734 "tab.releases": "Releases",
735 "tab.tags": "Tags",
707 736 "tab.settings": "Einstellungen",
708 737 "repo.searchFile": "Datei suchen",
709 738 "repo.code": "Code",
@@ -721,6 +750,21 @@ var de = map[string]string{
721 750 "repo.files": "Dateien",
722 751 "repo.binary": "Binäre Datei.",
723 752 "repo.noTags": "Noch keine Tags.",
753 "tag.search": "Tag suchen",
754 "tag.create": "Tag anlegen",
755 "tag.name": "Name",
756 "tag.target": "Branch oder Commit",
757 "tag.message": "Nachricht",
758 "tag.date": "Datum",
759 "tag.commit": "Commit",
760 "tag.annotated": "Mit Nachricht",
761 "tag.lightweight": "Ohne Nachricht",
762 "tag.release": "Release",
763 "tag.zip": "zip",
764 "tag.tgz": "tar.gz",
765 "tag.delete": "Löschen",
766 "tag.confirm": "Tag %s löschen?",
767 "tag.noMatch": "Keine passenden Tags.",
724 768 "repo.noBranches": "Noch keine Branches.",
725 769 "count.commit.one": "%d Commit",
726 770 "count.commit.many": "%d Commits",
@@ -843,12 +887,15 @@ var de = map[string]string{
843 887 "set.general": "Allgemein",
844 888 "set.members": "Mitglieder",
845 889 "set.branches": "Branches",
890 "set.tags": "Tags",
846 891 "set.secrets": "Geheimnisse",
847 892 "set.webhooks": "Webhooks",
848 893 "set.username": "Benutzername",
849 894 "set.pending": "wartet auf die erste Anmeldung",
850 895 "set.pattern": "master oder release/*",
851 896 "set.protectHint": "Entwickler können nicht auf diese Branches pushen.",
897 "set.tagPattern": "v*",
898 "set.tagHint": "Entwickler können diese Tags nicht anlegen oder löschen.",
852 899 "set.secretName": "Name",
853 900 "set.secretValue": "Wert",
854 901 "set.protectedOnly": "Nur auf einem geschützten Branch mitsenden",
@@ -896,6 +943,10 @@ var de = map[string]string{
896 943 "flash.memberSaved": "Mitglied gespeichert",
897 944 "flash.memberRemoved": "Mitglied entfernt",
898 945 "flash.branchOn": "Branch geschützt",
946 "flash.tagCreated": "Tag angelegt",
947 "flash.tagDeleted": "Tag gelöscht",
948 "flash.tagOn": "Tag-Muster geschützt",
949 "flash.tagOff": "Tag-Muster entfernt",
899 950 "flash.patternOff": "Muster entfernt",
900 951 "flash.secretSaved": "Geheimnis gespeichert",
901 952 "flash.secretRemoved": "Geheimnis entfernt",
@@ -962,11 +1013,16 @@ var de = map[string]string{
962 1013 "err.noteEmpty": "ein Kommentar ist leer",
963 1014 "err.mrTitle": "ein Merge Request braucht einen Titel",
964 1015 "err.tagExists": "Tag %s existiert bereits",
1016 "err.tagProtected": "Tag %s ist geschützt",
1017 "err.tagMissing": "Tag %s existiert nicht",
1018 "err.tagRef": "Branch oder Commit %q wurde nicht gefunden",
1019 "err.tagLong": "die Nachricht ist zu lang",
965 1020 "err.roleMissing": "Rolle fehlt",
966 1021 "err.roleUnknown": "unbekannte Rolle %q",
967 1022 "err.hook.nowrite": "keine Schreibrechte auf %s",
968 1023 "err.hook.branch": "ungültiger Branch %q",
969 1024 "err.hook.protected": "Branch %s ist geschützt; nur ein Betreuer darf ihn ändern",
1025 "err.hook.tag": "Tag %s ist geschützt; nur ein Betreuer darf ihn ändern",
970 1026 "err.hook.empty": "leerer Push",
971 1027 "err.secretLen": "der Geheimnisname muss 1 bis 80 Zeichen haben",
972 1028 "err.secretForm": "Geheimnisname %q muss [A-Z][A-Z0-9_]* entsprechen",
@@ -1278,6 +1334,7 @@ var fr = map[string]string{
1278 1334 "tab.mrs": "Merge requests",
1279 1335 "tab.pipelines": "Pipelines",
1280 1336 "tab.releases": "Versions",
1337 "tab.tags": "Tags",
1281 1338 "tab.settings": "Paramètres",
1282 1339 "repo.searchFile": "Chercher un fichier",
1283 1340 "repo.code": "Code",
@@ -1295,6 +1352,21 @@ var fr = map[string]string{
1295 1352 "repo.files": "Fichiers",
1296 1353 "repo.binary": "Fichier binaire.",
1297 1354 "repo.noTags": "Pas encore de tags.",
1355 "tag.search": "Chercher un tag",
1356 "tag.create": "Créer un tag",
1357 "tag.name": "Nom",
1358 "tag.target": "Branche ou commit",
1359 "tag.message": "Message",
1360 "tag.date": "Date",
1361 "tag.commit": "Commit",
1362 "tag.annotated": "Annoté",
1363 "tag.lightweight": "Sans message",
1364 "tag.release": "Version",
1365 "tag.zip": "zip",
1366 "tag.tgz": "tar.gz",
1367 "tag.delete": "Supprimer",
1368 "tag.confirm": "Supprimer le tag %s ?",
1369 "tag.noMatch": "Aucun tag correspondant.",
1298 1370 "repo.noBranches": "Pas encore de branches.",
1299 1371 "count.commit.one": "%d commit",
1300 1372 "count.commit.many": "%d commits",
@@ -1417,12 +1489,15 @@ var fr = map[string]string{
1417 1489 "set.general": "Général",
1418 1490 "set.members": "Membres",
1419 1491 "set.branches": "Branches",
1492 "set.tags": "Tags",
1420 1493 "set.secrets": "Secrets",
1421 1494 "set.webhooks": "Webhooks",
1422 1495 "set.username": "nom d’utilisateur",
1423 1496 "set.pending": "en attente de la première connexion",
1424 1497 "set.pattern": "master ou release/*",
1425 1498 "set.protectHint": "Les développeurs ne peuvent pas pousser vers ces branches.",
1499 "set.tagPattern": "v*",
1500 "set.tagHint": "Les développeurs ne peuvent pas créer ni supprimer ces tags.",
1426 1501 "set.secretName": "Nom",
1427 1502 "set.secretValue": "Valeur",
1428 1503 "set.protectedOnly": "N’envoyer que sur une branche protégée",
@@ -1470,6 +1545,10 @@ var fr = map[string]string{
1470 1545 "flash.memberSaved": "Membre enregistré",
1471 1546 "flash.memberRemoved": "Membre retiré",
1472 1547 "flash.branchOn": "Branche protégée",
1548 "flash.tagCreated": "Tag créé",
1549 "flash.tagDeleted": "Tag supprimé",
1550 "flash.tagOn": "Motif de tag protégé",
1551 "flash.tagOff": "Motif de tag retiré",
1473 1552 "flash.patternOff": "Motif retiré",
1474 1553 "flash.secretSaved": "Secret enregistré",
1475 1554 "flash.secretRemoved": "Secret supprimé",
@@ -1536,11 +1615,16 @@ var fr = map[string]string{
1536 1615 "err.noteEmpty": "un commentaire est vide",
1537 1616 "err.mrTitle": "une merge request a besoin d’un titre",
1538 1617 "err.tagExists": "le tag %s existe déjà",
1618 "err.tagProtected": "le tag %s est protégé",
1619 "err.tagMissing": "le tag %s n’existe pas",
1620 "err.tagRef": "branche ou commit %q est introuvable",
1621 "err.tagLong": "le message est trop long",
1539 1622 "err.roleMissing": "le rôle manque",
1540 1623 "err.roleUnknown": "rôle inconnu %q",
1541 1624 "err.hook.nowrite": "pas de droit d’écriture sur %s",
1542 1625 "err.hook.branch": "branche invalide %q",
1543 1626 "err.hook.protected": "la branche %s est protégée ; seul un mainteneur peut la modifier",
1627 "err.hook.tag": "le tag %s est protégé ; seul un mainteneur peut le modifier",
1544 1628 "err.hook.empty": "push vide",
1545 1629 "err.secretLen": "le nom du secret doit faire de 1 à 80 caractères",
1546 1630 "err.secretForm": "le nom de secret %q doit correspondre à [A-Z][A-Z0-9_]*",
@@ -130,6 +130,7 @@ var nl = map[string]string{
130 "tab.mrs": "Merge requests",
130 "tab.mrs": "Merge requests",
131 "tab.pipelines": "Pipelines",
131 "tab.pipelines": "Pipelines",
132 "tab.releases": "Releases",
132 "tab.releases": "Releases",
133 "tab.tags": "Tags",
133 "tab.settings": "Instellingen",
134 "tab.settings": "Instellingen",
134 "repo.searchFile": "Bestand zoeken",
135 "repo.searchFile": "Bestand zoeken",
135 "repo.code": "Code",
136 "repo.code": "Code",
@@ -147,6 +148,21 @@ var nl = map[string]string{
147 "repo.files": "Bestanden",
148 "repo.files": "Bestanden",
148 "repo.binary": "Binair bestand.",
149 "repo.binary": "Binair bestand.",
149 "repo.noTags": "Nog geen tags.",
150 "repo.noTags": "Nog geen tags.",
151 "tag.search": "Zoek een tag",
152 "tag.create": "Tag aanmaken",
153 "tag.name": "Naam",
154 "tag.target": "Branch of commit",
155 "tag.message": "Bericht",
156 "tag.date": "Datum",
157 "tag.commit": "Commit",
158 "tag.annotated": "Met bericht",
159 "tag.lightweight": "Zonder bericht",
160 "tag.release": "Release",
161 "tag.zip": "zip",
162 "tag.tgz": "tar.gz",
163 "tag.delete": "Verwijderen",
164 "tag.confirm": "Tag %s verwijderen?",
165 "tag.noMatch": "Geen passende tags.",
150 "repo.noBranches": "Nog geen branches.",
166 "repo.noBranches": "Nog geen branches.",
151 "count.commit.one": "%d commit",
167 "count.commit.one": "%d commit",
152 "count.commit.many": "%d commits",
168 "count.commit.many": "%d commits",
@@ -269,12 +285,15 @@ var nl = map[string]string{
269 "set.general": "Algemeen",
285 "set.general": "Algemeen",
270 "set.members": "Leden",
286 "set.members": "Leden",
271 "set.branches": "Branches",
287 "set.branches": "Branches",
288 "set.tags": "Tags",
272 "set.secrets": "Geheimen",
289 "set.secrets": "Geheimen",
273 "set.webhooks": "Webhooks",
290 "set.webhooks": "Webhooks",
274 "set.username": "gebruikersnaam",
291 "set.username": "gebruikersnaam",
275 "set.pending": "wacht op eerste aanmelding",
292 "set.pending": "wacht op eerste aanmelding",
276 "set.pattern": "master of release/*",
293 "set.pattern": "master of release/*",
277 "set.protectHint": "Ontwikkelaars kunnen niet naar deze branches pushen.",
294 "set.protectHint": "Ontwikkelaars kunnen niet naar deze branches pushen.",
295 "set.tagPattern": "v*",
296 "set.tagHint": "Ontwikkelaars kunnen deze tags niet aanmaken of verwijderen.",
278 "set.secretName": "Naam",
297 "set.secretName": "Naam",
279 "set.secretValue": "Waarde",
298 "set.secretValue": "Waarde",
280 "set.protectedOnly": "Alleen meesturen op een beschermde branch",
299 "set.protectedOnly": "Alleen meesturen op een beschermde branch",
@@ -322,6 +341,10 @@ var nl = map[string]string{
322 "flash.memberSaved": "Lid opgeslagen",
341 "flash.memberSaved": "Lid opgeslagen",
323 "flash.memberRemoved": "Lid verwijderd",
342 "flash.memberRemoved": "Lid verwijderd",
324 "flash.branchOn": "Branch beschermd",
343 "flash.branchOn": "Branch beschermd",
344 "flash.tagCreated": "Tag aangemaakt",
345 "flash.tagDeleted": "Tag verwijderd",
346 "flash.tagOn": "Tagpatroon beschermd",
347 "flash.tagOff": "Tagpatroon verwijderd",
325 "flash.patternOff": "Patroon verwijderd",
348 "flash.patternOff": "Patroon verwijderd",
326 "flash.secretSaved": "Geheim opgeslagen",
349 "flash.secretSaved": "Geheim opgeslagen",
327 "flash.secretRemoved": "Geheim verwijderd",
350 "flash.secretRemoved": "Geheim verwijderd",
@@ -388,11 +411,16 @@ var nl = map[string]string{
388 "err.noteEmpty": "een reactie is leeg",
411 "err.noteEmpty": "een reactie is leeg",
389 "err.mrTitle": "een merge request heeft een titel nodig",
412 "err.mrTitle": "een merge request heeft een titel nodig",
390 "err.tagExists": "tag %s bestaat al",
413 "err.tagExists": "tag %s bestaat al",
414 "err.tagProtected": "tag %s is beschermd",
415 "err.tagMissing": "tag %s bestaat niet",
416 "err.tagRef": "branch of commit %q is niet gevonden",
417 "err.tagLong": "het bericht is te lang",
391 "err.roleMissing": "rol ontbreekt",
418 "err.roleMissing": "rol ontbreekt",
392 "err.roleUnknown": "onbekende rol %q",
419 "err.roleUnknown": "onbekende rol %q",
393 "err.hook.nowrite": "geen schrijfrechten op %s",
420 "err.hook.nowrite": "geen schrijfrechten op %s",
394 "err.hook.branch": "ongeldige branch %q",
421 "err.hook.branch": "ongeldige branch %q",
395 "err.hook.protected": "branch %s is beschermd; alleen een beheerder mag die wijzigen",
422 "err.hook.protected": "branch %s is beschermd; alleen een beheerder mag die wijzigen",
423 "err.hook.tag": "tag %s is beschermd; alleen een beheerder mag die wijzigen",
396 "err.hook.empty": "lege push",
424 "err.hook.empty": "lege push",
397 "err.secretLen": "geheimnaam moet 1 tot 80 tekens zijn",
425 "err.secretLen": "geheimnaam moet 1 tot 80 tekens zijn",
398 "err.secretForm": "geheimnaam %q moet [A-Z][A-Z0-9_]* zijn",
426 "err.secretForm": "geheimnaam %q moet [A-Z][A-Z0-9_]* zijn",
@@ -704,6 +732,7 @@ var de = map[string]string{
704 "tab.mrs": "Merge Requests",
732 "tab.mrs": "Merge Requests",
705 "tab.pipelines": "Pipelines",
733 "tab.pipelines": "Pipelines",
706 "tab.releases": "Releases",
734 "tab.releases": "Releases",
735 "tab.tags": "Tags",
707 "tab.settings": "Einstellungen",
736 "tab.settings": "Einstellungen",
708 "repo.searchFile": "Datei suchen",
737 "repo.searchFile": "Datei suchen",
709 "repo.code": "Code",
738 "repo.code": "Code",
@@ -721,6 +750,21 @@ var de = map[string]string{
721 "repo.files": "Dateien",
750 "repo.files": "Dateien",
722 "repo.binary": "Binäre Datei.",
751 "repo.binary": "Binäre Datei.",
723 "repo.noTags": "Noch keine Tags.",
752 "repo.noTags": "Noch keine Tags.",
753 "tag.search": "Tag suchen",
754 "tag.create": "Tag anlegen",
755 "tag.name": "Name",
756 "tag.target": "Branch oder Commit",
757 "tag.message": "Nachricht",
758 "tag.date": "Datum",
759 "tag.commit": "Commit",
760 "tag.annotated": "Mit Nachricht",
761 "tag.lightweight": "Ohne Nachricht",
762 "tag.release": "Release",
763 "tag.zip": "zip",
764 "tag.tgz": "tar.gz",
765 "tag.delete": "Löschen",
766 "tag.confirm": "Tag %s löschen?",
767 "tag.noMatch": "Keine passenden Tags.",
724 "repo.noBranches": "Noch keine Branches.",
768 "repo.noBranches": "Noch keine Branches.",
725 "count.commit.one": "%d Commit",
769 "count.commit.one": "%d Commit",
726 "count.commit.many": "%d Commits",
770 "count.commit.many": "%d Commits",
@@ -843,12 +887,15 @@ var de = map[string]string{
843 "set.general": "Allgemein",
887 "set.general": "Allgemein",
844 "set.members": "Mitglieder",
888 "set.members": "Mitglieder",
845 "set.branches": "Branches",
889 "set.branches": "Branches",
890 "set.tags": "Tags",
846 "set.secrets": "Geheimnisse",
891 "set.secrets": "Geheimnisse",
847 "set.webhooks": "Webhooks",
892 "set.webhooks": "Webhooks",
848 "set.username": "Benutzername",
893 "set.username": "Benutzername",
849 "set.pending": "wartet auf die erste Anmeldung",
894 "set.pending": "wartet auf die erste Anmeldung",
850 "set.pattern": "master oder release/*",
895 "set.pattern": "master oder release/*",
851 "set.protectHint": "Entwickler können nicht auf diese Branches pushen.",
896 "set.protectHint": "Entwickler können nicht auf diese Branches pushen.",
897 "set.tagPattern": "v*",
898 "set.tagHint": "Entwickler können diese Tags nicht anlegen oder löschen.",
852 "set.secretName": "Name",
899 "set.secretName": "Name",
853 "set.secretValue": "Wert",
900 "set.secretValue": "Wert",
854 "set.protectedOnly": "Nur auf einem geschützten Branch mitsenden",
901 "set.protectedOnly": "Nur auf einem geschützten Branch mitsenden",
@@ -896,6 +943,10 @@ var de = map[string]string{
896 "flash.memberSaved": "Mitglied gespeichert",
943 "flash.memberSaved": "Mitglied gespeichert",
897 "flash.memberRemoved": "Mitglied entfernt",
944 "flash.memberRemoved": "Mitglied entfernt",
898 "flash.branchOn": "Branch geschützt",
945 "flash.branchOn": "Branch geschützt",
946 "flash.tagCreated": "Tag angelegt",
947 "flash.tagDeleted": "Tag gelöscht",
948 "flash.tagOn": "Tag-Muster geschützt",
949 "flash.tagOff": "Tag-Muster entfernt",
899 "flash.patternOff": "Muster entfernt",
950 "flash.patternOff": "Muster entfernt",
900 "flash.secretSaved": "Geheimnis gespeichert",
951 "flash.secretSaved": "Geheimnis gespeichert",
901 "flash.secretRemoved": "Geheimnis entfernt",
952 "flash.secretRemoved": "Geheimnis entfernt",
@@ -962,11 +1013,16 @@ var de = map[string]string{
962 "err.noteEmpty": "ein Kommentar ist leer",
1013 "err.noteEmpty": "ein Kommentar ist leer",
963 "err.mrTitle": "ein Merge Request braucht einen Titel",
1014 "err.mrTitle": "ein Merge Request braucht einen Titel",
964 "err.tagExists": "Tag %s existiert bereits",
1015 "err.tagExists": "Tag %s existiert bereits",
1016 "err.tagProtected": "Tag %s ist geschützt",
1017 "err.tagMissing": "Tag %s existiert nicht",
1018 "err.tagRef": "Branch oder Commit %q wurde nicht gefunden",
1019 "err.tagLong": "die Nachricht ist zu lang",
965 "err.roleMissing": "Rolle fehlt",
1020 "err.roleMissing": "Rolle fehlt",
966 "err.roleUnknown": "unbekannte Rolle %q",
1021 "err.roleUnknown": "unbekannte Rolle %q",
967 "err.hook.nowrite": "keine Schreibrechte auf %s",
1022 "err.hook.nowrite": "keine Schreibrechte auf %s",
968 "err.hook.branch": "ungültiger Branch %q",
1023 "err.hook.branch": "ungültiger Branch %q",
969 "err.hook.protected": "Branch %s ist geschützt; nur ein Betreuer darf ihn ändern",
1024 "err.hook.protected": "Branch %s ist geschützt; nur ein Betreuer darf ihn ändern",
1025 "err.hook.tag": "Tag %s ist geschützt; nur ein Betreuer darf ihn ändern",
970 "err.hook.empty": "leerer Push",
1026 "err.hook.empty": "leerer Push",
971 "err.secretLen": "der Geheimnisname muss 1 bis 80 Zeichen haben",
1027 "err.secretLen": "der Geheimnisname muss 1 bis 80 Zeichen haben",
972 "err.secretForm": "Geheimnisname %q muss [A-Z][A-Z0-9_]* entsprechen",
1028 "err.secretForm": "Geheimnisname %q muss [A-Z][A-Z0-9_]* entsprechen",
@@ -1278,6 +1334,7 @@ var fr = map[string]string{
1278 "tab.mrs": "Merge requests",
1334 "tab.mrs": "Merge requests",
1279 "tab.pipelines": "Pipelines",
1335 "tab.pipelines": "Pipelines",
1280 "tab.releases": "Versions",
1336 "tab.releases": "Versions",
1337 "tab.tags": "Tags",
1281 "tab.settings": "Paramètres",
1338 "tab.settings": "Paramètres",
1282 "repo.searchFile": "Chercher un fichier",
1339 "repo.searchFile": "Chercher un fichier",
1283 "repo.code": "Code",
1340 "repo.code": "Code",
@@ -1295,6 +1352,21 @@ var fr = map[string]string{
1295 "repo.files": "Fichiers",
1352 "repo.files": "Fichiers",
1296 "repo.binary": "Fichier binaire.",
1353 "repo.binary": "Fichier binaire.",
1297 "repo.noTags": "Pas encore de tags.",
1354 "repo.noTags": "Pas encore de tags.",
1355 "tag.search": "Chercher un tag",
1356 "tag.create": "Créer un tag",
1357 "tag.name": "Nom",
1358 "tag.target": "Branche ou commit",
1359 "tag.message": "Message",
1360 "tag.date": "Date",
1361 "tag.commit": "Commit",
1362 "tag.annotated": "Annoté",
1363 "tag.lightweight": "Sans message",
1364 "tag.release": "Version",
1365 "tag.zip": "zip",
1366 "tag.tgz": "tar.gz",
1367 "tag.delete": "Supprimer",
1368 "tag.confirm": "Supprimer le tag %s ?",
1369 "tag.noMatch": "Aucun tag correspondant.",
1298 "repo.noBranches": "Pas encore de branches.",
1370 "repo.noBranches": "Pas encore de branches.",
1299 "count.commit.one": "%d commit",
1371 "count.commit.one": "%d commit",
1300 "count.commit.many": "%d commits",
1372 "count.commit.many": "%d commits",
@@ -1417,12 +1489,15 @@ var fr = map[string]string{
1417 "set.general": "Général",
1489 "set.general": "Général",
1418 "set.members": "Membres",
1490 "set.members": "Membres",
1419 "set.branches": "Branches",
1491 "set.branches": "Branches",
1492 "set.tags": "Tags",
1420 "set.secrets": "Secrets",
1493 "set.secrets": "Secrets",
1421 "set.webhooks": "Webhooks",
1494 "set.webhooks": "Webhooks",
1422 "set.username": "nom d’utilisateur",
1495 "set.username": "nom d’utilisateur",
1423 "set.pending": "en attente de la première connexion",
1496 "set.pending": "en attente de la première connexion",
1424 "set.pattern": "master ou release/*",
1497 "set.pattern": "master ou release/*",
1425 "set.protectHint": "Les développeurs ne peuvent pas pousser vers ces branches.",
1498 "set.protectHint": "Les développeurs ne peuvent pas pousser vers ces branches.",
1499 "set.tagPattern": "v*",
1500 "set.tagHint": "Les développeurs ne peuvent pas créer ni supprimer ces tags.",
1426 "set.secretName": "Nom",
1501 "set.secretName": "Nom",
1427 "set.secretValue": "Valeur",
1502 "set.secretValue": "Valeur",
1428 "set.protectedOnly": "N’envoyer que sur une branche protégée",
1503 "set.protectedOnly": "N’envoyer que sur une branche protégée",
@@ -1470,6 +1545,10 @@ var fr = map[string]string{
1470 "flash.memberSaved": "Membre enregistré",
1545 "flash.memberSaved": "Membre enregistré",
1471 "flash.memberRemoved": "Membre retiré",
1546 "flash.memberRemoved": "Membre retiré",
1472 "flash.branchOn": "Branche protégée",
1547 "flash.branchOn": "Branche protégée",
1548 "flash.tagCreated": "Tag créé",
1549 "flash.tagDeleted": "Tag supprimé",
1550 "flash.tagOn": "Motif de tag protégé",
1551 "flash.tagOff": "Motif de tag retiré",
1473 "flash.patternOff": "Motif retiré",
1552 "flash.patternOff": "Motif retiré",
1474 "flash.secretSaved": "Secret enregistré",
1553 "flash.secretSaved": "Secret enregistré",
1475 "flash.secretRemoved": "Secret supprimé",
1554 "flash.secretRemoved": "Secret supprimé",
@@ -1536,11 +1615,16 @@ var fr = map[string]string{
1536 "err.noteEmpty": "un commentaire est vide",
1615 "err.noteEmpty": "un commentaire est vide",
1537 "err.mrTitle": "une merge request a besoin d’un titre",
1616 "err.mrTitle": "une merge request a besoin d’un titre",
1538 "err.tagExists": "le tag %s existe déjà",
1617 "err.tagExists": "le tag %s existe déjà",
1618 "err.tagProtected": "le tag %s est protégé",
1619 "err.tagMissing": "le tag %s n’existe pas",
1620 "err.tagRef": "branche ou commit %q est introuvable",
1621 "err.tagLong": "le message est trop long",
1539 "err.roleMissing": "le rôle manque",
1622 "err.roleMissing": "le rôle manque",
1540 "err.roleUnknown": "rôle inconnu %q",
1623 "err.roleUnknown": "rôle inconnu %q",
1541 "err.hook.nowrite": "pas de droit d’écriture sur %s",
1624 "err.hook.nowrite": "pas de droit d’écriture sur %s",
1542 "err.hook.branch": "branche invalide %q",
1625 "err.hook.branch": "branche invalide %q",
1543 "err.hook.protected": "la branche %s est protégée ; seul un mainteneur peut la modifier",
1626 "err.hook.protected": "la branche %s est protégée ; seul un mainteneur peut la modifier",
1627 "err.hook.tag": "le tag %s est protégé ; seul un mainteneur peut le modifier",
1544 "err.hook.empty": "push vide",
1628 "err.hook.empty": "push vide",
1545 "err.secretLen": "le nom du secret doit faire de 1 à 80 caractères",
1629 "err.secretLen": "le nom du secret doit faire de 1 à 80 caractères",
1546 "err.secretForm": "le nom de secret %q doit correspondre à [A-Z][A-Z0-9_]*",
1630 "err.secretForm": "le nom de secret %q doit correspondre à [A-Z][A-Z0-9_]*",
internal/i18n/i18n_test.go +7 −0
@@ -44,6 +44,13 @@ func TestCuneiformIsSigns(t *testing.T) {
44 44 if utf8.RuneCountInString(Transliterate("a")) != 1 || Transliterate("a") != "𒀀" {
45 45 t.Fatalf("a = %q", Transliterate("a"))
46 46 }
47 got = T(Cuneiform, "tag.confirm", "1")
48 if !strings.Contains(got, "1") || !strings.Contains(got, "?") {
49 t.Fatalf("cijfers en leestekens blijven: %s", got)
50 }
51 if strings.Contains(got, "Delete") {
52 t.Fatalf("engels bleef staan: %s", got)
53 }
47 54 }
48 55
49 56 func TestFallback(t *testing.T) {
@@ -44,6 +44,13 @@ func TestCuneiformIsSigns(t *testing.T) {
44 if utf8.RuneCountInString(Transliterate("a")) != 1 || Transliterate("a") != "𒀀" {
44 if utf8.RuneCountInString(Transliterate("a")) != 1 || Transliterate("a") != "𒀀" {
45 t.Fatalf("a = %q", Transliterate("a"))
45 t.Fatalf("a = %q", Transliterate("a"))
46 }
46 }
47 got = T(Cuneiform, "tag.confirm", "1")
48 if !strings.Contains(got, "1") || !strings.Contains(got, "?") {
49 t.Fatalf("cijfers en leestekens blijven: %s", got)
50 }
51 if strings.Contains(got, "Delete") {
52 t.Fatalf("engels bleef staan: %s", got)
53 }
47}
54}
48
55
49func TestFallback(t *testing.T) {
56func TestFallback(t *testing.T) {
internal/server/git_http.go +2 −1
@@ -60,7 +60,8 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
60 60 if write {
61 61 before, _ = gitrepo.Refs(r.Context(), s.Git, dir)
62 62 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
63 extra = gitrepo.PushEnv(role, patterns)
63 tagPatterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
64 extra = gitrepo.PushEnv(role, patterns, tagPatterns)
64 65 }
65 66 rest := strings.TrimPrefix(r.URL.Path, "/"+owner+"/"+repoSeg)
66 67 pathInfo := gitrepo.PathInfo(owner, repoSeg, rest)
@@ -60,7 +60,8 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
60 if write {
60 if write {
61 before, _ = gitrepo.Refs(r.Context(), s.Git, dir)
61 before, _ = gitrepo.Refs(r.Context(), s.Git, dir)
62 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
62 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
63 extra = gitrepo.PushEnv(role, patterns)
63 tagPatterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
64 extra = gitrepo.PushEnv(role, patterns, tagPatterns)
64 }
65 }
65 rest := strings.TrimPrefix(r.URL.Path, "/"+owner+"/"+repoSeg)
66 rest := strings.TrimPrefix(r.URL.Path, "/"+owner+"/"+repoSeg)
66 pathInfo := gitrepo.PathInfo(owner, repoSeg, rest)
67 pathInfo := gitrepo.PathInfo(owner, repoSeg, rest)
internal/server/project.go +0 −12
@@ -103,18 +103,6 @@ func (s *Server) branchList(r *http.Request, v *View, dir string) {
103 103 }
104 104 }
105 105
106 func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
107 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
108 if !ok {
109 return
110 }
111 v := s.repoView(w, r, repo, role, "title.tags")
112 v.Wide = true
113 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
114 v.TagNames, _ = gitrepo.Tags(r.Context(), s.Git, dir)
115 s.render(w, "tags", v)
116 }
117
118 106 func fileRows(entries []gitrepo.Entry, base string, touch map[string]gitrepo.Commit, lang i18n.Lang) []FileRow {
119 107 var out []FileRow
120 108 for _, e := range entries {
@@ -103,18 +103,6 @@ func (s *Server) branchList(r *http.Request, v *View, dir string) {
103 }
103 }
104}
104}
105
105
106func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
107 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
108 if !ok {
109 return
110 }
111 v := s.repoView(w, r, repo, role, "title.tags")
112 v.Wide = true
113 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
114 v.TagNames, _ = gitrepo.Tags(r.Context(), s.Git, dir)
115 s.render(w, "tags", v)
116}
117
118func fileRows(entries []gitrepo.Entry, base string, touch map[string]gitrepo.Commit, lang i18n.Lang) []FileRow {
106func fileRows(entries []gitrepo.Entry, base string, touch map[string]gitrepo.Commit, lang i18n.Lang) []FileRow {
119 var out []FileRow
107 var out []FileRow
120 for _, e := range entries {
108 for _, e := range entries {
internal/server/server.go +14 −1
@@ -111,6 +111,9 @@ func (s *Server) Handler() http.Handler {
111 111 mux.HandleFunc("GET /{owner}/{repo}/-/blob/{path...}", s.blob)
112 112 mux.HandleFunc("GET /{owner}/{repo}/-/commits", s.commits)
113 113 mux.HandleFunc("GET /{owner}/{repo}/-/tags", s.tags)
114 mux.HandleFunc("POST /{owner}/{repo}/-/tags", s.createTag)
115 mux.HandleFunc("POST /{owner}/{repo}/-/tags/delete", s.deleteTag)
116 mux.HandleFunc("GET /{owner}/{repo}/-/tags/archive", s.tagArchive)
114 117 mux.HandleFunc("GET /{owner}/{repo}/-/commit/{sha}", s.commit)
115 118 mux.HandleFunc("GET /{owner}/{repo}/-/branches", s.branches)
116 119 mux.HandleFunc("GET /{owner}/{repo}/-/merge-requests", s.mergeRequests)
@@ -144,6 +147,8 @@ func (s *Server) Handler() http.Handler {
144 147 mux.HandleFunc("POST /{owner}/{repo}/-/members/remove", s.repoMemberRemove)
145 148 mux.HandleFunc("POST /{owner}/{repo}/-/protected", s.addProtected)
146 149 mux.HandleFunc("POST /{owner}/{repo}/-/protected/remove", s.removeProtected)
150 mux.HandleFunc("POST /{owner}/{repo}/-/protected-tags", s.addProtectedTag)
151 mux.HandleFunc("POST /{owner}/{repo}/-/protected-tags/remove", s.removeProtectedTag)
147 152 mux.HandleFunc("POST /{owner}/{repo}/-/secrets", s.repoSecret)
148 153 mux.HandleFunc("POST /{owner}/{repo}/-/secrets/delete", s.repoSecretDelete)
149 154 mux.HandleFunc("POST /{owner}/{repo}/-/webhooks", s.repoWebhook)
@@ -473,6 +478,8 @@ type View struct {
473 478 Secrets []store.SecretMeta
474 479 Hooks []HookView
475 480 Patterns []string
481 TagPatterns []string
482 Tags []TagRow
476 483 Tokens []store.TokenInfo
477 484 Keys []store.SSHKey
478 485 CloneHTTP string
@@ -511,7 +518,6 @@ type View struct {
511 518 BlobSize string
512 519 FileName string
513 520 RevProtected bool
514 TagNames []string
515 521 Heat *activity.Calendar
516 522 Notes []NoteRow
517 523 Profile *store.User
@@ -553,6 +559,13 @@ type DiffLineView struct {
553 559 Notes []NoteRow
554 560 }
555 561
562 // TagRow is één tag op de tagspagina.
563 type TagRow struct {
564 Name, Message, SHA, Short, Subject, Date string
565 Annotated, Protected, HasRelease, CanDelete bool
566 ZipURL, TarURL string
567 }
568
556 569 // FileRow is een rij in de bestandstabel of de boom.
557 570 type FileRow struct {
558 571 Name, Path, Icon, Subject, When, SHA string
@@ -111,6 +111,9 @@ func (s *Server) Handler() http.Handler {
111 mux.HandleFunc("GET /{owner}/{repo}/-/blob/{path...}", s.blob)
111 mux.HandleFunc("GET /{owner}/{repo}/-/blob/{path...}", s.blob)
112 mux.HandleFunc("GET /{owner}/{repo}/-/commits", s.commits)
112 mux.HandleFunc("GET /{owner}/{repo}/-/commits", s.commits)
113 mux.HandleFunc("GET /{owner}/{repo}/-/tags", s.tags)
113 mux.HandleFunc("GET /{owner}/{repo}/-/tags", s.tags)
114 mux.HandleFunc("POST /{owner}/{repo}/-/tags", s.createTag)
115 mux.HandleFunc("POST /{owner}/{repo}/-/tags/delete", s.deleteTag)
116 mux.HandleFunc("GET /{owner}/{repo}/-/tags/archive", s.tagArchive)
114 mux.HandleFunc("GET /{owner}/{repo}/-/commit/{sha}", s.commit)
117 mux.HandleFunc("GET /{owner}/{repo}/-/commit/{sha}", s.commit)
115 mux.HandleFunc("GET /{owner}/{repo}/-/branches", s.branches)
118 mux.HandleFunc("GET /{owner}/{repo}/-/branches", s.branches)
116 mux.HandleFunc("GET /{owner}/{repo}/-/merge-requests", s.mergeRequests)
119 mux.HandleFunc("GET /{owner}/{repo}/-/merge-requests", s.mergeRequests)
@@ -144,6 +147,8 @@ func (s *Server) Handler() http.Handler {
144 mux.HandleFunc("POST /{owner}/{repo}/-/members/remove", s.repoMemberRemove)
147 mux.HandleFunc("POST /{owner}/{repo}/-/members/remove", s.repoMemberRemove)
145 mux.HandleFunc("POST /{owner}/{repo}/-/protected", s.addProtected)
148 mux.HandleFunc("POST /{owner}/{repo}/-/protected", s.addProtected)
146 mux.HandleFunc("POST /{owner}/{repo}/-/protected/remove", s.removeProtected)
149 mux.HandleFunc("POST /{owner}/{repo}/-/protected/remove", s.removeProtected)
150 mux.HandleFunc("POST /{owner}/{repo}/-/protected-tags", s.addProtectedTag)
151 mux.HandleFunc("POST /{owner}/{repo}/-/protected-tags/remove", s.removeProtectedTag)
147 mux.HandleFunc("POST /{owner}/{repo}/-/secrets", s.repoSecret)
152 mux.HandleFunc("POST /{owner}/{repo}/-/secrets", s.repoSecret)
148 mux.HandleFunc("POST /{owner}/{repo}/-/secrets/delete", s.repoSecretDelete)
153 mux.HandleFunc("POST /{owner}/{repo}/-/secrets/delete", s.repoSecretDelete)
149 mux.HandleFunc("POST /{owner}/{repo}/-/webhooks", s.repoWebhook)
154 mux.HandleFunc("POST /{owner}/{repo}/-/webhooks", s.repoWebhook)
@@ -473,6 +478,8 @@ type View struct {
473 Secrets []store.SecretMeta
478 Secrets []store.SecretMeta
474 Hooks []HookView
479 Hooks []HookView
475 Patterns []string
480 Patterns []string
481 TagPatterns []string
482 Tags []TagRow
476 Tokens []store.TokenInfo
483 Tokens []store.TokenInfo
477 Keys []store.SSHKey
484 Keys []store.SSHKey
478 CloneHTTP string
485 CloneHTTP string
@@ -511,7 +518,6 @@ type View struct {
511 BlobSize string
518 BlobSize string
512 FileName string
519 FileName string
513 RevProtected bool
520 RevProtected bool
514 TagNames []string
515 Heat *activity.Calendar
521 Heat *activity.Calendar
516 Notes []NoteRow
522 Notes []NoteRow
517 Profile *store.User
523 Profile *store.User
@@ -553,6 +559,13 @@ type DiffLineView struct {
553 Notes []NoteRow
559 Notes []NoteRow
554}
560}
555
561
562// TagRow is één tag op de tagspagina.
563type TagRow struct {
564 Name, Message, SHA, Short, Subject, Date string
565 Annotated, Protected, HasRelease, CanDelete bool
566 ZipURL, TarURL string
567}
568
556// FileRow is een rij in de bestandstabel of de boom.
569// FileRow is een rij in de bestandstabel of de boom.
557type FileRow struct {
570type FileRow struct {
558 Name, Path, Icon, Subject, When, SHA string
571 Name, Path, Icon, Subject, When, SHA string
internal/server/settings_handlers.go +3 −0
@@ -31,6 +31,7 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) {
31 31 }
32 32 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
33 33 v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
34 v.TagPatterns, _ = s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
34 35 v.Hooks = s.hookViews(r, "repo", repo.ID)
35 36 s.fillApproval(r, &v, repo)
36 37 }
@@ -421,6 +422,8 @@ func settingsTab(tab string) string {
421 422 return "secrets"
422 423 case "branches":
423 424 return "branches"
425 case "tags":
426 return "tags"
424 427 case "webhooks":
425 428 return "webhooks"
426 429 case "approvals":
@@ -31,6 +31,7 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) {
31 }
31 }
32 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
32 v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
33 v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
33 v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
34 v.TagPatterns, _ = s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
34 v.Hooks = s.hookViews(r, "repo", repo.ID)
35 v.Hooks = s.hookViews(r, "repo", repo.ID)
35 s.fillApproval(r, &v, repo)
36 s.fillApproval(r, &v, repo)
36 }
37 }
@@ -421,6 +422,8 @@ func settingsTab(tab string) string {
421 return "secrets"
422 return "secrets"
422 case "branches":
423 case "branches":
423 return "branches"
424 return "branches"
425 case "tags":
426 return "tags"
424 case "webhooks":
427 case "webhooks":
425 return "webhooks"
428 return "webhooks"
426 case "approvals":
429 case "approvals":
internal/server/static/style.css +7 −1
@@ -132,6 +132,12 @@ table.files { background: white; border: 1px solid var(--line); border-radius: 1
132 132 table.files th { color: var(--muted); font-weight: 600; font-size: 0.92rem; }
133 133 table.files td.msg { max-width: 280px; }
134 134 table.files td.msg a { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: inherit; text-decoration: none; }
135 table.tags { width: 100%; background: white; border: 1px solid var(--line); border-radius: 10px; border-collapse: collapse; }
136 table.tags th, table.tags td { text-align: left; padding: 0.65rem 0.55rem; border-bottom: 1px solid var(--line); vertical-align: top; }
137 table.tags th { color: var(--muted); font-weight: 600; font-size: 0.92rem; }
138 table.tags td.acts { white-space: nowrap; }
139 table.tags td.acts a { margin-right: 0.55rem; }
140 .tagmsg { white-space: pre-wrap; }
135 141 .readme, .codebox, .side {
136 142 background: white; border: 1px solid var(--line); border-radius: 12px; margin-top: 1rem;
137 143 }
@@ -387,7 +393,7 @@ svg.ico { width: 14px; height: 14px; flex: none; }
387 393 }
388 394 .danger-modal::backdrop { background: rgba(80, 8, 8, 0.55); }
389 395 .danger-modal p { font-size: 1.7rem; line-height: 1.45; margin: 0 0 1.2rem; }
390 .danger-modal [data-transfer-submit] { background: #a31212; color: #fff; }
396 .danger-modal [data-transfer-submit], .danger-modal [data-tag-submit] { background: #a31212; color: #fff; }
391 397 .danger-modal [data-transfer-submit]:disabled { opacity: 0.45; }
392 398 .stage { position: relative; display: flex; align-items: center; }
393 399 .stage + .stage::before { content: ""; width: 14px; height: 2px; background: #c5d0dc; margin: 0 2px; }
@@ -132,6 +132,12 @@ table.files { background: white; border: 1px solid var(--line); border-radius: 1
132table.files th { color: var(--muted); font-weight: 600; font-size: 0.92rem; }
132table.files th { color: var(--muted); font-weight: 600; font-size: 0.92rem; }
133table.files td.msg { max-width: 280px; }
133table.files td.msg { max-width: 280px; }
134table.files td.msg a { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: inherit; text-decoration: none; }
134table.files td.msg a { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: inherit; text-decoration: none; }
135table.tags { width: 100%; background: white; border: 1px solid var(--line); border-radius: 10px; border-collapse: collapse; }
136table.tags th, table.tags td { text-align: left; padding: 0.65rem 0.55rem; border-bottom: 1px solid var(--line); vertical-align: top; }
137table.tags th { color: var(--muted); font-weight: 600; font-size: 0.92rem; }
138table.tags td.acts { white-space: nowrap; }
139table.tags td.acts a { margin-right: 0.55rem; }
140.tagmsg { white-space: pre-wrap; }
135.readme, .codebox, .side {
141.readme, .codebox, .side {
136 background: white; border: 1px solid var(--line); border-radius: 12px; margin-top: 1rem;
142 background: white; border: 1px solid var(--line); border-radius: 12px; margin-top: 1rem;
137}
143}
@@ -387,7 +393,7 @@ svg.ico { width: 14px; height: 14px; flex: none; }
387}
393}
388.danger-modal::backdrop { background: rgba(80, 8, 8, 0.55); }
394.danger-modal::backdrop { background: rgba(80, 8, 8, 0.55); }
389.danger-modal p { font-size: 1.7rem; line-height: 1.45; margin: 0 0 1.2rem; }
395.danger-modal p { font-size: 1.7rem; line-height: 1.45; margin: 0 0 1.2rem; }
390.danger-modal [data-transfer-submit] { background: #a31212; color: #fff; }
396.danger-modal [data-transfer-submit], .danger-modal [data-tag-submit] { background: #a31212; color: #fff; }
391.danger-modal [data-transfer-submit]:disabled { opacity: 0.45; }
397.danger-modal [data-transfer-submit]:disabled { opacity: 0.45; }
392.stage { position: relative; display: flex; align-items: center; }
398.stage { position: relative; display: flex; align-items: center; }
393.stage + .stage::before { content: ""; width: 14px; height: 2px; background: #c5d0dc; margin: 0 2px; }
399.stage + .stage::before { content: ""; width: 14px; height: 2px; background: #c5d0dc; margin: 0 2px; }
internal/server/static/tags.js added +27 −0
@@ -0,0 +1,27 @@
1 (function () {
2 var dialog = document.querySelector("[data-tag-dialog]");
3 if (!dialog) {
4 return;
5 }
6 var copy = dialog.querySelector("[data-tag-copy]");
7 var name = dialog.querySelector("[data-tag-name]");
8 var pattern = copy ? copy.getAttribute("data-pattern") || "" : "";
9 document.querySelectorAll("[data-tag-open]").forEach(function (btn) {
10 btn.addEventListener("click", function () {
11 var tag = btn.getAttribute("data-tag") || "";
12 if (name) {
13 name.value = tag;
14 }
15 if (copy) {
16 copy.textContent = pattern.split("%s").join(tag);
17 }
18 dialog.showModal();
19 });
20 });
21 var cancel = dialog.querySelector("[data-tag-cancel]");
22 if (cancel) {
23 cancel.addEventListener("click", function () {
24 dialog.close();
25 });
26 }
27 })();
@@ -0,0 +1,27 @@
1(function () {
2 var dialog = document.querySelector("[data-tag-dialog]");
3 if (!dialog) {
4 return;
5 }
6 var copy = dialog.querySelector("[data-tag-copy]");
7 var name = dialog.querySelector("[data-tag-name]");
8 var pattern = copy ? copy.getAttribute("data-pattern") || "" : "";
9 document.querySelectorAll("[data-tag-open]").forEach(function (btn) {
10 btn.addEventListener("click", function () {
11 var tag = btn.getAttribute("data-tag") || "";
12 if (name) {
13 name.value = tag;
14 }
15 if (copy) {
16 copy.textContent = pattern.split("%s").join(tag);
17 }
18 dialog.showModal();
19 });
20 });
21 var cancel = dialog.querySelector("[data-tag-cancel]");
22 if (cancel) {
23 cancel.addEventListener("click", function () {
24 dialog.close();
25 });
26 }
27})();
internal/server/tags.go added +180 −0
@@ -0,0 +1,180 @@
1 package server
2
3 import (
4 "net/http"
5 "net/url"
6 "strings"
7 "time"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/names"
13 )
14
15 func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
16 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
17 if !ok {
18 return
19 }
20 v := s.repoView(w, r, repo, role, "title.tags")
21 v.Page = "tags"
22 v.Wide = true
23 v.Query = strings.TrimSpace(r.URL.Query().Get("q"))
24 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
25 s.branchList(r, &v, dir)
26 lang := i18n.Parse(v.Lang)
27 patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
28 released := map[string]bool{}
29 if rels, err := s.Store.ListReleases(r.Context(), repo.ID); err == nil {
30 for _, rel := range rels {
31 released[rel.Tag] = true
32 }
33 }
34 infos, _ := gitrepo.ListTags(r.Context(), s.Git, dir)
35 needle := strings.ToLower(v.Query)
36 for _, info := range infos {
37 if needle != "" && !strings.Contains(strings.ToLower(info.Name), needle) {
38 continue
39 }
40 protected := access.BranchProtected(patterns, info.Name)
41 short := info.CommitSHA
42 if len(short) > 10 {
43 short = short[:10]
44 }
45 when := ""
46 if info.Unix > 0 {
47 when = i18n.FormatDate(lang, time.Unix(info.Unix, 0).UTC())
48 }
49 row := TagRow{
50 Name: info.Name, Message: info.Message, SHA: info.CommitSHA, Short: short,
51 Subject: info.CommitSubject, Date: when, Annotated: info.Annotated,
52 Protected: protected, HasRelease: released[info.Name],
53 CanDelete: role.CanWriteCode() && (!protected || role.CanManageSettings()),
54 ZipURL: tagArchiveURL(repo, info.Name, "zip"),
55 TarURL: tagArchiveURL(repo, info.Name, "tar.gz"),
56 }
57 v.Tags = append(v.Tags, row)
58 }
59 s.render(w, "tags", v)
60 }
61
62 func (s *Server) createTag(w http.ResponseWriter, r *http.Request) {
63 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
64 if !ok || !s.csrfOK(w, r) {
65 return
66 }
67 back := repoURL(repo) + "/-/tags"
68 name := strings.TrimSpace(r.FormValue("name"))
69 if err := names.ValidTag(name); err != nil {
70 s.redirect(w, r, back, "", s.trErr(r, err))
71 return
72 }
73 patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
74 if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
75 s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))
76 return
77 }
78 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
79 target := r.FormValue("target")
80 if strings.TrimSpace(target) == "" {
81 target = repo.DefaultBranch
82 }
83 email := u.Username + "@users.git.timfalken.com"
84 if err := gitrepo.CreateTag(r.Context(), s.Git, dir, name, target, r.FormValue("message"), u.Username, email); err != nil {
85 s.redirect(w, r, back, "", s.trErr(r, err))
86 return
87 }
88 s.redirect(w, r, back, s.tr(r, "flash.tagCreated"), "")
89 }
90
91 func (s *Server) deleteTag(w http.ResponseWriter, r *http.Request) {
92 _, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
93 if !ok || !s.csrfOK(w, r) {
94 return
95 }
96 back := repoURL(repo) + "/-/tags"
97 name := strings.TrimSpace(r.FormValue("name"))
98 patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
99 if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
100 s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))
101 return
102 }
103 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
104 if err := gitrepo.DeleteTag(r.Context(), s.Git, dir, name); err != nil {
105 s.redirect(w, r, back, "", s.trErr(r, err))
106 return
107 }
108 s.redirect(w, r, back, s.tr(r, "flash.tagDeleted"), "")
109 }
110
111 func (s *Server) tagArchive(w http.ResponseWriter, r *http.Request) {
112 _, repo, _, ok := s.guard(w, r, access.RoleReadonly)
113 if !ok {
114 return
115 }
116 name := r.URL.Query().Get("name")
117 format := r.URL.Query().Get("format")
118 if format != "zip" && format != "tar.gz" {
119 http.NotFound(w, r)
120 return
121 }
122 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
123 if !gitrepo.HasTag(r.Context(), s.Git, dir, name) {
124 http.NotFound(w, r)
125 return
126 }
127 filename := archiveFilename(repo.Name, name, format)
128 if format == "zip" {
129 w.Header().Set("Content-Type", "application/zip")
130 } else {
131 w.Header().Set("Content-Type", "application/gzip")
132 }
133 w.Header().Set("Content-Disposition", "attachment; filename=\""+filename+"\"")
134 prefix := repo.Name + "-" + strings.ReplaceAll(name, "/", "-")
135 if err := gitrepo.Archive(r.Context(), w, s.Git, dir, prefix, name, format); err != nil && s.Log != nil {
136 s.Log.Error("tag archief", "err", err, "tag", name)
137 }
138 }
139
140 func (s *Server) addProtectedTag(w http.ResponseWriter, r *http.Request) {
141 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
142 if !ok || !s.csrfOK(w, r) {
143 return
144 }
145 back := repoURL(repo) + "/-/settings?tab=tags"
146 if err := s.Store.AddProtectedTag(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
147 s.redirect(w, r, back, "", s.trErr(r, err))
148 return
149 }
150 s.redirect(w, r, back, s.tr(r, "flash.tagOn"), "")
151 }
152
153 func (s *Server) removeProtectedTag(w http.ResponseWriter, r *http.Request) {
154 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
155 if !ok || !s.csrfOK(w, r) {
156 return
157 }
158 _ = s.Store.RemoveProtectedTag(r.Context(), repo.ID, r.FormValue("pattern"))
159 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=tags", s.tr(r, "flash.tagOff"), "")
160 }
161
162 func tagArchiveURL(repo interface{ FullPath() string }, name, format string) string {
163 return "/" + repo.FullPath() + "/-/tags/archive?name=" + url.QueryEscape(name) + "&format=" + format
164 }
165
166 func archiveFilename(repoName, tag, format string) string {
167 base := repoName + "-" + strings.ReplaceAll(tag, "/", "-")
168 base = strings.Map(func(r rune) rune {
169 switch {
170 case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '.' || r == '_' || r == '-':
171 return r
172 default:
173 return '-'
174 }
175 }, base)
176 if base == "" || base == "-" {
177 base = "archive"
178 }
179 return base + "." + format
180 }
@@ -0,0 +1,180 @@
1package server
2
3import (
4 "net/http"
5 "net/url"
6 "strings"
7 "time"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/names"
13)
14
15func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
16 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
17 if !ok {
18 return
19 }
20 v := s.repoView(w, r, repo, role, "title.tags")
21 v.Page = "tags"
22 v.Wide = true
23 v.Query = strings.TrimSpace(r.URL.Query().Get("q"))
24 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
25 s.branchList(r, &v, dir)
26 lang := i18n.Parse(v.Lang)
27 patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
28 released := map[string]bool{}
29 if rels, err := s.Store.ListReleases(r.Context(), repo.ID); err == nil {
30 for _, rel := range rels {
31 released[rel.Tag] = true
32 }
33 }
34 infos, _ := gitrepo.ListTags(r.Context(), s.Git, dir)
35 needle := strings.ToLower(v.Query)
36 for _, info := range infos {
37 if needle != "" && !strings.Contains(strings.ToLower(info.Name), needle) {
38 continue
39 }
40 protected := access.BranchProtected(patterns, info.Name)
41 short := info.CommitSHA
42 if len(short) > 10 {
43 short = short[:10]
44 }
45 when := ""
46 if info.Unix > 0 {
47 when = i18n.FormatDate(lang, time.Unix(info.Unix, 0).UTC())
48 }
49 row := TagRow{
50 Name: info.Name, Message: info.Message, SHA: info.CommitSHA, Short: short,
51 Subject: info.CommitSubject, Date: when, Annotated: info.Annotated,
52 Protected: protected, HasRelease: released[info.Name],
53 CanDelete: role.CanWriteCode() && (!protected || role.CanManageSettings()),
54 ZipURL: tagArchiveURL(repo, info.Name, "zip"),
55 TarURL: tagArchiveURL(repo, info.Name, "tar.gz"),
56 }
57 v.Tags = append(v.Tags, row)
58 }
59 s.render(w, "tags", v)
60}
61
62func (s *Server) createTag(w http.ResponseWriter, r *http.Request) {
63 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
64 if !ok || !s.csrfOK(w, r) {
65 return
66 }
67 back := repoURL(repo) + "/-/tags"
68 name := strings.TrimSpace(r.FormValue("name"))
69 if err := names.ValidTag(name); err != nil {
70 s.redirect(w, r, back, "", s.trErr(r, err))
71 return
72 }
73 patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
74 if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
75 s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))
76 return
77 }
78 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
79 target := r.FormValue("target")
80 if strings.TrimSpace(target) == "" {
81 target = repo.DefaultBranch
82 }
83 email := u.Username + "@users.git.timfalken.com"
84 if err := gitrepo.CreateTag(r.Context(), s.Git, dir, name, target, r.FormValue("message"), u.Username, email); err != nil {
85 s.redirect(w, r, back, "", s.trErr(r, err))
86 return
87 }
88 s.redirect(w, r, back, s.tr(r, "flash.tagCreated"), "")
89}
90
91func (s *Server) deleteTag(w http.ResponseWriter, r *http.Request) {
92 _, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
93 if !ok || !s.csrfOK(w, r) {
94 return
95 }
96 back := repoURL(repo) + "/-/tags"
97 name := strings.TrimSpace(r.FormValue("name"))
98 patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
99 if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
100 s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))
101 return
102 }
103 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
104 if err := gitrepo.DeleteTag(r.Context(), s.Git, dir, name); err != nil {
105 s.redirect(w, r, back, "", s.trErr(r, err))
106 return
107 }
108 s.redirect(w, r, back, s.tr(r, "flash.tagDeleted"), "")
109}
110
111func (s *Server) tagArchive(w http.ResponseWriter, r *http.Request) {
112 _, repo, _, ok := s.guard(w, r, access.RoleReadonly)
113 if !ok {
114 return
115 }
116 name := r.URL.Query().Get("name")
117 format := r.URL.Query().Get("format")
118 if format != "zip" && format != "tar.gz" {
119 http.NotFound(w, r)
120 return
121 }
122 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
123 if !gitrepo.HasTag(r.Context(), s.Git, dir, name) {
124 http.NotFound(w, r)
125 return
126 }
127 filename := archiveFilename(repo.Name, name, format)
128 if format == "zip" {
129 w.Header().Set("Content-Type", "application/zip")
130 } else {
131 w.Header().Set("Content-Type", "application/gzip")
132 }
133 w.Header().Set("Content-Disposition", "attachment; filename=\""+filename+"\"")
134 prefix := repo.Name + "-" + strings.ReplaceAll(name, "/", "-")
135 if err := gitrepo.Archive(r.Context(), w, s.Git, dir, prefix, name, format); err != nil && s.Log != nil {
136 s.Log.Error("tag archief", "err", err, "tag", name)
137 }
138}
139
140func (s *Server) addProtectedTag(w http.ResponseWriter, r *http.Request) {
141 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
142 if !ok || !s.csrfOK(w, r) {
143 return
144 }
145 back := repoURL(repo) + "/-/settings?tab=tags"
146 if err := s.Store.AddProtectedTag(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
147 s.redirect(w, r, back, "", s.trErr(r, err))
148 return
149 }
150 s.redirect(w, r, back, s.tr(r, "flash.tagOn"), "")
151}
152
153func (s *Server) removeProtectedTag(w http.ResponseWriter, r *http.Request) {
154 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
155 if !ok || !s.csrfOK(w, r) {
156 return
157 }
158 _ = s.Store.RemoveProtectedTag(r.Context(), repo.ID, r.FormValue("pattern"))
159 s.redirect(w, r, repoURL(repo)+"/-/settings?tab=tags", s.tr(r, "flash.tagOff"), "")
160}
161
162func tagArchiveURL(repo interface{ FullPath() string }, name, format string) string {
163 return "/" + repo.FullPath() + "/-/tags/archive?name=" + url.QueryEscape(name) + "&format=" + format
164}
165
166func archiveFilename(repoName, tag, format string) string {
167 base := repoName + "-" + strings.ReplaceAll(tag, "/", "-")
168 base = strings.Map(func(r rune) rune {
169 switch {
170 case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '.' || r == '_' || r == '-':
171 return r
172 default:
173 return '-'
174 }
175 }, base)
176 if base == "" || base == "-" {
177 base = "archive"
178 }
179 return base + "." + format
180}
internal/server/tags_test.go added +373 −0
@@ -0,0 +1,373 @@
1 package server
2
3 import (
4 "context"
5 "net/http"
6 "net/http/cookiejar"
7 "net/http/httptest"
8 "net/url"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "testing"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/auth"
17 "gitlab.com/Timfa/bluegit/internal/config"
18 "gitlab.com/Timfa/bluegit/internal/store"
19 )
20
21 func TestTagsPage(t *testing.T) {
22 if _, err := exec.LookPath("git"); err != nil {
23 t.Skip("git ontbreekt")
24 }
25 hook := filepath.Join(t.TempDir(), "bluegit")
26 build := exec.Command("go", "build", "-o", hook, "gitlab.com/Timfa/bluegit/cmd/bluegit")
27 build.Env = append(os.Environ(), "CGO_ENABLED=0")
28 if out, err := build.CombinedOutput(); err != nil {
29 t.Fatalf("hook bouwen: %v\n%s", err, out)
30 }
31
32 storage := t.TempDir()
33 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
34 if err != nil {
35 t.Fatal(err)
36 }
37 t.Cleanup(func() { _ = st.Close() })
38 cfg := config.Config{
39 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
40 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
41 Git: config.Git{Binary: "git", DefaultBranch: "master"},
42 SSH: config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
43 }
44 cfg.Auth.BaseURL = "https://auth.timfalken.com"
45 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: hook}
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48
49 jar, _ := cookiejar.New(nil)
50 client := &http.Client{Jar: jar}
51 res, err := client.Get(ts.URL + "/login")
52 if err != nil {
53 t.Fatal(err)
54 }
55 body := read(t, res)
56 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
57 "csrf": {csrfOf(t, body)}, "name": {"tags"}, "description": {"tags"}, "visibility": {"private"},
58 })
59 if err != nil {
60 t.Fatal(err)
61 }
62 body = read(t, res)
63 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
64 if err != nil {
65 t.Fatal(err)
66 }
67 body = read(t, res)
68 token := between(body, `<p class="code">`, "</p>")
69 work := t.TempDir()
70 git(t, work, "init", "-b", "master")
71 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
72 git(t, work, "config", "user.name", "tim")
73 writeFile(t, filepath.Join(work, "README.md"), "hallo\n")
74 git(t, work, "add", "README.md")
75 git(t, work, "commit", "-m", "eerste commit")
76 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/tags.git"
77 git(t, work, "remote", "add", "origin", remote)
78 git(t, work, "push", "-u", "origin", "master")
79 shaOut, err := gitOut(work, "rev-parse", "HEAD")
80 if err != nil {
81 t.Fatal(shaOut)
82 }
83 sha := strings.TrimSpace(shaOut)
84
85 res, err = client.Get(ts.URL + "/tim/tags")
86 if err != nil {
87 t.Fatal(err)
88 }
89 overview := read(t, res)
90 if !strings.Contains(overview, `href="/tim/tags/-/tags"`) || !strings.Contains(overview, ">0 tags<") && !strings.Contains(overview, "0 tags") {
91 t.Fatalf("overzicht zonder taglink:\n%s", overview)
92 }
93
94 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
95 if err != nil {
96 t.Fatal(err)
97 }
98 page := read(t, res)
99 for _, want := range []string{
100 `class="on">Tags`, `Find a tag`, `Create tag`, `No tags yet.`, `value="master"`, `/assets/tags.js`, `data-tag-dialog`,
101 } {
102 if !strings.Contains(page, want) {
103 t.Fatalf("tags mist %q\n%s", want, page)
104 }
105 }
106 csrf := csrfOf(t, page)
107 res, err = client.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
108 "csrf": {csrf}, "name": {"beta"}, "target": {"master"},
109 })
110 if err != nil {
111 t.Fatal(err)
112 }
113 page = read(t, res)
114 if !strings.Contains(page, "Tag created") || !strings.Contains(page, "<code>beta</code>") || !strings.Contains(page, "Lightweight") || !strings.Contains(page, "eerste commit") {
115 t.Fatalf("lichte tag:\n%s", page)
116 }
117 if !strings.Contains(page, "/tim/tags/-/commit/"+sha) || !strings.Contains(page, sha[:10]) {
118 t.Fatalf("commitlink:\n%s", page)
119 }
120 time.Sleep(1100 * time.Millisecond)
121
122 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
123 if err != nil {
124 t.Fatal(err)
125 }
126 csrf = csrfOf(t, read(t, res))
127 res, err = client.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
128 "csrf": {csrf}, "name": {"v1"}, "target": {sha}, "message": {"uitgave\ntweede regel"},
129 })
130 if err != nil {
131 t.Fatal(err)
132 }
133 page = read(t, res)
134 if strings.Index(page, "<code>v1</code>") < 0 || strings.Index(page, "<code>v1</code>") > strings.Index(page, "<code>beta</code>") {
135 t.Fatalf("nieuwste niet eerst:\n%s", page)
136 }
137 if !strings.Contains(page, "Annotated") || !strings.Contains(page, "uitgave") || !strings.Contains(page, "tweede regel") {
138 t.Fatalf("bericht:\n%s", page)
139 }
140
141 ctx := context.Background()
142 repo, err := st.RepoByPath(ctx, "tim", "tags")
143 if err != nil {
144 t.Fatal(err)
145 }
146 tim, err := st.UserByUsername(ctx, "tim")
147 if err != nil {
148 t.Fatal(err)
149 }
150 if _, err := st.CreateRelease(ctx, repo.ID, "v1", sha, "Versie een", "", tim.ID, 0, nil); err != nil {
151 t.Fatal(err)
152 }
153 res, err = client.Get(ts.URL + "/tim/tags/-/tags?q=v1")
154 if err != nil {
155 t.Fatal(err)
156 }
157 filtered := read(t, res)
158 if strings.Contains(filtered, "<code>beta</code>") || !strings.Contains(filtered, `href="/tim/tags/-/releases#v1"`) {
159 t.Fatalf("zoeken of release:\n%s", filtered)
160 }
161 res, err = client.Get(ts.URL + "/tim/tags/-/tags?q=geen")
162 if err != nil {
163 t.Fatal(err)
164 }
165 if !strings.Contains(read(t, res), "No matching tags.") {
166 t.Fatal("lege zoekactie")
167 }
168
169 res, err = client.Get(ts.URL + "/tim/tags/-/tags/archive?name=v1&format=zip")
170 if err != nil {
171 t.Fatal(err)
172 }
173 zip := read(t, res)
174 if res.StatusCode != 200 || !strings.HasPrefix(zip, "PK") || !strings.Contains(res.Header.Get("Content-Disposition"), "tags-v1.zip") {
175 t.Fatalf("zip %d %q %q", res.StatusCode, res.Header.Get("Content-Disposition"), zip[:min(8, len(zip))])
176 }
177 res, err = client.Get(ts.URL + "/tim/tags/-/tags/archive?name=v1&format=tar.gz")
178 if err != nil {
179 t.Fatal(err)
180 }
181 gz := read(t, res)
182 if res.StatusCode != 200 || len(gz) < 2 || gz[0] != 0x1f || gz[1] != 0x8b {
183 t.Fatalf("tar.gz %d", res.StatusCode)
184 }
185
186 res, err = client.Get(ts.URL + "/tim/tags/-/settings?tab=tags")
187 if err != nil {
188 t.Fatal(err)
189 }
190 settings := read(t, res)
191 if !strings.Contains(settings, `class="on">Tags`) || !strings.Contains(settings, "v*") || !strings.Contains(settings, "Developers cannot create or delete these tags.") {
192 t.Fatalf("instellingen:\n%s", settings)
193 }
194 res, err = client.PostForm(ts.URL+"/tim/tags/-/protected-tags", url.Values{
195 "csrf": {csrfOf(t, settings)}, "pattern": {"v*"},
196 })
197 if err != nil {
198 t.Fatal(err)
199 }
200 if !strings.Contains(read(t, res), "<code>v*</code>") {
201 t.Fatal("patroon niet opgeslagen")
202 }
203 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
204 if err != nil {
205 t.Fatal(err)
206 }
207 if !strings.Contains(read(t, res), "Protected") {
208 t.Fatal("beschermde tag zonder kenmerk")
209 }
210
211 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
212 if err != nil {
213 t.Fatal(err)
214 }
215 if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
216 t.Fatal(err)
217 }
218 adaSess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
219 if err != nil {
220 t.Fatal(err)
221 }
222 adaJar, _ := cookiejar.New(nil)
223 adaClient := &http.Client{Jar: adaJar}
224 u, _ := url.Parse(ts.URL)
225 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: adaSess.ID, Path: "/"}})
226 res, err = adaClient.Get(ts.URL + "/tim/tags/-/tags")
227 if err != nil {
228 t.Fatal(err)
229 }
230 adaPage := read(t, res)
231 if strings.Contains(adaPage, `data-tag="v1"`) || !strings.Contains(adaPage, `data-tag="beta"`) {
232 t.Fatalf("verwijderknoppen:\n%s", adaPage)
233 }
234 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
235 "csrf": {csrfOf(t, adaPage)}, "name": {"v2"}, "target": {"master"}, "message": {"nee"},
236 })
237 if err != nil {
238 t.Fatal(err)
239 }
240 if !strings.Contains(read(t, res), "tag v2 is protected") {
241 t.Fatal("ontwikkelaar zette een beschermde tag")
242 }
243 res, err = adaClient.Get(ts.URL + "/tim/tags/-/tags")
244 if err != nil {
245 t.Fatal(err)
246 }
247 adaCSRF := csrfOf(t, read(t, res))
248 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags/delete", url.Values{"csrf": {adaCSRF}, "name": {"v1"}})
249 if err != nil {
250 t.Fatal(err)
251 }
252 if !strings.Contains(read(t, res), "tag v1 is protected") {
253 t.Fatal("ontwikkelaar verwijderde een beschermde tag")
254 }
255 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
256 "csrf": {adaCSRF}, "name": {"side"}, "target": {"master"},
257 })
258 if err != nil {
259 t.Fatal(err)
260 }
261 if !strings.Contains(read(t, res), "<code>side</code>") {
262 t.Fatal("gewone tag van een ontwikkelaar")
263 }
264 res, err = adaClient.Get(ts.URL + "/tim/tags/-/tags")
265 if err != nil {
266 t.Fatal(err)
267 }
268 sideCSRF := csrfOf(t, read(t, res))
269 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags/delete", url.Values{
270 "csrf": {sideCSRF}, "name": {"side"},
271 })
272 if err != nil {
273 t.Fatal(err)
274 }
275 deleted := read(t, res)
276 if strings.Contains(deleted, "<code>side</code>") || !strings.Contains(deleted, "Tag deleted") {
277 t.Fatal("verwijderen van een gewone tag")
278 }
279
280 adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
281 if err != nil {
282 t.Fatal(err)
283 }
284 adaWork := t.TempDir()
285 adaRemote := strings.Replace(ts.URL, "http://", "http://ada:"+adaToken+"@", 1) + "/tim/tags.git"
286 git(t, adaWork, "clone", adaRemote, ".")
287 git(t, adaWork, "config", "user.email", "ada@users.git.timfalken.com")
288 git(t, adaWork, "config", "user.name", "ada")
289 if out, err := gitOut(adaWork, "tag", "v9"); err != nil {
290 t.Fatal(out)
291 }
292 if out, err := gitOut(adaWork, "push", "origin", "v9"); err == nil || !strings.Contains(out, "protected") {
293 t.Fatalf("push van beschermde tag: %v\n%s", err, out)
294 }
295 if out, err := gitOut(adaWork, "tag", "plain"); err != nil {
296 t.Fatal(out)
297 }
298 if out, err := gitOut(adaWork, "push", "origin", "plain"); err != nil {
299 t.Fatalf("push van gewone tag: %v\n%s", err, out)
300 }
301
302 ro, err := st.UpsertUser(ctx, 3, "ro", "", false)
303 if err != nil {
304 t.Fatal(err)
305 }
306 if err := st.SetMember(ctx, "repo", repo.ID, "ro", "readonly"); err != nil {
307 t.Fatal(err)
308 }
309 roSess, err := st.CreateSession(ctx, ro.ID, "dev", time.Now().Add(time.Hour))
310 if err != nil {
311 t.Fatal(err)
312 }
313 roJar, _ := cookiejar.New(nil)
314 roClient := &http.Client{Jar: roJar}
315 roJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: roSess.ID, Path: "/"}})
316 res, err = roClient.Get(ts.URL + "/tim/tags/-/tags")
317 if err != nil {
318 t.Fatal(err)
319 }
320 roPage := read(t, res)
321 if strings.Contains(roPage, "Create tag") || strings.Contains(roPage, "data-tag-dialog") || strings.Contains(roPage, "data-tag-open") {
322 t.Fatalf("alleen-lezen ziet het formulier:\n%s", roPage)
323 }
324 res, err = roClient.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{"csrf": {csrfOf(t, roPage)}, "name": {"x"}, "target": {"master"}})
325 if err != nil {
326 t.Fatal(err)
327 }
328 if res.StatusCode != http.StatusForbidden {
329 t.Fatalf("alleen-lezen status %d", res.StatusCode)
330 }
331 _ = res.Body.Close()
332
333 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
334 if err != nil {
335 t.Fatal(err)
336 }
337 delCSRF := csrfOf(t, read(t, res))
338 res, err = client.PostForm(ts.URL+"/tim/tags/-/tags/delete", url.Values{
339 "csrf": {delCSRF}, "name": {"v1"},
340 })
341 if err != nil {
342 t.Fatal(err)
343 }
344 gone := read(t, res)
345 if strings.Contains(gone, "<code>v1</code>") || !strings.Contains(gone, "Tag deleted") {
346 t.Fatalf("beheerder kon v1 niet verwijderen:\n%s", gone)
347 }
348
349 if err := st.SetLanguage(ctx, tim.ID, "nl"); err != nil {
350 t.Fatal(err)
351 }
352 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
353 if err != nil {
354 t.Fatal(err)
355 }
356 nl := read(t, res)
357 for _, want := range []string{"Tag aanmaken", "Zoek een tag", "Zonder bericht", "Verwijderen"} {
358 if !strings.Contains(nl, want) {
359 t.Fatalf("nederlands mist %q\n%s", want, nl)
360 }
361 }
362 if err := st.SetLanguage(ctx, tim.ID, "cuneiform"); err != nil {
363 t.Fatal(err)
364 }
365 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
366 if err != nil {
367 t.Fatal(err)
368 }
369 signs := read(t, res)
370 if strings.Contains(signs, "Create tag") || strings.Contains(signs, "Find a tag") || !strings.Contains(signs, "beta") {
371 t.Fatalf("spijkerschrift:\n%s", signs)
372 }
373 }
@@ -0,0 +1,373 @@
1package server
2
3import (
4 "context"
5 "net/http"
6 "net/http/cookiejar"
7 "net/http/httptest"
8 "net/url"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "testing"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/auth"
17 "gitlab.com/Timfa/bluegit/internal/config"
18 "gitlab.com/Timfa/bluegit/internal/store"
19)
20
21func TestTagsPage(t *testing.T) {
22 if _, err := exec.LookPath("git"); err != nil {
23 t.Skip("git ontbreekt")
24 }
25 hook := filepath.Join(t.TempDir(), "bluegit")
26 build := exec.Command("go", "build", "-o", hook, "gitlab.com/Timfa/bluegit/cmd/bluegit")
27 build.Env = append(os.Environ(), "CGO_ENABLED=0")
28 if out, err := build.CombinedOutput(); err != nil {
29 t.Fatalf("hook bouwen: %v\n%s", err, out)
30 }
31
32 storage := t.TempDir()
33 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
34 if err != nil {
35 t.Fatal(err)
36 }
37 t.Cleanup(func() { _ = st.Close() })
38 cfg := config.Config{
39 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
40 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
41 Git: config.Git{Binary: "git", DefaultBranch: "master"},
42 SSH: config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
43 }
44 cfg.Auth.BaseURL = "https://auth.timfalken.com"
45 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: hook}
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48
49 jar, _ := cookiejar.New(nil)
50 client := &http.Client{Jar: jar}
51 res, err := client.Get(ts.URL + "/login")
52 if err != nil {
53 t.Fatal(err)
54 }
55 body := read(t, res)
56 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
57 "csrf": {csrfOf(t, body)}, "name": {"tags"}, "description": {"tags"}, "visibility": {"private"},
58 })
59 if err != nil {
60 t.Fatal(err)
61 }
62 body = read(t, res)
63 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
64 if err != nil {
65 t.Fatal(err)
66 }
67 body = read(t, res)
68 token := between(body, `<p class="code">`, "</p>")
69 work := t.TempDir()
70 git(t, work, "init", "-b", "master")
71 git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
72 git(t, work, "config", "user.name", "tim")
73 writeFile(t, filepath.Join(work, "README.md"), "hallo\n")
74 git(t, work, "add", "README.md")
75 git(t, work, "commit", "-m", "eerste commit")
76 remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/tags.git"
77 git(t, work, "remote", "add", "origin", remote)
78 git(t, work, "push", "-u", "origin", "master")
79 shaOut, err := gitOut(work, "rev-parse", "HEAD")
80 if err != nil {
81 t.Fatal(shaOut)
82 }
83 sha := strings.TrimSpace(shaOut)
84
85 res, err = client.Get(ts.URL + "/tim/tags")
86 if err != nil {
87 t.Fatal(err)
88 }
89 overview := read(t, res)
90 if !strings.Contains(overview, `href="/tim/tags/-/tags"`) || !strings.Contains(overview, ">0 tags<") && !strings.Contains(overview, "0 tags") {
91 t.Fatalf("overzicht zonder taglink:\n%s", overview)
92 }
93
94 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
95 if err != nil {
96 t.Fatal(err)
97 }
98 page := read(t, res)
99 for _, want := range []string{
100 `class="on">Tags`, `Find a tag`, `Create tag`, `No tags yet.`, `value="master"`, `/assets/tags.js`, `data-tag-dialog`,
101 } {
102 if !strings.Contains(page, want) {
103 t.Fatalf("tags mist %q\n%s", want, page)
104 }
105 }
106 csrf := csrfOf(t, page)
107 res, err = client.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
108 "csrf": {csrf}, "name": {"beta"}, "target": {"master"},
109 })
110 if err != nil {
111 t.Fatal(err)
112 }
113 page = read(t, res)
114 if !strings.Contains(page, "Tag created") || !strings.Contains(page, "<code>beta</code>") || !strings.Contains(page, "Lightweight") || !strings.Contains(page, "eerste commit") {
115 t.Fatalf("lichte tag:\n%s", page)
116 }
117 if !strings.Contains(page, "/tim/tags/-/commit/"+sha) || !strings.Contains(page, sha[:10]) {
118 t.Fatalf("commitlink:\n%s", page)
119 }
120 time.Sleep(1100 * time.Millisecond)
121
122 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
123 if err != nil {
124 t.Fatal(err)
125 }
126 csrf = csrfOf(t, read(t, res))
127 res, err = client.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
128 "csrf": {csrf}, "name": {"v1"}, "target": {sha}, "message": {"uitgave\ntweede regel"},
129 })
130 if err != nil {
131 t.Fatal(err)
132 }
133 page = read(t, res)
134 if strings.Index(page, "<code>v1</code>") < 0 || strings.Index(page, "<code>v1</code>") > strings.Index(page, "<code>beta</code>") {
135 t.Fatalf("nieuwste niet eerst:\n%s", page)
136 }
137 if !strings.Contains(page, "Annotated") || !strings.Contains(page, "uitgave") || !strings.Contains(page, "tweede regel") {
138 t.Fatalf("bericht:\n%s", page)
139 }
140
141 ctx := context.Background()
142 repo, err := st.RepoByPath(ctx, "tim", "tags")
143 if err != nil {
144 t.Fatal(err)
145 }
146 tim, err := st.UserByUsername(ctx, "tim")
147 if err != nil {
148 t.Fatal(err)
149 }
150 if _, err := st.CreateRelease(ctx, repo.ID, "v1", sha, "Versie een", "", tim.ID, 0, nil); err != nil {
151 t.Fatal(err)
152 }
153 res, err = client.Get(ts.URL + "/tim/tags/-/tags?q=v1")
154 if err != nil {
155 t.Fatal(err)
156 }
157 filtered := read(t, res)
158 if strings.Contains(filtered, "<code>beta</code>") || !strings.Contains(filtered, `href="/tim/tags/-/releases#v1"`) {
159 t.Fatalf("zoeken of release:\n%s", filtered)
160 }
161 res, err = client.Get(ts.URL + "/tim/tags/-/tags?q=geen")
162 if err != nil {
163 t.Fatal(err)
164 }
165 if !strings.Contains(read(t, res), "No matching tags.") {
166 t.Fatal("lege zoekactie")
167 }
168
169 res, err = client.Get(ts.URL + "/tim/tags/-/tags/archive?name=v1&format=zip")
170 if err != nil {
171 t.Fatal(err)
172 }
173 zip := read(t, res)
174 if res.StatusCode != 200 || !strings.HasPrefix(zip, "PK") || !strings.Contains(res.Header.Get("Content-Disposition"), "tags-v1.zip") {
175 t.Fatalf("zip %d %q %q", res.StatusCode, res.Header.Get("Content-Disposition"), zip[:min(8, len(zip))])
176 }
177 res, err = client.Get(ts.URL + "/tim/tags/-/tags/archive?name=v1&format=tar.gz")
178 if err != nil {
179 t.Fatal(err)
180 }
181 gz := read(t, res)
182 if res.StatusCode != 200 || len(gz) < 2 || gz[0] != 0x1f || gz[1] != 0x8b {
183 t.Fatalf("tar.gz %d", res.StatusCode)
184 }
185
186 res, err = client.Get(ts.URL + "/tim/tags/-/settings?tab=tags")
187 if err != nil {
188 t.Fatal(err)
189 }
190 settings := read(t, res)
191 if !strings.Contains(settings, `class="on">Tags`) || !strings.Contains(settings, "v*") || !strings.Contains(settings, "Developers cannot create or delete these tags.") {
192 t.Fatalf("instellingen:\n%s", settings)
193 }
194 res, err = client.PostForm(ts.URL+"/tim/tags/-/protected-tags", url.Values{
195 "csrf": {csrfOf(t, settings)}, "pattern": {"v*"},
196 })
197 if err != nil {
198 t.Fatal(err)
199 }
200 if !strings.Contains(read(t, res), "<code>v*</code>") {
201 t.Fatal("patroon niet opgeslagen")
202 }
203 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
204 if err != nil {
205 t.Fatal(err)
206 }
207 if !strings.Contains(read(t, res), "Protected") {
208 t.Fatal("beschermde tag zonder kenmerk")
209 }
210
211 ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
212 if err != nil {
213 t.Fatal(err)
214 }
215 if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
216 t.Fatal(err)
217 }
218 adaSess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
219 if err != nil {
220 t.Fatal(err)
221 }
222 adaJar, _ := cookiejar.New(nil)
223 adaClient := &http.Client{Jar: adaJar}
224 u, _ := url.Parse(ts.URL)
225 adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: adaSess.ID, Path: "/"}})
226 res, err = adaClient.Get(ts.URL + "/tim/tags/-/tags")
227 if err != nil {
228 t.Fatal(err)
229 }
230 adaPage := read(t, res)
231 if strings.Contains(adaPage, `data-tag="v1"`) || !strings.Contains(adaPage, `data-tag="beta"`) {
232 t.Fatalf("verwijderknoppen:\n%s", adaPage)
233 }
234 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
235 "csrf": {csrfOf(t, adaPage)}, "name": {"v2"}, "target": {"master"}, "message": {"nee"},
236 })
237 if err != nil {
238 t.Fatal(err)
239 }
240 if !strings.Contains(read(t, res), "tag v2 is protected") {
241 t.Fatal("ontwikkelaar zette een beschermde tag")
242 }
243 res, err = adaClient.Get(ts.URL + "/tim/tags/-/tags")
244 if err != nil {
245 t.Fatal(err)
246 }
247 adaCSRF := csrfOf(t, read(t, res))
248 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags/delete", url.Values{"csrf": {adaCSRF}, "name": {"v1"}})
249 if err != nil {
250 t.Fatal(err)
251 }
252 if !strings.Contains(read(t, res), "tag v1 is protected") {
253 t.Fatal("ontwikkelaar verwijderde een beschermde tag")
254 }
255 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{
256 "csrf": {adaCSRF}, "name": {"side"}, "target": {"master"},
257 })
258 if err != nil {
259 t.Fatal(err)
260 }
261 if !strings.Contains(read(t, res), "<code>side</code>") {
262 t.Fatal("gewone tag van een ontwikkelaar")
263 }
264 res, err = adaClient.Get(ts.URL + "/tim/tags/-/tags")
265 if err != nil {
266 t.Fatal(err)
267 }
268 sideCSRF := csrfOf(t, read(t, res))
269 res, err = adaClient.PostForm(ts.URL+"/tim/tags/-/tags/delete", url.Values{
270 "csrf": {sideCSRF}, "name": {"side"},
271 })
272 if err != nil {
273 t.Fatal(err)
274 }
275 deleted := read(t, res)
276 if strings.Contains(deleted, "<code>side</code>") || !strings.Contains(deleted, "Tag deleted") {
277 t.Fatal("verwijderen van een gewone tag")
278 }
279
280 adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
281 if err != nil {
282 t.Fatal(err)
283 }
284 adaWork := t.TempDir()
285 adaRemote := strings.Replace(ts.URL, "http://", "http://ada:"+adaToken+"@", 1) + "/tim/tags.git"
286 git(t, adaWork, "clone", adaRemote, ".")
287 git(t, adaWork, "config", "user.email", "ada@users.git.timfalken.com")
288 git(t, adaWork, "config", "user.name", "ada")
289 if out, err := gitOut(adaWork, "tag", "v9"); err != nil {
290 t.Fatal(out)
291 }
292 if out, err := gitOut(adaWork, "push", "origin", "v9"); err == nil || !strings.Contains(out, "protected") {
293 t.Fatalf("push van beschermde tag: %v\n%s", err, out)
294 }
295 if out, err := gitOut(adaWork, "tag", "plain"); err != nil {
296 t.Fatal(out)
297 }
298 if out, err := gitOut(adaWork, "push", "origin", "plain"); err != nil {
299 t.Fatalf("push van gewone tag: %v\n%s", err, out)
300 }
301
302 ro, err := st.UpsertUser(ctx, 3, "ro", "", false)
303 if err != nil {
304 t.Fatal(err)
305 }
306 if err := st.SetMember(ctx, "repo", repo.ID, "ro", "readonly"); err != nil {
307 t.Fatal(err)
308 }
309 roSess, err := st.CreateSession(ctx, ro.ID, "dev", time.Now().Add(time.Hour))
310 if err != nil {
311 t.Fatal(err)
312 }
313 roJar, _ := cookiejar.New(nil)
314 roClient := &http.Client{Jar: roJar}
315 roJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: roSess.ID, Path: "/"}})
316 res, err = roClient.Get(ts.URL + "/tim/tags/-/tags")
317 if err != nil {
318 t.Fatal(err)
319 }
320 roPage := read(t, res)
321 if strings.Contains(roPage, "Create tag") || strings.Contains(roPage, "data-tag-dialog") || strings.Contains(roPage, "data-tag-open") {
322 t.Fatalf("alleen-lezen ziet het formulier:\n%s", roPage)
323 }
324 res, err = roClient.PostForm(ts.URL+"/tim/tags/-/tags", url.Values{"csrf": {csrfOf(t, roPage)}, "name": {"x"}, "target": {"master"}})
325 if err != nil {
326 t.Fatal(err)
327 }
328 if res.StatusCode != http.StatusForbidden {
329 t.Fatalf("alleen-lezen status %d", res.StatusCode)
330 }
331 _ = res.Body.Close()
332
333 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
334 if err != nil {
335 t.Fatal(err)
336 }
337 delCSRF := csrfOf(t, read(t, res))
338 res, err = client.PostForm(ts.URL+"/tim/tags/-/tags/delete", url.Values{
339 "csrf": {delCSRF}, "name": {"v1"},
340 })
341 if err != nil {
342 t.Fatal(err)
343 }
344 gone := read(t, res)
345 if strings.Contains(gone, "<code>v1</code>") || !strings.Contains(gone, "Tag deleted") {
346 t.Fatalf("beheerder kon v1 niet verwijderen:\n%s", gone)
347 }
348
349 if err := st.SetLanguage(ctx, tim.ID, "nl"); err != nil {
350 t.Fatal(err)
351 }
352 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
353 if err != nil {
354 t.Fatal(err)
355 }
356 nl := read(t, res)
357 for _, want := range []string{"Tag aanmaken", "Zoek een tag", "Zonder bericht", "Verwijderen"} {
358 if !strings.Contains(nl, want) {
359 t.Fatalf("nederlands mist %q\n%s", want, nl)
360 }
361 }
362 if err := st.SetLanguage(ctx, tim.ID, "cuneiform"); err != nil {
363 t.Fatal(err)
364 }
365 res, err = client.Get(ts.URL + "/tim/tags/-/tags")
366 if err != nil {
367 t.Fatal(err)
368 }
369 signs := read(t, res)
370 if strings.Contains(signs, "Create tag") || strings.Contains(signs, "Find a tag") || !strings.Contains(signs, "beta") {
371 t.Fatalf("spijkerschrift:\n%s", signs)
372 }
373}
internal/server/templates/collab.html +11 −1
@@ -364,7 +364,7 @@
364 364 <h1>{{t "title.releases"}}</h1>
365 365 {{template "repotabs" .}}
366 366 {{range .Releases}}
367 <article class="panel">
367 <article class="panel" id="{{.Tag}}">
368 368 <h2>{{.Name}} <span class="pill">{{.Tag}}</span></h2>
369 369 <p class="muted">{{short .CommitSHA}}</p>
370 370 {{if .Body}}<pre>{{.Body}}</pre>{{end}}
@@ -417,6 +417,7 @@
417 417 <a href="?tab=general"{{if or (eq .Tab "general") (eq .Tab "")}} class="on"{{end}}>{{t "set.general"}}</a>
418 418 <a href="?tab=members"{{if eq .Tab "members"}} class="on"{{end}}>{{t "set.members"}}</a>
419 419 <a href="?tab=branches"{{if eq .Tab "branches"}} class="on"{{end}}>{{t "set.branches"}}</a>
420 <a href="?tab=tags"{{if eq .Tab "tags"}} class="on"{{end}}>{{t "set.tags"}}</a>
420 421 <a href="?tab=secrets"{{if eq .Tab "secrets"}} class="on"{{end}}>{{t "set.secrets"}}</a>
421 422 <a href="?tab=webhooks"{{if eq .Tab "webhooks"}} class="on"{{end}}>{{t "set.webhooks"}}</a>
422 423 <a href="?tab=approvals"{{if eq .Tab "approvals"}} class="on"{{end}}>{{t "appr.tab"}}</a>
@@ -444,6 +445,15 @@
444 445 <form method="post" action="/{{$.Repo.FullPath}}/-/protected/remove"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="pattern" value="{{.}}"><button class="ghost" type="submit">{{t "action.remove"}}</button></form>
445 446 </li>{{end}}</ul>
446 447 <p class="muted">{{t "set.protectHint"}}</p>
448 {{else if eq .Tab "tags"}}
449 <form class="panel" method="post" action="/{{.Repo.FullPath}}/-/protected-tags">
450 <input type="hidden" name="csrf" value="{{.CSRF}}">
451 <div class="row"><input name="pattern" placeholder="{{t "set.tagPattern"}}" required><button type="submit">{{t "action.protect"}}</button></div>
452 </form>
453 <ul class="clean">{{range .TagPatterns}}<li><code>{{.}}</code>
454 <form method="post" action="/{{$.Repo.FullPath}}/-/protected-tags/remove"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="pattern" value="{{.}}"><button class="ghost" type="submit">{{t "action.remove"}}</button></form>
455 </li>{{end}}</ul>
456 <p class="muted">{{t "set.tagHint"}}</p>
447 457 {{else if eq .Tab "secrets"}}
448 458 <form class="panel" method="post" action="/{{.Repo.FullPath}}/-/secrets">
449 459 <input type="hidden" name="csrf" value="{{.CSRF}}">
@@ -364,7 +364,7 @@
364<h1>{{t "title.releases"}}</h1>
364<h1>{{t "title.releases"}}</h1>
365{{template "repotabs" .}}
365{{template "repotabs" .}}
366{{range .Releases}}
366{{range .Releases}}
367<article class="panel">
367<article class="panel" id="{{.Tag}}">
368 <h2>{{.Name}} <span class="pill">{{.Tag}}</span></h2>
368 <h2>{{.Name}} <span class="pill">{{.Tag}}</span></h2>
369 <p class="muted">{{short .CommitSHA}}</p>
369 <p class="muted">{{short .CommitSHA}}</p>
370 {{if .Body}}<pre>{{.Body}}</pre>{{end}}
370 {{if .Body}}<pre>{{.Body}}</pre>{{end}}
@@ -417,6 +417,7 @@
417 <a href="?tab=general"{{if or (eq .Tab "general") (eq .Tab "")}} class="on"{{end}}>{{t "set.general"}}</a>
417 <a href="?tab=general"{{if or (eq .Tab "general") (eq .Tab "")}} class="on"{{end}}>{{t "set.general"}}</a>
418 <a href="?tab=members"{{if eq .Tab "members"}} class="on"{{end}}>{{t "set.members"}}</a>
418 <a href="?tab=members"{{if eq .Tab "members"}} class="on"{{end}}>{{t "set.members"}}</a>
419 <a href="?tab=branches"{{if eq .Tab "branches"}} class="on"{{end}}>{{t "set.branches"}}</a>
419 <a href="?tab=branches"{{if eq .Tab "branches"}} class="on"{{end}}>{{t "set.branches"}}</a>
420 <a href="?tab=tags"{{if eq .Tab "tags"}} class="on"{{end}}>{{t "set.tags"}}</a>
420 <a href="?tab=secrets"{{if eq .Tab "secrets"}} class="on"{{end}}>{{t "set.secrets"}}</a>
421 <a href="?tab=secrets"{{if eq .Tab "secrets"}} class="on"{{end}}>{{t "set.secrets"}}</a>
421 <a href="?tab=webhooks"{{if eq .Tab "webhooks"}} class="on"{{end}}>{{t "set.webhooks"}}</a>
422 <a href="?tab=webhooks"{{if eq .Tab "webhooks"}} class="on"{{end}}>{{t "set.webhooks"}}</a>
422 <a href="?tab=approvals"{{if eq .Tab "approvals"}} class="on"{{end}}>{{t "appr.tab"}}</a>
423 <a href="?tab=approvals"{{if eq .Tab "approvals"}} class="on"{{end}}>{{t "appr.tab"}}</a>
@@ -444,6 +445,15 @@
444 <form method="post" action="/{{$.Repo.FullPath}}/-/protected/remove"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="pattern" value="{{.}}"><button class="ghost" type="submit">{{t "action.remove"}}</button></form>
445 <form method="post" action="/{{$.Repo.FullPath}}/-/protected/remove"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="pattern" value="{{.}}"><button class="ghost" type="submit">{{t "action.remove"}}</button></form>
445</li>{{end}}</ul>
446</li>{{end}}</ul>
446<p class="muted">{{t "set.protectHint"}}</p>
447<p class="muted">{{t "set.protectHint"}}</p>
448{{else if eq .Tab "tags"}}
449<form class="panel" method="post" action="/{{.Repo.FullPath}}/-/protected-tags">
450 <input type="hidden" name="csrf" value="{{.CSRF}}">
451 <div class="row"><input name="pattern" placeholder="{{t "set.tagPattern"}}" required><button type="submit">{{t "action.protect"}}</button></div>
452</form>
453<ul class="clean">{{range .TagPatterns}}<li><code>{{.}}</code>
454 <form method="post" action="/{{$.Repo.FullPath}}/-/protected-tags/remove"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="pattern" value="{{.}}"><button class="ghost" type="submit">{{t "action.remove"}}</button></form>
455</li>{{end}}</ul>
456<p class="muted">{{t "set.tagHint"}}</p>
447{{else if eq .Tab "secrets"}}
457{{else if eq .Tab "secrets"}}
448<form class="panel" method="post" action="/{{.Repo.FullPath}}/-/secrets">
458<form class="panel" method="post" action="/{{.Repo.FullPath}}/-/secrets">
449 <input type="hidden" name="csrf" value="{{.CSRF}}">
459 <input type="hidden" name="csrf" value="{{.CSRF}}">
internal/server/templates/layout.html +1 −0
@@ -40,6 +40,7 @@
40 40 <a href="/{{.Repo.FullPath}}/-/tree{{if .Rev}}?rev={{.Rev}}{{end}}"{{if eq .Page "files"}} class="on"{{end}}>{{t "tab.files"}}</a>
41 41 <a href="/{{.Repo.FullPath}}/-/commits{{if .Rev}}?rev={{.Rev}}{{end}}"{{if eq .Page "commits"}} class="on"{{end}}>{{t "tab.commits"}}</a>
42 42 <a href="/{{.Repo.FullPath}}/-/branches">{{t "tab.branches"}}</a>
43 <a href="/{{.Repo.FullPath}}/-/tags"{{if eq .Page "tags"}} class="on"{{end}}>{{t "tab.tags"}}</a>
43 44 <a href="/{{.Repo.FullPath}}/-/merge-requests">{{t "tab.mrs"}}</a>
44 45 <a href="/{{.Repo.FullPath}}/-/pipelines"{{if or (eq .Page "pipelines") (eq .Page "editor")}} class="on"{{end}}>{{t "tab.pipelines"}}</a>
45 46 <a href="/{{.Repo.FullPath}}/-/releases">{{t "tab.releases"}}</a>
@@ -40,6 +40,7 @@
40 <a href="/{{.Repo.FullPath}}/-/tree{{if .Rev}}?rev={{.Rev}}{{end}}"{{if eq .Page "files"}} class="on"{{end}}>{{t "tab.files"}}</a>
40 <a href="/{{.Repo.FullPath}}/-/tree{{if .Rev}}?rev={{.Rev}}{{end}}"{{if eq .Page "files"}} class="on"{{end}}>{{t "tab.files"}}</a>
41 <a href="/{{.Repo.FullPath}}/-/commits{{if .Rev}}?rev={{.Rev}}{{end}}"{{if eq .Page "commits"}} class="on"{{end}}>{{t "tab.commits"}}</a>
41 <a href="/{{.Repo.FullPath}}/-/commits{{if .Rev}}?rev={{.Rev}}{{end}}"{{if eq .Page "commits"}} class="on"{{end}}>{{t "tab.commits"}}</a>
42 <a href="/{{.Repo.FullPath}}/-/branches">{{t "tab.branches"}}</a>
42 <a href="/{{.Repo.FullPath}}/-/branches">{{t "tab.branches"}}</a>
43 <a href="/{{.Repo.FullPath}}/-/tags"{{if eq .Page "tags"}} class="on"{{end}}>{{t "tab.tags"}}</a>
43 <a href="/{{.Repo.FullPath}}/-/merge-requests">{{t "tab.mrs"}}</a>
44 <a href="/{{.Repo.FullPath}}/-/merge-requests">{{t "tab.mrs"}}</a>
44 <a href="/{{.Repo.FullPath}}/-/pipelines"{{if or (eq .Page "pipelines") (eq .Page "editor")}} class="on"{{end}}>{{t "tab.pipelines"}}</a>
45 <a href="/{{.Repo.FullPath}}/-/pipelines"{{if or (eq .Page "pipelines") (eq .Page "editor")}} class="on"{{end}}>{{t "tab.pipelines"}}</a>
45 <a href="/{{.Repo.FullPath}}/-/releases">{{t "tab.releases"}}</a>
46 <a href="/{{.Repo.FullPath}}/-/releases">{{t "tab.releases"}}</a>
internal/server/templates/pages.html +58 −3
@@ -382,9 +382,64 @@
382 382 {{template "layout-start" .}}
383 383 <h1>{{t "title.tags"}}</h1>
384 384 {{template "repotabs" .}}
385 <ul class="clean">
386 {{range .TagNames}}<li><code>{{.}}</code></li>{{else}}<li class="muted">{{t "repo.noTags"}}</li>{{end}}
387 </ul>
385 <form class="bar" method="get" action="/{{.Repo.FullPath}}/-/tags">
386 <input type="search" name="q" value="{{.Query}}" placeholder="{{t "tag.search"}}" aria-label="{{t "tag.search"}}">
387 </form>
388 {{if .CanWrite}}
389 <form class="panel" method="post" action="/{{.Repo.FullPath}}/-/tags">
390 <input type="hidden" name="csrf" value="{{.CSRF}}">
391 <div class="row">
392 <input name="name" placeholder="{{t "tag.name"}}" required>
393 <input name="target" list="tag-targets" placeholder="{{t "tag.target"}}" value="{{.Rev}}" required>
394 <input name="message" placeholder="{{t "tag.message"}}">
395 <button type="submit">{{t "tag.create"}}</button>
396 </div>
397 </form>
398 <datalist id="tag-targets">{{range .Branches}}<option value="{{.Name}}"></option>{{end}}</datalist>
399 {{end}}
400 {{if .Tags}}
401 <table class="tags">
402 <thead>
403 <tr>
404 <th>{{t "tag.name"}}</th>
405 <th>{{t "tag.commit"}}</th>
406 <th>{{t "tag.date"}}</th>
407 <th>{{t "tag.message"}}</th>
408 <th></th>
409 </tr>
410 </thead>
411 <tbody>
412 {{range .Tags}}
413 <tr>
414 <td><code>{{.Name}}</code> {{if .Protected}}<span class="pill">{{t "vis.protected"}}</span>{{end}}</td>
415 <td>{{if .SHA}}<a href="/{{$.Repo.FullPath}}/-/commit/{{.SHA}}"><code>{{.Short}}</code> {{.Subject}}</a>{{end}}</td>
416 <td>{{.Date}}</td>
417 <td>{{if .Annotated}}<span class="pill">{{t "tag.annotated"}}</span> {{if .Message}}<span class="tagmsg">{{.Message}}</span>{{end}}{{else}}<span class="muted">{{t "tag.lightweight"}}</span>{{end}}</td>
418 <td class="acts">
419 {{if .HasRelease}}<a href="/{{$.Repo.FullPath}}/-/releases#{{.Name}}">{{t "tag.release"}}</a>{{end}}
420 <a href="{{.ZipURL}}">{{t "tag.zip"}}</a>
421 <a href="{{.TarURL}}">{{t "tag.tgz"}}</a>
422 {{if .CanDelete}}<button type="button" class="ghost" data-tag-open data-tag="{{.Name}}">{{t "tag.delete"}}</button>{{end}}
423 </td>
424 </tr>
425 {{end}}
426 </tbody>
427 </table>
428 {{else if .Query}}<p class="muted">{{t "tag.noMatch"}}</p>{{else}}<p class="muted">{{t "repo.noTags"}}</p>{{end}}
429 {{if .CanWrite}}
430 <dialog class="danger-modal" data-tag-dialog>
431 <form method="post" action="/{{.Repo.FullPath}}/-/tags/delete">
432 <input type="hidden" name="csrf" value="{{.CSRF}}">
433 <input type="hidden" name="name" value="" data-tag-name>
434 <p data-tag-copy data-pattern="{{t "tag.confirm" "%s"}}"></p>
435 <div class="row">
436 <button type="submit" data-tag-submit>{{t "tag.delete"}}</button>
437 <button type="button" class="ghost" data-tag-cancel>{{t "action.close"}}</button>
438 </div>
439 </form>
440 </dialog>
441 <script src="/assets/tags.js"></script>
442 {{end}}
388 443 {{template "layout-end" .}}
389 444 {{end}}
390 445
@@ -382,9 +382,64 @@
382{{template "layout-start" .}}
382{{template "layout-start" .}}
383<h1>{{t "title.tags"}}</h1>
383<h1>{{t "title.tags"}}</h1>
384{{template "repotabs" .}}
384{{template "repotabs" .}}
385<ul class="clean">
385<form class="bar" method="get" action="/{{.Repo.FullPath}}/-/tags">
386 {{range .TagNames}}<li><code>{{.}}</code></li>{{else}}<li class="muted">{{t "repo.noTags"}}</li>{{end}}
386 <input type="search" name="q" value="{{.Query}}" placeholder="{{t "tag.search"}}" aria-label="{{t "tag.search"}}">
387</ul>
387</form>
388{{if .CanWrite}}
389<form class="panel" method="post" action="/{{.Repo.FullPath}}/-/tags">
390 <input type="hidden" name="csrf" value="{{.CSRF}}">
391 <div class="row">
392 <input name="name" placeholder="{{t "tag.name"}}" required>
393 <input name="target" list="tag-targets" placeholder="{{t "tag.target"}}" value="{{.Rev}}" required>
394 <input name="message" placeholder="{{t "tag.message"}}">
395 <button type="submit">{{t "tag.create"}}</button>
396 </div>
397</form>
398<datalist id="tag-targets">{{range .Branches}}<option value="{{.Name}}"></option>{{end}}</datalist>
399{{end}}
400{{if .Tags}}
401<table class="tags">
402 <thead>
403 <tr>
404 <th>{{t "tag.name"}}</th>
405 <th>{{t "tag.commit"}}</th>
406 <th>{{t "tag.date"}}</th>
407 <th>{{t "tag.message"}}</th>
408 <th></th>
409 </tr>
410 </thead>
411 <tbody>
412 {{range .Tags}}
413 <tr>
414 <td><code>{{.Name}}</code> {{if .Protected}}<span class="pill">{{t "vis.protected"}}</span>{{end}}</td>
415 <td>{{if .SHA}}<a href="/{{$.Repo.FullPath}}/-/commit/{{.SHA}}"><code>{{.Short}}</code> {{.Subject}}</a>{{end}}</td>
416 <td>{{.Date}}</td>
417 <td>{{if .Annotated}}<span class="pill">{{t "tag.annotated"}}</span> {{if .Message}}<span class="tagmsg">{{.Message}}</span>{{end}}{{else}}<span class="muted">{{t "tag.lightweight"}}</span>{{end}}</td>
418 <td class="acts">
419 {{if .HasRelease}}<a href="/{{$.Repo.FullPath}}/-/releases#{{.Name}}">{{t "tag.release"}}</a>{{end}}
420 <a href="{{.ZipURL}}">{{t "tag.zip"}}</a>
421 <a href="{{.TarURL}}">{{t "tag.tgz"}}</a>
422 {{if .CanDelete}}<button type="button" class="ghost" data-tag-open data-tag="{{.Name}}">{{t "tag.delete"}}</button>{{end}}
423 </td>
424 </tr>
425 {{end}}
426 </tbody>
427</table>
428{{else if .Query}}<p class="muted">{{t "tag.noMatch"}}</p>{{else}}<p class="muted">{{t "repo.noTags"}}</p>{{end}}
429{{if .CanWrite}}
430<dialog class="danger-modal" data-tag-dialog>
431 <form method="post" action="/{{.Repo.FullPath}}/-/tags/delete">
432 <input type="hidden" name="csrf" value="{{.CSRF}}">
433 <input type="hidden" name="name" value="" data-tag-name>
434 <p data-tag-copy data-pattern="{{t "tag.confirm" "%s"}}"></p>
435 <div class="row">
436 <button type="submit" data-tag-submit>{{t "tag.delete"}}</button>
437 <button type="button" class="ghost" data-tag-cancel>{{t "action.close"}}</button>
438 </div>
439 </form>
440</dialog>
441<script src="/assets/tags.js"></script>
442{{end}}
388{{template "layout-end" .}}
443{{template "layout-end" .}}
389{{end}}
444{{end}}
390
445
internal/sshd/server.go +2 −1
@@ -192,7 +192,8 @@ func (s *Server) execGit(channel ssh.Channel, user store.User, command string) i
192 192 cmd.Stderr = channel.Stderr()
193 193 if write {
194 194 patterns, _ := s.Store.ProtectedPatterns(context.Background(), repo.ID)
195 cmd.Env = append(os.Environ(), gitrepo.PushEnv(role, patterns)...)
195 tagPatterns, _ := s.Store.ProtectedTagPatterns(context.Background(), repo.ID)
196 cmd.Env = append(os.Environ(), gitrepo.PushEnv(role, patterns, tagPatterns)...)
196 197 }
197 198 runErr := cmd.Run()
198 199 if write && runErr == nil && s.OnPush != nil {
@@ -192,7 +192,8 @@ func (s *Server) execGit(channel ssh.Channel, user store.User, command string) i
192 cmd.Stderr = channel.Stderr()
192 cmd.Stderr = channel.Stderr()
193 if write {
193 if write {
194 patterns, _ := s.Store.ProtectedPatterns(context.Background(), repo.ID)
194 patterns, _ := s.Store.ProtectedPatterns(context.Background(), repo.ID)
195 cmd.Env = append(os.Environ(), gitrepo.PushEnv(role, patterns)...)
195 tagPatterns, _ := s.Store.ProtectedTagPatterns(context.Background(), repo.ID)
196 cmd.Env = append(os.Environ(), gitrepo.PushEnv(role, patterns, tagPatterns)...)
196 }
197 }
197 runErr := cmd.Run()
198 runErr := cmd.Run()
198 if write && runErr == nil && s.OnPush != nil {
199 if write && runErr == nil && s.OnPush != nil {
internal/store/repos.go +37 −0
@@ -544,6 +544,43 @@ func (s *Store) RemoveProtected(ctx context.Context, repoID int64, pattern strin
544 544 return err
545 545 }
546 546
547 // ProtectedTagPatterns geeft de beschermde tagpatronen.
548 func (s *Store) ProtectedTagPatterns(ctx context.Context, repoID int64) ([]string, error) {
549 rows, err := s.db.QueryContext(ctx, `SELECT pattern FROM protected_tags WHERE repo_id = ? ORDER BY pattern`, repoID)
550 if err != nil {
551 return nil, err
552 }
553 defer rows.Close()
554 var out []string
555 for rows.Next() {
556 var p string
557 if err := rows.Scan(&p); err != nil {
558 return nil, err
559 }
560 out = append(out, p)
561 }
562 return out, rows.Err()
563 }
564
565 // AddProtectedTag voegt een tagpatroon toe.
566 func (s *Store) AddProtectedTag(ctx context.Context, repoID int64, pattern string) error {
567 pattern = strings.TrimSpace(pattern)
568 if pattern == "" || strings.Contains(pattern, " ") || strings.Contains(pattern, "..") {
569 return i18n.E("err.pattern", pattern)
570 }
571 _, err := s.db.ExecContext(ctx, `INSERT INTO protected_tags (repo_id, pattern) VALUES (?, ?)`, repoID, pattern)
572 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
573 return nil
574 }
575 return err
576 }
577
578 // RemoveProtectedTag haalt een tagpatroon weg.
579 func (s *Store) RemoveProtectedTag(ctx context.Context, repoID int64, pattern string) error {
580 _, err := s.db.ExecContext(ctx, `DELETE FROM protected_tags WHERE repo_id = ? AND pattern = ?`, repoID, pattern)
581 return err
582 }
583
547 584 // SecretMeta is een geheim zonder de waarde.
548 585 type SecretMeta struct {
549 586 Name string
@@ -544,6 +544,43 @@ func (s *Store) RemoveProtected(ctx context.Context, repoID int64, pattern strin
544 return err
544 return err
545}
545}
546
546
547// ProtectedTagPatterns geeft de beschermde tagpatronen.
548func (s *Store) ProtectedTagPatterns(ctx context.Context, repoID int64) ([]string, error) {
549 rows, err := s.db.QueryContext(ctx, `SELECT pattern FROM protected_tags WHERE repo_id = ? ORDER BY pattern`, repoID)
550 if err != nil {
551 return nil, err
552 }
553 defer rows.Close()
554 var out []string
555 for rows.Next() {
556 var p string
557 if err := rows.Scan(&p); err != nil {
558 return nil, err
559 }
560 out = append(out, p)
561 }
562 return out, rows.Err()
563}
564
565// AddProtectedTag voegt een tagpatroon toe.
566func (s *Store) AddProtectedTag(ctx context.Context, repoID int64, pattern string) error {
567 pattern = strings.TrimSpace(pattern)
568 if pattern == "" || strings.Contains(pattern, " ") || strings.Contains(pattern, "..") {
569 return i18n.E("err.pattern", pattern)
570 }
571 _, err := s.db.ExecContext(ctx, `INSERT INTO protected_tags (repo_id, pattern) VALUES (?, ?)`, repoID, pattern)
572 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
573 return nil
574 }
575 return err
576}
577
578// RemoveProtectedTag haalt een tagpatroon weg.
579func (s *Store) RemoveProtectedTag(ctx context.Context, repoID int64, pattern string) error {
580 _, err := s.db.ExecContext(ctx, `DELETE FROM protected_tags WHERE repo_id = ? AND pattern = ?`, repoID, pattern)
581 return err
582}
583
547// SecretMeta is een geheim zonder de waarde.
584// SecretMeta is een geheim zonder de waarde.
548type SecretMeta struct {
585type SecretMeta struct {
549 Name string
586 Name string
internal/store/store.go +6 −0
@@ -189,6 +189,12 @@ CREATE TABLE IF NOT EXISTS protected_branches (
189 189 pattern TEXT NOT NULL,
190 190 UNIQUE(repo_id, pattern)
191 191 );
192 CREATE TABLE IF NOT EXISTS protected_tags (
193 id INTEGER PRIMARY KEY,
194 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
195 pattern TEXT NOT NULL,
196 UNIQUE(repo_id, pattern)
197 );
192 198 CREATE TABLE IF NOT EXISTS secrets (
193 199 id INTEGER PRIMARY KEY,
194 200 scope_kind TEXT NOT NULL,
@@ -189,6 +189,12 @@ CREATE TABLE IF NOT EXISTS protected_branches (
189 pattern TEXT NOT NULL,
189 pattern TEXT NOT NULL,
190 UNIQUE(repo_id, pattern)
190 UNIQUE(repo_id, pattern)
191);
191);
192CREATE TABLE IF NOT EXISTS protected_tags (
193 id INTEGER PRIMARY KEY,
194 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
195 pattern TEXT NOT NULL,
196 UNIQUE(repo_id, pattern)
197);
192CREATE TABLE IF NOT EXISTS secrets (
198CREATE TABLE IF NOT EXISTS secrets (
193 id INTEGER PRIMARY KEY,
199 id INTEGER PRIMARY KEY,
194 scope_kind TEXT NOT NULL,
200 scope_kind TEXT NOT NULL,