use std::ffi::{OsStr, OsString};
use std::io;
use std::path::{Path, PathBuf};
use std::process::Command;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Os {
Linux,
MacOs,
Windows,
}
const DEFAULT_PATHEXT: &str = ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC";
impl Os {
pub const CURRENT: Self = if cfg!(windows) {
Self::Windows
} else if cfg!(target_os = "macos") {
Self::MacOs
} else {
Self::Linux
};
pub fn executable_names(self, program: &str, pathext: Option<&str>) -> Vec<String> {
if self != Self::Windows {
return vec![program.to_owned()];
}
let extensions: Vec<&str> = pathext
.filter(|value| !value.is_empty())
.unwrap_or(DEFAULT_PATHEXT)
.split(';')
.map(|ext| ext.trim_end_matches('.'))
.filter(|ext| !ext.is_empty())
.collect();
let upper = program.to_uppercase();
let has_extension = extensions
.iter()
.any(|ext| upper.ends_with(&ext.to_uppercase()));
has_extension
.then(|| program.to_owned())
.into_iter()
.chain(extensions.iter().map(|ext| format!("{program}{ext}")))
.collect()
}
pub fn find_executable(
self,
program: &str,
path: impl IntoIterator<Item = PathBuf>,
pathext: Option<&str>,
is_executable: impl Fn(&Path) -> bool,
) -> Option<PathBuf> {
let given = Path::new(program);
let (dirs, name): (Vec<PathBuf>, &str) =
match given.parent().filter(|dir| !dir.as_os_str().is_empty()) {
Some(dir) => (vec![dir.to_owned()], given.file_name()?.to_str()?),
None => (path.into_iter().collect(), program),
};
let names = self.executable_names(name, pathext);
dirs.iter()
.flat_map(|dir| names.iter().map(move |name| dir.join(name)))
.find(|candidate| is_executable(candidate))
}
pub fn without_verbatim_prefix(self, path: PathBuf) -> PathBuf {
if self != Self::Windows {
return path;
}
let Some(text) = path.to_str() else {
return path;
};
if let Some(rest) = text.strip_prefix(r"\\?\UNC\") {
return PathBuf::from(format!(r"\\{rest}"));
}
match text.strip_prefix(r"\\?\") {
Some(rest) if is_drive_path(rest) => PathBuf::from(rest),
_ => path,
}
}
pub fn native_url_path(self, url_path: &str) -> String {
if self != Self::Windows {
return url_path.to_owned();
}
let drive = |path: &str| {
let mut chars = path.chars();
let letter = chars.next()?;
matches!(chars.next(), Some(':' | '|')).then_some(letter.len_utf8())
};
let path = url_path
.strip_prefix('/')
.filter(|rest| drive(rest).is_some())
.unwrap_or(url_path);
let path = match drive(path) {
Some(len) => format!("{}:{}", &path[..len], &path[len + 1..]),
None => path.to_owned(),
};
path.replace('/', "\\")
}
pub fn as_posix(self, path: &Path) -> String {
let text = path.to_string_lossy();
match self {
Self::Windows => text.replace('\\', "/"),
Self::Linux | Self::MacOs => text.into_owned(),
}
}
pub fn renamed_over_meanwhile(self, code: Option<i32>) -> bool {
const ACCESS_DENIED: i32 = 5;
const SHARING_VIOLATION: i32 = 32;
self == Self::Windows && matches!(code, Some(ACCESS_DENIED | SHARING_VIOLATION))
}
}
fn is_drive_path(text: &str) -> bool {
let bytes = text.as_bytes();
bytes.len() >= 3 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':' && bytes[2] == b'\\'
}
pub fn which(program: impl AsRef<OsStr>) -> Option<PathBuf> {
let program = program.as_ref().to_str()?;
let path = std::env::var_os("PATH").unwrap_or_default();
let pathext = std::env::var_os("PATHEXT").map(OsString::into_string);
let pathext = pathext.as_ref().and_then(|value| value.as_deref().ok());
Os::CURRENT.find_executable(
program,
std::env::split_paths(&path).filter(|dir| !dir.as_os_str().is_empty()),
pathext,
is_executable,
)
}
fn is_executable(path: &Path) -> bool {
std::fs::metadata(path).is_ok_and(|meta| meta.is_file() && has_execute_permission(&meta))
}
#[cfg(unix)]
fn has_execute_permission(meta: &std::fs::Metadata) -> bool {
use std::os::unix::fs::PermissionsExt as _;
meta.permissions().mode() & 0o111 != 0
}
#[cfg(not(unix))]
fn has_execute_permission(_meta: &std::fs::Metadata) -> bool {
true
}
pub fn lost_rename_race(error: &io::Error, to: &Path) -> bool {
Os::CURRENT.renamed_over_meanwhile(error.raw_os_error()) && to.is_file()
}
pub fn hide_console(command: &mut Command) -> &mut Command {
#[cfg(windows)]
{
use std::os::windows::process::CommandExt as _;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
command.creation_flags(CREATE_NO_WINDOW);
}
command
}
pub fn expand_user(path: &Path) -> PathBuf {
match (path.strip_prefix("~"), std::env::home_dir()) {
(Ok(rest), Some(home)) if rest.as_os_str().is_empty() => home,
(Ok(rest), Some(home)) => home.join(rest),
_ => path.to_owned(),
}
}
pub fn resolve(path: &Path) -> io::Result<PathBuf> {
std::fs::canonicalize(path).map(|resolved| Os::CURRENT.without_verbatim_prefix(resolved))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_current_system_is_the_target() {
assert_eq!(Os::CURRENT == Os::Windows, cfg!(windows));
assert_eq!(Os::CURRENT == Os::MacOs, cfg!(target_os = "macos"));
}
#[test]
fn only_windows_loses_renames_to_other_processes() {
for code in [5, 32] {
assert!(Os::Windows.renamed_over_meanwhile(Some(code)));
assert!(!Os::Linux.renamed_over_meanwhile(Some(code)));
assert!(!Os::MacOs.renamed_over_meanwhile(Some(code)));
}
assert!(!Os::Windows.renamed_over_meanwhile(Some(2)), "not found");
assert!(!Os::Windows.renamed_over_meanwhile(None));
}
#[test]
fn programs_are_their_names_off_windows() {
for os in [Os::Linux, Os::MacOs] {
assert_eq!(os.executable_names("gs", Some(".EXE")), ["gs"]);
}
}
#[test]
fn windows_programs_take_the_extensions_of_pathext() {
assert_eq!(
Os::Windows.executable_names("gswin64c", None),
[
"gswin64c.COM",
"gswin64c.EXE",
"gswin64c.BAT",
"gswin64c.CMD",
"gswin64c.VBS",
"gswin64c.JS",
"gswin64c.WS",
"gswin64c.MSC"
]
);
assert_eq!(
Os::Windows.executable_names("ffmpeg", Some(".exe;;.cmd.")),
["ffmpeg.exe", "ffmpeg.cmd"]
);
assert_eq!(
Os::Windows.executable_names("ffmpeg.EXE", Some(".exe;.bat")),
["ffmpeg.EXE", "ffmpeg.EXE.exe", "ffmpeg.EXE.bat"],
"a name with an extension of PATHEXT comes first"
);
assert_eq!(
Os::Windows.executable_names("x", Some("")),
Os::Windows.executable_names("x", None),
"an empty PATHEXT is the default"
);
}
#[test]
fn programs_are_found_in_the_first_directory_holding_one() {
let files = [PathBuf::from("/b/tex"), PathBuf::from("/c/tex")];
let exists = |path: &Path| files.iter().any(|file| file == path);
let dirs = || ["/a", "/b", "/c"].map(PathBuf::from);
assert_eq!(
Os::Linux.find_executable("tex", dirs(), None, exists),
Some(PathBuf::from("/b/tex"))
);
assert_eq!(
Os::Linux.find_executable("latex", dirs(), None, exists),
None
);
assert_eq!(
Os::Linux.find_executable("/c/tex", dirs(), None, exists),
Some(PathBuf::from("/c/tex")),
"a path is looked up where it says"
);
assert_eq!(
Os::Linux.find_executable("/a/tex", dirs(), None, exists),
None
);
assert_eq!(Os::Linux.find_executable("tex", [], None, exists), None);
let files = [PathBuf::from("/bin/gswin64c.exe")];
let exists = |path: &Path| files.iter().any(|file| file == path);
assert_eq!(
Os::Windows.find_executable(
"gswin64c",
dirs().map(|_| "/bin".into()),
Some(".exe"),
exists
),
Some(PathBuf::from("/bin/gswin64c.exe"))
);
assert_eq!(
Os::Linux.find_executable("gswin64c", ["/bin".into()], Some(".exe"), exists),
None
);
}
#[test]
fn windows_paths_lose_the_verbatim_prefix() {
let strip = |text: &str| Os::Windows.without_verbatim_prefix(PathBuf::from(text));
assert_eq!(strip(r"\\?\C:\Users\me"), PathBuf::from(r"C:\Users\me"));
assert_eq!(
strip(r"\\?\UNC\host\share\x"),
PathBuf::from(r"\\host\share\x")
);
assert_eq!(strip(r"\\?\Volume{1}\x"), PathBuf::from(r"\\?\Volume{1}\x"));
assert_eq!(strip(r"C:\x"), PathBuf::from(r"C:\x"));
assert_eq!(strip(r"\\?\C:"), PathBuf::from(r"\\?\C:"));
assert_eq!(
Os::Linux.without_verbatim_prefix(PathBuf::from(r"\\?\C:\x")),
PathBuf::from(r"\\?\C:\x"),
"only Windows has verbatim paths"
);
}
#[test]
fn posix_spellings_use_slashes() {
let path = Path::new(r"C:\Users\me\tmp.eps");
assert_eq!(Os::Windows.as_posix(path), "C:/Users/me/tmp.eps");
assert_eq!(Os::Linux.as_posix(path), r"C:\Users\me\tmp.eps");
assert_eq!(Os::MacOs.as_posix(Path::new("/tmp/a b")), "/tmp/a b");
}
#[test]
fn url_paths_name_windows_drives() {
let windows = |path: &str| Os::Windows.native_url_path(path);
assert_eq!(
windows("/C:/Users/me/a%20b.mplstyle"),
r"C:\Users\me\a%20b.mplstyle"
);
assert_eq!(windows("/c|/x"), r"c:\x");
assert_eq!(windows("D|/x"), r"D:\x");
assert_eq!(windows("/dir/x"), r"\dir\x");
assert_eq!(windows("/1:/x"), r"1:\x");
assert_eq!(windows("/é|/x"), r"é:\x");
assert_eq!(windows(""), "");
for os in [Os::Linux, Os::MacOs] {
assert_eq!(os.native_url_path("/C:/x"), "/C:/x");
}
}
#[test]
fn the_process_finds_its_programs() {
assert_eq!(which("pltrs-no-such-program"), None);
if cfg!(unix) {
assert!(which("sh").is_some_and(|sh| sh.ends_with("sh")));
}
let dir = std::env::temp_dir();
assert_eq!(
resolve(&dir).unwrap(),
resolve(&resolve(&dir).unwrap()).unwrap()
);
assert!(resolve(&dir.join("pltrs-no-such-file")).is_err());
}
#[test]
fn home_directories_expand() {
let Some(home) = std::env::home_dir() else {
return;
};
assert_eq!(expand_user(Path::new("~")), home);
assert_eq!(expand_user(Path::new("~/a/b")), home.join("a/b"));
assert_eq!(expand_user(Path::new("a/~")), PathBuf::from("a/~"));
assert_eq!(expand_user(Path::new("~x")), PathBuf::from("~x"));
}
}