fix: split_long_word incorrectly splits multi-codepoint character

Cargo.toml

@@ -53,15 +53,18 @@ debug = []
 integration_test = []
 
 [dependencies]
+unicode-segmentation = { version = "1" }
+unicode-width = { version = "0.2" }
+
+# Optional dependencies
 ansi-str = { version = "0.8", optional = true }
 console = { version = "0.15", optional = true }
-unicode-width = "0.2"
 
 [dev-dependencies]
 criterion = "0.5"
 pretty_assertions = "1"
 proptest = "1"
-rand = "0.8"
+rand = "0.9"
 rstest = "0.24"
 
 # We don't need any of the default features for crossterm.

benches/build_large_table.rs

@@ -2,11 +2,11 @@ use criterion::{criterion_group, criterion_main, Criterion};
 
 use comfy_table::presets::UTF8_FULL;
 use comfy_table::*;
-use rand::distributions::Alphanumeric;
+use rand::distr::Alphanumeric;
 use rand::Rng;
 
 /// Create a dynamic 10x500 Table with width 300 and unevenly distributed content.
-/// There're no constriant, the content simply has to be formatted to fit as good as possible into
+/// There are no constraint, the content simply has to be formatted to fit as good as possible into
 /// the given space.
 fn build_huge_table() {
     let mut table = Table::new();
@@ -16,12 +16,12 @@ fn build_huge_table() {
         .set_width(300)
         .set_header(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     // Create a 10x10 grid
     for _ in 0..500 {
         let mut row = Vec::new();
         for _ in 0..10 {
-            let string_length = rng.gen_range(2..100);
+            let string_length = rng.random_range(2..100);
             let random_string: String = (&mut rng)
                 .sample_iter(&Alphanumeric)
                 .take(string_length)

src/utils/formatting/content_split/normal.rs

@@ -1,4 +1,5 @@
-use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
 
 /// returns printed length of string
 /// if ansi feature enabled, takes into account escape codes
@@ -22,12 +23,12 @@ pub fn split_long_word(allowed_width: usize, word: &str) -> (String, String) {
     let mut current_width = 0;
     let mut parts = String::new();
 
-    let mut char_iter = word.chars().peekable();
+    let mut char_iter = word.graphemes(true).peekable();
     // Check if the string might be too long, one character at a time.
     // Peek into the next char and check the exit condition.
     // That is, pushing the next character would result in the string being too long.
     while let Some(c) = char_iter.peek() {
-        if (current_width + c.width().unwrap_or(1)) > allowed_width {
+        if (current_width + c.width()) > allowed_width {
             break;
         }
 
@@ -36,15 +37,37 @@ pub fn split_long_word(allowed_width: usize, word: &str) -> (String, String) {
 
         // We default to 1 char, if the character length cannot be determined.
         // The user has to live with this, if they decide to add control characters or some fancy
-        // stuff into their tables. This is considered undefined behavior and we try to handle this
+        // stuff into their tables. This is considered undefined behavior, and we try to handle this
         // to the best of our capabilities.
-        let character_width = c.width().unwrap_or(1);
+        let character_width = c.width();
 
         current_width += character_width;
-        parts.push(c);
+        parts.push_str(c);
     }
 
     // Collect the remaining characters.
     let remaining = char_iter.collect();
     (parts, remaining)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_split_long_word() {
+        let emoji = "🙂‍↕️"; // U+1F642 U+200D U+2195 U+FE0F head shaking vertically
+        assert_eq!(emoji.len(), 13);
+        assert_eq!(emoji.chars().count(), 4);
+        assert_eq!(emoji.width(), 2);
+
+        let (word, remaining) = split_long_word(emoji.width(), &emoji);
+
+        assert_eq!(word, "\u{1F642}\u{200D}\u{2195}\u{FE0F}");
+        assert_eq!(word.len(), 13);
+        assert_eq!(word.chars().count(), 4);
+        assert_eq!(word.width(), 2);
+
+        assert!(remaining.is_empty());
+    }
+}