nu-path crate refactor (#3730)

* Resolve rebase artifacts

* Remove leftover dependencies on removed feature

* Remove unnecessary 'pub'

* Start taking notes and fooling around

* Split canonicalize to two versions; Add TODOs

One that takes `relative_to` and one that doesn't.
More TODO notes.

* Merge absolutize to and rename resolve_dots

* Add custom absolutize fn and use it in path expand

* Convert a couple of dunce::canonicalize to ours

* Update nu-path description

* Replace all canonicalize with nu-path version

* Remove leftover dunce dependencies

* Fix broken autocd with trailing slash

Trailing slash is preserved *only* in paths that do not contain "." or
"..". This should be fixed in the future to cover all paths but for now
it at least covers basic cases.

* Use dunce::canonicalize for canonicalizing

* Alow cd recovery from non-existent cwd

* Disable removed canonicalize functionality tests

Remove unused import

* Break down nu-path into separate modules

* Remove unused public imports

* Remove abundant cow mapping

* Fix clippy warning

* Reformulate old canonicalize tests to expand_path

They wouldn't work with the new canonicalize.

* Canonicalize also ~ and ndots; Unify path joining

Also, add doc comments in nu_path::expansions.

* Add comment

* Avoid expanding ndots if path is not valid UTF-8

With this change, no lossy path->string conversion should happen in the
nu-path crate.

* Fmt

* Slight expand_tilde refactor; Add doc comments

* Start nu-path integration tests

* Add tests TODO

* Fix docstring typo

* Fix some doc strings

* Add README for nu-path crate

* Add a couple of canonicalize tests

* Add nu-path integration tests

* Add trim trailing slashes tests

* Update nu-path dependency

* Remove unused import

* Regenerate lockfile

crates/nu-path/src/tilde.rs

@@ -0,0 +1,85 @@
+use std::path::{Path, PathBuf};
+
+fn expand_tilde_with(path: impl AsRef<Path>, home: Option<PathBuf>) -> PathBuf {
+    let path = path.as_ref();
+
+    if !path.starts_with("~") {
+        return path.into();
+    }
+
+    match home {
+        None => path.into(),
+        Some(mut h) => {
+            if h == Path::new("/") {
+                // Corner case: `h` is a root directory;
+                // don't prepend extra `/`, just drop the tilde.
+                path.strip_prefix("~").unwrap_or(path).into()
+            } else {
+                if let Ok(p) = path.strip_prefix("~/") {
+                    h.push(p)
+                }
+                h
+            }
+        }
+    }
+}
+
+/// Expand tilde ("~") into a home directory if it is the first path component
+pub fn expand_tilde(path: impl AsRef<Path>) -> PathBuf {
+    // TODO: Extend this to work with "~user" style of home paths
+    expand_tilde_with(path, dirs_next::home_dir())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn check_expanded(s: &str) {
+        let home = Path::new("/home");
+        let buf = Some(PathBuf::from(home));
+        assert!(expand_tilde_with(Path::new(s), buf).starts_with(&home));
+
+        // Tests the special case in expand_tilde for "/" as home
+        let home = Path::new("/");
+        let buf = Some(PathBuf::from(home));
+        assert!(!expand_tilde_with(Path::new(s), buf).starts_with("//"));
+    }
+
+    fn check_not_expanded(s: &str) {
+        let home = PathBuf::from("/home");
+        let expanded = expand_tilde_with(Path::new(s), Some(home));
+        assert!(expanded == Path::new(s));
+    }
+
+    #[test]
+    fn string_with_tilde() {
+        check_expanded("~");
+    }
+
+    #[test]
+    fn string_with_tilde_forward_slash() {
+        check_expanded("~/test/");
+    }
+
+    #[test]
+    fn string_with_tilde_double_forward_slash() {
+        check_expanded("~//test/");
+    }
+
+    #[test]
+    fn does_not_expand_tilde_if_tilde_is_not_first_character() {
+        check_not_expanded("1~1");
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn string_with_tilde_backslash() {
+        check_expanded("~\\test/test2/test3");
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn string_with_double_tilde_backslash() {
+        check_expanded("~\\\\test\\test2/test3");
+    }
+}