beet_parse 0.0.8

Parsers for various text and token formats
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::prelude::*;
use beet_core::prelude::*;
use beet_dom::prelude::*;
use proc_macro2::TokenStream;
use quote::quote;




/// Tokenize a bsx tree from the given entity as root. The root is the [`SnippetRoot`]
/// with all children nested under, in bsx we flatten in the case of a single child.
pub fn tokenize_bsx_root(world: &World, entity: Entity) -> Result<TokenStream> {
	let children = world.entity(entity).get::<Children>();

	let inner = match children.map_or(0, |c| c.len()) {
		// no children, return unit
		0 => quote!(()),
		// if one child we unwrap the first child
		1 => tokenize_bsx(world, children.unwrap()[0])?,
		// otherwise we parse as normal, the parent will simply be a list of children
		_ => tokenize_bsx(world, entity)?,
	};
	quote! {
		ResolveSnippets::resolve(#inner)
	}
	.xok()
}
/// Recursively tokenize bsx for this entity
fn tokenize_bsx(world: &World, entity: Entity) -> Result<TokenStream> {
	let mut items = Vec::new();
	RsxComponents::tokenize_if_present(&world, &mut items, entity);
	// BsxComponents::tokenize_if_present(&world, &mut items, entity);
	if world.entity(entity).contains::<ElementNode>() {
		TokenizeTemplate { wrap_inner: false }
			.tokenize(world, &mut items, entity)?;
	}
	if world.entity(entity).contains::<TemplateNode>() {
		tokenize_struct(world, &mut items, entity)?;
	}
	tokenize_node_exprs(world, &mut items, entity)?;
	tokenize_related::<Children>(world, &mut items, entity, tokenize_bsx)?;
	items.xmap(unbounded_bundle).xok()
}

/// tokenize node expressions like the `{foobar}` in `<div>{foobar}</div>`
fn tokenize_node_exprs(
	world: &World,
	items: &mut Vec<TokenStream>,
	entity: Entity,
) -> Result<()> {
	if let Some(block) = world.entity(entity).get::<NodeExpr>() {
		items.push(block.insert_deferred());
	}
	Ok(())
}

#[cfg(test)]
mod test {
	use crate::prelude::*;
	use beet_core::prelude::*;
	use proc_macro2::TokenStream;
	use quote::quote;

	fn parse(tokens: TokenStream) -> TokenStream {
		tokens
			.xmap(|t| ParseRsxTokens::rstml_to_bsx(t, WsPathBuf::new(file!())))
			.unwrap()
	}

	#[test]
	fn empty() { parse(quote! {}).xpect_snapshot(); }
	#[test]
	fn single() { parse(quote! {<my-func/>}).xpect_snapshot(); }
	#[test]
	fn multiple() {
		parse(quote! {
		<my_func/>
		<MyStruct/>
		})
		.xpect_snapshot();
	}
	#[test]
	fn args() { parse(quote! {<func foo=bar/>}).xpect_snapshot(); }
	#[test]
	fn children() { parse(quote! {<func>foo{bar}</func>}).xpect_snapshot(); }
}