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

proc: simplify expose macro

Browse source
This commit is contained in:
🪞👃🪞 2025-05-06 00:48:14 +03:00
parent cba23a005c
commit 7570aefcc2
5 changed files with 288 additions and 405 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock generated
View file

@ -976,6 +976,7 @@ dependencies = [
name = "tengri_proc" name = "tengri_proc"
version = "0.13.0" version = "0.13.0"
dependencies = [ dependencies = [
"heck",
"proc-macro2", "proc-macro2",
"quote", "quote",
"syn", "syn",

5
proc/Cargo.toml
View file

@ -8,6 +8,7 @@ edition = { workspace = true }
proc-macro = true proc-macro = true
[dependencies] [dependencies]
syn = { version = "2", features = ["full", "extra-traits"] } syn = { version = "2", features = ["full", "extra-traits"] }
quote = { version = "1" } quote = { version = "1" }
proc-macro2 = { version = "1", features = ["span-locations"] } proc-macro2 = { version = "1", features = ["span-locations"] }
heck = { version = "0.5" }

24
proc/src/lib.rs
View file

@ -1,6 +1,6 @@
extern crate proc_macro; extern crate proc_macro;
pub(crate) use std::collections::{HashMap, BTreeMap}; pub(crate) use std::collections::{BTreeMap, BTreeSet};
pub(crate) use std::cmp::Ordering; pub(crate) use std::cmp::Ordering;
pub(crate) use proc_macro::TokenStream; pub(crate) use proc_macro::TokenStream;
pub(crate) use proc_macro2::{ pub(crate) use proc_macro2::{
@ -10,22 +10,38 @@ pub(crate) use proc_macro2::{
pub(crate) use syn::{ pub(crate) use syn::{
parse, parse_macro_input, parse_quote as pq, parse, parse_macro_input, parse_quote as pq,
braced, bracketed, parenthesized, Token, braced, bracketed, parenthesized, Token,
Arm, Expr, Attribute, Meta, MetaList, Path, PathSegment, PathArguments, ImplItem, LitStr, Type, Arm, Expr, Attribute, Meta, MetaList, Path, PathSegment, PathArguments,
ImplItem, ImplItemFn, LitStr, Type, ItemImpl, ReturnType, Signature,
parse::{Parse, ParseStream, Result}, parse::{Parse, ParseStream, Result},
token::{PathSep, Brace}, token::{PathSep, Brace},
punctuated::Punctuated, punctuated::Punctuated,
}; };
pub(crate) use quote::{quote, TokenStreamExt, ToTokens}; pub(crate) use quote::{quote, TokenStreamExt, ToTokens};
pub(crate) use heck::AsKebabCase;
mod proc_view; mod proc_view;
mod proc_expose; mod proc_expose;
#[proc_macro_attribute] #[proc_macro_attribute]
pub fn view (meta: TokenStream, item: TokenStream) -> TokenStream { pub fn view (meta: TokenStream, item: TokenStream) -> TokenStream {
self::proc_view::view_impl(meta.into(), item.into()).into() use self::proc_view::{ViewDef, ViewMeta, ViewImpl};
write_macro(ViewDef(
parse_macro_input!(meta as ViewMeta),
parse_macro_input!(item as ViewImpl),
))
} }
#[proc_macro_attribute] #[proc_macro_attribute]
pub fn expose (meta: TokenStream, item: TokenStream) -> TokenStream { pub fn expose (meta: TokenStream, item: TokenStream) -> TokenStream {
self::proc_expose::expose_impl(meta.into(), item.into()).into() use self::proc_expose::{ExposeDef, ExposeMeta, ExposeImpl};
write_macro(ExposeDef(
parse_macro_input!(meta as ExposeMeta),
parse_macro_input!(item as ExposeImpl),
))
}
fn write_macro <T: ToTokens> (t: T) -> TokenStream {
let mut out = TokenStream2::new();
t.to_tokens(&mut out);
out.into()
} }

393
proc/src/proc_expose.rs
View file

@ -1,103 +1,76 @@
use crate::*; use crate::*;
use syn::parse::discouraged::Speculative;
pub(crate) fn expose_impl (meta: TokenStream, data: TokenStream) -> TokenStream { #[derive(Debug, Clone)]
let mut out = TokenStream2::new(); pub(crate) struct ExposeDef(pub(crate) ExposeMeta, pub(crate) ExposeImpl);
ExposeDefinition {
meta: parse_macro_input!(meta as ExposeMeta), #[derive(Debug, Clone)]
data: parse_macro_input!(data as ExposeImpl), pub(crate) struct ExposeMeta;
}.to_tokens(&mut out);
out.into() #[derive(Debug, Clone)]
pub(crate) struct ExposeImpl {
block: ItemImpl,
exposed: BTreeMap<ExposeType, BTreeMap<String, Ident>>,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct ExposeDefinition { struct ExposeArm(String, Ident);
meta: ExposeMeta,
data: ExposeImpl,
}
impl Parse for ExposeDefinition { #[derive(Debug, Clone)]
struct ExposeSym(LitStr);
#[derive(Debug, Clone)]
struct ExposeType(Box<Type>);
impl Parse for ExposeMeta {
fn parse (input: ParseStream) -> Result<Self> { fn parse (input: ParseStream) -> Result<Self> {
Ok(Self { Ok(Self)
meta: input.parse::<ExposeMeta>()?,
data: input.parse::<ExposeImpl>()?,
})
} }
} }
impl ToTokens for ExposeDefinition { impl Parse for ExposeImpl {
fn parse (input: ParseStream) -> Result<Self> {
let block = input.parse::<ItemImpl>()?;
let mut exposed: BTreeMap<ExposeType, BTreeMap<String, Ident>> = Default::default();
for item in block.items.iter() {
if let ImplItem::Fn(ImplItemFn { sig: Signature { ident, output, .. }, .. }) = item {
if let ReturnType::Type(_, return_type) = output {
let return_type = ExposeType(return_type.clone());
if !exposed.contains_key(&return_type) {
exposed.insert(return_type.clone(), Default::default());
}
let values = exposed.get_mut(&return_type).unwrap();
let key = format!(":{}", AsKebabCase(format!("{}", &ident)));
if values.contains_key(&key) {
return Err(input.error(format!("already defined: {key}")))
}
values.insert(key, ident.clone());
} else {
return Err(input.error("output type must be specified"))
}
}
}
Ok(Self { block, exposed })
}
}
impl ToTokens for ExposeDef {
fn to_tokens (&self, out: &mut TokenStream2) { fn to_tokens (&self, out: &mut TokenStream2) {
let Self { meta, data } = self; let Self(meta, data) = self;
for token in quote! { #data } { for token in quote! { #data } {
out.append(token) out.append(token)
} }
} }
} }
#[derive(Debug, Clone)]
struct ExposeMeta {}
impl Parse for ExposeMeta {
fn parse (input: ParseStream) -> Result<Self> {
Ok(Self {})
}
}
#[derive(Debug, Clone)]
struct ExposeImpl {
target: Ident,
items: Vec<ImplItem>,
types: BTreeMap<ExposeType, BTreeMap<ExposeSym, ExposeArm>>,
}
impl Parse for ExposeImpl {
fn parse (input: ParseStream) -> Result<Self> {
let _impl = input.parse::<Token![impl]>()?;
let target = input.parse::<Ident>()?;
let group;
let brace = braced!(group in input);
let mut items = vec![];
let mut types: BTreeMap<ExposeType, BTreeMap<ExposeSym, ExposeArm>> = Default::default();
while !group.is_empty() {
let fork = group.fork();
if let Ok(block) = fork.parse::<ExposeBlock>() {
let t = block.type_.into();
if let Some(values) = types.get_mut(&t) {
for (key, value) in block.values.into_iter() {
if values.contains_key(&key) {
return Err(input.error(format!("{key:?} ({t:?}): already exists")))
} else {
values.insert(key, value);
}
}
} else {
types.insert(t, block.values);
}
group.advance_to(&fork);
continue
}
let fork = group.fork();
if let Ok(item) = fork.parse::<ImplItem>() {
items.push(item);
group.advance_to(&fork);
continue
}
return Err(input.error(
"expected either item or #[tengri::expose(type)] { \":key\" => value }"
));
}
Ok(Self { target, items, types })
}
}
impl ToTokens for ExposeImpl { impl ToTokens for ExposeImpl {
fn to_tokens (&self, out: &mut TokenStream2) { fn to_tokens (&self, out: &mut TokenStream2) {
let Self { target, items, types } = self; let Self { block, exposed } = self;
for token in quote! { impl #target { #(#items)* } } { let target = &self.block.self_ty;
for token in quote! { #block } {
out.append(token); out.append(token);
} }
for (t, variants) in types.iter() { for (t, variants) in exposed.iter() {
let predef = match format!("{}", quote! { #t }).as_str() { let predefined = match format!("{}", quote! { #t }).as_str() {
"bool" => vec![ "bool" => vec![
quote! { ::tengri::dsl::Value::Sym(":true") => true }, quote! { ::tengri::dsl::Value::Sym(":true") => true },
quote! { ::tengri::dsl::Value::Sym(":false") => false }, quote! { ::tengri::dsl::Value::Sym(":false") => false },
@ -113,7 +86,7 @@ impl ToTokens for ExposeImpl {
impl ::tengri::dsl::Context<#t> for #target { impl ::tengri::dsl::Context<#t> for #target {
fn get (&self, dsl: &::tengri::dsl::Value) -> Option<#t> { fn get (&self, dsl: &::tengri::dsl::Value) -> Option<#t> {
Some(match dsl { Some(match dsl {
#(#predef,)* #(#predefined,)*
#(#values,)* #(#values,)*
_ => return None _ => return None
}) })
@ -127,61 +100,9 @@ impl ToTokens for ExposeImpl {
} }
} }
#[derive(Debug, Clone)]
struct ExposeBlock {
type_: Type,
values: BTreeMap<ExposeSym, ExposeArm>,
}
impl Parse for ExposeBlock {
fn parse (input: ParseStream) -> Result<Self> {
let _ = input.parse::<Token![#]>()?;
let group;
let bracket = bracketed!(group in input);
let path = group.parse::<Path>()?;
let type_ = if
path.segments.get(0).map(|x|x.ident.to_string()) == Some("tengri".to_string()) &&
path.segments.get(1).map(|x|x.ident.to_string()) == Some("expose".to_string())
{
let token;
let paren = parenthesized!(token in group);
token.parse::<Type>()?
} else {
return Err(input.error("expected #[tengri::expose(type)]"))
};
let group;
let brace = braced!(group in input);
let mut values = BTreeMap::new();
while !group.is_empty() {
let arm = group.parse::<ExposeArm>()?;
values.insert(arm.key.clone(), arm);
let _ = group.parse::<Token![,]>()?;
}
Ok(Self { type_, values })
}
}
#[derive(Debug, Clone)]
struct ExposeArm {
key: ExposeSym,
value: Expr
}
impl Parse for ExposeArm {
fn parse (input: ParseStream) -> Result<Self> {
let key = input.parse::<LitStr>()?.into();
let _ = input.parse::<Token![=]>()?;
let _ = input.parse::<Token![>]>()?;
let value = input.parse::<Expr>()?;
Ok(Self { key, value })
}
}
impl ToTokens for ExposeArm { impl ToTokens for ExposeArm {
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(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()));
@ -196,7 +117,7 @@ impl ToTokens for ExposeArm {
out.append(Ident::new("Sym", Span::call_site())); out.append(Ident::new("Sym", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, { out.append(Group::new(Delimiter::Parenthesis, {
let mut out = TokenStream2::new(); let mut out = TokenStream2::new();
out.append(key.0.token()); out.append(LitStr::new(&key, Span::call_site()).token());
out out
})); }));
out.append(Punct::new('=', Joint)); out.append(Punct::new('=', Joint));
@ -207,9 +128,6 @@ impl ToTokens for ExposeArm {
} }
} }
#[derive(Debug, Clone)]
struct ExposeSym(LitStr);
impl From<LitStr> for ExposeSym { impl From<LitStr> for ExposeSym {
fn from (this: LitStr) -> Self { fn from (this: LitStr) -> Self {
Self(this) Self(this)
@ -242,12 +160,9 @@ impl PartialEq for ExposeSym {
impl Eq for ExposeSym {} impl Eq for ExposeSym {}
#[derive(Debug, Clone)]
struct ExposeType(Type);
impl From<Type> for ExposeType { impl From<Type> for ExposeType {
fn from (this: Type) -> Self { fn from (this: Type) -> Self {
Self(this) Self(Box::new(this))
} }
} }
@ -284,109 +199,107 @@ impl ToTokens for ExposeType {
} }
#[cfg(test)] #[test] fn test_expose_definition () { #[cfg(test)] #[test] fn test_expose_definition () {
let parsed: ExposeImpl = pq! { // TODO
//#[tengri_proc::expose] //let parsed: ExposeImpl = pq! {
impl Something { ////#[tengri_proc::expose]
#[tengri::expose(bool)] { //impl Something {
":bool1" => true || false, //fn something () -> bool {}
} //}
fn something () {} //};
} //// FIXME:
}; ////assert_eq!(
// FIXME: ////format!("{}", quote! { #parsed }),
//assert_eq!( ////format!("{}", quote! {
//format!("{}", quote! { #parsed }), ////impl Something {
//format!("{}", quote! { ////fn something () {}
//impl Something { ////}
//fn something () {} ////impl ::tengri::Context<bool> for Something {
//} ////fn get (&self, dsl: &::tengri::Value) -> Option<bool> {
//impl ::tengri::Context<bool> for Something { ////Some(match dsl {
//fn get (&self, dsl: &::tengri::Value) -> Option<bool> { ////::tengri::Value::Sym(":true") => true,
//Some(match dsl { ////::tengri::Value::Sym(":false") => false,
//::tengri::Value::Sym(":true") => true, ////::tengri::Value::Sym(":bool1") => true || false,
//::tengri::Value::Sym(":false") => false, ////_ => return None
//::tengri::Value::Sym(":bool1") => true || false, ////})
//_ => return None ////}
//}) ////}
//} ////})
//} ////);
//})
//);
let parsed: ExposeImpl = pq! { //let parsed: ExposeImpl = pq! {
//#[tengri_proc::expose] ////#[tengri_proc::expose]
impl Something { //impl Something {
#[tengri::expose(bool)] { //#[tengri::expose(bool)] {
":bool1" => true || false, //":bool1" => true || false,
}
#[tengri::expose(u16)] {
":u161" => 0 + 1,
}
#[tengri::expose(usize)] {
":usize1" => 1 + 2,
}
#[tengri::expose(Arc<str>)] {
":arcstr1" => "foo".into(),
}
#[tengri::expose(Option<Arc<str>>)] {
":optarcstr1" => Some("bar".into()),
":optarcstr2" => Some("baz".into()),
}
fn something () {}
}
};
// FIXME:
//assert_eq!(
//format!("{}", quote! { #parsed }),
//format!("{}", quote! {
//impl Something {
//fn something () {}
//} //}
//impl ::tengri::Context<Arc<str>> for Something { //#[tengri::expose(u16)] {
//fn get (&self, dsl: &::tengri::Value) -> Option<Arc<str>> { //":u161" => 0 + 1,
//Some(match dsl {
//::tengri::Value::Sym(":arcstr1") => "foo".into(),
//_ => return None
//})
//}
//} //}
//impl ::tengri::Context<Option<Arc<str>>> for Something { //#[tengri::expose(usize)] {
//fn get (&self, dsl: &::tengri::Value) -> Option<Option<Arc<str>>> { //":usize1" => 1 + 2,
//Some(match dsl {
//::tengri::Value::Sym(":optarcstr1") => Some("bar".into()),
//::tengri::Value::Sym(":optarcstr2") => Some("baz".into()),
//_ => return None
//})
//}
//} //}
//impl ::tengri::Context<bool> for Something { //#[tengri::expose(Arc<str>)] {
//fn get (&self, dsl: &::tengri::Value) -> Option<bool> { //":arcstr1" => "foo".into(),
//Some(match dsl {
//::tengri::Value::Sym(":true") => true,
//::tengri::Value::Sym(":false") => false,
//::tengri::Value::Sym(":bool1") => true || false,
//_ => return None
//})
//}
//} //}
//impl ::tengri::Context<u16> for Something { //#[tengri::expose(Option<Arc<str>>)] {
//fn get (&self, dsl: &::tengri::Value) -> Option<u16> { //":optarcstr1" => Some("bar".into()),
//Some(match dsl { //":optarcstr2" => Some("baz".into()),
//::tengri::Value::Num(n) => *n as u16,
//::tengri::Value::Sym(":u161") => 0 + 1,
//_ => return None
//})
//}
//} //}
//impl ::tengri::Context<usize> for Something { //fn something () {}
//fn get (&self, dsl: &::tengri::Value) -> Option<usize> { //}
//Some(match dsl { //};
//::tengri::Value::Num(n) => *n as usize, //// FIXME:
//::tengri::Value::Sym(":usize1") => 1 + 2, ////assert_eq!(
//_ => return None ////format!("{}", quote! { #parsed }),
//}) ////format!("{}", quote! {
//} ////impl Something {
//} ////fn something () {}
//}) ////}
//) ////impl ::tengri::Context<Arc<str>> for Something {
////fn get (&self, dsl: &::tengri::Value) -> Option<Arc<str>> {
////Some(match dsl {
////::tengri::Value::Sym(":arcstr1") => "foo".into(),
////_ => return None
////})
////}
////}
////impl ::tengri::Context<Option<Arc<str>>> for Something {
////fn get (&self, dsl: &::tengri::Value) -> Option<Option<Arc<str>>> {
////Some(match dsl {
////::tengri::Value::Sym(":optarcstr1") => Some("bar".into()),
////::tengri::Value::Sym(":optarcstr2") => Some("baz".into()),
////_ => return None
////})
////}
////}
////impl ::tengri::Context<bool> for Something {
////fn get (&self, dsl: &::tengri::Value) -> Option<bool> {
////Some(match dsl {
////::tengri::Value::Sym(":true") => true,
////::tengri::Value::Sym(":false") => false,
////::tengri::Value::Sym(":bool1") => true || false,
////_ => return None
////})
////}
////}
////impl ::tengri::Context<u16> for Something {
////fn get (&self, dsl: &::tengri::Value) -> Option<u16> {
////Some(match dsl {
////::tengri::Value::Num(n) => *n as u16,
////::tengri::Value::Sym(":u161") => 0 + 1,
////_ => return None
////})
////}
////}
////impl ::tengri::Context<usize> for Something {
////fn get (&self, dsl: &::tengri::Value) -> Option<usize> {
////Some(match dsl {
////::tengri::Value::Num(n) => *n as usize,
////::tengri::Value::Sym(":usize1") => 1 + 2,
////_ => return None
////})
////}
////}
////})
////)
} }

270
proc/src/proc_view.rs
View file

@ -1,52 +1,20 @@
use crate::*; use crate::*;
pub(crate) fn view_impl (meta: TokenStream, data: TokenStream) -> TokenStream { #[derive(Debug, Clone)]
let mut out = TokenStream2::new(); pub(crate) struct ViewDef(pub(crate) ViewMeta, pub(crate) ViewImpl);
ViewDefinition {
meta: parse_macro_input!(meta as ViewMeta),
data: parse_macro_input!(data as ViewImpl),
}.to_tokens(&mut out);
out.into()
}
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct ViewDefinition { pub(crate) struct ViewMeta {
meta: ViewMeta,
data: ViewImpl,
}
#[derive(Debug, Clone)]
struct ViewMeta {
output: Ident, output: Ident,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct ViewImpl { pub(crate) struct ViewImpl {
target: Ident, block: ItemImpl,
items: Vec<ViewItem>, exposed: BTreeMap<String, Ident>,
syms: Vec<ViewSym>,
} }
#[derive(Debug, Clone)] struct ViewArm(String, Ident);
struct ViewItem {
item: ImplItem,
expose: Option<Literal>,
}
#[derive(Debug, Clone)]
struct ViewSym {
symbol: Literal,
name: Ident,
}
impl Parse for ViewDefinition {
fn parse (input: ParseStream) -> Result<Self> {
Ok(Self {
meta: input.parse::<ViewMeta>()?,
data: input.parse::<ViewImpl>()?,
})
}
}
impl Parse for ViewMeta { impl Parse for ViewMeta {
fn parse (input: ParseStream) -> Result<Self> { fn parse (input: ParseStream) -> Result<Self> {
@ -58,68 +26,52 @@ impl Parse for ViewMeta {
impl Parse for ViewImpl { impl Parse for ViewImpl {
fn parse (input: ParseStream) -> Result<Self> { fn parse (input: ParseStream) -> Result<Self> {
let _ = input.parse::<Token![impl]>()?; let block = input.parse::<ItemImpl>()?;
let mut syms = vec![]; let mut exposed: BTreeMap<String, Ident> = Default::default();
Ok(Self { for item in block.items.iter() {
target: input.parse::<Ident>()?, if let ImplItem::Fn(ImplItemFn { sig: Signature { ident, .. }, .. }) = item {
items: { let key = format!(":{}", AsKebabCase(format!("{}", &ident)));
let group; if exposed.contains_key(&key) {
let brace = braced!(group in input); return Err(input.error(format!("already defined: {ident}")));
let mut items = vec![];
while !group.is_empty() {
let item = group.parse::<ViewItem>()?;
if let Some(expose) = &item.expose {
if let ImplItem::Fn(ref item) = item.item {
let symbol = expose.clone();
let name = item.sig.ident.clone();
syms.push(ViewSym { symbol, name })
} else {
return Err(
input.error("only fn items can be exposed to #[tengri::view]")
)
}
}
items.push(item);
} }
items exposed.insert(key, ident.clone());
}, }
syms, }
}) Ok(Self { block, exposed })
} }
} }
impl ToTokens for ViewDef {
impl Parse for ViewItem {
fn parse (input: ParseStream) -> Result<Self> {
let mut expose = None;
Ok(Self {
item: {
let mut item = input.parse::<ImplItem>()?;
if let ImplItem::Fn(ref mut item) = item {
item.attrs = item.attrs.iter().filter(|attr| {
if let Attribute {
meta: Meta::List(MetaList { path, tokens, .. }), ..
} = attr
&& path.segments.len() == 2
&& nth_segment_is(&path.segments, 0, "tengri")
&& nth_segment_is(&path.segments, 1, "view")
&& let Some(TokenTree::Literal(name)) = tokens.clone().into_iter().next()
{
expose = Some(name);
return false
}
true
}).map(|x|x.clone()).collect();
};
item
},
expose,
})
}
}
impl ToTokens for ViewSym {
fn to_tokens (&self, out: &mut TokenStream2) { fn to_tokens (&self, out: &mut TokenStream2) {
let Self(ViewMeta { output }, ViewImpl { block, exposed }) = self;
let ident = &block.self_ty;
let exposed: Vec<_> = exposed.iter().map(|(k,v)|ViewArm(k.clone(), v.clone())).collect();
for token in quote! {
#block
/// Generated by [tengri_proc].
impl ::tengri::output::Content<#output> for #ident {
fn content (&self) -> impl Render<#output> {
self.size.of(::tengri::output::View(self, self.config.view))
}
}
/// Generated by [tengri_proc].
impl<'a> ::tengri::output::ViewContext<'a, #output> for #ident {
fn get_content_sym (&'a self, value: &Value<'a>) -> Option<RenderBox<'a, #output>> {
match value {
#(#exposed)*
_ => panic!("expected Sym(content), got: {value:?}")
}
}
}
} {
out.append(token)
}
}
}
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(':', 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()));
@ -134,7 +86,7 @@ impl ToTokens for ViewSym {
out.append(Ident::new("Sym", Span::call_site())); out.append(Ident::new("Sym", Span::call_site()));
out.append(Group::new(Delimiter::Parenthesis, { out.append(Group::new(Delimiter::Parenthesis, {
let mut out = TokenStream2::new(); let mut out = TokenStream2::new();
out.append(self.symbol.clone()); out.append(LitStr::new(key, Span::call_site()).token());
out out
})); }));
out.append(Punct::new('=', Joint)); out.append(Punct::new('=', Joint));
@ -144,7 +96,7 @@ impl ToTokens for ViewSym {
let mut out = TokenStream2::new(); let mut out = TokenStream2::new();
out.append(Ident::new("self", Span::call_site())); out.append(Ident::new("self", Span::call_site()));
out.append(Punct::new('.', Alone)); out.append(Punct::new('.', Alone));
out.append(self.name.clone()); out.append(value.clone());
out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new())); out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
out.append(Punct::new('.', Alone)); out.append(Punct::new('.', Alone));
out.append(Ident::new("boxed", Span::call_site())); out.append(Ident::new("boxed", Span::call_site()));
@ -155,43 +107,42 @@ impl ToTokens for ViewSym {
} }
} }
impl ToTokens for ViewItem { //impl ToTokens for ViewSym {
fn to_tokens (&self, out: &mut TokenStream2) { //fn to_tokens (&self, out: &mut TokenStream2) {
self.item.to_tokens(out) //out.append(Punct::new(':', Joint));
} //out.append(Punct::new(':', Alone));
} //out.append(Ident::new("tengri", Span::call_site()));
//out.append(Punct::new(':', Joint));
impl ToTokens for ViewDefinition { //out.append(Punct::new(':', Alone));
fn to_tokens (&self, out: &mut TokenStream2) { //out.append(Ident::new("dsl", Span::call_site()));
let Self { //out.append(Punct::new(':', Joint));
meta: ViewMeta { output }, //out.append(Punct::new(':', Alone));
data: ViewImpl { target, syms, items }, //out.append(Ident::new("Value", Span::call_site()));
} = self; //out.append(Punct::new(':', Joint));
for token in quote! { //out.append(Punct::new(':', Alone));
/// Augmented by [tengri_proc]. //out.append(Ident::new("Sym", Span::call_site()));
impl #target { //out.append(Group::new(Delimiter::Parenthesis, {
#(#items)* //let mut out = TokenStream2::new();
} //out.append(self.symbol.clone());
/// Generated by [tengri_proc]. //out
impl ::tengri::output::Content<#output> for #target { //}));
fn content (&self) -> impl Render<#output> { //out.append(Punct::new('=', Joint));
self.size.of(::tengri::output::View(self, self.config.view)) //out.append(Punct::new('>', Alone));
} //out.append(Ident::new("Some", Span::call_site()));
} //out.append(Group::new(Delimiter::Parenthesis, {
/// Generated by [tengri_proc]. //let mut out = TokenStream2::new();
impl<'a> ::tengri::output::ViewContext<'a, #output> for #target { //out.append(Ident::new("self", Span::call_site()));
fn get_content_sym (&'a self, value: &Value<'a>) -> Option<RenderBox<'a, #output>> { //out.append(Punct::new('.', Alone));
match value { //out.append(self.name.clone());
#(#syms)* //out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
_ => panic!("expected Sym(content), got: {value:?}") //out.append(Punct::new('.', Alone));
} //out.append(Ident::new("boxed", Span::call_site()));
} //out.append(Group::new(Delimiter::Parenthesis, TokenStream2::new()));
} //out
} { //}));
out.append(token) //out.append(Punct::new(',', Alone));
} //}
} //}
}
fn nth_segment_is (segments: &Punctuated<PathSegment, PathSep>, n: usize, x: &str) -> bool { fn nth_segment_is (segments: &Punctuated<PathSegment, PathSep>, n: usize, x: &str) -> bool {
if let Some(PathSegment { arguments: PathArguments::None, ident, .. }) = segments.get(n) { if let Some(PathSegment { arguments: PathArguments::None, ident, .. }) = segments.get(n) {
@ -202,17 +153,17 @@ fn nth_segment_is (segments: &Punctuated<PathSegment, PathSep>, n: usize, x: &st
return false return false
} }
impl std::cmp::PartialEq for ViewItem { //impl std::cmp::PartialEq for ViewItem {
fn eq (&self, other: &Self) -> bool { //fn eq (&self, other: &Self) -> bool {
self.item == other.item && (format!("{:?}", self.expose) == format!("{:?}", other.expose)) //self.item == other.item && (format!("{:?}", self.expose) == format!("{:?}", other.expose))
} //}
} //}
impl std::cmp::PartialEq for ViewSym { //impl std::cmp::PartialEq for ViewSym {
fn eq (&self, other: &Self) -> bool { //fn eq (&self, other: &Self) -> bool {
self.name == other.name && (format!("{}", self.symbol) == format!("{}", other.symbol)) //self.name == other.name && (format!("{}", self.symbol) == format!("{}", other.symbol))
} //}
} //}
#[cfg(test)] #[test] fn test_view_meta () { #[cfg(test)] #[test] fn test_view_meta () {
let x: ViewMeta = pq! { SomeOutput }; let x: ViewMeta = pq! { SomeOutput };
@ -221,6 +172,7 @@ impl std::cmp::PartialEq for ViewSym {
} }
#[cfg(test)] #[test] fn test_view_impl () { #[cfg(test)] #[test] fn test_view_impl () {
// TODO
let x: ViewImpl = pq! { let x: ViewImpl = pq! {
impl Foo { impl Foo {
/// docstring1 /// docstring1
@ -232,20 +184,20 @@ impl std::cmp::PartialEq for ViewSym {
} }
}; };
let expected_target: Ident = pq! { Foo }; let expected_target: Ident = pq! { Foo };
assert_eq!(x.target, expected_target); //assert_eq!(x.target, expected_target);
assert_eq!(x.items.len(), 2); //assert_eq!(x.items.len(), 2);
assert_eq!(x.items[0].item, pq! { //assert_eq!(x.items[0].item, pq! {
/// docstring1 ///// docstring1
#[bar] fn a_view () {} //#[bar] fn a_view () {}
}); //});
assert_eq!(x.items[1].item, pq! { //assert_eq!(x.items[1].item, pq! {
#[baz] //#[baz]
/// docstring2 ///// docstring2
#[baz] fn is_not_view () {} //#[baz] fn is_not_view () {}
}); //});
assert_eq!(x.syms, vec![ //assert_eq!(x.syms, vec![
ViewSym { symbol: pq! { ":view1" }, name: pq! { a_view }, }, //ViewArm( { symbol: pq! { ":view1" }, name: pq! { a_view }, },
]); //]);
} }
#[cfg(test)] #[test] fn test_view_definition () { #[cfg(test)] #[test] fn test_view_definition () {