Merge pull request #130 from togglebyte/dev

0.2.8

Author: togglebyte

CHANGES.md

@@ -1,3 +1,12 @@
+* 0.2.8
+    * An emitter can be created before the runtime
+    * Messages can be emitted to both widget ids and component ids
+    * Feature flag: `serde` is now a feature flag that adds `Serialize` / `Deserialize` to `WidgetId`
+    * There is now a distinction between `global`s and `local`s
+    * BUGFIX: ctrl+c works with the error display
+    * Trying to use a component twice will now include the component name in the
+      error
+    * Global definitions will raise an error if it's already assigned
 * 0.2.7
     * BUGFIX: use correct truthiness check in control flow update
 * 0.2.6

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "anathema"
 edition = "2024"
-version = "0.2.7"
+version = "0.2.8"
 license = "MIT"
 description = "Create beautiful, easily customisable terminal applications"
 keywords = ["tui", "terminal", "widgets", "ui", "layout"]
@@ -31,31 +31,32 @@ anathema-testutils = { path = "anathema-testutils" }
 [features]
 default = []
 profile = ["anathema-runtime/profile", "anathema-widgets/profile", "anathema-backend/profile"]
+serde = ["anathema-store/serde"]
 # filelog = ["anathema-debug/filelog", "anathema-widgets/filelog", "anathema-runtime/filelog"]
 
 [lints]
 workspace = true
 
 [workspace.package]
 edition = "2024"
-version = "0.2.7"
+version = "0.2.8"
 
 [workspace.dependencies]
 bitflags = "2.4.1"
 crossterm = "0.28.1"
 unicode-width = "0.1.11"
 flume = "0.11.0"
 notify = "6.1.1"
-anathema-default-widgets = { path = "./anathema-default-widgets", version = "0.2.7" }
-anathema-backend = { path = "./anathema-backend", version = "0.2.7" }
-anathema-runtime = { path = "./anathema-runtime", version = "0.2.7" }
-anathema-state = { path = "./anathema-state", version = "0.2.7" }
-anathema-state-derive = { path = "./anathema-state-derive", version = "0.2.7" }
-anathema-store = { path = "./anathema-store", version = "0.2.7" }
-anathema-templates = { path = "./anathema-templates", version = "0.2.7" }
-anathema-widgets = { path = "./anathema-widgets", version = "0.2.7" }
-anathema-geometry = { path = "./anathema-geometry", version = "0.2.7" }
-anathema-value-resolver = { path = "./anathema-value-resolver", version = "0.2.7" }
+anathema-default-widgets = { path = "./anathema-default-widgets", version = "0.2.8" }
+anathema-backend = { path = "./anathema-backend", version = "0.2.8" }
+anathema-runtime = { path = "./anathema-runtime", version = "0.2.8" }
+anathema-state = { path = "./anathema-state", version = "0.2.8" }
+anathema-state-derive = { path = "./anathema-state-derive", version = "0.2.8" }
+anathema-store = { path = "./anathema-store", version = "0.2.8" }
+anathema-templates = { path = "./anathema-templates", version = "0.2.8" }
+anathema-widgets = { path = "./anathema-widgets", version = "0.2.8" }
+anathema-geometry = { path = "./anathema-geometry", version = "0.2.8" }
+anathema-value-resolver = { path = "./anathema-value-resolver", version = "0.2.8" }
 
 [workspace]
 members = [

anathema-backend/src/testing/events.rs

@@ -1,5 +1,6 @@
 use std::collections::VecDeque;
 
+use anathema_geometry::Size;
 use anathema_widgets::components::events::{Event, KeyEvent};
 
 pub struct EventsMut<'a> {
@@ -19,6 +20,12 @@ impl EventsMut<'_> {
         self
     }
 
+    pub fn resize(self, new_size: impl Into<Size>) -> Self {
+        let size = new_size.into();
+        self.event_queue.push_back(Some(Event::Resize(size)));
+        self
+    }
+
     pub fn stop(self) -> Self {
         self.event_queue.push_back(Some(Event::Stop));
         self

anathema-backend/src/testing/surface.rs

@@ -23,7 +23,7 @@ impl TestSurface {
 
     pub(crate) fn resize(&mut self, new_size: Size, _glyph_map: &mut GlyphMap) {
         self.size = new_size;
-        todo!("truncate and pop lines outside of the new size")
+        // TODO: this should pop and truncate the lines to fit the new size
     }
 
     // Get from previous lines as the clear function has most likely

anathema-default-widgets/src/testing.rs

@@ -3,7 +3,7 @@ use anathema_backend::{Backend, WidgetCycle};
 use anathema_geometry::{Pos, Size};
 use anathema_state::{State, StateId, States, Value};
 use anathema_templates::blueprints::Blueprint;
-use anathema_templates::{Document, Globals, ToSourceKind};
+use anathema_templates::{Document, ToSourceKind, Variables};
 use anathema_value_resolver::{AttributeStorage, Attributes, FunctionTable, Scope};
 use anathema_widgets::components::ComponentRegistry;
 use anathema_widgets::components::events::Event;
@@ -131,7 +131,7 @@ pub struct TestRunner {
     factory: Factory,
     backend: TestBackend,
     blueprint: Blueprint,
-    globals: Globals,
+    variables: Variables,
     components: Components,
     function_table: FunctionTable,
 }
@@ -167,7 +167,7 @@ impl TestRunner {
             states,
             component_registry,
             blueprint,
-            globals,
+            variables: globals,
             components: Components::new(),
             function_table: FunctionTable::new(),
         }
@@ -178,7 +178,7 @@ impl TestRunner {
             &self.blueprint,
             &mut self.states,
             &mut self.backend,
-            &self.globals,
+            &self.variables,
             &self.factory,
             &mut self.component_registry,
             &mut self.components,
@@ -192,7 +192,7 @@ pub struct TestInstance<'bp> {
     attribute_storage: AttributeStorage<'bp>,
     floating_widgets: FloatingWidgets,
     states: &'bp mut States,
-    globals: &'bp Globals,
+    variables: &'bp Variables,
     backend: &'bp mut TestBackend,
     viewport: Viewport,
     factory: &'bp Factory,
@@ -208,7 +208,7 @@ impl<'bp> TestInstance<'bp> {
         blueprint: &'bp Blueprint,
         states: &'bp mut States,
         backend: &'bp mut TestBackend,
-        globals: &'bp Globals,
+        variables: &'bp Variables,
         factory: &'bp Factory,
         component_registry: &'bp mut ComponentRegistry,
         components: &'bp mut Components,
@@ -222,7 +222,7 @@ impl<'bp> TestInstance<'bp> {
 
         let scope = Scope::root();
         let mut ctx = LayoutCtx::new(
-            globals,
+            variables,
             factory,
             states,
             &mut attribute_storage,
@@ -244,7 +244,7 @@ impl<'bp> TestInstance<'bp> {
             attribute_storage,
             floating_widgets,
             states,
-            globals,
+            variables,
             backend,
             viewport,
             factory,
@@ -274,7 +274,7 @@ impl<'bp> TestInstance<'bp> {
         let mut tree = self.tree.view();
 
         let mut ctx = LayoutCtx::new(
-            self.globals,
+            self.variables,
             self.factory,
             self.states,
             &mut self.attribute_storage,
@@ -319,7 +319,7 @@ impl<'bp> TestInstance<'bp> {
         let constraints = Constraints::new(width as u16, height as u16);
 
         let mut ctx = LayoutCtx::new(
-            self.globals,
+            self.variables,
             self.factory,
             self.states,
             &mut self.attribute_storage,

anathema-runtime/src/builder.rs

@@ -31,14 +31,18 @@ pub struct Builder<G> {
 }
 
 impl<G: GlobalEventHandler> Builder<G> {
-    /// Create a new runtime builder
-    pub(super) fn new(document: Document, size: Size, global_event_handler: G) -> Self {
+    /// Create a new runtime builder with a reciver.
+    /// Use this if the `Emitter` was created outside of the runtime.
+    pub(super) fn with_receiver(
+        message_receiver: flume::Receiver<ViewMessage>,
+        emitter: Emitter,
+        document: Document,
+        size: Size,
+        global_event_handler: G,
+    ) -> Self {
         let mut factory = Factory::new();
         register_default_widgets(&mut factory);
 
-        let (tx, message_receiver) = flume::unbounded();
-        let emitter = tx.into();
-
         Self {
             factory,
             document,
@@ -53,6 +57,13 @@ impl<G: GlobalEventHandler> Builder<G> {
         }
     }
 
+    /// Create a new runtime builder
+    pub(super) fn new(document: Document, size: Size, global_event_handler: G) -> Self {
+        let (tx, rx) = flume::unbounded();
+        let emitter = Emitter::from(tx);
+        Self::with_receiver(rx, emitter.clone(), document, size, global_event_handler)
+    }
+
     /// Enable/Disable hot reloading
     pub fn hot_reload(&mut self, value: bool) {
         self.hot_reload = value;
@@ -172,9 +183,15 @@ impl<G: GlobalEventHandler> Builder<G> {
         let (blueprint, globals) = loop {
             match self.document.compile() {
                 Ok(val) => break val,
-                Err(error) => {
-                    show_error(error, backend, &mut self.document)?;
-                }
+                // This can only show template errors.
+                // Widget errors doesn't become available until after the first tick.
+                Err(error) => match show_error(error.into(), backend, &self.document) {
+                    Ok(()) => return Err(Error::Stop),
+                    Err(Error::Reload) if self.hot_reload => {
+                        _ = self.document.reload_templates();
+                    }
+                    err => err?,
+                },
             }
         };
 
@@ -193,42 +210,10 @@ impl<G: GlobalEventHandler> Builder<G> {
             self.fps,
             self.global_event_handler,
             self.function_table,
+            self.hot_reload,
         );
 
-        // NOTE:
-        // this enables hot reload,
-        // however with this enabled the `with_frame` function
-        // on the runtime will repeat
-        loop {
-            match f(&mut inst, backend) {
-                Ok(()) => (),
-                e => match e {
-                    Ok(_) => continue,
-                    Err(Error::Stop) => break Ok(()),
-                    Err(Error::Template(error)) => match show_error(error, backend, &mut inst.document) {
-                        Ok(_) => continue,
-                        Err(err) => panic!("error console failed: {err}"),
-                    },
-                    Err(Error::Widget(err)) => panic!("this should not panic in the future: {err}"),
-                    Err(e) => break Err(e),
-                },
-            }
-
-            if !self.hot_reload {
-                break Ok(());
-            }
-
-            match inst.reload() {
-                Ok(()) => continue,
-                Err(Error::Stop) => todo!(),
-                Err(Error::Template(error)) => match show_error(error, backend, &mut inst.document) {
-                    Ok(_) => continue,
-                    Err(err) => panic!("error console failed: {err}"),
-                },
-                Err(Error::Widget(_error)) => todo!(),
-                Err(e) => break Err(e),
-            }
-        }
+        f(&mut inst, backend)
     }
 
     fn set_watcher(&mut self, hot_reload: bool) -> Result<Option<RecommendedWatcher>> {

anathema-runtime/src/error.rs

@@ -8,22 +8,24 @@ pub type Result<T> = std::result::Result<T, Error>;
 #[derive(Debug)]
 pub enum Error {
     Template(TemplateError),
-    Notify(notify::Error),
     Widget(anathema_widgets::error::Error),
+    Notify(notify::Error),
     Stop,
+    Reload,
     InvalidComponentName,
     Resolver(anathema_value_resolver::Error),
 }
 
 impl Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::Template(template) => write!(f, "{template}"),
-            Error::Stop => write!(f, "stopping"),
-            Error::Notify(err) => write!(f, "{err}"),
-            Error::Widget(err) => write!(f, "{err}"),
-            Error::Resolver(err) => write!(f, "{err}"),
-            Error::InvalidComponentName => write!(f, "no such component"),
+            Self::Template(template) => write!(f, "{template}"),
+            Self::Stop => write!(f, "stopping"),
+            Self::Reload => write!(f, "reloading"),
+            Self::Notify(err) => write!(f, "{err}"),
+            Self::Widget(err) => write!(f, "{err}"),
+            Self::Resolver(err) => write!(f, "{err}"),
+            Self::InvalidComponentName => write!(f, "no such component"),
         }
     }
 }