Implement FuriString::{chars_lossy, char_indices_lossy, bytes}

This enables us to improve the `Debug` and `Display` impls.

Author: str4d

crates/flipperzero/src/furi/string.rs

@@ -16,6 +16,9 @@ use alloc::{borrow::Cow, boxed::Box, ffi::CString};
 
 use flipperzero_sys as sys;
 
+mod iter;
+use self::iter::{Bytes, CharIndices, Chars};
+
 mod pattern;
 use self::pattern::Pattern;
 
@@ -243,6 +246,50 @@ impl FuriString {
 // and that are useful for a non-slice string. Some of these are altered to be mutating
 // as we can't provide string slices.
 impl FuriString {
+    /// Returns an iterator over the [`char`]s of a `FuriString`.
+    ///
+    /// A `FuriString` might not contain valid UTF-8 (for example, if it represents a
+    /// string obtained through the Flipper Zero SDK).Any invalid UTF-8 sequences will be
+    /// replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: �
+    ///
+    /// [U+FFFD]: core::char::REPLACEMENT_CHARACTER
+    ///
+    /// It's important to remember that [`char`] represents a Unicode Scalar
+    /// Value, and might not match your idea of what a 'character' is. Iteration
+    /// over grapheme clusters may be what you actually want.
+    #[inline]
+    pub fn chars_lossy(&self) -> Chars<'_> {
+        Chars {
+            iter: self.to_bytes().iter(),
+        }
+    }
+
+    /// Returns an iterator over the [`char`]s of a `FuriString`, and their positions.
+    ///
+    /// A `FuriString` might not contain valid UTF-8 (for example, if it represents a
+    /// string obtained through the Flipper Zero SDK).Any invalid UTF-8 sequences will be
+    /// replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: �
+    ///
+    /// [U+FFFD]: core::char::REPLACEMENT_CHARACTER
+    ///
+    /// The iterator yields tuples. The position is first, the [`char`] is second.
+    #[inline]
+    pub fn char_indices_lossy(&self) -> CharIndices<'_> {
+        CharIndices {
+            front_offset: 0,
+            iter: self.chars_lossy(),
+        }
+    }
+
+    /// An iterator over the bytes of a string slice.
+    ///
+    /// As a string consists of a sequence of bytes, we can iterate through a string by
+    /// byte. This method returns such an iterator.
+    #[inline]
+    pub fn bytes(&self) -> Bytes<'_> {
+        Bytes(self.to_bytes().iter().copied())
+    }
+
     /// Returns `true` if the given pattern matches a sub-slice of this string slice.
     ///
     /// Returns `false` if it does not.
@@ -716,8 +763,8 @@ impl fmt::Debug for FuriString {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_char('"')?;
-        for byte in self.to_bytes().escape_ascii() {
-            f.write_char(byte as char)?;
+        for c in self.chars_lossy() {
+            f.write_char(c)?;
         }
         f.write_char('"')
     }
@@ -730,8 +777,8 @@ impl ufmt::uDebug for FuriString {
         W: ufmt::uWrite + ?Sized,
     {
         f.write_char('"')?;
-        for byte in self.to_bytes().escape_ascii() {
-            f.write_char(byte as char)?;
+        for c in self.chars_lossy() {
+            f.write_char(c)?;
         }
         f.write_char('"')
     }
@@ -740,8 +787,8 @@ impl ufmt::uDebug for FuriString {
 impl fmt::Display for FuriString {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for byte in self.to_bytes().escape_ascii() {
-            f.write_char(byte as char)?;
+        for c in self.chars_lossy() {
+            f.write_char(c)?;
         }
         Ok(())
     }
@@ -753,8 +800,8 @@ impl ufmt::uDisplay for FuriString {
     where
         W: ufmt::uWrite + ?Sized,
     {
-        for byte in self.to_bytes().escape_ascii() {
-            f.write_char(byte as char)?;
+        for c in self.chars_lossy() {
+            f.write_char(c)?;
         }
         Ok(())
     }
@@ -789,3 +836,26 @@ impl ufmt::uWrite for FuriString {
         Ok(())
     }
 }
+
+#[flipperzero_test::tests]
+mod tests {
+    use flipperzero_sys as sys;
+
+    use super::FuriString;
+
+    #[test]
+    fn invalid_utf8_is_replaced() {
+        // The German word für encoded in ISO 8859-1.
+        let d: [u8; 3] = [0x66, 0xfc, 0x72];
+
+        // Construct an invalid string using the Flipper Zero SDK.
+        let s = FuriString::new();
+        for b in d {
+            unsafe { sys::furi_string_push_back(s.0, b as i8) };
+        }
+
+        for (l, r) in s.chars_lossy().zip("f�r".chars()) {
+            assert_eq!(l, r);
+        }
+    }
+}

crates/flipperzero/src/lib.rs

@@ -26,6 +26,7 @@ flipperzero_test::tests_runner!(
     [
         crate::furi::message_queue::tests,
         crate::furi::rng::tests,
+        crate::furi::string::tests,
         crate::furi::sync::tests,
         crate::toolbox::crc32::tests,
         crate::toolbox::md5::tests,

crates/flipperzero/tests/string.rs

@@ -456,8 +456,8 @@ mod tests {
         let t = "ศไทย中华";
         let u = "Việt Nam";
 
-        // let a: String = s.chars().collect();
-        // assert_eq!(s, a);
+        let a: String = s.chars_lossy().collect();
+        assert_eq!(s, a);
 
         let mut b = String::from(t);
         b.extend(u.chars());
@@ -850,17 +850,17 @@ mod str_tests {
         // );
     }
 
-    /*
     #[test]
     fn collect() {
         let empty = String::from("");
-        let s: String = empty.chars().collect();
+        let s: String = empty.chars_lossy().collect();
         assert_eq!(empty, s);
         let data = String::from("ประเทศไทย中");
-        let s: String = data.chars().collect();
+        let s: String = data.chars_lossy().collect();
         assert_eq!(data, s);
     }
 
+    /*
     #[test]
     fn into_bytes() {
         let data = String::from("asdf");
@@ -1929,7 +1929,6 @@ mod str_tests {
         assert_eq!(String::from("22").cmp(&String::from("1234")), Greater);
     }
 
-    /*
     #[test]
     fn iterator() {
         let s = String::from("ศไทย中华Việt Nam");
@@ -1938,16 +1937,17 @@ mod str_tests {
         ];
 
         let mut pos = 0;
-        let it = s.chars();
+        let it = s.chars_lossy();
 
         for c in it {
             assert_eq!(c, v[pos]);
             pos += 1;
         }
         assert_eq!(pos, v.len());
-        assert_eq!(s.chars().count(), v.len());
+        assert_eq!(s.chars_lossy().count(), v.len());
     }
 
+    /*
     #[test]
     fn rev_iterator() {
         let s = String::from("ศไทย中华Việt Nam");
@@ -2004,8 +2004,8 @@ mod str_tests {
     fn chars_decoding() {
         let mut bytes = [0; 4];
         for c in (0..0x110000).filter_map(core::char::from_u32) {
-            let s = c.encode_utf8(&mut bytes);
-            if Some(c) != s.chars().next() {
+            let s = String::from(c.encode_utf8(&mut bytes));
+            if Some(c) != s.chars_lossy().next() {
                 panic!("character {:x}={} does not decode correctly", c as u32, c);
             }
         }
@@ -2021,32 +2021,35 @@ mod str_tests {
             }
         }
     }
+    */
 
     #[test]
     fn iterator_clone() {
         let s = String::from("ศไทย中华Việt Nam");
-        let mut it = s.chars();
+        let mut it = s.chars_lossy();
         it.next();
         assert!(it.clone().zip(it).all(|(x, y)| x == y));
     }
 
     #[test]
     fn iterator_last() {
         let s = String::from("ศไทย中华Việt Nam");
-        let mut it = s.chars();
+        let mut it = s.chars_lossy();
         it.next();
         assert_eq!(it.last(), Some('m'));
     }
 
+    /*
     #[test]
     fn chars_debug() {
-        let s = "ศไทย中华Việt Nam";
-        let c = s.chars();
+        let s = String::from("ศไทย中华Việt Nam");
+        let c = s.chars_lossy();
         assert_eq!(
             format!("{c:?}"),
             r#"Chars(['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm'])"#
         );
     }
+    */
 
     #[test]
     fn bytesator() {
@@ -2117,7 +2120,7 @@ mod str_tests {
         ];
 
         let mut pos = 0;
-        let it = s.char_indices();
+        let it = s.char_indices_lossy();
 
         for c in it {
             assert_eq!(c, (p[pos], v[pos]));
@@ -2127,6 +2130,7 @@ mod str_tests {
         assert_eq!(pos, p.len());
     }
 
+    /*
     #[test]
     fn char_indices_revator() {
         let s = String::from("ศไทย中华Việt Nam");
@@ -2145,15 +2149,17 @@ mod str_tests {
         assert_eq!(pos, v.len());
         assert_eq!(pos, p.len());
     }
+    */
 
     #[test]
     fn char_indices_last() {
         let s = String::from("ศไทย中华Việt Nam");
-        let mut it = s.char_indices();
+        let mut it = s.char_indices_lossy();
         it.next();
         assert_eq!(it.last(), Some((27, 'm')));
     }
 
+    /*
     #[test]
     fn splitn_char_iterator() {
         let data = "\nMäry häd ä little lämb\nLittle lämb\n";