Merge pull request #133 from togglebyte/dev

togglebyte · web-flow · commit c979618a6ec6 · 2025-07-14T15:18:21.000+02:00
Dev
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,3 +1,9 @@
+* 0.2.9
+    * New function: truncate
+    * New border style: "rounded"
+    * Hex and Color can now be serialized / deserialized if the `serde` feature
+      is enabled.
+    * `MessageReceiver` is now part of prelude
 * 0.2.8
     * An emitter can be created before the runtime
     * Messages can be emitted to both widget ids and component ids
diff --git a/Cargo.toml b/Cargo.toml
@@ -31,7 +31,7 @@ anathema-testutils = { path = "anathema-testutils" }
 [features]
 default = []
 profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile"]
-serde = ["anathema-store/serde"]
+serde = ["anathema-state/serde", "anathema-store/serde"]
 # filelog = ["anathema-debug/filelog", "anathema-widgets/filelog", "anathema-runtime/filelog"]
 
 [lints]
diff --git a/anathema-default-widgets/src/border.rs b/anathema-default-widgets/src/border.rs
@@ -131,6 +131,17 @@ pub const DEFAULT_THICK_EDGES: [Glyph; 8] = [
     Glyph::from_char('║', 1),
 ];
 
+pub const DEFAULT_ROUNDED_EDGES: [Glyph; 8] = [
+    Glyph::from_char('╭', 1),
+    Glyph::from_char('─', 1),
+    Glyph::from_char('╮', 1),
+    Glyph::from_char('│', 1),
+    Glyph::from_char('╯', 1),
+    Glyph::from_char('─', 1),
+    Glyph::from_char('╰', 1),
+    Glyph::from_char('│', 1),
+];
+
 /// The style of the border.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
 pub enum BorderStyle {
@@ -152,6 +163,7 @@ pub enum BorderStyle {
     /// 7hello3
     /// 6555554
     /// ```
+    Rounded,
     Custom([Glyph; 8]),
 }
 
@@ -160,6 +172,7 @@ impl BorderStyle {
         match self {
             BorderStyle::Thin => DEFAULT_SLIM_EDGES,
             BorderStyle::Thick => DEFAULT_THICK_EDGES,
+            BorderStyle::Rounded => DEFAULT_ROUNDED_EDGES,
             BorderStyle::Custom(edges) => *edges,
         }
     }
@@ -429,6 +442,7 @@ impl Widget for Border {
                 match s {
                     Some("thin") | None => BorderStyle::default(),
                     Some("thick") => BorderStyle::Thick,
+                    Some("rounded") => BorderStyle::Rounded,
                     Some(s) => {
                         let mut glyphs = Glyphs::new(s);
                         while let Some(g) = glyphs.next(ctx.glyph_map) {
diff --git a/anathema-geometry/src/position.rs b/anathema-geometry/src/position.rs
@@ -126,7 +126,7 @@ impl SubAssign for Pos {
 // -----------------------------------------------------------------------------
 
 /// Positions in a local space.
-/// These coordiantes can not be negative.
+/// These coordinates can not be negative.
 /// `0, 0` refers to top left.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub struct LocalPos {
diff --git a/anathema-runtime/src/builder.rs b/anathema-runtime/src/builder.rs
@@ -31,7 +31,7 @@ pub struct Builder<G> {
 }
 
 impl<G: GlobalEventHandler> Builder<G> {
-    /// Create a new runtime builder with a reciver.
+    /// Create a new runtime builder with a receiver.
     /// Use this if the `Emitter` was created outside of the runtime.
     pub(super) fn with_receiver(
         message_receiver: flume::Receiver<ViewMessage>,
diff --git a/anathema-state/Cargo.toml b/anathema-state/Cargo.toml
@@ -11,6 +11,11 @@ repository = "https://github.com/togglebyte/anathema"
 [dependencies]
 anathema-state-derive = { workspace = true }
 anathema-store = { workspace = true }
+serde = { version = "1.0", optional = true, features = ["derive"] }
+
+[features]
+default = []
+serde = ["dep:serde"]
 
 [lints]
 workspace = true
diff --git a/anathema-state/src/colors.rs b/anathema-state/src/colors.rs
@@ -11,6 +11,7 @@ pub trait FromColor {
 ///
 /// [ANSI color table](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors)
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Color {
     #[default]
     Reset,
diff --git a/anathema-state/src/lib.rs b/anathema-state/src/lib.rs
@@ -45,6 +45,7 @@ impl<'a> From<&'a str> for Path<'a> {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Hex {
     pub r: u8,
     pub g: u8,
diff --git a/anathema-state/src/value/maybe.rs b/anathema-state/src/value/maybe.rs
@@ -29,12 +29,12 @@ impl<T: State> Maybe<T> {
         self.0.take()
     }
 
-    /// Get option of a refernce to the underlying value
+    /// Get option of a reference to the underlying value
     pub fn get_ref(&self) -> Option<&Value<T>> {
         self.0.as_ref()
     }
 
-    /// Get option of a mutable refernce to the underlying value
+    /// Get option of a mutable reference to the underlying value
     pub fn get_mut(&mut self) -> Option<&mut Value<T>> {
         self.0.as_mut()
     }
diff --git a/anathema-store/src/indexmap.rs b/anathema-store/src/indexmap.rs
@@ -14,7 +14,7 @@ where
     K: std::hash::Hash,
     K: Clone,
 {
-    /// Create an empy index map
+    /// Create an empty index map
     pub fn empty() -> Self {
         Self {
             slab: Slab::empty(),
diff --git a/anathema-store/src/slab/basic.rs b/anathema-store/src/slab/basic.rs
@@ -342,7 +342,7 @@ where
         match entry {
             Entry::Occupied(value) => Ticket { value, key },
             Entry::CheckedOut(_) => panic!("value already checked out"),
-            _ => panic!("no entry maching the key"),
+            _ => panic!("no entry matching the key"),
         }
     }
 
diff --git a/anathema-store/src/slab/generational.rs b/anathema-store/src/slab/generational.rs
@@ -69,13 +69,13 @@ impl Key {
         Self(index | generation)
     }
 
-    /// Set the upper auxillary value
+    /// Set the upper auxiliary value
     pub fn set_aux(&mut self, aux: u16) {
         let aux = (aux as u64) << (Self::INDEX_BITS + Self::GEN_BITS);
         self.0 = self.0 << Self::GEN_BITS >> Self::GEN_BITS | aux;
     }
 
-    /// Get the auxillary value
+    /// Get the auxiliary value
     pub fn aux(&self) -> u16 {
         (self.0 >> Self::AUX_OFFSET) as u16
     }
diff --git a/anathema-store/src/slab/shared/arc.rs b/anathema-store/src/slab/shared/arc.rs
@@ -236,7 +236,7 @@ mod test {
     }
 
     #[test]
-    fn ensure_arc_resuse() {
+    fn ensure_arc_reuse() {
         let mut slab = ArcSlab::<usize, _>::empty();
 
         // Add and remove the value to ensure there is
diff --git a/anathema-store/src/slab/shared/rc.rs b/anathema-store/src/slab/shared/rc.rs
@@ -225,7 +225,7 @@ mod test {
     }
 
     #[test]
-    fn ensure_rc_resuse() {
+    fn ensure_rc_reuse() {
         let mut slab = RcSlab::<usize, _>::empty();
 
         // Add and remove the value to ensure there is
diff --git a/anathema-store/src/tree/mod.rs b/anathema-store/src/tree/mod.rs
@@ -140,7 +140,7 @@ impl Nodes {
         self.inner.push(Node::new(key));
     }
 
-    // Clear nodes and remove associted values
+    // Clear nodes and remove associated values
     fn clear<T, F>(&mut self, values: &mut GenSlab<(Box<[u16]>, T)>, removed_values: &mut RemovedValues, f: &mut F)
     where
         F: FnMut(T),
diff --git a/anathema-store/src/tree/transactions.rs b/anathema-store/src/tree/transactions.rs
@@ -58,7 +58,7 @@ impl<'a, 'tree, T> InsertTransaction<'a, 'tree, T> {
                 path[path.len() - 1] += 1;
                 let path = path.clone();
 
-                // Update the root of all the children of the preceeding siblings
+                // Update the root of all the children of the preceding siblings
                 node.reparent(&path, self.tree.values);
             });
             value_id
diff --git a/anathema-store/src/tree/view.rs b/anathema-store/src/tree/view.rs
@@ -154,7 +154,7 @@ impl<'tree, T> TreeView<'tree, T> {
 
                 // Clone the path to drop the borrow of the tree
                 let path = path.clone();
-                // Update the root of all the children of the preceeding siblings
+                // Update the root of all the children of the preceding siblings
                 node.reparent(&path, self.values);
             });
 
@@ -276,7 +276,7 @@ mod test {
     }
 
     // This is where we start:
-    // Insert At has to be a posibility.
+    // Insert At has to be a possibility.
     // Scenario:
     // * Insert at 0
     // * Insert at len
diff --git a/anathema-templates/src/components.rs b/anathema-templates/src/components.rs
@@ -219,26 +219,26 @@ impl ComponentTemplates {
 
     pub(crate) fn load(
         &mut self,
-        parent_id: ComponentBlueprintId,
+        component_id: ComponentBlueprintId,
         variables: &mut Variables,
         slots: SmallMap<StringId, Vec<Blueprint>>,
         strings: &mut Strings,
     ) -> Result<Vec<Blueprint>> {
-        let ticket = self.components.checkout(parent_id);
+        let ticket = self.components.checkout(component_id);
         let (_, component_src) = &*ticket;
 
-        if self.dependencies.contains(&parent_id) {
+        if self.dependencies.contains(&component_id) {
             let path = component_src.path();
             self.components.restore(ticket);
             return Err(Error::new(path, ErrorKind::CircularDependency));
         }
 
-        self.dependencies.push(parent_id);
+        self.dependencies.push(component_id);
 
         // NOTE
         // The ticket has to be restored to the component store,
         // this is why the error is returned rather than using `?` on `self.compile`.
-        let ret = self.compile(component_src, variables, slots, strings, parent_id);
+        let ret = self.compile(component_src, variables, slots, strings, component_id);
         self.components.restore(ticket);
         self.dependencies.pop();
         ret
diff --git a/anathema-templates/src/statements/eval.rs b/anathema-templates/src/statements/eval.rs
@@ -222,17 +222,19 @@ impl Scope {
 
         // If the next statement is NOT a slot id then assume $children
         // and still try to take the scope
-        if !scope.is_next_slot() {
-            let slot_id = ctx.strings.children();
-            let scope = Scope::new(scope);
-            let body = scope.eval(ctx)?;
-            slots.set(slot_id, body);
-        } else {
-            // for each slot take the scope and associate it with the slot id
-            while let Some(slot_id) = scope.next_slot() {
-                let scope = Scope::new(scope.take_scope());
+        if !scope.is_empty() {
+            if !scope.is_next_slot() {
+                let slot_id = ctx.strings.children();
+                let scope = Scope::new(scope);
                 let body = scope.eval(ctx)?;
                 slots.set(slot_id, body);
+            } else {
+                // for each slot take the scope and associate it with the slot id
+                while let Some(slot_id) = scope.next_slot() {
+                    let scope = Scope::new(scope.take_scope());
+                    let body = scope.eval(ctx)?;
+                    slots.set(slot_id, body);
+                }
             }
         }
 
diff --git a/anathema-templates/src/statements/mod.rs b/anathema-templates/src/statements/mod.rs
@@ -52,11 +52,10 @@ impl Context<'_> {
 
     fn load_component(
         &mut self,
-        parent_component_id: ComponentBlueprintId,
+        component_id: ComponentBlueprintId,
         slots: SmallMap<StringId, Vec<Blueprint>>,
     ) -> Result<Vec<Blueprint>> {
-        self.components
-            .load(parent_component_id, self.variables, slots, self.strings)
+        self.components.load(component_id, self.variables, slots, self.strings)
     }
 }
 
diff --git a/anathema-templates/src/variables.rs b/anathema-templates/src/variables.rs
@@ -301,7 +301,7 @@ impl Variables {
         self.boundary.pop();
     }
 
-    /// Create a new child and set the new childs id as the `current` id.
+    /// Create a new child and set the new child's id as the `current` id.
     /// Any operations done from here on out are acting upon the new child scope.
     pub(crate) fn push(&mut self) {
         let parent = self.root.get_scope_mut(&self.current);
@@ -478,7 +478,7 @@ mod test {
     fn get_inside_boundary() {
         let mut vars = Variables::new();
 
-        // Define a varialbe in the root scope
+        // Define a variable in the root scope
         _ = vars.define_local("var", 1);
 
         // Create a new unique scope and boundary.
diff --git a/anathema-value-resolver/Cargo.toml b/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
diff --git a/anathema-value-resolver/src/functions/mod.rs b/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));
diff --git a/anathema-value-resolver/src/functions/string.rs b/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("🐇"));
+    }
 }
diff --git a/anathema-widgets/src/components/mod.rs b/anathema-widgets/src/components/mod.rs
@@ -256,7 +256,7 @@ impl<'frame, 'bp, T: 'static> Context<'frame, 'bp, T> {
     pub fn emit<M: 'static + Send + Sync>(&self, recipient: ComponentId<M>, value: M) {
         self.emitter
             .emit(recipient, value)
-            .expect("this will not fail unless the runtime is droped")
+            .expect("this will not fail unless the runtime is dropped")
     }
 }
 
diff --git a/anathema-widgets/src/layout/mod.rs b/anathema-widgets/src/layout/mod.rs
diff --git a/anathema-widgets/src/nodes/element.rs b/anathema-widgets/src/nodes/element.rs
diff --git a/anathema-widgets/src/paint.rs b/anathema-widgets/src/paint.rs
diff --git a/anathema-widgets/src/tree/mod.rs b/anathema-widgets/src/tree/mod.rs
diff --git a/examples/basic.rs b/examples/basic.rs
diff --git a/examples/message-passing.rs b/examples/message-passing.rs
diff --git a/src/lib.rs b/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ pub struct Builder<G> {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`impl<G: GlobalEventHandler> Builder<G> {`
`34`		`- /// Create a new runtime builder with a reciver.`
	`34`	`+ /// Create a new runtime builder with a receiver.`
`35`	`35`	/// Use this if the `Emitter` was created outside of the runtime.
`36`	`36`	`pub(super) fn with_receiver(`
`37`	`37`	`message_receiver: flume::Receiver<ViewMessage>,`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ impl<'a> From<&'a str> for Path<'a> {`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]`
	`48`	`+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]`
`48`	`49`	`pub struct Hex {`
`49`	`50`	`pub r: u8,`
`50`	`51`	`pub g: u8,`
Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,12 @@ impl<T: State> Maybe<T> {`
`29`	`29`	`self.0.take()`
`30`	`30`	`}`
`31`	`31`
`32`		`- /// Get option of a refernce to the underlying value`
	`32`	`+ /// Get option of a reference to the underlying value`
`33`	`33`	`pub fn get_ref(&self) -> Option<&Value<T>> {`
`34`	`34`	`self.0.as_ref()`
`35`	`35`	`}`
`36`	`36`
`37`		`- /// Get option of a mutable refernce to the underlying value`
	`37`	`+ /// Get option of a mutable reference to the underlying value`
`38`	`38`	`pub fn get_mut(&mut self) -> Option<&mut Value<T>> {`
`39`	`39`	`self.0.as_mut()`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ where`
`14`	`14`	`K: std::hash::Hash,`
`15`	`15`	`K: Clone,`
`16`	`16`	`{`
`17`		`- /// Create an empy index map`
	`17`	`+ /// Create an empty index map`
`18`	`18`	`pub fn empty() -> Self {`
`19`	`19`	`Self {`
`20`	`20`	`slab: Slab::empty(),`