BUGFIX: remove components when truncating the tree

Author: togglebyte

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);

anathema-widgets/src/nodes/controlflow.rs

@@ -1,8 +1,8 @@
 use anathema_state::Change;
 use anathema_templates::blueprints::Blueprint;
-use anathema_value_resolver::{AttributeStorage, Value};
+use anathema_value_resolver::Value;
 
-use crate::WidgetKind;
+use crate::layout::LayoutCtx;
 use crate::widget::WidgetTreeView;
 
 #[derive(Debug)]
@@ -11,12 +11,22 @@ pub struct ControlFlow<'bp> {
 }
 
 impl<'bp> ControlFlow<'bp> {
-    pub(crate) fn update(&mut self, change: &Change, branch_id: u16, attribute_storage: &AttributeStorage<'bp>) {
+    pub(crate) fn update(
+        &mut self,
+        change: &Change,
+        branch_id: u16,
+        mut tree: WidgetTreeView<'_, 'bp>,
+        ctx: &mut LayoutCtx<'_, 'bp>,
+    ) {
         match change {
             Change::Changed | Change::Dropped => {
                 let Some(el) = self.elses.get_mut(branch_id as usize) else { return };
                 let Some(cond) = el.cond.as_mut() else { return };
-                cond.reload(attribute_storage);
+                let current = cond.as_bool();
+                cond.reload(ctx.attribute_storage);
+                if cond.as_bool() != current {
+                    ctx.truncate_children(&mut tree);
+                }
             }
             // TODO:
             // this could probably happen given something like this
@@ -29,39 +39,6 @@ impl<'bp> ControlFlow<'bp> {
     }
 }
 
-impl ControlFlow<'_> {
-    pub(crate) fn has_changed(&self, children: &WidgetTreeView<'_, '_>) -> bool {
-        let child_count = children.layout_len();
-        if child_count != 1 {
-            return true;
-        }
-
-        let branch_id = self.current_branch_id(children);
-
-        // Check if another branch id before this has become true,
-        // if so this has changed.
-        if self.elses[..branch_id as usize].iter().any(|e| e.is_true()) {
-            return true;
-        }
-
-        // If the current branch is false, the value has changed,
-        // as it has to have been true at one point to become
-        // the current branch.
-        !self.elses[branch_id as usize].is_true()
-    }
-
-    fn current_branch_id(&self, children: &WidgetTreeView<'_, '_>) -> u16 {
-        let node_id = children.layout[0].value();
-        let (_, widget) = children
-            .values
-            .get(node_id)
-            .expect("because the node exists, the value exist");
-
-        let WidgetKind::ControlFlowContainer(id) = widget.kind else { unreachable!() };
-        id
-    }
-}
-
 #[derive(Debug)]
 pub struct Else<'bp> {
     pub cond: Option<Value<'bp>>,

anathema-widgets/src/nodes/update.rs

@@ -34,9 +34,7 @@ pub fn update_widget<'bp>(
         WidgetKind::For(for_loop) => for_loop.update(change, tree, ctx)?,
         WidgetKind::With(with) => with.update(change, tree, ctx.attribute_storage)?,
         WidgetKind::Iteration(_) => todo!(),
-        WidgetKind::ControlFlow(controlflow) => {
-            controlflow.update(change, value_id.index().into(), ctx.attribute_storage)
-        }
+        WidgetKind::ControlFlow(controlflow) => controlflow.update(change, value_id.index().into(), tree, ctx),
         WidgetKind::ControlFlowContainer(_) => unreachable!("control flow containers have no values"),
         WidgetKind::Component(_) => (),
         WidgetKind::Slot => todo!(),