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.
75 lines
1.8 KiB
Go
75 lines
1.8 KiB
Go
package scanner
|
|
|
|
import (
|
|
"context"
|
|
"path/filepath"
|
|
|
|
"golang.org/x/sync/errgroup"
|
|
|
|
"gitea.oblak.solutions/dimitar/gitFlow/internal/git"
|
|
"gitea.oblak.solutions/dimitar/gitFlow/pkg/status"
|
|
)
|
|
|
|
// Scanner produces status snapshots for a set of repositories, scanning them
|
|
// concurrently with a bounded worker pool.
|
|
type Scanner struct {
|
|
git *git.Executor
|
|
workers int
|
|
}
|
|
|
|
// ScannerOption configures a Scanner (functional options pattern).
|
|
type ScannerOption func(*Scanner)
|
|
|
|
// WithGitExecutor overrides the git executor used for scanning.
|
|
func WithGitExecutor(e *git.Executor) ScannerOption {
|
|
return func(s *Scanner) { s.git = e }
|
|
}
|
|
|
|
// WithWorkers sets the maximum number of concurrent git scans.
|
|
func WithWorkers(n int) ScannerOption {
|
|
return func(s *Scanner) {
|
|
if n > 0 {
|
|
s.workers = n
|
|
}
|
|
}
|
|
}
|
|
|
|
// NewScanner builds a Scanner with sane defaults.
|
|
func NewScanner(opts ...ScannerOption) *Scanner {
|
|
s := &Scanner{git: git.NewExecutor(), workers: 8}
|
|
for _, opt := range opts {
|
|
opt(s)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// Scan snapshots every repository path. A repository that fails to scan is
|
|
// reported with StatusError rather than aborting the pass. The returned
|
|
// error is non-nil only when the context is cancelled mid-scan.
|
|
func (s *Scanner) Scan(ctx context.Context, paths []string) ([]status.RepoInfo, error) {
|
|
infos := make([]status.RepoInfo, len(paths))
|
|
|
|
g, ctx := errgroup.WithContext(ctx)
|
|
g.SetLimit(s.workers)
|
|
for i, path := range paths {
|
|
i, path := i, path
|
|
g.Go(func() error {
|
|
info, err := s.git.Status(ctx, path)
|
|
if err != nil {
|
|
if ctx.Err() != nil {
|
|
return ctx.Err() // cancelled mid-scan, not a repo failure
|
|
}
|
|
info = status.RepoInfo{
|
|
Path: path,
|
|
Name: filepath.Base(path),
|
|
Status: status.StatusError,
|
|
Error: err.Error(),
|
|
}
|
|
}
|
|
infos[i] = info
|
|
return nil
|
|
})
|
|
}
|
|
return infos, g.Wait()
|
|
}
|