wip: rewrite core to be template focused

packages/core/src.old/nodes/arbitrary_value.rs

@@ -0,0 +1,163 @@
+use std::{
+    any::Any,
+    fmt::{Arguments, Formatter},
+};
+
+use bumpalo::Bump;
+
+/// Possible values for an attribute
+#[derive(Clone, Copy)]
+pub enum AttributeValue<'a> {
+    /// Reference strs, most common
+    Text(&'a str),
+    /// Basic float values
+    Float(f32),
+    /// Basic Int values
+    Int(i32),
+    /// Basic bool values
+    Bool(bool),
+    /// Everything else
+    Any(&'a dyn AnyAttributeValue),
+}
+
+impl<'a> PartialEq for AttributeValue<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Text(l0), Self::Text(r0)) => l0 == r0,
+            (Self::Float(l0), Self::Float(r0)) => l0 == r0,
+            (Self::Int(l0), Self::Int(r0)) => l0 == r0,
+            (Self::Bool(l0), Self::Bool(r0)) => l0 == r0,
+            (Self::Any(l0), Self::Any(r0)) => (*l0).cmp_any(*r0),
+            _ => false,
+        }
+    }
+}
+
+impl std::fmt::Debug for AttributeValue<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AttributeValue::Text(s) => write!(f, "AttributeValue::Text({:?})", s),
+            AttributeValue::Float(v) => write!(f, "AttributeValue::Float({:?})", v),
+            AttributeValue::Int(v) => write!(f, "AttributeValue::Int({:?})", v),
+            AttributeValue::Bool(b) => write!(f, "AttributeValue::Bool({:?})", b),
+            AttributeValue::Any(_) => write!(f, "AttributeValue::Any()"),
+        }
+    }
+}
+
+/// A value that can be converted into an attribute value
+pub trait IntoAttributeValue<'a> {
+    /// Convert into an attribute value
+    fn into_value(self, bump: &'a Bump) -> AttributeValue<'a>;
+}
+
+impl<'a> IntoAttributeValue<'a> for &'a str {
+    fn into_value(self, _: &'a Bump) -> AttributeValue<'a> {
+        AttributeValue::Text(self)
+    }
+}
+impl<'a> IntoAttributeValue<'a> for f32 {
+    fn into_value(self, _: &'a Bump) -> AttributeValue<'a> {
+        AttributeValue::Float(self)
+    }
+}
+impl<'a> IntoAttributeValue<'a> for i32 {
+    fn into_value(self, _: &'a Bump) -> AttributeValue<'a> {
+        AttributeValue::Int(self)
+    }
+}
+impl<'a> IntoAttributeValue<'a> for bool {
+    fn into_value(self, _: &'a Bump) -> AttributeValue<'a> {
+        AttributeValue::Bool(self)
+    }
+}
+impl<'a> IntoAttributeValue<'a> for Arguments<'_> {
+    fn into_value(self, bump: &'a Bump) -> AttributeValue<'a> {
+        use bumpalo::core_alloc::fmt::Write;
+        let mut str_buf = bumpalo::collections::String::new_in(bump);
+        str_buf.write_fmt(self).unwrap();
+        AttributeValue::Text(str_buf.into_bump_str())
+    }
+}
+
+// todo
+#[allow(missing_docs)]
+impl<'a> AttributeValue<'a> {
+    pub fn is_truthy(&self) -> bool {
+        match self {
+            AttributeValue::Text(t) => *t == "true",
+            AttributeValue::Bool(t) => *t,
+            _ => false,
+        }
+    }
+
+    pub fn is_falsy(&self) -> bool {
+        match self {
+            AttributeValue::Text(t) => *t == "false",
+            AttributeValue::Bool(t) => !(*t),
+            _ => false,
+        }
+    }
+}
+
+/// A trait that allows for comparing two values of the same type through the Any trait
+///
+/// Defaults to false if the types are not the same
+///
+/// This is an implicit trait, so any value that is 'static and PartialEq can be used directly
+///
+/// If you want to override the default behavior, you should implement PartialEq through a wrapper type
+pub trait AnyAttributeValue: Any {
+    /// Perform a comparison between two values
+    fn cmp_any<'a>(&'a self, _other: &'a dyn AnyAttributeValue) -> bool {
+        false
+    }
+}
+
+impl<T: Any + PartialEq> AnyAttributeValue for T {
+    fn cmp_any(&self, other: &dyn AnyAttributeValue) -> bool {
+        // we can't, for whatever reason use other as &dyn Any
+        let right: &dyn Any = unsafe { std::mem::transmute(other) };
+
+        match right.downcast_ref::<T>() {
+            Some(right) => self == right,
+            None => false,
+        }
+    }
+}
+
+#[test]
+fn cmp_any_works_even_though_it_transmutes() {
+    // same type, same value
+    let a = 2;
+    let b = 2;
+    assert!(a.cmp_any(&b as &dyn AnyAttributeValue));
+
+    // same type, different value
+    let a = "asds";
+    let b = "asdsasd";
+    assert!(!a.cmp_any(&b as &dyn AnyAttributeValue));
+
+    // different type, different values
+    let a = 123;
+    let b = "asdsasd";
+    assert!(!a.cmp_any(&b as &dyn AnyAttributeValue));
+
+    // Custom structs
+    #[derive(PartialEq)]
+    struct CustomStruct {
+        a: i32,
+    }
+
+    let a = CustomStruct { a: 1 };
+    let b = CustomStruct { a: 1 };
+    assert!(a.cmp_any(&b as &dyn AnyAttributeValue));
+
+    let a = CustomStruct { a: 1 };
+    let b = CustomStruct { a: 123 };
+    assert!(!a.cmp_any(&b as &dyn AnyAttributeValue));
+
+    let a = CustomStruct { a: 1 };
+    let b = "asdasd";
+    assert!(!a.cmp_any(&b as &dyn AnyAttributeValue));
+}