use crate::toolchain::cargo::{self, Dependency};
use std::collections::HashMap;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::path::{Path, PathBuf};
#[derive(Clone, Debug)]
pub(crate) struct Package {
pub(crate) lib: String,
pub(crate) name: String,
pub(crate) dir: PathBuf,
pub(crate) root: PathBuf,
pub(crate) edition: String,
pub(crate) dependencies: Vec<Dependency>,
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Project {
pub(crate) packages: Vec<Package>,
pub(crate) workspace: PathBuf,
pub(crate) work: PathBuf,
pub(crate) error: Option<String>,
}
impl Project {
pub(crate) fn read(start: &Path, in_memory: Option<&str>) -> Project {
let metadata = match cargo::metadata(start) {
Ok(metadata) => metadata,
Err(error) => return Project { error: Some(error), ..Project::default() },
};
let packages = metadata.packages.iter().filter_map(package).collect();
let work = match in_memory {
Some(root) => std::env::temp_dir().join("docattest-rust").join(format!("{:016x}", hash(root))),
None => metadata.target_directory.join("docattest"),
};
Project { packages, workspace: metadata.workspace_root, work, error: None }
}
pub(crate) fn by_lib(&self, lib: &str) -> Option<&Package> {
self.packages.iter().find(|package| package.lib == lib)
}
}
fn hash(text: &str) -> u64 {
let mut hasher = DefaultHasher::new();
text.hash(&mut hasher);
hasher.finish()
}
fn package(found: &cargo::Package) -> Option<Package> {
let lib =
found.targets.iter().find(|target| target.kind.iter().any(|kind| kind == "lib" || kind == "rlib"))?;
Some(Package {
lib: lib.name.replace('-', "_"),
name: found.name.clone(),
dir: found.manifest_path.parent()?.to_path_buf(),
root: lib.src_path.clone(),
edition: found.edition.clone(),
dependencies: found.dependencies.clone(),
})
}
pub(crate) fn materialise(named: &str, files: &HashMap<String, String>) -> std::io::Result<PathBuf> {
let unique = format!(
"docattest-rust-{}-{:016x}",
std::process::id(),
hash(&format!("{named}{:?}", std::time::Instant::now()))
);
let root = std::env::temp_dir().join(unique);
for (rel, text) in files {
let path = root.join(rel);
std::fs::create_dir_all(path.parent().unwrap_or(&root))?;
std::fs::write(path, text)?;
}
std::fs::create_dir_all(&root)?;
root.canonicalize()
}