use std::process::Stdio;
use std::time::Duration;
use tokio::process::Command;
pub const PREFIX: char = '=';
const QALC_BUDGET_MS: u64 = 500;
const DEADLINE: Duration = Duration::from_millis(1200);
#[must_use]
pub fn claims(query: &str) -> Option<&str> {
let rest = query.strip_prefix(PREFIX)?.trim();
(!rest.is_empty()).then_some(rest)
}
#[must_use]
pub fn available() -> bool {
use std::sync::OnceLock;
static AVAILABLE: OnceLock<bool> = OnceLock::new();
*AVAILABLE.get_or_init(|| {
std::env::var_os("PATH").is_some_and(|paths| {
std::env::split_paths(&paths).any(|dir| dir.join("qalc").is_file())
})
})
}
pub async fn evaluate(expression: &str) -> Option<String> {
if !available() {
return None;
}
let expression = expression.trim();
if expression.is_empty() {
return None;
}
let child = Command::new("qalc")
.arg("-t")
.arg("-m")
.arg(QALC_BUDGET_MS.to_string())
.arg("--")
.arg(expression)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.kill_on_drop(true)
.output();
let output = match tokio::time::timeout(DEADLINE, child).await {
Ok(Ok(output)) => output,
Ok(Err(error)) => {
tracing::warn!(%error, "qalc failed to run");
return None;
}
Err(_) => {
tracing::warn!(expression, "qalc exceeded its deadline");
return None;
}
};
let answer = String::from_utf8_lossy(&output.stdout).trim().to_owned();
if answer.is_empty() {
return None;
}
if squeeze(&answer) == squeeze(expression) {
return None;
}
Some(answer)
}
fn squeeze(text: &str) -> String {
text.chars()
.filter(|character| !character.is_whitespace())
.flat_map(char::to_lowercase)
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_prefix_claims_with_or_without_a_space() {
assert_eq!(claims("=15*3"), Some("15*3"));
assert_eq!(claims("= 15*3"), Some("15*3"));
assert_eq!(claims("= 5 km to miles "), Some("5 km to miles"));
}
#[test]
fn a_bare_prefix_and_ordinary_queries_claim_nothing() {
assert_eq!(claims("="), None);
assert_eq!(claims("= "), None);
assert_eq!(claims("firefox"), None);
assert_eq!(claims(""), None);
}
#[test]
fn a_restatement_is_not_an_answer() {
assert_eq!(squeeze("1 / 0"), squeeze("1/0"));
assert_ne!(squeeze("45"), squeeze("15*3"));
}
#[tokio::test(flavor = "multi_thread")]
#[ignore = "needs qalc installed"]
async fn qalc_answers_arithmetic_and_conversions() {
assert_eq!(evaluate("15*3").await.as_deref(), Some("45"));
let converted = evaluate("5 km to miles").await.expect("a conversion");
assert!(converted.contains("mi"), "got {converted}");
assert_eq!(evaluate("1/0").await, None);
assert_eq!(evaluate("").await, None);
}
}