Create helix-stdx crate for stdlib extensions

helix-stdx is meant to carry extensions to the stdlib or low-level
dependencies that are useful in all other crates. This commit starts
with all of the path functions from helix-core and the CWD tracking that
lived in helix-loader.

The CWD tracking in helix-loader was previously unable to call the
canonicalization functions in helix-core. Switching to our custom
canonicalization code should make no noticeable difference though
since `std::env::current_dir` returns a canonicalized path with
symlinks resolved (at least on unix).

4 files changed, 1 insertions, 307 deletions

diff --git a/helix-core/Cargo.toml b/helix-core/Cargo.toml
index 07c801b8..42c88f4b 100644
--- a/helix-core/Cargo.toml
+++ b/helix-core/Cargo.toml
@@ -16,6 +16,7 @@ unicode-lines = ["ropey/unicode_lines"]
 integration = []
 
 [dependencies]
+helix-stdx = { path = "../helix-stdx" }
 helix-loader = { path = "../helix-loader" }
 
 ropey = { version = "1.6.1", default-features = false, features = ["simd"] }
@@ -55,4 +56,3 @@ parking_lot = "0.12"
 [dev-dependencies]
 quickcheck = { version = "1", default-features = false }
 indoc = "2.0.4"
-tempfile = "3.9"
diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs
index 0acdb238..94802eba 100644
--- a/helix-core/src/lib.rs
+++ b/helix-core/src/lib.rs
@@ -17,7 +17,6 @@ pub mod macros;
 pub mod match_brackets;
 pub mod movement;
 pub mod object;
-pub mod path;
 mod position;
 pub mod search;
 pub mod selection;
diff --git a/helix-core/src/path.rs b/helix-core/src/path.rs
deleted file mode 100644
index 0cf6f812..00000000
--- a/helix-core/src/path.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-use etcetera::home_dir;
-use std::path::{Component, Path, PathBuf};
-
-/// 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: &Path) -> PathBuf {
-    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 get_normalized_path(path: &Path) -> PathBuf {
-    let mut components = path.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 get_canonicalized_path(path: &Path) -> PathBuf {
-    let path = expand_tilde(path);
-    let path = if path.is_relative() {
-        helix_loader::current_working_dir().join(path)
-    } else {
-        path
-    };
-
-    get_normalized_path(path.as_path())
-}
-
-pub fn get_relative_path(path: &Path) -> PathBuf {
-    let path = PathBuf::from(path);
-    let path = if path.is_absolute() {
-        let cwdir = get_normalized_path(&helix_loader::current_working_dir());
-        get_normalized_path(&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_core::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<P: AsRef<Path>>(path: P) -> PathBuf {
-    let cwd = helix_loader::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
-}
diff --git a/helix-core/tests/path.rs b/helix-core/tests/path.rs
deleted file mode 100644
index cbda5e1a..00000000
--- a/helix-core/tests/path.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#![cfg(windows)]
-
-use std::{
-    env::set_current_dir,
-    error::Error,
-    path::{Component, Path, PathBuf},
-};
-
-use helix_core::path::get_normalized_path;
-use tempfile::Builder;
-
-// Paths on Windows are almost always case-insensitive.
-// Normalization should return the original path.
-// E.g. mkdir `CaSe`, normalize(`case`) = `CaSe`.
-#[test]
-fn test_case_folding_windows() -> Result<(), Box<dyn Error>> {
-    // tmp/root/case
-    let tmp_prefix = std::env::temp_dir();
-    set_current_dir(&tmp_prefix)?;
-
-    let root = Builder::new().prefix("root-").tempdir()?;
-    let case = Builder::new().prefix("CaSe-").tempdir_in(&root)?;
-
-    let root_without_prefix = root.path().strip_prefix(&tmp_prefix)?;
-
-    let lowercase_case = format!(
-        "case-{}",
-        case.path()
-            .file_name()
-            .unwrap()
-            .to_string_lossy()
-            .split_at(5)
-            .1
-    );
-    let test_path = root_without_prefix.join(lowercase_case);
-    assert_eq!(
-        get_normalized_path(&test_path),
-        case.path().strip_prefix(&tmp_prefix)?
-    );
-
-    Ok(())
-}
-
-#[test]
-fn test_normalize_path() -> Result<(), Box<dyn Error>> {
-    /*
-    tmp/root/
-    ├── link -> dir1/orig_file
-    ├── dir1/
-    │   └── orig_file
-    └── dir2/
-        └── dir_link -> ../dir1/
-    */
-
-    let tmp_prefix = std::env::temp_dir();
-    set_current_dir(&tmp_prefix)?;
-
-    // Create a tree structure as shown above
-    let root = Builder::new().prefix("root-").tempdir()?;
-    let dir1 = Builder::new().prefix("dir1-").tempdir_in(&root)?;
-    let orig_file = Builder::new().prefix("orig_file-").tempfile_in(&dir1)?;
-    let dir2 = Builder::new().prefix("dir2-").tempdir_in(&root)?;
-
-    // Create path and delete existing file
-    let dir_link = Builder::new()
-        .prefix("dir_link-")
-        .tempfile_in(&dir2)?
-        .path()
-        .to_owned();
-    let link = Builder::new()
-        .prefix("link-")
-        .tempfile_in(&root)?
-        .path()
-        .to_owned();
-
-    use std::os::windows;
-    windows::fs::symlink_dir(&dir1, &dir_link)?;
-    windows::fs::symlink_file(&orig_file, &link)?;
-
-    // root/link
-    let path = link.strip_prefix(&tmp_prefix)?;
-    assert_eq!(
-        get_normalized_path(path),
-        path,
-        "input {:?} and symlink last component shouldn't be resolved",
-        path
-    );
-
-    // root/dir2/dir_link/orig_file/../..
-    let path = dir_link
-        .strip_prefix(&tmp_prefix)
-        .unwrap()
-        .join(orig_file.path().file_name().unwrap())
-        .join(Component::ParentDir)
-        .join(Component::ParentDir);
-    let expected = dir_link
-        .strip_prefix(&tmp_prefix)
-        .unwrap()
-        .join(Component::ParentDir);
-    assert_eq!(
-        get_normalized_path(&path),
-        expected,
-        "input {:?} and \"..\" should not erase the simlink that goes ahead",
-        &path
-    );
-
-    // root/link/.././../dir2/../
-    let path = link
-        .strip_prefix(&tmp_prefix)
-        .unwrap()
-        .join(Component::ParentDir)
-        .join(Component::CurDir)
-        .join(Component::ParentDir)
-        .join(dir2.path().file_name().unwrap())
-        .join(Component::ParentDir);
-    let expected = link
-        .strip_prefix(&tmp_prefix)
-        .unwrap()
-        .join(Component::ParentDir)
-        .join(Component::ParentDir);
-    assert_eq!(get_normalized_path(&path), expected, "input {:?}", &path);
-
-    Ok(())
-}