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())
}
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"),
}
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");
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);
}