cargo-telar 0.2.2

Cargo subcommand for Telar apps: dev server with hot reload, and packaging into native installers.
//! `cargo telar doctor`: what this machine has, and what a build or a bundle would still need.

use std::process::Command;

use super::android::{android_sdk_root, installed_android_platforms, resolve_ndk_root};
use super::config::{
    WEB_PROFILE_TOML, backend_as_str, find_package_dir, has_web_profile, missing_devtools_note,
    missing_workshop_note, moved_features_hint_for, read_manifest_telar, resolve_package,
    try_load_config,
};

struct Doctor {
    warnings: usize,
    errors: usize,
}

impl Doctor {
    fn new() -> Self {
        Self {
            warnings: 0,
            errors: 0,
        }
    }

    fn section(&self, title: &str) {
        println!("\n{title}");
    }

    fn info(&self, label: &str, detail: &str) {
        println!("  \u{2022} {label}: {detail}");
    }

    fn ok(&self, label: &str, detail: &str) {
        println!("  \u{2713} {label}: {detail}");
    }

    fn warn(&mut self, label: &str, detail: &str) {
        self.warnings += 1;
        println!("  \u{26a0} {label}: {detail}");
    }

    fn fail(&mut self, label: &str, detail: &str) {
        self.errors += 1;
        println!("  \u{2717} {label}: {detail}");
    }
}

fn command_first_line(program: &str, args: &[&str]) -> Option<String> {
    let output = Command::new(program).args(args).output().ok()?;
    if !output.status.success() {
        return None;
    }
    let stream = if output.stdout.is_empty() {
        output.stderr
    } else {
        output.stdout
    };
    let text = String::from_utf8_lossy(&stream);
    Some(text.lines().next().unwrap_or("").trim().to_string())
}

/// Whether a linker faster than the default is installed. The name probed is the driver's, not the package's — `-fuse-ld=lld` makes the C compiler look for `ld.lld` on PATH, so probing `lld` would report one that the link would then fail to find.
fn fast_linker() -> Option<&'static str> {
    [("mold", "mold"), ("lld", "ld.lld")]
        .into_iter()
        .find(|(_, program)| command_first_line(program, &["--version"]).is_some())
        .map(|(flavor, _)| flavor)
}

fn rustup_has_target(target: &str) -> Option<bool> {
    let output = Command::new("rustup")
        .args(["target", "list", "--installed"])
        .output()
        .ok()?;
    if !output.status.success() {
        return None;
    }
    let text = String::from_utf8_lossy(&output.stdout);
    Some(text.lines().any(|line| line.trim() == target))
}

pub(crate) fn run_doctor_cmd() -> ! {
    let mut doc = Doctor::new();
    println!("cargo telar doctor");

    doc.section("Toolchain");
    match command_first_line("cargo", &["--version"]) {
        Some(v) => doc.ok("cargo", &v),
        None => doc.fail("cargo", "not found on PATH"),
    }
    match command_first_line("rustc", &["--version"]) {
        Some(v) => doc.ok("rustc", &v),
        None => doc.fail("rustc", "not found on PATH"),
    }
    // Reported, never imposed: the linker a machine builds with belongs to its own cargo config, and swapping it here would be choosing for the whole workspace.
    if cfg!(target_os = "linux") {
        match fast_linker() {
            Some(found) => doc.info("fast linker installed", found),
            None => doc.info(
                "fast linker installed",
                "none — `mold` or `lld` shortens the relink in front of every hot reload (see \"Build profiles\" in the README)",
            ),
        }
    }

    doc.section("Project");
    let cwd = std::env::current_dir().unwrap_or_default();
    match telar_project::find_workspace_root(&cwd) {
        Some(root) => doc.info("workspace root", &root.display().to_string()),
        None => doc.info("workspace root", "none (standalone package)"),
    }
    let package_dir = find_package_dir(&[]);
    let config = try_load_config(&package_dir).unwrap_or_default();
    let telar_toml = package_dir.join("telar.toml");
    if telar_toml.exists() {
        doc.ok("telar.toml", &telar_toml.display().to_string());
    } else {
        doc.info("telar.toml", "not found (using defaults)");
    }
    match read_manifest_telar(&package_dir) {
        Ok(Some(_)) => doc.info("[package.metadata.telar]", "present"),
        Ok(None) => doc.info("[package.metadata.telar]", "not set"),
        Err(e) => doc.fail("[package.metadata.telar]", &e.to_string()),
    }
    doc.info(
        "config precedence",
        "CLI flags > telar.toml > [package.metadata.telar] > defaults",
    );
    match telar_project::prelude_problems(&package_dir) {
        Ok(problems) if !problems.is_empty() => {
            for problem in problems {
                let declaration = &problem.declaration;
                doc.fail(
                    "[telar] prelude",
                    &format!(
                        "{}:{}: {} — {}",
                        declaration.file.display(),
                        declaration.line,
                        problem.message,
                        problem.help
                    ),
                );
            }
        }
        Ok(_) => match telar_project::resolve_prelude(&package_dir) {
            Ok(prelude) if !prelude.is_empty() => {
                let entries: Vec<String> = prelude.iter().map(ToString::to_string).collect();
                doc.ok("[telar] prelude", &entries.join(", "));
            }
            _ => doc.info("[telar] prelude", "none"),
        },
        Err(e) => doc.fail("telar.toml", &e.to_string()),
    }
    if let Some(hint) = moved_features_hint_for(&package_dir) {
        doc.warn("moved telar features", &hint.replace('\n', "\n      "));
    }
    let resolved = resolve_package(&[]);
    if telar_project::declares_optional_dependency(
        &resolved.package_dir,
        telar_project::DEVTOOLS_PACKAGE,
    ) {
        doc.ok(
            "devtools overlay",
            "`telar-devtools` is an optional dependency, which `cargo telar dev` and `cargo telar preview` turn on",
        );
    } else if resolved.package.is_some() {
        doc.warn("devtools overlay", &missing_devtools_note(&resolved.name()));
    }
    if telar_project::declares_optional_dependency(
        &resolved.package_dir,
        telar_project::WORKSHOP_PACKAGE,
    ) {
        doc.ok(
            "preview workshop",
            "`telar-workshop` is an optional dependency, which `cargo telar preview` turns on",
        );
    } else if resolved.package.is_some() {
        doc.warn("preview workshop", &missing_workshop_note(&resolved.name()));
    }
    match telar_project::previews_include_problems(&package_dir) {
        Ok(problems) if !problems.is_empty() => {
            for problem in problems {
                let declaration = &problem.declaration;
                doc.fail(
                    "[telar.previews] include",
                    &format!(
                        "{}:{}: {} — {}",
                        declaration.file.display(),
                        declaration.line,
                        problem.message,
                        problem.help
                    ),
                );
            }
        }
        Ok(_) => match telar_project::TelarManifest::load(&package_dir) {
            Ok(manifest) if !manifest.telar.previews.include().is_empty() => {
                let entries: Vec<String> = manifest
                    .telar
                    .previews
                    .include()
                    .iter()
                    .map(ToString::to_string)
                    .collect();
                doc.ok("[telar.previews] include", &entries.join(", "));
            }
            _ => {}
        },
        Err(_) => {}
    }
    if resolved.targets_web() {
        if has_web_profile(&resolved.workspace_root) {
            doc.ok("[profile.web]", "present");
        } else {
            doc.fail(
                "[profile.web]",
                &format!(
                    "missing from {} — a release web build passes `--profile web` and fails without it. Add:\n      {}",
                    resolved.workspace_root.join("Cargo.toml").display(),
                    WEB_PROFILE_TOML.trim_end().replace('\n', "\n      ")
                ),
            );
        }
    }

    doc.section("Desktop");
    let backend = config
        .backend
        .map(backend_as_str)
        .unwrap_or("auto (default)");
    doc.info("configured backend", backend);
    doc.info("software renderer", "always available");
    doc.info(
        "hardware renderer",
        "needs a working GPU/driver, verified at runtime",
    );

    doc.section("Packaging");
    doc.info("dir/apk", "built-in");
    // Only the current host's native-installer tools are relevant: rsx does not cross-compile.
    if cfg!(target_os = "linux") {
        match command_first_line("dpkg-deb", &["--version"]) {
            Some(v) => doc.ok("dpkg-deb", &v),
            None => doc.info("dpkg-deb", "not found (needed for --format deb)"),
        }
        match command_first_line("appimagetool", &["--version"]) {
            Some(v) => doc.ok("appimagetool", &v),
            None => doc.info("appimagetool", "not found (needed for --format appimage)"),
        }
    }
    if cfg!(target_os = "macos") {
        match command_first_line("hdiutil", &["info"]) {
            Some(_) => doc.ok("hdiutil", "available"),
            None => doc.info("hdiutil", "not found (needed for --format dmg)"),
        }
    }
    if cfg!(target_os = "windows") {
        match command_first_line("makensis", &["/VERSION"]) {
            Some(v) => doc.ok("makensis", &v),
            None => doc.info("makensis", "not found (needed for --format nsis)"),
        }
    }

    doc.section("Android (only needed for --target android)");
    match android_sdk_root() {
        Some(sdk) if sdk.exists() => {
            doc.ok("Android SDK", &sdk.display().to_string());
            let platforms = installed_android_platforms(&sdk);
            if platforms.is_empty() {
                doc.warn(
                    "installed SDK platforms",
                    "none found — `sdkmanager \"platforms;android-36\"`",
                );
            } else {
                let list = platforms
                    .iter()
                    .map(u32::to_string)
                    .collect::<Vec<_>>()
                    .join(", ");
                doc.info("installed SDK platforms", &list);
            }
        }
        Some(sdk) => doc.warn(
            "Android SDK",
            &format!("{} (path does not exist)", sdk.display()),
        ),
        None => doc.warn("Android SDK", "not set (ANDROID_HOME / ANDROID_SDK_ROOT)"),
    }
    match resolve_ndk_root() {
        Some(ndk) => doc.ok("Android NDK", &ndk),
        None => doc.warn(
            "Android NDK",
            "not found (ANDROID_NDK_ROOT or $ANDROID_HOME/ndk/*)",
        ),
    }
    match command_first_line("cargo", &["apk", "--version"]) {
        Some(v) => doc.ok("cargo-apk", &v),
        None => doc.warn("cargo-apk", "not found (`cargo install cargo-apk`)"),
    }
    match rustup_has_target("aarch64-linux-android") {
        Some(true) => doc.ok("rust target aarch64-linux-android", "installed"),
        Some(false) => doc.warn(
            "rust target aarch64-linux-android",
            "missing (`rustup target add aarch64-linux-android`)",
        ),
        None => doc.warn(
            "rust target aarch64-linux-android",
            "rustup not found, cannot verify",
        ),
    }
    match command_first_line("adb", &["--version"]) {
        Some(v) => doc.ok("adb", &v),
        None => doc.warn("adb", "not found (Android platform-tools)"),
    }

    println!();
    if doc.errors > 0 {
        println!(
            "\u{2717} {} error(s), {} warning(s)",
            doc.errors, doc.warnings
        );
        std::process::exit(1);
    } else if doc.warnings > 0 {
        println!("\u{26a0} {} warning(s)", doc.warnings);
        std::process::exit(0);
    }
    println!("\u{2713} everything looks good");
    std::process::exit(0);
}