diff options
Diffstat (limited to 'helix-stdx/src/path.rs')
| -rw-r--r-- | helix-stdx/src/path.rs | 185 |
1 files changed, 185 insertions, 0 deletions
diff --git a/helix-stdx/src/path.rs b/helix-stdx/src/path.rs new file mode 100644 index 00000000..5746657c --- /dev/null +++ b/helix-stdx/src/path.rs @@ -0,0 +1,185 @@ +pub use etcetera::home_dir; + +use std::path::{Component, Path, PathBuf}; + +use crate::env::current_working_dir; + +/// Replaces users home directory from `path` with tilde `~` if the directory +/// is available, otherwise returns the path unchanged. +pub fn fold_home_dir(path: &Path) -> PathBuf { + if let Ok(home) = home_dir() { + if let Ok(stripped) = path.strip_prefix(&home) { + return PathBuf::from("~").join(stripped); + } + } + + path.to_path_buf() +} + +/// Expands tilde `~` into users home directory if available, otherwise returns the path +/// unchanged. The tilde will only be expanded when present as the first component of the path +/// and only slash follows it. +pub fn expand_tilde(path: impl AsRef<Path>) -> PathBuf { + let path = path.as_ref(); + let mut components = path.components().peekable(); + if let Some(Component::Normal(c)) = components.peek() { + if c == &"~" { + if let Ok(home) = home_dir() { + // it's ok to unwrap, the path starts with `~` + return home.join(path.strip_prefix("~").unwrap()); + } + } + } + + path.to_path_buf() +} + +/// Normalize a path without resolving symlinks. +// Strategy: start from the first component and move up. Cannonicalize previous path, +// join component, cannonicalize new path, strip prefix and join to the final result. +pub fn normalize(path: impl AsRef<Path>) -> PathBuf { + let mut components = path.as_ref().components().peekable(); + let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() { + components.next(); + PathBuf::from(c.as_os_str()) + } else { + PathBuf::new() + }; + + for component in components { + match component { + Component::Prefix(..) => unreachable!(), + Component::RootDir => { + ret.push(component.as_os_str()); + } + Component::CurDir => {} + #[cfg(not(windows))] + Component::ParentDir => { + ret.pop(); + } + #[cfg(windows)] + Component::ParentDir => { + if let Some(head) = ret.components().next_back() { + match head { + Component::Prefix(_) | Component::RootDir => {} + Component::CurDir => unreachable!(), + // If we left previous component as ".." it means we met a symlink before and we can't pop path. + Component::ParentDir => { + ret.push(".."); + } + Component::Normal(_) => { + if ret.is_symlink() { + ret.push(".."); + } else { + ret.pop(); + } + } + } + } + } + #[cfg(not(windows))] + Component::Normal(c) => { + ret.push(c); + } + #[cfg(windows)] + Component::Normal(c) => 'normal: { + use std::fs::canonicalize; + + let new_path = ret.join(c); + if new_path.is_symlink() { + ret = new_path; + break 'normal; + } + let (can_new, can_old) = (canonicalize(&new_path), canonicalize(&ret)); + match (can_new, can_old) { + (Ok(can_new), Ok(can_old)) => { + let striped = can_new.strip_prefix(can_old); + ret.push(striped.unwrap_or_else(|_| c.as_ref())); + } + _ => ret.push(c), + } + } + } + } + dunce::simplified(&ret).to_path_buf() +} + +/// Returns the canonical, absolute form of a path with all intermediate components normalized. +/// +/// This function is used instead of [`std::fs::canonicalize`] because we don't want to verify +/// here if the path exists, just normalize it's components. +pub fn canonicalize(path: impl AsRef<Path>) -> PathBuf { + let path = expand_tilde(path); + let path = if path.is_relative() { + current_working_dir().join(path) + } else { + path + }; + + normalize(path) +} + +pub fn get_relative_path(path: impl AsRef<Path>) -> PathBuf { + let path = PathBuf::from(path.as_ref()); + let path = if path.is_absolute() { + let cwdir = normalize(current_working_dir()); + normalize(&path) + .strip_prefix(cwdir) + .map(PathBuf::from) + .unwrap_or(path) + } else { + path + }; + fold_home_dir(&path) +} + +/// Returns a truncated filepath where the basepart of the path is reduced to the first +/// char of the folder and the whole filename appended. +/// +/// Also strip the current working directory from the beginning of the path. +/// Note that this function does not check if the truncated path is unambiguous. +/// +/// ``` +/// use helix_stdx::path::get_truncated_path; +/// use std::path::Path; +/// +/// assert_eq!( +/// get_truncated_path("/home/cnorris/documents/jokes.txt").as_path(), +/// Path::new("/h/c/d/jokes.txt") +/// ); +/// assert_eq!( +/// get_truncated_path("jokes.txt").as_path(), +/// Path::new("jokes.txt") +/// ); +/// assert_eq!( +/// get_truncated_path("/jokes.txt").as_path(), +/// Path::new("/jokes.txt") +/// ); +/// assert_eq!( +/// get_truncated_path("/h/c/d/jokes.txt").as_path(), +/// Path::new("/h/c/d/jokes.txt") +/// ); +/// assert_eq!(get_truncated_path("").as_path(), Path::new("")); +/// ``` +/// +pub fn get_truncated_path(path: impl AsRef<Path>) -> PathBuf { + let cwd = current_working_dir(); + let path = path + .as_ref() + .strip_prefix(cwd) + .unwrap_or_else(|_| path.as_ref()); + let file = path.file_name().unwrap_or_default(); + let base = path.parent().unwrap_or_else(|| Path::new("")); + let mut ret = PathBuf::new(); + for d in base { + ret.push( + d.to_string_lossy() + .chars() + .next() + .unwrap_or_default() + .to_string(), + ); + } + ret.push(file); + ret +} |