fixed errors

Author: togglebyte

anathema-runtime/src/runtime/mod.rs

@@ -3,7 +3,7 @@ use std::time::{Duration, Instant};
 
 use anathema_backend::{Backend, WidgetCycle};
 use anathema_geometry::Size;
-use anathema_state::{Changes, StateId, States, clear_all_changes, clear_all_subs, drain_changes};
+use anathema_state::{clear_all_changes, clear_all_subs, drain_changes, Changes, StateId, States};
 use anathema_store::tree::root_node;
 use anathema_templates::blueprints::Blueprint;
 use anathema_templates::{Document, Globals};
@@ -17,8 +17,8 @@ use anathema_widgets::layout::{LayoutCtx, Viewport};
 use anathema_widgets::query::Children;
 use anathema_widgets::tabindex::{Index, TabIndex};
 use anathema_widgets::{
-    Component, Components, Factory, FloatingWidgets, GlyphMap, WidgetContainer, WidgetId, WidgetKind, WidgetTree,
-    eval_blueprint, update_widget,
+    eval_blueprint, update_widget, Component, Components, Factory, FloatingWidgets, GlyphMap, WidgetContainer,
+    WidgetId, WidgetKind, WidgetTree,
 };
 use flume::Receiver;
 use notify::RecommendedWatcher;

anathema-state/src/store/values.rs

@@ -131,18 +131,6 @@ pub(crate) fn drop_value(key: ValueKey) -> OwnedValue {
     value
 }
 
-pub(crate) fn copy_val<T: 'static + Copy>(key: OwnedKey) -> T {
-    OWNED
-        .with(|owned| {
-            owned.with(key, |val| {
-                let val: &dyn std::any::Any = &val.val;
-                let val = val.downcast_ref::<T>();
-                *val.expect("the value type is determined by the wrapping Value<T> and should not change")
-            })
-        })
-        .expect("the value is assumed to not be checked out or borrowed")
-}
-
 // /// This should only be used for debugging.
 // pub fn dump_state() -> String {
 //     use std::fmt::Write;

anathema-state/src/value/mod.rs

@@ -12,12 +12,12 @@ pub use self::list::List;
 pub use self::map::Map;
 pub use self::maybe::{Maybe, Nullable};
 use crate::states::State;
-use crate::store::subscriber::{SubKey, subscribe, unsubscribe};
+use crate::store::subscriber::{subscribe, unsubscribe, SubKey};
 use crate::store::values::{
-    OwnedValue, copy_val, drop_value, get_unique, make_shared, new_value, return_owned, return_shared, try_make_shared,
+    drop_value, get_unique, make_shared, new_value, return_owned, return_shared, try_make_shared, OwnedValue,
 };
-use crate::store::watchers::{Watcher, monitor, queue_monitor};
-use crate::store::{ValueKey, changed};
+use crate::store::watchers::{monitor, queue_monitor, Watcher};
+use crate::store::{changed, ValueKey};
 use crate::{Change, Subscriber};
 
 mod list;
@@ -157,11 +157,9 @@ impl<T: State> Value<T> {
 }
 
 /// Copy the inner value from the owned value.
-///
-/// This does not copy any auxillary data attached to the key
 impl<T: State + Copy> Value<T> {
     pub fn copy_value(&self) -> T {
-        copy_val(self.key.owned())
+        *self.to_ref()
     }
 }
 

anathema-store/src/storage/strings.rs

@@ -62,3 +62,9 @@ impl Display for StringId {
         write!(f, "<sid {}>", self.0)
     }
 }
+
+impl From<usize> for StringId {
+    fn from(value: usize) -> Self {
+        Self(value)
+    }
+}

anathema-templates/src/components.rs

@@ -6,7 +6,6 @@ use anathema_store::smallmap::SmallMap;
 use anathema_store::stack::Stack;
 use anathema_store::storage::Storage;
 
-use crate::Lexer;
 use crate::blueprints::Blueprint;
 use crate::error::{Error, Result};
 use crate::statements::eval::Scope;
@@ -15,6 +14,7 @@ use crate::statements::{Context, Statements};
 use crate::strings::{StringId, Strings};
 use crate::token::Tokens;
 use crate::variables::Variables;
+use crate::Lexer;
 
 pub trait ToSourceKind {
     fn to_path(self) -> SourceKind;
@@ -75,7 +75,6 @@ impl From<&str> for SourceKind {
 pub(crate) enum ComponentSource {
     File { path: PathBuf, template: String },
     InMemory(String),
-    Empty,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -102,6 +101,13 @@ impl SlabIndex for ComponentBlueprintId {
     }
 }
 
+#[cfg(test)]
+impl From<u32> for ComponentBlueprintId {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
 impl From<ComponentBlueprintId> for Index {
     fn from(value: ComponentBlueprintId) -> Self {
         value.0.into()
@@ -126,12 +132,6 @@ pub(crate) struct ComponentTemplates {
 }
 
 impl ComponentTemplates {
-    pub fn debug_bs(&self) {
-        for (a, (b, c)) in self.components.iter() {
-            eprintln!("{b:?}");
-        }
-    }
-
     pub(crate) fn new() -> Self {
         Self {
             dependencies: Stack::empty(),
@@ -147,10 +147,6 @@ impl ComponentTemplates {
         *k
     }
 
-    pub(crate) fn insert_id(&mut self, name: StringId) -> ComponentBlueprintId {
-        self.components.push(name, ComponentSource::Empty)
-    }
-
     pub(crate) fn insert(&mut self, ident: StringId, template: ComponentSource) -> ComponentBlueprintId {
         self.components.insert(ident, template)
     }
@@ -174,7 +170,6 @@ impl ComponentTemplates {
         let template = match component_src {
             ComponentSource::File { template, .. } => template,
             ComponentSource::InMemory(template) => template,
-            ComponentSource::Empty => return Err(Error::MissingComponent(ident)),
         };
 
         // NOTE
@@ -211,7 +206,6 @@ impl ComponentTemplates {
         self.components.iter().filter_map(|(_, (_, src))| match src {
             ComponentSource::File { path, .. } => Some(path),
             ComponentSource::InMemory(_) => None,
-            ComponentSource::Empty => None,
         })
     }
 
@@ -221,7 +215,7 @@ impl ComponentTemplates {
                 ComponentSource::File { path, template } => {
                     *template = read_to_string(path)?;
                 }
-                ComponentSource::InMemory(_) | ComponentSource::Empty => (),
+                ComponentSource::InMemory(_) => (),
             }
         }
         Ok(())

anathema-templates/src/error/parse.rs

@@ -63,9 +63,9 @@ impl Display for ParseError {
             ParseErrorKind::UnexpectedEof => "unexpected end of file".into(),
             ParseErrorKind::TrailingPipe => "trailing pipe character".into(),
             ParseErrorKind::InvalidDedent => "dedent does not match previous indentation levels".into(),
-            ParseErrorKind::InvalidOperator(_op) => "invalid operator: {op}".into(),
-            ParseErrorKind::UnexpectedToken(_msg) => "unexpected token: {msg}".into(),
-            ParseErrorKind::UnregisteredComponent(name) => "unregistered component: {name}".into(),
+            ParseErrorKind::InvalidOperator(op) => format!("invalid operator: {op}"),
+            ParseErrorKind::UnexpectedToken(msg) => format!("unexpected token: {msg}"),
+            ParseErrorKind::UnregisteredComponent(name) => format!("unregistered component: {name}"),
             ParseErrorKind::InvalidKey => todo!(),
         };
 

anathema-templates/src/statements/mod.rs

@@ -1,12 +1,12 @@
 use anathema_store::smallmap::SmallMap;
 
-use crate::ComponentBlueprintId;
 use crate::blueprints::Blueprint;
 use crate::components::{AssocEventMapping, ComponentTemplates};
 use crate::error::Result;
 use crate::expressions::Expression;
 use crate::strings::{StringId, Strings};
 use crate::variables::Variables;
+use crate::ComponentBlueprintId;
 
 mod const_eval;
 pub(crate) mod eval;
@@ -229,17 +229,21 @@ mod test {
         }
     }
 
-    pub(crate) fn component(id: ComponentBlueprintId) -> Statement {
-        Statement::Component(id)
+    pub(crate) fn component(id: u32) -> Statement {
+        let comp_id = ComponentBlueprintId::from(id);
+        Statement::Component(comp_id)
     }
 
     pub(crate) fn slot(id: usize) -> Statement {
         let id = StringId::from_usize(id);
         Statement::ComponentSlot(id.into())
     }
 
-    pub(crate) fn associated_fun(internal: StringId, external: StringId) -> Statement {
-        Statement::AssociatedFunction { internal, external }
+    pub(crate) fn associated_fun(internal: usize, external: usize) -> Statement {
+        Statement::AssociatedFunction(AssocEventMapping {
+            internal: internal.into(),
+            external: external.into(),
+        })
     }
 
     pub(crate) fn node(id: usize) -> Statement {

anathema-templates/src/statements/parser.rs

@@ -560,7 +560,9 @@ mod test {
 
     fn parse(src: &str) -> Vec<Result<Statement>> {
         let mut strings = Strings::new();
+        let x_id = strings.push("x");
         let mut components = ComponentTemplates::new();
+        components.insert(x_id, crate::components::ComponentSource::InMemory(String::new()));
         let lexer = Lexer::new(src, &mut strings);
         let tokens = Tokens::new(lexer.collect::<Result<Vec<_>>>().unwrap(), src.len());
         let parser = Parser::new(tokens, &mut strings, src, &mut components);
@@ -582,13 +584,13 @@ mod test {
     #[test]
     fn parse_single_instruction() {
         let actual = parse_ok("a").remove(0);
-        assert_eq!(node(1), actual);
+        assert_eq!(node(2), actual);
     }
 
     #[test]
     fn parse_attributes() {
         let src = "a [a: a]";
-        let expected = vec![node(1), load_attrib(1, ident("a")), eof()];
+        let expected = vec![node(2), load_attrib(2, ident("a")), eof()];
 
         let actual = parse_ok(src);
         assert_eq!(expected, actual);
@@ -597,7 +599,7 @@ mod test {
     #[test]
     fn parse_text() {
         let src = "a 'a'      \n\n//some comments \n    ";
-        let expected = vec![node(1), load_value(strlit("a")), eof()];
+        let expected = vec![node(2), load_value(strlit("a")), eof()];
 
         let actual = parse_ok(src);
         assert_eq!(expected, actual);
@@ -613,15 +615,15 @@ mod test {
             a
             ";
         let expected = vec![
-            node(1),
-            scope_start(),
             node(2),
             scope_start(),
             node(3),
+            scope_start(),
+            node(4),
             scope_end(),
-            node(2),
+            node(3),
             scope_end(),
-            node(1),
+            node(2),
             eof(),
         ];
 
@@ -634,11 +636,11 @@ mod test {
                     c
             ";
         let expected = vec![
-            node(1),
-            scope_start(),
             node(2),
             scope_start(),
             node(3),
+            scope_start(),
+            node(4),
             scope_end(),
             scope_end(),
             eof(),
@@ -699,7 +701,7 @@ mod test {
 
         assert_eq!(statements.remove(0), if_stmt(ident("data")));
         assert_eq!(statements.remove(0), scope_start());
-        assert_eq!(statements.remove(0), node(2));
+        assert_eq!(statements.remove(0), node(1));
         assert_eq!(statements.remove(0), scope_end());
     }
 
@@ -715,7 +717,7 @@ mod test {
 
         assert_eq!(statements.remove(0), if_stmt(*ident("data")));
         assert_eq!(statements.remove(0), scope_start());
-        assert_eq!(statements.remove(0), node(2));
+        assert_eq!(statements.remove(0), node(1));
         assert_eq!(statements.remove(0), scope_end());
         assert_eq!(statements.remove(0), else_stmt());
         assert_eq!(statements.remove(0), scope_start());
@@ -737,7 +739,7 @@ mod test {
 
         assert_eq!(statements.remove(0), if_stmt(ident("data")));
         assert_eq!(statements.remove(0), scope_start());
-        assert_eq!(statements.remove(0), node(2));
+        assert_eq!(statements.remove(0), node(1));
         assert_eq!(statements.remove(0), scope_end());
         assert_eq!(statements.remove(0), if_else(ident("data")));
         assert_eq!(statements.remove(0), scope_start());
@@ -751,11 +753,11 @@ mod test {
 
     #[test]
     fn parse_component() {
-        let src = "@mycomp";
+        let src = "@x";
         let mut statements = parse_ok(src);
         assert_eq!(statements.remove(0), component(0));
 
-        let src = "@mycomp state";
+        let src = "@x state";
         let mut statements = parse_ok(src);
         assert_eq!(statements.remove(0), component(0));
         assert_eq!(statements.remove(0), load_value(ident("state")));
@@ -765,7 +767,7 @@ mod test {
     fn parse_component_slot() {
         let src = "$slot";
         let mut statements = parse_ok(src);
-        assert_eq!(statements.remove(0), slot(1));
+        assert_eq!(statements.remove(0), slot(2));
     }
 
     #[test]
@@ -810,7 +812,7 @@ mod test {
     fn parse_text_with_multiple_values() {
         let src = "a 'a' 'b'";
         let mut statements = parse_ok(src);
-        assert_eq!(statements.remove(0), node(1));
+        assert_eq!(statements.remove(0), node(2));
         assert_eq!(
             statements.remove(0),
             load_value(text_segments([strlit("a"), strlit("b")]))