oxy git colocate: a .git beside .oxy, kept up to date after every command; .git is never content and never written by checkout (closes #160) c397a8c36a9f

//! `oxy git colocate` (oxygenhub#355, part two): a `.git` beside `.oxy`,

//! kept up to date after every oxy command, so Git tools read an Oxygen

//! checkout; oxy never takes `.git` as content.

use std::path::Path;

use std::process::Command;

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> (bool, String) {

    let out = Command::new(env!("CARGO_BIN_EXE_oxy"))

        .arg("--plain")

        .args(args)

        .current_dir(dir)

        .env("OXY_HOME", home)

        .env("NO_COLOR", "1")

        .output()

        .unwrap();

    (

        out.status.success(),

        format!(

            "{}{}",

            String::from_utf8_lossy(&out.stdout),

            String::from_utf8_lossy(&out.stderr)

        ),

    )

}

fn git(dir: &Path, args: &[&str]) -> String {

    let out = Command::new("git")

        .args(args)

        .current_dir(dir)

        .env("GIT_CONFIG_NOSYSTEM", "1")

        .env("HOME", dir)

        .output()

        .unwrap();

    assert!(

        out.status.success(),

        "git {args:?}: {}",

        String::from_utf8_lossy(&out.stderr)

    );

    String::from_utf8_lossy(&out.stdout).trim().to_string()

}

#[test]

fn a_colocated_git_follows_the_bookmark() {

    if Command::new("git").arg("--version").output().is_err() {

        eprintln!("git not installed; skipping");

        return;

    }

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let r = tmp.path().join("r");

    assert!(oxy(tmp.path(), &home, &["init", r.to_str().unwrap()]).0);

    assert!(

        oxy(

            &r,

            &home,

            &[

                "identity",

                "create",

                "--name",

                "Ada",

                "--email",

                "[email protected]"

            ]

        )

        .0

    );

    std::fs::write(r.join("a.txt"), "one\n").unwrap();

    assert!(oxy(&r, &home, &["commit", "-m", "first"]).0);

    let (ok, out) = oxy(&r, &home, &["git", "colocate"]);

    assert!(ok, "{out}");

    assert!(r.join(".git/HEAD").exists());

    assert_eq!(git(&r, &["log", "--format=%s"]), "first");

    assert_eq!(git(&r, &["symbolic-ref", "HEAD"]), "refs/heads/main");

    assert_eq!(

        git(&r, &["status", "--porcelain"]),

        "",

        "Git sees no difference, and not .oxy either"

    );

    let (_, status) = oxy(&r, &home, &["status"]);

    assert!(

        !status.contains(".git"),

        "oxy never takes .git as content: {status}"

    );

    // An oxy commit shows in Git without asking.

    std::fs::write(r.join("a.txt"), "one\ntwo\n").unwrap();

    assert_eq!(

        git(&r, &["status", "--porcelain"]),

        "M a.txt",

        "uncommitted work shows as modified"

    );

    assert!(oxy(&r, &home, &["commit", "-m", "second"]).0);

    assert_eq!(git(&r, &["log", "--format=%s"]), "second\nfirst");

    assert_eq!(git(&r, &["status", "--porcelain"]), "");

    assert_eq!(git(&r, &["show", "HEAD:a.txt"]), "one\ntwo");

    // Off: no more updates, the .git stays.

    assert!(oxy(&r, &home, &["git", "colocate", "--off"]).0);

    std::fs::write(r.join("b.txt"), "b\n").unwrap();

    assert!(oxy(&r, &home, &["commit", "-m", "third"]).0);

    assert_eq!(

        git(&r, &["log", "--format=%s"]),

        "second\nfirst",

        "no longer followed"

    );

    assert!(r.join(".git/HEAD").exists());

}

- **Added: `oxy git colocate`, a `.git` beside `.oxy` (oxygenhub#355).** Your editor's Git features (blame, history, gutter marks) and other Git tools now work on an Oxygen checkout: oxy keeps a `.git` there with the current bookmark exported after every command, Git's index at its tree so `git status` shows only your uncommitted work, and `.oxy/` excluded. One way: commit with oxy. `--off` stops it.

- **Changed: `.git` is never content.** oxy no longer picks up a `.git` directory at a checkout's top, and checkout refuses a path with a `.git` component at any depth (as Git does), so a change cannot plant Git hooks.

            // A `.git` path could plant hooks a side-by-side Git would run;

            // Git refuses them at any depth and in any case, and so does oxy.

            if comp.eq_ignore_ascii_case(".git") {

                return fail(format!("refusing to write a .git path: {rel:?}"));

            }

/// `.` or `..` component, a backslash, a first component `.oxy`, or a

/// `.git` component anywhere (it could plant Git hooks).

        }

        if comp.eq_ignore_ascii_case(".git") {

            return fail(format!("refusing to write a .git path: {rel:?}"));

}

#[cfg(test)]

mod path_name_tests {

    use super::check_path_name;

    #[test]

    fn git_paths_are_refused_at_any_depth_and_case() {

        for bad in [

            ".git/hooks/post-checkout",

            "sub/.git/config",

            ".GIT/hooks/x",

            "a/.Git",

            ".oxy/x",

            "../x",

        ] {

            assert!(check_path_name(bad).is_err(), "{bad}");

        }

        for good in [

            "src/main.rs",

            ".gitignore",

            ".github/workflows/ci.yml",

            "a/.gitmodules",

        ] {

            assert!(check_path_name(good).is_ok(), "{good}");

        }

    }

    /// `git.colocate`: keep a `.git` beside `.oxy` with the current

    /// bookmark exported after every operation, so editors' Git features

    /// work on an Oxygen checkout (one way: oxy to Git).

    pub git_colocate: bool,

            git_colocate: false,

            "git.colocate" => self.git_colocate = matches!(value, "true" | "1" | "yes"),

impl Repo {

    /// Bring the side-by-side Git repository up to date (`git.colocate`):

    /// a `.git` beside `.oxy`, made with `git init` when missing and told to

    /// leave `.oxy/` alone, holding the current bookmark as exported by

    /// `git_export_as` (one commit per state the bookmark passed through),

    /// with HEAD on that branch and Git's index at its tree, so `git status`

    /// shows only the working copy's uncommitted work. Files on disk are

    /// never touched. Does nothing when the bookmark has not moved since the

    /// last time; `Ok(true)` when it exported.

    pub fn git_colocate_sync(&self) -> Result<bool> {

        if self.bare {

            return fail("a bare repository has no working copy for a .git beside it");

        }

        let git_dir = self.root.join(".git");

        if git_dir.is_file() {

            return fail(".git is a file (a Git worktree or submodule link); remove it to keep a side-by-side Git repository here");

        }

        if !git_dir.join("HEAD").exists() {

            git(&self.root, &["init", "-q"])?;

        }

        let exclude = git_dir.join("info").join("exclude");

        let have = fs::read_to_string(&exclude).unwrap_or_default();

        if !have.lines().any(|l| l.trim() == "/.oxy/") {

            fs::create_dir_all(exclude.parent().expect("info/"))?;

            let sep = if have.is_empty() || have.ends_with('\n') {

                ""

            } else {

                "\n"

            };

            fs::write(

                &exclude,

                format!("{have}{sep}# Oxygen's own repository (oxy git colocate)\n/.oxy/\n"),

            )?;

        }

        let bookmark = self.config.bookmark.clone();

        let state = self

            .view()?

            .bookmarks

            .get(&bookmark)

            .map(|s| s.to_hex())

            .unwrap_or_default();

        let stamp_file = self.oxy.join("git").join("colocate-stamp");

        let stamp = format!("{bookmark} {state}");

        if fs::read_to_string(&stamp_file).is_ok_and(|s| s.trim() == stamp) {

            return Ok(false);

        }

        if !state.is_empty() {

            self.git_export_as(&git_dir, &bookmark)?;

            git(

                &self.root,

                &["symbolic-ref", "HEAD", &format!("refs/heads/{bookmark}")],

            )?;

            git(&self.root, &["read-tree", "HEAD"])?;

        }

        fs::create_dir_all(stamp_file.parent().expect("git/"))?;

        fs::write(&stamp_file, stamp)?;

        Ok(!state.is_empty())

    }

}

        // `.git` is never content: a side-by-side Git repository

        // (`git.colocate`), or Git's own beside an import.

        if name == OXY_DIR || name.eq_ignore_ascii_case(".git") {

- **A side-by-side `.git`.** `oxy git colocate` (config `git.colocate`) keeps a `.git` beside `.oxy` so editors' and other tools' Git features work on an Oxygen checkout: made with `git init` when missing, `/.oxy/` added to its `info/exclude`, the current bookmark exported into it (as `oxy git export` does) after every oxy command that leaves the bookmark somewhere new, HEAD on that branch and the index at its tree, so `git status` shows exactly the working copy's uncommitted work. It is one way: commits made with Git are not read back. oxy never takes a `.git` directory as content, and checkout refuses to write a path with a `.git` component at any depth or case (as Git does), so a change cannot plant hooks there. `oxy git colocate --off` stops the updates and leaves `.git` in place.

    /// Set a configuration key (author.*, core.sign, core.op-retention, core.gc-grace, core.checkpoint-interval, filter.max-blob, filter.paths, storage.cache, workspace.bookmark, remote.<name>.url|token|ca, git.claim, git.colocate, auth.helper with --user)

    /// Keep a .git beside .oxy, up to date after every oxy command, so editors' Git features work here (one way: oxy to Git)

    Colocate {

        /// Stop updating it (the .git is left as it is)

        #[arg(long)]

        off: bool,

    },

/// After a command, bring the side-by-side `.git` up to date when this

/// checkout keeps one (`git.colocate`). It never fails the command: a

/// problem is a warning, and the next command tries again.

pub fn after_command() {

    if AT_OP.get().and_then(|o| o.as_deref()).is_some() {

        return;

    }

    let Ok(dir) = std::env::current_dir() else {

        return;

    };

    let Ok(repo) = Repo::open(&dir) else { return };

    if !repo.config.git_colocate || repo.is_bare() {

        return;

    }

    if let Err(e) = repo.git_colocate_sync() {

        eprintln!(

            "{} the .git beside this checkout was not updated: {e}",

            ui::warn("!")

        );

    }

}

        Cmd::Git {

            cmd: GitCmd::Colocate { off },

        } => sync::git_colocate(off),

/// `oxy git colocate [--off]`: keep a `.git` beside `.oxy` (spec §23).

pub fn git_colocate(off: bool) -> Result<i32> {

    let mut repo = open()?;

    if repo.is_bare() {

        anyhow::bail!("a bare repository has no working copy for a .git beside it");

    }

    repo.config

        .set("git.colocate", if off { "false" } else { "true" })?;

    repo.save_config()?;

    if off {

        println!(

            "{} the .git beside this checkout is no longer updated {}",

            ui::done("Stopped:"),

            ui::dim("(it is left as it is: delete .git yourself if you want it gone)")

        );

        return Ok(0);

    }

    let sp = ui::spinner("Exporting to .git…");

    repo.git_colocate_sync()?;

    sp.clear();

    println!(

        "{} .git beside .oxy holds {} {}",

        ui::done("Colocated:"),

        ui::bookmark(&repo.config.bookmark),

        ui::dim("(updated after every oxy command; Git's own commits are not read back: commit with oxy)")

    );

    Ok(0)

}

    if result.is_ok() {

        cli::after_command();

    }