use crate::template::Template;
use std::{
ffi::{OsStr, OsString},
fmt,
path::{Path, PathBuf},
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Requirement {
pub program: String,
pub hint: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub struct MissingRequirements {
pub template: String,
pub missing: Vec<Requirement>,
}
impl fmt::Display for MissingRequirements {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"template `{}` requires programs that are not on PATH:",
self.template
)?;
for requirement in &self.missing {
match &requirement.hint {
Some(hint) => write!(f, "\n {}: {hint}", requirement.program)?,
None => write!(f, "\n {}", requirement.program)?,
}
}
Ok(())
}
}
pub fn check(template: &Template) -> Result<(), MissingRequirements> {
check_in(
template,
search_path().as_deref(),
&std::env::current_dir().unwrap_or_default(),
)
}
pub fn search_path() -> Option<OsString> {
let path = std::env::var_os("PATH")?;
let cwd = std::env::current_dir().ok();
let entries: Vec<PathBuf> = std::env::split_paths(&path)
.filter_map(|entry| {
if entry.is_absolute() {
return Some(entry);
}
let absolute = cwd.as_ref()?.join(entry);
std::env::join_paths([&absolute])
.is_ok()
.then_some(absolute)
})
.collect();
if entries.is_empty() {
return None;
}
std::env::join_paths(entries).ok()
}
pub fn locate(program: &str) -> Option<PathBuf> {
which::which_in(
program,
search_path(),
std::env::current_dir().unwrap_or_default(),
)
.ok()
}
pub fn check_in(
template: &Template,
paths: Option<&OsStr>,
cwd: &Path,
) -> Result<(), MissingRequirements> {
let missing: Vec<Requirement> = template
.requirements()
.into_iter()
.filter(|requirement| which::which_in(&requirement.program, paths, cwd).is_err())
.collect();
if missing.is_empty() {
Ok(())
} else {
Err(MissingRequirements {
template: template.name.clone(),
missing,
})
}
}