use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use anyhow::{Context, Result, bail};
use tokio::process::Command;
use crate::Frontend;
static DIST: OnceLock<PathBuf> = OnceLock::new();
pub fn dist() -> Result<&'static Path> {
let dist = DIST
.get()
.context("the frontend has not been built; see `Fixture::config`")?;
Ok(dist.as_path())
}
pub(crate) async fn build(frontend: &Frontend) -> Result<()> {
if DIST.get().is_some() {
return Ok(());
}
let Frontend::Trunk(dir) = frontend else {
return Ok(());
};
let dist = resolve(dir).await?;
let _ = DIST.set(dist);
Ok(())
}
pub fn target_dir() -> Result<PathBuf> {
if let Some(target) = std::env::var_os("CARGO_TARGET_DIR") {
return Ok(PathBuf::from(target));
}
Ok(workspace_root()?.join("target"))
}
pub fn workspace_root() -> Result<PathBuf> {
if let Some(dir) = std::env::var_os("CARGO_MANIFEST_DIR") {
let dir = PathBuf::from(dir);
return Ok(search(&dir).unwrap_or(dir));
}
let from = std::env::current_dir().context("locating the current directory")?;
search(&from).or_else(|| package(&from)).with_context(|| {
format!(
"locating the workspace root from {}: run under cargo, or from inside the workspace",
from.display()
)
})
}
fn search(from: &Path) -> Option<PathBuf> {
from.ancestors()
.find(|dir| is_root(dir))
.map(Path::to_owned)
}
fn package(from: &Path) -> Option<PathBuf> {
from.ancestors()
.find(|dir| dir.join("Cargo.toml").is_file())
.map(Path::to_owned)
}
fn is_root(dir: &Path) -> bool {
let Ok(manifest) = std::fs::read_to_string(dir.join("Cargo.toml")) else {
return false;
};
manifest.lines().any(|line| line.trim() == "[workspace]")
}
async fn resolve(dir: &Path) -> Result<PathBuf> {
if let Some(given) = std::env::var_os("E2E_DIST") {
let given = PathBuf::from(given);
if !given.join("index.html").is_file() {
bail!(
"E2E_DIST is set to {}, which holds no index.html",
given.display()
);
}
println!("serving the frontend from {}", given.display());
return Ok(given);
}
let root = workspace_root()?.join(dir);
let dist = target_dir()?.join("e2e-dist");
println!("building the frontend into {}", dist.display());
let status = Command::new("trunk")
.current_dir(&root)
.arg("build")
.arg("--dist")
.arg(&dist)
.status()
.await
.context("running `trunk build`, is trunk installed?")?;
if !status.success() {
bail!("`trunk build` failed: {status}");
}
Ok(dist)
}
#[cfg(test)]
mod tests {
use std::fs;
use std::path::Path;
use super::{is_root, package, search};
fn workspace(at: &Path) {
fs::write(
at.join("Cargo.toml"),
"[workspace]\nmembers = [\"crates/*\"]\n",
)
.expect("writing the manifest");
fs::create_dir_all(at.join("crates/app/src")).expect("making the crates");
fs::write(
at.join("crates/app/Cargo.toml"),
"[package]\nname = \"app\"\n",
)
.expect("writing a package manifest");
}
#[test]
fn the_root_is_found_from_somewhere_under_it() {
let dir = tempfile::tempdir().expect("a temporary directory");
let at = dir.path();
workspace(at);
assert_eq!(search(&at.join("crates/app/src")).as_deref(), Some(at));
assert_eq!(search(&at.join("crates/app")).as_deref(), Some(at));
let deep = at.join("crates/pod/macros/src");
fs::create_dir_all(&deep).expect("making a nested crate");
assert_eq!(search(&deep).as_deref(), Some(at));
}
#[test]
fn the_root_is_found_from_the_root() {
let dir = tempfile::tempdir().expect("a temporary directory");
let at = dir.path();
workspace(at);
assert_eq!(search(at).as_deref(), Some(at));
}
#[test]
fn somewhere_outside_a_workspace_finds_nothing() {
let dir = tempfile::tempdir().expect("a temporary directory");
let at = dir.path();
fs::create_dir_all(at.join("elsewhere")).expect("making a directory");
assert_eq!(search(&at.join("elsewhere")), None);
assert_eq!(package(&at.join("elsewhere")), None);
}
#[test]
fn a_lone_package_is_its_own_root() {
let dir = tempfile::tempdir().expect("a temporary directory");
let at = dir.path();
fs::create_dir_all(at.join("src")).expect("making a directory");
fs::write(at.join("Cargo.toml"), "[package]\nname = \"app\"\n")
.expect("writing a manifest");
assert!(!is_root(at));
assert_eq!(search(&at.join("src")), None);
assert_eq!(package(&at.join("src")).as_deref(), Some(at));
}
#[test]
fn a_directory_called_cargo_toml_is_not_a_manifest() {
let dir = tempfile::tempdir().expect("a temporary directory");
let at = dir.path();
fs::create_dir_all(at.join("Cargo.toml")).expect("making a directory");
assert!(!is_root(at));
}
}