package gitrepo import ( "context" "fmt" "strconv" "strings" ) // Change is één bestand in een diff, zonder de difftekst zelf. // Status is added, modified, removed of renamed. type Change struct { Path string OldPath string Status string Added int Deleted int Binary bool } // CommitFileChanges geeft de bestanden die sha tegen zijn eerste parent wijzigt. // Een root-commit wordt met de lege boom vergeleken. func CommitFileChanges(ctx context.Context, gitBin, dir, sha string) ([]Change, error) { base, err := diffBase(ctx, gitBin, dir, sha) if err != nil { return nil, err } return diffChanges(ctx, gitBin, dir, base, sha) } // CompareChanges is de three-dot diff van from...to, zonder de difftekst. func CompareChanges(ctx context.Context, gitBin, dir, from, to string) ([]Change, error) { if from == "" || to == "" { return nil, fmt.Errorf("lege vergelijking") } return diffChanges(ctx, gitBin, dir, from+"..."+to) } // CommitDiff is de unified diff van sha tegen zijn eerste parent. func CommitDiff(ctx context.Context, gitBin, dir, sha string) (string, error) { base, err := diffBase(ctx, gitBin, dir, sha) if err != nil { return "", err } return unifiedDiff(ctx, gitBin, dir, base, sha) } // CompareDiff is de unified three-dot diff van from...to. func CompareDiff(ctx context.Context, gitBin, dir, from, to string) (string, error) { if from == "" || to == "" { return "", fmt.Errorf("lege vergelijking") } return unifiedDiff(ctx, gitBin, dir, from+"..."+to) } func diffBase(ctx context.Context, gitBin, dir, sha string) (string, error) { out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--parents", "-n", "1", sha) if err != nil { return "", err } fields := strings.Fields(out) if len(fields) == 0 { return "", fmt.Errorf("commit niet gevonden") } if len(fields) > 1 { return fields[1], nil } empty, err := run(ctx, gitBin, nil, "hash-object", "-t", "tree", "--stdin") if err != nil { return "", err } return strings.TrimSpace(empty), nil } func diffChanges(ctx context.Context, gitBin, dir string, revs ...string) ([]Change, error) { nameRaw, err := gitDiff(ctx, gitBin, dir, append([]string{"--name-status", "--find-renames", "-z"}, revs...)...) if err != nil { return nil, err } numRaw, err := gitDiff(ctx, gitBin, dir, append([]string{"--numstat", "--find-renames", "-z"}, revs...)...) if err != nil { return nil, err } files := parseNameStatus(nameRaw) counts, binary := parseNumstat(numRaw) for i := range files { key := files[i].Path if n, ok := counts[key]; ok { files[i].Added, files[i].Deleted = n[0], n[1] } if binary[key] { files[i].Binary = true files[i].Added, files[i].Deleted = 0, 0 } } if files == nil { files = []Change{} } return files, nil } func unifiedDiff(ctx context.Context, gitBin, dir string, revs ...string) (string, error) { return gitDiff(ctx, gitBin, dir, append([]string{"--no-color", "--find-renames", "--unified=3"}, revs...)...) } func gitDiff(ctx context.Context, gitBin, dir string, flags ...string) (string, error) { args := []string{"-c", "core.quotepath=false", "-C", dir, "diff"} args = append(args, flags...) return runAllow(ctx, gitBin, nil, 1, args...) } func parseNameStatus(raw string) []Change { parts := strings.Split(raw, "\x00") var out []Change for i := 0; i < len(parts); { status := parts[i] if status == "" { i++ continue } i++ if i >= len(parts) { break } if strings.HasPrefix(status, "R") || strings.HasPrefix(status, "C") { old := parts[i] i++ if i >= len(parts) { break } path := parts[i] i++ st := "renamed" if strings.HasPrefix(status, "C") { st = "modified" } out = append(out, Change{Path: path, OldPath: old, Status: st}) continue } out = append(out, Change{Path: parts[i], Status: changeStatus(status)}) i++ } return out } func changeStatus(status string) string { switch status { case "A": return "added" case "D": return "removed" default: return "modified" } } func parseNumstat(raw string) (map[string][2]int, map[string]bool) { counts := map[string][2]int{} binary := map[string]bool{} for _, rec := range strings.Split(raw, "\x00") { rec = strings.TrimRight(rec, "\n") if rec == "" { continue } added, deleted, path, ok := splitNumstat(rec) if !ok || path == "" { continue } path = numstatPath(path) if added == "-" || deleted == "-" { binary[path] = true continue } a, aErr := strconv.Atoi(added) d, dErr := strconv.Atoi(deleted) if aErr != nil || dErr != nil { continue } counts[path] = [2]int{a, d} } return counts, binary } func splitNumstat(rec string) (added, deleted, path string, ok bool) { tab := strings.IndexByte(rec, '\t') if tab < 0 { return "", "", "", false } tab2 := strings.IndexByte(rec[tab+1:], '\t') if tab2 < 0 { return "", "", "", false } tab2 += tab + 1 return rec[:tab], rec[tab+1 : tab2], rec[tab2+1:], true } func numstatPath(path string) string { brace := strings.Index(path, "{") arrow := strings.Index(path, " => ") end := strings.Index(path, "}") if brace >= 0 && arrow > brace && end > arrow { return path[:brace] + path[arrow+4:end] + path[end+1:] } if arrow >= 0 { return path[arrow+4:] } return path }