package gitrepo import ( "context" "errors" "os" "path/filepath" "sort" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/i18n" ) // SuggestionEdit vervangt de regels Start t/m End (1-based, inclusief) // als die nog gelijk zijn aan Base. type SuggestionEdit struct { Path, Base, Replacement string Start, End int } // ParseSuggestion haalt de eerste ```suggestion-blok uit een reactie. // De tekst is zonder de afsluitende newline van het blok. func ParseSuggestion(body string) (string, bool) { body = strings.ReplaceAll(body, "\r\n", "\n") const open = "```suggestion" i := strings.Index(body, open) if i < 0 { return "", false } rest := body[i+len(open):] nl := strings.IndexByte(rest, '\n') if nl < 0 { return "", false } rest = rest[nl+1:] end := strings.Index(rest, "```") if end < 0 { return "", false } return strings.TrimSuffix(rest[:end], "\n"), true } // SplitLines splitst een bestand op newlines. Een afsluitende newline telt niet als lege regel. func SplitLines(s string) []string { if s == "" { return nil } s = strings.TrimSuffix(s, "\n") return strings.Split(s, "\n") } // ApplySuggestions past alle edits toe. Bij een conflict of overlap verandert er niets. func ApplySuggestions(files map[string]string, edits []SuggestionEdit) (map[string]string, error) { byPath := map[string][]SuggestionEdit{} for _, e := range edits { byPath[e.Path] = append(byPath[e.Path], e) } out := map[string]string{} changed := false for path, group := range byPath { raw, ok := files[path] if !ok { return nil, i18n.E("err.sugFile") } sort.Slice(group, func(i, j int) bool { return group[i].Start < group[j].Start }) for i := 1; i < len(group); i++ { if group[i].Start <= group[i-1].End { return nil, i18n.E("err.sugOverlap", path) } } lines := SplitLines(raw) nl := strings.HasSuffix(raw, "\n") || raw == "" sort.Slice(group, func(i, j int) bool { return group[i].Start > group[j].Start }) for _, e := range group { if e.Start < 1 || e.End < e.Start || e.End > len(lines) { return nil, i18n.E("err.sugConflict", path, e.Start, e.End) } base := strings.Join(lines[e.Start-1:e.End], "\n") if base != e.Base { return nil, i18n.E("err.sugConflict", path, e.Start, e.End) } var mid []string if e.Replacement != "" { mid = strings.Split(e.Replacement, "\n") } next := append([]string{}, lines[:e.Start-1]...) next = append(next, mid...) next = append(next, lines[e.End:]...) lines = next } next := "" if len(lines) > 0 { next = strings.Join(lines, "\n") if nl { next += "\n" } } if next != raw { changed = true out[path] = next } } if !changed { return nil, i18n.E("err.sugSame") } return out, nil } // CommitOnBranch schrijft files op branch en pusht één commit. // De push loopt door de hook, met role en de beschermde patronen. // Een repository zonder commits krijgt deze branch als eerste commit, zonder parent. // Git draait met een eigen HOME en TMPDIR onder work, niet met die van het proces: // ProtectHome maakt de homedirectory onleesbaar en /tmp is niet de werkmap. func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error { return CommitChanges(ctx, gitBin, bare, work, branch, author, email, title, description, files, nil, role, patterns) } // CommitChanges schrijft files, verwijdert paden en pusht één commit. func CommitChanges(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, deletes []string, role access.Role, patterns []string) error { if len(files) == 0 && len(deletes) == 0 { return i18n.E("err.commitEmpty") } repo, env, err := prepareWork(work, author, email) if err != nil { return classifyGit(err) } if _, err := run(ctx, gitBin, env, "clone", bare, repo); err != nil { return classifyGit(err) } if _, err := run(ctx, gitBin, env, "-C", repo, "rev-parse", "--verify", "--quiet", "HEAD"); err != nil { if _, err := run(ctx, gitBin, env, "-C", repo, "symbolic-ref", "HEAD", "refs/heads/"+branch); err != nil { return classifyGit(err) } } else if _, err := run(ctx, gitBin, env, "-C", repo, "checkout", branch); err != nil { return classifyGit(err) } var paths []string for path, body := range files { if !safeWorkPath(path) { return i18n.E("err.sugFile") } dst := filepath.Join(repo, filepath.FromSlash(path)) if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil { return classifyGit(err) } if err := os.WriteFile(dst, []byte(body), 0o644); err != nil { return classifyGit(err) } paths = append(paths, path) } sort.Strings(paths) if len(paths) > 0 { args := append([]string{"-C", repo, "add", "--"}, paths...) if _, err := run(ctx, gitBin, env, args...); err != nil { return classifyGit(err) } } for _, path := range deletes { if !safeWorkPath(path) { return i18n.E("err.sugFile") } if _, err := run(ctx, gitBin, env, "-C", repo, "rm", "-f", "--ignore-unmatch", "--", path); err != nil { return classifyGit(err) } } commit := []string{"-C", repo, "-c", "commit.gpgsign=false", "commit", "-m", title} if strings.TrimSpace(description) != "" { commit = append(commit, "-m", description) } if _, err := run(ctx, gitBin, env, commit...); err != nil { return classifyGit(err) } pushEnv := append(append([]string{}, env...), PushEnv(role, patterns, nil)...) if _, err := run(ctx, gitBin, pushEnv, "-C", repo, "push", "origin", "HEAD:"+branch); err != nil { return classifyGit(err) } return nil } // CommandEnv is de omgeving voor elke git-aanroep die een commit maakt. // HOME en TMPDIR wijzen naar mappen die het proces zelf mag schrijven. // Naam en e-mail staan expliciet, zodat een lege of afgeschermde identiteit niet meetelt. func CommandEnv(author, email, home, tmp string) []string { env := make([]string, 0, len(os.Environ())+8) for _, e := range os.Environ() { if strings.HasPrefix(e, "GIT_AUTHOR_") || strings.HasPrefix(e, "GIT_COMMITTER_") || strings.HasPrefix(e, "GIT_CONFIG") { continue } if strings.HasPrefix(e, "HOME=") || strings.HasPrefix(e, "TMPDIR=") { continue } env = append(env, e) } return append(env, "HOME="+home, "TMPDIR="+tmp, "GIT_CONFIG_GLOBAL=/dev/null", "GIT_CONFIG_SYSTEM=/dev/null", "GIT_AUTHOR_NAME="+author, "GIT_AUTHOR_EMAIL="+email, "GIT_COMMITTER_NAME="+author, "GIT_COMMITTER_EMAIL="+email, ) } // prepareWork maakt work leeg en zet er een eigen home en tmp in. // De kloon komt in work/repo, zodat die mappen geen deel van de tree zijn. func prepareWork(work, author, email string) (string, []string, error) { if err := os.RemoveAll(work); err != nil { return "", nil, err } if err := os.MkdirAll(work, 0o755); err != nil { return "", nil, err } home := filepath.Join(work, "home") tmp := filepath.Join(work, "tmp") if err := os.MkdirAll(home, 0o700); err != nil { return "", nil, err } if err := os.MkdirAll(tmp, 0o700); err != nil { return "", nil, err } return filepath.Join(work, "repo"), CommandEnv(author, email, home, tmp), nil } // Cause koppelt een vertaalbare melding aan de ruwe git-tekst. // Error() is de git-tekst voor het journal. Unwrap levert de vertaling. func Cause(key, git string, args ...any) error { return gitCause{git: git, err: i18n.E(key, args...)} } type gitCause struct { git string err error } func (g gitCause) Error() string { return g.git } func (g gitCause) Unwrap() error { return g.err } func classifyGit(err error) error { if err == nil { return nil } var ie i18n.Error if errors.As(err, &ie) { return err } low := strings.ToLower(err.Error()) switch { case strings.Contains(low, "nothing to commit") || strings.Contains(low, "nothing added"): return Cause("edit.same", err.Error()) case strings.Contains(low, "protected") || strings.Contains(low, "beschermd") || strings.Contains(low, "geschützt") || strings.Contains(low, "protégée"): return Cause("edit.protected", err.Error()) case strings.Contains(low, "author identity") || strings.Contains(low, "user.email") || strings.Contains(low, "user.name") || strings.Contains(low, "tell me who you are"): return Cause("edit.failIdentity", err.Error()) case strings.Contains(low, "permission denied") || strings.Contains(low, "read-only") || strings.Contains(low, "unable to access") || strings.Contains(low, "operation not permitted"): return Cause("edit.failWrite", err.Error()) default: return Cause("edit.failGit", err.Error()) } } func safeWorkPath(p string) bool { if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, `\`) || strings.Contains(p, "..") { return false } return true }