Git bridge, export side: one commit per bookmark state via git fast-import, Change-Id/Oxy-Hash/Oxy-State trailers, incremental marks 79ab8528ff62

//! Git bridge (spec §23), export side: each state the current bookmark

//! passed through becomes a Git commit through `git fast-import`, with the

//! state's full tree and the previous state's commit as parent. A state

//! that added exactly one change carries that change's message, author,

//! and `Change-Id`/`Oxy-Hash` trailers; every commit carries `Oxy-State`.

//!

//! Marks make re-exports incremental: `.oxy/git/<target>/git-marks` is

//! git's own marks file and `oxy-marks` maps state refs to marks.

use super::*;

use std::process::{Command, Stdio};

#[derive(Debug, Clone, Default, PartialEq, Eq)]

pub struct GitExportReport {

    pub exported: usize,

    pub skipped: usize,

    pub branch: String,

    pub heads: usize,

}

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

    let out = Command::new("git").arg("-C").arg(dir).args(args).output().map_err(|e| RepoError::Msg(format!("running git: {e}")))?;

    if !out.status.success() {

        return fail(format!("git {} failed: {}", args.join(" "), String::from_utf8_lossy(&out.stderr).trim()));

    }

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

}

impl Repo {

    fn git_marks_dir(&self, git_dir: &Path) -> Result<PathBuf> {

        let canonical = git_dir.canonicalize().unwrap_or_else(|_| git_dir.to_path_buf());

        let key = hash_object(ObjectType::Chunk, canonical.to_string_lossy().as_bytes()).short(16);

        let dir = self.oxy.join("git").join(key);

        fs::create_dir_all(&dir)?;

        Ok(dir)

    }

    fn read_oxy_marks(path: &Path) -> Result<BTreeMap<ObjectRef, u64>> {

        let mut out = BTreeMap::new();

        if let Ok(text) = fs::read_to_string(path) {

            for line in text.lines() {

                if let Some((h, m)) = line.split_once(' ') {

                    if let (Some(h), Ok(m)) = (ObjectRef::from_hex(h), m.parse()) {

                        out.insert(h, m);

                    }

                }

            }

        }

        Ok(out)

    }

    /// Export the current bookmark to the Git repository at `git_dir`,

    /// creating a bare one if nothing is there. Each state the bookmark

    /// passed through (per the operation log) becomes one commit whose tree

    /// is that state, so the Git branch is a linear history of full trees.

    pub fn git_export(&self, git_dir: &Path) -> Result<GitExportReport> {

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

            fs::create_dir_all(git_dir)?;

            git(git_dir, &["init", "--bare", "-q"])?;

        }

        let marks_dir = self.git_marks_dir(git_dir)?;

        let git_marks = marks_dir.join("git-marks");

        let oxy_marks_path = marks_dir.join("oxy-marks");

        let mut marks = Self::read_oxy_marks(&oxy_marks_path)?;

        let mut next_mark = marks.values().copied().max().unwrap_or(0) + 1;

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

        let mut stream: Vec<u8> = Vec::new();

        let mut report = GitExportReport { branch: bookmark.clone(), heads: self.bookmark_heads()?.len(), ..Default::default() };

        // States along the bookmark, oldest first, skipping unchanged and pruned ones.

        let mut ops = self.op_log()?;

        ops.reverse();

        let mut prev: Option<(ObjectRef, Vec<ChangeHash>)> = None;

        let mut last_mark: Option<u64> = None;

        for (_, op) in &ops {

            let Some(state_ref) = op.view.bookmarks.get(&bookmark).copied() else { continue };

            if prev.as_ref().is_some_and(|(p, _)| *p == state_ref) {

                continue;

            }

            let Ok(state) = self.store.get_state(&state_ref) else { continue };

            if state.heads.is_empty() {

                prev = Some((state_ref, vec![]));

                continue;

            }

            if let Some(m) = marks.get(&state_ref) {

                report.skipped += 1;

                last_mark = Some(*m);

                prev = Some((state_ref, state.heads.clone()));

                continue;

            }

            let prev_heads = prev.as_ref().map(|(_, h)| h.clone()).unwrap_or_default();

            let added = self.negotiate(&prev_heads, &state.heads).unwrap_or_default();

            let loaded = self.load_state(&state.heads)?;

            let snapshot = loaded.materialize();

            let (author, secs, mut message) = match added.as_slice() {

                [h] => {

                    let c = self.store.get_change(h)?;

                    let mut m = c.message.clone();

                    if !m.ends_with('\n') {

                        m.push('\n');

                    }

                    m.push_str(&format!("\nChange-Id: {}\nOxy-Hash: {}\n", c.change_id.to_hex(), h.to_hex()));

                    (self.git_author(&c), c.hlc.wall_ms / 1000, m)

                }

                [] => ("oxy <oxy@localhost>".to_string(), op.hlc.wall_ms / 1000, format!("oxy: {}\n\n", op.command)),

                many => {

                    let mut m = format!("oxy: {} ({} changes)\n\n", op.command, many.len());

                    for h in many {

                        let c = self.store.get_change(h)?;

                        m.push_str(&format!("- {} {}\n", c.change_id.short(8), c.message.lines().next().unwrap_or("")));

                    }

                    m.push_str(&format!("\nOxy-Changes: {}\n", many.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(" ")));

                    ("oxy <oxy@localhost>".to_string(), op.hlc.wall_ms / 1000, m)

                }

            };

            message.push_str(&format!("Oxy-State: {}\n", state_ref.to_hex()));

            if snapshot.is_conflicted() {

                message.push_str("Oxy-Conflicted: true\n");

            }

            let mark = next_mark;

            next_mark += 1;

            let parents: Vec<u64> = last_mark.into_iter().collect();

            self.write_commit(&mut stream, "refs/oxy/export", mark, &author, secs, &message, &parents, &snapshot)?;

            marks.insert(state_ref, mark);

            last_mark = Some(mark);

            prev = Some((state_ref, state.heads.clone()));

            report.exported += 1;

        }

        match last_mark {

            Some(m) => stream.extend_from_slice(format!("reset refs/heads/{bookmark}\nfrom :{m}\n\ndone\n").as_bytes()),

            None => stream.extend_from_slice(b"done\n"),

        }

        let mut cmd = Command::new("git");

        // `--force`: the scratch ref may jump between unrelated states.

        cmd.arg("-C").arg(git_dir).args(["fast-import", "--quiet", "--done", "--force"]).arg(format!("--export-marks={}", git_marks.display()));

        if git_marks.exists() {

            cmd.arg(format!("--import-marks={}", git_marks.display()));

        }

        let mut child = cmd.stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::piped()).spawn().map_err(|e| RepoError::Msg(format!("running git fast-import: {e}")))?;

        child.stdin.take().unwrap().write_all(&stream)?;

        let out = child.wait_with_output()?;

        if !out.status.success() {

            return fail(format!("git fast-import failed: {}", String::from_utf8_lossy(&out.stderr).trim()));

        }

        let text: String = marks.iter().map(|(h, m)| format!("{} {m}\n", h.to_hex())).collect();

        write_atomic(&oxy_marks_path, text.as_bytes())?;

        let _ = git(git_dir, &["update-ref", "-d", "refs/oxy/export"]);

        Ok(report)

    }

    fn git_author(&self, c: &Change) -> String {

        match self.store.get_identity(&c.author) {

            Ok(id) if !id.name.is_empty() => format!("{} <{}>", id.name.replace(['<', '>', '\n'], " "), id.email.replace(['<', '>', '\n', ' '], "")),

            _ => "oxy <oxy@localhost>".to_string(),

        }

    }

    #[allow(clippy::too_many_arguments)]

    fn write_commit(&self, out: &mut Vec<u8>, reference: &str, mark: u64, author: &str, secs: u64, message: &str, parents: &[u64], snapshot: &Snapshot) -> Result<()> {

        out.extend_from_slice(format!("commit {reference}\nmark :{mark}\nauthor {author} {secs} +0000\ncommitter {author} {secs} +0000\ndata {}\n{message}\n", message.len()).as_bytes());

        for (i, p) in parents.iter().enumerate() {

            out.extend_from_slice(format!("{} :{p}\n", if i == 0 { "from" } else { "merge" }).as_bytes());

        }

        out.extend_from_slice(b"deleteall\n");

        for (path, f) in &snapshot.files {

            let (mode, bytes): (&str, Vec<u8>) = match (&f.kind, &f.content) {

                (NodeKind::Dir, _) => continue,

                (NodeKind::Symlink, FileContent::Opaque { blobs }) => ("120000", blobs.first().map(|b| self.read_blob(b)).transpose()?.unwrap_or_default()),

                (_, FileContent::Text { bytes, .. }) => (if f.mode.exec { "100755" } else { "100644" }, bytes.clone()),

                (_, FileContent::Opaque { blobs }) => (if f.mode.exec { "100755" } else { "100644" }, blobs.first().map(|b| self.read_blob(b)).transpose()?.unwrap_or_default()),

                (_, FileContent::Dir) => continue,

            };

            out.extend_from_slice(format!("M {mode} inline {path}\ndata {}\n", bytes.len()).as_bytes());

            out.extend_from_slice(&bytes);

            out.push(b'\n');

        }

        out.push(b'\n');

        Ok(())

    }

}

mod git;

pub use git::GitExportReport;

#[test]

fn git_export_mirrors_history() {

    hermetic();

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

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

        return;

    }

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

    let root = dir.path();

    let mut repo = Repo::init(&root.join("r")).unwrap().with_home(root.join("home"));

    repo.create_identity("Ada Lovelace", "[email protected]", IdentityScope::User).unwrap();

    let r = root.join("r");

    write(&r, "README.md", b"hello\n");

    write(&r, "src/main.rs", b"fn main() {}\n");

    let h1 = repo.commit("first", &[]).unwrap();

    write(&r, "src/main.rs", b"fn main() { run(); }\n");

    write(&r, "logo.png", b"\x89PNG\0\0");

    let h2 = repo.commit("second", &[]).unwrap();

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

    let rep = repo.git_export(&git_dir).unwrap();

    assert_eq!((rep.exported, rep.skipped, rep.heads), (2, 0, 1));

    let git = |args: &[&str]| -> String {

        let out = std::process::Command::new("git").arg("-C").arg(&git_dir).args(args).output().unwrap();

        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));

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

    };

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

    assert_eq!(git(&["show", "main:src/main.rs"]), "fn main() { run(); }");

    assert_eq!(git(&["show", "main:README.md"]), "hello");

    let body = git(&["log", "-1", "--format=%B", "main"]);

    assert!(body.contains(&format!("Oxy-Hash: {}", h2.to_hex())), "{body}");

    assert!(body.contains("Change-Id: "), "{body}");

    assert_eq!(git(&["log", "-1", "--format=%an <%ae>", "main"]), "Ada Lovelace <[email protected]>");

    assert_eq!(git(&["ls-tree", "--name-only", "main"]), "README.md\nlogo.png\nsrc");

    // Re-export is incremental.

    let rep = repo.git_export(&git_dir).unwrap();

    assert_eq!((rep.exported, rep.skipped), (0, 2));

    // An independent change makes two heads; the next state is one more

    // commit on the linear branch whose tree is the union.

    repo.checkout(&[h1], false, "checkout").unwrap();

    write(&r, "other.txt", b"o\n");

    let h3 = repo.commit("third", &[]).unwrap();

    let rep = repo.git_export(&git_dir).unwrap();

    assert_eq!((rep.exported, rep.heads), (1, 2));

    assert_eq!(git(&["log", "--format=%s", "main"]), "third\nsecond\nfirst");

    let parents = git(&["rev-list", "--parents", "-1", "main"]);

    assert_eq!(parents.split(' ').count(), 2, "one parent: {parents}");

    assert_eq!(git(&["show", "main:other.txt"]), "o");

    assert_eq!(git(&["show", "main:src/main.rs"]), "fn main() { run(); }");

    assert_eq!(git(&["ls-tree", "--name-only", "main"]), "README.md\nlogo.png\nother.txt\nsrc");

    let body = git(&["log", "-1", "--format=%B", "main"]);

    assert!(body.contains(&format!("Oxy-Hash: {}", h3.to_hex())) && body.contains("Oxy-State: "), "{body}");

    // A rewrite is a new state whose one new change is the rewritten one.

    repo.describe(&h3, "third, described").unwrap();

    let rep = repo.git_export(&git_dir).unwrap();

    assert_eq!(rep.exported, 1);

    assert_eq!(git(&["log", "-1", "--format=%s", "main"]), "third, described");

    assert_eq!(git(&["log", "--format=%s", "main"]).lines().count(), 4);

    let _ = h2;

}

    /// Git interoperability

    Git {

        #[command(subcommand)]

        cmd: GitCmd,

    },

enum GitCmd {

    /// Export the current bookmark to a Git repository (created bare if absent)

    Export { git_dir: PathBuf },

}

#[derive(Subcommand)]

        Cmd::Git { cmd: GitCmd::Export { git_dir } } => sync::git_export(&git_dir),

pub fn git_export(git_dir: &std::path::Path) -> Result<i32> {

    let repo = open()?;

    let r = repo.git_export(git_dir)?;

    println!(

        "Exported {} to {} (branch {}: {}{}); {} already exported.",

        plural(r.exported, "change"),

        git_dir.display(),

        r.branch,

        plural(r.heads, "head"),

        if r.heads > 1 { ", joined by a synthetic merge commit" } else { "" },

        r.skipped

    );

    Ok(0)

}