use std::io::BufReader;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use serde::Deserialize;
use super::diagnostics;
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub(crate) struct Artifact {
manifest_path: PathBuf,
target: ArtifactTarget,
filenames: Vec<PathBuf>,
executable: Option<PathBuf>,
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
struct ArtifactTarget {
name: String,
kind: Vec<String>,
}
impl Artifact {
pub(crate) fn from_message(message: &serde_json::Value) -> Option<Self> {
if message.get("reason")?.as_str()? != "compiler-artifact" {
return None;
}
Self::deserialize(message).ok()
}
fn belongs_to(&self, package_dir: &Path) -> bool {
same_file(&self.manifest_path, &package_dir.join("Cargo.toml"))
}
fn is(&self, kind: &str) -> bool {
self.target.kind.iter().any(|k| k == kind)
}
}
fn same_file(a: &Path, b: &Path) -> bool {
match (a.canonicalize(), b.canonicalize()) {
(Ok(a), Ok(b)) => a == b,
_ => a == b,
}
}
pub(crate) fn cdylib(
artifacts: &[Artifact],
package_dir: &Path,
extension: &str,
) -> Option<PathBuf> {
artifacts
.iter()
.filter(|artifact| artifact.is("cdylib") && artifact.belongs_to(package_dir))
.flat_map(|artifact| &artifact.filenames)
.find(|file| file.extension().is_some_and(|ext| ext == extension))
.cloned()
}
pub(crate) fn binary(
artifacts: &[Artifact],
package_dir: &Path,
default_run: Option<&str>,
) -> Result<PathBuf, String> {
let built: Vec<(&str, &Path)> = artifacts
.iter()
.filter(|artifact| artifact.is("bin") && artifact.belongs_to(package_dir))
.filter_map(|artifact| {
Some((
artifact.target.name.as_str(),
artifact.executable.as_deref()?,
))
})
.collect();
if let [(_, only)] = built.as_slice() {
return Ok(only.to_path_buf());
}
if let Some((_, chosen)) = built.iter().find(|(name, _)| Some(*name) == default_run) {
return Ok(chosen.to_path_buf());
}
match built.is_empty() {
true => Err(format!(
"cargo reported no binary for the package in {}. Does it have a `[[bin]]`?",
package_dir.display()
)),
false => {
let names: Vec<String> = built.iter().map(|(name, _)| format!("`{name}`")).collect();
Err(format!(
"the package in {} builds several binaries ({}); name the one to run with `default-run` under its `[package]`.",
package_dir.display(),
names.join(", ")
))
}
}
}
pub(crate) fn with_json_messages(args: &mut Vec<String>) {
if !args.iter().any(|a| a.starts_with("--message-format")) {
args.push("--message-format=json".to_string());
}
}
pub(crate) fn build_with_diagnostics(cmd: &mut Command) -> (bool, diagnostics::Report) {
cmd.arg("--color=always")
.stdout(Stdio::piped())
.stderr(Stdio::inherit());
let mut child = cmd.spawn().expect("[cargo-telar] failed to invoke cargo");
let report = match child.stdout.take() {
Some(stdout) => diagnostics::collect(BufReader::new(stdout)),
None => diagnostics::Report::default(),
};
let succeeded = child.wait().map(|status| status.success()).unwrap_or(false);
if report.has_diagnostics() {
eprintln!();
eprint!("{}", report.render(true));
}
(succeeded, report)
}
#[cfg(test)]
#[path = "artifacts.test.rs"]
mod tests;