wip

Author: togglebyte

anathema-core/src/attributes.rs

@@ -1,6 +1,5 @@
 //! Element attributes
 use std::borrow::Borrow;
-// #![deny(missing_docs)]
 use std::ops::Deref;
 
 use anathema_store::remotecell::RemoteCell;
@@ -10,12 +9,13 @@ use anathema_store::smallmap::{SmallIndex, SmallMap};
 use crate::runtime::elements::ElementId;
 use crate::runtime::eval::values::TemplateValue;
 
+// All attributes for all elements
 #[derive(Debug)]
-pub struct AllAttributes<'bp> {
+pub(crate) struct AttributeRegistry<'bp> {
     attributes: SecondaryMap<ElementId, Attributes<'bp>>,
 }
 
-impl<'bp> AllAttributes<'bp> {
+impl<'bp> AttributeRegistry<'bp> {
     pub(crate) fn empty() -> Self {
         Self {
             attributes: SecondaryMap::empty(),
@@ -27,14 +27,15 @@ impl<'bp> AllAttributes<'bp> {
     }
 }
 
+// The access key for attributes.
 #[derive(Debug, Copy, Clone, PartialEq)]
-pub enum ValueKey<'bp> {
+pub(crate) enum ValueKey<'bp> {
     Value,
     Attribute(&'bp str),
 }
 
 impl ValueKey<'_> {
-    pub fn as_str(&self) -> &str {
+    fn as_str(&self) -> &str {
         match self {
             ValueKey::Value => "[value]",
             ValueKey::Attribute(name) => name,
@@ -48,12 +49,20 @@ impl Borrow<str> for ValueKey<'_> {
     }
 }
 
+/// Element attributes
+///
+/// ```text
+/// text [foreground: "red", bold: true] "hello world"
+/// ```
+///
+/// Attributes can be set / replaced or read, but never mutated because of the `RemoteCell`.
 #[derive(Debug)]
 pub struct Attributes<'bp> {
     inner: SmallMap<ValueKey<'bp>, RemoteCell<TemplateValue<'bp>>>,
 }
 
 impl<'bp> Attributes<'bp> {
+    /// Create a new instance of en empty set of attributes
     pub fn empty() -> Self {
         Self {
             inner: SmallMap::empty(),
@@ -102,8 +111,9 @@ impl<'bp> Attributes<'bp> {
         self.inner.remove(key)
     }
 
-    pub(crate) fn get(&self, key: &str) -> Option<&RemoteCell<TemplateValue<'bp>>> {
-        self.inner.get(key)
+    pub(crate) fn get(&self, key: &str) -> Option<&TemplateValue<'bp>> {
+        let val = self.inner.get(key)?;
+        Some(&*val)
     }
 
     /// Get a value as a given type.
@@ -129,6 +139,7 @@ impl<'bp> Attributes<'bp> {
     pub fn value_as<'a, T>(&'a self) -> Option<T>
     where
         T: TryFrom<&'a TemplateValue<'bp>>,
+        T: ?Sized,
     {
         self.inner
             .get(&ValueKey::Value)
@@ -177,12 +188,116 @@ impl<'bp> Attributes<'bp> {
             .flatten()
     }
 
-    /// Iterate over attributes.
-    /// This will skip the value
-    pub fn iter(&self) -> impl Iterator<Item = (&ValueKey<'_>, &RemoteCell<TemplateValue<'bp>>)> {
+    /// Iterator of keys and values.
+    /// NOTE: This will skip the value
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &TemplateValue<'bp>)> {
         self.inner.iter().filter_map(|(key, val)| match key {
             ValueKey::Value => None,
-            ValueKey::Attribute(_) => Some((key, &*val)),
+            &ValueKey::Attribute(key) => Some((key, &**val)),
         })
     }
+
+    /// Iterator of keys
+    pub fn iter_keys(&self) -> impl Iterator<Item = &str> {
+        self.inner.iter().filter_map(|(key, _)| match key {
+            ValueKey::Value => None,
+            &ValueKey::Attribute(key) => Some(key),
+        })
+    }
+
+    /// Iterator of values
+    pub fn iter_values(&self) -> impl Iterator<Item = &TemplateValue<'bp>> {
+        self.inner.iter().filter_map(|(key, value)| match key {
+            ValueKey::Value => None,
+            &ValueKey::Attribute(_) => Some(&**value),
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn attributes() -> Attributes<'static> {
+        let mut attributes = Attributes::empty();
+        attributes.set("int", 1);
+        attributes.set("strings", vec!["one", "two"]);
+        attributes.set("numbers", vec![1, 2, 3]);
+        attributes.set(
+            "mixed",
+            TemplateValue::List(vec![true.into(), 1.into(), "string".into()].into()),
+        );
+        attributes
+    }
+
+    #[test]
+    fn replace_attribute() {
+        let mut attributes = attributes();
+        assert_eq!(attributes.get_as::<u32>("int").unwrap(), 1);
+        attributes.set("int", 2);
+        assert_eq!(attributes.get_as::<u32>("int").unwrap(), 2);
+    }
+
+    #[test]
+    fn set_value() {
+        let mut attributes = attributes();
+        attributes.set("other", 2);
+        assert_eq!(attributes.get_as::<u32>("other").unwrap(), 2);
+    }
+
+    #[test]
+    fn remove() {
+        let mut attributes = attributes();
+        attributes.remove("int");
+        assert!(attributes.get("int").is_none());
+    }
+
+    #[test]
+    fn get_attribute() {
+        let attributes = attributes();
+        assert_eq!(attributes.get("int"), Some(&TemplateValue::Int(1)));
+    }
+
+    #[test]
+    fn get_attribute_as() {
+        let attributes = attributes();
+        assert_eq!(attributes.get_as::<u8>("int").unwrap(), 1);
+        assert!(attributes.get_as::<bool>("int").is_none());
+    }
+
+    #[test]
+    fn get_value_as() {
+        let mut attributes = attributes();
+        attributes.set_value("hello world");
+        assert_eq!(attributes.value_as::<&str>().unwrap(), "hello world");
+
+        attributes.set_value("hello world".to_string());
+        assert_eq!(attributes.value_as::<&str>().unwrap(), "hello world");
+    }
+
+    #[test]
+    fn iterate_as() {
+        let attributes = attributes();
+        let numbers = attributes.iter_as::<u32>("numbers").collect::<Vec<_>>();
+        assert_eq!(numbers, vec![1, 2, 3]);
+
+        let strings = attributes.iter_as::<&str>("strings").collect::<Vec<_>>();
+        assert_eq!(strings, vec!["one", "two"]);
+    }
+
+    #[test]
+    fn iter() {
+        let attributes = attributes();
+        let mut iter = attributes.iter();
+        assert_eq!(("int", &TemplateValue::Int(1)), iter.next().unwrap());
+    }
+
+    #[test]
+    fn iter_keys() {
+        let attributes = attributes();
+        let mut iter = attributes.iter_keys();
+        assert_eq!("int", iter.next().unwrap());
+        assert_eq!("strings", iter.next().unwrap());
+        assert_eq!("numbers", iter.next().unwrap());
+    }
 }

anathema-core/src/layout.rs

@@ -1,15 +1,19 @@
+//! Storing the calculated layout of each element.
+//!
+//! The calculating the layout it self is done elsewhere.
 use anathema_geometry::{Pos, Region, Size};
 use anathema_store::slab::SecondaryMap;
 
 use crate::runtime::elements::ElementId;
 
+/// Store the layout for each element.
 #[derive(Debug)]
 pub struct Layout {
     regions: SecondaryMap<ElementId, Region>,
 }
 
 impl Layout {
-    pub fn empty() -> Self {
+    pub(crate) fn empty() -> Self {
         Self {
             regions: SecondaryMap::empty(),
         }

anathema-core/src/lib.rs

@@ -2,11 +2,16 @@
 #[allow(unused_extern_crates)]
 extern crate anathema_state as anathema;
 
+// Has docs
 pub mod attributes;
 pub mod frontend;
 pub mod layout;
+
+// Dosn't like has docs so is a bit mid
 pub mod runtime;
 pub mod templates;
-pub mod ui;
+
+// Decide what to do here
+// pub mod ui;
 
 pub(crate) mod testing;

anathema-core/src/runtime/eval/mod.rs

@@ -5,7 +5,7 @@ use anathema_store::remotecell::RemoteHandle;
 
 use self::scope::Scope;
 use super::error::Result;
-use crate::attributes::{AllAttributes, Attributes, ValueKey};
+use crate::attributes::{AttributeRegistry, Attributes, ValueKey};
 use crate::runtime::components::Components;
 use crate::runtime::elements::{Element, ElementId, Elements};
 use crate::runtime::eval::expression::{eval_by_id, RuntimeExpression, RuntimeExpressions};
@@ -14,7 +14,6 @@ use crate::runtime::functions::{Function, FunctionTable};
 use crate::runtime::widgets::RegisteredWidgets;
 use crate::templates::expressions::{self, Expressions};
 use crate::templates::{Blueprint, Component, ExpressionId, For, Single, Variables};
-use crate::ui::Document;
 
 mod assoc;
 pub(crate) mod expression;
@@ -24,7 +23,7 @@ pub(crate) mod values;
 #[derive(Debug)]
 pub struct EvalCtx<'a, 'bp> {
     pub(crate) elements: &'a mut Elements<'bp>,
-    pub(crate) attributes: &'a mut AllAttributes<'bp>,
+    pub(crate) attributes: &'a mut AttributeRegistry<'bp>,
     pub(crate) components: &'a mut Components,
     pub(crate) variables: &'a Variables,
     pub(crate) expressions: &'bp Expressions,
@@ -37,7 +36,7 @@ pub struct EvalCtx<'a, 'bp> {
 impl<'frame, 'bp> EvalCtx<'frame, 'bp> {
     pub(crate) fn new(
         elements: &'frame mut Elements<'bp>,
-        attributes: &'frame mut AllAttributes<'bp>,
+        attributes: &'frame mut AttributeRegistry<'bp>,
         components: &'frame mut Components,
         variables: &'frame Variables,
         expressions: &'bp Expressions,
@@ -239,7 +238,7 @@ mod test {
     use anathema_state::Value;
 
     use super::*;
-    use crate::attributes::AllAttributes;
+    use crate::attributes::AttributeRegistry;
     use crate::layout::Layout;
     use crate::testing::{RunBuilder, TestWidget};
 

anathema-core/src/templates/blueprints.rs

@@ -60,11 +60,17 @@ pub struct Component {
 /// A blueprint represents what widget should be built from the information
 #[derive(Clone, Debug, PartialEq)]
 pub enum Blueprint {
+    /// A singular widget
     Single(Single),
+    /// A for-loop
     For(For),
+    /// A `with` statement
     With(With),
+    /// If / else
     ControlFlow(ControlFlow),
+    /// A component
     Component(Component),
+    /// A slot for a component
     Slot(Vec<Self>),
 }