fixing failing tests and removing warnings

Author: togglebyte

anathema-state-derive/src/lib.rs

@@ -1,5 +1,5 @@
 use syn::spanned::Spanned as _;
-use syn::{DeriveInput, parse_macro_input};
+use syn::{parse_macro_input, DeriveInput};
 
 static DERIVE_NAMESPACE: &str = "anathema";
 
@@ -10,20 +10,18 @@ pub fn anathema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         syn::Data::Struct(data) => structs::generate(&input, data),
 
         syn::Data::Enum(data) => syn::Error::new(
-            data.enum_token.span(), //
+            data.enum_token.span(),
             "anathema's State cannot be derived on enums currently",
         )
         .to_compile_error()
         .into(),
 
-        syn::Data::Union(data) => {
-            syn::Error::new(
-                data.union_token.span(), //
-                "anathema's State cannot be derived on unions currently",
-            )
-            .to_compile_error()
-            .into()
-        }
+        syn::Data::Union(data) => syn::Error::new(
+            data.union_token.span(),
+            "anathema's State cannot be derived on unions currently",
+        )
+        .to_compile_error()
+        .into(),
     }
 }
 

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) => {
@@ -442,89 +442,72 @@ fn float_op(lhs: f64, rhs: f64, op: Op) -> f64 {
 
 #[cfg(test)]
 mod test {
-    use anathema_state::{Changes, States};
+    use anathema_state::{drain_changes, Changes, States};
+    use anathema_templates::expressions::{ident, index, num, strlit};
 
     use crate::testing::setup;
 
     #[test]
     fn subscribe_if_not_exist() {
-        // // TODO: finish this test.
-        // // The test runner should take a custom state.
-        // // Right now it uses a Map<Box<dyn AnyState>> and that
-        // // is just annoying
+        // In this case the list is empty but it exists
 
-        // // In this case the list is empty but it exists
+        let mut changes = Changes::empty();
+        drain_changes(&mut changes);
+        assert!(changes.is_empty());
 
-        // let mut changes = Changes::empty();
-        // drain_changes(&mut changes);
-        // assert!(changes.is_empty());
-
-        // let mut states = States::new();
-        // setup(&mut states, Default::default(), |test| {
-        //     let expr = index(index(ident("state"), strlit("list")), num(0));
-
-        //     let mut list = List::<u32>::empty();
-        //     test.set_state("list", list);
+        let mut states = States::new();
+        setup(&mut states, Default::default(), |test| {
+            let expr = index(index(ident("state"), strlit("list")), num(0));
 
-        //     let mut value = test.eval(&expr);
+            let mut value = test.eval(&expr);
 
-        //     assert_eq!(value.as_int(), None);
+            assert_eq!(value.as_int(), None);
 
-        //     test.with_state(|state| {
-        //         let list = state.get_mut("list").unwrap();
-        //         let mut list = list.to_mut_cast::<List<u32>>();
-        //         // list.push(1);
-        //     });
+            test.with_state(|state| state.list.push("a"));
 
-        //     drain_changes(&mut changes);
-        //     for (subs, change) in changes.drain() {
-        //         for sub in subs.iter() {
-        //             if sub == value.sub {
-        //                 value.reload(&test.attributes);
-        //             }
-        //         }
-        //     }
+            drain_changes(&mut changes);
+            for (subs, _) in changes.drain() {
+                for sub in subs.iter() {
+                    if sub == value.sub {
+                        value.reload(&test.attributes);
+                    }
+                }
+            }
 
-        //     assert_eq!(value.as_int().unwrap(), 1);
-        // });
+            assert_eq!(value.as_str().unwrap(), "a");
+        });
     }
 
     #[test]
     fn list_preceding_value_removed() {
-        // TODO: finish this test.
-        // The test runner should take a custom state.
-        // Right now it uses a Map<Box<dyn AnyState>> and that
-        // is just annoying
-        let changes = Changes::empty();
+        let mut changes = Changes::empty();
 
         let mut states = States::new();
         setup(&mut states, Default::default(), |test| {
-            // let expr = index(index(ident("state"), strlit("list")), num(1));
+            let expr = index(index(ident("state"), strlit("list")), num(1));
 
-            // let mut list = List::from_iter([0u32, 1, 2]);
-            // test.set_state("list", list);
+            test.with_state(|state| {
+                state.list.push("a");
+                state.list.push("b");
+                state.list.push("c");
+            });
 
-            // let mut value = test.eval(&expr);
+            let mut value = test.eval(&expr);
 
-            // assert_eq!(value.as_int().unwrap(), 1);
+            assert_eq!(value.as_str().unwrap(), "b");
 
-            // test.with_state(|state| {
-            //     // let list = state.get_mut("list".into()).unwrap();
-            //     // let mut list = list.to_mut_cast::<List<u32>>();
-            //     // list.remove(0);
-            //     // panic!()
-            // });
+            test.with_state(|state| state.list.remove(0));
 
-            // drain_changes(&mut changes);
-            // for (subs, change) in changes.drain() {
-            //     for sub in subs.iter() {
-            //         if sub == value.sub {
-            //             value.reload(&test.attributes);
-            //         }
-            //     }
-            // }
+            drain_changes(&mut changes);
+            for (subs, _) in changes.drain() {
+                for sub in subs.iter() {
+                    if sub == value.sub {
+                        value.reload(&test.attributes);
+                    }
+                }
+            }
 
-            // assert_eq!(value.as_int().unwrap(), 2);
+            assert_eq!(value.as_str().unwrap(), "c");
         });
     }
 }

anathema-value-resolver/src/testing.rs

@@ -1,11 +1,57 @@
-use anathema_state::{AnyState, Map, StateId, States, Subscriber};
+use anathema_state::{AnyMap, AnyState, List, Map, State, StateId, States, Subscriber, Value};
 use anathema_store::slab::Key;
 use anathema_templates::{Expression, Globals, Variables};
 
 use super::*;
 use crate::context::ResolverCtx;
 use crate::scope::Scope;
-use crate::value::Value;
+
+#[derive(Debug)]
+pub(crate) struct TestState {
+    pub(crate) string: Value<&'static str>,
+    pub(crate) num: Value<i32>,
+    pub(crate) num_2: Value<i32>,
+    pub(crate) float: Value<f64>,
+    pub(crate) list: Value<List<&'static str>>,
+    pub(crate) map: Value<Map<i32>>,
+}
+
+impl TestState {
+    pub fn new() -> Self {
+        Self {
+            string: "".into(),
+            num: 0.into(),
+            num_2: 0.into(),
+            float: 0.0.into(),
+            list: List::empty().into(),
+            map: Map::empty().into(),
+        }
+    }
+}
+
+impl State for TestState {
+    fn type_info(&self) -> anathema_state::Type {
+        anathema_state::Type::Composite
+    }
+
+    fn as_any_map(&self) -> Option<&dyn AnyMap> {
+        Some(self)
+    }
+}
+
+impl AnyMap for TestState {
+    fn lookup(&self, key: &str) -> Option<anathema_state::PendingValue> {
+        match key {
+            "list" => self.list.reference().into(),
+            "num" => self.num.reference().into(),
+            "num_2" => self.num_2.reference().into(),
+            "float" => self.float.reference().into(),
+            "string" => self.string.reference().into(),
+            "map" => self.map.reference().into(),
+            _ => None,
+        }
+    }
+}
 
 pub(crate) struct TestCase<'a, 'bp> {
     globals: &'static Globals,
@@ -25,8 +71,7 @@ impl<'a, 'bp> TestCase<'a, 'bp> {
         }
     }
 
-    pub(crate) fn eval(&self, expr: &'bp Expression) -> Value<'bp> {
-        let root = Scope::root();
+    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);
 
@@ -38,21 +83,17 @@ impl<'a, 'bp> TestCase<'a, 'bp> {
         let scope = Scope::with_component(StateId::ZERO, Key::ZERO, None);
         self.attributes.with_mut(Key::ZERO, |attributes, storage| {
             let ctx = ResolverCtx::new(&self.globals, &scope, &self.states, storage);
-            attributes.insert_with(ValueKey::Attribute(key), |index| resolve(expr, &ctx, Subscriber::ZERO));
+            attributes.insert_with(ValueKey::Attribute(key), |_index| resolve(expr, &ctx, Subscriber::ZERO));
         });
     }
 
-    pub(crate) fn with_state<F>(&mut self, f: F)
+    pub(crate) fn with_state<F, U>(&mut self, f: F) -> U
     where
-        F: FnOnce(&mut Map<Box<dyn AnyState>>),
+        F: FnOnce(&mut TestState) -> U,
     {
         let state = self.states.get_mut(StateId::ZERO).unwrap();
-        let mut state = state.to_mut_cast::<Map<Box<dyn AnyState>>>();
-        f(&mut *state);
-    }
-
-    pub(crate) fn set_state(&mut self, key: &str, value: impl AnyState) {
-        self.with_state(|state| state.insert(key, Box::new(value)));
+        let mut state = state.to_mut_cast::<TestState>();
+        f(&mut *state)
     }
 }
 
@@ -61,7 +102,7 @@ where
     F: FnMut(&mut TestCase<'_, 'bp>),
 {
     // let state: Map<Box<dyn AnyState>> = Value::new(Map::empty());
-    let state: Box<dyn AnyState> = Box::new(Map::<Box<dyn AnyState>>::empty());
+    let state: Box<dyn AnyState> = Box::new(TestState::new());
     let state: anathema_state::Value<Box<dyn AnyState>> = anathema_state::Value::new(state);
     states.insert(state);
     let mut test = TestCase::new(states, globals.into());