✨ Añade macro para componer HTML en código
- Incorpora el código de la versión 0.25.0 de `maud_macros` creado por Chris Wong. - Y reexporta los elementos esenciales desde la librería principal.
This commit is contained in:
parent
91139d43d3
commit
5ec1b0dc8f
15 changed files with 1834 additions and 19 deletions
80
Cargo.lock
generated
80
Cargo.lock
generated
|
|
@ -65,7 +65,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "e01ed3140b2f8d422c68afa1ed2e85d996ea619c988ac834d255db32138655cb"
|
checksum = "e01ed3140b2f8d422c68afa1ed2e85d996ea619c988ac834d255db32138655cb"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -182,7 +182,7 @@ dependencies = [
|
||||||
"actix-router",
|
"actix-router",
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -426,7 +426,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
"unicode-xid",
|
"unicode-xid",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
@ -448,7 +448,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -918,12 +918,13 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "pagetop"
|
name = "pagetop"
|
||||||
version = "0.0.3"
|
version = "0.0.4"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"actix-web",
|
"actix-web",
|
||||||
"colored",
|
"colored",
|
||||||
"config",
|
"config",
|
||||||
"figlet-rs",
|
"figlet-rs",
|
||||||
|
"itoa",
|
||||||
"pagetop-macros",
|
"pagetop-macros",
|
||||||
"serde",
|
"serde",
|
||||||
"substring",
|
"substring",
|
||||||
|
|
@ -938,7 +939,11 @@ dependencies = [
|
||||||
name = "pagetop-macros"
|
name = "pagetop-macros"
|
||||||
version = "0.0.1"
|
version = "0.0.1"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
|
"proc-macro-crate",
|
||||||
|
"proc-macro-error",
|
||||||
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -993,7 +998,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -1038,6 +1043,39 @@ dependencies = [
|
||||||
"zerocopy",
|
"zerocopy",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "proc-macro-crate"
|
||||||
|
version = "3.3.0"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
|
||||||
|
dependencies = [
|
||||||
|
"toml_edit",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "proc-macro-error"
|
||||||
|
version = "1.0.4"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
|
||||||
|
dependencies = [
|
||||||
|
"proc-macro-error-attr",
|
||||||
|
"proc-macro2",
|
||||||
|
"quote",
|
||||||
|
"syn 1.0.109",
|
||||||
|
"version_check",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "proc-macro-error-attr"
|
||||||
|
version = "1.0.4"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
|
||||||
|
dependencies = [
|
||||||
|
"proc-macro2",
|
||||||
|
"quote",
|
||||||
|
"version_check",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "proc-macro2"
|
name = "proc-macro2"
|
||||||
version = "1.0.95"
|
version = "1.0.95"
|
||||||
|
|
@ -1204,7 +1242,7 @@ checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -1312,6 +1350,16 @@ dependencies = [
|
||||||
"autocfg",
|
"autocfg",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "syn"
|
||||||
|
version = "1.0.109"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
|
||||||
|
dependencies = [
|
||||||
|
"proc-macro2",
|
||||||
|
"unicode-ident",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "syn"
|
name = "syn"
|
||||||
version = "2.0.104"
|
version = "2.0.104"
|
||||||
|
|
@ -1331,7 +1379,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -1361,7 +1409,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -1523,7 +1571,7 @@ checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -1673,7 +1721,7 @@ dependencies = [
|
||||||
"log",
|
"log",
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
"wasm-bindgen-shared",
|
"wasm-bindgen-shared",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
@ -1695,7 +1743,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
"wasm-bindgen-backend",
|
"wasm-bindgen-backend",
|
||||||
"wasm-bindgen-shared",
|
"wasm-bindgen-shared",
|
||||||
]
|
]
|
||||||
|
|
@ -1857,7 +1905,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
"synstructure",
|
"synstructure",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
@ -1878,7 +1926,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -1898,7 +1946,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
"synstructure",
|
"synstructure",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
@ -1932,7 +1980,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"proc-macro2",
|
"proc-macro2",
|
||||||
"quote",
|
"quote",
|
||||||
"syn",
|
"syn 2.0.104",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,6 @@
|
||||||
[package]
|
[package]
|
||||||
name = "pagetop"
|
name = "pagetop"
|
||||||
version = "0.0.3"
|
version = "0.0.4"
|
||||||
edition = "2021"
|
edition = "2021"
|
||||||
|
|
||||||
description = """\
|
description = """\
|
||||||
|
|
@ -18,6 +18,7 @@ authors.workspace = true
|
||||||
colored = "3.0.0"
|
colored = "3.0.0"
|
||||||
config = { version = "0.15.11", default-features = false, features = ["toml"] }
|
config = { version = "0.15.11", default-features = false, features = ["toml"] }
|
||||||
figlet-rs = "0.1.5"
|
figlet-rs = "0.1.5"
|
||||||
|
itoa = "1.0.15"
|
||||||
serde.workspace = true
|
serde.workspace = true
|
||||||
substring = "1.4.5"
|
substring = "1.4.5"
|
||||||
terminal_size = "0.4.2"
|
terminal_size = "0.4.2"
|
||||||
|
|
|
||||||
|
|
@ -18,4 +18,8 @@ authors.workspace = true
|
||||||
proc-macro = true
|
proc-macro = true
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
|
proc-macro2 = "1.0.95"
|
||||||
|
proc-macro-crate = "3.3.0"
|
||||||
|
proc-macro-error = "1.0.4"
|
||||||
quote = "1.0.40"
|
quote = "1.0.40"
|
||||||
|
syn = { version = "2.0.104", features = ["full"] }
|
||||||
|
|
|
||||||
|
|
@ -8,6 +8,13 @@
|
||||||
|
|
||||||
</div>
|
</div>
|
||||||
|
|
||||||
|
## Descripción general
|
||||||
|
|
||||||
|
Entre sus macros se incluye una adaptación de [maud-macros](https://crates.io/crates/maud_macros)
|
||||||
|
([0.25.0](https://github.com/lambda-fairy/maud/tree/v0.25.0/maud_macros)) de
|
||||||
|
[Chris Wong](https://crates.io/users/lambda-fairy) para no tener que referenciar `maud` en las
|
||||||
|
dependencias del archivo `Cargo.toml` de cada proyecto `PageTop`.
|
||||||
|
|
||||||
## Sobre PageTop
|
## Sobre PageTop
|
||||||
|
|
||||||
[PageTop](https://docs.rs/pagetop) es un entorno de desarrollo que reivindica la esencia de la web
|
[PageTop](https://docs.rs/pagetop) es un entorno de desarrollo que reivindica la esencia de la web
|
||||||
|
|
|
||||||
|
|
@ -14,9 +14,18 @@
|
||||||
//! web clásica para crear soluciones web SSR (*renderizadas en el servidor*) modulares, extensibles
|
//! web clásica para crear soluciones web SSR (*renderizadas en el servidor*) modulares, extensibles
|
||||||
//! y configurables, basadas en HTML, CSS y JavaScript.
|
//! y configurables, basadas en HTML, CSS y JavaScript.
|
||||||
|
|
||||||
|
mod maud;
|
||||||
|
|
||||||
use proc_macro::TokenStream;
|
use proc_macro::TokenStream;
|
||||||
|
use proc_macro_error::proc_macro_error;
|
||||||
use quote::quote;
|
use quote::quote;
|
||||||
|
|
||||||
|
#[proc_macro]
|
||||||
|
#[proc_macro_error]
|
||||||
|
pub fn html(input: TokenStream) -> TokenStream {
|
||||||
|
maud::expand(input.into()).into()
|
||||||
|
}
|
||||||
|
|
||||||
/// Define una función `main` asíncrona como punto de entrada de `PageTop`.
|
/// Define una función `main` asíncrona como punto de entrada de `PageTop`.
|
||||||
///
|
///
|
||||||
/// # Ejemplos
|
/// # Ejemplos
|
||||||
|
|
|
||||||
39
helpers/pagetop-macros/src/maud.rs
Normal file
39
helpers/pagetop-macros/src/maud.rs
Normal file
|
|
@ -0,0 +1,39 @@
|
||||||
|
// #![doc(html_root_url = "https://docs.rs/maud_macros/0.25.0")]
|
||||||
|
// TokenStream values are reference counted, and the mental overhead of tracking
|
||||||
|
// lifetimes outweighs the marginal gains from explicit borrowing
|
||||||
|
// #![allow(clippy::needless_pass_by_value)]
|
||||||
|
|
||||||
|
mod ast;
|
||||||
|
mod escape;
|
||||||
|
mod generate;
|
||||||
|
mod parse;
|
||||||
|
|
||||||
|
use proc_macro2::{Ident, Span, TokenStream, TokenTree};
|
||||||
|
use proc_macro_crate::{crate_name, FoundCrate};
|
||||||
|
use quote::quote;
|
||||||
|
|
||||||
|
pub fn expand(input: TokenStream) -> TokenStream {
|
||||||
|
let output_ident = TokenTree::Ident(Ident::new("__maud_output", Span::mixed_site()));
|
||||||
|
// Heuristic: the size of the resulting markup tends to correlate with the
|
||||||
|
// code size of the template itself
|
||||||
|
let size_hint = input.to_string().len();
|
||||||
|
let markups = parse::parse(input);
|
||||||
|
let stmts = generate::generate(markups, output_ident.clone());
|
||||||
|
|
||||||
|
let found_crate = crate_name("pagetop").expect("pagetop is present in `Cargo.toml`");
|
||||||
|
let pre_escaped = match found_crate {
|
||||||
|
FoundCrate::Itself => quote!(
|
||||||
|
crate::html::PreEscaped(#output_ident)
|
||||||
|
),
|
||||||
|
_ => quote!(
|
||||||
|
pagetop::html::PreEscaped(#output_ident)
|
||||||
|
),
|
||||||
|
};
|
||||||
|
|
||||||
|
quote!({
|
||||||
|
extern crate alloc;
|
||||||
|
let mut #output_ident = alloc::string::String::with_capacity(#size_hint);
|
||||||
|
#stmts
|
||||||
|
#pre_escaped
|
||||||
|
})
|
||||||
|
}
|
||||||
221
helpers/pagetop-macros/src/maud/ast.rs
Normal file
221
helpers/pagetop-macros/src/maud/ast.rs
Normal file
|
|
@ -0,0 +1,221 @@
|
||||||
|
use proc_macro2::{TokenStream, TokenTree};
|
||||||
|
use proc_macro_error::SpanRange;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Markup {
|
||||||
|
/// Used as a placeholder value on parse error.
|
||||||
|
ParseError {
|
||||||
|
span: SpanRange,
|
||||||
|
},
|
||||||
|
Block(Block),
|
||||||
|
Literal {
|
||||||
|
content: String,
|
||||||
|
span: SpanRange,
|
||||||
|
},
|
||||||
|
Symbol {
|
||||||
|
symbol: TokenStream,
|
||||||
|
},
|
||||||
|
Splice {
|
||||||
|
expr: TokenStream,
|
||||||
|
outer_span: SpanRange,
|
||||||
|
},
|
||||||
|
Element {
|
||||||
|
name: TokenStream,
|
||||||
|
attrs: Vec<Attr>,
|
||||||
|
body: ElementBody,
|
||||||
|
},
|
||||||
|
Let {
|
||||||
|
at_span: SpanRange,
|
||||||
|
tokens: TokenStream,
|
||||||
|
},
|
||||||
|
Special {
|
||||||
|
segments: Vec<Special>,
|
||||||
|
},
|
||||||
|
Match {
|
||||||
|
at_span: SpanRange,
|
||||||
|
head: TokenStream,
|
||||||
|
arms: Vec<MatchArm>,
|
||||||
|
arms_span: SpanRange,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Markup {
|
||||||
|
pub fn span(&self) -> SpanRange {
|
||||||
|
match *self {
|
||||||
|
Markup::ParseError { span } => span,
|
||||||
|
Markup::Block(ref block) => block.span(),
|
||||||
|
Markup::Literal { span, .. } => span,
|
||||||
|
Markup::Symbol { ref symbol } => span_tokens(symbol.clone()),
|
||||||
|
Markup::Splice { outer_span, .. } => outer_span,
|
||||||
|
Markup::Element {
|
||||||
|
ref name, ref body, ..
|
||||||
|
} => {
|
||||||
|
let name_span = span_tokens(name.clone());
|
||||||
|
name_span.join_range(body.span())
|
||||||
|
}
|
||||||
|
Markup::Let {
|
||||||
|
at_span,
|
||||||
|
ref tokens,
|
||||||
|
} => at_span.join_range(span_tokens(tokens.clone())),
|
||||||
|
Markup::Special { ref segments } => join_ranges(segments.iter().map(Special::span)),
|
||||||
|
Markup::Match {
|
||||||
|
at_span, arms_span, ..
|
||||||
|
} => at_span.join_range(arms_span),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Attr {
|
||||||
|
Class {
|
||||||
|
dot_span: SpanRange,
|
||||||
|
name: Markup,
|
||||||
|
toggler: Option<Toggler>,
|
||||||
|
},
|
||||||
|
Id {
|
||||||
|
hash_span: SpanRange,
|
||||||
|
name: Markup,
|
||||||
|
},
|
||||||
|
Named {
|
||||||
|
named_attr: NamedAttr,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Attr {
|
||||||
|
pub fn span(&self) -> SpanRange {
|
||||||
|
match *self {
|
||||||
|
Attr::Class {
|
||||||
|
dot_span,
|
||||||
|
ref name,
|
||||||
|
ref toggler,
|
||||||
|
} => {
|
||||||
|
let name_span = name.span();
|
||||||
|
let dot_name_span = dot_span.join_range(name_span);
|
||||||
|
if let Some(toggler) = toggler {
|
||||||
|
dot_name_span.join_range(toggler.cond_span)
|
||||||
|
} else {
|
||||||
|
dot_name_span
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Attr::Id {
|
||||||
|
hash_span,
|
||||||
|
ref name,
|
||||||
|
} => {
|
||||||
|
let name_span = name.span();
|
||||||
|
hash_span.join_range(name_span)
|
||||||
|
}
|
||||||
|
Attr::Named { ref named_attr } => named_attr.span(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum ElementBody {
|
||||||
|
Void { semi_span: SpanRange },
|
||||||
|
Block { block: Block },
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ElementBody {
|
||||||
|
pub fn span(&self) -> SpanRange {
|
||||||
|
match *self {
|
||||||
|
ElementBody::Void { semi_span } => semi_span,
|
||||||
|
ElementBody::Block { ref block } => block.span(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Block {
|
||||||
|
pub markups: Vec<Markup>,
|
||||||
|
pub outer_span: SpanRange,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Block {
|
||||||
|
pub fn span(&self) -> SpanRange {
|
||||||
|
self.outer_span
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Special {
|
||||||
|
pub at_span: SpanRange,
|
||||||
|
pub head: TokenStream,
|
||||||
|
pub body: Block,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Special {
|
||||||
|
pub fn span(&self) -> SpanRange {
|
||||||
|
let body_span = self.body.span();
|
||||||
|
self.at_span.join_range(body_span)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct NamedAttr {
|
||||||
|
pub name: TokenStream,
|
||||||
|
pub attr_type: AttrType,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl NamedAttr {
|
||||||
|
fn span(&self) -> SpanRange {
|
||||||
|
let name_span = span_tokens(self.name.clone());
|
||||||
|
if let Some(attr_type_span) = self.attr_type.span() {
|
||||||
|
name_span.join_range(attr_type_span)
|
||||||
|
} else {
|
||||||
|
name_span
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum AttrType {
|
||||||
|
Normal { value: Markup },
|
||||||
|
Optional { toggler: Toggler },
|
||||||
|
Empty { toggler: Option<Toggler> },
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AttrType {
|
||||||
|
fn span(&self) -> Option<SpanRange> {
|
||||||
|
match *self {
|
||||||
|
AttrType::Normal { ref value } => Some(value.span()),
|
||||||
|
AttrType::Optional { ref toggler } => Some(toggler.span()),
|
||||||
|
AttrType::Empty { ref toggler } => toggler.as_ref().map(Toggler::span),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Toggler {
|
||||||
|
pub cond: TokenStream,
|
||||||
|
pub cond_span: SpanRange,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Toggler {
|
||||||
|
fn span(&self) -> SpanRange {
|
||||||
|
self.cond_span
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct MatchArm {
|
||||||
|
pub head: TokenStream,
|
||||||
|
pub body: Block,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn span_tokens<I: IntoIterator<Item = TokenTree>>(tokens: I) -> SpanRange {
|
||||||
|
join_ranges(tokens.into_iter().map(|s| SpanRange::single_span(s.span())))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn join_ranges<I: IntoIterator<Item = SpanRange>>(ranges: I) -> SpanRange {
|
||||||
|
let mut iter = ranges.into_iter();
|
||||||
|
let first = match iter.next() {
|
||||||
|
Some(span) => span,
|
||||||
|
None => return SpanRange::call_site(),
|
||||||
|
};
|
||||||
|
let last = iter.last().unwrap_or(first);
|
||||||
|
first.join_range(last)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn name_to_string(name: TokenStream) -> String {
|
||||||
|
name.into_iter().map(|token| token.to_string()).collect()
|
||||||
|
}
|
||||||
34
helpers/pagetop-macros/src/maud/escape.rs
Normal file
34
helpers/pagetop-macros/src/maud/escape.rs
Normal file
|
|
@ -0,0 +1,34 @@
|
||||||
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
// !!!!!!!! PLEASE KEEP THIS IN SYNC WITH `maud/src/escape.rs` !!!!!!!!!
|
||||||
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use alloc::string::String;
|
||||||
|
|
||||||
|
pub fn escape_to_string(input: &str, output: &mut String) {
|
||||||
|
for b in input.bytes() {
|
||||||
|
match b {
|
||||||
|
b'&' => output.push_str("&"),
|
||||||
|
b'<' => output.push_str("<"),
|
||||||
|
b'>' => output.push_str(">"),
|
||||||
|
b'"' => output.push_str("""),
|
||||||
|
_ => unsafe { output.as_mut_vec().push(b) },
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use super::escape_to_string;
|
||||||
|
use alloc::string::String;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_works() {
|
||||||
|
let mut s = String::new();
|
||||||
|
escape_to_string("<script>launchMissiles()</script>", &mut s);
|
||||||
|
assert_eq!(s, "<script>launchMissiles()</script>");
|
||||||
|
}
|
||||||
|
}
|
||||||
308
helpers/pagetop-macros/src/maud/generate.rs
Normal file
308
helpers/pagetop-macros/src/maud/generate.rs
Normal file
|
|
@ -0,0 +1,308 @@
|
||||||
|
use proc_macro2::{Delimiter, Group, Ident, Literal, Span, TokenStream, TokenTree};
|
||||||
|
use proc_macro_error::SpanRange;
|
||||||
|
use quote::quote;
|
||||||
|
|
||||||
|
use crate::maud::{ast::*, escape};
|
||||||
|
|
||||||
|
use proc_macro_crate::{crate_name, FoundCrate};
|
||||||
|
|
||||||
|
pub fn generate(markups: Vec<Markup>, output_ident: TokenTree) -> TokenStream {
|
||||||
|
let mut build = Builder::new(output_ident.clone());
|
||||||
|
Generator::new(output_ident).markups(markups, &mut build);
|
||||||
|
build.finish()
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Generator {
|
||||||
|
output_ident: TokenTree,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Generator {
|
||||||
|
fn new(output_ident: TokenTree) -> Generator {
|
||||||
|
Generator { output_ident }
|
||||||
|
}
|
||||||
|
|
||||||
|
fn builder(&self) -> Builder {
|
||||||
|
Builder::new(self.output_ident.clone())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn markups(&self, markups: Vec<Markup>, build: &mut Builder) {
|
||||||
|
for markup in markups {
|
||||||
|
self.markup(markup, build);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn markup(&self, markup: Markup, build: &mut Builder) {
|
||||||
|
match markup {
|
||||||
|
Markup::ParseError { .. } => {}
|
||||||
|
Markup::Block(Block {
|
||||||
|
markups,
|
||||||
|
outer_span,
|
||||||
|
}) => {
|
||||||
|
if markups
|
||||||
|
.iter()
|
||||||
|
.any(|markup| matches!(*markup, Markup::Let { .. }))
|
||||||
|
{
|
||||||
|
self.block(
|
||||||
|
Block {
|
||||||
|
markups,
|
||||||
|
outer_span,
|
||||||
|
},
|
||||||
|
build,
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
self.markups(markups, build);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Markup::Literal { content, .. } => build.push_escaped(&content),
|
||||||
|
Markup::Symbol { symbol } => self.name(symbol, build),
|
||||||
|
Markup::Splice { expr, .. } => self.splice(expr, build),
|
||||||
|
Markup::Element { name, attrs, body } => self.element(name, attrs, body, build),
|
||||||
|
Markup::Let { tokens, .. } => build.push_tokens(tokens),
|
||||||
|
Markup::Special { segments } => {
|
||||||
|
for Special { head, body, .. } in segments {
|
||||||
|
build.push_tokens(head);
|
||||||
|
self.block(body, build);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Markup::Match {
|
||||||
|
head,
|
||||||
|
arms,
|
||||||
|
arms_span,
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
let body = {
|
||||||
|
let mut build = self.builder();
|
||||||
|
for MatchArm { head, body } in arms {
|
||||||
|
build.push_tokens(head);
|
||||||
|
self.block(body, &mut build);
|
||||||
|
}
|
||||||
|
build.finish()
|
||||||
|
};
|
||||||
|
let mut body = TokenTree::Group(Group::new(Delimiter::Brace, body));
|
||||||
|
body.set_span(arms_span.collapse());
|
||||||
|
build.push_tokens(quote!(#head #body));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn block(
|
||||||
|
&self,
|
||||||
|
Block {
|
||||||
|
markups,
|
||||||
|
outer_span,
|
||||||
|
}: Block,
|
||||||
|
build: &mut Builder,
|
||||||
|
) {
|
||||||
|
let block = {
|
||||||
|
let mut build = self.builder();
|
||||||
|
self.markups(markups, &mut build);
|
||||||
|
build.finish()
|
||||||
|
};
|
||||||
|
let mut block = TokenTree::Group(Group::new(Delimiter::Brace, block));
|
||||||
|
block.set_span(outer_span.collapse());
|
||||||
|
build.push_tokens(TokenStream::from(block));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn splice(&self, expr: TokenStream, build: &mut Builder) {
|
||||||
|
let output_ident = self.output_ident.clone();
|
||||||
|
|
||||||
|
let found_crate = crate_name("pagetop").expect("pagetop is present in `Cargo.toml`");
|
||||||
|
build.push_tokens(match found_crate {
|
||||||
|
FoundCrate::Itself => quote!(
|
||||||
|
crate::html::html_private::render_to!(&#expr, &mut #output_ident);
|
||||||
|
),
|
||||||
|
_ => quote!(
|
||||||
|
pagetop::html::html_private::render_to!(&#expr, &mut #output_ident);
|
||||||
|
),
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn element(&self, name: TokenStream, attrs: Vec<Attr>, body: ElementBody, build: &mut Builder) {
|
||||||
|
build.push_str("<");
|
||||||
|
self.name(name.clone(), build);
|
||||||
|
self.attrs(attrs, build);
|
||||||
|
build.push_str(">");
|
||||||
|
if let ElementBody::Block { block } = body {
|
||||||
|
self.markups(block.markups, build);
|
||||||
|
build.push_str("</");
|
||||||
|
self.name(name, build);
|
||||||
|
build.push_str(">");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn name(&self, name: TokenStream, build: &mut Builder) {
|
||||||
|
build.push_escaped(&name_to_string(name));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn attrs(&self, attrs: Vec<Attr>, build: &mut Builder) {
|
||||||
|
for NamedAttr { name, attr_type } in desugar_attrs(attrs) {
|
||||||
|
match attr_type {
|
||||||
|
AttrType::Normal { value } => {
|
||||||
|
build.push_str(" ");
|
||||||
|
self.name(name, build);
|
||||||
|
build.push_str("=\"");
|
||||||
|
self.markup(value, build);
|
||||||
|
build.push_str("\"");
|
||||||
|
}
|
||||||
|
AttrType::Optional {
|
||||||
|
toggler: Toggler { cond, .. },
|
||||||
|
} => {
|
||||||
|
let inner_value = quote!(inner_value);
|
||||||
|
let body = {
|
||||||
|
let mut build = self.builder();
|
||||||
|
build.push_str(" ");
|
||||||
|
self.name(name, &mut build);
|
||||||
|
build.push_str("=\"");
|
||||||
|
self.splice(inner_value.clone(), &mut build);
|
||||||
|
build.push_str("\"");
|
||||||
|
build.finish()
|
||||||
|
};
|
||||||
|
build.push_tokens(quote!(if let Some(#inner_value) = (#cond) { #body }));
|
||||||
|
}
|
||||||
|
AttrType::Empty { toggler: None } => {
|
||||||
|
build.push_str(" ");
|
||||||
|
self.name(name, build);
|
||||||
|
}
|
||||||
|
AttrType::Empty {
|
||||||
|
toggler: Some(Toggler { cond, .. }),
|
||||||
|
} => {
|
||||||
|
let body = {
|
||||||
|
let mut build = self.builder();
|
||||||
|
build.push_str(" ");
|
||||||
|
self.name(name, &mut build);
|
||||||
|
build.finish()
|
||||||
|
};
|
||||||
|
build.push_tokens(quote!(if (#cond) { #body }));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
fn desugar_attrs(attrs: Vec<Attr>) -> Vec<NamedAttr> {
|
||||||
|
let mut classes_static = vec![];
|
||||||
|
let mut classes_toggled = vec![];
|
||||||
|
let mut ids = vec![];
|
||||||
|
let mut named_attrs = vec![];
|
||||||
|
for attr in attrs {
|
||||||
|
match attr {
|
||||||
|
Attr::Class {
|
||||||
|
name,
|
||||||
|
toggler: Some(toggler),
|
||||||
|
..
|
||||||
|
} => classes_toggled.push((name, toggler)),
|
||||||
|
Attr::Class {
|
||||||
|
name,
|
||||||
|
toggler: None,
|
||||||
|
..
|
||||||
|
} => classes_static.push(name),
|
||||||
|
Attr::Id { name, .. } => ids.push(name),
|
||||||
|
Attr::Named { named_attr } => named_attrs.push(named_attr),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let classes = desugar_classes_or_ids("class", classes_static, classes_toggled);
|
||||||
|
let ids = desugar_classes_or_ids("id", ids, vec![]);
|
||||||
|
classes.into_iter().chain(ids).chain(named_attrs).collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn desugar_classes_or_ids(
|
||||||
|
attr_name: &'static str,
|
||||||
|
values_static: Vec<Markup>,
|
||||||
|
values_toggled: Vec<(Markup, Toggler)>,
|
||||||
|
) -> Option<NamedAttr> {
|
||||||
|
if values_static.is_empty() && values_toggled.is_empty() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let mut markups = Vec::new();
|
||||||
|
let mut leading_space = false;
|
||||||
|
for name in values_static {
|
||||||
|
markups.extend(prepend_leading_space(name, &mut leading_space));
|
||||||
|
}
|
||||||
|
for (name, Toggler { cond, cond_span }) in values_toggled {
|
||||||
|
let body = Block {
|
||||||
|
markups: prepend_leading_space(name, &mut leading_space),
|
||||||
|
// TODO: is this correct?
|
||||||
|
outer_span: cond_span,
|
||||||
|
};
|
||||||
|
markups.push(Markup::Special {
|
||||||
|
segments: vec![Special {
|
||||||
|
at_span: SpanRange::call_site(),
|
||||||
|
head: quote!(if (#cond)),
|
||||||
|
body,
|
||||||
|
}],
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Some(NamedAttr {
|
||||||
|
name: TokenStream::from(TokenTree::Ident(Ident::new(attr_name, Span::call_site()))),
|
||||||
|
attr_type: AttrType::Normal {
|
||||||
|
value: Markup::Block(Block {
|
||||||
|
markups,
|
||||||
|
outer_span: SpanRange::call_site(),
|
||||||
|
}),
|
||||||
|
},
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn prepend_leading_space(name: Markup, leading_space: &mut bool) -> Vec<Markup> {
|
||||||
|
let mut markups = Vec::new();
|
||||||
|
if *leading_space {
|
||||||
|
markups.push(Markup::Literal {
|
||||||
|
content: " ".to_owned(),
|
||||||
|
span: name.span(),
|
||||||
|
});
|
||||||
|
}
|
||||||
|
*leading_space = true;
|
||||||
|
markups.push(name);
|
||||||
|
markups
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
struct Builder {
|
||||||
|
output_ident: TokenTree,
|
||||||
|
tokens: Vec<TokenTree>,
|
||||||
|
tail: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Builder {
|
||||||
|
fn new(output_ident: TokenTree) -> Builder {
|
||||||
|
Builder {
|
||||||
|
output_ident,
|
||||||
|
tokens: Vec::new(),
|
||||||
|
tail: String::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn push_str(&mut self, string: &str) {
|
||||||
|
self.tail.push_str(string);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn push_escaped(&mut self, string: &str) {
|
||||||
|
escape::escape_to_string(string, &mut self.tail);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn push_tokens(&mut self, tokens: TokenStream) {
|
||||||
|
self.cut();
|
||||||
|
self.tokens.extend(tokens);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn cut(&mut self) {
|
||||||
|
if self.tail.is_empty() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let push_str_expr = {
|
||||||
|
let output_ident = self.output_ident.clone();
|
||||||
|
let string = TokenTree::Literal(Literal::string(&self.tail));
|
||||||
|
quote!(#output_ident.push_str(#string);)
|
||||||
|
};
|
||||||
|
self.tail.clear();
|
||||||
|
self.tokens.extend(push_str_expr);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finish(mut self) -> TokenStream {
|
||||||
|
self.cut();
|
||||||
|
self.tokens.into_iter().collect()
|
||||||
|
}
|
||||||
|
}
|
||||||
752
helpers/pagetop-macros/src/maud/parse.rs
Normal file
752
helpers/pagetop-macros/src/maud/parse.rs
Normal file
|
|
@ -0,0 +1,752 @@
|
||||||
|
use proc_macro2::{Delimiter, Ident, Literal, Spacing, Span, TokenStream, TokenTree};
|
||||||
|
use proc_macro_error::{abort, abort_call_site, emit_error, SpanRange};
|
||||||
|
use std::collections::HashMap;
|
||||||
|
|
||||||
|
use syn::Lit;
|
||||||
|
|
||||||
|
use crate::maud::ast;
|
||||||
|
|
||||||
|
pub fn parse(input: TokenStream) -> Vec<ast::Markup> {
|
||||||
|
Parser::new(input).markups()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
struct Parser {
|
||||||
|
/// If we're inside an attribute, then this contains the attribute name.
|
||||||
|
current_attr: Option<String>,
|
||||||
|
input: <TokenStream as IntoIterator>::IntoIter,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Iterator for Parser {
|
||||||
|
type Item = TokenTree;
|
||||||
|
|
||||||
|
fn next(&mut self) -> Option<TokenTree> {
|
||||||
|
self.input.next()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Parser {
|
||||||
|
fn new(input: TokenStream) -> Parser {
|
||||||
|
Parser {
|
||||||
|
current_attr: None,
|
||||||
|
input: input.into_iter(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn with_input(&self, input: TokenStream) -> Parser {
|
||||||
|
Parser {
|
||||||
|
current_attr: self.current_attr.clone(),
|
||||||
|
input: input.into_iter(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the next token in the stream without consuming it.
|
||||||
|
fn peek(&mut self) -> Option<TokenTree> {
|
||||||
|
self.clone().next()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the next two tokens in the stream without consuming them.
|
||||||
|
fn peek2(&mut self) -> Option<(TokenTree, Option<TokenTree>)> {
|
||||||
|
let mut clone = self.clone();
|
||||||
|
clone.next().map(|first| (first, clone.next()))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Advances the cursor by one step.
|
||||||
|
fn advance(&mut self) {
|
||||||
|
self.next();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Advances the cursor by two steps.
|
||||||
|
fn advance2(&mut self) {
|
||||||
|
self.next();
|
||||||
|
self.next();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses multiple blocks of markup.
|
||||||
|
fn markups(&mut self) -> Vec<ast::Markup> {
|
||||||
|
let mut result = Vec::new();
|
||||||
|
loop {
|
||||||
|
match self.peek2() {
|
||||||
|
None => break,
|
||||||
|
Some((TokenTree::Punct(ref punct), _)) if punct.as_char() == ';' => self.advance(),
|
||||||
|
Some((TokenTree::Punct(ref punct), Some(TokenTree::Ident(ref ident))))
|
||||||
|
if punct.as_char() == '@' && *ident == "let" =>
|
||||||
|
{
|
||||||
|
self.advance2();
|
||||||
|
let keyword = TokenTree::Ident(ident.clone());
|
||||||
|
result.push(self.let_expr(punct.span(), keyword));
|
||||||
|
}
|
||||||
|
_ => result.push(self.markup()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
result
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses a single block of markup.
|
||||||
|
fn markup(&mut self) -> ast::Markup {
|
||||||
|
let token = match self.peek() {
|
||||||
|
Some(token) => token,
|
||||||
|
None => {
|
||||||
|
abort_call_site!("unexpected end of input");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
let markup = match token {
|
||||||
|
// Literal
|
||||||
|
TokenTree::Literal(literal) => {
|
||||||
|
self.advance();
|
||||||
|
self.literal(literal)
|
||||||
|
}
|
||||||
|
// Special form
|
||||||
|
TokenTree::Punct(ref punct) if punct.as_char() == '@' => {
|
||||||
|
self.advance();
|
||||||
|
let at_span = punct.span();
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Ident(ident)) => {
|
||||||
|
let keyword = TokenTree::Ident(ident.clone());
|
||||||
|
match ident.to_string().as_str() {
|
||||||
|
"if" => {
|
||||||
|
let mut segments = Vec::new();
|
||||||
|
self.if_expr(at_span, vec![keyword], &mut segments);
|
||||||
|
ast::Markup::Special { segments }
|
||||||
|
}
|
||||||
|
"while" => self.while_expr(at_span, keyword),
|
||||||
|
"for" => self.for_expr(at_span, keyword),
|
||||||
|
"match" => self.match_expr(at_span, keyword),
|
||||||
|
"let" => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: ident.span(),
|
||||||
|
};
|
||||||
|
abort!(span, "`@let` only works inside a block");
|
||||||
|
}
|
||||||
|
other => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: ident.span(),
|
||||||
|
};
|
||||||
|
abort!(span, "unknown keyword `@{}`", other);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
abort!(at_span, "expected keyword after `@`");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Element
|
||||||
|
TokenTree::Ident(ident) => {
|
||||||
|
let ident_string = ident.to_string();
|
||||||
|
match ident_string.as_str() {
|
||||||
|
"if" | "while" | "for" | "match" | "let" => {
|
||||||
|
abort!(
|
||||||
|
ident,
|
||||||
|
"found keyword `{}`", ident_string;
|
||||||
|
help = "should this be a `@{}`?", ident_string
|
||||||
|
);
|
||||||
|
}
|
||||||
|
"true" | "false" => {
|
||||||
|
if let Some(attr_name) = &self.current_attr {
|
||||||
|
emit_error!(
|
||||||
|
ident,
|
||||||
|
r#"attribute value must be a string"#;
|
||||||
|
help = "to declare an empty attribute, omit the equals sign: `{}`",
|
||||||
|
attr_name;
|
||||||
|
help = "to toggle the attribute, use square brackets: `{}[some_boolean_flag]`",
|
||||||
|
attr_name;
|
||||||
|
);
|
||||||
|
return ast::Markup::ParseError {
|
||||||
|
span: SpanRange::single_span(ident.span()),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
|
||||||
|
// `.try_namespaced_name()` should never fail as we've
|
||||||
|
// already seen an `Ident`
|
||||||
|
let name = self.try_namespaced_name().expect("identifier");
|
||||||
|
self.element(name)
|
||||||
|
}
|
||||||
|
// Div element shorthand
|
||||||
|
TokenTree::Punct(ref punct) if punct.as_char() == '.' || punct.as_char() == '#' => {
|
||||||
|
let name = TokenTree::Ident(Ident::new("div", punct.span()));
|
||||||
|
self.element(name.into())
|
||||||
|
}
|
||||||
|
// Splice
|
||||||
|
TokenTree::Group(ref group) if group.delimiter() == Delimiter::Parenthesis => {
|
||||||
|
self.advance();
|
||||||
|
ast::Markup::Splice {
|
||||||
|
expr: group.stream(),
|
||||||
|
outer_span: SpanRange::single_span(group.span()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Block
|
||||||
|
TokenTree::Group(ref group) if group.delimiter() == Delimiter::Brace => {
|
||||||
|
self.advance();
|
||||||
|
ast::Markup::Block(self.block(group.stream(), SpanRange::single_span(group.span())))
|
||||||
|
}
|
||||||
|
// ???
|
||||||
|
token => {
|
||||||
|
abort!(token, "invalid syntax");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
markup
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses a literal string.
|
||||||
|
fn literal(&mut self, literal: Literal) -> ast::Markup {
|
||||||
|
match Lit::new(literal.clone()) {
|
||||||
|
Lit::Str(lit_str) => {
|
||||||
|
return ast::Markup::Literal {
|
||||||
|
content: lit_str.value(),
|
||||||
|
span: SpanRange::single_span(literal.span()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Boolean literals are idents, so `Lit::Bool` is handled in
|
||||||
|
// `markup`, not here.
|
||||||
|
Lit::Int(..) | Lit::Float(..) => {
|
||||||
|
emit_error!(literal, r#"literal must be double-quoted: `"{}"`"#, literal);
|
||||||
|
}
|
||||||
|
Lit::Char(lit_char) => {
|
||||||
|
emit_error!(
|
||||||
|
literal,
|
||||||
|
r#"literal must be double-quoted: `"{}"`"#,
|
||||||
|
lit_char.value(),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
emit_error!(literal, "expected string");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast::Markup::ParseError {
|
||||||
|
span: SpanRange::single_span(literal.span()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses an `@if` expression.
|
||||||
|
///
|
||||||
|
/// The leading `@if` should already be consumed.
|
||||||
|
fn if_expr(&mut self, at_span: Span, prefix: Vec<TokenTree>, segments: &mut Vec<ast::Special>) {
|
||||||
|
let mut head = prefix;
|
||||||
|
let body = loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Group(ref block)) if block.delimiter() == Delimiter::Brace => {
|
||||||
|
break self.block(block.stream(), SpanRange::single_span(block.span()));
|
||||||
|
}
|
||||||
|
Some(token) => head.push(token),
|
||||||
|
None => {
|
||||||
|
let mut span = ast::span_tokens(head);
|
||||||
|
span.first = at_span;
|
||||||
|
abort!(span, "expected body for this `@if`");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
segments.push(ast::Special {
|
||||||
|
at_span: SpanRange::single_span(at_span),
|
||||||
|
head: head.into_iter().collect(),
|
||||||
|
body,
|
||||||
|
});
|
||||||
|
self.else_if_expr(segments)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses an optional `@else if` or `@else`.
|
||||||
|
///
|
||||||
|
/// The leading `@else if` or `@else` should *not* already be consumed.
|
||||||
|
fn else_if_expr(&mut self, segments: &mut Vec<ast::Special>) {
|
||||||
|
match self.peek2() {
|
||||||
|
Some((TokenTree::Punct(ref punct), Some(TokenTree::Ident(ref else_keyword))))
|
||||||
|
if punct.as_char() == '@' && *else_keyword == "else" =>
|
||||||
|
{
|
||||||
|
self.advance2();
|
||||||
|
let at_span = punct.span();
|
||||||
|
let else_keyword = TokenTree::Ident(else_keyword.clone());
|
||||||
|
match self.peek() {
|
||||||
|
// `@else if`
|
||||||
|
Some(TokenTree::Ident(ref if_keyword)) if *if_keyword == "if" => {
|
||||||
|
self.advance();
|
||||||
|
let if_keyword = TokenTree::Ident(if_keyword.clone());
|
||||||
|
self.if_expr(at_span, vec![else_keyword, if_keyword], segments)
|
||||||
|
}
|
||||||
|
// Just an `@else`
|
||||||
|
_ => match self.next() {
|
||||||
|
Some(TokenTree::Group(ref group))
|
||||||
|
if group.delimiter() == Delimiter::Brace =>
|
||||||
|
{
|
||||||
|
let body =
|
||||||
|
self.block(group.stream(), SpanRange::single_span(group.span()));
|
||||||
|
segments.push(ast::Special {
|
||||||
|
at_span: SpanRange::single_span(at_span),
|
||||||
|
head: vec![else_keyword].into_iter().collect(),
|
||||||
|
body,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: else_keyword.span(),
|
||||||
|
};
|
||||||
|
abort!(span, "expected body for this `@else`");
|
||||||
|
}
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// We didn't find an `@else`; stop
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses an `@while` expression.
|
||||||
|
///
|
||||||
|
/// The leading `@while` should already be consumed.
|
||||||
|
fn while_expr(&mut self, at_span: Span, keyword: TokenTree) -> ast::Markup {
|
||||||
|
let keyword_span = keyword.span();
|
||||||
|
let mut head = vec![keyword];
|
||||||
|
let body = loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Group(ref block)) if block.delimiter() == Delimiter::Brace => {
|
||||||
|
break self.block(block.stream(), SpanRange::single_span(block.span()));
|
||||||
|
}
|
||||||
|
Some(token) => head.push(token),
|
||||||
|
None => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: keyword_span,
|
||||||
|
};
|
||||||
|
abort!(span, "expected body for this `@while`");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
ast::Markup::Special {
|
||||||
|
segments: vec![ast::Special {
|
||||||
|
at_span: SpanRange::single_span(at_span),
|
||||||
|
head: head.into_iter().collect(),
|
||||||
|
body,
|
||||||
|
}],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses a `@for` expression.
|
||||||
|
///
|
||||||
|
/// The leading `@for` should already be consumed.
|
||||||
|
fn for_expr(&mut self, at_span: Span, keyword: TokenTree) -> ast::Markup {
|
||||||
|
let keyword_span = keyword.span();
|
||||||
|
let mut head = vec![keyword];
|
||||||
|
loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Ident(ref in_keyword)) if *in_keyword == "in" => {
|
||||||
|
head.push(TokenTree::Ident(in_keyword.clone()));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Some(token) => head.push(token),
|
||||||
|
None => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: keyword_span,
|
||||||
|
};
|
||||||
|
abort!(span, "missing `in` in `@for` loop");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let body = loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Group(ref block)) if block.delimiter() == Delimiter::Brace => {
|
||||||
|
break self.block(block.stream(), SpanRange::single_span(block.span()));
|
||||||
|
}
|
||||||
|
Some(token) => head.push(token),
|
||||||
|
None => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: keyword_span,
|
||||||
|
};
|
||||||
|
abort!(span, "expected body for this `@for`");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
ast::Markup::Special {
|
||||||
|
segments: vec![ast::Special {
|
||||||
|
at_span: SpanRange::single_span(at_span),
|
||||||
|
head: head.into_iter().collect(),
|
||||||
|
body,
|
||||||
|
}],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses a `@match` expression.
|
||||||
|
///
|
||||||
|
/// The leading `@match` should already be consumed.
|
||||||
|
fn match_expr(&mut self, at_span: Span, keyword: TokenTree) -> ast::Markup {
|
||||||
|
let keyword_span = keyword.span();
|
||||||
|
let mut head = vec![keyword];
|
||||||
|
let (arms, arms_span) = loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Group(ref body)) if body.delimiter() == Delimiter::Brace => {
|
||||||
|
let span = SpanRange::single_span(body.span());
|
||||||
|
break (self.with_input(body.stream()).match_arms(), span);
|
||||||
|
}
|
||||||
|
Some(token) => head.push(token),
|
||||||
|
None => {
|
||||||
|
let span = SpanRange {
|
||||||
|
first: at_span,
|
||||||
|
last: keyword_span,
|
||||||
|
};
|
||||||
|
abort!(span, "expected body for this `@match`");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
ast::Markup::Match {
|
||||||
|
at_span: SpanRange::single_span(at_span),
|
||||||
|
head: head.into_iter().collect(),
|
||||||
|
arms,
|
||||||
|
arms_span,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn match_arms(&mut self) -> Vec<ast::MatchArm> {
|
||||||
|
let mut arms = Vec::new();
|
||||||
|
while let Some(arm) = self.match_arm() {
|
||||||
|
arms.push(arm);
|
||||||
|
}
|
||||||
|
arms
|
||||||
|
}
|
||||||
|
|
||||||
|
fn match_arm(&mut self) -> Option<ast::MatchArm> {
|
||||||
|
let mut head = Vec::new();
|
||||||
|
loop {
|
||||||
|
match self.peek2() {
|
||||||
|
Some((TokenTree::Punct(ref eq), Some(TokenTree::Punct(ref gt))))
|
||||||
|
if eq.as_char() == '='
|
||||||
|
&& gt.as_char() == '>'
|
||||||
|
&& eq.spacing() == Spacing::Joint =>
|
||||||
|
{
|
||||||
|
self.advance2();
|
||||||
|
head.push(TokenTree::Punct(eq.clone()));
|
||||||
|
head.push(TokenTree::Punct(gt.clone()));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Some((token, _)) => {
|
||||||
|
self.advance();
|
||||||
|
head.push(token);
|
||||||
|
}
|
||||||
|
None => {
|
||||||
|
if head.is_empty() {
|
||||||
|
return None;
|
||||||
|
} else {
|
||||||
|
let head_span = ast::span_tokens(head);
|
||||||
|
abort!(head_span, "unexpected end of @match pattern");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let body = match self.next() {
|
||||||
|
// $pat => { $stmts }
|
||||||
|
Some(TokenTree::Group(ref body)) if body.delimiter() == Delimiter::Brace => {
|
||||||
|
let body = self.block(body.stream(), SpanRange::single_span(body.span()));
|
||||||
|
// Trailing commas are optional if the match arm is a braced block
|
||||||
|
if let Some(TokenTree::Punct(ref punct)) = self.peek() {
|
||||||
|
if punct.as_char() == ',' {
|
||||||
|
self.advance();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
body
|
||||||
|
}
|
||||||
|
// $pat => $expr
|
||||||
|
Some(first_token) => {
|
||||||
|
let mut span = SpanRange::single_span(first_token.span());
|
||||||
|
let mut body = vec![first_token];
|
||||||
|
loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(TokenTree::Punct(ref punct)) if punct.as_char() == ',' => break,
|
||||||
|
Some(token) => {
|
||||||
|
span.last = token.span();
|
||||||
|
body.push(token);
|
||||||
|
}
|
||||||
|
None => break,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.block(body.into_iter().collect(), span)
|
||||||
|
}
|
||||||
|
None => {
|
||||||
|
let span = ast::span_tokens(head);
|
||||||
|
abort!(span, "unexpected end of @match arm");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
Some(ast::MatchArm {
|
||||||
|
head: head.into_iter().collect(),
|
||||||
|
body,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses a `@let` expression.
|
||||||
|
///
|
||||||
|
/// The leading `@let` should already be consumed.
|
||||||
|
fn let_expr(&mut self, at_span: Span, keyword: TokenTree) -> ast::Markup {
|
||||||
|
let mut tokens = vec![keyword];
|
||||||
|
loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(token) => match token {
|
||||||
|
TokenTree::Punct(ref punct) if punct.as_char() == '=' => {
|
||||||
|
tokens.push(token.clone());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
_ => tokens.push(token),
|
||||||
|
},
|
||||||
|
None => {
|
||||||
|
let mut span = ast::span_tokens(tokens);
|
||||||
|
span.first = at_span;
|
||||||
|
abort!(span, "unexpected end of `@let` expression");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
loop {
|
||||||
|
match self.next() {
|
||||||
|
Some(token) => match token {
|
||||||
|
TokenTree::Punct(ref punct) if punct.as_char() == ';' => {
|
||||||
|
tokens.push(token.clone());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
_ => tokens.push(token),
|
||||||
|
},
|
||||||
|
None => {
|
||||||
|
let mut span = ast::span_tokens(tokens);
|
||||||
|
span.first = at_span;
|
||||||
|
abort!(
|
||||||
|
span,
|
||||||
|
"unexpected end of `@let` expression";
|
||||||
|
help = "are you missing a semicolon?"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast::Markup::Let {
|
||||||
|
at_span: SpanRange::single_span(at_span),
|
||||||
|
tokens: tokens.into_iter().collect(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses an element node.
|
||||||
|
///
|
||||||
|
/// The element name should already be consumed.
|
||||||
|
fn element(&mut self, name: TokenStream) -> ast::Markup {
|
||||||
|
if self.current_attr.is_some() {
|
||||||
|
let span = ast::span_tokens(name);
|
||||||
|
abort!(span, "unexpected element");
|
||||||
|
}
|
||||||
|
let attrs = self.attrs();
|
||||||
|
let body = match self.peek() {
|
||||||
|
Some(TokenTree::Punct(ref punct))
|
||||||
|
if punct.as_char() == ';' || punct.as_char() == '/' =>
|
||||||
|
{
|
||||||
|
// Void element
|
||||||
|
self.advance();
|
||||||
|
if punct.as_char() == '/' {
|
||||||
|
emit_error!(
|
||||||
|
punct,
|
||||||
|
"void elements must use `;`, not `/`";
|
||||||
|
help = "change this to `;`";
|
||||||
|
help = "see https://github.com/lambda-fairy/maud/pull/315 for details";
|
||||||
|
);
|
||||||
|
}
|
||||||
|
ast::ElementBody::Void {
|
||||||
|
semi_span: SpanRange::single_span(punct.span()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Some(_) => match self.markup() {
|
||||||
|
ast::Markup::Block(block) => ast::ElementBody::Block { block },
|
||||||
|
markup => {
|
||||||
|
let markup_span = markup.span();
|
||||||
|
abort!(
|
||||||
|
markup_span,
|
||||||
|
"element body must be wrapped in braces";
|
||||||
|
help = "see https://github.com/lambda-fairy/maud/pull/137 for details"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
None => abort_call_site!("expected `;`, found end of macro"),
|
||||||
|
};
|
||||||
|
ast::Markup::Element { name, attrs, body }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses the attributes of an element.
|
||||||
|
fn attrs(&mut self) -> Vec<ast::Attr> {
|
||||||
|
let mut attrs = Vec::new();
|
||||||
|
loop {
|
||||||
|
if let Some(name) = self.try_namespaced_name() {
|
||||||
|
// Attribute
|
||||||
|
match self.peek() {
|
||||||
|
// Non-empty attribute
|
||||||
|
Some(TokenTree::Punct(ref punct)) if punct.as_char() == '=' => {
|
||||||
|
self.advance();
|
||||||
|
// Parse a value under an attribute context
|
||||||
|
assert!(self.current_attr.is_none());
|
||||||
|
self.current_attr = Some(ast::name_to_string(name.clone()));
|
||||||
|
let attr_type = match self.attr_toggler() {
|
||||||
|
Some(toggler) => ast::AttrType::Optional { toggler },
|
||||||
|
None => {
|
||||||
|
let value = self.markup();
|
||||||
|
ast::AttrType::Normal { value }
|
||||||
|
}
|
||||||
|
};
|
||||||
|
self.current_attr = None;
|
||||||
|
attrs.push(ast::Attr::Named {
|
||||||
|
named_attr: ast::NamedAttr { name, attr_type },
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// Empty attribute (legacy syntax)
|
||||||
|
Some(TokenTree::Punct(ref punct)) if punct.as_char() == '?' => {
|
||||||
|
self.advance();
|
||||||
|
let toggler = self.attr_toggler();
|
||||||
|
attrs.push(ast::Attr::Named {
|
||||||
|
named_attr: ast::NamedAttr {
|
||||||
|
name: name.clone(),
|
||||||
|
attr_type: ast::AttrType::Empty { toggler },
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// Empty attribute (new syntax)
|
||||||
|
_ => {
|
||||||
|
let toggler = self.attr_toggler();
|
||||||
|
attrs.push(ast::Attr::Named {
|
||||||
|
named_attr: ast::NamedAttr {
|
||||||
|
name: name.clone(),
|
||||||
|
attr_type: ast::AttrType::Empty { toggler },
|
||||||
|
},
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
match self.peek() {
|
||||||
|
// Class shorthand
|
||||||
|
Some(TokenTree::Punct(ref punct)) if punct.as_char() == '.' => {
|
||||||
|
self.advance();
|
||||||
|
let name = self.class_or_id_name();
|
||||||
|
let toggler = self.attr_toggler();
|
||||||
|
attrs.push(ast::Attr::Class {
|
||||||
|
dot_span: SpanRange::single_span(punct.span()),
|
||||||
|
name,
|
||||||
|
toggler,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// ID shorthand
|
||||||
|
Some(TokenTree::Punct(ref punct)) if punct.as_char() == '#' => {
|
||||||
|
self.advance();
|
||||||
|
let name = self.class_or_id_name();
|
||||||
|
attrs.push(ast::Attr::Id {
|
||||||
|
hash_span: SpanRange::single_span(punct.span()),
|
||||||
|
name,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// If it's not a valid attribute, backtrack and bail out
|
||||||
|
_ => break,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut attr_map: HashMap<String, Vec<SpanRange>> = HashMap::new();
|
||||||
|
let mut has_class = false;
|
||||||
|
for attr in &attrs {
|
||||||
|
let name = match attr {
|
||||||
|
ast::Attr::Class { .. } => {
|
||||||
|
if has_class {
|
||||||
|
// Only check the first class to avoid spurious duplicates
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
has_class = true;
|
||||||
|
"class".to_string()
|
||||||
|
}
|
||||||
|
ast::Attr::Id { .. } => "id".to_string(),
|
||||||
|
ast::Attr::Named { named_attr } => named_attr
|
||||||
|
.name
|
||||||
|
.clone()
|
||||||
|
.into_iter()
|
||||||
|
.map(|token| token.to_string())
|
||||||
|
.collect(),
|
||||||
|
};
|
||||||
|
let entry = attr_map.entry(name).or_default();
|
||||||
|
entry.push(attr.span());
|
||||||
|
}
|
||||||
|
|
||||||
|
for (name, spans) in attr_map {
|
||||||
|
if spans.len() > 1 {
|
||||||
|
let mut spans = spans.into_iter();
|
||||||
|
let first_span = spans.next().expect("spans should be non-empty");
|
||||||
|
abort!(first_span, "duplicate attribute `{}`", name);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
attrs
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses the name of a class or ID.
|
||||||
|
fn class_or_id_name(&mut self) -> ast::Markup {
|
||||||
|
if let Some(symbol) = self.try_name() {
|
||||||
|
ast::Markup::Symbol { symbol }
|
||||||
|
} else {
|
||||||
|
self.markup()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses the `[cond]` syntax after an empty attribute or class shorthand.
|
||||||
|
fn attr_toggler(&mut self) -> Option<ast::Toggler> {
|
||||||
|
match self.peek() {
|
||||||
|
Some(TokenTree::Group(ref group)) if group.delimiter() == Delimiter::Bracket => {
|
||||||
|
self.advance();
|
||||||
|
Some(ast::Toggler {
|
||||||
|
cond: group.stream(),
|
||||||
|
cond_span: SpanRange::single_span(group.span()),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses an identifier, without dealing with namespaces.
|
||||||
|
fn try_name(&mut self) -> Option<TokenStream> {
|
||||||
|
let mut result = Vec::new();
|
||||||
|
if let Some(token @ TokenTree::Ident(_)) = self.peek() {
|
||||||
|
self.advance();
|
||||||
|
result.push(token);
|
||||||
|
} else {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let mut expect_ident = false;
|
||||||
|
loop {
|
||||||
|
expect_ident = match self.peek() {
|
||||||
|
Some(TokenTree::Punct(ref punct)) if punct.as_char() == '-' => {
|
||||||
|
self.advance();
|
||||||
|
result.push(TokenTree::Punct(punct.clone()));
|
||||||
|
true
|
||||||
|
}
|
||||||
|
Some(TokenTree::Ident(ref ident)) if expect_ident => {
|
||||||
|
self.advance();
|
||||||
|
result.push(TokenTree::Ident(ident.clone()));
|
||||||
|
false
|
||||||
|
}
|
||||||
|
_ => break,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
Some(result.into_iter().collect())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses a HTML element or attribute name, along with a namespace
|
||||||
|
/// if necessary.
|
||||||
|
fn try_namespaced_name(&mut self) -> Option<TokenStream> {
|
||||||
|
let mut result = vec![self.try_name()?];
|
||||||
|
if let Some(TokenTree::Punct(ref punct)) = self.peek() {
|
||||||
|
if punct.as_char() == ':' {
|
||||||
|
self.advance();
|
||||||
|
result.push(TokenStream::from(TokenTree::Punct(punct.clone())));
|
||||||
|
result.push(self.try_name()?);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Some(result.into_iter().collect())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Parses the given token stream as a Maud expression.
|
||||||
|
fn block(&mut self, body: TokenStream, outer_span: SpanRange) -> ast::Block {
|
||||||
|
let markups = self.with_input(body).markups();
|
||||||
|
ast::Block {
|
||||||
|
markups,
|
||||||
|
outer_span,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
4
src/html.rs
Normal file
4
src/html.rs
Normal file
|
|
@ -0,0 +1,4 @@
|
||||||
|
//! HTML en código.
|
||||||
|
|
||||||
|
mod maud;
|
||||||
|
pub use maud::{html, html_private, Markup, PreEscaped, DOCTYPE};
|
||||||
350
src/html/maud.rs
Normal file
350
src/html/maud.rs
Normal file
|
|
@ -0,0 +1,350 @@
|
||||||
|
//#![no_std]
|
||||||
|
|
||||||
|
//! A macro for writing HTML templates.
|
||||||
|
//!
|
||||||
|
//! This documentation only describes the runtime API. For a general
|
||||||
|
//! guide, check out the [book] instead.
|
||||||
|
//!
|
||||||
|
//! [book]: https://maud.lambda.xyz/
|
||||||
|
|
||||||
|
//#![doc(html_root_url = "https://docs.rs/maud/0.25.0")]
|
||||||
|
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use alloc::{borrow::Cow, boxed::Box, string::String};
|
||||||
|
use core::fmt::{self, Arguments, Display, Write};
|
||||||
|
|
||||||
|
pub use pagetop_macros::html;
|
||||||
|
|
||||||
|
mod escape;
|
||||||
|
|
||||||
|
/// An adapter that escapes HTML special characters.
|
||||||
|
///
|
||||||
|
/// The following characters are escaped:
|
||||||
|
///
|
||||||
|
/// * `&` is escaped as `&`
|
||||||
|
/// * `<` is escaped as `<`
|
||||||
|
/// * `>` is escaped as `>`
|
||||||
|
/// * `"` is escaped as `"`
|
||||||
|
///
|
||||||
|
/// All other characters are passed through unchanged.
|
||||||
|
///
|
||||||
|
/// **Note:** In versions prior to 0.13, the single quote (`'`) was
|
||||||
|
/// escaped as well.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```rust#ignore
|
||||||
|
/// use maud::Escaper;
|
||||||
|
/// use std::fmt::Write;
|
||||||
|
/// let mut s = String::new();
|
||||||
|
/// write!(Escaper::new(&mut s), "<script>launchMissiles()</script>").unwrap();
|
||||||
|
/// assert_eq!(s, "<script>launchMissiles()</script>");
|
||||||
|
/// ```
|
||||||
|
pub struct Escaper<'a>(&'a mut String);
|
||||||
|
|
||||||
|
impl<'a> Escaper<'a> {
|
||||||
|
/// Creates an `Escaper` from a `String`.
|
||||||
|
pub fn new(buffer: &'a mut String) -> Escaper<'a> {
|
||||||
|
Escaper(buffer)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> fmt::Write for Escaper<'a> {
|
||||||
|
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||||
|
escape::escape_to_string(s, self.0);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Represents a type that can be rendered as HTML.
|
||||||
|
///
|
||||||
|
/// To implement this for your own type, override either the `.render()`
|
||||||
|
/// or `.render_to()` methods; since each is defined in terms of the
|
||||||
|
/// other, you only need to implement one of them. See the example below.
|
||||||
|
///
|
||||||
|
/// # Minimal implementation
|
||||||
|
///
|
||||||
|
/// An implementation of this trait must override at least one of
|
||||||
|
/// `.render()` or `.render_to()`. Since the default definitions of
|
||||||
|
/// these methods call each other, not doing this will result in
|
||||||
|
/// infinite recursion.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```rust#ignore
|
||||||
|
/// use maud::{html, Markup, Render};
|
||||||
|
///
|
||||||
|
/// /// Provides a shorthand for linking to a CSS stylesheet.
|
||||||
|
/// pub struct Stylesheet(&'static str);
|
||||||
|
///
|
||||||
|
/// impl Render for Stylesheet {
|
||||||
|
/// fn render(&self) -> Markup {
|
||||||
|
/// html! {
|
||||||
|
/// link rel="stylesheet" type="text/css" href=(self.0);
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub trait Render {
|
||||||
|
/// Renders `self` as a block of `Markup`.
|
||||||
|
fn render(&self) -> Markup {
|
||||||
|
let mut buffer = String::new();
|
||||||
|
self.render_to(&mut buffer);
|
||||||
|
PreEscaped(buffer)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Appends a representation of `self` to the given buffer.
|
||||||
|
///
|
||||||
|
/// Its default implementation just calls `.render()`, but you may
|
||||||
|
/// override it with something more efficient.
|
||||||
|
///
|
||||||
|
/// Note that no further escaping is performed on data written to
|
||||||
|
/// the buffer. If you override this method, you must make sure that
|
||||||
|
/// any data written is properly escaped, whether by hand or using
|
||||||
|
/// the [`Escaper`](struct.Escaper.html) wrapper struct.
|
||||||
|
fn render_to(&self, buffer: &mut String) {
|
||||||
|
buffer.push_str(&self.render().into_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Render for str {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
escape::escape_to_string(self, w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Render for String {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
str::render_to(self, w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Render for Cow<'a, str> {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
str::render_to(self, w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Render for Arguments<'a> {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
let _ = Escaper::new(w).write_fmt(*self);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, T: Render + ?Sized> Render for &'a T {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
T::render_to(self, w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, T: Render + ?Sized> Render for &'a mut T {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
T::render_to(self, w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Render + ?Sized> Render for Box<T> {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
T::render_to(self, w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_render_with_display {
|
||||||
|
($($ty:ty)*) => {
|
||||||
|
$(
|
||||||
|
impl Render for $ty {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
// TODO: remove the explicit arg when Rust 1.58 is released
|
||||||
|
format_args!("{self}", self = self).render_to(w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_render_with_display! {
|
||||||
|
char f32 f64
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_render_with_itoa {
|
||||||
|
($($ty:ty)*) => {
|
||||||
|
$(
|
||||||
|
impl Render for $ty {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
w.push_str(itoa::Buffer::new().format(*self));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_render_with_itoa! {
|
||||||
|
i8 i16 i32 i64 i128 isize
|
||||||
|
u8 u16 u32 u64 u128 usize
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Renders a value using its [`Display`] impl.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```rust#ignore
|
||||||
|
/// use maud::html;
|
||||||
|
/// use std::net::Ipv4Addr;
|
||||||
|
///
|
||||||
|
/// let ip_address = Ipv4Addr::new(127, 0, 0, 1);
|
||||||
|
///
|
||||||
|
/// let markup = html! {
|
||||||
|
/// "My IP address is: "
|
||||||
|
/// (maud::display(ip_address))
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// assert_eq!(markup.into_string(), "My IP address is: 127.0.0.1");
|
||||||
|
/// ```
|
||||||
|
pub fn display(value: impl Display) -> impl Render {
|
||||||
|
struct DisplayWrapper<T>(T);
|
||||||
|
|
||||||
|
impl<T: Display> Render for DisplayWrapper<T> {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
format_args!("{0}", self.0).render_to(w);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
DisplayWrapper(value)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A wrapper that renders the inner value without escaping.
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
pub struct PreEscaped<T: AsRef<str>>(pub T);
|
||||||
|
|
||||||
|
impl<T: AsRef<str>> Render for PreEscaped<T> {
|
||||||
|
fn render_to(&self, w: &mut String) {
|
||||||
|
w.push_str(self.0.as_ref());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A block of markup is a string that does not need to be escaped.
|
||||||
|
///
|
||||||
|
/// The `html!` macro expands to an expression of this type.
|
||||||
|
pub type Markup = PreEscaped<String>;
|
||||||
|
|
||||||
|
impl Markup {
|
||||||
|
pub fn is_empty(&self) -> bool {
|
||||||
|
self.0.is_empty()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: AsRef<str> + Into<String>> PreEscaped<T> {
|
||||||
|
/// Converts the inner value to a string.
|
||||||
|
pub fn into_string(self) -> String {
|
||||||
|
self.0.into()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: AsRef<str> + Into<String>> From<PreEscaped<T>> for String {
|
||||||
|
fn from(value: PreEscaped<T>) -> String {
|
||||||
|
value.into_string()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: AsRef<str> + Default> Default for PreEscaped<T> {
|
||||||
|
fn default() -> Self {
|
||||||
|
Self(Default::default())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The literal string `<!DOCTYPE html>`.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// A minimal web page:
|
||||||
|
///
|
||||||
|
/// ```rust#ignore
|
||||||
|
/// use maud::{DOCTYPE, html};
|
||||||
|
///
|
||||||
|
/// let markup = html! {
|
||||||
|
/// (DOCTYPE)
|
||||||
|
/// html {
|
||||||
|
/// head {
|
||||||
|
/// meta charset="utf-8";
|
||||||
|
/// title { "Test page" }
|
||||||
|
/// }
|
||||||
|
/// body {
|
||||||
|
/// p { "Hello, world!" }
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// };
|
||||||
|
/// ```
|
||||||
|
pub const DOCTYPE: PreEscaped<&'static str> = PreEscaped("<!DOCTYPE html>");
|
||||||
|
|
||||||
|
mod actix_support {
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use crate::html::PreEscaped;
|
||||||
|
use actix_web::{http::header, HttpRequest, HttpResponse, Responder};
|
||||||
|
use alloc::string::String;
|
||||||
|
|
||||||
|
impl Responder for PreEscaped<String> {
|
||||||
|
type Body = String;
|
||||||
|
|
||||||
|
fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> {
|
||||||
|
HttpResponse::Ok()
|
||||||
|
.content_type(header::ContentType::html())
|
||||||
|
.message_body(self.0)
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub mod html_private {
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use super::{display, Render};
|
||||||
|
use alloc::string::String;
|
||||||
|
use core::fmt::Display;
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[macro_export]
|
||||||
|
macro_rules! render_to {
|
||||||
|
($x:expr, $buffer:expr) => {{
|
||||||
|
use $crate::html::html_private::*;
|
||||||
|
match ChooseRenderOrDisplay($x) {
|
||||||
|
x => (&&x).implements_render_or_display().render_to(x.0, $buffer),
|
||||||
|
}
|
||||||
|
}};
|
||||||
|
}
|
||||||
|
|
||||||
|
pub use render_to;
|
||||||
|
|
||||||
|
pub struct ChooseRenderOrDisplay<T>(pub T);
|
||||||
|
|
||||||
|
pub struct ViaRenderTag;
|
||||||
|
pub struct ViaDisplayTag;
|
||||||
|
|
||||||
|
pub trait ViaRender {
|
||||||
|
fn implements_render_or_display(&self) -> ViaRenderTag {
|
||||||
|
ViaRenderTag
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub trait ViaDisplay {
|
||||||
|
fn implements_render_or_display(&self) -> ViaDisplayTag {
|
||||||
|
ViaDisplayTag
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Render> ViaRender for &ChooseRenderOrDisplay<T> {}
|
||||||
|
impl<T: Display> ViaDisplay for ChooseRenderOrDisplay<T> {}
|
||||||
|
|
||||||
|
impl ViaRenderTag {
|
||||||
|
pub fn render_to<T: Render + ?Sized>(self, value: &T, buffer: &mut String) {
|
||||||
|
value.render_to(buffer);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ViaDisplayTag {
|
||||||
|
pub fn render_to<T: Display + ?Sized>(self, value: &T, buffer: &mut String) {
|
||||||
|
display(value).render_to(buffer);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
34
src/html/maud/escape.rs
Normal file
34
src/html/maud/escape.rs
Normal file
|
|
@ -0,0 +1,34 @@
|
||||||
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
// !!!!! PLEASE KEEP THIS IN SYNC WITH `maud_macros/src/escape.rs` !!!!!
|
||||||
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use alloc::string::String;
|
||||||
|
|
||||||
|
pub fn escape_to_string(input: &str, output: &mut String) {
|
||||||
|
for b in input.bytes() {
|
||||||
|
match b {
|
||||||
|
b'&' => output.push_str("&"),
|
||||||
|
b'<' => output.push_str("<"),
|
||||||
|
b'>' => output.push_str(">"),
|
||||||
|
b'"' => output.push_str("""),
|
||||||
|
_ => unsafe { output.as_mut_vec().push(b) },
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use super::escape_to_string;
|
||||||
|
use alloc::string::String;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn it_works() {
|
||||||
|
let mut s = String::new();
|
||||||
|
escape_to_string("<script>launchMissiles()</script>", &mut s);
|
||||||
|
assert_eq!(s, "<script>launchMissiles()</script>");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -32,7 +32,7 @@
|
||||||
|
|
||||||
// RE-EXPORTED *************************************************************************************
|
// RE-EXPORTED *************************************************************************************
|
||||||
|
|
||||||
pub use pagetop_macros::{main, test};
|
pub use pagetop_macros::{html, main, test};
|
||||||
|
|
||||||
// API *********************************************************************************************
|
// API *********************************************************************************************
|
||||||
|
|
||||||
|
|
@ -42,6 +42,8 @@ pub mod config;
|
||||||
pub mod global;
|
pub mod global;
|
||||||
// Gestión de trazas y registro de eventos de la aplicación.
|
// Gestión de trazas y registro de eventos de la aplicación.
|
||||||
pub mod trace;
|
pub mod trace;
|
||||||
|
// HTML en código.
|
||||||
|
pub mod html;
|
||||||
// Gestión del servidor y servicios web.
|
// Gestión del servidor y servicios web.
|
||||||
pub mod service;
|
pub mod service;
|
||||||
// Prepara y ejecuta la aplicación.
|
// Prepara y ejecuta la aplicación.
|
||||||
|
|
|
||||||
|
|
@ -2,7 +2,7 @@
|
||||||
|
|
||||||
// RE-EXPORTED.
|
// RE-EXPORTED.
|
||||||
|
|
||||||
pub use crate::{main, test};
|
pub use crate::{html, main, test};
|
||||||
|
|
||||||
// MACROS.
|
// MACROS.
|
||||||
|
|
||||||
|
|
@ -15,6 +15,8 @@ pub use crate::global;
|
||||||
|
|
||||||
pub use crate::trace;
|
pub use crate::trace;
|
||||||
|
|
||||||
|
pub use crate::html::*;
|
||||||
|
|
||||||
pub use crate::service;
|
pub use crate::service;
|
||||||
|
|
||||||
pub use crate::app::Application;
|
pub use crate::app::Application;
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue