feat: support for 'ironvar' dynamic variables

src/ironvar.rs

@@ -0,0 +1,107 @@
+#![doc = include_str!("../docs/Ironvars.md")]
+
+use crate::{arc_rw, send};
+use color_eyre::{Report, Result};
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use tokio::sync::broadcast;
+
+lazy_static! {
+    static ref VARIABLE_MANAGER: Arc<RwLock<VariableManager>> = arc_rw!(VariableManager::new());
+}
+
+pub fn get_variable_manager() -> Arc<RwLock<VariableManager>> {
+    VARIABLE_MANAGER.clone()
+}
+
+/// Global singleton manager for `IronVar` variables.
+pub struct VariableManager {
+    variables: HashMap<Box<str>, IronVar>,
+}
+
+impl VariableManager {
+    pub fn new() -> Self {
+        Self {
+            variables: HashMap::new(),
+        }
+    }
+
+    /// Sets the value for a variable,
+    /// creating it if it does not exist.
+    pub fn set(&mut self, key: Box<str>, value: String) -> Result<()> {
+        if Self::key_is_valid(&key) {
+            if let Some(var) = self.variables.get_mut(&key) {
+                var.set(Some(value));
+            } else {
+                let var = IronVar::new(Some(value));
+                self.variables.insert(key, var);
+            }
+
+            Ok(())
+        } else {
+            Err(Report::msg("Invalid key"))
+        }
+    }
+
+    /// Gets the current value of an `ironvar`.
+    /// Prefer to use `subscribe` where possible.
+    pub fn get(&self, key: &str) -> Option<String> {
+        self.variables.get(key).and_then(IronVar::get)
+    }
+
+    /// Subscribes to an `ironvar`, creating it if it does not exist.
+    /// Any time the var is set, its value is sent on the channel.
+    pub fn subscribe(&mut self, key: Box<str>) -> broadcast::Receiver<Option<String>> {
+        self.variables
+            .entry(key)
+            .or_insert_with(|| IronVar::new(None))
+            .subscribe()
+    }
+
+    fn key_is_valid(key: &str) -> bool {
+        !key.is_empty()
+            && key
+                .chars()
+                .all(|char| char.is_alphanumeric() || char == '_' || char == '-')
+    }
+}
+
+/// Ironbar dynamic variable representation.
+/// Interact with them through the `VARIABLE_MANAGER` `VariableManager` singleton.
+#[derive(Debug)]
+struct IronVar {
+    value: Option<String>,
+    tx: broadcast::Sender<Option<String>>,
+    _rx: broadcast::Receiver<Option<String>>,
+}
+
+impl IronVar {
+    /// Creates a new variable.
+    fn new(value: Option<String>) -> Self {
+        let (tx, rx) = broadcast::channel(32);
+
+        Self { value, tx, _rx: rx }
+    }
+
+    /// Gets the current variable value.
+    /// Prefer to subscribe to changes where possible.
+    fn get(&self) -> Option<String> {
+        self.value.clone()
+    }
+
+    /// Sets the current variable value.
+    /// The change is broadcast to all receivers.
+    fn set(&mut self, value: Option<String>) {
+        self.value = value.clone();
+        send!(self.tx, value);
+    }
+
+    /// Subscribes to the variable.
+    /// The latest value is immediately sent to all receivers.
+    fn subscribe(&self) -> broadcast::Receiver<Option<String>> {
+        let rx = self.tx.subscribe();
+        send!(self.tx, self.value.clone());
+        rx
+    }
+}