mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
With git_root: root, commit and push aborted on every tracked skill repo because NestedRepos flagged any directory with its own .git. Tracked repos are listed in the managed .gitignore block, so git add -A never stages them, and the suggested remedy (renaming .git to .git.disabled) breaks skillshare update for those repos. NestedRepos now asks git check-ignore about each nested repo and leaves out the ones git ignores and does not track. A repo already committed as a gitlink is still reported, since staging would update it. Paths are checked one at a time because git refuses a whole batch when one path lies inside a gitlink, and any git error keeps the warning. Closes #820
660 lines
23 KiB
Go
660 lines
23 KiB
Go
package git
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// WriteScopeGitignore ensures a .gitignore at dir. If none exists it writes a
|
|
// default; at "root" scope the default also excludes config.yaml. If a
|
|
// .gitignore already exists it is preserved, but at "root" scope config.yaml is
|
|
// appended when missing (idempotent) — this is the safety guarantee that a
|
|
// root-scope repo never tracks machine-specific config.yaml.
|
|
func WriteScopeGitignore(dir, scope string) error {
|
|
gitignore := filepath.Join(dir, ".gitignore")
|
|
|
|
if existing, err := os.ReadFile(gitignore); err == nil {
|
|
if scope == "root" && !gitignoreHasEntry(string(existing), "config.yaml") {
|
|
content := string(existing)
|
|
if content != "" && !strings.HasSuffix(content, "\n") {
|
|
content += "\n"
|
|
}
|
|
content += "config.yaml\n"
|
|
return os.WriteFile(gitignore, []byte(content), 0o644)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
lines := []string{".DS_Store"}
|
|
if scope == "root" {
|
|
lines = append([]string{"config.yaml"}, lines...)
|
|
}
|
|
return os.WriteFile(gitignore, []byte(strings.Join(lines, "\n")+"\n"), 0o644)
|
|
}
|
|
|
|
// gitignoreHasEntry reports whether content has a line exactly matching entry
|
|
// (ignoring surrounding whitespace), so we don't add a duplicate.
|
|
func gitignoreHasEntry(content, entry string) bool {
|
|
for _, line := range strings.Split(content, "\n") {
|
|
if strings.TrimSpace(line) == entry {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// EnsureLocalIdentity sets a repo-local fallback user.name/email when no git
|
|
// identity is configured (global or local), so commits succeed in fresh
|
|
// environments. Returns true if the fallback was applied.
|
|
func EnsureLocalIdentity(dir string) (bool, error) {
|
|
cmd := exec.Command("git", "config", "user.name")
|
|
cmd.Dir = dir
|
|
if out, err := cmd.Output(); err == nil && strings.TrimSpace(string(out)) != "" {
|
|
return false, nil // already configured
|
|
}
|
|
|
|
nameCmd := exec.Command("git", "config", "user.name", "skillshare")
|
|
nameCmd.Dir = dir
|
|
if err := nameCmd.Run(); err != nil {
|
|
return false, err
|
|
}
|
|
emailCmd := exec.Command("git", "config", "user.email", "skillshare@local")
|
|
emailCmd.Dir = dir
|
|
if err := emailCmd.Run(); err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// FallbackIdentityEnv returns GIT_AUTHOR_* and GIT_COMMITTER_* variables
|
|
// with the same fallback EnsureLocalIdentity writes, for a single commit in
|
|
// a repo the user owns, when git has no name or email for dir. Unlike
|
|
// EnsureLocalIdentity it leaves the repo config alone, so an identity the
|
|
// user sets later still applies. Variables already in the environment win.
|
|
func FallbackIdentityEnv(dir string) []string {
|
|
if gitConfigValue(dir, "user.name") != "" && gitConfigValue(dir, "user.email") != "" {
|
|
return nil
|
|
}
|
|
fallback := []struct{ key, value string }{
|
|
{"GIT_AUTHOR_NAME", "skillshare"}, {"GIT_AUTHOR_EMAIL", "skillshare@local"},
|
|
{"GIT_COMMITTER_NAME", "skillshare"}, {"GIT_COMMITTER_EMAIL", "skillshare@local"},
|
|
}
|
|
var env []string
|
|
for _, f := range fallback {
|
|
if os.Getenv(f.key) == "" {
|
|
env = append(env, f.key+"="+f.value)
|
|
}
|
|
}
|
|
return env
|
|
}
|
|
|
|
func gitConfigValue(dir, key string) string {
|
|
cmd := exec.Command("git", "config", key)
|
|
cmd.Dir = dir
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(string(out))
|
|
}
|
|
|
|
// InitScopeRepo initializes a git repository at dir if one is not already
|
|
// present: it creates dir, runs `git init`, writes a scope-aware .gitignore,
|
|
// and ensures a local identity. If dir is already a repo it only ensures the
|
|
// scope-aware .gitignore (so an existing root repo gains config.yaml exclusion).
|
|
// identitySet reports whether a fallback git identity was applied.
|
|
func InitScopeRepo(dir, scope string) (identitySet bool, err error) {
|
|
if IsRepo(dir) {
|
|
return false, WriteScopeGitignore(dir, scope)
|
|
}
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
return false, err
|
|
}
|
|
cmd := exec.Command("git", "init")
|
|
cmd.Dir = dir
|
|
if err := cmd.Run(); err != nil {
|
|
return false, err
|
|
}
|
|
if err := WriteScopeGitignore(dir, scope); err != nil {
|
|
return false, err
|
|
}
|
|
return EnsureLocalIdentity(dir)
|
|
}
|
|
|
|
// ensureGitignoreEntry appends entry as a line to dir/.gitignore when absent,
|
|
// creating the file if needed. It is the single-entry counterpart to
|
|
// WriteScopeGitignore and is idempotent.
|
|
func ensureGitignoreEntry(dir, entry string) error {
|
|
gitignore := filepath.Join(dir, ".gitignore")
|
|
existing, err := os.ReadFile(gitignore)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return os.WriteFile(gitignore, []byte(entry+"\n"), 0o644)
|
|
}
|
|
return err
|
|
}
|
|
if gitignoreHasEntry(string(existing), entry) {
|
|
return nil
|
|
}
|
|
content := string(existing)
|
|
if content != "" && !strings.HasSuffix(content, "\n") {
|
|
content += "\n"
|
|
}
|
|
content += entry + "\n"
|
|
return os.WriteFile(gitignore, []byte(content), 0o644)
|
|
}
|
|
|
|
// ConfigGitignoreNeedsRepair reports whether EnsureConfigUntracked would change
|
|
// dir/.gitignore: the explicit config.yaml entry is missing, or the rules do
|
|
// not actually ignore it. A dry run uses it to preview that change.
|
|
func ConfigGitignoreNeedsRepair(dir string) bool {
|
|
data, err := os.ReadFile(filepath.Join(dir, ".gitignore"))
|
|
return err != nil || !gitignoreHasEntry(string(data), "config.yaml") || !isIgnored(dir, "config.yaml")
|
|
}
|
|
|
|
// isIgnored reports whether .gitignore rules ignore path, even if it is tracked.
|
|
func isIgnored(dir, path string) bool {
|
|
cmd := exec.Command("git", "check-ignore", "-q", "--no-index", "--", path)
|
|
cmd.Dir = dir
|
|
return cmd.Run() == nil
|
|
}
|
|
|
|
// appendGitignoreLine appends entry to dir/.gitignore even when an earlier line
|
|
// matches it, so it overrides any negation before it.
|
|
func appendGitignoreLine(dir, entry string) error {
|
|
gitignore := filepath.Join(dir, ".gitignore")
|
|
existing, err := os.ReadFile(gitignore)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
content := string(existing)
|
|
if content != "" && !strings.HasSuffix(content, "\n") {
|
|
content += "\n"
|
|
}
|
|
return os.WriteFile(gitignore, []byte(content+entry+"\n"), 0o644)
|
|
}
|
|
|
|
// IsConfigTracked reports whether config.yaml is tracked in the repo at dir.
|
|
// Used by the web UI to warn that a root-scope repo is versioning the
|
|
// machine-specific config.yaml.
|
|
func IsConfigTracked(dir string) bool {
|
|
return isTracked(dir, "config.yaml")
|
|
}
|
|
|
|
// isTracked reports whether path (relative to dir) is tracked in the repo at dir.
|
|
func isTracked(dir, path string) bool {
|
|
cmd := exec.Command("git", "ls-files", "--", path)
|
|
cmd.Dir = dir
|
|
out, err := cmd.Output()
|
|
return err == nil && strings.TrimSpace(string(out)) != ""
|
|
}
|
|
|
|
// RemoteTracksConfig reports whether the remote ref (e.g. "origin/main")
|
|
// tracks config.yaml at its root.
|
|
func RemoteTracksConfig(dir, remoteRef string) bool {
|
|
cmd := exec.Command("git", "ls-tree", remoteRef, "--", "config.yaml")
|
|
cmd.Dir = dir
|
|
out, err := cmd.Output()
|
|
return err == nil && strings.TrimSpace(string(out)) != ""
|
|
}
|
|
|
|
// HasLocalRootConfig reports whether dir contains a local config.yaml or
|
|
// ignores it via .gitignore (the signature of root scope).
|
|
func HasLocalRootConfig(dir string) bool {
|
|
if _, err := os.Stat(filepath.Join(dir, "config.yaml")); err == nil {
|
|
return true
|
|
}
|
|
data, err := os.ReadFile(filepath.Join(dir, ".gitignore"))
|
|
return err == nil && gitignoreHasEntry(string(data), "config.yaml")
|
|
}
|
|
|
|
// UnpushedConfigHistoryError names commits that would publish config.yaml.
|
|
type UnpushedConfigHistoryError struct {
|
|
Commits []string
|
|
HasUpstream bool
|
|
// Base is the rebase start that keeps published commits intact: the
|
|
// parent of the oldest offending commit, or empty for a root commit.
|
|
Base string
|
|
}
|
|
|
|
func (e *UnpushedConfigHistoryError) Error() string {
|
|
base := "--root"
|
|
if e.Base != "" {
|
|
base = e.Base
|
|
}
|
|
return fmt.Sprintf("refusing to push: unpushed commits add or modify config.yaml: %s. Remove config.yaml from these commits using git rebase -i %s (mark them for edit, run git rm -r --cached -- config.yaml and git commit --amend, then git rebase --continue), or amend the latest commit if it is the only affected commit. A later stop-tracking commit does not remove the file from history; skillshare never rewrites history automatically", strings.Join(e.Commits, ", "), base)
|
|
}
|
|
|
|
// CheckUnpushedConfigHistory refuses histories that would publish local config
|
|
// contents, even if a later commit removed the file. Unpushed means reachable
|
|
// from HEAD but from no ref the remote PushArgs targets has right now, so
|
|
// history that remote already has never counts, with or without an upstream.
|
|
// When the destination branch has moved to a commit this clone lacks, the push
|
|
// is rejected as non-fast-forward, so there is nothing to refuse yet and
|
|
// `push --pull` can integrate first. Deletions alone are safe; combined merge
|
|
// diffs check new resolutions without treating config inherited from upstream
|
|
// as a new local change. The check never changes the index, worktree, or refs.
|
|
func CheckUnpushedConfigHistory(dir string) error {
|
|
head := exec.Command("git", "rev-parse", "--verify", "--quiet", "HEAD")
|
|
head.Dir = dir
|
|
if err := head.Run(); err != nil {
|
|
var exit *exec.ExitError
|
|
if errors.As(err, &exit) && exit.ExitCode() == 1 {
|
|
return nil // no commits yet
|
|
}
|
|
return fmt.Errorf("check config.yaml history: %w", err)
|
|
}
|
|
remote, branch := pushTarget(dir)
|
|
// Replacement refs change what log reads but not what push uploads.
|
|
args := []string{"--no-replace-objects", "log", "--format=%x00%h", "--full-history", "--root",
|
|
"-c", "--diff-filter=AMT", "--no-renames", "--no-show-signature", "--raw"}
|
|
cmd := exec.Command("git")
|
|
live, rejected, ok := liveRemoteCommits(dir, remote, branch)
|
|
if rejected {
|
|
return nil
|
|
}
|
|
if ok {
|
|
args = append(args, "--stdin")
|
|
// "^<id>" lines, not "--not": git before 2.42 rejects options on stdin.
|
|
var revs strings.Builder
|
|
revs.WriteString("HEAD\n")
|
|
for _, id := range live {
|
|
revs.WriteString("^" + id + "\n")
|
|
}
|
|
cmd.Stdin = strings.NewReader(revs.String())
|
|
} else {
|
|
args = append(args, "HEAD", "--not", "--remotes="+remote)
|
|
}
|
|
cmd.Args = append(cmd.Args, append(args, "--", ":(top,literal)config.yaml")...)
|
|
cmd.Dir = dir
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return fmt.Errorf("check config.yaml history: %w", err)
|
|
}
|
|
var commits []string
|
|
for _, record := range strings.Split(string(out), "\x00") {
|
|
commit, diff, ok := strings.Cut(strings.TrimSpace(record), "\n")
|
|
// Path history can list a merge even when its combined diff is empty:
|
|
// config inherited unchanged from one parent is not a local addition.
|
|
// Raw diff records start with ':' and never include file contents.
|
|
if ok && strings.HasPrefix(strings.TrimSpace(diff), ":") {
|
|
commits = append(commits, commit)
|
|
}
|
|
}
|
|
if len(commits) > 0 {
|
|
histErr := &UnpushedConfigHistoryError{Commits: commits, HasUpstream: HasUpstream(dir)}
|
|
parent := exec.Command("git", "--no-replace-objects", "rev-parse", "--verify", "--quiet", "--short", commits[len(commits)-1]+"^")
|
|
parent.Dir = dir
|
|
if out, err := parent.Output(); err == nil {
|
|
histErr.Base = strings.TrimSpace(string(out))
|
|
}
|
|
return histErr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// liveRemoteCommits returns the objects that the refs of every push URL of
|
|
// remote point to now (git push sends to all of them, so an object counts only
|
|
// if each has it), limited to those this clone has. A push URL whose
|
|
// destination branch tip this clone lacks will reject the push as
|
|
// non-fast-forward and receive nothing, so it is left out; rejected reports
|
|
// that every push URL is like that. branch is the destination, or empty before
|
|
// the first push, where it is the remote's default branch or else the local
|
|
// one, as in PushArgs. Local
|
|
// remote-tracking refs can be stale after the remote was rewritten to drop a
|
|
// leaked config.yaml, so they are only the fallback (ok=false) when the remote
|
|
// cannot be reached, in which case the push itself fails too.
|
|
func liveRemoteCommits(dir, remote, branch string) (objects []string, rejected, ok bool) {
|
|
getURLs := exec.Command("git", "remote", "get-url", "--push", "--all", remote)
|
|
getURLs.Dir = dir
|
|
out, err := getURLs.Output()
|
|
if err != nil {
|
|
return nil, false, false
|
|
}
|
|
local, _ := GetCurrentBranch(dir)
|
|
var ids []string
|
|
usable := 0
|
|
for _, url := range strings.Split(strings.TrimSpace(string(out)), "\n") {
|
|
lsRemote := exec.Command("git", "ls-remote", "--symref", url)
|
|
lsRemote.Dir = dir
|
|
lsRemote.Env = append(os.Environ(), AuthEnvForRepo(dir)...)
|
|
refs, err := lsRemote.Output()
|
|
if err != nil {
|
|
return nil, false, false
|
|
}
|
|
have := map[string]bool{}
|
|
tips := map[string]string{}
|
|
defaultBranch := ""
|
|
for _, line := range strings.Split(string(refs), "\n") {
|
|
id, ref, found := strings.Cut(line, "\t")
|
|
if !found {
|
|
continue
|
|
}
|
|
if target, isSymref := strings.CutPrefix(id, "ref: "); isSymref {
|
|
if ref == "HEAD" {
|
|
defaultBranch = strings.TrimPrefix(target, "refs/heads/")
|
|
}
|
|
continue
|
|
}
|
|
have[id] = true
|
|
tips[ref] = id
|
|
}
|
|
dest := branch
|
|
if dest == "" {
|
|
dest = defaultBranch
|
|
}
|
|
if dest == "" {
|
|
dest = local
|
|
}
|
|
if tip := tips["refs/heads/"+dest]; tip != "" {
|
|
known := exec.Command("git", "cat-file", "-e", tip+"^{commit}")
|
|
known.Dir = dir
|
|
if known.Run() != nil {
|
|
continue // non-fast-forward: this URL rejects the push
|
|
}
|
|
}
|
|
usable++
|
|
if usable == 1 {
|
|
for id := range have {
|
|
ids = append(ids, id)
|
|
}
|
|
continue
|
|
}
|
|
kept := ids[:0]
|
|
for _, id := range ids {
|
|
if have[id] {
|
|
kept = append(kept, id)
|
|
}
|
|
}
|
|
ids = kept
|
|
}
|
|
if usable == 0 {
|
|
return nil, true, true
|
|
}
|
|
if len(ids) == 0 {
|
|
return nil, false, true
|
|
}
|
|
check := exec.Command("git", "cat-file", "--batch-check=%(objectname) %(objecttype)")
|
|
check.Dir = dir
|
|
check.Stdin = strings.NewReader(strings.Join(ids, "\n") + "\n")
|
|
out, err = check.Output()
|
|
if err != nil {
|
|
return nil, false, false
|
|
}
|
|
for _, line := range strings.Split(string(out), "\n") {
|
|
if id, typ, found := strings.Cut(line, " "); found && (typ == "commit" || typ == "tag") {
|
|
objects = append(objects, id)
|
|
}
|
|
}
|
|
return objects, false, true
|
|
}
|
|
|
|
// EnsureConfigUntracked keeps skillshare's own config.yaml out of a root-scope
|
|
// repo: it ensures config.yaml is in .gitignore and, if the file is already
|
|
// tracked, removes it from the index with `git rm --cached` (the file stays on
|
|
// disk). Returns removed=true only when an actually-tracked config.yaml was
|
|
// untracked. This is the push-time safety net for repos created outside
|
|
// InitScopeRepo (manual `git_root: root` edits, externally-initialized repos, or
|
|
// a config.yaml committed before switching to root scope), where the init-time
|
|
// .gitignore guarantee does not apply. This changes only the index, not past
|
|
// commits; push callers must also use CheckUnpushedConfigHistory before staging.
|
|
func EnsureConfigUntracked(dir string) (removed bool, err error) {
|
|
if err := ensureGitignoreEntry(dir, "config.yaml"); err != nil {
|
|
return false, err
|
|
}
|
|
// A later "!config.yaml" (e.g. pulled from another machine) overrides the
|
|
// entry, and `git add -A` would track the file again; the last match wins.
|
|
if !isIgnored(dir, "config.yaml") {
|
|
if err := appendGitignoreLine(dir, "config.yaml"); err != nil {
|
|
return false, err
|
|
}
|
|
}
|
|
if !isTracked(dir, "config.yaml") {
|
|
return false, nil
|
|
}
|
|
cmd := exec.Command("git", "rm", "-r", "--cached", "--", "config.yaml")
|
|
cmd.Dir = dir
|
|
if err := cmd.Run(); err != nil {
|
|
return false, fmt.Errorf("untrack config.yaml: %w", err)
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// KeepLocalConfig snapshots a root-scope repo's config.yaml (a file or a
|
|
// symlink) before a pull. Git treats the ignored file as expendable, so a merge
|
|
// or reset that brings in a remote-tracked config.yaml replaces this machine's
|
|
// copy. The returned restore reports whether the upstream tracks config.yaml
|
|
// after the pull, even when the tracked copy matches this machine's, so callers
|
|
// can warn and suggest push to remove it. It puts the snapshot back only when
|
|
// the pull changed config.yaml's index entry or removed the file (an aborted
|
|
// merge that had brought it in deletes it again), so edits made while the
|
|
// pull ran to a file Git left alone are kept.
|
|
func KeepLocalConfig(dir string) (restore func() (remoteTracks bool, err error), err error) {
|
|
path := filepath.Join(dir, "config.yaml")
|
|
entryBefore := configIndexEntry(dir)
|
|
put, err := snapshotConfig(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return func() (bool, error) {
|
|
remoteTracks := RemoteTracksConfig(dir, "@{u}")
|
|
entryAfter := configIndexEntry(dir)
|
|
_, statErr := os.Lstat(path)
|
|
if entryAfter == entryBefore && !errors.Is(statErr, fs.ErrNotExist) {
|
|
return remoteTracks, nil
|
|
}
|
|
if editedAfterCheckout(dir, entryAfter) {
|
|
return remoteTracks, nil
|
|
}
|
|
_, err := put()
|
|
return remoteTracks, err
|
|
}, nil
|
|
}
|
|
|
|
// editedAfterCheckout reports whether config.yaml on disk differs from what
|
|
// the pull checked out (entry is its merged index entry), i.e. someone wrote a
|
|
// newer copy or link after Git did. Conflicts and removals report false so the
|
|
// snapshot is restored.
|
|
func editedAfterCheckout(dir, entry string) bool {
|
|
fields := strings.Fields(entry)
|
|
if len(fields) != 4 || fields[2] != "0" {
|
|
return false
|
|
}
|
|
path := filepath.Join(dir, "config.yaml")
|
|
info, err := os.Lstat(path)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
cmd := exec.Command("git", "hash-object", "--stdin")
|
|
cmd.Dir = dir
|
|
switch {
|
|
case info.Mode()&fs.ModeSymlink != 0 && fields[0] == "120000":
|
|
target, err := os.Readlink(path)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
cmd.Stdin = strings.NewReader(target)
|
|
case info.Mode()&fs.ModeSymlink != 0:
|
|
return true // Git checks out a regular entry as a file, not a link
|
|
case info.Mode().IsRegular() && (fields[0] == "100644" || fields[0] == "100755"):
|
|
cmd = exec.Command("git", "hash-object", "--", "config.yaml")
|
|
cmd.Dir = dir
|
|
default:
|
|
return false
|
|
}
|
|
out, err := cmd.Output()
|
|
return err == nil && strings.TrimSpace(string(out)) != fields[1]
|
|
}
|
|
|
|
// configIndexEntry returns config.yaml's index entries (mode, blob, stage), or
|
|
// "" when it is untracked. A merge, reset or conflict that touches the file
|
|
// changes this value.
|
|
func configIndexEntry(dir string) string {
|
|
cmd := exec.Command("git", "ls-files", "-s", "--", "config.yaml")
|
|
cmd.Dir = dir
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(string(out))
|
|
}
|
|
|
|
// removeCheckedOut clears whatever the pull left at path so the snapshot can be
|
|
// written back. A pull can check out a tracked config.yaml/ directory there;
|
|
// its contents are in Git, so removing it loses nothing.
|
|
func removeCheckedOut(path string) error {
|
|
info, err := os.Lstat(path)
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
return nil
|
|
}
|
|
if err == nil && info.IsDir() {
|
|
err = os.RemoveAll(path)
|
|
} else if err == nil {
|
|
err = os.Remove(path)
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("restore config.yaml: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// snapshotConfig records the config.yaml at path and returns a put that writes
|
|
// it back, reporting whether it had changed. A missing file is a no-op.
|
|
func snapshotConfig(path string) (put func() (replaced bool, err error), err error) {
|
|
info, err := os.Lstat(path)
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
return func() (bool, error) { return false, nil }, nil
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("snapshot config.yaml: %w", err)
|
|
}
|
|
if info.Mode()&fs.ModeSymlink != 0 {
|
|
target, err := os.Readlink(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("snapshot config.yaml: %w", err)
|
|
}
|
|
return func() (bool, error) {
|
|
if cur, err := os.Readlink(path); err == nil && cur == target {
|
|
return false, nil
|
|
}
|
|
if err := removeCheckedOut(path); err != nil {
|
|
return true, err
|
|
}
|
|
return true, os.Symlink(target, path)
|
|
}, nil
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("snapshot config.yaml: %w", err)
|
|
}
|
|
return func() (bool, error) {
|
|
if cur, err := os.Lstat(path); err == nil && cur.Mode().IsRegular() && cur.Mode().Perm() == info.Mode().Perm() {
|
|
if got, err := os.ReadFile(path); err == nil && bytes.Equal(got, data) {
|
|
return false, nil
|
|
}
|
|
}
|
|
if err := removeCheckedOut(path); err != nil {
|
|
return true, err
|
|
}
|
|
if err := os.WriteFile(path, data, info.Mode().Perm()); err != nil {
|
|
return true, err
|
|
}
|
|
return true, os.Chmod(path, info.Mode().Perm()) // WriteFile's mode is masked by umask
|
|
}, nil
|
|
}
|
|
|
|
// NestedRepos returns subdirectories of dir (relative paths, excluding dir
|
|
// itself) that contain their own .git. Git records such directories as gitlinks
|
|
// (submodules) on commit, silently dropping all of their files — so callers warn
|
|
// about them before staging a root-scope repo. The walk prunes at each match and
|
|
// skips .git / .git.disabled internals; results are sorted. Repos that git
|
|
// ignores and does not track (such as tracked skill repos in the managed
|
|
// .gitignore block) are left out, because staging never adds them.
|
|
func NestedRepos(dir string) ([]string, error) {
|
|
root := filepath.Clean(dir)
|
|
found := make([]string, 0)
|
|
err := filepath.WalkDir(root, func(path string, d fs.DirEntry, walkErr error) error {
|
|
if walkErr != nil || !d.IsDir() {
|
|
return nil //nolint:nilerr // skip unreadable entries, keep walking
|
|
}
|
|
if path == root {
|
|
return nil // the scope repo's own .git is not "nested"
|
|
}
|
|
if name := d.Name(); name == ".git" || name == ".git.disabled" {
|
|
return filepath.SkipDir
|
|
}
|
|
if _, statErr := os.Stat(filepath.Join(path, ".git")); statErr == nil {
|
|
rel, _ := filepath.Rel(root, path)
|
|
if !isIgnoredUntracked(root, rel) {
|
|
found = append(found, rel)
|
|
}
|
|
return filepath.SkipDir // don't descend into a nested repo
|
|
}
|
|
return nil
|
|
})
|
|
sort.Strings(found)
|
|
return found, err
|
|
}
|
|
|
|
// isIgnoredUntracked reports whether the repo at dir ignores path and does not
|
|
// track it. Without --no-index, check-ignore treats a tracked path as not
|
|
// ignored, so a nested repo already committed as a gitlink is still reported.
|
|
// Each path is checked on its own: git refuses the whole query when one path
|
|
// lies inside a gitlink. Any error counts as not ignored, keeping the warning.
|
|
func isIgnoredUntracked(dir, path string) bool {
|
|
cmd := exec.Command("git", "check-ignore", "-q", "--", filepath.ToSlash(path))
|
|
cmd.Dir = dir
|
|
return cmd.Run() == nil
|
|
}
|
|
|
|
// DisableNestedRepo neutralizes a nested git repo at dir/sub by renaming its
|
|
// .git to .git.disabled (reversible: rename back to re-enable) and ensuring
|
|
// .git.disabled is gitignored so the disabled internals are never committed.
|
|
// It refuses to clobber an existing .git.disabled.
|
|
func DisableNestedRepo(dir, sub string) error {
|
|
gitDir := filepath.Join(dir, sub, ".git")
|
|
disabled := filepath.Join(dir, sub, ".git.disabled")
|
|
if _, err := os.Stat(gitDir); err != nil {
|
|
return fmt.Errorf("%s has no nested .git", sub)
|
|
}
|
|
if _, err := os.Stat(disabled); err == nil {
|
|
return fmt.Errorf("%s/.git.disabled already exists; resolve it manually", sub)
|
|
}
|
|
if err := os.Rename(gitDir, disabled); err != nil {
|
|
return err
|
|
}
|
|
if err := ensureGitignoreEntry(dir, ".git.disabled"); err != nil {
|
|
return err
|
|
}
|
|
// If the parent repo already committed <sub> as a gitlink (160000), renaming
|
|
// .git is not enough: the stale gitlink stays in the index and `git add -A`
|
|
// won't deconvert it. Drop the index entry so the directory's files are
|
|
// re-tracked as blobs on the next add. Best-effort: a repo that never
|
|
// committed the gitlink has no such entry.
|
|
if IsRepo(dir) && isGitlink(dir, sub) {
|
|
cmd := exec.Command("git", "rm", "--cached", "-q", "--", sub)
|
|
cmd.Dir = dir
|
|
_ = cmd.Run()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// isGitlink reports whether the repo at dir records sub as a gitlink (an
|
|
// embedded submodule pointer, index mode 160000) rather than tracked files.
|
|
func isGitlink(dir, sub string) bool {
|
|
cmd := exec.Command("git", "ls-files", "-s", "--", sub)
|
|
cmd.Dir = dir
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return strings.HasPrefix(strings.TrimSpace(string(out)), "160000")
|
|
}
|