#![allow(dead_code)]
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::path::{Path, PathBuf};
use std::process::{Command, Output, Stdio};
use std::sync::atomic::{AtomicU32, Ordering};
#[must_use]
pub(crate) fn bin(name: &str) -> PathBuf {
let var = match name {
"oxtar" => env!("CARGO_BIN_EXE_oxtar"),
"oxcpio" => env!("CARGO_BIN_EXE_oxcpio"),
"oxcat" => env!("CARGO_BIN_EXE_oxcat"),
"oxunzip" => env!("CARGO_BIN_EXE_oxunzip"),
other => panic!("unknown bin {other}"),
};
PathBuf::from(var)
}
pub(crate) struct TempDir {
path: PathBuf,
}
impl TempDir {
#[must_use]
pub(crate) fn new(tag: &str) -> Self {
static COUNTER: AtomicU32 = AtomicU32::new(0);
let n = COUNTER.fetch_add(1, Ordering::Relaxed);
let path = std::env::temp_dir().join(format!("oxcli_{tag}_{}_{n}", std::process::id()));
std::fs::create_dir_all(&path).expect("create temp dir");
Self { path }
}
#[must_use]
pub(crate) fn path(&self) -> &Path {
&self.path
}
#[must_use]
pub(crate) fn join(&self, rel: &str) -> PathBuf {
self.path.join(rel)
}
pub(crate) fn write(&self, rel: &str, contents: &[u8]) -> PathBuf {
let p = self.join(rel);
if let Some(parent) = p.parent() {
std::fs::create_dir_all(parent).expect("create parents");
}
std::fs::write(&p, contents).expect("write file");
p
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.path);
}
}
pub(crate) fn run_in(bin_name: &str, args: &[&str], cwd: &Path) -> Output {
Command::new(bin(bin_name))
.args(args)
.current_dir(cwd)
.output()
.expect("spawn bin")
}
pub(crate) fn run(bin_name: &str, args: &[&str]) -> Output {
Command::new(bin(bin_name))
.args(args)
.output()
.expect("spawn bin")
}
pub(crate) fn run_stdin(bin_name: &str, args: &[&str], cwd: &Path, stdin_bytes: &[u8]) -> Output {
use std::io::Write;
let mut child = Command::new(bin(bin_name))
.args(args)
.current_dir(cwd)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn bin");
child
.stdin
.take()
.expect("stdin")
.write_all(stdin_bytes)
.expect("write stdin");
child.wait_with_output().expect("wait")
}
#[must_use]
pub(crate) fn code(out: &Output) -> i32 {
out.status.code().unwrap_or(-1)
}
#[must_use]
pub(crate) fn tool_present(name: &str) -> bool {
Command::new(name)
.arg("--version")
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.is_ok_and(|s| s.success())
}