Subrepositories: subrepo node kind with Oxygen and Git pins, .oxymodules, nested repositories skipped by the walker and moved by checkout, oxy submodule add|update|status|remove, Git gitlink import and export (spec 0.8 section 7.8) 4dee277c327a

//! Subrepositories in the working copy (spec §7.8): reading pins from

//! nested repositories, moving them to pins, and the `oxy submodule`

//! commands.

use super::*;

use crate::subrepo::{Module, Modules, Pin};

use std::process::Command;

/// What syncing a nested repository to its pin did.

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

pub enum SubrepoSync {

    Updated,

    UpToDate,

    Missing,

    Dirty,

    Failed(String),

}

/// One subrepo as `oxy submodule status` shows it.

#[derive(Clone, Debug)]

pub struct SubrepoInfo {

    pub path: String,

    pub pin: Pin,

    pub url: Option<String>,

    /// The nested repository's own pin now, if present.

    pub actual: Option<Pin>,

    pub dirty: bool,

}

fn git_out(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 {} in {}: {}", args.join(" "), dir.display(), String::from_utf8_lossy(&out.stderr).trim()));

    }

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

}

/// The pin a nested repository at `dir` is at: its current bookmark's

/// heads for an Oxygen repository, `HEAD` for a Git one.

pub(crate) fn read_pin(dir: &Path, bookmark_hint: Option<&str>) -> Result<Pin> {

    if dir.join(OXY_DIR).exists() {

        let nested = Repo::open(dir)?;

        return Ok(Pin::Oxy { repo: nested.id()?, heads: nested.bookmark_heads()?, bookmark: nested.config.bookmark.clone() });

    }

    if dir.join(".git").exists() {

        let sha = git_out(dir, &["rev-parse", "HEAD"])?;

        return Ok(Pin::Git { sha, branch: bookmark_hint.unwrap_or("HEAD").to_string() });

    }

    fail(format!("{} is not a repository", dir.display()))

}

/// Whether a nested repository has uncommitted work.

fn nested_dirty(dir: &Path) -> Result<bool> {

    if dir.join(OXY_DIR).exists() {

        let nested = Repo::open(dir)?;

        let snap = nested.snapshot("oxy submodule")?;

        return Ok(!snap.wc.tree_ops.is_empty() || !snap.wc.edits.is_empty());

    }

    Ok(!git_out(dir, &["status", "--porcelain"])?.is_empty())

}

/// Whether `url` names an Oxygen repository (else it is taken to be Git).

fn is_oxy_url(url: &str) -> bool {

    if url.starts_with("http://") || url.starts_with("https://") {

        return crate::protocol::open_remote(url, &RemoteOptions::default()).and_then(|r| r.repo_id()).is_ok();

    }

    let p = Path::new(url.strip_prefix("file://").unwrap_or(url));

    p.join(OXY_DIR).exists()

}

impl Repo {

    pub(crate) fn modules_on_disk(&self) -> Modules {

        fs::read_to_string(self.root.join(".oxymodules")).map(|t| Modules::parse(&t)).unwrap_or_default()

    }

    fn write_modules(&self, m: &Modules) -> Result<()> {

        if m.entries.is_empty() {

            let _ = fs::remove_file(self.root.join(".oxymodules"));

            return Ok(());

        }

        write_atomic(&self.root.join(".oxymodules"), m.to_text().as_bytes())

    }

    /// Bring the nested repository at `path` to `pin`, cloning it first when

    /// `init` and it is absent.

    pub(crate) fn sync_subrepo(&self, path: &str, pin: &Pin, init: bool) -> Result<SubrepoSync> {

        let dir = self.root.join(path);

        let module = self.modules_on_disk().entries.get(path).cloned();

        let present = dir.join(OXY_DIR).exists() || dir.join(".git").exists();

        let cloned = !present;

        if !present {

            if !init {

                return Ok(SubrepoSync::Missing);

            }

            let Some(m) = &module else { return Ok(SubrepoSync::Failed("no .oxymodules entry to clone from".into())) };

            if let Some(parent) = dir.parent() {

                fs::create_dir_all(parent)?;

            }

            let _ = fs::remove_dir(&dir);

            let r = match pin {

                Pin::Oxy { .. } => Repo::clone(&m.url, &dir).map(|_| ()),

                Pin::Git { .. } => Command::new("git")

                    .args(["clone", "-q", &m.url])

                    .arg(&dir)

                    .status()

                    .map_err(|e| RepoError::Msg(e.to_string()))

                    .and_then(|s| if s.success() { Ok(()) } else { fail(format!("git clone {} failed", m.url)) }),

            };

            if let Err(e) = r {

                return Ok(SubrepoSync::Failed(format!("cloning {}: {e}", m.url)));

            }

        }

        let actual = read_pin(&dir, module.as_ref().and_then(|m| m.bookmark.as_deref()))?;

        let same = match (pin, &actual) {

            (Pin::Oxy { heads: a, .. }, Pin::Oxy { heads: b, .. }) => {

                let (mut a, mut b) = (a.clone(), b.clone());

                a.sort();

                b.sort();

                a == b

            }

            (Pin::Git { sha: a, .. }, Pin::Git { sha: b, .. }) => a == b,

            _ => false,

        };

        if same {

            return Ok(if cloned { SubrepoSync::Updated } else { SubrepoSync::UpToDate });

        }

        if nested_dirty(&dir)? {

            return Ok(SubrepoSync::Dirty);

        }

        match pin {

            Pin::Oxy { heads, .. } => {

                let nested = Repo::open(&dir)?;

                if nested.load_state(heads).is_err() {

                    // The pinned changes are not here yet: fetch from origin.

                    if let Err(e) = nested.fetch("origin") {

                        return Ok(SubrepoSync::Failed(format!("fetching the pinned changes: {e}")));

                    }

                }

                match nested.checkout(heads, false, "oxy submodule update") {

                    Ok(_) => {

                        let _ = nested.bookmark_set(&nested.config.bookmark, heads);

                        Ok(SubrepoSync::Updated)

                    }

                    Err(e) => Ok(SubrepoSync::Failed(e.to_string())),

                }

            }

            Pin::Git { sha, .. } => {

                if git_out(&dir, &["cat-file", "-e", &format!("{sha}^{{commit}}")]).is_err() {

                    if let Err(e) = git_out(&dir, &["fetch", "-q", "origin"]) {

                        return Ok(SubrepoSync::Failed(e.to_string()));

                    }

                }

                match git_out(&dir, &["checkout", "-q", "--detach", sha]) {

                    Ok(_) => Ok(SubrepoSync::Updated),

                    Err(e) => Ok(SubrepoSync::Failed(e.to_string())),

                }

            }

        }

    }

    /// Every subrepo of the working copy's base state.

    pub fn subrepos(&self) -> Result<Vec<SubrepoInfo>> {

        let (_, wc) = self.working_copy()?;

        let snap = self.load_state(&wc.deps)?.materialize();

        let modules = self.modules_on_disk();

        let mut out = Vec::new();

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

            if f.kind != NodeKind::Subrepo {

                continue;

            }

            let FileContent::Opaque { blobs } = &f.content else { continue };

            let Some(b) = blobs.first() else { continue };

            let pin = Pin::decode(&self.read_blob(b)?)?;

            let dir = self.root.join(path);

            let present = dir.join(OXY_DIR).exists() || dir.join(".git").exists();

            let actual = if present { read_pin(&dir, modules.entries.get(path).and_then(|m| m.bookmark.as_deref())).ok() } else { None };

            let dirty = present && nested_dirty(&dir).unwrap_or(false);

            out.push(SubrepoInfo { path: path.clone(), pin, url: modules.entries.get(path).map(|m| m.url.clone()), actual, dirty });

        }

        Ok(out)

    }

    /// Clone `url` at `path`, register it in `.oxymodules`, and return the

    /// pin the next snapshot will record.

    pub fn submodule_add(&self, url: &str, path: &str, bookmark: Option<&str>) -> Result<Pin> {

        let path = path.trim_end_matches('/').to_string();

        if path.is_empty() || path.starts_with('/') || path.split('/').any(|c| c == ".." || c == ".") {

            return fail(format!("{path:?} is not a valid subrepo path"));

        }

        let dir = self.root.join(&path);

        if dir.exists() && fs::read_dir(&dir)?.next().is_some() {

            return fail(format!("{path} exists and is not empty"));

        }

        if let Some(parent) = dir.parent() {

            fs::create_dir_all(parent)?;

        }

        let git = !is_oxy_url(url);

        if git {

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

            cmd.args(["clone", "-q"]);

            if let Some(b) = bookmark {

                cmd.args(["--branch", b]);

            }

            let status = cmd.arg(url).arg(&dir).status().map_err(|e| RepoError::Msg(format!("running git: {e}")))?;

            if !status.success() {

                return fail(format!("git clone {url} failed"));

            }

        } else {

            let _ = fs::remove_dir(&dir);

            let mut nested = Repo::clone(url, &dir)?;

            if let Some(b) = bookmark {

                nested.bookmark_switch(b, true)?;

            }

        }

        let mut modules = self.modules_on_disk();

        modules.entries.insert(path.clone(), Module { url: url.to_string(), bookmark: bookmark.map(str::to_string), git });

        self.write_modules(&modules)?;

        read_pin(&dir, bookmark)

    }

    /// Bring nested repositories to their pins (`paths` empty = all).

    pub fn submodule_update(&self, init: bool, paths: &[String]) -> Result<Vec<(String, SubrepoSync)>> {

        let mut out = Vec::new();

        for s in self.subrepos()? {

            if !paths.is_empty() && !paths.iter().any(|p| p.trim_end_matches('/') == s.path) {

                continue;

            }

            let r = self.sync_subrepo(&s.path, &s.pin, init)?;

            out.push((s.path, r));

        }

        Ok(out)

    }

    /// Drop the `.oxymodules` entry; the node goes with the next snapshot

    /// only if the directory is removed, since a registered or tracked

    /// nested repository keeps contributing its pin. Here the directory is

    /// left in place and the node is removed explicitly from the working

    /// copy's next change by unregistering and moving the directory aside.

    pub fn submodule_remove(&self, path: &str) -> Result<()> {

        let path = path.trim_end_matches('/').to_string();

        let mut modules = self.modules_on_disk();

        let known = modules.entries.remove(&path).is_some() || self.subrepos()?.iter().any(|s| s.path == path);

        if !known {

            return fail(format!("{path} is not a subrepo"));

        }

        self.write_modules(&modules)?;

        // The directory stays; the walker ignores an unregistered nested

        // repository unless tracked, so mark it as removed for the next

        // snapshot by recording an explicit removal.

        let dir = self.oxy.join("subrepos-removed");

        fs::create_dir_all(&dir)?;

        write_atomic(&dir.join(path.replace('/', "%2F")), b"")?;

        Ok(())

    }

    /// Paths whose subrepo node was removed with `oxy submodule remove` and

    /// whose directory is still on disk.

    pub(crate) fn removed_subrepos(&self) -> BTreeSet<String> {

        let mut out = BTreeSet::new();

        if let Ok(rd) = fs::read_dir(self.oxy.join("subrepos-removed")) {

            for e in rd.flatten() {

                out.insert(e.file_name().to_string_lossy().replace("%2F", "/"));

            }

        }

        out

    }

    pub(crate) fn clear_removed_subrepo(&self, path: &str) {

        let _ = fs::remove_file(self.oxy.join("subrepos-removed").join(path.replace('/', "%2F")));

    }

}

//! Subrepositories (spec §7.8): the pin stored as a `subrepo` node's

//! content, and the `.oxymodules` file mapping paths to remotes.

//!

//! Pin encoding: `{0: 1, 1: kind, 2: locator, 3: pin, 4: bookmark}`; kind 0

//! is an Oxygen repository (locator = repository id, pin = sorted heads),

//! kind 1 a Git repository (locator = null, pin = commit sha as text).

use crate::cbor::{self, Value};

use crate::hash::ChangeHash;

use crate::objects::{array, bytes, check_version, field, oref, text, uint, ObjectError, FORMAT_VERSION};

use std::collections::BTreeMap;

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

pub enum Pin {

    Oxy { repo: [u8; 16], heads: Vec<ChangeHash>, bookmark: String },

    Git { sha: String, branch: String },

}

impl Pin {

    pub fn encode(&self) -> Vec<u8> {

        let v = match self {

            Pin::Oxy { repo, heads, bookmark } => {

                let mut heads = heads.clone();

                heads.sort();

                heads.dedup();

                Value::map([

                    (0, Value::Uint(FORMAT_VERSION)),

                    (1, Value::Uint(0)),

                    (2, Value::Bytes(repo.to_vec())),

                    (3, Value::Array(heads.iter().map(|h| Value::Bytes(h.0.to_vec())).collect())),

                    (4, Value::Text(bookmark.clone())),

                ])

            }

            Pin::Git { sha, branch } => Value::map([

                (0, Value::Uint(FORMAT_VERSION)),

                (1, Value::Uint(1)),

                (2, Value::Null),

                (3, Value::Text(sha.clone())),

                (4, Value::Text(branch.clone())),

            ]),

        };

        cbor::encode(&v)

    }

    pub fn decode(b: &[u8]) -> Result<Pin, ObjectError> {

        let v = cbor::decode(b)?;

        let m = v.as_map().ok_or_else(|| ObjectError::Schema("pin: expected map".into()))?;

        check_version(m)?;

        let bookmark = text(field(m, 4, "bookmark")?, "bookmark")?.to_owned();

        match uint(field(m, 1, "kind")?, "kind")? {

            0 => {

                let repo: [u8; 16] = bytes(field(m, 2, "repo")?, "repo")?.try_into().map_err(|_| ObjectError::Schema("pin: repo id must be 16 bytes".into()))?;

                let heads = array(field(m, 3, "heads")?, "heads")?.iter().map(|h| oref(h, "head")).collect::<Result<Vec<_>, _>>()?;

                Ok(Pin::Oxy { repo, heads, bookmark })

            }

            1 => Ok(Pin::Git { sha: text(field(m, 3, "sha")?, "sha")?.to_owned(), branch: bookmark }),

            k => Err(ObjectError::Schema(format!("pin: unknown kind {k}"))),

        }

    }

    /// A one-line description for listings.

    pub fn summary(&self) -> String {

        match self {

            Pin::Oxy { heads, bookmark, .. } => format!("oxy {bookmark} {}", heads.iter().map(|h| h.short(12)).collect::<Vec<_>>().join(" ")),

            Pin::Git { sha, branch } => format!("git {branch} {}", &sha[..sha.len().min(12)]),

        }

    }

    pub fn is_git(&self) -> bool {

        matches!(self, Pin::Git { .. })

    }

}

/// One `.oxymodules` entry.

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

pub struct Module {

    pub url: String,

    /// Oxygen bookmark or Git branch to track.

    pub bookmark: Option<String>,

    pub git: bool,

}

/// `.oxymodules`: `[path]` sections with `url`, and `bookmark` (Oxygen) or

/// `branch` (Git) keys.

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

pub struct Modules {

    pub entries: BTreeMap<String, Module>,

}

impl Modules {

    pub fn parse(text: &str) -> Modules {

        let mut out = Modules::default();

        let mut current: Option<String> = None;

        for line in text.lines() {

            let line = line.trim();

            if line.is_empty() || line.starts_with('#') {

                continue;

            }

            if let Some(inner) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {

                let path = inner.trim().trim_matches('"').trim_end_matches('/').to_string();

                out.entries.entry(path.clone()).or_default();

                current = Some(path);

                continue;

            }

            let (Some(path), Some((k, v))) = (&current, line.split_once('=')) else { continue };

            let v = v.trim().trim_matches('"').to_string();

            let m = out.entries.get_mut(path).unwrap();

            match k.trim() {

                "url" => m.url = v,

                "bookmark" => {

                    m.bookmark = Some(v);

                    m.git = false;

                }

                "branch" => {

                    m.bookmark = Some(v);

                    m.git = true;

                }

                "kind" => m.git = v == "git",

                _ => {}

            }

        }

        out

    }

    pub fn to_text(&self) -> String {

        let mut s = String::new();

        for (path, m) in &self.entries {

            s.push_str(&format!("[{path}]\nurl = {}\n", m.url));

            if m.git {

                s.push_str("kind = git\n");

            }

            if let Some(b) = &m.bookmark {

                s.push_str(&format!("{} = {b}\n", if m.git { "branch" } else { "bookmark" }));

            }

            s.push('\n');

        }

        s

    }

    /// From Git's `.gitmodules` (`[submodule "name"]` with `path`, `url`, `branch`).

    pub fn from_gitmodules(text: &str) -> Modules {

        let mut out = Modules::default();

        let mut path: Option<String> = None;

        let mut url = String::new();

        let mut branch: Option<String> = None;

        let flush = |out: &mut Modules, path: &Option<String>, url: &str, branch: &Option<String>| {

            if let Some(p) = path {

                out.entries.insert(p.clone(), Module { url: url.to_string(), bookmark: branch.clone(), git: true });

            }

        };

        for line in text.lines() {

            let line = line.trim();

            if line.starts_with("[submodule") {

                flush(&mut out, &path, &url, &branch);

                path = None;

                url.clear();

                branch = None;

                continue;

            }

            if let Some((k, v)) = line.split_once('=') {

                let v = v.trim().to_string();

                match k.trim() {

                    "path" => path = Some(v.trim_end_matches('/').to_string()),

                    "url" => url = v,

                    "branch" => branch = Some(v),

                    _ => {}

                }

            }

        }

        flush(&mut out, &path, &url, &branch);

        out

    }

    /// Git's `.gitmodules` form of the Git-kind entries.

    pub fn to_gitmodules(&self) -> String {

        let mut s = String::new();

        for (path, m) in &self.entries {

            if !m.git {

                continue;

            }

            s.push_str(&format!("[submodule \"{path}\"]\n\tpath = {path}\n\turl = {}\n", m.url));

            if let Some(b) = &m.bookmark {

                s.push_str(&format!("\tbranch = {b}\n"));

            }

        }

        s

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::hash::ObjectRef;

    #[test]

    fn pins_round_trip() {

        let o = Pin::Oxy { repo: [7; 16], heads: vec![ObjectRef([2; 32]), ObjectRef([1; 32])], bookmark: "main".into() };

        let back = Pin::decode(&o.encode()).unwrap();

        assert_eq!(back, Pin::Oxy { repo: [7; 16], heads: vec![ObjectRef([1; 32]), ObjectRef([2; 32])], bookmark: "main".into() });

        let g = Pin::Git { sha: "0cb4742f64cf204e5fafd0963749d84afc561892".into(), branch: "main".into() };

        assert_eq!(Pin::decode(&g.encode()).unwrap(), g);

        assert!(g.is_git() && !o.is_git());

    }

    #[test]

    fn modules_files() {

        let text = "[libs/sub]\nurl = ../sub\nbookmark = main\n\n[vendor/x]\nurl = https://example.org/x.git\nkind = git\nbranch = trunk\n";

        let m = Modules::parse(text);

        assert_eq!(m.entries["libs/sub"], Module { url: "../sub".into(), bookmark: Some("main".into()), git: false });

        assert_eq!(m.entries["vendor/x"], Module { url: "https://example.org/x.git".into(), bookmark: Some("trunk".into()), git: true });

        assert_eq!(Modules::parse(&m.to_text()), m);

        let gm = "[submodule \"rstar-api\"]\n\tpath = rstar-api\n\turl = https://github.com/x/rstar-api.git\n[submodule \"c\"]\n\tpath = cstar-api\n\turl = https://github.com/x/cstar-api.git\n\tbranch = dev\n";

        let g = Modules::from_gitmodules(gm);

        assert_eq!(g.entries.len(), 2);

        assert!(g.entries["rstar-api"].git && g.entries["rstar-api"].bookmark.is_none());

        assert_eq!(g.entries["cstar-api"].bookmark.as_deref(), Some("dev"));

        assert!(g.to_gitmodules().contains("[submodule \"cstar-api\"]") && g.to_gitmodules().contains("branch = dev"));

    }

}

pub mod subrepo;

    /// A nested repository pinned to a state (spec §7.8); content is a pin.

    Subrepo,

            NodeKind::Subrepo => 3,

            3 => NodeKind::Subrepo,

        for k in [NodeKind::File, NodeKind::Dir, NodeKind::Symlink, NodeKind::Subrepo] {

    /// Nested repositories that could not be moved, and other remarks.

    pub notes: Vec<String>,

        // Remove tracked paths that the target does not have. A nested

        // repository is never deleted (spec §7.8); it is left in place.

        for (path, entry) in &current {

                if entry.kind == NodeKind::Subrepo {

                    report.notes.push(format!("{path}: nested repository left in place"));

                    continue;

                }

                    if f.kind == NodeKind::Subrepo {

                        let pin = crate::subrepo::Pin::decode(&bytes)?;

                        match self.sync_subrepo(path, &pin, false)? {

                            SubrepoSync::Updated => report.written += 1,

                            SubrepoSync::UpToDate => {}

                            SubrepoSync::Missing => report.notes.push(format!("{path}: nested repository not present; run oxy submodule update --init")),

                            SubrepoSync::Dirty => report.notes.push(format!("{path}: nested repository has uncommitted changes; left as is")),

                            SubrepoSync::Failed(e) => report.notes.push(format!("{path}: {e}")),

                        }

                        continue;

                    }

        let entries = self.walk_working_copy_with(None, &Self::tracked_kinds(&target))?;

    /// Gitlink entries imported as subrepo nodes with Git pins.

    pub submodules: usize,

    /// Subrepo nodes with Oxygen pins, which Git cannot represent.

    pub skipped_subrepos: usize,

        report.skipped_subrepos = self.git_export_skipped.replace(0);

            let mut gitlinks: Vec<(String, String)> = Vec::new();

                        gitlinks.push((path, sha));

            // Submodules (spec §23): gitlinks become subrepo nodes with Git

            // pins, and `.gitmodules` also yields `.oxymodules`.

            if !gitlinks.is_empty() {

                report.submodules += gitlinks.len();

                let gm = entries.get(".gitmodules").map(|e| crate::subrepo::Modules::from_gitmodules(&String::from_utf8_lossy(&e.content))).unwrap_or_default();

                let mut modules = entries.get(".oxymodules").map(|e| crate::subrepo::Modules::parse(&String::from_utf8_lossy(&e.content))).unwrap_or_default();

                for (path, sha) in &gitlinks {

                    let m = gm.entries.get(path);

                    let branch = m.and_then(|m| m.bookmark.clone()).unwrap_or_else(|| "HEAD".into());

                    entries.insert(path.clone(), FsEntry::new(NodeKind::Subrepo, false, crate::subrepo::Pin::Git { sha: sha.clone(), branch }.encode()));

                    if let Some(m) = m {

                        modules.entries.insert(path.clone(), m.clone());

                    }

                }

                if !modules.entries.is_empty() {

                    entries.insert(".oxymodules".into(), FsEntry::new(NodeKind::File, false, modules.to_text().into_bytes()));

                }

            }

        let has_gitmodules = snapshot.files.contains_key(".gitmodules");

            if path == ".oxymodules" {

                // Git reads `.gitmodules`; derive it unless the tree has one.

                if !has_gitmodules {

                    if let FileContent::Text { bytes, .. } = &f.content {

                        let gm = crate::subrepo::Modules::parse(&String::from_utf8_lossy(bytes)).to_gitmodules();

                        if !gm.is_empty() {

                            out.extend_from_slice(format!("M 100644 inline .gitmodules\ndata {}\n", gm.len()).as_bytes());

                            out.extend_from_slice(gm.as_bytes());

                            out.push(b'\n');

                        }

                    }

                }

                continue;

            }

            if f.kind == NodeKind::Subrepo {

                if let FileContent::Opaque { blobs } = &f.content {

                    if let Some(b) = blobs.first() {

                        match crate::subrepo::Pin::decode(&self.read_blob(b)?)? {

                            crate::subrepo::Pin::Git { sha, .. } => out.extend_from_slice(format!("M 160000 {sha} {path}\n").as_bytes()),

                            crate::subrepo::Pin::Oxy { .. } => self.git_export_skipped.set(self.git_export_skipped.get() + 1),

                        }

                    }

                }

                continue;

            }

#[allow(unused_imports)]

use crate::subrepo::Pin;

mod subrepos;

pub use subrepos::{SubrepoInfo, SubrepoSync};

    /// Oxygen-pinned subrepos skipped by the running Git export.

    pub(crate) git_export_skipped: std::cell::Cell<usize>,

        let repo = Repo { git_export_skipped: Default::default(), root, oxy, store, workspace, keys_dir: default_keys_dir(), user_config: default_user_config(), config };

                let mut repo = Repo { git_export_skipped: Default::default(), root: d.to_path_buf(), oxy: shared, store, workspace, keys_dir: default_keys_dir(), user_config: default_user_config(), config };

                let mut repo = Repo { git_export_skipped: Default::default(), root: d.to_path_buf(), oxy, store, workspace, keys_dir: default_keys_dir(), user_config: default_user_config(), config };

        self.walk_working_copy_with(None, &BTreeMap::new())

    }

    /// A walker over the working copy that never enters a nested repository

    /// (a directory below the root holding `.oxy` or `.git`); the directories

    /// it skipped are collected into `nested`.

    pub(crate) fn walker(&self, nested: &std::sync::Arc<std::sync::Mutex<Vec<PathBuf>>>) -> ignore::WalkBuilder {

        let mut wb = ignore::WalkBuilder::new(&self.root);

        wb.hidden(false)

            .git_ignore(false)

            .git_global(false)

            .git_exclude(false)

            .require_git(false)

            .follow_links(false)

            .add_custom_ignore_filename(".oxyignore");

        let nested = nested.clone();

        wb.filter_entry(move |e| {

            if e.file_name() == OXY_DIR {

                return false;

            }

            if e.depth() > 0 && e.file_type().is_some_and(|t| t.is_dir()) && (e.path().join(OXY_DIR).exists() || e.path().join(".git").exists()) {

                nested.lock().unwrap().push(e.path().to_path_buf());

                return false;

            }

            true

        });

        wb

    fn walk_working_copy_with(&self, cache: Option<&prompt::Manifest>, tracked: &BTreeMap<String, (NodeKind, Option<ObjectRef>)>) -> Result<BTreeMap<String, FsEntry>> {

        let nested = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));

        let wb = self.walker(&nested);

        // Nested repositories (spec §7.8): registered in `.oxymodules` or

        // already tracked as subrepo nodes, they contribute their pin;

        // unregistered ones are left alone.

        let modules = self.modules_on_disk();

        let removed = self.removed_subrepos();

        for rel in &removed {

            if tracked.get(rel).map(|(k, _)| *k) != Some(NodeKind::Subrepo) {

                self.clear_removed_subrepo(rel);

            }

        }

        let nested_dirs = std::mem::take(&mut *nested.lock().unwrap());

        for dir in nested_dirs {

            let rel = self.rel_path(&dir);

            if !self.in_scope(&rel) || removed.contains(&rel) {

                continue;

            }

            let registered = modules.entries.get(&rel);

            if registered.is_none() && tracked.get(&rel).map(|(k, _)| *k) != Some(NodeKind::Subrepo) {

                continue;

            }

            let pin = subrepos::read_pin(&dir, registered.and_then(|m| m.bookmark.as_deref()))?;

            out.insert(rel, FsEntry::new(NodeKind::Subrepo, false, pin.encode()));

        }

        for (rel, (kind, blob)) in tracked {

            if *kind == NodeKind::Subrepo {

                if removed.contains(rel) {

                    continue;

                }

                let present = path.is_dir() && (path.join(OXY_DIR).exists() || path.join(".git").exists());

                if present {

                    let pin = subrepos::read_pin(&path, modules.entries.get(rel).and_then(|m| m.bookmark.as_deref()))?;

                    out.insert(rel.clone(), FsEntry::new(NodeKind::Subrepo, false, pin.encode()));

                } else if let Some(b) = blob {

                    // Not cloned (or emptied): the pin stays as recorded, as a

                    // Git gitlink does when its directory is absent.

                    out.insert(rel.clone(), FsEntry { kind: NodeKind::Subrepo, exec: false, content: vec![], blob: Some(*b), content_hash: None });

                }

                continue;

            }

    /// The non-directory paths of a snapshot with their kinds, for the

    /// walker's `tracked` set.

    pub(crate) fn tracked_kinds(snapshot: &Snapshot) -> BTreeMap<String, (NodeKind, Option<ObjectRef>)> {

        snapshot

            .files

            .iter()

            .filter(|(_, f)| f.kind != NodeKind::Dir)

            .map(|(p, f)| {

                let blob = match &f.content {

                    FileContent::Opaque { blobs } => blobs.first().copied(),

                    _ => None,

                };

                (p.clone(), (f.kind, blob))

            })

            .collect()

    }

    /// A path under the root as a `/`-separated relative string.

    pub(crate) fn rel_path(&self, path: &Path) -> String {

        path.strip_prefix(&self.root).unwrap_or(path).components().map(|c| c.as_os_str().to_string_lossy().to_string()).collect::<Vec<_>>().join("/")

        let nested = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));

        let wb = self.walker(&nested);

        let fs_entries = self.walk_working_copy_with(None, &Self::tracked_kinds(base_snapshot))?;

        let fs_entries = self.walk_working_copy_with(manifest.as_ref(), &Self::tracked_kinds(&base_snapshot))?;

        if e.kind == NodeKind::Symlink || e.kind == NodeKind::Subrepo {

    assert_eq!(r, CheckoutReport { written: 2, removed: 1, conflicted: false, notes: vec![] });

#[test]

fn oxygen_subrepos_pin_follow_and_update() {

    hermetic();

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

    let root = dir.path();

    // A library repository with two commits, and a bare-ish origin for it.

    let lib_origin = Repo::init(&root.join("lib-origin")).unwrap();

    let lib_url = root.join("lib-origin").to_string_lossy().to_string();

    let lib = Repo::clone(&lib_url, &root.join("lib")).unwrap().with_home(root.join("home"));

    write(&root.join("lib"), "lib.txt", b"v1\n");

    let l1 = lib.commit("lib v1", &[]).unwrap();

    assert!(lib.push("origin", false).unwrap()[0].ok);

    let _ = lib_origin;

    // The application (a clone of its own origin) adds it as a subrepo.

    let app_origin = Repo::init(&root.join("app-origin")).unwrap();

    let app_url = root.join("app-origin").to_string_lossy().to_string();

    let _ = app_origin;

    let app_dir = root.join("app");

    let app = Repo::clone(&app_url, &app_dir).unwrap().with_home(root.join("home"));

    write(&app_dir, "main.txt", b"app\n");

    let pin = app.submodule_add(&lib_url, "libs/lib", None).unwrap();

    assert!(matches!(&pin, crate::subrepo::Pin::Oxy { heads, .. } if heads == &vec![l1]));

    assert!(app_dir.join(".oxymodules").exists() && app_dir.join("libs/lib/.oxy").is_dir());

    let snap = app.snapshot("status").unwrap();

    let paths: Vec<&str> = snap.statuses.iter().map(|s| s.path.as_str()).collect();

    assert_eq!(paths, vec![".oxymodules", "libs/lib", "main.txt"], "the nested files are not walked");

    let a1 = app.commit("app with lib", &[]).unwrap();

    let files = app.load_state(&[a1]).unwrap().materialize().files;

    assert_eq!(files["libs/lib"].kind, NodeKind::Subrepo);

    assert!(!files.contains_key("libs/lib/lib.txt"));

    assert!(!app.snapshot("status").unwrap().changed);

    let subs = app.subrepos().unwrap();

    assert_eq!(subs.len(), 1);

    assert_eq!(subs[0].actual.as_ref(), Some(&subs[0].pin));

    // Advance the nested repository: the parent sees a modified pin.

    let nested = Repo::open(&app_dir.join("libs/lib")).unwrap().with_home(root.join("home"));

    write(&app_dir.join("libs/lib"), "lib.txt", b"v2\n");

    let l2 = nested.commit("lib v2", &[]).unwrap();

    assert!(nested.push("origin", false).unwrap()[0].ok);

    let snap = app.snapshot("status").unwrap();

    assert_eq!(snap.statuses.iter().map(|s| (s.path.as_str(), s.status)).collect::<Vec<_>>(), vec![("libs/lib", ChangeStatus::Modified)]);

    let a2 = app.commit("bump lib", &[]).unwrap();

    // Checking out the older app state moves the nested repository back.

    let r = app.checkout(&[a1], false, "checkout").unwrap();

    assert!(r.notes.is_empty(), "{:?}", r.notes);

    assert_eq!(fs::read(app_dir.join("libs/lib/lib.txt")).unwrap(), b"v1\n");

    assert_eq!(Repo::open(&app_dir.join("libs/lib")).unwrap().bookmark_heads().unwrap(), vec![l1]);

    assert!(!app.snapshot("status").unwrap().changed);

    // A dirty nested repository is left alone and reported.

    write(&app_dir.join("libs/lib"), "scratch.txt", b"wip\n");

    let r = app.checkout(&[a2], false, "checkout").unwrap();

    assert!(r.notes.iter().any(|n| n.contains("uncommitted")), "{:?}", r.notes);

    assert_eq!(fs::read(app_dir.join("libs/lib/lib.txt")).unwrap(), b"v1\n");

    fs::remove_file(app_dir.join("libs/lib/scratch.txt")).unwrap();

    let r = app.submodule_update(false, &[]).unwrap();

    assert_eq!(r, vec![("libs/lib".to_string(), SubrepoSync::Updated)]);

    assert_eq!(fs::read(app_dir.join("libs/lib/lib.txt")).unwrap(), b"v2\n");

    let _ = l2;

    // A fresh clone of the app has the pin but no nested repository until update --init.

    assert!(app.push("origin", false).unwrap()[0].ok);

    let clone_dir = root.join("app-clone");

    let clone = Repo::clone(&app_url, &clone_dir).unwrap().with_home(root.join("home"));

    assert!(!clone_dir.join("libs/lib/.oxy").exists());

    assert_eq!(clone.submodule_update(false, &[]).unwrap(), vec![("libs/lib".to_string(), SubrepoSync::Missing)]);

    assert_eq!(clone.submodule_update(true, &[]).unwrap(), vec![("libs/lib".to_string(), SubrepoSync::Updated)]);

    assert_eq!(fs::read(clone_dir.join("libs/lib/lib.txt")).unwrap(), b"v2\n");

    assert!(!clone.snapshot("status").unwrap().changed);

    // Removing the subrepo leaves the directory and drops the node.

    clone.submodule_remove("libs/lib").unwrap();

    let snap = clone.snapshot("status").unwrap();

    assert!(snap.statuses.iter().any(|s| s.path == "libs/lib" && s.status == ChangeStatus::Removed), "{:?}", snap.statuses);

    let c = clone.commit("drop lib", &[]).unwrap();

    assert!(!clone.load_state(&[c]).unwrap().materialize().files.contains_key("libs/lib"));

    assert!(clone_dir.join("libs/lib/lib.txt").exists());

    assert!(!clone.snapshot("status").unwrap().changed, "an unregistered nested repository is ignored");

}

#[test]

fn git_submodules_import_and_export_as_gitlinks() {

    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 git_in = |d: &Path, args: &[&str]| -> String {

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

            .arg("-C")

            .arg(d)

            .args(["-c", "user.name=Grace", "-c", "[email protected]", "-c", "commit.gpgsign=false", "-c", "protocol.file.allow=always"])

            .args(args)

            .output()

            .unwrap();

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

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

    };

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

    fs::create_dir_all(&sub).unwrap();

    git_in(&sub, &["init", "-q", "-b", "main"]);

    write(&sub, "s.txt", b"sub\n");

    git_in(&sub, &["add", "."]);

    git_in(&sub, &["commit", "-q", "-m", "sub initial"]);

    let sub_sha = git_in(&sub, &["rev-parse", "HEAD"]);

    let g = root.join("main.git");

    fs::create_dir_all(&g).unwrap();

    git_in(&g, &["init", "-q", "-b", "main"]);

    write(&g, "README.md", b"# app\n");

    git_in(&g, &["add", "."]);

    git_in(&g, &["commit", "-q", "-m", "initial"]);

    git_in(&g, &["submodule", "add", "-q", sub.to_str().unwrap(), "vendor/sub"]);

    git_in(&g, &["commit", "-q", "-m", "add submodule"]);

    let dest = root.join("oxy");

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

    let rep = repo.import_git(&g, "main").unwrap();

    assert_eq!((rep.commits, rep.submodules), (2, 1));

    let files = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap().materialize().files;

    assert_eq!(files["vendor/sub"].kind, NodeKind::Subrepo);

    let FileContent::Opaque { blobs } = &files["vendor/sub"].content else { panic!() };

    assert_eq!(crate::subrepo::Pin::decode(&repo.read_blob(&blobs[0]).unwrap()).unwrap(), crate::subrepo::Pin::Git { sha: sub_sha.clone(), branch: "HEAD".into() });

    let modules = crate::subrepo::Modules::parse(&fs::read_to_string(dest.join(".oxymodules")).unwrap());

    assert_eq!(modules.entries["vendor/sub"].url, sub.to_string_lossy());

    assert!(modules.entries["vendor/sub"].git);

    assert!(files.contains_key(".gitmodules"), "the Git file is kept for round trips");

    assert!(!dest.join("vendor/sub/.git").exists(), "not cloned until update --init");

    assert!(!repo.snapshot("status").unwrap().changed);

    // update --init clones it at the pinned commit; status is unchanged.

    assert_eq!(repo.submodule_update(true, &[]).unwrap(), vec![("vendor/sub".to_string(), SubrepoSync::Updated)]);

    assert_eq!(git_in(&dest.join("vendor/sub"), &["rev-parse", "HEAD"]), sub_sha);

    assert!(!repo.snapshot("status").unwrap().changed);

    // Export writes the gitlink and .gitmodules back.

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

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

    assert_eq!(rep.skipped_subrepos, 0);

    let ls = git_in(&mirror, &["ls-tree", "main", "vendor/sub"]);

    assert!(ls.starts_with("160000 commit ") && ls.contains(&sub_sha), "{ls}");

    assert_eq!(git_in(&mirror, &["ls-tree", "--name-only", "main"]), ".gitmodules\nREADME.md\nvendor");

    let orig_tree = git_in(&g, &["rev-parse", "main^{tree}"]);

    assert_eq!(git_in(&mirror, &["rev-parse", "main^{tree}"]), orig_tree, "tree round trip");

}

                NodeKind::Symlink | NodeKind::Subrepo => FileContent::Opaque { blobs: self.live_blobs(&e.node) },

## 11a. Nested repositories (submodules)

A subrepo is another repository checked out at a path and pinned to a state,

Oxygen or Git. The pin is versioned like a file, so two people pinning

different states get an ordinary conflict.

```

oxy submodule add https://host/lib.git libs/lib     # Git or Oxygen URL; records .oxymodules

oxy commit -m "Add lib"                              # the pin is committed with the parent

oxy submodule status                                 # pin vs what is on disk

oxy submodule update --init                          # after a clone: fetch nested repositories

oxy submodule remove libs/lib                        # drop the node; the directory stays

```

Committing the parent records whatever the nested repository is at, and

checking out an older parent state moves the nested repository back, unless

it has uncommitted changes, which are never overwritten. An absent nested

repository keeps its pin until you run `update --init`. Git submodules

survive `oxy git import` as Git pins and go back out as gitlinks on export.

- [x] Subrepositories (spec §7.8, §23): node kind `subrepo`, pin encoding, `.oxymodules`, snapshot stops at nested repositories and reads their pin, checkout moves or leaves nested repositories, `oxy submodule add|update|status|remove`; Git import/export of gitlinks and `.gitmodules` (test with a mirror of tetriblox, never the live repository).

In the working copy a subrepo is a directory holding its own `.oxy/` (or `.git/`). The snapshot MUST NOT descend into it; it reads the nested repository's current bookmark heads (or Git `HEAD`) as the pin, so committing the parent records whatever the nested repository is at, as in Git. A nested repository that is neither registered in `.oxymodules` nor tracked as a subrepo node is left alone entirely: not walked, not added. A tracked subrepo whose directory is absent keeps its recorded pin, as a Git gitlink does. `oxy checkout` of the parent MUST move an existing nested repository to the pinned state (`oxy checkout` of those heads, or `git checkout --detach <sha>`), fetching from the recorded remote when objects are missing, MUST leave an absent nested repository absent until `oxy submodule update --init` clones it, and MUST never delete a nested repository, even when the target state has no node for it. A nested working copy with uncommitted changes is never overwritten: the checkout reports it and continues.

`oxy submodule add URL PATH [--bookmark NAME]` clones URL into PATH (an Oxygen remote when URL answers as one, otherwise Git), records `.oxymodules`, and the next snapshot adds the node pinned at the clone's heads. `oxy submodule update [--init] [PATH..]` brings nested repositories to their pins. `oxy submodule status` lists each subrepo with its pin and whether the nested repository matches it. `oxy submodule remove PATH` drops the `.oxymodules` entry and records that the node is to go with the next snapshot; the directory is left in place and thereafter ignored as unregistered.

- **Submodules.** A Git gitlink entry (mode `160000`) imports as a `subrepo` node with a Git pin (§7.8) and the matching `.gitmodules` entry becomes a `.oxymodules` entry with `branch` set to the submodule's configured branch when there is one. Export writes a Git pin back as a gitlink, keeps a tracked `.gitmodules` as is, and otherwise derives `.gitmodules` from `.oxymodules`; an Oxygen pin has no Git form and is omitted from the exported tree, which the export report counts.

| Subrepositories with Oxygen and Git pins, `.oxymodules`, Git gitlink import and export (§7.8, §23) | Implemented |

    /// Subrepositories: nested repositories pinned to a state

    Submodule {

        #[command(subcommand)]

        cmd: SubmoduleCmd,

    },

enum SubmoduleCmd {

    /// Clone URL (Oxygen or Git) into PATH and register it in .oxymodules

    Add {

        url: String,

        path: String,

        /// Bookmark (Oxygen) or branch (Git) to check out and track

        #[arg(long)]

        bookmark: Option<String>,

    },

    /// Bring nested repositories to their pins

    Update {

        /// Clone nested repositories that are absent

        #[arg(long)]

        init: bool,

        paths: Vec<String>,

    },

    /// List subrepos with their pins and on-disk state

    Status,

    /// Unregister PATH; the directory stays, the node goes with the next commit

    Remove { path: String },

}

#[derive(Subcommand)]

        Cmd::Submodule { cmd } => match cmd {

            SubmoduleCmd::Add { url, path, bookmark } => sync::submodule_add(&url, &path, bookmark.as_deref()),

            SubmoduleCmd::Update { init, paths } => sync::submodule_update(init, &paths),

            SubmoduleCmd::Status => sync::submodule_status(),

            SubmoduleCmd::Remove { path } => sync::submodule_remove(&path),

        },

    if r.submodules > 0 {

        println!("  {} {}", ui::note(), ui::dim(format!("{} submodule {} imported as subrepos with Git pins", r.submodules, if r.submodules == 1 { "entry" } else { "entries" })));

    if r.submodules > 0 {

        println!("  {} {}", ui::note(), ui::dim(format!("{} submodule {} imported as subrepos with Git pins", r.submodules, if r.submodules == 1 { "entry" } else { "entries" })));

    }

    Ok(0)

}

pub fn submodule_add(url: &str, path: &str, bookmark: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner(&format!("Cloning {url} into {path}…"));

    let pin = repo.submodule_add(url, path, bookmark)?;

    sp.done(&format!("{} subrepo {} {} {}", ui::done("Added"), ui::path(path), ui::dim(ui::glyph("→", "->")), ui::dim(pin.summary())));

    println!("  {} {}", ui::note(), ui::dim("recorded in .oxymodules; commit to pin it"));

    Ok(0)

}

pub fn submodule_update(init: bool, paths: &[String]) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner("Updating subrepos…");

    let results = repo.submodule_update(init, paths)?;

    sp.clear();

    if results.is_empty() {

        println!("{}", ui::dim("No subrepos."));

    }

    let mut code = 0;

    for (path, r) in results {

        use oxy_core::repo::SubrepoSync::*;

        let line = match r {

            Updated => ui::done("Updated"),

            UpToDate => ui::ok(format!("{} up to date", ui::glyph("✔", "*"))),

            Missing => {

                code = 1;

                ui::warn(format!("{} missing (pass --init to clone)", ui::glyph("⚠", "!")))

            }