fix(dirname): handle paths ending in /. correctly

Fixes #8910

Match POSIX/GNU behavior where dirname("/home/dos/.") returns
"/home/dos" instead of "/home". This aligns with the basename fix
from #8373 (c5268a8).

The issue occurs because Rust's Path::parent() normalizes paths,
treating "/home/dos/." the same as "/home/dos/", both returning
"/home" as the parent. This breaks tools like homeshick that rely
on correct dirname behavior for symlink generation.

Solution:
- Detect paths ending in "/." using byte-level checking
- Strip the "/." suffix manually before path operations
- Handle edge case: "/." -> "/"
- Preserve non-UTF-8 path handling with platform-specific code
- Add comprehensive tests covering edge cases

Tests added:
- Basic "/." handling (5 test cases)
- Flag interaction with -z/--zero
- Multiple paths with mixed "/." suffixes
- Edge cases: double slashes, dots in middle
- Unicode/emoji paths
- Non-UTF-8 paths (Unix only)
- Backward compatibility verification (7 test cases)

Author: naoNao89

src/uu/dirname/src/dirname.rs

@@ -35,20 +35,57 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     for path in &dirnames {
-        let p = Path::new(path);
-        match p.parent() {
-            Some(d) => {
-                if d.components().next().is_none() {
-                    print!(".");
-                } else {
-                    print_verbatim(d).unwrap();
+        // Handle special case where path ends with /.
+        // This matches GNU/POSIX behavior where dirname("/home/dos/.") returns "/home/dos"
+        // rather than "/home" (which would be the result of Path::parent() due to normalization).
+        // Per POSIX.1-2017 dirname specification and GNU coreutils manual:
+        // - POSIX: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname.html
+        // - GNU: https://www.gnu.org/software/coreutils/manual/html_node/dirname-invocation.html
+        // dirname should do simple string manipulation without path normalization.
+        // See issue #8910 and similar fix in basename (#8373, commit c5268a897).
+        let path_bytes = uucore::os_str_as_bytes(path.as_os_str()).unwrap_or(&[]);
+        if path_bytes.ends_with(b"/.") {
+            // Strip the "/." suffix and print the result
+            if path_bytes.len() == 2 {
+                // Special case: "/." -> "/"
+                print!("/");
+            } else {
+                // General case: "/home/dos/." -> "/home/dos"
+                let stripped = &path_bytes[..path_bytes.len() - 2];
+                #[cfg(unix)]
+                {
+                    use std::os::unix::ffi::OsStrExt;
+                    let result = std::ffi::OsStr::from_bytes(stripped);
+                    print_verbatim(result).unwrap();
+                }
+                #[cfg(not(unix))]
+                {
+                    // On non-Unix, fall back to lossy conversion
+                    if let Ok(s) = std::str::from_utf8(stripped) {
+                        print!("{}", s);
+                    } else {
+                        // Fallback for invalid UTF-8
+                        print_verbatim(Path::new(path)).unwrap();
+                    }
                 }
             }
-            None => {
-                if p.is_absolute() || path.as_os_str() == "/" {
-                    print!("/");
-                } else {
-                    print!(".");
+        } else {
+            // Normal path handling using Path::parent()
+            let p = Path::new(path);
+            match p.parent() {
+                Some(d) => {
+                    if d.components().next().is_none() {
+                        print!(".");
+                    } else {
+                        print_verbatim(d).unwrap();
+                    }
+                }
+                None => {
+                    if p.is_absolute() || path.as_os_str() == "/" {
+                        print!("/");
+                    } else {
+                        print!(".");
+                    }
                 }
             }
         }

tests/by-util/test_dirname.rs

@@ -102,3 +102,135 @@ fn test_emoji_handling() {
         .succeeds()
         .stdout_is("/🌟/emoji/path\u{0}");
 }
+
+#[test]
+fn test_trailing_dot() {
+    // Basic case: path ending with /. should return parent without stripping last component
+    // This matches GNU coreutils behavior and fixes issue #8910
+    new_ucmd!()
+        .arg("/home/dos/.")
+        .succeeds()
+        .stdout_is("/home/dos\n");
+
+    // Root with dot
+    new_ucmd!().arg("/.").succeeds().stdout_is("/\n");
+
+    // Relative path with /.
+    new_ucmd!().arg("hello/.").succeeds().stdout_is("hello\n");
+
+    // Deeper path with /.
+    new_ucmd!()
+        .arg("/foo/bar/baz/.")
+        .succeeds()
+        .stdout_is("/foo/bar/baz\n");
+
+    // Multiple components
+    new_ucmd!()
+        .arg("/usr/local/bin/.")
+        .succeeds()
+        .stdout_is("/usr/local/bin\n");
+}
+
+#[test]
+fn test_trailing_dot_with_zero_flag() {
+    // Test that -z flag works correctly with /. paths
+    new_ucmd!()
+        .arg("-z")
+        .arg("/home/dos/.")
+        .succeeds()
+        .stdout_is("/home/dos\u{0}");
+
+    new_ucmd!()
+        .arg("--zero")
+        .arg("/.")
+        .succeeds()
+        .stdout_is("/\u{0}");
+}
+
+#[test]
+fn test_trailing_dot_multiple_paths() {
+    // Test multiple paths, some with /. suffix
+    new_ucmd!()
+        .args(&["/home/dos/.", "/var/log", "/tmp/."])
+        .succeeds()
+        .stdout_is("/home/dos\n/var\n/tmp\n");
+}
+
+#[test]
+fn test_trailing_dot_edge_cases() {
+    // Double slash before dot (should still work)
+    new_ucmd!()
+        .arg("/home/dos//.")
+        .succeeds()
+        .stdout_is("/home/dos/\n");
+
+    // Path with . in middle (should use normal logic)
+    new_ucmd!()
+        .arg("/path/./to/file")
+        .succeeds()
+        .stdout_is("/path/./to\n");
+}
+
+#[test]
+fn test_trailing_dot_emoji() {
+    // Emoji paths with /. suffix
+    new_ucmd!()
+        .arg("/🌍/path/.")
+        .succeeds()
+        .stdout_is("/🌍/path\n");
+
+    new_ucmd!().arg("/🎉/🚀/.").succeeds().stdout_is("/🎉/🚀\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_trailing_dot_non_utf8() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    // Create a path with non-UTF-8 bytes ending in /.
+    let non_utf8_bytes = b"/test_\xFF\xFE/.";
+    let non_utf8_path = OsStr::from_bytes(non_utf8_bytes);
+
+    // Test that dirname handles non-UTF-8 paths with /. suffix
+    let result = new_ucmd!().arg(non_utf8_path).succeeds();
+
+    // The output should be the path without the /. suffix
+    let output = result.stdout_str_lossy();
+    assert!(!output.is_empty());
+    assert!(output.contains("test_"));
+    // Should not contain the . at the end
+    assert!(!output.trim().ends_with('.'));
+}
+
+#[test]
+fn test_existing_behavior_preserved() {
+    // Ensure we didn't break existing test cases
+    // These tests verify backward compatibility
+
+    // Normal paths without /. should work as before
+    new_ucmd!().arg("/home/dos").succeeds().stdout_is("/home\n");
+
+    new_ucmd!()
+        .arg("/home/dos/")
+        .succeeds()
+        .stdout_is("/home\n");
+
+    // Parent directory references
+    new_ucmd!()
+        .arg("/home/dos/..")
+        .succeeds()
+        .stdout_is("/home/dos\n");
+
+    // Root
+    new_ucmd!().arg("/").succeeds().stdout_is("/\n");
+
+    // Current directory
+    new_ucmd!().arg(".").succeeds().stdout_is(".\n");
+
+    // Parent reference
+    new_ucmd!().arg("..").succeeds().stdout_is(".\n");
+
+    // Empty string
+    new_ucmd!().arg("").succeeds().stdout_is(".\n");
+}