Merge pull request #128 from togglebyte/feature/better-errors

BUGFIX: terminating from error display now works

Author: togglebyte

CHANGES.md

@@ -3,6 +3,9 @@
     * 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
 * 0.2.7
     * BUGFIX: use correct truthiness check in control flow update
 * 0.2.6

anathema-runtime/src/builder.rs

@@ -183,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?,
+                },
             }
         };
 
@@ -204,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"),
         }
     }
 }

anathema-runtime/src/runtime/error.rs

@@ -2,7 +2,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 
 use anathema_backend::Backend;
 use anathema_templates::Document;
-use anathema_templates::error::Error as TemplateError;
 use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher, recommended_watcher};
 
 use super::Runtime;
@@ -13,75 +12,87 @@ static STOP_ERROR_RT: AtomicBool = AtomicBool::new(false);
 // TODO:
 // this should be cleaned up.
 // The file watcher is almost identitcal to the one in the runtime.
-pub(crate) fn show_error<B: Backend>(error: TemplateError, backend: &mut B, document: &mut Document) -> Result<()> {
+pub(crate) fn show_error<B: Backend>(error: Error, backend: &mut B, document: &Document) -> Result<()> {
     if STOP_ERROR_RT.load(Ordering::Relaxed) {
         panic!("recursive error displays.");
     }
 
+    let template_path = match &error {
+        Error::Template(error) => format!(": {}", error.path()),
+        Error::Widget(error) => match error.path.as_ref() {
+            Some(path) => format!(": {}", path.display()),
+            None => String::new(),
+        },
+        _ => String::new(),
+    };
+
     let tpl = format!(
         "
 align [alignment: 'centre']
     border [background: 'red', foreground: 'black']
         vstack
-            text [bold: true] 'Template error:'
+            text [bold: true] 'Template error{template_path}'
             text '{error}'
     "
     );
 
     let doc = Document::new(tpl);
 
     // File watchers here
-    let _watcher = set_watcher(document)?;
+    let _watcher = set_watcher(document);
 
     let mut builder = Runtime::builder(doc, backend);
     builder.hot_reload(false);
-    builder.finish(backend, |runtime, backend| {
+    let res = builder.finish(backend, |runtime, backend| {
         runtime.with_frame(backend, |backend, mut frame| {
             loop {
                 if STOP_ERROR_RT.load(Ordering::Relaxed) {
-                    break;
+                    break Err(Error::Reload);
                 }
 
                 frame.tick(backend)?;
                 frame.present(backend);
                 frame.cleanup();
-            }
+            }?;
             backend.clear();
             Err(Error::Stop)
         })
-    })?;
-    document.reload_templates()?;
+    });
 
     // Reset
     STOP_ERROR_RT.store(false, Ordering::Relaxed);
 
-    Ok(())
+    res
 }
 
 fn set_watcher(document: &Document) -> Result<RecommendedWatcher> {
-    let paths = document
+    let _paths = document
         .template_paths()
         .filter_map(|p| p.canonicalize().ok())
         .collect::<Vec<_>>();
 
     let mut watcher = recommended_watcher(move |event: std::result::Result<Event, _>| match event {
         Ok(event) => match event.kind {
             notify::EventKind::Create(_) | notify::EventKind::Remove(_) | notify::EventKind::Modify(_) => {
-                if paths.iter().any(|p| event.paths.contains(p)) {
-                    STOP_ERROR_RT.store(true, Ordering::Relaxed);
-                }
+                // NOTE: we'll let any changes to any files stop the error runtime,
+                // and let the main runtime attempt to restart again.
+                //
+                // This might change in the future but it works for now
+
+                // if paths.iter().any(|p| event.paths.contains(p)) {
+                STOP_ERROR_RT.store(true, Ordering::Relaxed);
+                // }
             }
             notify::EventKind::Any | notify::EventKind::Access(_) | notify::EventKind::Other => (),
         },
         Err(_err) => (),
     })?;
 
     for path in document.template_paths() {
-        let path = path.canonicalize().unwrap();
+        let Some(path) = path.parent() else { continue };
+        let Ok(path) = path.canonicalize() else { continue };
 
-        if let Some(parent) = path.parent() {
-            watcher.watch(parent, RecursiveMode::NonRecursive)?;
-        }
+        watcher.watch(&path, RecursiveMode::NonRecursive)?;
     }
 
     Ok(watcher)

anathema-runtime/src/runtime/mod.rs

@@ -56,6 +56,7 @@ pub struct Runtime<G> {
     pub(super) deferred_components: DeferredComponents,
     pub(super) global_event_handler: G,
     pub(super) function_table: FunctionTable,
+    pub(super) hot_reload: bool,
 }
 
 impl Runtime<()> {
@@ -89,6 +90,7 @@ impl<G: GlobalEventHandler> Runtime<G> {
         fps: u32,
         global_event_handler: G,
         function_table: FunctionTable,
+        hot_reload: bool,
     ) -> Self {
         let sleep_micros: u64 = ((1.0 / fps as f64) * 1000.0 * 1000.0) as u64;
 
@@ -113,6 +115,7 @@ impl<G: GlobalEventHandler> Runtime<G> {
             sleep_micros,
             global_event_handler,
             function_table,
+            hot_reload,
         }
     }
 
@@ -133,39 +136,81 @@ impl<G: GlobalEventHandler> Runtime<G> {
 
     pub fn run<B: Backend>(&mut self, backend: &mut B) -> Result<()> {
         let sleep_micros = self.sleep_micros;
-        self.with_frame(backend, |backend, mut frame| {
-            // Perform the initial tick so tab index has a tree to work with.
-            // This means we can not react to any events in this tick as the tree does not
-            // yet have any widgets or components.
-            frame.tick(backend)?;
 
-            let mut tabindex = TabIndex::new(&mut frame.tabindex, frame.tree.view());
-            tabindex.next();
+        loop {
+            let res = self.with_frame(backend, |backend, mut frame| {
+                // Perform the initial tick so tab index has a tree to work with.
+                // This means we can not react to any events in this tick as the tree does not
+                // yet have any widgets or components.
+                _ = frame.tick(backend);
+                TabIndex::new(&mut frame.tabindex, frame.tree.view()).next();
+
+                if let Some(current) = frame.tabindex.as_ref() {
+                    frame.with_component(current.widget_id, current.state_id, |comp, children, ctx| {
+                        comp.dyn_component.any_focus(children, ctx)
+                    });
+                }
 
-            if let Some(current) = frame.tabindex.as_ref() {
-                frame.with_component(current.widget_id, current.state_id, |comp, children, ctx| {
-                    comp.dyn_component.any_focus(children, ctx)
-                });
-            }
+                loop {
+                    if REBUILD.swap(false, Ordering::Relaxed) {
+                        frame.force_unmount_return();
+                        backend.clear();
+                        break Err(Error::Reload);
+                    }
 
-            loop {
-                frame.tick(backend)?;
-                if frame.layout_ctx.stop_runtime {
-                    return Err(Error::Stop);
-                }
+                    match frame.tick(backend) {
+                        Ok(_duration) => (),
+                        Err(err) => match err {
+                            err @ (Error::Template(_) | Error::Widget(_)) => {
+                                match show_error(err, backend, frame.document) {
+                                    Err(Error::Stop) => return Err(Error::Stop),
+                                    // NOTE: we continue here as this should
+                                    // cause the REBUILD to trigger
+                                    Err(Error::Reload) => continue,
+                                    _ => unreachable!("show_error only return stop or rebuild"),
+                                }
+                            }
+                            err => return Err(err),
+                        },
+                    }
 
-                frame.present(backend);
-                frame.cleanup();
-                std::thread::sleep(Duration::from_micros(sleep_micros));
+                    if frame.layout_ctx.stop_runtime {
+                        return Err(Error::Stop);
+                    }
 
-                if REBUILD.swap(false, Ordering::Relaxed) {
-                    frame.force_rebuild()?;
-                    backend.clear();
-                    break Ok(());
+                    frame.present(backend);
+                    frame.cleanup();
+                    std::thread::sleep(Duration::from_micros(sleep_micros));
                 }
+            });
+
+            match res {
+                Ok(()) => panic!(),
+                Err(e) => match e {
+                    Error::Template(_) | Error::Widget(_) => {
+                        unreachable!("these error variants are handled inside the tick loop")
+                    }
+                    Error::Stop => return Err(Error::Stop),
+
+                    Error::Reload => loop {
+                        // Reload can fail if the template fails to parse.
+                        match self.reload() {
+                            Ok(()) => break,
+                            Err(e) => {
+                                if let Err(Error::Stop) = show_error(e, backend, &self.document) {
+                                    return Err(Error::Stop);
+                                }
+                            }
+                        }
+                    },
+                    e => return Err(e),
+                },
             }
-        })?;
 
+            if !self.hot_reload {
+                break;
+            }
+        }
         Ok(())
     }
 
@@ -250,7 +295,8 @@ pub struct Frame<'rt, 'bp, G> {
 }
 
 impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
-    pub fn force_rebuild(mut self) -> Result<()> {
+    /// Unmount all components and return them to storage
+    pub fn force_unmount_return(mut self) {
         // call unmount on all components
         for i in 0..self.layout_ctx.components.len() {
             let Some((widget_id, state_id)) = self.layout_ctx.components.get_ticking(i) else { continue };
@@ -259,7 +305,6 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         }
 
         self.return_state_and_component();
-        Ok(())
     }
 
     pub fn handle_global_event(&mut self, event: Event) -> Option<Event> {
@@ -714,11 +759,6 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         }
     }
 
-    // fn display_error(&mut self, backend: &mut impl Backend) {
-    //     let _tpl = "text 'you goofed up'";
-    //     backend.render(self.layout_ctx.glyph_map);
-    // }
-
     fn post_cycle_events(&mut self) {
         while let Some(event) = self.post_cycle_events.pop_front() {
             self.event(event);