Merge branch 'discovery-fix'

Author: Byron

git-path/src/convert.rs

@@ -1,7 +1,6 @@
 use std::{
     borrow::Cow,
     ffi::OsStr,
-    iter::FromIterator,
     path::{Path, PathBuf},
 };
 
@@ -220,6 +219,7 @@ pub fn to_windows_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr
 
 /// 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()`
@@ -238,28 +238,27 @@ pub fn normalize<'a>(path: impl Into<Cow<'a, Path>>, current_dir: impl AsRef<Pat
     }
     let current_dir = current_dir.as_ref();
     let mut current_dir_opt = Some(current_dir);
-    let mut components = path.components();
-    let mut path = PathBuf::from_iter(components.next());
+    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;
             }
-            if path.as_os_str().is_empty() {
-                path.clear();
-                path.push(current_dir_opt.take()?);
-                if path_was_dot && !path.pop() {
-                    return None;
-                }
-            }
         } else {
             path.push(component)
         }
     }
-    Some(if path.as_os_str().is_empty() || path == current_dir {
-        PathBuf::from(".").into()
+
+    if (path.as_os_str().is_empty() || path == current_dir) && was_relative {
+        Cow::Borrowed(Path::new("."))
     } else {
         path.into()
-    })
+    }
+    .into()
 }

git-path/tests/convert/normalize.rs

@@ -42,6 +42,28 @@ fn special_cases_around_cwd() -> crate::Result {
         "absolute CWDs are always shortened…"
     );
     assert_eq!(normalize(p("./a/.."), &cwd).unwrap(), p("."), "…like this as well…");
+    assert_eq!(
+        normalize(&cwd, &cwd).unwrap(),
+        cwd,
+        "…but only if there were relative to begin with."
+    );
+    assert_eq!(
+        normalize(p("."), &cwd).unwrap(),
+        p("."),
+        "and this means that `.`. stays `.`"
+    );
+    {
+        let mut path = cwd.clone();
+        let last_component = path.file_name().expect("directory").to_owned();
+        path.push("..");
+        path.push(last_component);
+
+        assert_eq!(
+            normalize(path, &cwd).unwrap(),
+            cwd,
+            "absolute input paths stay absolute"
+        );
+    }
     Ok(())
 }
 
@@ -53,6 +75,18 @@ fn parent_dirs_cause_the_cwd_to_be_used() {
     );
 }
 
+#[test]
+fn multiple_parent_dir_movements_eat_into_the_current_dir() {
+    assert_eq!(
+        normalize(p("../../../d/e"), "/users/name/a/b/c").unwrap().as_ref(),
+        p("/users/name/d/e")
+    );
+    assert_eq!(
+        normalize(p("c/../../../d/e"), "/users/name/a/b").unwrap().as_ref(),
+        p("/users/name/d/e")
+    );
+}
+
 #[test]
 fn walking_up_too_much_yield_none() {
     let cwd = "/users/name";
@@ -71,14 +105,15 @@ fn trailing_directories_after_too_numereous_parent_dirs_yield_none() {
 
 #[test]
 fn trailing_relative_components_are_resolved() {
-    let cwd = std::env::current_dir().unwrap();
+    let cwd = Path::new("/a/b/c");
     for (input, expected) in [
         ("./a/b/./c/../d/..", "./a/b"),
         ("a/./b/c/.././..", "a"),
         ("/a/b/c/.././../.", "/a"),
         ("./a/..", "."),
         ("a/..", "."),
         ("./a", "./a"),
+        ("./a/./b", "./a/./b"),
         ("./a/./b/..", "./a/."),
         ("/a/./b/c/.././../.", "/a"),
         ("/a/./b", "/a/./b"),
@@ -90,7 +125,7 @@ fn trailing_relative_components_are_resolved() {
     ] {
         let path = p(input);
         assert_eq!(
-            normalize(path, &cwd).unwrap_or_else(|| panic!("{path:?}")),
+            normalize(path, cwd).unwrap_or_else(|| panic!("{path:?}")),
             Cow::Borrowed(p(expected)),
             "'{}' got an unexpected result",
             input