unspeaker/tengri
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tengri.git synced 2025-12-06 19:56:44 +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

92
dsl/src/dsl_provide.rs
View file

@ -1,55 +1,75 @@
use crate::*;
/// Map EDN tokens to parameters of a given type for a given context
/// TODO: Replace both [Context] and [TryFromDsl] with this trait
/// which returns a [Result].
/// Implement the [Dsl] trait, which boils down to
/// specifying two types and providing an expression.
#[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 {
fn take <'state, 'source> (_: &'state Self, _: &mut TokenIter<'source>) -> Perhaps<U> {
Ok(None)
fn take <'state, 'source> (
&'state self,
_: &mut TokenIter<'source>
) -> Perhaps<U> {
unimplemented!()
}
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> {
if let Some(value) = Self::take(state, iter)? {
if let Some(value) = Dsl::<U>::take(self, token)? {
Ok(value)
} 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
pub trait Context<'state, U>: Sized {
fn get <'source> (&'state self, _iter: &mut TokenIter<'source>) -> Option<U> {
None
}
//impl<T: Dsl<U>, U> Dsl<U> for &T {
//fn take <'state, 'source> (&'state self, iter: &mut TokenIter<'source>) -> Perhaps<U> {
//(*self).take(iter)
//}
//}
//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 {
fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<U> {
(*self).get(iter)
}
}
//impl<T, U: FromDsl<T>> Dsl<U> for T {
//}
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 FromDsl<'state, T>: Sized {
fn take_from <'source: 'state> (
state: &'state T,
_token: &mut TokenIter<'source>
) -> Perhaps<Self> {
unimplemented!()
}
}
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)
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())
}
None
}
}

100
input/src/input_dsl.rs
View file

@ -1,25 +1,18 @@
use crate::*;
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].
pub trait DslInput: Input {
fn matches_dsl (&self, token: &str) -> bool;
}
pub trait DslInput: Input { fn matches_dsl (&self, token: &str) -> bool; }
/// 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.
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].
impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> for SourceIter<'state> {
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C> {
impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for SourceIter<'source> {
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
let mut iter = self.clone();
while let Some((token, rest)) = iter.next() {
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() {
Some(Token { value: Value::Sym(binding), .. }) => {
if input.matches_dsl(binding) {
if let Some(command) = C::try_from_expr(state, &mut exp_iter) {
return Some(command)
if let Some(command) = Dsl::<C>::take(state, &mut exp_iter)? {
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)")
}
}
None
Ok(None)
}
}
/// A [TokenIter] can be a [KeyMap].
impl<'state, S, C: DslCommand<'state, S>, I: DslInput> KeyMap<'state, S, C, I> for TokenIter<'state> {
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C> {
impl<'source, S: Dsl<C>, C: Command<S>, I: DslInput> KeyMap<S, C, I> for TokenIter<'source> {
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
let mut iter = self.clone();
while let Some(next) = iter.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() {
Some(Token { value: Value::Sym(binding), .. }) => {
if input.matches_dsl(binding) {
if let Some(command) = C::try_from_expr(state, &mut e) {
return Some(command)
if let Some(command) = Dsl::<C>::take(state, &mut e)? {
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:?})")
}
}
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,
/// which may be made available subject to given conditions.
pub struct InputMap<'state, S, C, I, M>
where
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
__: &'state PhantomData<(S, C, I)>,
pub layers: Vec<(InputLayerCond<'state, S>, M)>,
pub struct InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
__: PhantomData<(S, C, I)>,
pub layers: Vec<(InputLayerCond<S>, M)>,
}
impl<'state, S, C, I, M> Default for InputMap<'state, S, C, I, M>
where
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
impl<S, C, I, M> Default for InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
fn default () -> Self {
Self {
__: &PhantomData,
layers: vec![]
}
Self { __: PhantomData, layers: vec![] }
}
}
impl<'state, S, C, I, M> InputMap<'state, S, C, I, M>
where
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
impl<S, C, I, M> InputMap<S, C, I, M>
where S: Dsl<C> + 'static, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
pub fn new (keymap: M) -> Self {
Self::default().layer(keymap)
}
@ -112,46 +90,38 @@ where
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
}
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
}
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
}
}
impl<'state, S, C, I, M> std::fmt::Debug for InputMap<'state, S, C, I, M>
where
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
impl<S, C, I, M> std::fmt::Debug for InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
write!(f, "[InputMap: {} layer(s)]", self.layers.len())
}
}
/// An [InputMap] can be a [KeyMap].
impl<'state, S, C, I, M> KeyMap<'state, S, C, I> for InputMap<'state, S, C, I, M>
where
C: DslCommand<'state, S>,
I: DslInput,
M: KeyMap<'state, S, C, I> + Send + Sync
{
fn command (&'state self, state: &'state S, input: &'state I) -> Option<C> {
impl<S, C, I, M> KeyMap<S, C, I> for InputMap<S, C, I, M>
where S: Dsl<C>, C: Command<S>, I: DslInput, M: KeyMap<S, C, I> + Send + Sync {
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
for (condition, keymap) in self.layers.iter() {
if !condition(state) {
if !condition(state)? {
continue
}
if let Some(command) = keymap.command(state, input) {
return Some(command)
if let Some(command) = keymap.keybind_resolve(state, input)? {
return Ok(Some(command))
}
}
None
Ok(None)
}
}

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

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

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

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

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

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

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

112
output/src/view.rs
View file

@ -8,15 +8,15 @@ use crate::*;
fn content (&$self) -> impl Render<$Output> { $expr }
}
impl<'a> ViewContext<'a, $Output> for $State {
fn get_content_sym (&'a $self, value: &Value<'a>) -> Option<RenderBox<'a, $Output>> {
if let Value::Sym(s) = value {
fn get_content_sym (&'a $self, iter: &Value<'a>) -> Perhaps<RenderBox<'a, $Output>> {
Ok(if let Value::Sym(s) = value {
match *s {
$($sym => Some($body.boxed()),)*
_ => None
}
} 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> {
fn content (&self) -> impl Render<O> {
let mut iter = self.1.clone();
while let Some(Token { value, .. }) = iter.next() {
if let Some(content) = self.0.get_content(&value) {
while let Some(Token { value, .. }) = iter.peek() {
if let Ok(Some(content)) = self.0.get_content(&mut iter) {
return Some(content)
// TODO handle errors here, how?
// error receiver trait in viewcontext?
}
}
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.
#[cfg(feature = "dsl")]
pub trait ViewContext<'state, E: Output + 'state>: Send + Sync
+ Context<'state, bool>
+ Context<'state, usize>
+ Context<'state, E::Unit>
+ Dsl<bool>
+ Dsl<usize>
+ Dsl<E::Unit>
{
fn get_content <'source: 'state> (&'state self, value: &Value<'source>) -> Option<RenderBox<'state, E>> {
match value {
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_or_fail <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-> Usually<RenderBox<'state, E>>
{
let base = iter.clone();
if let Some(content) = self.get_content(iter)? {
Ok(content)
} else {
Err(format!("not found: {iter:?}").into())
}
}
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>>
fn get_content <'source: 'state> (&'state self, iter: &mut TokenIter<'source>)
-> Perhaps<RenderBox<'state, E>>
{
try_delegate!(self, *value, When::<RenderBox<'state, E>>);
try_delegate!(self, *value, Either::<RenderBox<'state, E>, RenderBox<'state, E>>);
try_delegate!(self, *value, Align::<RenderBox<'state, E>>);
try_delegate!(self, *value, Bsp::<RenderBox<'state, E>, RenderBox<'state, E>>);
try_delegate!(self, *value, Fill::<RenderBox<'state, E>>);
try_delegate!(self, *value, Fixed::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Min::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Max::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Shrink::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Expand::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Push::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Pull::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Margin::<_, RenderBox<'state, E>>);
try_delegate!(self, *value, Padding::<_, RenderBox<'state, E>>);
None
match iter.peek() {
Some(Token { value: Value::Sym(_), .. }) =>
self.get_content_sym(iter),
Some(Token { value: Value::Exp(_, _), .. }) =>
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")]
#[macro_export] macro_rules! try_delegate {
($s:ident, $dsl:expr, $T:ty) => {
if let Some(value) = <$T>::try_from_atom($s, $dsl) {
return 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
}
let value: Option<$T> = FromDsl::take_from($s, $dsl)?;
if let Some(value) = value {
return Ok(Some(value.boxed()))
}
}
}

183
proc/src/proc_command.rs
View file

@ -52,49 +52,111 @@ impl CommandImpl {
impl ToTokens for CommandDef {
fn to_tokens (&self, out: &mut TokenStream2) {
let Self(CommandMeta(target), CommandImpl(block, exposed)) = self;
let enumeration = &block.self_ty;
let variants = exposed.values().map(|x|x.to_enum_variant_def());
let matchers = exposed.values().map(CommandArm::to_matcher);
let implementations = exposed.values().map(CommandArm::to_implementation);
let Self(CommandMeta(state), CommandImpl(block, exposed)) = self;
let command_enum = &block.self_ty;
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! {
/// Generated by [tengri_proc].
#[derive(Clone, Debug)]
pub enum #enumeration {
#(#variants)*
}
#[derive(Clone, Debug)] pub enum #command_enum { #(#variants)* }
/// Not generated by [tengri_proc].
#block
/// Generated by [tengri_proc].
impl<'state> ::tengri::dsl::TryFromDsl<'state, #target> for #enumeration {
fn try_from_expr <'source: 'state> (
state: &'state #target, iter: &mut ::tengri::dsl::TokenIter<'source>
) -> Option<Self> {
let mut iter = iter.clone();
let token = iter.next();
match token {
#(#matchers)*
_ => None
}
impl ::tengri::input::Command<#state> for #command_enum {
fn execute (self, state: &mut #state) -> Perhaps<Self> {
match self { #(#implementations)* }
}
}
/// Generated by [tengri_proc].
impl<'state> ::tengri::dsl::Context<'state, #enumeration> for #target {
fn get <'source> (&self, iter: &mut ::tengri::dsl::TokenIter<'source>)
-> Option<#enumeration>
impl ::tengri::dsl::Dsl<#command_enum> for #state {
fn take <'source, 'state> (
&'state self, words: &mut TokenIter<'source>
)
-> ::tengri::Perhaps<#command_enum>
{
use ::tengri::dsl::TryFromDsl;
#enumeration::try_from_expr(self, iter)
}
}
/// Generated by [tengri_proc].
impl ::tengri::input::Command<#target> for #enumeration {
fn execute (self, state: &mut #target) -> Perhaps<Self> {
match self {
#(#implementations)*
}
let mut words = words.clone();
let token = words.next();
todo!()//Ok(match token { #(#matchers)* _ => None })
}
}
});
//if exposed.len() > 0 {
//panic!("{:#?}", block.self_ty);
//if let Type::Path(ref path) = *block.self_ty {
@ -146,61 +208,4 @@ impl CommandArm {
out.append(Punct::new(',', Alone));
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);
write_quote_to(out, quote! {
/// Generated by [tengri_proc].
impl<'state> ::tengri::dsl::Context<'state, #t> for #target {
fn get <'source> (
&self, iter: &mut ::tengri::dsl::TokenIter<'source>
) -> Option<#t> {
Some(match iter.next().map(|x|x.value) {
impl ::tengri::dsl::Dsl<#t> for #target {
fn take <'state, 'source> (
&'state self, iter: &mut ::tengri::dsl::TokenIter<'source>
) -> Perhaps<#t> {
Ok(Some(match iter.next().map(|x|x.value) {
#predefined
#(#values,)*
_ => return None
})
_ => return Ok(None)
}))
}
}
});

58
proc/src/proc_view.rs
View file

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

16
tengri/src/lib.rs
View file

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