dimitar
ae23019277
Implement the core data layer that everything else builds on: walking a parent directory for Git repositories and snapshotting each repository's state via porcelain commands. Domain model (pkg/status): - RepoStatus enum with zero value = StatusUnknown (invalid/unset), covering clean / modified / ahead / behind / diverged / detached / bare / error - RepoInfo snapshot: path, name, remote URL, branch, detached flag, staged / modified / untracked file lists, ahead/behind counts, stash count, error - ScanResult with computed Summary counters and NeedsAttention filter Git wrapper (internal/git): - Executor built with functional options (binary, timeout, env), defaults to "git" with a 10s per-command timeout so a hung repository can never stall a scan; context cancellation honoured via exec.CommandContext - Status() validates with rev-parse --is-bare-repository (bare repos are reported as StatusBare and skipped), then parses `git status --porcelain=v2 --branch -z` - Parsing uses the NUL-separated v2 format so paths with spaces, quotes, and tabs survive verbatim (no C-quoting to decode); rename records (type 2) and ahead/behind lines (# branch.ab) are handled, unknown tokens are ignored for forward compatibility - Best-effort remote URL (git config --get-regexp) and stash count Discovery (internal/scanner/discover.go): - WalkDir-based traversal that never descends into .git internals - Detects working trees via .git directory or .git pointer file (linked worktrees, submodule checkouts) and bare repos via a *.git directory carrying its own HEAD/objects/refs - WithExclude glob patterns (matched against full path and base name) and WithMaxDepth depth limiting as functional options - Walk errors (e.g. permission denied) are aggregated and returned alongside partial results via errors.Join; cancellation is propagated Scanner (internal/scanner/scanner.go): - Concurrent status scanning with a bounded worker pool (errgroup + SetLimit, default 8 workers) - Per-repo failures become StatusError entries instead of aborting the pass; a cancelled context aborts the whole scan Testing: - Table-driven parser tests with canned NUL-separated porcelain output - Integration tests against a real git binary (clean / modified / staged / stashed / detached / bare / non-repo) - Discovery tests over a fixture tree with nested repos, a bare repo, a linked worktree, and an exclusion target - Scanner tests for mixed success/failure, bounded concurrency, and cancellation; everything runs under -race Note: LastFetch from the original plan was dropped — the only reliable source is a reflog of the remote-tracking ref, which does not exist on fresh clones, so it would always be misleading. The model remains extensible if a fetch-history feature is wanted later.
81 lines
2.2 KiB
Go
81 lines
2.2 KiB
Go
// Package git is a thin wrapper around the git binary. It runs porcelain
|
|
// commands via os/exec with a per-command timeout so a scan can never hang
|
|
// on a broken or unresponsive repository.
|
|
package git
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// DefaultTimeout bounds every git invocation. A single hung git call would
|
|
// otherwise stall the whole scan.
|
|
const DefaultTimeout = 10 * time.Second
|
|
|
|
// Executor runs git commands against a repository working directory.
|
|
type Executor struct {
|
|
bin string
|
|
timeout time.Duration
|
|
env []string
|
|
}
|
|
|
|
// Option configures an Executor (functional options pattern).
|
|
type Option func(*Executor)
|
|
|
|
// WithBinary overrides the git executable path (default "git").
|
|
func WithBinary(bin string) Option {
|
|
return func(e *Executor) { e.bin = bin }
|
|
}
|
|
|
|
// WithTimeout overrides the per-command timeout (default 10s).
|
|
func WithTimeout(d time.Duration) Option {
|
|
return func(e *Executor) { e.timeout = d }
|
|
}
|
|
|
|
// WithEnv appends extra environment variables to every command.
|
|
func WithEnv(env ...string) Option {
|
|
return func(e *Executor) { e.env = append(e.env, env...) }
|
|
}
|
|
|
|
// NewExecutor builds an Executor with sensible defaults.
|
|
func NewExecutor(opts ...Option) *Executor {
|
|
e := &Executor{bin: "git", timeout: DefaultTimeout}
|
|
for _, opt := range opts {
|
|
opt(e)
|
|
}
|
|
return e
|
|
}
|
|
|
|
// Run executes git <args...> in dir with a context timeout and returns the
|
|
// trimmed stdout. Context cancellation is honoured; the configured timeout
|
|
// guards against a hanging repository.
|
|
func (e *Executor) Run(ctx context.Context, dir string, args ...string) (string, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, e.timeout)
|
|
defer cancel()
|
|
|
|
cmd := exec.CommandContext(ctx, e.bin, args...)
|
|
cmd.Dir = dir
|
|
cmd.Env = append(os.Environ(), e.env...)
|
|
|
|
var stdout, stderr bytes.Buffer
|
|
cmd.Stdout = &stdout
|
|
cmd.Stderr = &stderr
|
|
|
|
if err := cmd.Run(); err != nil {
|
|
if ctx.Err() != nil {
|
|
return "", fmt.Errorf("git %s: timed out after %s", strings.Join(args, " "), e.timeout)
|
|
}
|
|
msg := strings.TrimSpace(stderr.String())
|
|
if msg == "" {
|
|
msg = err.Error()
|
|
}
|
|
return "", fmt.Errorf("git %s: %s", strings.Join(args, " "), msg)
|
|
}
|
|
return strings.TrimSpace(stdout.String()), nil
|
|
}
|