other: optimize truncate_text

Flamegraphs showed that this area seems to be a bit heavy at times with
some inefficient use of iterators and collection. This change should
hopefully optimize this a bit by reducing some collections or
reallocations.

There can also be some further optimizations with less allocations from
callers.

Cargo.toml

@@ -41,6 +41,8 @@ doctest = true
 doc = true
 
 [profile.release]
+# debug = true
+# strip = false
 debug = 0
 strip = "symbols"
 lto = true
@@ -126,9 +128,21 @@ clap_mangen = "0.1.6"
 [package.metadata.deb]
 section = "utility"
 assets = [
-    ["target/release/btm", "usr/bin/", "755"],
-    ["LICENSE", "usr/share/doc/btm/", "644"],
-    ["manpage/btm.1.gz", "usr/share/man/man1/btm.1.gz", "644"],
+    [
+        "target/release/btm",
+        "usr/bin/",
+        "755",
+    ],
+    [
+        "LICENSE",
+        "usr/share/doc/btm/",
+        "644",
+    ],
+    [
+        "manpage/btm.1.gz",
+        "usr/share/man/man1/btm.1.gz",
+        "644",
+    ],
     [
         "completion/btm.bash",
         "usr/share/bash-completion/completions/btm",
@@ -139,7 +153,11 @@ assets = [
         "usr/share/fish/vendor_completions.d/btm.fish",
         "644",
     ],
-    ["completion/_btm", "usr/share/zsh/vendor-completions/", "644"],
+    [
+        "completion/_btm",
+        "usr/share/zsh/vendor-completions/",
+        "644",
+    ],
 ]
 extended-description = """
 

src/app/data_harvester/memory/general/heim.rs

@@ -32,6 +32,7 @@ pub async fn get_ram_data() -> crate::utils::error::Result<Option<MemHarvest>> {
     let (mem_total_in_kib, mem_used_in_kib) = {
         #[cfg(target_os = "linux")]
         {
+            // TODO: [OPT] is this efficient?
             use smol::fs::read_to_string;
             let meminfo = read_to_string("/proc/meminfo").await?;
 

src/components/data_table/draw.rs

@@ -221,7 +221,11 @@ where
                                 .iter()
                                 .zip(&self.state.calculated_widths)
                                 .filter_map(|(column, &width)| {
-                                    data_row.to_cell(column.inner(), width)
+                                    if width > 0 {
+                                        data_row.to_cell(column.inner(), width)
+                                    } else {
+                                        None
+                                    }
                                 }),
                         );
 

src/components/time_graph.rs

@@ -132,7 +132,7 @@ impl<'a> TimeGraph<'a> {
 
         // This is some ugly manual loop unswitching. Maybe unnecessary.
         // TODO: Optimize this step. Cut out unneeded points.
-        let data = graph_data.iter().map(|data| create_dataset(data)).collect();
+        let data = graph_data.iter().map(create_dataset).collect();
         let block = Block::default()
             .title(self.generate_title(draw_loc))
             .borders(Borders::ALL)

src/lib.rs

@@ -522,6 +522,8 @@ pub fn create_collection_thread(
                     }
                 }
             }
+
+            // TODO: [OPT] this feels like it might not be totally optimal. Hm.
             futures::executor::block_on(data_state.update_data());
 
             // Yet another check to bail if needed...

src/utils/gen_util.rs

@@ -1,7 +1,6 @@
 use std::cmp::Ordering;
 
-use concat_string::concat_string;
-use tui::text::Text;
+use tui::text::{Span, Spans, Text};
 use unicode_segmentation::UnicodeSegmentation;
 
 pub const KILO_LIMIT: u64 = 1000;
@@ -99,14 +98,37 @@ pub fn get_decimal_prefix(quantity: u64, unit: &str) -> (f64, String) {
 /// Truncates text if it is too long, and adds an ellipsis at the end if needed.
 pub fn truncate_text<'a, U: Into<usize>>(content: &str, width: U) -> Text<'a> {
     let width = width.into();
-    let graphemes: Vec<&str> = UnicodeSegmentation::graphemes(content, true).collect();
-
-    if graphemes.len() > width && width > 0 {
-        // Truncate with ellipsis
-        let first_n = graphemes[..(width - 1)].concat();
-        Text::raw(concat_string!(first_n, "…"))
+    let mut graphemes = UnicodeSegmentation::graphemes(content, true);
+    let grapheme_len = {
+        let (_, upper) = graphemes.size_hint();
+        match upper {
+            Some(upper) => upper,
+            None => graphemes.clone().count(), // Don't think this ever fires.
+        }
+    };
+
+    let text = if grapheme_len > width {
+        let mut text = String::with_capacity(width);
+        // Truncate with ellipsis.
+
+        // Use a hack to reduce the size to size `width`. Think of it like removing
+        // The last `grapheme_len - width` graphemes, which reduces the length to
+        // `width` long.
+        //
+        // This is a way to get around the currently experimental`advance_back_by`.
+        graphemes.nth_back(grapheme_len - width);
+
+        text.push_str(graphemes.as_str());
+        text.push('…');
+
+        text
     } else {
-        Text::raw(content.to_string())
+        content.to_string()
+    };
+
+    // TODO: [OPT] maybe add interning here?
+    Text {
+        lines: vec![Spans(vec![Span::raw(text)])],
     }
 }
 
@@ -156,4 +178,9 @@ mod test {
         y.sort_by(|a, b| sort_partial_fn(true)(a, b));
         assert_eq!(y, vec![16.15, 15.0, 1.0, -1.0, -100.0, -100.0, -100.1]);
     }
+
+    #[test]
+    fn test_truncation() {
+        // TODO: Add tests for `truncate_text`
+    }
 }

src/widgets/process_table/proc_widget_data.rs

@@ -221,6 +221,7 @@ impl ProcWidgetData {
 
 impl DataToCell<ProcColumn> for ProcWidgetData {
     fn to_cell<'a>(&'a self, column: &ProcColumn, calculated_width: u16) -> Option<Text<'a>> {
+        // TODO: Optimize the string allocations here...
         Some(truncate_text(
             &match column {
                 ProcColumn::CpuPercent => {