use super::Runner;
use super::generated::CRATE;
use super::programs::{Built, Line, Render, Rendered};
use crate::analysis::surfaces::Surface;
use crate::language::text::identifiers;
use crate::protocol::{Error, Evaluation, Fact, Observable, Observation};
use serde_json::{Value, json};
use std::collections::HashMap;
const PREAMBLE: usize = 7;
const DEFAULT_SURFACE: &str = "default";
const MIN_ADDRESS_DIGITS: usize = 6;
impl Runner {
pub(crate) fn evaluate(&self, facts: &[Fact]) -> HashMap<String, Evaluation> {
let mut out = HashMap::new();
let mut groups: Vec<(&Surface, Vec<&Fact>)> = Vec::new();
for fact in facts {
match self.refusal(fact) {
Some(refusal) => drop(out.insert(fact.id.clone(), Evaluation::failed(refusal))),
None => match groups.iter_mut().find(|(surface, _)| surface.name == fact.surface) {
Some((_, group)) => group.push(fact),
None => groups
.extend(self.analysis.surface(&fact.surface).map(|surface| (surface, vec![fact]))),
},
}
}
let expressions: Vec<Vec<String>> = groups
.iter()
.map(|(_, group)| group.iter().map(|fact| fact.expression.clone()).collect())
.collect();
let renders: Vec<_> = groups
.iter()
.zip(&expressions)
.map(|((surface, _), expressions)| {
move |live: &[bool]| self.facts_main(surface, expressions, live, "facts")
})
.collect();
let specs: Vec<(usize, Render)> = renders
.iter()
.zip(&expressions)
.map(|(render, expressions)| (expressions.len(), render as Render))
.collect();
let programs = self.build_programs(&specs);
let answered: Vec<HashMap<String, Evaluation>> = std::thread::scope(|scope| {
let running: Vec<_> = groups
.iter()
.zip(programs)
.map(|((surface, group), program)| {
scope.spawn(move || self.read_group(surface, group, program))
})
.collect();
running.into_iter().map(|thread| thread.join().unwrap_or_default()).collect()
});
out.extend(answered.into_iter().flatten());
out
}
fn refusal(&self, fact: &Fact) -> Option<String> {
if let Some(missing) = self.analysis.not_found(&fact.surface) {
return Some(missing);
}
if let Err(err) = syn::parse_str::<syn::Expr>(&fact.expression) {
return Some(format!("cannot parse fact expression `{}`: {err}", fact.expression));
}
let (surface, helpers) = (self.analysis.surface(&fact.surface)?, self.analysis.setup_names());
let both = identifiers(&fact.expression)
.into_iter()
.find(|name| self.analysis.exported(surface, name) && helpers.iter().any(|h| h == name))?;
Some(format!(
"fact `{}`: \"{both}\" is both an export of surface \"{}\" and of the setup module; rename the one in the setup module",
fact.expression, fact.surface
))
}
fn read_group(&self, surface: &Surface, facts: &[&Fact], program: Built) -> HashMap<String, Evaluation> {
let mut out = HashMap::new();
let mut kept: Vec<&Fact> = Vec::new();
for (k, fact) in facts.iter().enumerate() {
let label = format!("fact `{}`", fact.expression);
match (program.dropped.get(&k), &program.binary) {
(Some(complaint), _) => drop(out.insert(
fact.id.clone(),
Evaluation::failed(format!("{label}: {}", not_exported(complaint, surface))),
)),
(None, None) => {
let why = program.failure.clone().unwrap_or_default();
out.insert(
fact.id.clone(),
Evaluation::failed(format!("surface \"{}\" failed to load: {why}", surface.name)),
);
}
(None, Some(_)) => kept.push(fact),
}
}
let Some(binary) = program.binary.filter(|_| !kept.is_empty()) else { return out };
let answers = self.serve(&binary, None, kept.len());
for (k, fact) in kept.iter().enumerate() {
let evaluation = match &answers {
Ok(answers) => self.evaluation(fact, &answers[k]),
Err(failed) => Evaluation::failed(failed.clone()),
};
out.insert(fact.id.clone(), evaluation);
}
out
}
fn evaluation(&self, fact: &Fact, answer: &Line) -> Evaluation {
let label = format!("fact `{}`", fact.expression);
if answer.timeout {
return Evaluation::failed(format!("{label} {}", self.timed_out()));
}
if let Some(panic) = &answer.panic {
return Evaluation::failed(format!("{label} panicked: {panic}"));
}
if let Some(lost) = &answer.lost {
return Evaluation::failed(format!("{label}: {lost}"));
}
match serde_json::from_value::<Observation>(answer.value.clone()) {
Ok(value) => Evaluation::of(value),
Err(_) => Evaluation::failed(format!("{label}: the program returned no value")),
}
}
fn facts_main(&self, surface: &Surface, expressions: &[String], live: &[bool], serves: &str) -> Rendered {
let mut source = format!(
"#![allow(unused, ambiguous_glob_imports)]\nuse {CRATE}::harness::serve::{{manifest, snapshot}};\nuse {CRATE}::observe;\nuse {}::*;\n{}\nfn main() {{\n {CRATE}::harness::serve::{serves}(vec![\n",
surface.import,
self.setup_module()
.map_or_else(|| "// no setup module".to_string(), |module| format!("{module} use setup::*;")),
);
let mut lines = HashMap::new();
for (k, expression) in expressions.iter().enumerate().filter(|(k, _)| live[*k]) {
lines.insert(PREAMBLE + lines.len() + 1, k);
let read = format!(
"Box::new(|| observe!({}))",
expression.split_whitespace().collect::<Vec<_>>().join(" ")
);
let item = if serves == "facts" { read } else { format!("({expression:?}, {read})") };
source.push_str(&format!(" {item},\n"));
}
source.push_str(" ]);\n}\n");
Rendered { source, lines }
}
pub(crate) fn observables(&self, name: &str) -> Result<Value, Error> {
let user = |why: String| Error::User(format!("docattest: audit: {why}"));
if let Some(missing) = self.analysis.not_found(name) {
return Err(user(missing));
}
let Some(surface) = self.analysis.surface(name) else { return Ok(json!([])) };
let roots = self.roots(surface);
if roots.is_empty() {
return Ok(json!([]));
}
let program =
self.build_program(roots.len(), &|live| self.facts_main(surface, &roots, live, "observables"));
let Some(binary) = program.binary else {
return program
.failure
.map_or(Ok(json!([])), |why| Err(user(format!("surface \"{name}\" failed to load: {why}"))));
};
let answers = self
.serve(&binary, None, 1)
.map_err(|why| user(format!("surface \"{name}\" could not be read: {why}")))?;
let answer = &answers[0];
if let Some(why) =
answer.panic.clone().or(answer.lost.clone()).or(answer.timeout.then(|| self.timed_out()))
{
return Err(user(format!("surface \"{name}\" could not be read: {why}")));
}
let found: Vec<Observable> = answer
.value
.as_array()
.into_iter()
.flatten()
.filter_map(|item| observable(name, item))
.filter(|o| !shows_an_address(&o.value))
.collect();
Ok(json!(found))
}
fn roots(&self, surface: &Surface) -> Vec<String> {
let mut roots = self.analysis.exports_of(&surface.name).unwrap_or_default();
if surface.name == DEFAULT_SURFACE {
let helpers = self.analysis.setup_helpers().into_iter();
roots.extend(helpers.filter(|h| !self.analysis.exported(surface, h)).map(|h| format!("{h}()")));
}
roots
}
}
fn shows_an_address(value: &Observation) -> bool {
if value.kind.as_deref() == Some("text") {
return false;
}
let text = value.text.as_bytes();
text.windows(2).enumerate().any(|(k, pair)| {
let starts = k == 0 || !(text[k - 1].is_ascii_alphanumeric() || text[k - 1] == b'_');
let hex = text[k + 2..].iter().take_while(|b| b.is_ascii_hexdigit()).count();
starts && pair == b"0x" && hex >= MIN_ADDRESS_DIGITS
})
}
fn observable(surface: &str, item: &Value) -> Option<Observable> {
Some(Observable {
surface: surface.to_string(),
expression: item["expression"].as_str()?.to_string(),
path: vec![item["expression"].as_str()?.to_string()],
value: serde_json::from_value(item["value"].clone()).ok()?,
})
}
fn not_exported(complaint: &str, surface: &Surface) -> String {
let named = complaint.strip_prefix("cannot find ").and_then(|rest| rest.split('`').nth(1));
match named.filter(|_| complaint.ends_with("in this scope")) {
Some(name) => format!("{name} is not exported by surface \"{}\" ({complaint})", surface.name),
None => complaint.to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn value(text: &str, kind: Option<&str>) -> Observation {
Observation {
text: text.into(),
items: None,
description: String::new(),
kind: kind.map(str::to_string),
}
}
#[test]
fn a_value_that_shows_an_address_is_not_offered() {
assert!(shows_an_address(&value("[(\"a\", 0x1004f43c0)]", None)));
assert!(shows_an_address(&value("0x16b0f2f48", None)));
for shown in ["255", "0xFF", "x0x1004f43c0", "[\"a\"]"] {
assert!(!shows_an_address(&value(shown, None)), "{shown}");
}
assert!(!shows_an_address(&value("0x1004f43c0", Some("text"))));
}
}