BUGFIX: template reload no longer fails on globals

Author: togglebyte

anathema-templates/src/document.rs

@@ -57,6 +57,7 @@ impl Document {
     }
 
     pub fn compile(&mut self, globals: &mut Variables) -> Result<Blueprint> {
+        globals.reset_globals();
         let tokens = Lexer::new(&self.template, &mut self.strings).collect::<Result<Vec<_>>>()?;
         let tokens = Tokens::new(tokens, self.template.len());
         let parser = Parser::new(tokens, &mut self.strings, &self.template, &mut self.components);

anathema-templates/src/variables.rs

@@ -6,8 +6,16 @@ use anathema_store::slab::{Slab, SlabIndex};
 use crate::error::ErrorKind;
 use crate::expressions::Expression;
 
+#[derive(Debug, Clone)]
+enum Global {
+    // The global value was set from the runtime
+    Runtime(Expression),
+    // The global value originates from a template
+    Template(Expression),
+}
+
 #[derive(Debug, Default, Clone)]
-pub struct Globals(HashMap<String, Expression>);
+pub struct Globals(HashMap<String, Global>);
 
 impl Globals {
     pub fn empty() -> Self {
@@ -19,15 +27,31 @@ impl Globals {
     }
 
     pub fn get(&self, ident: &str) -> Option<&Expression> {
-        self.0.get(ident)
+        match self.0.get(ident)? {
+            Global::Runtime(expression) | Global::Template(expression) => Some(expression),
+        }
     }
 
-    pub fn set(&mut self, ident: String, value: Expression) {
+    fn set(&mut self, ident: String, value: Global) {
         if self.0.contains_key(&ident) {
             return;
         }
         _ = self.0.insert(ident, value);
     }
+
+    fn clear_template_globals(&mut self) {
+        let mut clear = vec![];
+        for (key, glob) in &self.0 {
+            match glob {
+                Global::Runtime(_) => continue,
+                Global::Template(_) => clear.push(key.to_owned()),
+            }
+        }
+
+        for key in clear {
+            _ = self.0.remove(&key);
+        }
+    }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -252,16 +276,34 @@ impl Variables {
         var_id
     }
 
-    pub fn define_global(&mut self, ident: impl Into<String>, value: impl Into<Expression>) -> Result<(), ErrorKind> {
+    fn set_global(&mut self, ident: impl Into<String>, global: Global) -> Result<(), ErrorKind> {
         let ident = ident.into();
         if self.globals.contains(&ident) {
             return Err(ErrorKind::GlobalAlreadyAssigned(ident));
         }
 
-        self.globals.set(ident, value.into());
+        self.globals.set(ident, global);
         Ok(())
     }
 
+    /// Reset the globals defined in the template.
+    /// This keeps any globals registered through Rust
+    pub fn reset_globals(&mut self) {
+        self.globals.clear_template_globals();
+    }
+
+    pub fn register_global(&mut self, ident: impl Into<String>, value: impl Into<Expression>) -> Result<(), ErrorKind> {
+        let expression = value.into();
+        let global = Global::Runtime(expression);
+        self.set_global(ident, global)
+    }
+
+    pub fn define_global(&mut self, ident: impl Into<String>, value: impl Into<Expression>) -> Result<(), ErrorKind> {
+        let expression = value.into();
+        let global = Global::Template(expression);
+        self.set_global(ident, global)
+    }
+
     pub fn define_local(&mut self, ident: impl Into<String>, value: impl Into<Expression>) -> VarId {
         let value = value.into();
         let scope_id = self.current.clone();

anathema-widgets/src/nodes/loops.rs

@@ -28,6 +28,10 @@ impl<'bp> For<'bp> {
         parent_widget: Option<WidgetId>,
         dirty_widgets: &mut DirtyWidgets,
     ) -> Result<()> {
+        if let Some(widget) = parent_widget {
+            dirty_widgets.push(widget);
+        }
+
         match change {
             Change::Inserted(index) => {
                 // 1. Declare insert path
@@ -89,9 +93,6 @@ impl<'bp> For<'bp> {
                 // then truncate the tree
                 self.collection.reload(ctx.attribute_storage);
                 ctx.truncate_children(&mut tree);
-                if let Some(widget) = parent_widget {
-                    dirty_widgets.push(widget);
-                }
             }
         }