attributes.set now supports adding owned strings, added missing u64 to try_from. more tests

Author: togglebyte

anathema-value-resolver/src/attributes.rs

@@ -110,6 +110,14 @@ impl<'bp> Attributes<'bp> {
         }
     }
 
+    /// Set an attribute value.
+    /// ```
+    /// # use anathema_value_resolver::{Attributes, ValueKind};
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// attributes.set("name", "Nonsense");
+    /// attributes.get_as::<&str>("name").unwrap();
+    /// ```
     pub fn set(&mut self, key: &'bp str, value: impl Into<ValueKind<'bp>>) {
         let key = ValueKey::Attribute(key);
         let value = value.into();
@@ -123,13 +131,15 @@ impl<'bp> Attributes<'bp> {
         self.attribs.set(key, value);
     }
 
+    #[doc(hidden)]
     pub fn insert_with<F>(&mut self, key: ValueKey<'bp>, f: F) -> SmallIndex
     where
         F: FnMut(SmallIndex) -> Value<'bp>,
     {
         self.attribs.insert_with(key, f)
     }
 
+    /// Remove a value from attributes
     pub fn remove(&mut self, key: &'bp str) -> Option<Value<'bp>> {
         let key = ValueKey::Attribute(key);
         self.attribs.remove(&key)
@@ -146,13 +156,37 @@ impl<'bp> Attributes<'bp> {
         self.attribs.get(key).map(|val| &val.kind)
     }
 
+    /// Get a value as a given type.
+    /// If the value doesn't exist or can not be cast to the
+    /// expected type `None` is returned.
+    /// ```
+    /// # use anathema_value_resolver::{Attributes, ValueKind};
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// attributes.set("num", 123);
+    ///
+    /// assert_eq!(attributes.get_as::<u32>("num").unwrap(), 123);
+    /// assert_eq!(attributes.get_as::<i16>("num").unwrap(), 123);
+    /// ```
     pub fn get_as<'a, T>(&'a self, key: &str) -> Option<T>
     where
         T: TryFrom<&'a ValueKind<'bp>>,
     {
         self.attribs.get(key).and_then(|val| (&val.kind).try_into().ok())
     }
 
+    /// Iterate over values of a given type
+    /// ```
+    /// # use anathema_value_resolver::{Attributes, ValueKind};
+    ///
+    /// let mut attributes = Attributes::empty();
+    /// let values =
+    ///     ValueKind::List([ValueKind::Int(1), ValueKind::Bool(true), ValueKind::Int(2)].into());
+    /// attributes.set("mixed_list", values);
+    ///
+    /// let iter = attributes.iter_as::<u32>("mixed_list");
+    /// assert_eq!(vec![1u32, 2], iter.collect::<Vec<_>>());
+    /// ```
     pub fn iter_as<'a, T>(&'a self, key: &str) -> impl Iterator<Item = T>
     where
         T: TryFrom<&'a ValueKind<'bp>>,
@@ -171,6 +205,9 @@ impl<'bp> Attributes<'bp> {
             .flatten()
     }
 
+    #[doc(hidden)]
+    /// This should only be used internally by the widgets
+    /// when updating a value.
     pub fn get_mut_with_index(&mut self, index: SmallIndex) -> Option<&mut Value<'bp>> {
         self.attribs.get_mut_with_index(index)
     }
@@ -192,18 +229,87 @@ impl<'bp> Attributes<'bp> {
 
 #[cfg(test)]
 mod test {
+    use anathema_state::{Color, Hex};
+
     use super::*;
 
-    #[test]
-    fn iter_as_int() {
+    fn attribs() -> Attributes<'static> {
         let mut attributes = Attributes::empty();
+
         let values = ValueKind::List([ValueKind::Int(1), ValueKind::Bool(true), ValueKind::Int(2)].into());
-        attributes.set("a", values);
+        attributes.set("mixed_list", values);
+        attributes.set("num", 123);
+        attributes.set("static_str", "static");
+        attributes.set("string", String::from("string"));
+        attributes.set("hex", Hex::from((1, 2, 3)));
+        attributes.set("red", Color::Red);
+        attributes.set("float", 1.23);
+        attributes.set("bool", true);
+        attributes.set("char", 'a');
+
+        attributes
+    }
+
+    #[test]
+    fn iter_as_type() {
+        let attributes = attribs();
 
-        let values = attributes.iter_as::<u8>("a").collect::<Vec<_>>();
+        let values = attributes.iter_as::<u8>("mixed_list").collect::<Vec<_>>();
         assert_eq!(vec![1, 2], values);
 
-        let values = attributes.iter_as::<bool>("a").collect::<Vec<_>>();
+        let values = attributes.iter_as::<bool>("mixed_list").collect::<Vec<_>>();
         assert_eq!(vec![true], values);
     }
+
+    #[test]
+    fn get_as_int() {
+        assert_eq!(123, attribs().get_as::<u8>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<i8>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<u16>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<i16>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<u32>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<i32>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<u64>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<i64>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<usize>("num").unwrap());
+        assert_eq!(123, attribs().get_as::<isize>("num").unwrap());
+    }
+
+    #[test]
+    fn get_as_strings() {
+        let attributes = attribs();
+        assert_eq!("static", attributes.get_as::<&str>("static_str").unwrap());
+        assert_eq!("string", attributes.get_as::<&str>("string").unwrap());
+    }
+
+    #[test]
+    fn get_as_hex() {
+        let attributes = attribs();
+        assert_eq!(Hex::from((1, 2, 3)), attributes.get_as::<Hex>("hex").unwrap());
+    }
+
+    #[test]
+    fn get_as_color() {
+        let attributes = attribs();
+        assert_eq!(Color::Red, attributes.get_as::<Color>("red").unwrap());
+    }
+
+    #[test]
+    fn get_as_float() {
+        let attributes = attribs();
+        assert_eq!(1.23, attributes.get_as::<f32>("float").unwrap());
+        assert_eq!(1.23, attributes.get_as::<f64>("float").unwrap());
+    }
+
+    #[test]
+    fn get_as_bool() {
+        let attributes = attribs();
+        assert_eq!(true, attributes.get_as::<bool>("bool").unwrap());
+    }
+
+    #[test]
+    fn get_as_char() {
+        let attributes = attribs();
+        assert_eq!('a', attributes.get_as::<char>("char").unwrap());
+    }
 }

anathema-value-resolver/src/value.rs

@@ -385,6 +385,12 @@ impl<'a> From<&'a str> for ValueKind<'a> {
     }
 }
 
+impl From<String> for ValueKind<'_> {
+    fn from(value: String) -> Self {
+        ValueKind::Str(value.into())
+    }
+}
+
 // -----------------------------------------------------------------------------
 //   - Try From -
 // -----------------------------------------------------------------------------
@@ -426,11 +432,13 @@ try_from_valuekind!(Hex, Hex);
 try_from_valuekind!(Color, Color);
 
 try_from_valuekind_int!(usize, Int);
+try_from_valuekind_int!(isize, Int);
 try_from_valuekind_int!(i32, Int);
 try_from_valuekind_int!(f32, Float);
 try_from_valuekind_int!(i16, Int);
 try_from_valuekind_int!(i8, Int);
 try_from_valuekind_int!(u32, Int);
+try_from_valuekind_int!(u64, Int);
 try_from_valuekind_int!(u16, Int);
 try_from_valuekind_int!(u8, Int);