added truncate function

Author: togglebyte

CHANGES.md

@@ -1,4 +1,5 @@
 * 0.2.9
+    * New function: truncate
     * New border style: "rounded"
     * Hex and Color can now be serialized / deserialized if the `serde` feature
       is enabled.

anathema-value-resolver/Cargo.toml

@@ -12,6 +12,7 @@ repository = "https://github.com/togglebyte/anathema"
 anathema-state = { workspace = true }
 anathema-templates = { workspace = true }
 anathema-store = { workspace = true }
+unicode-width = { workspace = true }
 
 [lints]
 workspace = true

anathema-value-resolver/src/functions/mod.rs

@@ -57,6 +57,7 @@ impl FunctionTable {
         let mut inner = HashMap::new();
         inner.insert("to_upper".into(), Function::from(string::to_upper));
         inner.insert("to_lower".into(), Function::from(string::to_lower));
+        inner.insert("truncate".into(), Function::from(string::truncate));
         inner.insert("to_str".into(), Function::from(string::to_str));
         inner.insert("to_int".into(), Function::from(number::to_int));
         inner.insert("to_float".into(), Function::from(number::to_float));

anathema-value-resolver/src/functions/string.rs

@@ -1,3 +1,5 @@
+use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
+
 use crate::ValueKind;
 
 pub(super) fn to_upper<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
@@ -40,6 +42,37 @@ pub(super) fn to_str<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
     ValueKind::Str(buffer.into())
 }
 
+pub(super) fn truncate<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
+    if args.len() != 2 {
+        return ValueKind::Null;
+    }
+
+    let Some(mut remainder) = args[1].as_int() else { return ValueKind::Null };
+
+    let mut buffer = String::new();
+    args[0].strings(|s| {
+        let width = s.width() as i64;
+
+        if width < remainder {
+            remainder = remainder.saturating_sub(width);
+            buffer.push_str(s);
+        } else {
+            let mut chars = s.chars();
+            while remainder > 0 {
+                let Some(c) = chars.next() else { break };
+                let width = c.width().unwrap_or(0) as i64;
+                if width > remainder {
+                    break;
+                };
+                buffer.push(c);
+                remainder = remainder.saturating_sub(width);
+            }
+        }
+        true
+    });
+    ValueKind::Str(buffer.into())
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -86,4 +119,25 @@ mod test {
         let val = to_str(&[val]);
         assert_eq!(val, value("123"));
     }
+
+    #[test]
+    fn truncate_long_string() {
+        let val = value("this is a longer string");
+        let val = truncate(&[val, value(4)]);
+        assert_eq!(val, value("this"));
+    }
+
+    #[test]
+    fn truncate_short_string() {
+        let val = value("hi");
+        let val = truncate(&[val, value(4)]);
+        assert_eq!(val, value("hi"));
+    }
+
+    #[test]
+    fn truncate_wide_cells() {
+        let val = value("🐇🐇");
+        let val = truncate(&[val, value(3)]);
+        assert_eq!(val, value("🐇"));
+    }
 }