beet_router_parser 0.0.5

Tools for building reactive structures
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

pub use crate::prelude::*;
use anyhow::Result;
use beet_rsx::prelude::*;
use proc_macro2::Literal;
use proc_macro2::TokenStream;
use quote::quote;
use std::path::PathBuf;
use sweet::prelude::FsExt;
use sweet::prelude::ReadDir;
use sweet::prelude::ReadFile;
use syn::spanned::Spanned;
use syn::visit::Visit;
mod hash_file;
mod template_watcher;
pub use hash_file::*;
pub use template_watcher::*;


#[derive(Debug)]
pub struct BuildRsxTemplateMap {
	/// use [ron::ser::to_string_pretty] instead of
	/// directly serializing the ron tokens.
	pub pretty: bool,
	pub src: PathBuf,
	// keep default in sync with StaticFileRouter
	pub dst: PathBuf,
}

impl BuildRsxTemplateMap {
	pub const DEFAULT_TEMPLATES_DST: &'static str = "target/rsx-templates.ron";

	pub fn new(src: impl Into<PathBuf>) -> Self {
		Self::new_with_dst(src, Self::DEFAULT_TEMPLATES_DST)
	}
	pub fn new_with_dst(
		src: impl Into<PathBuf>,
		dst: impl Into<PathBuf>,
	) -> Self {
		Self {
			pretty: true,
			src: src.into(),
			dst: dst.into(),
		}
	}

	pub fn build_and_write(&self) -> Result<()> {
		let map_tokens = self.build_ron()?;
		let mut map_str = map_tokens.to_string();
		if self.pretty {
			let map = ron::de::from_str::<RsxTemplateMap>(&map_str)?;
			map_str = ron::ser::to_string_pretty(&map, Default::default())?;
		}
		FsExt::write(&self.dst, &map_str)?;
		Ok(())
	}


	pub fn build_ron(&self) -> Result<TokenStream> {
		let items = ReadDir::files_recursive(&self.src)?
			.into_iter()
			.map(|path| self.file_templates(path))
			.collect::<Result<Vec<_>>>()?
			.into_iter()
			.flatten()
			.map(|(RsxMacroLocation { file, line, col }, tokens)| {
				let line = Literal::usize_unsuffixed(line);
				let col = Literal::usize_unsuffixed(col);
				quote! {
					RsxMacroLocation(
						file: #file,
						line: #line,
						col: #col
					):#tokens
				}
			});

		let map = quote! {
			RsxTemplateMap({#(#items),*})
		};
		Ok(map)
	}


	fn file_templates(
		&self,
		path: PathBuf,
	) -> Result<Vec<(RsxMacroLocation, TokenStream)>> {
		let file = ReadFile::to_string(&path)?;
		let file = syn::parse_file(&file)?;
		let mac = syn::parse_quote!(rsx);
		let mut visitor = RsxSynVisitor::new(path.to_string_lossy(), mac);

		visitor.visit_file(&file);
		Ok(visitor.templates)
	}
}

#[derive(Debug)]
struct RsxSynVisitor {
	file: String,
	templates: Vec<(RsxMacroLocation, TokenStream)>,
	mac: syn::Ident,
}
impl RsxSynVisitor {
	pub fn new(file: impl Into<String>, mac: syn::Ident) -> Self {
		Self {
			file: file.into(),
			templates: Default::default(),
			mac,
		}
	}
}


impl<'a> Visit<'a> for RsxSynVisitor {
	fn visit_macro(&mut self, mac: &syn::Macro) {
		if mac
			.path
			.segments
			.last()
			.map_or(false, |seg| seg.ident == self.mac)
		{
			// use the span of the inner tokens to match the behavior of
			// the rsx! macro
			let span = mac.tokens.span();
			let start = span.start();
			let loc =
				RsxMacroLocation::new(&self.file, start.line, start.column);
			let tokens = RstmlToRsxTemplate::default()
				.map_tokens(mac.tokens.clone(), &self.file);
			self.templates.push((loc, tokens));
		}
	}
}