feat: add str::to_precomposed_unicode(), effective on apple devices only.

Author: Byron

Cargo.lock

@@ -14,3 +14,5 @@ doctest = false
 
 [dependencies]
 fastrand = "2.0.0"
+unicode-normalization = { version = "0.1.19", default-features = false }
+

gix-utils/Cargo.toml

@@ -10,6 +10,9 @@ pub mod backoff;
 ///
 pub mod buffers;
 
+///
+pub mod str;
+
 /// A utility to do buffer-swapping with.
 ///
 /// Use `src` to read from and `dest` to write to, and after actually changing data, call [Buffers::swap()].

gix-utils/src/lib.rs

@@ -0,0 +1,53 @@
+use std::borrow::Cow;
+use std::ffi::OsStr;
+use std::path::Path;
+
+/// Assure that `s` is precomposed, i.e. `ä` is a single code-point, and not two i.e. `a` and `<umlaut>`.
+///
+/// At the expense of extra-compute, it does nothing if there is no work to be done, returning the original input without allocating.
+pub fn precompose(s: Cow<'_, str>) -> Cow<'_, str> {
+    use unicode_normalization::UnicodeNormalization;
+    if s.as_ref().nfc().cmp(s.as_ref().chars()).is_eq() {
+        s
+    } else {
+        Cow::Owned(s.as_ref().nfc().collect())
+    }
+}
+
+/// Assure that `s` is decomposed, i.e. `ä` turns into `a` and `<umlaut>`.
+///
+/// At the expense of extra-compute, it does nothing if there is no work to be done, returning the original input without allocating.
+pub fn decompose(s: Cow<'_, str>) -> Cow<'_, str> {
+    use unicode_normalization::UnicodeNormalization;
+    if s.as_ref().nfd().cmp(s.as_ref().chars()).is_eq() {
+        s
+    } else {
+        Cow::Owned(s.as_ref().nfd().collect())
+    }
+}
+
+/// Return the precomposed version of `path`, or `path` itself if it contained illformed unicode,
+/// or if the unicode version didn't contains decomposed unicode.
+/// Otherwise, similar to [`precompose()`]
+pub fn precompose_path(path: Cow<'_, Path>) -> Cow<'_, Path> {
+    match path.to_str() {
+        None => path,
+        Some(maybe_decomposed) => match precompose(maybe_decomposed.into()) {
+            Cow::Borrowed(_) => path,
+            Cow::Owned(precomposed) => Cow::Owned(precomposed.into()),
+        },
+    }
+}
+
+/// Return the precomposed version of `name`, or `name` itself if it contained illformed unicode,
+/// or if the unicode version didn't contains decomposed unicode.
+/// Otherwise, similar to [`precompose()`]
+pub fn precompose_os_string(path: Cow<'_, OsStr>) -> Cow<'_, OsStr> {
+    match path.to_str() {
+        None => path,
+        Some(maybe_decomposed) => match precompose(maybe_decomposed.into()) {
+            Cow::Borrowed(_) => path,
+            Cow::Owned(precomposed) => Cow::Owned(precomposed.into()),
+        },
+    }
+}

gix-utils/src/str.rs

@@ -0,0 +1,44 @@
+mod decompose {
+    use std::borrow::Cow;
+
+    #[test]
+    fn precomposed_unicode_is_decomposed() {
+        let precomposed = "ä";
+        let actual = gix_utils::str::decompose(precomposed.into());
+        assert!(matches!(actual, Cow::Owned(_)), "new data is produced");
+        assert_eq!(actual, "a\u{308}");
+    }
+
+    #[test]
+    fn already_decomposed_does_not_copy() {
+        let decomposed = "a\u{308}";
+        let actual = gix_utils::str::decompose(decomposed.into());
+        assert!(
+            matches!(actual, Cow::Borrowed(_)),
+            "pass-through as nothing needs to be done"
+        );
+        assert_eq!(actual, decomposed);
+    }
+}
+
+mod precompose {
+    use std::borrow::Cow;
+
+    #[test]
+    fn decomposed_unicode_is_precomposed() {
+        let decomposed = "a\u{308}";
+        let actual = gix_utils::str::precompose(decomposed.into());
+        assert!(matches!(actual, Cow::Owned(_)), "new data is produced");
+        assert_eq!(actual.chars().collect::<Vec<_>>(), ['ä']);
+    }
+
+    #[test]
+    fn already_precomposed_does_not_copy() {
+        let actual = gix_utils::str::precompose("ä".into());
+        assert!(
+            matches!(actual, Cow::Borrowed(_)),
+            "pass-through as nothing needs to be done"
+        );
+        assert_eq!(actual.chars().collect::<Vec<_>>(), ['ä']);
+    }
+}

gix-utils/tests/str/mod.rs

@@ -1,2 +1,3 @@
 mod backoff;
 mod buffers;
+mod str;