BUGFIX: remove components when truncating the tree

Author: togglebyte

CHANGES.md

@@ -3,6 +3,7 @@
     * `Backend::full_screen()` convenience function
     * `to_float` template function
     * `PathBuf`s can now be used as templates
+    * BUGFIX: tick events no longer tries to use removed components
 * 0.2.5
     * BUGFIX: component reuse in if / else
     * `with` statement

anathema-backend/src/tui/mod.rs

@@ -117,7 +117,7 @@ impl TuiBackend {
     }
 
     /// Convenience function this is the same as calling
-    /// ```
+    /// ```no_run
     /// # use anathema_backend::tui::TuiBackend;
     /// # use anathema_backend::Backend;
     /// let mut backend = TuiBackend::builder()

anathema-runtime/src/runtime/mod.rs

@@ -327,6 +327,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         let now = Instant::now();
         self.init_new_components();
         let elapsed = self.handle_messages(now);
+        // Pre cycle events
         self.poll_events(elapsed, now, backend);
         self.drain_deferred_commands();
         self.drain_assoc_events();
@@ -340,6 +341,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         self.tick_components(self.dt.elapsed());
         self.cycle(backend)?;
 
+        // Post cycle events
         *self.dt = Instant::now();
 
         match self.layout_ctx.stop_runtime {

anathema-state/src/value/map.rs

@@ -132,7 +132,7 @@ mod test {
     }
     impl Drop for DM {
         fn drop(&mut self) {
-            eprintln!("- drop: {}", self.0);
+            // eprintln!("- drop: {}", self.0);
         }
     }
 

anathema-store/src/slab/basic.rs

@@ -69,7 +69,7 @@ impl<I, T> Entry<I, T> {
     // Insert an Occupied entry in place of a vacant one.
     fn swap(&mut self, value: T) {
         debug_assert!(matches!(self, Entry::Vacant(_)));
-        std::mem::swap(self, &mut Entry::Occupied(value));
+        *self = Entry::Occupied(value);
     }
 
     // Create a new occupied entry

anathema-store/src/slab/generational.rs

@@ -144,7 +144,7 @@ impl<T> Entry<T> {
     // Insert an Occupied entry in place of a vacant one.
     fn swap(&mut self, value: T, generation: Gen) {
         debug_assert!(matches!(self, Entry::Vacant(_)));
-        std::mem::swap(self, &mut Entry::Occupied(value, generation));
+        *self = Entry::Occupied(value, generation);
     }
 
     // Create a new occupied entry
@@ -437,7 +437,7 @@ where
                 Entry::Vacant(key) => {
                     let _ = write!(&mut s, "{idx}: vacant ");
                     match key {
-                        Some(key) => writeln!(&mut s, "next key: {:?}", key),
+                        Some(key) => writeln!(&mut s, "next key: {key:?}"),
                         None => writeln!(&mut s, "no next id"),
                     }
                 }
@@ -451,7 +451,7 @@ where
         let _ = writeln!(&mut s, "---- next id ----");
 
         let _ = match self.next_id {
-            Some(key) => writeln!(&mut s, "next key: {:?}", key),
+            Some(key) => writeln!(&mut s, "next key: {key:?}"),
             None => writeln!(&mut s, "no next id"),
         };
 

anathema-store/src/slab/shared/arc.rs

@@ -46,7 +46,7 @@ impl<I, T> Entry<I, T> {
                     .expect("Arc strong count is always one here")
                     .replace(inner_value);
 
-                swap(self, &mut Entry::Occupied(storage_cell));
+                *self = Entry::Occupied(storage_cell);
             }
             _ => unreachable!(),
         }
@@ -70,7 +70,7 @@ impl<I, T> Entry<I, T> {
                     .expect("strong count is always one")
                     .take()
                     .expect("occupied variant never contains a None");
-                swap(self, &mut Entry::Vacant(next_id.take(), store));
+                *self = Entry::Vacant(next_id.take(), store);
                 Some(value)
             }
             _ => unreachable!(),

anathema-store/src/slab/shared/rc.rs

@@ -44,7 +44,7 @@ impl<I, T> Entry<I, T> {
                     .expect("Rc strong count is always one here")
                     .replace(inner_value);
 
-                swap(self, &mut Entry::Occupied(storage_cell));
+                *self = Entry::Occupied(storage_cell);
             }
             _ => unreachable!(),
         }
@@ -68,7 +68,7 @@ impl<I, T> Entry<I, T> {
                     .expect("strong count is always one")
                     .take()
                     .expect("occupied variant never contains a None");
-                swap(self, &mut Entry::Vacant(next_id.take(), store));
+                *self = Entry::Vacant(next_id.take(), store);
                 Some(value)
             }
             _ => unreachable!(),

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

@@ -64,7 +64,7 @@ pub(super) fn round<'bp>(args: &[ValueKind<'bp>]) -> ValueKind<'bp> {
     };
 
     match &args[0] {
-        ValueKind::Float(f) => ValueKind::Str(format!("{f:.*}", precision).into()),
+        ValueKind::Float(f) => ValueKind::Str(format!("{f:.precision$}").into()),
         _ => ValueKind::Null,
     }
 }

anathema-widgets/src/layout/mod.rs

@@ -82,7 +82,7 @@ impl<'frame, 'bp> LayoutCtx<'frame, 'bp> {
     }
 
     pub(crate) fn truncate_children(&mut self, tree: &mut TreeView<'_, WidgetContainer<'bp>>) {
-        tree.truncate_children(&mut &mut |widget| {
+        tree.truncate_children(&mut |widget| {
             self.return_component(widget);
         });
     }
@@ -95,6 +95,7 @@ impl<'frame, 'bp> LayoutCtx<'frame, 'bp> {
 
     fn return_component(&mut self, widget: WidgetContainer<'_>) {
         let WidgetKind::Component(comp) = widget.kind else { return };
+        self.components.try_remove(comp.widget_id);
         let id = comp.component_id;
         let state = self.states.remove(comp.state_id).take();
         self.component_registry.return_component(id, comp.dyn_component, state);