diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-04 12:41:41 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-04 12:41:41 +0000 |
commit | 10ee2acdd26a7f1298c6f6d6b7af9b469fe29b87 (patch) | |
tree | bdffd5d80c26cf4a7a518281a204be1ace85b4c1 /vendor/gix-path/src/convert.rs | |
parent | Releasing progress-linux version 1.70.0+dfsg1-9~progress7.99u1. (diff) | |
download | rustc-10ee2acdd26a7f1298c6f6d6b7af9b469fe29b87.tar.xz rustc-10ee2acdd26a7f1298c6f6d6b7af9b469fe29b87.zip |
Merging upstream version 1.70.0+dfsg2.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/gix-path/src/convert.rs')
-rw-r--r-- | vendor/gix-path/src/convert.rs | 273 |
1 files changed, 273 insertions, 0 deletions
diff --git a/vendor/gix-path/src/convert.rs b/vendor/gix-path/src/convert.rs new file mode 100644 index 000000000..6a949529f --- /dev/null +++ b/vendor/gix-path/src/convert.rs @@ -0,0 +1,273 @@ +use std::{ + borrow::Cow, + ffi::{OsStr, OsString}, + path::{Path, PathBuf}, +}; + +use bstr::{BStr, BString}; + +#[derive(Debug)] +/// The error type returned by [`into_bstr()`] and others may suffer from failed conversions from or to bytes. +pub struct Utf8Error; + +impl std::fmt::Display for Utf8Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("Could not convert to UTF8 or from UTF8 due to ill-formed input") + } +} + +impl std::error::Error for Utf8Error {} + +/// Like [`into_bstr()`], but takes `OsStr` as input for a lossless, but fallible, conversion. +pub fn os_str_into_bstr(path: &OsStr) -> Result<&BStr, Utf8Error> { + let path = try_into_bstr(Cow::Borrowed(path.as_ref()))?; + match path { + Cow::Borrowed(path) => Ok(path), + Cow::Owned(_) => unreachable!("borrowed cows stay borrowed"), + } +} + +/// Like [`into_bstr()`], but takes `OsString` as input for a lossless, but fallible, conversion. +pub fn os_string_into_bstring(path: OsString) -> Result<BString, Utf8Error> { + let path = try_into_bstr(Cow::Owned(path.into()))?; + match path { + Cow::Borrowed(_path) => unreachable!("borrowed cows stay borrowed"), + Cow::Owned(path) => Ok(path), + } +} + +/// Convert the given path either into its raw bytes on unix or its UTF8 encoded counterpart on windows. +/// +/// On windows, if the source Path contains ill-formed, lone surrogates, the UTF-8 conversion will fail +/// causing `Utf8Error` to be returned. +pub fn try_into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Result<Cow<'a, BStr>, Utf8Error> { + let path = path.into(); + let path_str = match path { + Cow::Owned(path) => Cow::Owned({ + #[cfg(unix)] + let p: BString = { + use std::os::unix::ffi::OsStringExt; + path.into_os_string().into_vec().into() + }; + #[cfg(target_os = "wasi")] + let p: BString = { + use std::os::wasi::ffi::OsStringExt; + path.into_os_string().into_vec().into() + }; + #[cfg(not(any(unix, target_os = "wasi")))] + let p: BString = path.into_os_string().into_string().map_err(|_| Utf8Error)?.into(); + p + }), + Cow::Borrowed(path) => Cow::Borrowed({ + #[cfg(unix)] + let p: &BStr = { + use std::os::unix::ffi::OsStrExt; + path.as_os_str().as_bytes().into() + }; + #[cfg(target_os = "wasi")] + let p: &BStr = { + use std::os::wasi::ffi::OsStrExt; + path.as_os_str().as_bytes().into() + }; + #[cfg(not(any(unix, target_os = "wasi")))] + let p: &BStr = path.to_str().ok_or(Utf8Error)?.as_bytes().into(); + p + }), + }; + Ok(path_str) +} + +/// Similar to [`try_into_bstr()`] but **panics** if malformed surrogates are encountered on windows. +pub fn into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Cow<'a, BStr> { + try_into_bstr(path).expect("prefix path doesn't contain ill-formed UTF-8") +} + +/// Given `input` bytes, produce a `Path` from them ignoring encoding entirely if on unix. +/// +/// On windows, the input is required to be valid UTF-8, which is guaranteed if we wrote it before. There are some potential +/// git versions and windows installation which produce mal-formed UTF-16 if certain emojies are in the path. It's as rare as +/// it sounds, but possible. +pub fn try_from_byte_slice(input: &[u8]) -> Result<&Path, Utf8Error> { + #[cfg(unix)] + let p = { + use std::os::unix::ffi::OsStrExt; + OsStr::from_bytes(input).as_ref() + }; + #[cfg(target_os = "wasi")] + let p: &Path = { + use std::os::wasi::ffi::OsStrExt; + OsStr::from_bytes(input).as_ref() + }; + #[cfg(not(any(unix, target_os = "wasi")))] + let p = Path::new(std::str::from_utf8(input).map_err(|_| Utf8Error)?); + Ok(p) +} + +/// Similar to [`from_byte_slice()`], but takes either borrowed or owned `input`. +pub fn try_from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> Result<Cow<'a, Path>, Utf8Error> { + let input = input.into(); + match input { + Cow::Borrowed(input) => try_from_byte_slice(input).map(Cow::Borrowed), + Cow::Owned(input) => try_from_bstring(input).map(Cow::Owned), + } +} + +/// Similar to [`try_from_bstr()`], but **panics** if malformed surrogates are encountered on windows. +pub fn from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> Cow<'a, Path> { + try_from_bstr(input).expect("prefix path doesn't contain ill-formed UTF-8") +} + +/// Similar to [`try_from_bstr()`], but takes and produces owned data. +pub fn try_from_bstring(input: impl Into<BString>) -> Result<PathBuf, Utf8Error> { + let input = input.into(); + #[cfg(unix)] + let p = { + use std::os::unix::ffi::OsStringExt; + std::ffi::OsString::from_vec(input.into()).into() + }; + #[cfg(target_os = "wasi")] + let p: PathBuf = { + use std::os::wasi::ffi::OsStringExt; + std::ffi::OsString::from_vec(input.into()).into() + }; + #[cfg(not(any(unix, target_os = "wasi")))] + let p = { + use bstr::ByteVec; + PathBuf::from( + { + let v: Vec<_> = input.into(); + v + } + .into_string() + .map_err(|_| Utf8Error)?, + ) + }; + Ok(p) +} + +/// Similar to [`try_from_bstring()`], but will **panic** if there is ill-formed UTF-8 in the `input`. +pub fn from_bstring(input: impl Into<BString>) -> PathBuf { + try_from_bstring(input).expect("well-formed UTF-8 on windows") +} + +/// Similar to [`try_from_byte_slice()`], but will **panic** if there is ill-formed UTF-8 in the `input`. +pub fn from_byte_slice(input: &[u8]) -> &Path { + try_from_byte_slice(input).expect("well-formed UTF-8 on windows") +} + +fn replace<'a>(path: impl Into<Cow<'a, BStr>>, find: u8, replace: u8) -> Cow<'a, BStr> { + let path = path.into(); + match path { + Cow::Owned(mut path) => { + for b in path.iter_mut().filter(|b| **b == find) { + *b = replace; + } + path.into() + } + Cow::Borrowed(path) => { + if !path.contains(&find) { + return path.into(); + } + let mut path = path.to_owned(); + for b in path.iter_mut().filter(|b| **b == find) { + *b = replace; + } + path.into() + } + } +} + +/// Assures the given bytes use the native path separator. +pub fn to_native_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> { + #[cfg(not(windows))] + let p = to_unix_separators(path); + #[cfg(windows)] + let p = to_windows_separators(path); + p +} + +/// Convert paths with slashes to backslashes on windows and do nothing on unix, but **panics** if malformed surrogates are encountered on windows. +pub fn to_native_path_on_windows<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, std::path::Path> { + #[cfg(not(windows))] + { + crate::from_bstr(path) + } + #[cfg(windows)] + { + crate::from_bstr(to_windows_separators(path)) + } +} + +/// Replaces windows path separators with slashes, but only do so on windows. +pub fn to_unix_separators_on_windows<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> { + #[cfg(windows)] + { + replace(path, b'\\', b'/') + } + #[cfg(not(windows))] + { + path.into() + } +} + +/// Replaces windows path separators with slashes, unconditionally. +/// +/// **Note** Do not use these and prefer the conditional versions of this method. +// TODO: use https://lib.rs/crates/path-slash to handle escapes +pub fn to_unix_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> { + replace(path, b'\\', b'/') +} + +/// Find backslashes and replace them with slashes, which typically resembles a unix path, unconditionally. +/// +/// **Note** Do not use these and prefer the conditional versions of this method. +// TODO: use https://lib.rs/crates/path-slash to handle escapes +pub fn to_windows_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> { + replace(path, b'/', b'\\') +} + +/// Resolve relative components virtually without accessing the file system, e.g. turn `a/./b/c/.././..` into `a`, +/// without keeping intermediate `..` and `/a/../b/..` becomes `/`. +/// If the input path was relative and ends up being the `current_dir`, `.` is returned instead of the full path to `current_dir`. +/// +/// This is particularly useful when manipulating paths that are based on user input, and not resolving intermediate +/// symlinks keeps the path similar to what the user provided. If that's not desirable, use `[realpath()][crate::realpath()` +/// instead. +/// +/// Note that we might access the `current_dir` if we run out of path components to pop off, which is expected to be absolute +/// as typical return value of `std::env::current_dir()`. +/// As a `current_dir` like `/c` can be exhausted by paths like `../../r`, `None` will be returned to indicate the inability +/// to produce a logically consistent path. +pub fn normalize<'a>(path: impl Into<Cow<'a, Path>>, current_dir: impl AsRef<Path>) -> Option<Cow<'a, Path>> { + use std::path::Component::ParentDir; + + let path = path.into(); + if !path.components().any(|c| matches!(c, ParentDir)) { + return Some(path); + } + let current_dir = current_dir.as_ref(); + let mut current_dir_opt = Some(current_dir); + let was_relative = path.is_relative(); + let components = path.components(); + let mut path = PathBuf::new(); + for component in components { + if let ParentDir = component { + let path_was_dot = path == Path::new("."); + if path.as_os_str().is_empty() || path_was_dot { + path.push(current_dir_opt.take()?); + } + if !path.pop() { + return None; + } + } else { + path.push(component) + } + } + + if (path.as_os_str().is_empty() || path == current_dir) && was_relative { + Cow::Borrowed(Path::new(".")) + } else { + path.into() + } + .into() +} |