unspeaker/tengri
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tengri.git synced 2025-12-06 11:46:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

dsl: use only Dsl trait

Browse source
This commit is contained in:
🪞👃🪞 2025-05-19 00:06:03 +03:00
parent 3bc739328e
commit 90f5699fff
11 changed files with 430 additions and 406 deletions
Download patch file Download diff file Expand all files Collapse all files

98
dsl/src/dsl_provide.rs
View file

@ -1,55 +1,75 @@
use crate::*; use crate::*;
/// Map EDN tokens to parameters of a given type for a given context /// Implement the [Dsl] trait, which boils down to
/// TODO: Replace both [Context] and [TryFromDsl] with this trait /// specifying two types and providing an expression.
/// which returns a [Result]. #[macro_export] macro_rules! dsl {
($T:ty: |$self:ident:$S:ty, $iter:ident|$expr:expr) => {
impl ::tengri::dsl::Dsl<$T> for $S {
fn take <'state, 'source> (
&'state $self, $iter: &mut ::tengri::dsl::TokenIter<'source>,
) -> ::tengri::Perhaps<$T> {
$expr
}
}
}
}
/// Maps a sequencer of EDN tokens to parameters of supported types
/// for a given context.
pub trait Dsl<U>: Sized { pub trait Dsl<U>: Sized {
fn take <'state, 'source> (_: &'state Self, _: &mut TokenIter<'source>) -> Perhaps<U> { fn take <'state, 'source> (
Ok(None) &'state self,
_: &mut TokenIter<'source>
) -> Perhaps<U> {
unimplemented!()
} }
fn take_or_fail <'state, 'source> ( fn take_or_fail <'state, 'source> (
state: &'state Self, iter: &mut TokenIter<'source> &'state self,
token: &mut TokenIter<'source>,
error: impl Into<Box<dyn std::error::Error>>
) -> Usually<U> { ) -> Usually<U> {
if let Some(value) = Self::take(state, iter)? { if let Some(value) = Dsl::<U>::take(self, token)? {
Ok(value) Ok(value)
} else { } else {
Result::Err("not found".into()) // TODO add info and error type Result::Err(error.into())
} }
} }
} }
/// Map EDN tokens to parameters of a given type for a given context //impl<T: Dsl<U>, U> Dsl<U> for &T {
pub trait Context<'state, U>: Sized { //fn take <'state, 'source> (&'state self, iter: &mut TokenIter<'source>) -> Perhaps<U> {
fn get <'source> (&'state self, _iter: &mut TokenIter<'source>) -> Option<U> { //(*self).take(iter)
None //}
} //}
//impl<T: Dsl<U>, U> Dsl<U> for Option<T> {
//fn take <'state, 'source> (&'state self, iter: &mut TokenIter<'source>) -> Perhaps<U> {
//Ok(self.as_ref().map(|s|s.take(iter)).transpose()?.flatten())
//}
//}
impl<'state, X, Y> Dsl<X> for Y where Y: FromDsl<'state, X> {
} }
impl<'state, T: Context<'state, U>, U> Context<'state, U> for &T { //impl<T, U: FromDsl<T>> Dsl<U> for T {
fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<U> { //}
(*self).get(iter)
pub trait FromDsl<'state, T>: Sized {
fn take_from <'source: 'state> (
state: &'state T,
_token: &mut TokenIter<'source>
) -> Perhaps<Self> {
unimplemented!()
}
fn take_from_or_fail <'source: 'state> (
state: &'state T,
token: &mut TokenIter<'source>,
error: impl Into<Box<dyn std::error::Error>>
) -> Usually<Self> {
if let Some(value) = FromDsl::<T>::take_from(state, token)? {
Ok(value)
} else {
Result::Err(error.into())
}
} }
} }
impl<'state, T: Context<'state, U>, U> Context<'state, U> for Option<T> {
fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<U> {
self.as_ref().map(|s|s.get(iter)).flatten()
}
}
pub trait TryFromDsl<'state, T>: Sized {
fn try_from_expr <'source: 'state> (
_state: &'state T, _iter: &mut TokenIter<'source>
) -> Option<Self> {
None
}
fn try_from_atom <'source: 'state> (
state: &'state T, value: Value<'source>
) -> Option<Self> {
if let Exp(0, mut iter) = value {
return Self::try_from_expr(state, &mut iter)
}
None
}
}

100
input/src/input_dsl.rs
View file

@ -1,25 +1,18 @@
use crate::*; use crate::*;
use std::marker::PhantomData; use std::marker::PhantomData;
/// A [Command] that can be constructed from a [Token].
pub trait DslCommand<'state, C>: TryFromDsl<'state, C> + Command<C> {}
impl<'state, C, T: TryFromDsl<'state, C> + Command<C>> DslCommand<'state, C> for T {}
/// [Input] state that can be matched against a [Value]. /// [Input] state that can be matched against a [Value].
pub trait DslInput: Input { pub trait DslInput: Input { fn matches_dsl (&self, token: &str) -> bool; }
fn matches_dsl (&self, token: &str) -> bool;
}
/// A pre-configured mapping of input events to commands. /// A pre-configured mapping of input events to commands.
pub trait KeyMap<'state, S, C: DslCommand<'state, S>, I: DslInput> { pub trait KeyMap<S: Dsl<C>, C: Command<S>, I: DslInput> {
/// Try to find a command that matches the current input event. /// Try to find a command that matches the current input event.
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C>; fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C>;
} }
/// A [SourceIter] can be a [KeyMap]. /// A [SourceIter] can be a [KeyMap].
impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> for SourceIter<'state> { impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceIter<'source> {
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C> { fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
let mut iter = self.clone(); let mut iter = self.clone();
while let Some((token, rest)) = iter.next() { while let Some((token, rest)) = iter.next() {
iter = rest; iter = rest;
@ -29,8 +22,8 @@ impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> f
match exp_iter.next() { match exp_iter.next() {
Some(Token { value: Value::Sym(binding), .. }) => { Some(Token { value: Value::Sym(binding), .. }) => {
if input.matches_dsl(binding) { if input.matches_dsl(binding) {
if let Some(command) = C::try_from_expr(state, &mut exp_iter) { if let Some(command) = Dsl::<C>::take(state, &mut exp_iter)? {
return Some(command) return Ok(Some(command))
} }
} }
}, },
@ -40,13 +33,13 @@ impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> f
_ => panic!("invalid config (expected expression)") _ => panic!("invalid config (expected expression)")
} }
} }
None Ok(None)
} }
} }
/// A [TokenIter] can be a [KeyMap]. /// A [TokenIter] can be a [KeyMap].
impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> for TokenIter<'state> { impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIter<'source> {
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C> { fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
let mut iter = self.clone(); let mut iter = self.clone();
while let Some(next) = iter.next() { while let Some(next) = iter.next() {
match next { match next {
@ -55,8 +48,8 @@ impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> f
match e.next() { match e.next() {
Some(Token { value: Value::Sym(binding), .. }) => { Some(Token { value: Value::Sym(binding), .. }) => {
if input.matches_dsl(binding) { if input.matches_dsl(binding) {
if let Some(command) = C::try_from_expr(state, &mut e) { if let Some(command) = Dsl::<C>::take(state, &mut e)? {
return Some(command) return Ok(Some(command))
} }
} }
}, },
@ -66,44 +59,29 @@ impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> f
_ => panic!("invalid config (expected expression, got: {next:?})") _ => panic!("invalid config (expected expression, got: {next:?})")
} }
} }
None Ok(None)
} }
} }
pub type InputLayerCond<'state, S> = Box<dyn Fn(&S)->bool + Send + Sync + 'state>; pub type InputLayerCond<S> = Box<dyn Fn(&S)->Usually<bool> + Send + Sync>;
/// A collection of pre-configured mappings of input events to commands, /// A collection of pre-configured mappings of input events to commands,
/// which may be made available subject to given conditions. /// which may be made available subject to given conditions.
pub struct InputMap<'state, S, C, I, M> pub struct InputMap<S, C, I, M>
where where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
C: DslCommand<'state, S>, __: PhantomData<(S, C, I)>,
I: DslInput, pub layers: Vec<(InputLayerCond<S>, M)>,
M: KeyMap<'state, S, C, I> + Send + Sync
{
__: &'state PhantomData<(S, C, I)>,
pub layers: Vec<(InputLayerCond<'state, S>, M)>,
} }
impl<'state, S, C, I, M> Default for InputMap<'state, S, C, I, M> impl<S, C, I, M> Default for InputMap<S, C, I, M>
where where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
fn default () -> Self { fn default () -> Self {
Self { Self { __: PhantomData, layers: vec![] }
__: &PhantomData,
layers: vec![]
}
} }
} }
impl<'state, S, C, I, M> InputMap<'state, S, C, I, M> impl<S, C, I, M> InputMap<S, C, I, M>
where where S: Dsl<C> + 'static, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
pub fn new (keymap: M) -> Self { pub fn new (keymap: M) -> Self {
Self::default().layer(keymap) Self::default().layer(keymap)
} }
@ -112,46 +90,38 @@ where
self self
} }
pub fn add_layer (&mut self, keymap: M) -> &mut Self { pub fn add_layer (&mut self, keymap: M) -> &mut Self {
self.add_layer_if(Box::new(|_|true), keymap); self.add_layer_if(Box::new(|_|Ok(true)), keymap);
self self
} }
pub fn layer_if (mut self, condition: InputLayerCond<'state, S>, keymap: M) -> Self { pub fn layer_if (mut self, condition: InputLayerCond<S>, keymap: M) -> Self {
self.add_layer_if(condition, keymap); self.add_layer_if(condition, keymap);
self self
} }
pub fn add_layer_if (&mut self, condition: InputLayerCond<'state, S>, keymap: M) -> &mut Self { pub fn add_layer_if (&mut self, condition: InputLayerCond<S>, keymap: M) -> &mut Self {
self.layers.push((Box::new(condition), keymap)); self.layers.push((Box::new(condition), keymap));
self self
} }
} }
impl<'state, S, C, I, M> std::fmt::Debug for InputMap<'state, S, C, I, M> impl<S, C, I, M> std::fmt::Debug for InputMap<S, C, I, M>
where where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
write!(f, "[InputMap: {} layer(s)]", self.layers.len()) write!(f, "[InputMap: {} layer(s)]", self.layers.len())
} }
} }
/// An [InputMap] can be a [KeyMap]. /// An [InputMap] can be a [KeyMap].
impl<'state, S, C, I, M> KeyMap<'state, S, C, I> for InputMap<'state, S, C, I, M> impl<S, C, I, M> KeyMap<S, C, I> for InputMap<S, C, I, M>
where where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
C: DslCommand<'state, S>, fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C> {
for (condition, keymap) in self.layers.iter() { for (condition, keymap) in self.layers.iter() {
if !condition(state) { if !condition(state)? {
continue continue
} }
if let Some(command) = keymap.command(state, input) { if let Some(command) = keymap.keybind_resolve(state, input)? {
return Some(command) return Ok(Some(command))
} }
} }
None Ok(None)
} }
} }

20
output/src/ops/align.rs
View file

@ -36,20 +36,21 @@ pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
pub struct Align<A>(Alignment, A); pub struct Align<A>(Alignment, A);
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
try_from_expr!(<'source, 'state, E>: Align<RenderBox<'state, E>>: |state, iter|{ impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
FromDsl<'state, T> for Align<RenderBox<'state, E>> {
fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
if let Some(Token { value: Value::Key(key), .. }) = iter.peek() { if let Some(Token { value: Value::Key(key), .. }) = iter.peek() {
match key { match key {
"align/c"|"align/x"|"align/y"| "align/c"|"align/x"|"align/y"|
"align/n"|"align/s"|"align/e"|"align/w"| "align/n"|"align/s"|"align/e"|"align/w"|
"align/nw"|"align/sw"|"align/ne"|"align/se" => { "align/nw"|"align/sw"|"align/ne"|"align/se" => {
let _ = iter.next().unwrap(); let _ = iter.next().unwrap();
let content = iter.next().expect("no content specified"); let content = if let Some(content) = state.get_content(&mut iter.clone())? {
let content = if let Some(content) = state.get_content(&content.value) {
content content
} else { } else {
panic!("no content corresponding to {:?}", &content); panic!("no content corresponding to {:?}", &iter);
}; };
return Some(match key { return Ok(Some(match key {
"align/c" => Self::c(content), "align/c" => Self::c(content),
"align/x" => Self::x(content), "align/x" => Self::x(content),
"align/y" => Self::y(content), "align/y" => Self::y(content),
@ -62,12 +63,15 @@ try_from_expr!(<'source, 'state, E>: Align<RenderBox<'state, E>>: |state, iter|{
"align/sw" => Self::sw(content), "align/sw" => Self::sw(content),
"align/se" => Self::se(content), "align/se" => Self::se(content),
_ => unreachable!() _ => unreachable!()
}) }))
}, },
_ => return None _ => return Ok(None)
}
} else {
Ok(None)
} }
} }
}); }
impl<A> Align<A> { impl<A> Align<A> {
#[inline] pub const fn c (a: A) -> Self { Self(Alignment::Center, a) } #[inline] pub const fn c (a: A) -> Self { Self(Alignment::Center, a) }

52
output/src/ops/bsp.rs
View file

@ -21,30 +21,40 @@ impl<E: Output, A: Content<E>, B: Content<E>> Content<E> for Bsp<A, B> {
} }
} }
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
try_from_expr!(<'source, 'state, E>: Bsp<RenderBox<'state, E>, RenderBox<'state, E>>: |state, iter| { impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
if let Some(Token { value: Value::Key(key), .. }) = iter.peek() { FromDsl<'state, T> for Bsp<RenderBox<'state, E>, RenderBox<'state, E>> {
match key { fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
"bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b" => { Ok(if let Some(Token {
let original = iter.clone(); value: Value::Key("bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b"),
let _ = iter.next().unwrap(); ..
let c1 = iter.next().unwrap_or_else(||panic!("no content1 specified: {original:?}")); }) = iter.peek() {
let c2 = iter.next().unwrap_or_else(||panic!("no content2 specified: {original:?}")); let base = iter.clone();
let c1 = state.get_content(&c1.value).expect("no content1 provided"); return Ok(Some(match iter.next() {
let c2 = state.get_content(&c2.value).expect("no content2 provided"); Some(Token { value: Value::Key("bsp/n"), .. }) =>
return Some(match key { Self::n(state.get_content_or_fail(iter)?,
"bsp/n" => Self::n(c1, c2), state.get_content_or_fail(iter)?),
"bsp/s" => Self::s(c1, c2), Some(Token { value: Value::Key("bsp/s"), .. }) =>
"bsp/e" => Self::e(c1, c2), Self::s(state.get_content_or_fail(iter)?,
"bsp/w" => Self::w(c1, c2), state.get_content_or_fail(iter)?),
"bsp/a" => Self::a(c1, c2), Some(Token { value: Value::Key("bsp/e"), .. }) =>
"bsp/b" => Self::b(c1, c2), Self::e(state.get_content_or_fail(iter)?,
state.get_content_or_fail(iter)?),
Some(Token { value: Value::Key("bsp/w"), .. }) =>
Self::w(state.get_content_or_fail(iter)?,
state.get_content_or_fail(iter)?),
Some(Token { value: Value::Key("bsp/a"), .. }) =>
Self::a(state.get_content_or_fail(iter)?,
state.get_content_or_fail(iter)?),
Some(Token { value: Value::Key("bsp/b"), .. }) =>
Self::b(state.get_content_or_fail(iter)?,
state.get_content_or_fail(iter)?),
_ => unreachable!(), _ => unreachable!(),
}))
} else {
None
}) })
},
_ => return None
} }
} }
});
impl<A, B> Bsp<A, B> { impl<A, B> Bsp<A, B> {
#[inline] pub const fn n (a: A, b: B) -> Self { Self(North, a, b) } #[inline] pub const fn n (a: A, b: B) -> Self { Self(North, a, b) }
#[inline] pub const fn s (a: A, b: B) -> Self { Self(South, a, b) } #[inline] pub const fn s (a: A, b: B) -> Self { Self(South, a, b) }

48
output/src/ops/cond.rs
View file

@ -19,35 +19,41 @@ impl<A, B> Either<A, B> {
} }
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
try_from_expr!(<'source, 'state, E>: When<RenderBox<'state, E>>: |state, iter| { impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
if let Some(Token { value: Value::Key("when"), .. }) = iter.peek() { FromDsl<'state, T> for When<RenderBox<'state, E>> {
let _ = iter.next().unwrap(); fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
let content = iter.next().expect("no content specified").value; Ok(if let Some(Token {
return Some(Self( value: Value::Key("when"),
state.get(&mut iter) ..
.unwrap_or_else(||panic!("cond: no condition: {iter:?}")), }) = iter.peek() {
state.get_content(&content) let base = iter.clone();
.unwrap_or_else(||panic!("cond: no content for {:?}: {iter:?}", &content)) return Ok(Some(Self(
)) state.take(iter)?.unwrap_or_else(||panic!("cond: no condition: {base:?}")),
state.get_content_or_fail(iter)?
)))
} else {
None
})
} }
}); }
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
try_from_expr!(<'source, 'state, E>: Either<RenderBox<'state, E>, RenderBox<'state, E>>: |state, iter| { impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
FromDsl<'state, T> for Either<RenderBox<'state, E>, RenderBox<'state, E>> {
fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
if let Some(Token { value: Value::Key("either"), .. }) = iter.peek() { if let Some(Token { value: Value::Key("either"), .. }) = iter.peek() {
let base = iter.clone(); let base = iter.clone();
let _ = iter.next().unwrap(); let _ = iter.next().unwrap();
//panic!("{iter:?}"); //panic!("{iter:?}");
return Some(Self( return Ok(Some(Self(
state.get(&mut iter) state.take(iter)?.unwrap_or_else(||panic!("either: no condition: {base:?}")),
.unwrap_or_else(||panic!("either: no condition: {base:?}")), state.get_content_or_fail(iter)?,
state.get_content(&iter.next().expect("no content specified").value) state.get_content_or_fail(iter)?,
.unwrap_or_else(||panic!("either: no content 1: {base:?}")), )))
state.get_content(&iter.next().expect("no alternate specified").value)
.unwrap_or_else(||panic!("either: no content 2: {base:?}")),
))
} }
}); Ok(None)
}
}
impl<E: Output, A: Render<E>> Content<E> for When<A> { impl<E: Output, A: Render<E>> Content<E> for When<A> {
fn layout (&self, to: E::Area) -> E::Area { fn layout (&self, to: E::Area) -> E::Area {

77
output/src/ops/transform.rs
View file

@ -39,30 +39,22 @@ macro_rules! transform_xy {
} }
} }
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
impl<'state, E: Output + 'state, T: ViewContext<'state, E>> TryFromDsl<'state, T> impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
for $Enum<RenderBox<'state, E>> { FromDsl<'state, T> for $Enum<RenderBox<'state, E>> {
fn try_from_expr <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
-> Option<Self>
{
let mut iter = iter.clone();
if let Some(Token { value: Value::Key(k), .. }) = iter.peek() { if let Some(Token { value: Value::Key(k), .. }) = iter.peek() {
if k == $x || k == $y || k == $xy { let mut base = iter.clone();
let _ = iter.next().unwrap(); return Ok(Some(match iter.next() {
let token = iter.next().expect("no content specified"); Some(Token{value:Value::Key($x),..}) =>
let content = if let Some(content) = state.get_content(&token.value) { Self::x(state.get_content_or_fail(iter)?),
content Some(Token{value:Value::Key($y),..}) =>
} else { Self::y(state.get_content_or_fail(iter)?),
panic!("no content corresponding to {:?}", &token.value); Some(Token{value:Value::Key($xy),..}) =>
}; Self::xy(state.get_content_or_fail(iter)?),
return Some(match k {
$x => Self::x(content),
$y => Self::y(content),
$xy => Self::xy(content),
_ => unreachable!() _ => unreachable!()
}) }))
} }
} Ok(None)
None
} }
} }
impl<E: Output, T: Content<E>> Content<E> for $Enum<T> { impl<E: Output, T: Content<E>> Content<E> for $Enum<T> {
@ -92,31 +84,30 @@ macro_rules! transform_xy_unit {
#[inline] pub const fn xy (x: U, y: U, item: T) -> Self { Self::XY(x, y, item) } #[inline] pub const fn xy (x: U, y: U, item: T) -> Self { Self::XY(x, y, item) }
} }
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
impl<'state, E: Output + 'state, T: ViewContext<'state, E>> TryFromDsl<'state, T> impl<'state, E: Output + 'state, T: ViewContext<'state, E>>
for $Enum<E::Unit, RenderBox<'state, E>> { FromDsl<'state, T> for $Enum<E::Unit, RenderBox<'state, E>> {
fn try_from_expr <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Option<Self> { fn take_from <'source: 'state> (state: &'state T, iter: &mut TokenIter<'source>) -> Perhaps<Self> {
let mut iter = iter.clone(); Ok(if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = iter.peek() {
if let Some(Token { value: Value::Key(k), .. }) = iter.peek() { let mut base = iter.clone();
if k == $x || k == $y { Some(match iter.next() {
let _ = iter.next().unwrap(); Some(Token { value: Value::Key($x), .. }) => Self::x(
let u = state.get(&mut iter).expect("no unit specified"); state.take_or_fail(iter, "no unit specified")?,
let c = state.get_content(&iter.next().expect("no content specified").value) state.get_content_or_fail(iter)?,
.expect("no content provided"); ),
return Some(match k { Some(Token { value: Value::Key($y), .. }) => Self::y(
$x => Self::x(u, c), state.take_or_fail(iter, "no unit specified")?,
$y => Self::y(u, c), state.get_content_or_fail(iter)?,
),
Some(Token { value: Value::Key($x), .. }) => Self::xy(
state.take_or_fail(iter, "no unit specified")?,
state.take_or_fail(iter, "no unit specified")?,
state.get_content_or_fail(iter)?
),
_ => unreachable!(), _ => unreachable!(),
}) })
} else if k == $xy { } else {
let _ = iter.next().unwrap();
let u = state.get(&mut iter).expect("no unit specified");
let v = state.get(&mut iter).expect("no unit specified");
let c = state.get_content(&iter.next().expect("no content specified").value)
.expect("no content provided");
return Some(Self::xy(u, v, c))
}
}
None None
})
} }
} }
impl<E: Output, T: Content<E>> Content<E> for $Enum<E::Unit, T> { impl<E: Output, T: Content<E>> Content<E> for $Enum<E::Unit, T> {

116
output/src/view.rs
View file

@ -8,15 +8,15 @@ use crate::*;
fn content (&$self) -> impl Render<$Output> { $expr } fn content (&$self) -> impl Render<$Output> { $expr }
} }
impl<'a> ViewContext<'a, $Output> for $State { impl<'a> ViewContext<'a, $Output> for $State {
fn get_content_sym (&'a $self, value: &Value<'a>) -> Option<RenderBox<'a, $Output>> { fn get_content_sym (&'a $self, iter: &Value<'a>) -> Perhaps<RenderBox<'a, $Output>> {
if let Value::Sym(s) = value { Ok(if let Value::Sym(s) = value {
match *s { match *s {
$($sym => Some($body.boxed()),)* $($sym => Some($body.boxed()),)*
_ => None _ => None
} }
} else { } else {
panic!("expected content, got: {value:?}") return Err(format!("expected content, got: {iter:?}").into())
} })
} }
} }
} }
@ -34,9 +34,11 @@ pub struct View<'a, T>(
impl<'a, O: Output + 'a, T: ViewContext<'a, O>> Content<O> for View<'a, T> { impl<'a, O: Output + 'a, T: ViewContext<'a, O>> Content<O> for View<'a, T> {
fn content (&self) -> impl Render<O> { fn content (&self) -> impl Render<O> {
let mut iter = self.1.clone(); let mut iter = self.1.clone();
while let Some(Token { value, .. }) = iter.next() { while let Some(Token { value, .. }) = iter.peek() {
if let Some(content) = self.0.get_content(&value) { if let Ok(Some(content)) = self.0.get_content(&mut iter) {
return Some(content) return Some(content)
// TODO handle errors here, how?
// error receiver trait in viewcontext?
} }
} }
return None return None
@ -46,69 +48,61 @@ impl<'a, O: Output + 'a, T: ViewContext<'a, O>> Content<O> for View<'a, T> {
// Provides components to the view. // Provides components to the view.
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
pub trait ViewContext<'state, E: Output + 'state>: Send + Sync pub trait ViewContext<'state, E: Output + 'state>: Send + Sync
+ Context<'state, bool> + Dsl<bool>
+ Context<'state, usize> + Dsl<usize>
+ Context<'state, E::Unit> + Dsl<E::Unit>
{ {
fn get_content <'source: 'state> (&'state self, value: &Value<'source>) -> Option<RenderBox<'state, E>> { fn get_content_or_fail <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
match value { -> Usually<RenderBox<'state, E>>
Value::Sym(_) => self.get_content_sym(value),
Value::Exp(_, _) => self.get_content_exp(value),
_ => panic!("only :symbols and (expressions) accepted here, got: {value:?}")
}
}
fn get_content_sym <'source: 'state> (&'state self, value: &Value<'source>)
-> Option<RenderBox<'state, E>>;
fn get_content_exp <'source: 'state> (&'state self, value: &Value<'source>)
-> Option<RenderBox<'state, E>>
{ {
try_delegate!(self, *value, When::<RenderBox<'state, E>>); let base = iter.clone();
try_delegate!(self, *value, Either::<RenderBox<'state, E>, RenderBox<'state, E>>); if let Some(content) = self.get_content(iter)? {
try_delegate!(self, *value, Align::<RenderBox<'state, E>>); Ok(content)
try_delegate!(self, *value, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>); } else {
try_delegate!(self, *value, Fill::<RenderBox<'state, E>>); Err(format!("not found: {iter:?}").into())
try_delegate!(self, *value, Fixed::<_, RenderBox<'state, E>>); }
try_delegate!(self, *value, Min::<_, RenderBox<'state, E>>); }
try_delegate!(self, *value, Max::<_, RenderBox<'state, E>>); fn get_content <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
try_delegate!(self, *value, Shrink::<_, RenderBox<'state, E>>); -> Perhaps<RenderBox<'state, E>>
try_delegate!(self, *value, Expand::<_, RenderBox<'state, E>>); {
try_delegate!(self, *value, Push::<_, RenderBox<'state, E>>); match iter.peek() {
try_delegate!(self, *value, Pull::<_, RenderBox<'state, E>>); Some(Token { value: Value::Sym(_), .. }) =>
try_delegate!(self, *value, Margin::<_, RenderBox<'state, E>>); self.get_content_sym(iter),
try_delegate!(self, *value, Padding::<_, RenderBox<'state, E>>); Some(Token { value: Value::Exp(_, _), .. }) =>
None self.get_content_exp(iter),
None => Ok(None),
_ => panic!("only :symbols and (expressions) accepted here")
}
}
fn get_content_sym <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-> Perhaps<RenderBox<'state, E>>;
fn get_content_exp <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-> Perhaps<RenderBox<'state, E>>
{
try_delegate!(self, iter, When::<RenderBox<'state, E>>);
try_delegate!(self, iter, Either::<RenderBox<'state, E>, RenderBox<'state, E>>);
try_delegate!(self, iter, Align::<RenderBox<'state, E>>);
try_delegate!(self, iter, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>);
try_delegate!(self, iter, Fill::<RenderBox<'state, E>>);
try_delegate!(self, iter, Fixed::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Min::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Max::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Shrink::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Expand::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Push::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Pull::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Margin::<_, RenderBox<'state, E>>);
try_delegate!(self, iter, Padding::<_, RenderBox<'state, E>>);
Ok(None)
} }
} }
#[cfg(feature = "dsl")] #[cfg(feature = "dsl")]
#[macro_export] macro_rules! try_delegate { #[macro_export] macro_rules! try_delegate {
($s:ident, $dsl:expr, $T:ty) => { ($s:ident, $dsl:expr, $T:ty) => {
if let Some(value) = <$T>::try_from_atom($s, $dsl) { let value: Option<$T> = FromDsl::take_from($s, $dsl)?;
return Some(value.boxed()) if let Some(value) = value {
} return Ok(Some(value.boxed()))
}
}
#[cfg(feature = "dsl")]
#[macro_export] macro_rules! try_from_expr {
(<
$lt_source:lifetime,
$lt_state:lifetime,
$Output:ident
>: $Struct:ty: |$state:ident, $iter:ident|$body:expr) => {
impl<
$lt_state,
$Output: Output + $lt_state,
T: ViewContext<$lt_state, $Output>
> TryFromDsl<$lt_state, T> for $Struct {
fn try_from_expr <$lt_source: $lt_state> (
$state: &$lt_state T,
$iter: &mut TokenIter<$lt_source>
) -> Option<Self> {
let mut $iter = $iter.clone();
$body;
None
}
} }
} }
} }

183
proc/src/proc_command.rs
View file

@ -52,49 +52,111 @@ impl CommandImpl {
impl ToTokens for CommandDef { impl ToTokens for CommandDef {
fn to_tokens (&self, out: &mut TokenStream2) { fn to_tokens (&self, out: &mut TokenStream2) {
let Self(CommandMeta(target), CommandImpl(block, exposed)) = self; let Self(CommandMeta(state), CommandImpl(block, exposed)) = self;
let enumeration = &block.self_ty;
let variants = exposed.values().map(|x|x.to_enum_variant_def()); let command_enum = &block.self_ty;
let matchers = exposed.values().map(CommandArm::to_matcher);
let implementations = exposed.values().map(CommandArm::to_implementation); let variants = exposed.values().map(|arm|{
let mut out = TokenStream2::new();
out.append(arm.to_enum_variant_ident());
//let ident = &arm.0;
if arm.has_args() {
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
for (arg, ty) in arm.args() {
write_quote_to(&mut out, quote! { #arg : #ty , });
}
out
}));
}
out.append(Punct::new(',', Alone));
out
});
let matchers = exposed.values().map(|arm|{
let key = LitStr::new(&arm.to_key(), Span::call_site());
let variant = {
let mut out = TokenStream2::new();
out.append(arm.to_enum_variant_ident());
let ident = &arm.0;
if arm.has_args() {
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
for (arg, ty) in arm.args() {
write_quote_to(&mut out, quote! {
#arg: Dsl::take_or_fail(self, words)?,
});
}
out
}));
}
out
};
write_quote(quote! {
Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Key(#key), .. }) => {
let mut words = words.clone();
Some(#command_enum::#variant)
},
//Some(::tengri::dsl::Token {
//value: ::tengri::dsl::Value::Key(#key), ..
//}) => {
//let mut iter = iter.clone(); Some(#command_enum::#variant)
//},
})
});
let implementations = exposed.values().map(|arm|{
let ident = &arm.0;
let variant = {
let mut out = TokenStream2::new();
out.append(arm.to_enum_variant_ident());
//let ident = &arm.0;
if arm.has_args() {
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
for (arg, _ty) in arm.args() {
write_quote_to(&mut out, quote! { #arg , });
}
out
}));
}
out
};
let give_rest = write_quote(quote! { /*TODO*/ });
let give_args = arm.args()
.map(|(arg, _ty)|write_quote(quote! { #arg, }))
.collect::<Vec<_>>();
write_quote(quote! {
#command_enum::#variant =>
#command_enum::#ident(state, #(#give_args)* #give_rest),
})
});
write_quote_to(out, quote! { write_quote_to(out, quote! {
/// Generated by [tengri_proc]. /// Generated by [tengri_proc].
#[derive(Clone, Debug)] #[derive(Clone, Debug)] pub enum #command_enum { #(#variants)* }
pub enum #enumeration { /// Not generated by [tengri_proc].
#(#variants)*
}
#block #block
/// Generated by [tengri_proc]. /// Generated by [tengri_proc].
impl<'state> ::tengri::dsl::TryFromDsl<'state, #target> for #enumeration { impl ::tengri::input::Command<#state> for #command_enum {
fn try_from_expr <'source: 'state> ( fn execute (self, state: &mut #state) -> Perhaps<Self> {
state: &'state #target, iter: &mut ::tengri::dsl::TokenIter<'source> match self { #(#implementations)* }
) -> Option<Self> {
let mut iter = iter.clone();
let token = iter.next();
match token {
#(#matchers)*
_ => None
}
} }
} }
/// Generated by [tengri_proc]. /// Generated by [tengri_proc].
impl<'state> ::tengri::dsl::Context<'state, #enumeration> for #target { impl ::tengri::dsl::Dsl<#command_enum> for #state {
fn get <'source> (&self, iter: &mut ::tengri::dsl::TokenIter<'source>) fn take <'source, 'state> (
-> Option<#enumeration> &'state self, words: &mut TokenIter<'source>
)
-> ::tengri::Perhaps<#command_enum>
{ {
use ::tengri::dsl::TryFromDsl; let mut words = words.clone();
#enumeration::try_from_expr(self, iter) let token = words.next();
} todo!()//Ok(match token { #(#matchers)* _ => None })
}
/// Generated by [tengri_proc].
impl ::tengri::input::Command<#target> for #enumeration {
fn execute (self, state: &mut #target) -> Perhaps<Self> {
match self {
#(#implementations)*
}
} }
} }
}); });
//if exposed.len() > 0 { //if exposed.len() > 0 {
//panic!("{:#?}", block.self_ty); //panic!("{:#?}", block.self_ty);
//if let Type::Path(ref path) = *block.self_ty { //if let Type::Path(ref path) = *block.self_ty {
@ -146,61 +208,4 @@ impl CommandArm {
out.append(Punct::new(',', Alone)); out.append(Punct::new(',', Alone));
out out
} }
fn to_enum_variant_bind (&self) -> TokenStream2 {
let mut out = TokenStream2::new();
out.append(self.to_enum_variant_ident());
let ident = &self.0;
if self.has_args() {
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
for (arg, ty) in self.args() {
//let take_err = LitStr::new(&format!("{}: missing argument \"{}\" ({})",
//quote!{#ident}, quote!{#arg}, quote!{#ty}), Span::call_site());
let give_err = format!("{}: missing value for \"{}\" ({}): {{:#?}}",
quote!{#ident}, quote!{#arg}, quote!{#ty});
let give_err = LitStr::new(&give_err, Span::call_site());
write_quote_to(&mut out, quote! {
#arg: ::tengri::dsl::Context::get(state, &mut iter)
.unwrap_or_else(||panic!(#give_err, token)),
});
}
out
}));
}
out
}
fn to_enum_variant_unbind (&self) -> TokenStream2 {
let mut out = TokenStream2::new();
out.append(self.to_enum_variant_ident());
//let ident = &self.0;
if self.has_args() {
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
for (arg, _ty) in self.args() {
write_quote_to(&mut out, quote! { #arg , });
}
out
}));
}
out
}
fn to_matcher (&self) -> TokenStream2 {
let key = LitStr::new(&self.to_key(), Span::call_site());
let variant = self.to_enum_variant_bind();
let pattern = quote! {
Some(::tengri::dsl::Token { value: ::tengri::dsl::Value::Key(#key), .. })
};
write_quote(quote! {
#pattern => { let mut iter = iter.clone(); Some(Self::#variant) },
})
}
fn to_implementation (&self) -> TokenStream2 {
let ident = &self.0;
let variant = self.to_enum_variant_unbind();
let give_rest = write_quote(quote! { /*TODO*/ });
let give_args = self.args()
.map(|(arg, _ty)|write_quote(quote! { #arg, }))
.collect::<Vec<_>>();
write_quote(quote! { Self::#variant => Self::#ident(state, #(#give_args)* #give_rest), })
}
} }

14
proc/src/proc_expose.rs
View file

@ -85,15 +85,15 @@ impl ToTokens for ExposeImpl {
let values = variants.iter().map(ExposeArm::from); let values = variants.iter().map(ExposeArm::from);
write_quote_to(out, quote! { write_quote_to(out, quote! {
/// Generated by [tengri_proc]. /// Generated by [tengri_proc].
impl<'state> ::tengri::dsl::Context<'state, #t> for #target { impl ::tengri::dsl::Dsl<#t> for #target {
fn get <'source> ( fn take <'state, 'source> (
&self, iter: &mut ::tengri::dsl::TokenIter<'source> &'state self, iter: &mut ::tengri::dsl::TokenIter<'source>
) -> Option<#t> { ) -> Perhaps<#t> {
Some(match iter.next().map(|x|x.value) { Ok(Some(match iter.next().map(|x|x.value) {
#predefined #predefined
#(#values,)* #(#values,)*
_ => return None _ => return Ok(None)
}) }))
} }
} }
}); });

32
proc/src/proc_view.rs
View file

@ -52,7 +52,7 @@ impl ToTokens for ViewDef {
}).collect(); }).collect();
let available: String = available.join(", "); let available: String = available.join(", ");
let error_msg = LitStr::new( let error_msg = LitStr::new(
&format!("expected Sym(content), got: {{value:?}}, available: {available}"), &format!("expected Sym(content), got: {{iter:?}}, available: {available}"),
Span::call_site() Span::call_site()
); );
for token in quote! { for token in quote! {
@ -60,15 +60,16 @@ impl ToTokens for ViewDef {
/// Generated by [tengri_proc]. /// Generated by [tengri_proc].
impl ::tengri::output::Content<#output> for #ident { impl ::tengri::output::Content<#output> for #ident {
fn content (&self) -> impl Render<#output> { fn content (&self) -> impl Render<#output> {
// TODO move to self.view()
self.size.of(::tengri::output::View(self, self.config.view)) self.size.of(::tengri::output::View(self, self.config.view))
} }
} }
/// Generated by [tengri_proc]. /// Generated by [tengri_proc].
impl<'state> ::tengri::output::ViewContext<'state, #output> for #ident { impl<'state> ::tengri::output::ViewContext<'state, #output> for #ident {
fn get_content_sym <'source: 'state> (&'state self, value: &Value<'source>) fn get_content_sym <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-> Option<RenderBox<'state, #output>> -> ::tengri::Perhaps<RenderBox<'state, #output>>
{ {
match value { #(#exposed)* _ => panic!(#error_msg) } Ok(match iter.peek() { #(#exposed)* _ => panic!(#error_msg) })
} }
} }
} { } {
@ -80,6 +81,22 @@ impl ToTokens for ViewDef {
impl ToTokens for ViewArm { impl ToTokens for ViewArm {
fn to_tokens (&self, out: &mut TokenStream2) { fn to_tokens (&self, out: &mut TokenStream2) {
let Self(key, value) = self; let Self(key, value) = self;
out.append(Ident::new("Some", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, {
let mut out = TokenStream2::new();
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("tengri", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("dsl", Span::call_site()));
out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone));
out.append(Ident::new("Token", Span::call_site()));
out.append(Group::new(Delimiter::Brace, {
let mut out = TokenStream2::new();
out.append(Ident::new("value", Span::call_site()));
out.append(Punct::new(':', Alone));
out.append(Punct::new(':', Joint)); out.append(Punct::new(':', Joint));
out.append(Punct::new(':', Alone)); out.append(Punct::new(':', Alone));
out.append(Ident::new("tengri", Span::call_site())); out.append(Ident::new("tengri", Span::call_site()));
@ -97,6 +114,13 @@ impl ToTokens for ViewArm {
out.append(LitStr::new(key, Span::call_site()).token()); out.append(LitStr::new(key, Span::call_site()).token());
out out
})); }));
out.append(Punct::new(',', Alone));
out.append(Punct::new('.', Joint));
out.append(Punct::new('.', Alone));
out
}));
out
}));
out.append(Punct::new('=', Joint)); out.append(Punct::new('=', Joint));
out.append(Punct::new('>', Alone)); out.append(Punct::new('>', Alone));
out.append(Ident::new("Some", Span::call_site())); out.append(Ident::new("Some", Span::call_site()));

16
tengri/src/lib.rs
View file

@ -7,7 +7,7 @@ pub use ::tengri_core::*;
#[cfg(test)] extern crate tengri_proc; #[cfg(test)] extern crate tengri_proc;
#[cfg(test)] #[test] fn test_subcommand () -> Usually<()> { #[cfg(test)] #[test] fn test_subcommand () -> Usually<()> {
use crate::input::{Command, InputMap, KeyMap, Handle, handle}; use crate::input::{Command, InputMap, KeyMap, Handle, handle};
use crate::dsl::{TryFromDsl, TokenIter}; use crate::dsl::TokenIter;
use crate::tui::TuiIn; use crate::tui::TuiIn;
use crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState}; use crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState};
//use crate::input::*; //use crate::input::*;
@ -82,7 +82,7 @@ pub use ::tengri_core::*;
//FIXME: //FIXME:
//#[cfg(test)] #[test] fn test_dsl_context () { //#[cfg(test)] #[test] fn test_dsl_context () {
//use crate::dsl::{Context, Value}; //use crate::dsl::{Dsl, Value};
//struct Test; //struct Test;
//#[tengri_proc::expose] //#[tengri_proc::expose]
@ -91,10 +91,10 @@ pub use ::tengri_core::*;
//true //true
//} //}
//} //}
//assert_eq!(Context::get(&Test, &Value::Sym(":false")), Some(false)); //assert_eq!(Dsl::get(&Test, &Value::Sym(":false")), Some(false));
//assert_eq!(Context::get(&Test, &Value::Sym(":true")), Some(true)); //assert_eq!(Dsl::get(&Test, &Value::Sym(":true")), Some(true));
//assert_eq!(Context::get(&Test, &Value::Sym(":some-bool")), Some(true)); //assert_eq!(Dsl::get(&Test, &Value::Sym(":some-bool")), Some(true));
//assert_eq!(Context::get(&Test, &Value::Sym(":missing-bool")), None); //assert_eq!(Dsl::get(&Test, &Value::Sym(":missing-bool")), None);
//assert_eq!(Context::get(&Test, &Value::Num(0)), Some(false)); //assert_eq!(Dsl::get(&Test, &Value::Num(0)), Some(false));
//assert_eq!(Context::get(&Test, &Value::Num(1)), Some(true)); //assert_eq!(Dsl::get(&Test, &Value::Num(1)), Some(true));
//} //}