use super::{Command, run};
use serde::Deserialize;
use std::path::{Path, PathBuf};
pub fn program() -> PathBuf {
std::env::var_os("DOCATTEST_CARGO").map_or_else(|| "cargo".into(), PathBuf::from)
}
#[derive(Clone, Debug, Default, Deserialize)]
pub struct Metadata {
pub packages: Vec<Package>,
pub target_directory: PathBuf,
pub workspace_root: PathBuf,
}
#[derive(Clone, Debug, Default, Deserialize)]
pub struct Package {
pub name: String,
pub manifest_path: PathBuf,
pub edition: String,
pub targets: Vec<Target>,
pub dependencies: Vec<Dependency>,
}
#[derive(Clone, Debug, Default, Deserialize)]
pub struct Target {
pub name: String,
pub kind: Vec<String>,
pub src_path: PathBuf,
}
#[derive(Clone, Debug, Default, Deserialize)]
pub struct Dependency {
pub name: String,
pub req: String,
pub kind: Option<String>,
pub rename: Option<String>,
pub optional: bool,
pub uses_default_features: bool,
pub features: Vec<String>,
pub target: Option<String>,
pub path: Option<PathBuf>,
pub source: Option<String>,
}
pub fn metadata(dir: &Path) -> Result<Metadata, String> {
let args = ["metadata", "--format-version", "1", "--no-deps"].map(String::from).to_vec();
let asked = run(&Command { program: program(), args, dir: dir.to_path_buf(), ..Command::default() });
if let Some(error) = asked.error {
return Err(not_run(&error));
}
if asked.code != Some(0) {
return Err(last_error(&asked.stderr));
}
serde_json::from_str(&asked.stdout).map_err(|err| format!("cargo metadata: {err}"))
}
fn not_run(error: &str) -> String {
format!("{} could not be run: {error}", program().display())
}
pub(super) fn last_error(stderr: &str) -> String {
let lines: Vec<&str> = stderr.lines().filter(|line| !line.trim().is_empty()).collect();
let said = lines.iter().rev().find(|line| line.starts_with("error")).or(lines.last());
said.map_or_else(|| "cargo failed".to_string(), |line| line.trim().to_string())
}
#[derive(Clone, Debug, PartialEq)]
pub struct Problem {
pub target: String,
pub file: String,
pub line: usize,
pub message: String,
}
#[derive(Deserialize)]
struct Message {
reason: String,
target: Option<Target>,
message: Option<Diagnostic>,
}
#[derive(Deserialize)]
struct Diagnostic {
level: String,
message: String,
spans: Vec<Span>,
}
#[derive(Deserialize)]
struct Span {
file_name: String,
line_start: usize,
is_primary: bool,
expansion: Option<Box<Expansion>>,
}
#[derive(Deserialize)]
struct Expansion {
span: Span,
}
impl Span {
fn written(&self) -> &Span {
self.expansion.as_ref().map_or(self, |expansion| expansion.span.written())
}
}
pub fn build(krate: &Path, target: &Path, programs: &[String]) -> Vec<Problem> {
let mut args: Vec<String> =
["build", "--keep-going", "--message-format=json", "--target-dir"].map(String::from).to_vec();
args.push(target.to_string_lossy().into_owned());
for name in programs {
args.extend(["--bin".to_string(), name.clone()]);
}
let built = run(&Command { program: program(), args, dir: krate.to_path_buf(), ..Command::default() });
if let Some(error) = built.error {
return vec![Problem {
target: String::new(),
file: String::new(),
line: 0,
message: not_run(&error),
}];
}
let mut problems = errors(&built.stdout);
if built.code != Some(0) && problems.is_empty() {
problems.push(Problem {
target: String::new(),
file: String::new(),
line: 0,
message: last_error(&built.stderr),
});
}
problems
}
pub fn errors(messages: &str) -> Vec<Problem> {
let mut problems = Vec::new();
for line in messages.lines() {
let Ok(message) = serde_json::from_str::<Message>(line) else { continue };
let Some(diagnostic) =
message.message.filter(|d| message.reason == "compiler-message" && d.level == "error")
else {
continue;
};
let Some(span) = diagnostic.spans.iter().find(|span| span.is_primary).map(Span::written) else {
continue;
};
problems.push(Problem {
target: message.target.map(|t| t.name).unwrap_or_default(),
file: span.file_name.clone(),
line: span.line_start,
message: diagnostic.message,
});
}
problems
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn errors_are_read_from_the_compilers_messages() {
let messages = concat!(
r#"{"reason":"compiler-message","target":{"name":"e2","kind":["bin"],"src_path":"/x/src/bin/e2.rs"},"message":{"level":"error","message":"cannot find value `NO` in this scope","spans":[{"file_name":"src/bin/e2.rs","line_start":3,"is_primary":true}]}}"#,
"\n",
r#"{"reason":"compiler-message","target":{"name":"e2","kind":["bin"],"src_path":"/x"},"message":{"level":"warning","message":"unused","spans":[]}}"#,
"\n",
r#"{"reason":"compiler-message","target":{"name":"e2","kind":["bin"],"src_path":"/x"},"message":{"level":"error","message":"aborting due to 1 previous error","spans":[]}}"#,
"\nnot json\n",
r#"{"reason":"build-finished","success":false}"#,
);
let want = Problem {
target: "e2".into(),
file: "src/bin/e2.rs".into(),
line: 3,
message: "cannot find value `NO` in this scope".into(),
};
assert_eq!(errors(messages), vec![want]);
assert_eq!(last_error("warning: x\nerror: no such package\n\n"), "error: no such package");
}
}