runtime and builder can now register global values

togglebyte · togglebyte · commit 70c01ac415e6 · 2025-08-26T13:03:31.000+02:00
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,3 +1,6 @@
+* 0.2.12
+    * Clamping is now true by default on overflow
+    * Globals can now be registered with the runtime
 * 0.2.11
     * FEATURE: ranges 
     * `padding` function
diff --git a/anathema-default-widgets/src/testing.rs b/anathema-default-widgets/src/testing.rs
@@ -159,15 +159,16 @@ impl TestRunner {
         let main = doc.add_component("main", src.to_template()).unwrap();
         component_registry.add_component(main, (), TestState::new());
 
-        let (blueprint, globals) = doc.compile().unwrap();
+        let mut variables = Default::default();
+        let blueprint = doc.compile(&mut variables).unwrap();
 
         Self {
             factory,
             backend: TestBackend::new(size),
             states,
             component_registry,
             blueprint,
-            variables: globals,
+            variables,
             components: Components::new(),
             function_table: FunctionTable::new(),
         }
diff --git a/anathema-runtime/src/builder.rs b/anathema-runtime/src/builder.rs
@@ -3,7 +3,7 @@ use std::sync::atomic::Ordering;
 use anathema_backend::Backend;
 use anathema_default_widgets::register_default_widgets;
 use anathema_geometry::Size;
-use anathema_templates::{Document, ToSourceKind};
+use anathema_templates::{Document, Expression, ToSourceKind, Variables};
 use anathema_value_resolver::{Function, FunctionTable};
 use anathema_widgets::components::deferred::DeferredComponents;
 use anathema_widgets::components::events::Event;
@@ -28,6 +28,7 @@ pub struct Builder<G> {
     global_event_handler: G,
     hot_reload: bool,
     function_table: FunctionTable,
+    variables: Variables,
 }
 
 impl<G: GlobalEventHandler> Builder<G> {
@@ -54,6 +55,7 @@ impl<G: GlobalEventHandler> Builder<G> {
             global_event_handler,
             hot_reload: true,
             function_table: FunctionTable::new(),
+            variables: Variables::new(),
         }
     }
 
@@ -164,9 +166,15 @@ impl<G: GlobalEventHandler> Builder<G> {
             global_event_handler,
             hot_reload: self.hot_reload,
             function_table: self.function_table,
+            variables: Variables::new(),
         }
     }
 
+    pub fn register_global(&mut self, key: impl Into<String>, value: impl Into<Expression>) -> Result<()> {
+        self.variables.define_global(key, value).map_err(|e| e.to_error(None))?;
+        Ok(())
+    }
+
     pub fn finish<F, B>(mut self, backend: &mut B, mut f: F) -> Result<()>
     where
         F: FnMut(&mut Runtime<G>, &mut B) -> Result<()>,
@@ -180,8 +188,8 @@ impl<G: GlobalEventHandler> Builder<G> {
             server
         };
 
-        let (blueprint, globals) = loop {
-            match self.document.compile() {
+        let blueprint = loop {
+            match self.document.compile(&mut self.variables) {
                 Ok(val) => break val,
                 // This can only show template errors.
                 // Widget errors doesn't become available until after the first tick.
@@ -199,7 +207,7 @@ impl<G: GlobalEventHandler> Builder<G> {
 
         let mut inst = Runtime::new(
             blueprint,
-            globals,
+            self.variables,
             self.component_registry,
             self.document,
             self.factory,
diff --git a/anathema-runtime/src/runtime/mod.rs b/anathema-runtime/src/runtime/mod.rs
@@ -7,7 +7,7 @@ use anathema_geometry::Size;
 use anathema_state::{Changes, StateId, States, clear_all_changes, clear_all_subs, drain_changes};
 use anathema_store::tree::root_node;
 use anathema_templates::blueprints::Blueprint;
-use anathema_templates::{Document, Variables};
+use anathema_templates::{Document, Expression, Variables};
 use anathema_value_resolver::{AttributeStorage, FunctionTable, Scope};
 use anathema_widgets::components::deferred::{CommandKind, DeferredComponents};
 use anathema_widgets::components::events::{Event, EventType};
@@ -65,6 +65,11 @@ impl Runtime<()> {
         Builder::new(doc, backend.size(), ())
     }
 
+    pub fn register_global(&mut self, key: impl Into<String>, value: impl Into<Expression>) -> Result<()> {
+        self.variables.define_global(key, value).map_err(|e| e.to_error(None))?;
+        Ok(())
+    }
+
     /// Create a runtime builder using an existing emitter
     pub fn with_receiver<B: Backend>(
         message_receiver: MessageReceiver,
@@ -267,9 +272,8 @@ impl<G: GlobalEventHandler> Runtime<G> {
         // Reload templates
         self.document.reload_templates()?;
 
-        let (blueprint, variables) = self.document.compile()?;
+        let blueprint = self.document.compile(&mut self.variables)?;
         self.blueprint = blueprint;
-        self.variables = variables;
 
         Ok(())
     }
diff --git a/anathema-templates/src/document.rs b/anathema-templates/src/document.rs
@@ -21,7 +21,6 @@ use crate::{ComponentBlueprintId, Lexer, Variables};
 pub struct Document {
     template: TemplateSource,
     pub strings: Strings,
-    globals: Variables,
     components: ComponentTemplates,
     pub hot_reload: bool,
 }
@@ -32,7 +31,6 @@ impl Document {
         Self {
             template,
             strings: Strings::new(),
-            globals: Variables::default(),
             components: ComponentTemplates::new(),
             hot_reload: true,
         }
@@ -58,9 +56,7 @@ impl Document {
         Ok(id)
     }
 
-    pub fn compile(&mut self) -> Result<(Blueprint, Variables)> {
-        self.globals = Variables::default();
-
+    pub fn compile(&mut self, globals: &mut Variables) -> Result<Blueprint> {
         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);
@@ -69,7 +65,7 @@ impl Document {
 
         let mut context = Context {
             template: &self.template,
-            variables: &mut self.globals,
+            variables: globals,
             strings: &mut self.strings,
             components: &mut self.components,
             slots: SmallMap::empty(),
@@ -79,7 +75,7 @@ impl Document {
         let mut blueprints = Scope::new(statements).eval(&mut context)?;
         match blueprints.is_empty() {
             true => Err(Error::no_template(ErrorKind::EmptyTemplate)),
-            false => Ok((blueprints.remove(0), self.globals.take())),
+            false => Ok(blueprints.remove(0)),
         }
     }
 
diff --git a/anathema-templates/src/error/mod.rs b/anathema-templates/src/error/mod.rs
@@ -58,7 +58,7 @@ pub enum ErrorKind {
 }
 
 impl ErrorKind {
-    pub(crate) fn to_error(self, template: Option<PathBuf>) -> Error {
+    pub fn to_error(self, template: Option<PathBuf>) -> Error {
         Error::new(template, self)
     }
 }
diff --git a/anathema-templates/src/expressions/mod.rs b/anathema-templates/src/expressions/mod.rs
@@ -97,6 +97,33 @@ impl<T: Into<Primitive>> From<T> for Expression {
     }
 }
 
+impl<T: Into<Expression>> From<HashMap<String, T>> for Expression {
+    fn from(map: HashMap<String, T>) -> Self {
+        let map = map.into_iter().map(|(key, val)| (key, val.into())).collect();
+        Self::Map(map)
+    }
+}
+
+impl<T: Into<Expression>> From<Vec<T>> for Expression {
+    fn from(list: Vec<T>) -> Self {
+        let inner = list.into_iter().map(|i| i.into()).collect();
+        Self::List(inner)
+    }
+}
+
+impl<const N: usize, T: Into<Expression>> From<[T; N]> for Expression {
+    fn from(list: [T; N]) -> Self {
+        let inner = list.map(|i| i.into());
+        Self::List(inner.to_vec())
+    }
+}
+
+impl From<String> for Expression {
+    fn from(value: String) -> Self {
+        Self::Str(value)
+    }
+}
+
 impl From<&str> for Expression {
     fn from(value: &str) -> Self {
         Self::Str(value.into())
diff --git a/anathema-templates/src/statements/eval.rs b/anathema-templates/src/statements/eval.rs
@@ -261,12 +261,12 @@ impl Scope {
 mod test {
     use super::*;
     use crate::document::Document;
-    use crate::{ToSourceKind, single};
+    use crate::{ToSourceKind, Variables, single};
 
     #[test]
     fn eval_node() {
         let mut doc = Document::new("node");
-        let (bp, _) = doc.compile().unwrap();
+        let bp = doc.compile(&mut Variables::new()).unwrap();
         assert_eq!(bp, single!("node"));
     }
 
@@ -277,7 +277,7 @@ mod test {
             b
         ";
         let mut doc = Document::new(src);
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert_eq!(blueprint, single!(children @ "a", vec![single!("b")]));
     }
 
@@ -289,7 +289,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::Single(Single { value: Some(_), .. })));
     }
 
@@ -298,7 +298,7 @@ mod test {
         let src = "let state = 1";
 
         let mut doc = Document::new(src);
-        let response = doc.compile();
+        let response = doc.compile(&mut Variables::new());
         assert_eq!(
             response.err().unwrap().to_string(),
             "invalid statement: state is a reserved identifier"
@@ -313,7 +313,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        let response = doc.compile();
+        let response = doc.compile(&mut Variables::new());
         assert_eq!(
             response.err().unwrap().to_string(),
             "invalid statement: state is a reserved identifier"
@@ -327,7 +327,7 @@ mod test {
                 node
         ";
         let mut doc = Document::new(src);
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::For(For { .. })));
     }
 
@@ -341,7 +341,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         let Blueprint::ControlFlow(controlflow) = blueprint else { panic!() };
         assert!(matches!(controlflow.elses[0], Else { .. }));
         assert!(!controlflow.elses.is_empty());
@@ -356,7 +356,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         let Blueprint::ControlFlow(controlflow) = blueprint else { panic!() };
         assert!(matches!(controlflow.elses[0], Else { .. }));
         assert!(!controlflow.elses.is_empty());
@@ -374,7 +374,7 @@ mod test {
         ";
 
         let mut doc = Document::new(src);
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         let Blueprint::ControlFlow(controlflow) = blueprint else { panic!() };
         assert!(matches!(controlflow.elses[0], Else { .. }));
         assert!(!controlflow.elses.is_empty());
@@ -387,7 +387,7 @@ mod test {
 
         let mut doc = Document::new(src);
         doc.add_component("comp", comp_src.to_template()).unwrap();
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::Component(Component { .. })));
     }
 
@@ -412,7 +412,7 @@ mod test {
 
         let mut doc = Document::new(src);
         doc.add_component("comp", comp_src.to_template()).unwrap();
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::Component(Component { .. })));
     }
 
@@ -426,7 +426,7 @@ mod test {
 
         let mut doc = Document::new(src);
         doc.add_component("comp", "node a".to_template()).unwrap();
-        let _ = doc.compile().unwrap();
+        let _ = doc.compile(&mut Variables::new()).unwrap();
     }
 
     #[test]
@@ -437,7 +437,7 @@ mod test {
 
         let mut doc = Document::new(src);
         doc.add_component("comp", "node a".to_template()).unwrap();
-        let _ = doc.compile().unwrap();
+        let _ = doc.compile(&mut Variables::new()).unwrap();
     }
 
     #[test]
@@ -449,7 +449,7 @@ mod test {
 
         let mut doc = Document::new(src);
         doc.add_component("comp", "node a".to_template()).unwrap();
-        let (blueprint, _) = doc.compile().unwrap();
+        let blueprint = doc.compile(&mut Variables::new()).unwrap();
         assert!(matches!(blueprint, Blueprint::With(With { .. })));
     }
 }
diff --git a/anathema-templates/src/variables.rs b/anathema-templates/src/variables.rs
@@ -7,7 +7,7 @@ use crate::error::ErrorKind;
 use crate::expressions::Expression;
 
 #[derive(Debug, Default, Clone)]
-pub(crate) struct Globals(HashMap<String, Expression>);
+pub struct Globals(HashMap<String, Expression>);
 
 impl Globals {
     pub fn empty() -> Self {
@@ -22,7 +22,7 @@ impl Globals {
         self.0.get(ident)
     }
 
-    pub(crate) fn set(&mut self, ident: String, value: Expression) {
+    pub fn set(&mut self, ident: String, value: Expression) {
         if self.0.contains_key(&ident) {
             return;
         }
@@ -229,6 +229,12 @@ pub struct Variables {
 
 impl Default for Variables {
     fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Variables {
+    pub fn new() -> Self {
         let root = RootScope::default();
         Self {
             globals: Globals::empty(),
@@ -239,16 +245,6 @@ impl Default for Variables {
             declarations: Declarations::new(),
         }
     }
-}
-
-impl Variables {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn take(&mut self) -> Self {
-        std::mem::take(self)
-    }
 
     fn declare_at(&mut self, ident: impl Into<String>, var_id: VarId, id: ScopeId) -> VarId {
         let ident = ident.into();
@@ -262,8 +258,7 @@ impl Variables {
             return Err(ErrorKind::GlobalAlreadyAssigned(ident));
         }
 
-        let value = value.into();
-        self.globals.set(ident, value);
+        self.globals.set(ident, value.into());
         Ok(())
     }
 
diff --git a/anathema-widgets/src/testing.rs b/anathema-widgets/src/testing.rs

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ pub enum ErrorKind {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`impl ErrorKind {`
`61`		`- pub(crate) fn to_error(self, template: Option<PathBuf>) -> Error {`
	`61`	`+ pub fn to_error(self, template: Option<PathBuf>) -> Error {`
`62`	`62`	`Error::new(template, self)`
`63`	`63`	`}`
`64`	`64`	`}`