wowlab_common/

cli.rs

//! Shared CLI bootstrap utilities.

use wowlab_fs::{
    directory::{self, EntryKind},
    path::{Path, PathBuf},
    working_directory,
};

use super::output;

trait WorkspaceEnvironment {
    fn var(&self, key: &str) -> Option<String>;
    fn current_dir(&self) -> Option<PathBuf>;
}

struct ProcessWorkspaceEnvironment;

impl WorkspaceEnvironment for ProcessWorkspaceEnvironment {
    fn var(&self, key: &str) -> Option<String> {
        // #t(rust_ambient_syscall) process-environment adapter boundary
        std::env::var(key).ok()
    }

    fn current_dir(&self) -> Option<PathBuf> {
        working_directory::current().ok()
    }
}

/// Shared CLI context holding the workspace root and quiet-mode flag.
#[derive(Debug)]
pub struct CliApp {
    pub root: PathBuf,
    pub quiet: bool,
}

impl CliApp {
    #[must_use]
    pub fn crates_dir(&self) -> PathBuf {
        self.root.join("crates")
    }
}

/// Bootstrap a CLI tool: print the banner (unless quiet) and resolve the workspace root.
#[must_use]
pub fn boot(name: &str, version: &str, quiet: bool, root_env_var: &str) -> CliApp {
    if !quiet {
        output::banner(name, version);
    }

    let root = workspace_root(root_env_var);

    CliApp { root, quiet }
}

/// Find the workspace root by checking an explicit env var, `CARGO_MANIFEST_DIR`, then walking up from cwd.
///
/// # Panics
///
/// Panics when the process working directory cannot be determined.
#[must_use]
pub fn workspace_root(env_var: &str) -> PathBuf {
    workspace_root_with(&ProcessWorkspaceEnvironment, env_var)
        .expect("cannot determine working directory")
}

fn workspace_root_with(env: &impl WorkspaceEnvironment, env_var: &str) -> Option<PathBuf> {
    if let Some(dir) = env.var(env_var) {
        let root = PathBuf::from(dir);

        if is_directory(&root.join("crates")) {
            return Some(root);
        }
    }

    if let Some(dir) = env.var("CARGO_MANIFEST_DIR")
        && let Some(root) = PathBuf::from(dir)
            .parent()
            .and_then(|p| p.parent())
            .filter(|root| is_directory(&root.join("crates")))
    {
        return Some(root.to_path_buf());
    }

    let current_dir = env.current_dir()?;
    let mut candidate = current_dir.clone();

    loop {
        if entry_exists(&candidate.join("Cargo.toml")) && is_directory(&candidate.join("crates")) {
            return Some(candidate);
        }

        if !candidate.pop() {
            break;
        }
    }

    Some(current_dir)
}

fn entry_exists(path: &Path) -> bool {
    directory::inspect(path).is_ok_and(|entry| entry.is_some())
}

fn is_directory(path: &Path) -> bool {
    directory::inspect(path)
        .is_ok_and(|entry| entry.is_some_and(|entry| entry.kind() == EntryKind::Directory))
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;

    struct TestEnvironment {
        explicit_root: Option<PathBuf>,
        manifest_dir: Option<PathBuf>,
        current_dir: PathBuf,
    }

    impl WorkspaceEnvironment for TestEnvironment {
        fn var(&self, key: &str) -> Option<String> {
            match key {
                "TEST_ROOT" => self
                    .explicit_root
                    .as_ref()
                    .map(|path| path.display().to_string()),
                "CARGO_MANIFEST_DIR" => self
                    .manifest_dir
                    .as_ref()
                    .map(|path| path.display().to_string()),
                _ => None,
            }
        }

        fn current_dir(&self) -> Option<PathBuf> {
            Some(self.current_dir.clone())
        }
    }

    fn workspace(directory: &wowlab_fs::temporary::Directory, name: &str) -> Result<PathBuf> {
        let root = directory.path().join(name);

        directory::ensure(&root.join("crates")).or_fail()?;
        wowlab_fs::file::write_text(&root.join("Cargo.toml"), "[workspace]\n").or_fail()?;

        Ok(root)
    }

    #[gtest]
    fn explicit_root_has_precedence() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let explicit_root = workspace(&directory, "explicit").or_fail()?;
        let manifest_root = workspace(&directory, "manifest").or_fail()?;
        let current_root = workspace(&directory, "current").or_fail()?;
        let environment = TestEnvironment {
            explicit_root: Some(explicit_root.clone()),
            manifest_dir: Some(manifest_root.join("crates/common")),
            current_dir: current_root,
        };

        verify_that!(
            workspace_root_with(&environment, "TEST_ROOT").as_deref(),
            some(eq(&*explicit_root))
        )
    }

    #[gtest]
    fn manifest_directory_is_used_when_explicit_root_is_invalid() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let manifest_root = workspace(&directory, "manifest").or_fail()?;
        let current_root = workspace(&directory, "current").or_fail()?;
        let environment = TestEnvironment {
            explicit_root: Some(directory.path().join("missing")),
            manifest_dir: Some(manifest_root.join("crates/common")),
            current_dir: current_root,
        };

        verify_that!(
            workspace_root_with(&environment, "TEST_ROOT").as_deref(),
            some(eq(&*manifest_root))
        )
    }

    #[gtest]
    fn current_directory_walks_to_workspace_ancestor() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let root = workspace(&directory, "current").or_fail()?;
        let nested = root.join("crates/common/src");

        directory::ensure(&nested).or_fail()?;
        let environment = TestEnvironment {
            explicit_root: None,
            manifest_dir: None,
            current_dir: nested,
        };

        verify_that!(
            workspace_root_with(&environment, "TEST_ROOT").as_deref(),
            some(eq(&*root))
        )
    }

    #[gtest]
    fn current_directory_is_the_fallback_without_workspace_markers() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let current_dir = directory.path().join("plain/directory");

        directory::ensure(&current_dir).or_fail()?;
        let environment = TestEnvironment {
            explicit_root: None,
            manifest_dir: None,
            current_dir: current_dir.clone(),
        };

        verify_that!(
            workspace_root_with(&environment, "TEST_ROOT").as_deref(),
            some(eq(&*current_dir))
        )
    }
}