wip: EdnItem -> Atom, rewrite tokenizer

output/src/view.rs

@@ -0,0 +1,164 @@
+use crate::*;
+use std::{sync::Arc, marker::PhantomData};
+use Atom::*;
+/// Define an EDN-backed view.
+///
+/// This consists of:
+/// * render callback (implementation of [Content])
+/// * value providers (implementations of [EdnProvide])
+#[macro_export] macro_rules! edn_view {
+    ($Output:ty: |$self:ident: $App:ty| $content:expr; {
+        $( $type:ty { $($sym:literal => $value:expr),* } );*
+    }) => {
+        impl Content<$Output> for $App {
+            fn content(&$self) -> impl Render<$Output> { $content }
+        }
+        $(
+            impl<'a> EdnProvide<'a, $type> for $App {
+                fn get (&'a $self, edn: &'a Atom<impl AsRef<str>>) -> Option<$type> {
+                    Some(match edn.to_ref() { $(Atom::Sym($sym) => $value,)* _ => return None })
+                }
+            }
+        )*
+    }
+}
+/// Implements `EdnProvide` for content components and expressions
+#[macro_export] macro_rules! edn_provide_content {
+    (|$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<'a, E: Output> EdnProvide<'a, Box<dyn Render<E> + 'a>> for $State {
+            fn get (&'a $self, edn: &'a Atom<impl AsRef<str>>) -> Option<Box<dyn Render<E> + 'a>> {
+                Some(match edn.to_ref() {
+                    $(Atom::Sym($pat) => $expr),*,
+                    _ => return None
+                })
+            }
+        }
+    };
+    ($Output:ty: |$self:ident:$State:ty|{ $($pat:pat => $expr:expr),* $(,)? }) => {
+        impl<'a> EdnProvide<'a, Box<dyn Render<$Output> + 'a>> for $State {
+            fn get (&'a $self, edn: &'a Atom<impl AsRef<str>>) -> Option<Box<dyn Render<$Output> + 'a>> {
+                Some(match edn.to_ref() {
+                    $(Atom::Sym($pat) => $expr),*,
+                    _ => return None
+                })
+            }
+        }
+    }
+}
+/// Renders from EDN source and context.
+#[derive(Default)] pub enum EdnView<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> {
+    #[default] Inert,
+    Ok(T, Atom<Arc<str>>),
+    //render: Box<dyn Fn(&'a T)->Box<dyn Render<E> + Send + Sync + 'a> + Send + Sync + 'a>
+    Err(String),
+    _Unused(PhantomData<&'a E>),
+}
+impl<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> std::fmt::Debug for EdnView<'a, E, T> {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            Self::Inert | Self::_Unused(_) =>
+                write!(f, "EdnView::Inert"),
+            Self::Ok(state, view) =>
+                write!(f, "EdnView::Ok(state={state:?} view={view:?}"),
+            Self::Err(error) =>
+                write!(f, "EdnView::Err({error})"),
+            _ => unreachable!()
+        }
+    }
+}
+impl<'a, E: Output, T> EdnViewData<'a, E> for T where T:
+    EdnProvide<'a, bool> +
+    EdnProvide<'a, usize> +
+    EdnProvide<'a, E::Unit> +
+    EdnProvide<'a, Box<dyn Render<E> + 'a>>
+{}
+impl<'a, E: Output, T: EdnViewData<'a, E> + std::fmt::Debug> EdnView<'a, E, T> {
+    pub fn from_source (state: T, source: &'a str) -> Self {
+        match Atom::read_one(&source) {
+            Ok((layout, _)) => Self::Ok(state, layout),
+            Err(error) => Self::Err(format!("{error} in {source}"))
+        }
+    }
+    pub fn from_items (state: T, items: Vec<Atom<impl AsRef<str>>>) -> Self {
+        Self::Ok(state, Atom::Exp(items).to_arc())
+    }
+}
+impl<E: Output, T: for<'a>EdnViewData<'a, E> + Send + Sync + std::fmt::Debug> Content<E> for EdnView<'_, E, T> {
+    fn content (&self) -> impl Render<E> {
+        match self {
+            Self::Ok(state, layout) => state.get_content(layout),
+            Self::Err(_error) => {
+                panic!("{self:?}");
+                //TODO:&format!("EdnView error: {error:?}")) // FIXME: String is not Render
+            },
+            _ => todo!()
+        }
+    }
+}
+
+macro_rules! edn_try_delegate {
+    ($s:ident, $e:expr, $T:ty) => {
+        if let [head, tail @ ..] = $e.as_slice() {
+            if let Some(content) = <$T>::try_from_edn($s, head, tail) {
+                return Some(content.boxed())
+            }
+        }
+    }
+}
+
+/// Provides values to the template
+pub trait EdnViewData<'a, E: Output>:
+    EdnProvide<'a, bool> +
+    EdnProvide<'a, usize> +
+    EdnProvide<'a, E::Unit> +
+    EdnProvide<'a, Box<dyn Render<E> + 'a>>
+{
+    fn get_bool (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<bool> {
+        Some(match &item {
+            Sym(s) => match s.as_ref() {
+                ":false" | ":f" => false,
+                ":true"  | ":t" => true,
+                _ => return EdnProvide::get(self, item)
+            },
+            Num(0) => false,
+            Num(_) => true,
+            _ => return EdnProvide::get(self, item)
+        })
+    }
+    fn get_usize (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<usize> {
+        Some(match &item { Num(n) => *n, _ => return EdnProvide::get(self, item) })
+    }
+    fn get_unit (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<E::Unit> {
+        Some(match &item { Num(n) => (*n as u16).into(), _ => return EdnProvide::get(self, item) })
+    }
+    fn get_content (&'a self, item: &'a Atom<impl AsRef<str>>) -> Option<Box<dyn Render<E> + 'a>> where E: 'a {
+        Some(match item {
+            Nil => Box::new(()),
+            Exp(ref e) => {
+                edn_try_delegate!(self, e, When::<_, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Either::<_, RenderBox<'a, E>, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Align::<_, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Bsp::<_, RenderBox<'a, E>, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Fill::<_, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Fixed::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Min::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Max::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Shrink::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Expand::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Push::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Pull::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Margin::<_, _, RenderBox<'a, E>>);
+                edn_try_delegate!(self, e, Padding::<_, _, RenderBox<'a, E>>);
+                EdnProvide::get_or_fail(self, &item)
+            },
+            _ => EdnProvide::get_or_fail(self, &item)
+        })
+        //panic!("no content")
+    }
+}
+// A function that returns a `RenderBox.
+pub type EdnCallback<'a, O, State> =
+    dyn Fn(&'a State)-> RenderBox<'a, O> + Send + Sync + 'a;
+// A box containing a function that returns a `RenderBox.
+pub type EdnRenderCallback<'a, O, State> =
+    Box<EdnCallback<'a, O, State>>;