Special case when using an optional map / composite in an if statement

Author: togglebyte

anathema-runtime/src/runtime/mod.rs

@@ -442,6 +442,10 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
             let Some(remote_state) = self.layout_ctx.states.get(event.state) else { return };
             let Some(remote_state) = remote_state.shared_state() else { return };
             self.with_component(widget_id, state_id, |comp, children, ctx| {
+                // TODO:
+                // Create a new event type
+                // if the event is stopped then return from drain_assoc_events
+
                 let event_ident = self.document.strings.get_ref_unchecked(event.external);
                 comp.dyn_component
                     .any_receive(children, ctx, event_ident, &*remote_state);

anathema-state-derive/src/structs.rs

@@ -90,7 +90,10 @@ fn generate_list(name: &Ident, len: usize) -> proc_macro::TokenStream {
 fn generate_composite(name: &Ident, fields: Vec<data::Field>) -> proc_macro::TokenStream {
     let field_names = fields
         .iter()
-        .map(|data::Field { display_name, .. }| quote::quote! { #display_name });
+        .map(|data::Field { display_name, .. }| quote::quote! { #display_name })
+        .collect::<Vec<_>>();
+
+    let is_empty = field_names.is_empty();
 
     let field_idents = fields
         .iter()
@@ -131,6 +134,10 @@ fn generate_composite(name: &Ident, fields: Vec<data::Field>) -> proc_macro::Tok
                     _ => None,
                 }
             }
+
+            fn is_empty(&self) -> bool {
+                #is_empty
+            }
         }
     }
     .into()

anathema-state/src/states.rs

@@ -268,12 +268,18 @@ impl AnyState for Box<dyn AnyState> {
 
 pub trait AnyMap {
     fn lookup(&self, key: &str) -> Option<PendingValue>;
+
+    fn is_empty(&self) -> bool;
 }
 
 pub trait AnyList {
     fn lookup(&self, index: usize) -> Option<PendingValue>;
 
     fn len(&self) -> usize;
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }
 
 // -----------------------------------------------------------------------------

anathema-state/src/value/list.rs

@@ -7,7 +7,7 @@ use super::{Shared, Type, Unique, Value};
 use crate::states::{AnyList, AnyState};
 use crate::store::changed;
 use crate::store::values::{get_unique, try_make_shared};
-use crate::{Change, PendingValue};
+use crate::{Change, PendingValue, State};
 
 #[derive(Debug)]
 pub struct List<T> {
@@ -206,19 +206,11 @@ impl<T: AnyState + 'static> AnyList for List<T> {
     }
 }
 
-impl<T: AnyState + 'static> AnyState for List<T> {
+impl<T: AnyState + 'static> State for List<T> {
     fn type_info(&self) -> Type {
         Type::List
     }
 
-    fn to_any_ref(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn to_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
     fn as_any_list(&self) -> Option<&dyn AnyList> {
         Some(self)
     }
@@ -250,8 +242,8 @@ where
 mod test {
 
     use super::*;
-    use crate::Subscriber;
     use crate::store::testing::drain_changes;
+    use crate::Subscriber;
 
     #[test]
     fn insert() {

anathema-state/src/value/map.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use super::{Shared, Type, Unique, Value};
-use crate::PendingValue;
+use crate::{PendingValue, State};
 use crate::states::{AnyMap, AnyState};
 use crate::store::values::{get_unique, try_make_shared};
 
@@ -89,26 +89,23 @@ impl<T: AnyState + 'static> AnyMap for Map<T> {
     fn lookup(&self, key: &str) -> Option<PendingValue> {
         self.get(key).map(|val| val.reference())
     }
+
+    fn is_empty(&self) -> bool {
+        self.is_empty()
+    }
 }
 
-impl<T: AnyState + 'static> AnyState for Map<T> {
+impl<T: AnyState + 'static> State for Map<T> {
     fn type_info(&self) -> Type {
         Type::Map
     }
 
-    fn to_any_ref(&self) -> &dyn std::any::Any {
-        self
-    }
-
-    fn to_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
     fn as_any_map(&self) -> Option<&dyn AnyMap> {
         Some(self)
     }
 }
 
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -150,7 +147,7 @@ mod test {
     fn remove() {
         let mut map = Map::empty();
         map.insert("a", DM(1));
-        let value_ref = map.get("a").as_ref().unwrap();
+        let _ = map.get("a").as_ref().unwrap();
 
         assert!(map.remove("a").is_some());
         assert!(map.is_empty());

anathema-value-resolver/src/expression.rs

@@ -3,11 +3,11 @@ use std::collections::HashMap;
 
 use anathema_state::{Color, Hex, PendingValue, SubTo, Subscriber, Type};
 use anathema_store::slab::Key;
-use anathema_templates::Primitive;
 use anathema_templates::expressions::{Equality, LogicalOp, Op};
+use anathema_templates::Primitive;
 
-use crate::AttributeStorage;
 use crate::value::ValueKind;
+use crate::AttributeStorage;
 
 macro_rules! or_null {
     ($val:expr) => {
@@ -18,13 +18,13 @@ macro_rules! or_null {
     };
 }
 
-pub struct ValueThingy<'a, 'bp> {
-    sub: Subscriber,
-    sub_to: &'a mut SubTo,
+pub struct ValueResolutionContext<'a, 'bp> {
+    pub(crate) sub: Subscriber,
+    pub(crate) sub_to: &'a mut SubTo,
     attribute_storage: &'a AttributeStorage<'bp>,
 }
 
-impl<'a, 'bp> ValueThingy<'a, 'bp> {
+impl<'a, 'bp> ValueResolutionContext<'a, 'bp> {
     pub fn new(attribute_storage: &'a AttributeStorage<'bp>, sub: Subscriber, sub_to: &'a mut SubTo) -> Self {
         Self {
             attribute_storage,
@@ -127,7 +127,7 @@ impl<'bp> From<PendingValue> for ValueExpr<'bp> {
 }
 
 // Resolve an expression to a value kind, this is the final value in the chain
-pub(crate) fn resolve_value<'a, 'bp>(value_expr: &ValueExpr<'bp>, ctx: &mut ValueThingy<'a, 'bp>) -> ValueKind<'bp> {
+pub(crate) fn resolve_value<'a, 'bp>(value_expr: &ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'a, 'bp>) -> ValueKind<'bp> {
     match value_expr {
         // -----------------------------------------------------------------------------
         //   - Primitives -
@@ -255,7 +255,8 @@ pub(crate) fn resolve_value<'a, 'bp>(value_expr: &ValueExpr<'bp>, ctx: &mut Valu
         // -----------------------------------------------------------------------------
         //   - Maps and lists -
         // -----------------------------------------------------------------------------
-        ValueExpr::DynMap(_) | ValueExpr::Map(_) => ValueKind::Map,
+        ValueExpr::Map(_) => ValueKind::Map,
+        ValueExpr::DynMap(map) => ValueKind::DynMap(*map),
         ValueExpr::Attributes(_) => ValueKind::Attributes,
         ValueExpr::DynList(value) => {
             value.subscribe(ctx.sub);
@@ -270,7 +271,7 @@ pub(crate) fn resolve_value<'a, 'bp>(value_expr: &ValueExpr<'bp>, ctx: &mut Valu
             let expr = resolve_index(src, index, ctx);
             resolve_value(&expr, ctx)
         }
-        ValueExpr::Composite(_) => ValueKind::Composite,
+        ValueExpr::Composite(comp) => ValueKind::Composite(*comp),
 
         // -----------------------------------------------------------------------------
         //   - Call -
@@ -299,7 +300,7 @@ fn resolve_pending(val: PendingValue) -> ValueExpr<'static> {
     }
 }
 
-fn resolve_index<'bp>(src: &ValueExpr<'bp>, index: &ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp>) -> ValueExpr<'bp> {
+fn resolve_index<'bp>(src: &ValueExpr<'bp>, index: &ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> ValueExpr<'bp> {
     match src {
         ValueExpr::DynMap(value) | ValueExpr::Composite(value) => {
             let s = or_null!(value.as_state());
@@ -371,11 +372,11 @@ fn resolve_index<'bp>(src: &ValueExpr<'bp>, index: &ValueExpr<'bp>, ctx: &mut Va
             resolve_index(&src, index, ctx)
         }
         ValueExpr::Null => ValueExpr::Null,
-        val => unreachable!("resolving index: this should return null eventually: {val:?}"),
+        val => unreachable!("resolving index: this should return null eventually: {val:?} (you probably did something like x.y on a string)"),
     }
 }
 
-fn resolve_expr<'a, 'bp>(expr: &'a ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp>) -> Option<ValueExpr<'bp>> {
+fn resolve_expr<'a, 'bp>(expr: &'a ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> Option<ValueExpr<'bp>> {
     match expr {
         ValueExpr::Either(first, second) => match resolve_expr(first, ctx) {
             None | Some(ValueExpr::Null) => resolve_expr(second, ctx),
@@ -386,7 +387,7 @@ fn resolve_expr<'a, 'bp>(expr: &'a ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp
     }
 }
 
-fn resolve_str<'a, 'bp>(index: &'a ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp>) -> Option<Kind<&'bp str>> {
+fn resolve_str<'a, 'bp>(index: &'a ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> Option<Kind<&'bp str>> {
     match index {
         ValueExpr::Str(kind) => Some(*kind),
         ValueExpr::Index(src, index) => match resolve_index(src, index, ctx) {
@@ -400,7 +401,7 @@ fn resolve_str<'a, 'bp>(index: &'a ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp
     }
 }
 
-fn resolve_int<'a, 'bp>(index: &'a ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp>) -> i64 {
+fn resolve_int<'a, 'bp>(index: &'a ValueExpr<'bp>, ctx: &mut ValueResolutionContext<'_, 'bp>) -> i64 {
     let value = resolve_value(index, ctx);
     match value {
         ValueKind::Int(index) => index,
@@ -411,9 +412,10 @@ fn resolve_int<'a, 'bp>(index: &'a ValueExpr<'bp>, ctx: &mut ValueThingy<'_, 'bp
         | ValueKind::Hex(_)
         | ValueKind::Color(_)
         | ValueKind::Str(_)
-        | ValueKind::Composite
+        | ValueKind::Composite(_)
         | ValueKind::Null
         | ValueKind::Map
+        | ValueKind::DynMap(_)
         | ValueKind::Attributes
         | ValueKind::List(_)
         | ValueKind::DynList(_) => todo!("resolving int: the value is {value:?}"),
@@ -442,7 +444,7 @@ fn float_op(lhs: f64, rhs: f64, op: Op) -> f64 {
 
 #[cfg(test)]
 mod test {
-    use anathema_state::{Changes, States, drain_changes};
+    use anathema_state::{drain_changes, Changes, Map, States};
     use anathema_templates::expressions::{ident, index, num, strlit};
 
     use crate::testing::setup;
@@ -500,14 +502,34 @@ mod test {
 
             drain_changes(&mut changes);
             for (subs, _) in changes.drain() {
-                for sub in subs.iter() {
-                    if sub == value.sub {
-                        value.reload(&test.attributes);
-                    }
+                if subs.iter().any(|sub| sub == value.sub) {
+                    value.reload(&test.attributes);
                 }
             }
-
             assert_eq!(value.as_str().unwrap(), "c");
         });
     }
+
+    #[test]
+    fn optional_map_from_empty_to_value() {
+        let mut changes = Changes::empty();
+
+        let mut states = States::new();
+        setup(&mut states, Default::default(), |test| {
+            // let expr = index(index(ident("state"), strlit("opt_map")), strlit("key"));
+            let expr = index(ident("state"), strlit("opt_map"));
+
+            let mut value = test.eval(&expr);
+            assert!(value.as_str().is_none());
+
+            test.with_state(|state| {
+                let mut map = Map::empty();
+                map.insert("key", 123);
+                state.opt_map.set(Some(map));
+            });
+
+            drain_changes(&mut changes);
+            assert!(!changes.is_empty());
+        });
+    }
 }

anathema-value-resolver/src/testing.rs

@@ -14,6 +14,7 @@ pub(crate) struct TestState {
     pub(crate) float: Value<f64>,
     pub(crate) list: Value<List<&'static str>>,
     pub(crate) map: Value<Map<i32>>,
+    pub(crate) opt_map: Value<Option<Map<i32>>>,
 }
 
 impl TestState {
@@ -25,6 +26,7 @@ impl TestState {
             float: 0.0.into(),
             list: List::empty().into(),
             map: Map::empty().into(),
+            opt_map: Value::new(None),
         }
     }
 }
@@ -48,9 +50,14 @@ impl AnyMap for TestState {
             "float" => self.float.reference().into(),
             "string" => self.string.reference().into(),
             "map" => self.map.reference().into(),
+            "opt_map" => self.opt_map.reference().into(),
             _ => None,
         }
     }
+
+    fn is_empty(&self) -> bool {
+        false
+    }
 }
 
 pub(crate) struct TestCase<'a, 'bp> {
@@ -74,7 +81,6 @@ impl<'a, 'bp> TestCase<'a, 'bp> {
     pub(crate) fn eval(&self, expr: &'bp Expression) -> crate::value::Value<'bp> {
         let state_id = StateId::ZERO;
         let scope = Scope::with_component(state_id, Key::ZERO, None);
-
         let ctx = ResolverCtx::new(&self.globals, &scope, &self.states, &self.attributes);
         resolve(expr, &ctx, Subscriber::ZERO)
     }