package gitrepo import ( "context" "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. func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error { if err := os.RemoveAll(work); err != nil { return err } if err := os.MkdirAll(filepath.Dir(work), 0o755); err != nil { return err } if _, err := run(ctx, gitBin, nil, "clone", bare, work); err != nil { return err } if _, err := run(ctx, gitBin, nil, "-C", work, "checkout", branch); err != nil { return err } var paths []string for path, body := range files { if !safeWorkPath(path) { return i18n.E("err.sugFile") } dst := filepath.Join(work, filepath.FromSlash(path)) if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil { return err } if err := os.WriteFile(dst, []byte(body), 0o644); err != nil { return err } paths = append(paths, path) } sort.Strings(paths) args := append([]string{"-C", work, "add", "--"}, paths...) if _, err := run(ctx, gitBin, nil, args...); err != nil { return err } env := identityEnv(author, email) commit := []string{"-C", work, "-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 err } pushEnv := append(env, PushEnv(role, patterns)...) if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", "HEAD:"+branch); err != nil { return err } return nil } func identityEnv(author, email string) []string { env := make([]string, 0, len(os.Environ())+4) for _, e := range os.Environ() { if strings.HasPrefix(e, "GIT_AUTHOR_") || strings.HasPrefix(e, "GIT_COMMITTER_") { continue } env = append(env, e) } return append(env, "GIT_AUTHOR_NAME="+author, "GIT_AUTHOR_EMAIL="+email, "GIT_COMMITTER_NAME="+author, "GIT_COMMITTER_EMAIL="+email, ) } func safeWorkPath(p string) bool { if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, `\`) || strings.Contains(p, "..") { return false } return true }