use std::collections::BTreeMap;
use super::{Builder, sorted_keys};
use crate::cli::{GraphFormat, ToolAction};
use crate::color;
use crate::json_output;
use crate::tables;
use crate::tool_lock;
use anyhow::{Context, Result, bail};
use std::fmt::Write as FmtWrite;
use std::io::Write;
use std::process::Command;
pub(super) fn is_system_package_installed(
ctx: &crate::build_context::BuildContext,
pkg: &str,
) -> bool {
let probe = |program: &str, args: &[&str]| -> bool {
let mut cmd = Command::new(program);
cmd.args(args);
crate::processor::run_command_capture(ctx, &cmd).is_ok_and(|o| o.status.success())
};
if which::which("dpkg-query").is_ok() {
let mut cmd = Command::new("dpkg-query");
cmd.args(["-W", "-f", "${Status}", pkg]);
return crate::processor::run_command_capture(ctx, &cmd).is_ok_and(|o| {
o.status.success() && dpkg_status_means_installed(&String::from_utf8_lossy(&o.stdout))
});
}
if which::which("rpm").is_ok() {
return probe("rpm", &["-q", pkg]);
}
if which::which("pacman").is_ok() {
return probe("pacman", &["-Q", pkg]);
}
if which::which("brew").is_ok() {
return probe("brew", &["list", pkg]);
}
which::which(pkg).is_ok()
}
fn dpkg_status_means_installed(status: &str) -> bool {
status.split_whitespace().nth(2) == Some("installed")
}
fn is_installable_tool_name(tool: &str) -> bool {
!tool.contains('/')
}
fn package_probe_succeeds(
ctx: &crate::build_context::BuildContext,
program: &str,
args: &[&str],
) -> bool {
let mut cmd = Command::new(program);
cmd.args(args);
crate::processor::run_command_capture(ctx, &cmd).is_ok_and(|o| o.status.success())
}
fn uv_export_reqs(ctx: &crate::build_context::BuildContext) -> Result<Vec<String>> {
let mut cmd = Command::new("uv");
cmd.args([
"export",
"--frozen",
"--no-hashes",
"--no-annotate",
"--no-header",
"--no-emit-project",
]);
let out = crate::processor::run_command_capture(ctx, &cmd).context(
"failed to run `uv export` — is uv installed? (`rsconstruct tool install uv`, \
or set `python_installer = \"pip\"` under [dependencies] to install with pip)",
)?;
if !out.status.success() {
bail!(
"`uv export` failed: {}",
String::from_utf8_lossy(&out.stderr).trim()
);
}
Ok(crate::config::parse_uv_export(&String::from_utf8_lossy(
&out.stdout,
)))
}
fn tool_runtime(tool: &str) -> &'static str {
crate::tools::tool_runtime(tool).unwrap_or_else(|| {
debug_assert!(false, "tool_runtime: unrecognized tool '{tool}'");
"system"
})
}
pub fn tools_no_config(
ctx: &crate::build_context::BuildContext,
action: ToolAction,
verbose: bool,
) -> Result<()> {
let processors = super::create_all_default_processors()?;
run_tools_command(ctx, &processors, &|_name| true, action, verbose, None)
}
fn project_wanted(
builder: &Builder,
processors: &crate::processor::ProcessorMap,
is_enabled: &dyn Fn(&str) -> bool,
) -> Result<tool_lock::Wanted> {
tool_lock::collect_wanted(
processors,
is_enabled,
&builder.config.dependencies,
std::path::Path::new("."),
)
}
fn lock_for_install(
ctx: &crate::build_context::BuildContext,
wanted: &tool_lock::Wanted,
verbose: bool,
) -> Result<(
tool_lock::ToolLock,
std::collections::BTreeSet<(String, String)>,
)> {
let mode = tool_lock::LockMode::for_environment();
let synced = tool_lock::sync(ctx, wanted, mode, verbose)?;
synced.report();
let drift = if mode == tool_lock::LockMode::Locked {
tool_lock::mismatches(ctx, &synced.lock, wanted)
.into_iter()
.map(|m| (m.method, m.name))
.collect()
} else {
std::collections::BTreeSet::new()
};
Ok((synced.lock, drift))
}
fn drift_key(method: &str, package: &str) -> (String, String) {
match method {
"pip" | "uv" => (
"pip".to_string(),
crate::config::normalized_distribution_name(package),
),
_ => (method.to_string(), package.to_string()),
}
}
impl Builder {
pub fn verify_tool_versions(&self, ctx: &crate::build_context::BuildContext) -> Result<()> {
let processors = self.create_processors()?;
let wanted = project_wanted(self, &processors, &|_name| true)?;
tool_lock::verify(ctx, &wanted).map(|_| ())
}
pub fn tools(
&self,
ctx: &crate::build_context::BuildContext,
action: ToolAction,
verbose: bool,
) -> Result<()> {
let processors = self.create_processors()?;
run_tools_command(ctx, &processors, &|_name| true, action, verbose, Some(self))
}
}
fn run_tools_command(
ctx: &crate::build_context::BuildContext,
processors: &crate::processor::ProcessorMap,
is_enabled: &dyn Fn(&str) -> bool,
action: ToolAction,
verbose: bool,
builder: Option<&Builder>,
) -> Result<()> {
let show_all = matches!(&action, ToolAction::ListConfigured { all: true, .. });
let show_methods = matches!(
&action,
ToolAction::ListConfigured { methods: true, .. } | ToolAction::List { methods: true }
);
let install_interactive = matches!(
&action,
ToolAction::Install {
interactive: true,
..
}
);
let install_no_eatmydata = matches!(
&action,
ToolAction::Install {
no_eatmydata: true,
..
}
);
let install_all = matches!(&action, ToolAction::Install { all: true, .. });
let config_enables_eatmydata = builder.is_some_and(|b| b.config.dependencies.eatmydata)
|| (install_all && crate::config::running_in_ci());
let install_use_eatmydata =
!install_no_eatmydata && config_enables_eatmydata && which::which("eatmydata").is_ok();
let mut tool_map: BTreeMap<String, Vec<String>> = BTreeMap::new();
for name in sorted_keys(processors) {
if !show_all && !is_enabled(name) {
continue;
}
for tool in processors[name].required_tools() {
let procs = tool_map.entry(tool).or_default();
if !procs.contains(name) {
procs.push(name.clone());
}
}
}
match action {
ToolAction::List { .. } => {
if crate::json_output::is_json_mode() {
let entries: Vec<json_output::ToolListEntry> = crate::tools::all_tools()
.map(|info| json_output::ToolListEntry {
tool: info.name.to_string(),
installed: which::which(info.name).is_ok(),
runtime: info.runtime.to_string(),
processor: Vec::new(),
install_methods: info
.install_methods
.iter()
.map(|m| json_output::ToolInstallMethodEntry {
method: m.method.to_string(),
command: m.command(),
})
.collect(),
})
.collect();
println!("{}", serde_json::to_string_pretty(&entries)?);
return Ok(());
}
let mut tools: Vec<&crate::tools::ToolInfo> = crate::tools::all_tools().collect();
tools.sort_by_key(|t| t.name);
let show_install = verbose || show_methods;
let rows: Vec<Vec<String>> = tools
.iter()
.map(|info| {
let status = if which::which(info.name).is_ok() {
color::green("installed")
} else {
color::red("missing")
};
let mut row = vec![
info.name.to_string(),
status.to_string(),
info.runtime.to_string(),
];
let install_str = if show_methods {
let methods: Vec<String> = info
.install_methods
.iter()
.map(|m| format!("{}: {}", m.method, m.command()))
.collect();
if methods.is_empty() {
"?".to_string()
} else {
methods.join(" | ")
}
} else {
info.install_methods
.first()
.map_or_else(|| "?".to_string(), crate::tools::InstallMethod::command)
};
row.push(install_str);
row
})
.collect();
tables::print(&tables::defs::TOOL_LIST, show_install, &rows);
}
ToolAction::ListConfigured { .. } => {
if crate::json_output::is_json_mode() {
let entries: Vec<json_output::ToolListEntry> = tool_map
.iter()
.map(|(tool, procs)| {
let info = crate::tools::tool_info(tool);
let install_methods = info
.map(|i| {
i.install_methods
.iter()
.map(|m| json_output::ToolInstallMethodEntry {
method: m.method.to_string(),
command: m.command(),
})
.collect()
})
.unwrap_or_default();
json_output::ToolListEntry {
tool: tool.clone(),
installed: which::which(tool).is_ok(),
runtime: info.map_or("unknown", |i| i.runtime).to_string(),
processor: procs.clone(),
install_methods,
}
})
.collect();
println!("{}", serde_json::to_string_pretty(&entries)?);
return Ok(());
}
for (tool, procs) in &tool_map {
let installed = if which::which(tool).is_ok() {
color::green("installed")
} else {
color::red("missing")
};
let info = crate::tools::tool_info(tool);
let runtime = info.map_or("unknown", |i| i.runtime);
let install_str = if show_methods {
let methods: Vec<String> = info
.map(|i| {
i.install_methods
.iter()
.map(|m| format!("{}: {}", m.method, m.command()))
.collect()
})
.unwrap_or_default();
if methods.is_empty() {
"?".to_string()
} else {
methods.join(" | ")
}
} else {
info.and_then(|i| i.install_methods.first())
.map_or_else(|| "?".to_string(), crate::tools::InstallMethod::command)
};
println!(
"{} [{}] [{}] ({}) — {}",
tool,
installed,
runtime,
procs.join(", "),
color::dim(&install_str)
);
}
}
ToolAction::Check => {
let builder = builder.ok_or_else(|| {
anyhow::anyhow!("tool check requires a project with rsconstruct.toml")
})?;
let wanted = project_wanted(builder, processors, is_enabled)?;
tool_lock::verify(ctx, &wanted)?;
if crate::json_output::is_json_mode() {
let out = serde_json::json!({
"lock_file": tool_lock::LOCK_FILE,
"match": true,
});
println!("{}", serde_json::to_string_pretty(&out)?);
} else {
println!(
"{}",
color::green(&format!("Installed tools match {}.", tool_lock::LOCK_FILE))
);
}
}
ToolAction::Lock { upgrade } => {
let builder = builder.ok_or_else(|| {
anyhow::anyhow!("tool lock requires a project with rsconstruct.toml")
})?;
let wanted = project_wanted(builder, processors, is_enabled)?;
let synced = match upgrade {
None => tool_lock::sync(ctx, &wanted, tool_lock::LockMode::Fill, verbose)?,
Some(names) if names.is_empty() => {
tool_lock::sync(ctx, &wanted, tool_lock::LockMode::Upgrade, verbose)?
}
Some(names) => tool_lock::upgrade_named(ctx, &wanted, &names, verbose)?,
};
if crate::json_output::is_json_mode() {
let out = serde_json::json!({
"lock_file": tool_lock::LOCK_FILE,
"created": synced.created,
"changes": synced.changes,
});
println!("{}", serde_json::to_string_pretty(&out)?);
} else if synced.changes.is_empty() {
println!("{} is up to date.", color::bold(tool_lock::LOCK_FILE));
} else {
synced.report();
}
}
ToolAction::Graph { format, view } => {
if view {
let html_content = tools_graph_html(&tool_map);
let html_path = std::env::temp_dir().join("rsconstruct_tools_graph.html");
std::fs::write(&html_path, &html_content).with_context(|| {
format!("Failed to write HTML file: {}", html_path.display())
})?;
if let Some(b) = builder {
b.open_file(&html_path)?;
println!("Opened tools graph in browser: {}", html_path.display());
} else {
println!("Wrote tools graph to: {}", html_path.display());
}
} else {
let effective_format = if crate::json_output::is_json_mode() {
GraphFormat::Json
} else {
format
};
let output = match effective_format {
GraphFormat::Dot => tools_graph_dot(&tool_map),
GraphFormat::Mermaid => tools_graph_mermaid(&tool_map),
GraphFormat::Text => tools_graph_text(&tool_map),
GraphFormat::Json => tools_graph_json(&tool_map)?,
GraphFormat::Svg => tools_graph_svg(ctx, &tool_map)?,
};
println!("{output}");
}
}
ToolAction::Stats => {
let mut tool_stats: Vec<json_output::ToolStat> = Vec::new();
for (tool, procs) in &tool_map {
let installed = which::which(tool).is_ok();
let runtime = tool_runtime(tool).to_string();
let install_command = crate::tools::tool_install_command(tool);
tool_stats.push(json_output::ToolStat {
name: tool.clone(),
installed,
runtime,
processor: procs.clone(),
install_command,
});
}
let mut runtime_map: BTreeMap<&str, (usize, usize)> = BTreeMap::new();
for stat in &tool_stats {
let entry = runtime_map
.entry(tool_runtime(&stat.name))
.or_insert((0, 0));
entry.0 += 1;
if stat.installed {
entry.1 += 1;
}
}
let runtime_stats: Vec<json_output::RuntimeStat> = runtime_map
.iter()
.map(|(runtime, (total, installed))| json_output::RuntimeStat {
runtime: runtime.to_string(),
total: *total,
installed: *installed,
missing: total - installed,
})
.collect();
let total_tools = tool_stats.len();
let installed_count = tool_stats.iter().filter(|t| t.installed).count();
let missing_count = total_tools - installed_count;
if crate::json_output::is_json_mode() {
let output = json_output::ToolStatsOutput {
tools: tool_stats,
runtimes: runtime_stats,
summary: json_output::StatsSummary {
total_tools,
installed: installed_count,
missing: missing_count,
},
};
println!("{}", serde_json::to_string_pretty(&output)?);
} else {
let rows: Vec<Vec<String>> = tool_stats
.iter()
.map(|stat| {
let status = if stat.installed {
color::green("\u{2713}")
} else {
color::red("\u{2717}")
};
let procs = stat
.processor
.iter()
.map(|n| tables::short_processor_name(n))
.collect::<Vec<_>>()
.join(", ");
let install = stat.install_command.as_deref().unwrap_or("").to_string();
vec![stat.name.clone(), status.to_string(), procs, install]
})
.collect();
tables::print(&tables::defs::TOOL_STATS, false, &rows);
println!();
println!("Runtime summary:");
let runtime_display: &[(&str, &str)] = &[
("python", "Python"),
("node", "Node.js"),
("ruby", "Ruby"),
("rust", "Rust"),
("perl", "Perl"),
("jvm", "JVM"),
("system", "System"),
];
let rt_rows: Vec<Vec<String>> = runtime_display
.iter()
.filter_map(|(key, label)| {
runtime_stats.iter().find(|r| r.runtime == *key).map(|rs| {
let status_str = format!("{}/{}", rs.installed, rs.total);
let line = if rs.missing > 0 {
color::yellow(&status_str)
} else {
color::green(&status_str)
};
vec![label.to_string(), line.to_string()]
})
})
.collect();
tables::print(&tables::defs::TOOL_RUNTIMES, false, &rt_rows);
println!();
let total_line = format!("Total: {installed_count}/{total_tools} tools installed");
if missing_count > 0 {
println!("{}", color::yellow(&total_line));
} else {
println!("{}", color::green(&total_line));
}
}
}
ToolAction::Install { name, all, .. } => {
let (lock, drift) = match builder {
Some(b) if !all => {
let wanted = project_wanted(b, processors, is_enabled)?;
let (lock, drift) = lock_for_install(ctx, &wanted, verbose)?;
(Some(lock), drift)
}
_ => (None, std::collections::BTreeSet::new()),
};
let missing_tools: Vec<(&str, &crate::tools::InstallMethod)> = if all {
let mut missing = Vec::new();
let mut manual_only: Vec<&crate::tools::ToolInfo> = Vec::new();
for info in crate::tools::all_tools() {
if which::which(info.name).is_ok() {
continue;
}
match info.install_methods.iter().find(|m| m.method != "manual") {
Some(method) => missing.push((info.name, method)),
None => manual_only.push(info),
}
}
if !manual_only.is_empty() {
eprintln!(
"{}: {} tool(s) have no automatable install method:",
color::red("Error"),
manual_only.len(),
);
for info in &manual_only {
let instructions = info
.install_methods
.first()
.map_or("no install method known", |m| m.package);
eprintln!(" {} — {}", color::bold(info.name), instructions);
}
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ToolError,
format!(
"Cannot install {} tool(s) automatically: {}",
manual_only.len(),
manual_only
.iter()
.map(|i| i.name)
.collect::<Vec<_>>()
.join(", "),
),
)
.into());
}
if missing.is_empty() {
println!(
"{}",
color::green("All registry tools are already installed.")
);
return Ok(());
}
missing
} else if let Some(ref name) = name {
if let Some(info) = crate::tools::tool_info(name) {
if let Some(method) = info.install_methods.first() {
vec![(info.name, method)]
} else {
eprintln!("{}: No install method for '{}'", color::red("Error"), name);
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ToolError,
format!("No install method known for tool '{name}'"),
)
.into());
}
} else {
eprintln!("{}: Unknown tool '{}'", color::red("Error"), name);
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ToolError,
format!("Unknown tool '{name}'"),
)
.into());
}
} else {
let mut install_tools: BTreeMap<String, Vec<String>> = BTreeMap::new();
for name in sorted_keys(processors) {
if !is_enabled(name) {
continue;
}
for tool in processors[name].required_tools() {
let procs = install_tools.entry(tool).or_default();
if !procs.contains(name) {
procs.push(name.clone());
}
}
}
let mut missing = Vec::new();
let mut any_unknown = false;
for tool_name in install_tools.keys() {
if !is_installable_tool_name(tool_name) {
continue;
}
let drifted = crate::tools::tool_info(tool_name)
.and_then(|info| info.install_methods.first())
.is_some_and(|m| drift.contains(&drift_key(m.method, m.package)));
if which::which(tool_name).is_ok() && !drifted {
continue;
}
match crate::tools::tool_info(tool_name) {
Some(info) if !info.install_methods.is_empty() => {
missing.push((info.name, &info.install_methods[0]));
}
_ => {
eprintln!(
"{}: No install method for '{}'",
color::red("Error"),
tool_name
);
any_unknown = true;
}
}
}
if any_unknown {
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ToolError,
"Some tools have no known install procedure",
)
.into());
}
if missing.is_empty() {
println!("{}", color::green("All tools are already installed."));
return Ok(());
}
missing
};
let mut by_method: BTreeMap<&str, Vec<String>> = BTreeMap::new();
for (_tool_name, method) in &missing_tools {
let package = lock.as_ref().map_or_else(
|| method.package.to_string(),
|l| l.pinned(method.method, method.package),
);
by_method.entry(method.method).or_default().push(package);
}
println!(
"Missing {} tool(s), grouped by install method:",
missing_tools.len()
);
println!();
let method_order = &[
"pip", "apt", "brew", "npm", "cargo", "gem", "snap", "binary", "manual",
];
let ctx = crate::tools::InstallCtx {
verbose,
use_eatmydata: install_use_eatmydata,
binary_pins: lock.as_ref().map(|l| l.binary.clone()).unwrap_or_default(),
};
let mut any_failed = false;
for method in method_order {
let Some(packages) = by_method.get(method) else {
continue;
};
let packages: Vec<&str> = packages.iter().map(String::as_str).collect();
println!(
" {} {}",
color::bold(&format!("[{method}]")),
packages.join(", ")
);
for argv in crate::tools::describe(method, &packages) {
println!(" {}", color::dim(&argv.join(" ")));
}
}
println!();
if install_interactive {
print!("Proceed? [y/N] ");
std::io::stdout()
.flush()
.context("Failed to flush stdout before install prompt")?;
let mut answer = String::new();
std::io::stdin()
.read_line(&mut answer)
.context("Failed to read install prompt answer")?;
let answer = answer.trim().to_lowercase();
if answer != "y" && answer != "yes" {
println!("Aborted.");
return Ok(());
}
}
for method in method_order {
let Some(packages) = by_method.get(method) else {
continue;
};
let packages: Vec<&str> = packages.iter().map(String::as_str).collect();
match crate::tools::run(method, &packages, &ctx) {
Ok(()) => println!(
"{} [{}] {}",
color::green("OK"),
method,
packages.join(", ")
),
Err(e) => {
println!(
"{} [{}] {}: {:#}",
color::red("FAILED"),
method,
packages.join(", "),
e
);
any_failed = true;
}
}
}
if any_failed {
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ToolError,
"Some install commands failed",
)
.into());
}
println!("{}", color::green("All tools installed successfully."));
}
ToolAction::InstallDeps {
interactive,
no_eatmydata,
} => {
let builder = builder.ok_or_else(|| {
anyhow::anyhow!("install-deps requires a project with rsconstruct.toml")
})?;
let config = &builder.config.dependencies;
let wanted = project_wanted(builder, processors, is_enabled)?;
let (lock, drift) = lock_for_install(ctx, &wanted, verbose)?;
let use_eatmydata =
!no_eatmydata && config.eatmydata && which::which("eatmydata").is_ok();
let python_installer = config.python_installer;
let pip_deps = match python_installer {
crate::config::PythonInstaller::Uv => {
let has_python_deps =
std::path::Path::new("pyproject.toml").exists() || !config.pip.is_empty();
if has_python_deps && which::which("uv").is_err() {
println!("uv not found on PATH; bootstrapping it with pip");
crate::tools::run(
"pip",
&["uv"],
&crate::tools::InstallCtx {
verbose,
use_eatmydata: false,
binary_pins: BTreeMap::new(),
},
)
.context(
"failed to bootstrap uv with pip; install uv manually \
or set `python_installer = \"pip\"` under [dependencies]",
)?;
}
config.effective_pip_uv(std::path::Path::new("."), || uv_export_reqs(ctx))?
}
crate::config::PythonInstaller::Pip => {
config.effective_pip(std::path::Path::new("."))?
}
};
let pip_deps: Vec<String> = pip_deps.iter().map(|r| lock.pinned("pip", r)).collect();
let node_deps = config.node_deps(std::path::Path::new("."))?;
if config.is_empty() && pip_deps.is_empty() && node_deps.is_empty() {
println!(
"No dependencies declared in [dependencies], pyproject.toml or package.json."
);
return Ok(());
}
let system_method: &str = if which::which("apt-get").is_ok() {
"apt"
} else if which::which("dnf").is_ok() {
"dnf"
} else if which::which("pacman").is_ok() {
"pacman"
} else if which::which("brew").is_ok() {
"brew"
} else if !config.system.is_empty() {
bail!(
"No supported package manager found (apt-get, dnf, pacman, brew); install these system packages manually: {}",
config.system.join(", ")
);
} else {
"apt" };
let mut skipped: Vec<String> = Vec::new();
let mut groups: Vec<(&str, Vec<String>)> = Vec::new();
let system_missing: Vec<String> = config
.system
.iter()
.filter(|pkg| {
let installed = is_system_package_installed(ctx, pkg);
if installed {
skipped.push(format!("[system] {pkg}"));
}
!installed
})
.cloned()
.collect();
if !system_missing.is_empty() {
groups.push((system_method, system_missing));
}
match python_installer {
crate::config::PythonInstaller::Uv => {
if !pip_deps.is_empty() {
groups.push(("uv", pip_deps));
}
}
crate::config::PythonInstaller::Pip => {
let pip_missing: Vec<String> = pip_deps
.iter()
.filter(|pkg| {
if pkg.contains('[') {
return true;
}
let name = crate::config::normalized_distribution_name(pkg);
let installed =
package_probe_succeeds(ctx, "pip", &["show", name.as_str()])
&& !drift.contains(&drift_key("pip", pkg));
if installed {
skipped.push(format!("[pip] {pkg}"));
}
!installed
})
.cloned()
.collect();
if !pip_missing.is_empty() {
groups.push(("pip", pip_missing));
}
}
}
let npm_missing: Vec<String> = config
.npm
.iter()
.filter(|pkg| {
let installed = package_probe_succeeds(ctx, "npm", &["ls", "-g", pkg])
&& !drift.contains(&drift_key("npm", pkg));
if installed {
skipped.push(format!("[npm] {pkg}"));
}
!installed
})
.map(|pkg| lock.pinned("npm", pkg))
.collect();
if !npm_missing.is_empty() {
groups.push(("npm", npm_missing));
}
if !node_deps.is_empty() {
let root = std::path::Path::new(".");
let (method, up_to_date) = match config.npm_source {
crate::config::NpmSource::PackageLock => {
let pins =
crate::config::package_lock_pins(&root.join("package-lock.json"))?;
let up_to_date = node_deps.iter().all(|name| {
let installed =
crate::config::installed_node_package_version(root, name);
installed.is_some() && installed == pins.get(name).cloned()
});
("npm-ci", up_to_date)
}
crate::config::NpmSource::PackageJson => {
let up_to_date = node_deps.iter().all(|name| {
crate::config::installed_node_package_version(root, name).is_some()
});
("npm-install", up_to_date)
}
};
if up_to_date {
for name in &node_deps {
skipped.push(format!("[{method}] {name}"));
}
} else {
groups.push((method, node_deps));
}
}
let gem_missing: Vec<String> = config
.gem
.iter()
.filter(|pkg| {
let installed = package_probe_succeeds(ctx, "gem", &["list", "-i", pkg])
&& !drift.contains(&drift_key("gem", pkg));
if installed {
skipped.push(format!("[gem] {pkg}"));
}
!installed
})
.map(|pkg| lock.pinned("gem", pkg))
.collect();
if !gem_missing.is_empty() {
groups.push(("gem", gem_missing));
}
if !config.cargo.is_empty() {
let installed = crate::tools::installed_cargo_crates(ctx)?;
let cargo_missing: Vec<String> = config
.cargo
.iter()
.filter(|pkg| {
let present = installed.contains_key(pkg.as_str())
&& !drift.contains(&drift_key("cargo", pkg));
if present {
skipped.push(format!("[cargo] {pkg}"));
}
!present
})
.map(|pkg| lock.pinned("cargo", pkg))
.collect();
if !cargo_missing.is_empty() {
groups.push(("cargo", cargo_missing));
}
}
if !skipped.is_empty() {
println!("{}:", color::dim("Already installed (skipping)"));
for s in &skipped {
println!(" {} {}", color::green("✓"), s);
}
println!();
}
if groups.is_empty() {
println!("{}", color::green("All dependencies already installed."));
return Ok(());
}
println!("{}:", color::bold("Dependencies to install"));
for (method, packages) in &groups {
let pkgs_ref: Vec<&str> = packages.iter().map(String::as_str).collect();
let preview = crate::tools::describe(method, &pkgs_ref);
let line = preview.first().map(|a| a.join(" ")).unwrap_or_default();
println!(
" {} {}",
color::bold(&format!("[{method}]")),
color::dim(&line)
);
}
println!();
if interactive {
use std::io::Write;
print!("Proceed? [y/N] ");
std::io::stdout()
.flush()
.context("Failed to flush stdout before dependency install prompt")?;
let mut answer = String::new();
std::io::stdin()
.read_line(&mut answer)
.context("Failed to read dependency install prompt answer")?;
if !matches!(answer.trim().to_lowercase().as_str(), "y" | "yes") {
println!("Aborted.");
return Ok(());
}
}
let ctx = crate::tools::InstallCtx {
verbose,
use_eatmydata,
binary_pins: lock.binary,
};
let mut any_failed = false;
for (method, packages) in &groups {
let pkgs_ref: Vec<&str> = packages.iter().map(String::as_str).collect();
match crate::tools::run(method, &pkgs_ref, &ctx) {
Ok(()) => {
println!("{} [{}] {}", color::green("✓"), method, packages.join(", "));
}
Err(e) => {
println!(
"{} [{}] {}: {}",
color::red("✗"),
method,
packages.join(", "),
e
);
any_failed = true;
}
}
}
if any_failed {
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ToolError,
"Some dependency installs failed",
)
.into());
}
println!(
"{}",
color::green("All dependencies installed successfully.")
);
}
}
Ok(())
}
fn sanitize_node_id(prefix: &str, name: &str) -> String {
format!("{}_{}", prefix, name.replace(['.', '-', ' ', '+'], "_"))
}
fn tools_graph_dot(tool_map: &BTreeMap<String, Vec<String>>) -> String {
let mut out =
String::from("digraph tools {\n rankdir=LR;\n node [fontname=\"sans-serif\"];\n");
let mut processors: std::collections::BTreeSet<&str> = std::collections::BTreeSet::new();
for procs in tool_map.values() {
for p in procs {
processors.insert(p);
}
}
out.push_str(" // Tools\n");
for tool in tool_map.keys() {
let id = sanitize_node_id("tool", tool);
let _ = writeln!(
out,
" {id} [label=\"{tool}\" shape=box style=filled fillcolor=lightblue];"
);
}
out.push_str(" // Processors\n");
for proc in &processors {
let id = sanitize_node_id("proc", proc);
let _ = writeln!(
out,
" {id} [label=\"{proc}\" shape=box style=filled fillcolor=lightyellow];"
);
}
out.push_str(" // Edges\n");
for (tool, procs) in tool_map {
let tool_id = sanitize_node_id("tool", tool);
for proc in procs {
let proc_id = sanitize_node_id("proc", proc);
let _ = writeln!(out, " {tool_id} -> {proc_id};");
}
}
out.push_str("}\n");
out
}
fn tools_graph_mermaid(tool_map: &BTreeMap<String, Vec<String>>) -> String {
let mut out = String::from("graph LR\n");
for (tool, procs) in tool_map {
let tool_id = sanitize_node_id("tool", tool);
for proc in procs {
let proc_id = sanitize_node_id("proc", proc);
let _ = writeln!(
out,
" {tool_id}[\"{tool}\"]:::tool --> {proc_id}[\"{proc}\"]:::processor"
);
}
}
out.push_str(" classDef tool fill:#add8e6\n");
out.push_str(" classDef processor fill:#ffffe0\n");
out
}
fn tools_graph_text(tool_map: &BTreeMap<String, Vec<String>>) -> String {
let mut lines = Vec::new();
for (tool, procs) in tool_map {
for proc in procs {
lines.push(format!("{tool} \u{2192} {proc}"));
}
}
lines.join("\n")
}
fn tools_graph_json(tool_map: &BTreeMap<String, Vec<String>>) -> Result<String> {
let entries: Vec<crate::json_output::ToolListEntry> = tool_map
.iter()
.map(|(tool, procs)| {
let info = crate::tools::tool_info(tool);
let install_methods = info
.map(|i| {
i.install_methods
.iter()
.map(|m| crate::json_output::ToolInstallMethodEntry {
method: m.method.to_string(),
command: m.command(),
})
.collect()
})
.unwrap_or_default();
crate::json_output::ToolListEntry {
tool: tool.clone(),
installed: which::which(tool).is_ok(),
runtime: info.map_or("unknown", |i| i.runtime).to_string(),
processor: procs.clone(),
install_methods,
}
})
.collect();
Ok(serde_json::to_string_pretty(&entries)?)
}
fn tools_graph_html(tool_map: &BTreeMap<String, Vec<String>>) -> String {
let mermaid_content = tools_graph_mermaid(tool_map);
format!(
r#"<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>RSConstruct Tools Graph</title>
<script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
<style>
body {{
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
margin: 40px;
background: #f5f5f5;
}}
h1 {{
color: #333;
}}
.mermaid {{
background: white;
padding: 20px;
border-radius: 8px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}}
</style>
</head>
<body>
<h1>RSConstruct Tools Graph</h1>
<div class="mermaid">
{mermaid_content}
</div>
<script>
mermaid.initialize({{ startOnLoad: true, theme: 'default', maxTextSize: 500000 }});
</script>
</body>
</html>
"#
)
}
fn tools_graph_svg(
ctx: &crate::build_context::BuildContext,
tool_map: &BTreeMap<String, Vec<String>>,
) -> Result<String> {
crate::processor::dot_to_svg(ctx, &tools_graph_dot(tool_map))
}
#[cfg(test)]
mod dpkg_status_tests {
use super::dpkg_status_means_installed;
#[test]
fn installed_package_is_installed() {
assert!(dpkg_status_means_installed("install ok installed"));
assert!(dpkg_status_means_installed("install ok installed\n"));
}
#[test]
fn known_but_absent_package_is_not_installed() {
assert!(!dpkg_status_means_installed("unknown ok not-installed"));
assert!(!dpkg_status_means_installed("deinstall ok config-files"));
assert!(!dpkg_status_means_installed("install ok half-configured"));
assert!(!dpkg_status_means_installed(""));
}
}