⬆️ Actualiza el código de maud a la versión 0.27.0
This commit is contained in:
parent
5ec1b0dc8f
commit
bceb43e6d0
11 changed files with 1459 additions and 1221 deletions
82
Cargo.lock
generated
82
Cargo.lock
generated
|
|
@ -65,7 +65,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||
checksum = "e01ed3140b2f8d422c68afa1ed2e85d996ea619c988ac834d255db32138655cb"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -182,7 +182,7 @@ dependencies = [
|
|||
"actix-router",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -426,7 +426,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
"unicode-xid",
|
||||
]
|
||||
|
||||
|
|
@ -448,7 +448,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -937,13 +937,13 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "pagetop-macros"
|
||||
version = "0.0.1"
|
||||
version = "0.0.2"
|
||||
dependencies = [
|
||||
"proc-macro-crate",
|
||||
"proc-macro-error",
|
||||
"proc-macro2",
|
||||
"proc-macro2-diagnostics",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -998,7 +998,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1052,30 +1052,6 @@ 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]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.95"
|
||||
|
|
@ -1085,6 +1061,18 @@ dependencies = [
|
|||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2-diagnostics"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.40"
|
||||
|
|
@ -1242,7 +1230,7 @@ checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1350,16 +1338,6 @@ dependencies = [
|
|||
"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]]
|
||||
name = "syn"
|
||||
version = "2.0.104"
|
||||
|
|
@ -1379,7 +1357,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1409,7 +1387,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1571,7 +1549,7 @@ checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1721,7 +1699,7 @@ dependencies = [
|
|||
"log",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
"wasm-bindgen-shared",
|
||||
]
|
||||
|
||||
|
|
@ -1743,7 +1721,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
"wasm-bindgen-backend",
|
||||
"wasm-bindgen-shared",
|
||||
]
|
||||
|
|
@ -1905,7 +1883,7 @@ checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
"synstructure",
|
||||
]
|
||||
|
||||
|
|
@ -1926,7 +1904,7 @@ checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1946,7 +1924,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
"synstructure",
|
||||
]
|
||||
|
||||
|
|
@ -1980,7 +1958,7 @@ checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
|
|||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.104",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "pagetop-macros"
|
||||
version = "0.0.1"
|
||||
version = "0.0.2"
|
||||
edition = "2021"
|
||||
|
||||
description = """\
|
||||
|
|
@ -19,7 +19,7 @@ proc-macro = true
|
|||
|
||||
[dependencies]
|
||||
proc-macro2 = "1.0.95"
|
||||
proc-macro2-diagnostics = { version = "0.10.1", default-features = false }
|
||||
proc-macro-crate = "3.3.0"
|
||||
proc-macro-error = "1.0.4"
|
||||
quote = "1.0.40"
|
||||
syn = { version = "2.0.104", features = ["full"] }
|
||||
|
|
|
|||
|
|
@ -17,11 +17,10 @@
|
|||
mod maud;
|
||||
|
||||
use proc_macro::TokenStream;
|
||||
use proc_macro_error::proc_macro_error;
|
||||
use quote::quote;
|
||||
|
||||
/// Macro para escribir plantillas HTML ([Maud](https://docs.rs/maud)).
|
||||
#[proc_macro]
|
||||
#[proc_macro_error]
|
||||
pub fn html(input: TokenStream) -> TokenStream {
|
||||
maud::expand(input.into()).into()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// #![doc(html_root_url = "https://docs.rs/maud_macros/0.25.0")]
|
||||
// #![doc(html_root_url = "https://docs.rs/maud_macros/0.27.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)]
|
||||
|
|
@ -6,34 +6,55 @@
|
|||
mod ast;
|
||||
mod escape;
|
||||
mod generate;
|
||||
mod parse;
|
||||
|
||||
use proc_macro2::{Ident, Span, TokenStream, TokenTree};
|
||||
use ast::DiagnosticParse;
|
||||
use proc_macro2::{Ident, Span, TokenStream};
|
||||
use proc_macro2_diagnostics::Diagnostic;
|
||||
use proc_macro_crate::{crate_name, FoundCrate};
|
||||
use quote::quote;
|
||||
use syn::parse::{ParseStream, Parser};
|
||||
|
||||
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)
|
||||
),
|
||||
let mut diagnostics = Vec::new();
|
||||
let markups = match Parser::parse2(
|
||||
|input: ParseStream| ast::Markups::diagnostic_parse(input, &mut diagnostics),
|
||||
input,
|
||||
) {
|
||||
Ok(data) => data,
|
||||
Err(err) => {
|
||||
let err = err.to_compile_error();
|
||||
let diag_tokens = diagnostics.into_iter().map(Diagnostic::emit_as_expr_tokens);
|
||||
|
||||
return quote! {{
|
||||
#err
|
||||
#(#diag_tokens)*
|
||||
}};
|
||||
}
|
||||
};
|
||||
|
||||
quote!({
|
||||
let diag_tokens = diagnostics.into_iter().map(Diagnostic::emit_as_expr_tokens);
|
||||
|
||||
let output_ident = Ident::new("__maud_output", Span::mixed_site());
|
||||
let stmts = generate::generate(markups, output_ident.clone());
|
||||
|
||||
let found_crate = crate_name("pagetop").expect("pagetop must be in Cargo.toml");
|
||||
let crate_ident = match found_crate {
|
||||
FoundCrate::Itself => Ident::new("pagetop", Span::call_site()),
|
||||
FoundCrate::Name(ref name) => Ident::new(name, Span::call_site()),
|
||||
};
|
||||
let pre_escaped = quote! {
|
||||
#crate_ident::html::PreEscaped(#output_ident)
|
||||
};
|
||||
|
||||
quote! {{
|
||||
extern crate alloc;
|
||||
let mut #output_ident = alloc::string::String::with_capacity(#size_hint);
|
||||
#stmts
|
||||
#(#diag_tokens)*
|
||||
#pre_escaped
|
||||
})
|
||||
}}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -2,10 +2,6 @@
|
|||
// !!!!!!!! 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 {
|
||||
|
|
@ -20,10 +16,7 @@ pub fn escape_to_string(input: &str, output: &mut String) {
|
|||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
extern crate alloc;
|
||||
|
||||
use super::escape_to_string;
|
||||
use alloc::string::String;
|
||||
|
||||
#[test]
|
||||
fn it_works() {
|
||||
|
|
|
|||
|
|
@ -1,23 +1,23 @@
|
|||
use proc_macro2::{Delimiter, Group, Ident, Literal, Span, TokenStream, TokenTree};
|
||||
use proc_macro_error::SpanRange;
|
||||
use quote::quote;
|
||||
use proc_macro2::{Ident, Span, TokenStream};
|
||||
use quote::{quote, ToTokens};
|
||||
use syn::{parse_quote, token::Brace, Expr, Local};
|
||||
|
||||
use crate::maud::{ast::*, escape};
|
||||
|
||||
use proc_macro_crate::{crate_name, FoundCrate};
|
||||
|
||||
pub fn generate(markups: Vec<Markup>, output_ident: TokenTree) -> TokenStream {
|
||||
pub fn generate(markups: Markups<Element>, output_ident: Ident) -> TokenStream {
|
||||
let mut build = Builder::new(output_ident.clone());
|
||||
Generator::new(output_ident).markups(markups, &mut build);
|
||||
build.finish()
|
||||
}
|
||||
|
||||
struct Generator {
|
||||
output_ident: TokenTree,
|
||||
output_ident: Ident,
|
||||
}
|
||||
|
||||
impl Generator {
|
||||
fn new(output_ident: TokenTree) -> Generator {
|
||||
fn new(output_ident: Ident) -> Generator {
|
||||
Generator { output_ident }
|
||||
}
|
||||
|
||||
|
|
@ -25,129 +25,100 @@ impl Generator {
|
|||
Builder::new(self.output_ident.clone())
|
||||
}
|
||||
|
||||
fn markups(&self, markups: Vec<Markup>, build: &mut Builder) {
|
||||
for markup in markups {
|
||||
fn markups<E: Into<Element>>(&self, markups: Markups<E>, build: &mut Builder) {
|
||||
for markup in markups.markups {
|
||||
self.markup(markup, build);
|
||||
}
|
||||
}
|
||||
|
||||
fn markup(&self, markup: Markup, build: &mut Builder) {
|
||||
fn markup<E: Into<Element>>(&self, markup: Markup<E>, 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,
|
||||
Markup::Block(block) => {
|
||||
if block.markups.markups.iter().any(|markup| {
|
||||
matches!(
|
||||
*markup,
|
||||
Markup::ControlFlow(ControlFlow {
|
||||
kind: ControlFlowKind::Let(_),
|
||||
..
|
||||
} => {
|
||||
let body = {
|
||||
let mut build = self.builder();
|
||||
for MatchArm { head, body } in arms {
|
||||
build.push_tokens(head);
|
||||
self.block(body, &mut build);
|
||||
})
|
||||
)
|
||||
}) {
|
||||
self.block(block, build);
|
||||
} else {
|
||||
self.markups(block.markups, build);
|
||||
}
|
||||
}
|
||||
Markup::Lit(lit) => build.push_escaped(&lit.to_string()),
|
||||
Markup::Splice { expr, .. } => self.splice(expr, build),
|
||||
Markup::Element(element) => self.element(element.into(), build),
|
||||
Markup::ControlFlow(control_flow) => self.control_flow(control_flow, build),
|
||||
Markup::Semi(_) => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn block<E: Into<Element>>(&self, block: Block<E>, build: &mut Builder) {
|
||||
let markups = {
|
||||
let mut build = self.builder();
|
||||
self.markups(block.markups, &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));
|
||||
}
|
||||
}
|
||||
|
||||
build.push_tokens(quote!({ #markups }));
|
||||
}
|
||||
|
||||
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()
|
||||
fn splice(&self, expr: Expr, build: &mut Builder) {
|
||||
let output_ident = &self.output_ident;
|
||||
|
||||
let found_crate = crate_name("pagetop").expect("pagetop debe existir en Cargo.toml");
|
||||
let crate_ident = match found_crate {
|
||||
FoundCrate::Itself => Ident::new("pagetop", Span::call_site()),
|
||||
FoundCrate::Name(name) => Ident::new(&name, Span::call_site()),
|
||||
};
|
||||
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);
|
||||
),
|
||||
build.push_tokens(quote! {
|
||||
#crate_ident::html::html_private::render_to!(&(#expr), &mut #output_ident);
|
||||
});
|
||||
}
|
||||
|
||||
fn element(&self, name: TokenStream, attrs: Vec<Attr>, body: ElementBody, build: &mut Builder) {
|
||||
fn element(&self, element: Element, build: &mut Builder) {
|
||||
let element_name = element.name.clone().unwrap_or_else(|| parse_quote!(div));
|
||||
build.push_str("<");
|
||||
self.name(name.clone(), build);
|
||||
self.attrs(attrs, build);
|
||||
self.name(element_name.clone(), build);
|
||||
self.attrs(element.attrs, build);
|
||||
build.push_str(">");
|
||||
if let ElementBody::Block { block } = body {
|
||||
if let ElementBody::Block(block) = element.body {
|
||||
self.markups(block.markups, build);
|
||||
build.push_str("</");
|
||||
self.name(name, build);
|
||||
self.name(element_name, build);
|
||||
build.push_str(">");
|
||||
}
|
||||
}
|
||||
|
||||
fn name(&self, name: TokenStream, build: &mut Builder) {
|
||||
build.push_escaped(&name_to_string(name));
|
||||
fn name(&self, name: HtmlName, build: &mut Builder) {
|
||||
build.push_escaped(&name.to_string());
|
||||
}
|
||||
|
||||
fn attrs(&self, attrs: Vec<Attr>, build: &mut Builder) {
|
||||
for NamedAttr { name, attr_type } in desugar_attrs(attrs) {
|
||||
match attr_type {
|
||||
AttrType::Normal { value } => {
|
||||
fn name_or_markup(&self, name: HtmlNameOrMarkup, build: &mut Builder) {
|
||||
match name {
|
||||
HtmlNameOrMarkup::HtmlName(name) => self.name(name, build),
|
||||
HtmlNameOrMarkup::Markup(markup) => self.markup(markup, build),
|
||||
}
|
||||
}
|
||||
|
||||
fn attr(&self, name: HtmlName, value: AttributeType, build: &mut Builder) {
|
||||
match value {
|
||||
AttributeType::Normal { value, .. } => {
|
||||
build.push_str(" ");
|
||||
self.name(name, build);
|
||||
build.push_str("=\"");
|
||||
self.markup(value, build);
|
||||
build.push_str("\"");
|
||||
}
|
||||
AttrType::Optional {
|
||||
AttributeType::Optional {
|
||||
toggler: Toggler { cond, .. },
|
||||
..
|
||||
} => {
|
||||
let inner_value = quote!(inner_value);
|
||||
let inner_value: Expr = parse_quote!(inner_value);
|
||||
|
||||
let body = {
|
||||
let mut build = self.builder();
|
||||
build.push_str(" ");
|
||||
|
|
@ -159,13 +130,11 @@ impl Generator {
|
|||
};
|
||||
build.push_tokens(quote!(if let Some(#inner_value) = (#cond) { #body }));
|
||||
}
|
||||
AttrType::Empty { toggler: None } => {
|
||||
AttributeType::Empty(None) => {
|
||||
build.push_str(" ");
|
||||
self.name(name, build);
|
||||
}
|
||||
AttrType::Empty {
|
||||
toggler: Some(Toggler { cond, .. }),
|
||||
} => {
|
||||
AttributeType::Empty(Some(Toggler { cond, .. })) => {
|
||||
let body = {
|
||||
let mut build = self.builder();
|
||||
build.push_str(" ");
|
||||
|
|
@ -176,106 +145,221 @@ impl Generator {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn attrs(&self, attrs: Vec<Attribute>, build: &mut Builder) {
|
||||
let (classes, id, named_attrs) = split_attrs(attrs);
|
||||
|
||||
if !classes.is_empty() {
|
||||
let mut toggle_class_exprs = vec![];
|
||||
|
||||
build.push_str(" ");
|
||||
self.name(parse_quote!(class), build);
|
||||
build.push_str("=\"");
|
||||
for (i, (name, toggler)) in classes.into_iter().enumerate() {
|
||||
if let Some(toggler) = toggler {
|
||||
toggle_class_exprs.push((i > 0, name, toggler));
|
||||
} else {
|
||||
if i > 0 {
|
||||
build.push_str(" ");
|
||||
}
|
||||
self.name_or_markup(name, build);
|
||||
}
|
||||
}
|
||||
|
||||
for (not_first, name, toggler) in toggle_class_exprs {
|
||||
let body = {
|
||||
let mut build = self.builder();
|
||||
if not_first {
|
||||
build.push_str(" ");
|
||||
}
|
||||
self.name_or_markup(name, &mut build);
|
||||
build.finish()
|
||||
};
|
||||
build.push_tokens(quote!(if (#toggler) { #body }));
|
||||
}
|
||||
|
||||
build.push_str("\"");
|
||||
}
|
||||
|
||||
if let Some(id) = id {
|
||||
build.push_str(" ");
|
||||
self.name(parse_quote!(id), build);
|
||||
build.push_str("=\"");
|
||||
self.name_or_markup(id, build);
|
||||
build.push_str("\"");
|
||||
}
|
||||
|
||||
for (name, attr_type) in named_attrs {
|
||||
self.attr(name, attr_type, build);
|
||||
}
|
||||
}
|
||||
|
||||
fn control_flow<E: Into<Element>>(&self, control_flow: ControlFlow<E>, build: &mut Builder) {
|
||||
match control_flow.kind {
|
||||
ControlFlowKind::If(if_) => self.control_flow_if(if_, build),
|
||||
ControlFlowKind::Let(let_) => self.control_flow_let(let_, build),
|
||||
ControlFlowKind::For(for_) => self.control_flow_for(for_, build),
|
||||
ControlFlowKind::While(while_) => self.control_flow_while(while_, build),
|
||||
ControlFlowKind::Match(match_) => self.control_flow_match(match_, build),
|
||||
}
|
||||
}
|
||||
|
||||
fn control_flow_if<E: Into<Element>>(
|
||||
&self,
|
||||
IfExpr {
|
||||
if_token,
|
||||
cond,
|
||||
then_branch,
|
||||
else_branch,
|
||||
}: IfExpr<E>,
|
||||
build: &mut Builder,
|
||||
) {
|
||||
build.push_tokens(quote!(#if_token #cond));
|
||||
self.block(then_branch, build);
|
||||
|
||||
if let Some((_, else_token, if_or_block)) = else_branch {
|
||||
build.push_tokens(quote!(#else_token));
|
||||
self.control_flow_if_or_block(*if_or_block, build);
|
||||
}
|
||||
}
|
||||
|
||||
fn control_flow_if_or_block<E: Into<Element>>(
|
||||
&self,
|
||||
if_or_block: IfOrBlock<E>,
|
||||
build: &mut Builder,
|
||||
) {
|
||||
match if_or_block {
|
||||
IfOrBlock::If(if_) => self.control_flow_if(if_, build),
|
||||
IfOrBlock::Block(block) => self.block(block, build),
|
||||
}
|
||||
}
|
||||
|
||||
fn control_flow_let(&self, let_: Local, build: &mut Builder) {
|
||||
build.push_tokens(let_.to_token_stream());
|
||||
}
|
||||
|
||||
fn control_flow_for<E: Into<Element>>(
|
||||
&self,
|
||||
ForExpr {
|
||||
for_token,
|
||||
pat,
|
||||
in_token,
|
||||
expr,
|
||||
body,
|
||||
}: ForExpr<E>,
|
||||
build: &mut Builder,
|
||||
) {
|
||||
build.push_tokens(quote!(#for_token #pat #in_token (#expr)));
|
||||
self.block(body, build);
|
||||
}
|
||||
|
||||
fn control_flow_while<E: Into<Element>>(
|
||||
&self,
|
||||
WhileExpr {
|
||||
while_token,
|
||||
cond,
|
||||
body,
|
||||
}: WhileExpr<E>,
|
||||
build: &mut Builder,
|
||||
) {
|
||||
build.push_tokens(quote!(#while_token #cond));
|
||||
self.block(body, build);
|
||||
}
|
||||
|
||||
fn control_flow_match<E: Into<Element>>(
|
||||
&self,
|
||||
MatchExpr {
|
||||
match_token,
|
||||
expr,
|
||||
brace_token,
|
||||
arms,
|
||||
}: MatchExpr<E>,
|
||||
build: &mut Builder,
|
||||
) {
|
||||
let arms = {
|
||||
let mut build = self.builder();
|
||||
for MatchArm {
|
||||
pat,
|
||||
guard,
|
||||
fat_arrow_token,
|
||||
body,
|
||||
comma_token,
|
||||
} in arms
|
||||
{
|
||||
build.push_tokens(quote!(#pat));
|
||||
if let Some((if_token, cond)) = guard {
|
||||
build.push_tokens(quote!(#if_token #cond));
|
||||
}
|
||||
build.push_tokens(quote!(#fat_arrow_token));
|
||||
self.block(
|
||||
Block {
|
||||
brace_token: Brace(Span::call_site()),
|
||||
markups: Markups {
|
||||
markups: vec![body],
|
||||
},
|
||||
},
|
||||
&mut build,
|
||||
);
|
||||
build.push_tokens(quote!(#comma_token));
|
||||
}
|
||||
build.finish()
|
||||
};
|
||||
|
||||
let mut arm_block = TokenStream::new();
|
||||
|
||||
brace_token.surround(&mut arm_block, |tokens| {
|
||||
arms.to_tokens(tokens);
|
||||
});
|
||||
|
||||
build.push_tokens(quote!(#match_token #expr #arm_block));
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////
|
||||
|
||||
fn desugar_attrs(attrs: Vec<Attr>) -> Vec<NamedAttr> {
|
||||
let mut classes_static = vec![];
|
||||
let mut classes_toggled = vec![];
|
||||
let mut ids = vec![];
|
||||
#[allow(clippy::type_complexity)]
|
||||
fn split_attrs(
|
||||
attrs: Vec<Attribute>,
|
||||
) -> (
|
||||
Vec<(HtmlNameOrMarkup, Option<Expr>)>,
|
||||
Option<HtmlNameOrMarkup>,
|
||||
Vec<(HtmlName, AttributeType)>,
|
||||
) {
|
||||
let mut classes = vec![];
|
||||
let mut id = None;
|
||||
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),
|
||||
Attribute::Class { name, toggler, .. } => {
|
||||
classes.push((name, toggler.map(|toggler| toggler.cond)))
|
||||
}
|
||||
Attribute::Id { name, .. } => id = Some(name),
|
||||
Attribute::Named { name, attr_type } => named_attrs.push((name, attr_type)),
|
||||
}
|
||||
}
|
||||
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
|
||||
(classes, id, named_attrs)
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////
|
||||
|
||||
struct Builder {
|
||||
output_ident: TokenTree,
|
||||
tokens: Vec<TokenTree>,
|
||||
output_ident: Ident,
|
||||
tokens: TokenStream,
|
||||
tail: String,
|
||||
}
|
||||
|
||||
impl Builder {
|
||||
fn new(output_ident: TokenTree) -> Builder {
|
||||
fn new(output_ident: Ident) -> Builder {
|
||||
Builder {
|
||||
output_ident,
|
||||
tokens: Vec::new(),
|
||||
tokens: TokenStream::new(),
|
||||
tail: String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn push_str(&mut self, string: &str) {
|
||||
fn push_str(&mut self, string: &'static str) {
|
||||
self.tail.push_str(string);
|
||||
}
|
||||
|
||||
|
|
@ -294,8 +378,8 @@ impl Builder {
|
|||
}
|
||||
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);)
|
||||
let tail = &self.tail;
|
||||
quote!(#output_ident.push_str(#tail);)
|
||||
};
|
||||
self.tail.clear();
|
||||
self.tokens.extend(push_str_expr);
|
||||
|
|
@ -303,6 +387,6 @@ impl Builder {
|
|||
|
||||
fn finish(mut self) -> TokenStream {
|
||||
self.cut();
|
||||
self.tokens.into_iter().collect()
|
||||
self.tokens
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,752 +0,0 @@
|
|||
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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
//! HTML en código.
|
||||
|
||||
mod maud;
|
||||
pub use maud::{html, html_private, Markup, PreEscaped, DOCTYPE};
|
||||
pub use maud::{display, html, html_private, Escaper, Markup, PreEscaped, Render, DOCTYPE};
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//#![no_std]
|
||||
// #![no_std]
|
||||
|
||||
//! A macro for writing HTML templates.
|
||||
//!
|
||||
|
|
@ -7,11 +7,11 @@
|
|||
//!
|
||||
//! [book]: https://maud.lambda.xyz/
|
||||
|
||||
//#![doc(html_root_url = "https://docs.rs/maud/0.25.0")]
|
||||
// #![doc(html_root_url = "https://docs.rs/maud/0.27.0")]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
use alloc::{borrow::Cow, boxed::Box, string::String};
|
||||
use alloc::{borrow::Cow, boxed::Box, string::String, sync::Arc};
|
||||
use core::fmt::{self, Arguments, Display, Write};
|
||||
|
||||
pub use pagetop_macros::html;
|
||||
|
|
@ -34,8 +34,8 @@ mod escape;
|
|||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust#ignore
|
||||
/// use maud::Escaper;
|
||||
/// ```rust
|
||||
/// use pagetop::html::Escaper;
|
||||
/// use std::fmt::Write;
|
||||
/// let mut s = String::new();
|
||||
/// write!(Escaper::new(&mut s), "<script>launchMissiles()</script>").unwrap();
|
||||
|
|
@ -50,7 +50,7 @@ impl<'a> Escaper<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a> fmt::Write for Escaper<'a> {
|
||||
impl fmt::Write for Escaper<'_> {
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
escape::escape_to_string(s, self.0);
|
||||
Ok(())
|
||||
|
|
@ -72,8 +72,8 @@ impl<'a> fmt::Write for Escaper<'a> {
|
|||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust#ignore
|
||||
/// use maud::{html, Markup, Render};
|
||||
/// ```rust
|
||||
/// use pagetop::html::{html, Markup, Render};
|
||||
///
|
||||
/// /// Provides a shorthand for linking to a CSS stylesheet.
|
||||
/// pub struct Stylesheet(&'static str);
|
||||
|
|
@ -120,25 +120,25 @@ impl Render for String {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a> Render for Cow<'a, str> {
|
||||
impl Render for Cow<'_, str> {
|
||||
fn render_to(&self, w: &mut String) {
|
||||
str::render_to(self, w);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Render for Arguments<'a> {
|
||||
impl Render for Arguments<'_> {
|
||||
fn render_to(&self, w: &mut String) {
|
||||
let _ = Escaper::new(w).write_fmt(*self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Render + ?Sized> Render for &'a T {
|
||||
impl<T: Render + ?Sized> Render for &T {
|
||||
fn render_to(&self, w: &mut String) {
|
||||
T::render_to(self, w);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Render + ?Sized> Render for &'a mut T {
|
||||
impl<T: Render + ?Sized> Render for &mut T {
|
||||
fn render_to(&self, w: &mut String) {
|
||||
T::render_to(self, w);
|
||||
}
|
||||
|
|
@ -150,6 +150,12 @@ impl<T: Render + ?Sized> Render for Box<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: Render + ?Sized> Render for Arc<T> {
|
||||
fn render_to(&self, w: &mut String) {
|
||||
T::render_to(self, w);
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_render_with_display {
|
||||
($($ty:ty)*) => {
|
||||
$(
|
||||
|
|
@ -188,15 +194,15 @@ impl_render_with_itoa! {
|
|||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust#ignore
|
||||
/// use maud::html;
|
||||
/// ```rust
|
||||
/// use pagetop::html::{display, 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))
|
||||
/// (display(ip_address))
|
||||
/// };
|
||||
///
|
||||
/// assert_eq!(markup.into_string(), "My IP address is: 127.0.0.1");
|
||||
|
|
@ -215,7 +221,7 @@ pub fn display(value: impl Display) -> impl Render {
|
|||
|
||||
/// A wrapper that renders the inner value without escaping.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct PreEscaped<T: AsRef<str>>(pub T);
|
||||
pub struct PreEscaped<T>(pub T);
|
||||
|
||||
impl<T: AsRef<str>> Render for PreEscaped<T> {
|
||||
fn render_to(&self, w: &mut String) {
|
||||
|
|
@ -234,20 +240,20 @@ impl Markup {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: AsRef<str> + Into<String>> PreEscaped<T> {
|
||||
impl<T: 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 {
|
||||
impl<T: 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> {
|
||||
impl<T: Default> Default for PreEscaped<T> {
|
||||
fn default() -> Self {
|
||||
Self(Default::default())
|
||||
}
|
||||
|
|
@ -259,8 +265,8 @@ impl<T: AsRef<str> + Default> Default for PreEscaped<T> {
|
|||
///
|
||||
/// A minimal web page:
|
||||
///
|
||||
/// ```rust#ignore
|
||||
/// use maud::{DOCTYPE, html};
|
||||
/// ```rust
|
||||
/// use pagetop::html::{DOCTYPE, html};
|
||||
///
|
||||
/// let markup = html! {
|
||||
/// (DOCTYPE)
|
||||
|
|
@ -280,10 +286,35 @@ pub const DOCTYPE: PreEscaped<&'static str> = PreEscaped("<!DOCTYPE html>");
|
|||
mod actix_support {
|
||||
extern crate alloc;
|
||||
|
||||
use core::{
|
||||
pin::Pin,
|
||||
task::{Context, Poll},
|
||||
};
|
||||
|
||||
use crate::html::PreEscaped;
|
||||
use actix_web::{http::header, HttpRequest, HttpResponse, Responder};
|
||||
use actix_web::{
|
||||
body::{BodySize, MessageBody},
|
||||
http::header,
|
||||
web::Bytes,
|
||||
HttpRequest, HttpResponse, Responder,
|
||||
};
|
||||
use alloc::string::String;
|
||||
|
||||
impl MessageBody for PreEscaped<String> {
|
||||
type Error = <String as MessageBody>::Error;
|
||||
|
||||
fn size(&self) -> BodySize {
|
||||
self.0.size()
|
||||
}
|
||||
|
||||
fn poll_next(
|
||||
mut self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
) -> Poll<Option<Result<Bytes, Self::Error>>> {
|
||||
Pin::new(&mut self.0).poll_next(cx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Responder for PreEscaped<String> {
|
||||
type Body = String;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//! Gestión del servidor y servicios web ([actix-web](https://docs.rs/actix-web)).
|
||||
//! Gestión del servidor y servicios web ([Actix Web](https://docs.rs/actix-web)).
|
||||
|
||||
pub use actix_web::body::BoxBody;
|
||||
pub use actix_web::dev::Server;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue