badmanners/maud
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'proc-macro'

Browse source
This commit is contained in:
Chris Wong 2017-07-30 14:06:03 +12:00
commit 2353a64ce9
16 changed files with 518 additions and 538 deletions

16
.travis.yml
View file

@ -7,10 +7,12 @@ before_script:
- export PATH=$HOME/.cargo/bin:$PATH - export PATH=$HOME/.cargo/bin:$PATH
script: script:
- ( cd maud && cargo test --all-features ) - cargo test --all --all-features
- if command -v cargo-clippy > /dev/null; then ( cd maud && cargo clippy -- -D warnings ); fi - |
- ( cd maud_macros && cargo test --all-features ) if command -v cargo-clippy > /dev/null; then
# Silence `collapsible_if` warnings for now -- see https://github.com/lfairy/maud/issues/93 CLIPPY_STATUS=0
- if command -v cargo-clippy > /dev/null; then ( cd maud_macros && cargo clippy -- -D warnings -A collapsible_if ); fi for package in maud_htmlescape maud_macros maud maud_extras; do
- ( cd maud_extras && cargo test --all-features ) cargo clippy --manifest-path $package/Cargo.toml -- -D warnings || CLIPPY_STATUS=$?
- if command -v cargo-clippy > /dev/null; then ( cd maud_extras && cargo clippy -- -D warnings ); fi done
(exit $CLIPPY_STATUS)
fi

3
Cargo.toml
View file

@ -1,6 +1,7 @@
[workspace] [workspace]
members = [ members = [
"maud", "maud_htmlescape",
"maud_macros", "maud_macros",
"maud",
"maud_extras", "maud_extras",
] ]

2
maud/Cargo.toml
View file

@ -13,6 +13,8 @@ description = "Compile-time HTML templates."
categories = ["template-engine"] categories = ["template-engine"]
[dependencies] [dependencies]
maud_htmlescape = { version = "0.17.0", path = "../maud_htmlescape" }
maud_macros = { version = "0.16.3", path = "../maud_macros" }
iron = { version = "0.5.1", optional = true } iron = { version = "0.5.1", optional = true }
rocket = { version = "0.3", optional = true } rocket = { version = "0.3", optional = true }

53
maud/src/lib.rs
View file

@ -1,3 +1,4 @@
#![feature(proc_macro)]
#![feature(specialization)] #![feature(specialization)]
//! A macro for writing HTML templates. //! A macro for writing HTML templates.
@ -12,8 +13,13 @@
#[cfg(feature = "iron")] extern crate iron; #[cfg(feature = "iron")] extern crate iron;
#[cfg(feature = "rocket")] extern crate rocket; #[cfg(feature = "rocket")] extern crate rocket;
extern crate maud_htmlescape;
extern crate maud_macros;
use std::fmt::{self, Write}; use std::fmt::{self, Write};
pub use maud_macros::{html, html_debug};
/// Represents a type that can be rendered as HTML. /// Represents a type that can be rendered as HTML.
/// ///
/// If your type implements [`Display`][1], then it will implement this /// If your type implements [`Display`][1], then it will implement this
@ -116,52 +122,7 @@ impl<T: AsRef<str> + Into<String>> Into<String> for PreEscaped<T> {
} }
} }
/// An adapter that escapes HTML special characters. pub use maud_htmlescape::Escaper;
///
/// The following characters are escaped:
///
/// * `&` is escaped as `&amp;`
/// * `<` is escaped as `&lt;`
/// * `>` is escaped as `&gt;`
/// * `"` is escaped as `&quot;`
///
/// All other characters are passed through unchanged.
///
/// **Note:** In versions prior to 0.13, the single quote (`'`) was
/// escaped as well.
///
/// # Example
///
/// ```
/// # use maud::Escaper;
/// use std::fmt::Write;
/// let mut s = String::new();
/// write!(Escaper::new(&mut s), "<script>launchMissiles()</script>").unwrap();
/// assert_eq!(s, "&lt;script&gt;launchMissiles()&lt;/script&gt;");
/// ```
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 {
for b in s.bytes() {
match b {
b'&' => self.0.push_str("&amp;"),
b'<' => self.0.push_str("&lt;"),
b'>' => self.0.push_str("&gt;"),
b'"' => self.0.push_str("&quot;"),
_ => unsafe { self.0.as_mut_vec().push(b) },
}
}
Ok(())
}
}
/// The literal string `<!DOCTYPE html>`. /// The literal string `<!DOCTYPE html>`.
/// ///

5
maud_macros/tests/basic_syntax.rs → maud/tests/basic_syntax.rs
View file

@ -1,9 +1,8 @@
#![feature(plugin)] #![feature(proc_macro)]
#![plugin(maud_macros)]
extern crate maud; extern crate maud;
use maud::Markup; use maud::{Markup, html};
#[test] #[test]
fn literals() { fn literals() {

5
maud_macros/tests/control_structures.rs → maud/tests/control_structures.rs
View file

@ -1,8 +1,9 @@
#![feature(conservative_impl_trait, plugin)] #![feature(conservative_impl_trait, proc_macro)]
#![plugin(maud_macros)]
extern crate maud; extern crate maud;
use maud::html;
#[test] #[test]
fn if_expr() { fn if_expr() {
for (number, &name) in (1..4).zip(["one", "two", "three"].iter()) { for (number, &name) in (1..4).zip(["one", "two", "three"].iter()) {

5
maud_macros/tests/misc.rs → maud/tests/misc.rs
View file

@ -1,8 +1,9 @@
#![feature(plugin)] #![feature(proc_macro)]
#![plugin(maud_macros)]
extern crate maud; extern crate maud;
use maud::html;
#[test] #[test]
fn issue_13() { fn issue_13() {
let owned = String::from("yay"); let owned = String::from("yay");

5
maud_macros/tests/splices.rs → maud/tests/splices.rs
View file

@ -1,8 +1,9 @@
#![feature(plugin)] #![feature(proc_macro)]
#![plugin(maud_macros)]
extern crate maud; extern crate maud;
use maud::html;
#[test] #[test]
fn literals() { fn literals() {
let s = html!(("<pinkie>")).into_string(); let s = html!(("<pinkie>")).into_string();

1
maud_extras/Cargo.toml
View file

@ -10,7 +10,6 @@ description = "Extra bits and pieces for use in Maud templates."
[dependencies] [dependencies]
maud = { path = "../maud", features = ["iron"] } maud = { path = "../maud", features = ["iron"] }
maud_macros = { path = "../maud_macros" }
[lib] [lib]
path = "lib.rs" path = "lib.rs"

29
maud_extras/lib.rs
View file

@ -1,19 +1,18 @@
#![feature(plugin)] #![feature(proc_macro)]
#![plugin(maud_macros)]
extern crate maud; extern crate maud;
use maud::{Markup, Render}; use maud::{Markup, Render, html};
/// Links to an external stylesheet. /// Links to an external stylesheet.
/// ///
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// # #![feature(plugin)] /// # #![feature(proc_macro)]
/// # #![plugin(maud_macros)]
/// # extern crate maud; /// # extern crate maud;
/// # extern crate maud_extras; /// # extern crate maud_extras;
/// # use maud::html;
/// # use maud_extras::*; /// # use maud_extras::*;
/// # fn main() { /// # fn main() {
/// let markup = html! { (Css("styles.css")) }; /// let markup = html! { (Css("styles.css")) };
@ -36,10 +35,10 @@ impl<T: AsRef<str>> Render for Css<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// # #![feature(plugin)] /// # #![feature(proc_macro)]
/// # #![plugin(maud_macros)]
/// # extern crate maud; /// # extern crate maud;
/// # extern crate maud_extras; /// # extern crate maud_extras;
/// # use maud::html;
/// # use maud_extras::*; /// # use maud_extras::*;
/// # fn main() { /// # fn main() {
/// let markup = html! { (Js("app.js")) }; /// let markup = html! { (Js("app.js")) };
@ -62,10 +61,10 @@ impl<T: AsRef<str>> Render for Js<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// # #![feature(plugin)] /// # #![feature(proc_macro)]
/// # #![plugin(maud_macros)]
/// # extern crate maud; /// # extern crate maud;
/// # extern crate maud_extras; /// # extern crate maud_extras;
/// # use maud::html;
/// # use maud_extras::*; /// # use maud_extras::*;
/// # fn main() { /// # fn main() {
/// let markup = html! { (Meta("description", "test description")) }; /// let markup = html! { (Meta("description", "test description")) };
@ -88,10 +87,10 @@ impl<T: AsRef<str>, U: AsRef<str>> Render for Meta<T, U> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// # #![feature(plugin)] /// # #![feature(proc_macro)]
/// # #![plugin(maud_macros)]
/// # extern crate maud; /// # extern crate maud;
/// # extern crate maud_extras; /// # extern crate maud_extras;
/// # use maud::html;
/// # use maud_extras::*; /// # use maud_extras::*;
/// # fn main() { /// # fn main() {
/// let markup = html! { (Title("Maud")) }; /// let markup = html! { (Title("Maud")) };
@ -114,10 +113,10 @@ impl<T: AsRef<str>> Render for Title<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// # #![feature(plugin)] /// # #![feature(proc_macro)]
/// # #![plugin(maud_macros)]
/// # extern crate maud; /// # extern crate maud;
/// # extern crate maud_extras; /// # extern crate maud_extras;
/// # use maud::html;
/// # use maud_extras::*; /// # use maud_extras::*;
/// # fn main() { /// # fn main() {
/// let markup = html! { (Charset("utf-8")) }; /// let markup = html! { (Charset("utf-8")) };
@ -140,10 +139,10 @@ impl<T: AsRef<str>> Render for Charset<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// # #![feature(plugin)] /// # #![feature(proc_macro)]
/// # #![plugin(maud_macros)]
/// # extern crate maud; /// # extern crate maud;
/// # extern crate maud_extras; /// # extern crate maud_extras;
/// # use maud::html;
/// # use maud_extras::*; /// # use maud_extras::*;
/// # fn main() { /// # fn main() {
/// let markup = html! { (MetaProperty("og:description", "test description")) }; /// let markup = html! { (MetaProperty("og:description", "test description")) };

15
maud_htmlescape/Cargo.toml Normal file
View file

@ -0,0 +1,15 @@
[package]
name = "maud_htmlescape"
# When releasing a new version, please update html_root_url in lib.rs
version = "0.17.0"
authors = ["Chris Wong <lambda.fairy@gmail.com>"]
license = "MIT/Apache-2.0"
documentation = "https://docs.rs/maud_htmlescape/"
homepage = "https://maud.lambda.xyz/"
repository = "https://github.com/lfairy/maud"
description = "Internal support code used by Maud."
[lib]
path = "lib.rs"

68
maud_htmlescape/lib.rs Normal file
View file

@ -0,0 +1,68 @@
//! Internal support code used by the [Maud] template engine.
//!
//! You should not need to depend on this crate directly.
//!
//! [Maud]: https://maud.lambda.xyz
#![doc(html_root_url = "https://docs.rs/maud_htmlescape/0.17.0")]
use std::fmt;
/// An adapter that escapes HTML special characters.
///
/// The following characters are escaped:
///
/// * `&` is escaped as `&amp;`
/// * `<` is escaped as `&lt;`
/// * `>` is escaped as `&gt;`
/// * `"` is escaped as `&quot;`
///
/// 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 std::fmt::Write;
/// let mut s = String::new();
/// write!(Escaper::new(&mut s), "<script>launchMissiles()</script>").unwrap();
/// assert_eq!(s, "&lt;script&gt;launchMissiles()&lt;/script&gt;");
/// ```
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 {
for b in s.bytes() {
match b {
b'&' => self.0.push_str("&amp;"),
b'<' => self.0.push_str("&lt;"),
b'>' => self.0.push_str("&gt;"),
b'"' => self.0.push_str("&quot;"),
_ => unsafe { self.0.as_mut_vec().push(b) },
}
}
Ok(())
}
}
#[cfg(test)]
mod test {
use std::fmt::Write;
use Escaper;
#[test]
fn it_works() {
let mut s = String::new();
write!(Escaper::new(&mut s), "<script>launchMissiles()</script>").unwrap();
assert_eq!(s, "&lt;script&gt;launchMissiles()&lt;/script&gt;");
}
}

6
maud_macros/Cargo.toml
View file

@ -12,12 +12,12 @@ repository = "https://github.com/lfairy/maud"
description = "Compile-time HTML templates." description = "Compile-time HTML templates."
[dependencies] [dependencies]
if_chain = "0.1" literalext = { version = "0.1", default-features = false, features = ["proc-macro"] }
maud = { path = "../maud", version = "0.16.0" } maud_htmlescape = { version = "0.17.0", path = "../maud_htmlescape" }
[lib] [lib]
name = "maud_macros" name = "maud_macros"
plugin = true proc-macro = true
[badges] [badges]
travis-ci = { repository = "lfairy/maud" } travis-ci = { repository = "lfairy/maud" }

52
maud_macros/src/lib.rs
View file

@ -1,53 +1,45 @@
#![crate_type = "dylib"] #![feature(proc_macro)]
#![feature(plugin_registrar, quote)]
#![feature(slice_patterns)]
#![feature(rustc_private)]
#![recursion_limit = "1000"] // if_chain #![recursion_limit = "1000"] // if_chain
#![doc(html_root_url = "https://docs.rs/maud_macros/0.16.3")] #![doc(html_root_url = "https://docs.rs/maud_macros/0.16.3")]
#[macro_use] extern crate literalext;
extern crate if_chain; extern crate maud_htmlescape;
#[macro_use] extern crate proc_macro;
extern crate rustc;
extern crate rustc_plugin;
extern crate syntax;
extern crate maud;
use rustc_plugin::Registry; // TODO move lints into their own `maud_lints` crate
use syntax::codemap::Span; // mod lints;
use syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult};
use syntax::print::pprust;
use syntax::tokenstream::TokenTree;
mod lints;
mod parse; mod parse;
mod render; mod render;
type ParseResult<T> = Result<T, ()>; use proc_macro::TokenStream;
fn expand_html<'cx>(cx: &'cx mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'cx> { type ParseResult<T> = Result<T, String>;
match parse::parse(cx, sp, args) {
Ok(expr) => MacEager::expr(quote_expr!(cx, $expr)), #[proc_macro]
Err(..) => DummyResult::expr(sp), pub fn html(args: TokenStream) -> TokenStream {
match parse::parse(args) {
Ok(expr) => expr,
Err(e) => panic!(e),
} }
} }
fn expand_html_debug<'cx>(cx: &'cx mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'cx> { #[proc_macro]
match parse::parse(cx, sp, args) { pub fn html_debug(args: TokenStream) -> TokenStream {
match parse::parse(args) {
Ok(expr) => { Ok(expr) => {
let expr = quote_expr!(cx, $expr); println!("expansion:\n{}", expr);
cx.span_warn(sp, &format!("expansion:\n{}", expr
pprust::expr_to_string(&expr)));
MacEager::expr(expr)
}, },
Err(..) => DummyResult::expr(sp), Err(e) => panic!(e),
} }
} }
/*
#[plugin_registrar] #[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) { pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("html", expand_html); reg.register_macro("html", expand_html);
reg.register_macro("html_debug", expand_html_debug); reg.register_macro("html_debug", expand_html_debug);
lints::register_lints(reg); lints::register_lints(reg);
} }
*/

686
maud_macros/src/parse.rs
View file

@ -1,218 +1,191 @@
use proc_macro::{
Delimiter,
Literal,
Spacing,
Span,
TokenNode,
TokenStream,
TokenTree,
TokenTreeIter,
};
use std::iter;
use std::mem; use std::mem;
use syntax::ast::LitKind;
use syntax::codemap::Span; use literalext::LiteralExt;
use syntax::ext::base::ExtCtxt;
use syntax::parse;
use syntax::parse::token::{BinOpToken, DelimToken, Token};
use syntax::print::pprust;
use syntax::symbol::keywords;
use syntax::tokenstream::{Delimited, TokenStream, TokenTree};
use super::render::Renderer; use super::render::Renderer;
use super::ParseResult; use super::ParseResult;
macro_rules! at { pub fn parse(input: TokenStream) -> ParseResult<TokenStream> {
() => (TokenTree::Token(_, Token::At))
}
macro_rules! dot {
() => (TokenTree::Token(_, Token::Dot))
}
macro_rules! eq {
() => (TokenTree::Token(_, Token::Eq))
}
macro_rules! pound {
() => (TokenTree::Token(_, Token::Pound))
}
macro_rules! question {
() => (TokenTree::Token(_, Token::Question))
}
macro_rules! semi {
() => (TokenTree::Token(_, Token::Semi))
}
macro_rules! colon {
() => (TokenTree::Token(_, Token::Colon))
}
macro_rules! comma {
() => (TokenTree::Token(_, Token::Comma))
}
macro_rules! fat_arrow {
() => (TokenTree::Token(_, Token::FatArrow))
}
macro_rules! minus {
() => (TokenTree::Token(_, Token::BinOp(BinOpToken::Minus)))
}
macro_rules! slash {
() => (TokenTree::Token(_, Token::BinOp(BinOpToken::Slash)))
}
macro_rules! literal {
() => (TokenTree::Token(_, Token::Literal(..)))
}
macro_rules! ident {
($sp:pat, $x:pat) => (TokenTree::Token($sp, Token::Ident($x)))
}
macro_rules! keyword {
($sp:pat, $x:ident) => (TokenTree::Token($sp, ref $x @ Token::Ident(..)))
}
pub fn parse(cx: &ExtCtxt, sp: Span, input: &[TokenTree]) -> ParseResult<Vec<TokenTree>> {
let mut render = Renderer::new(cx);
Parser {
cx,
in_attr: false,
input: input,
span: sp,
}.markups(&mut render)?;
// Heuristic: the size of the resulting markup tends to correlate with the // Heuristic: the size of the resulting markup tends to correlate with the
// code size of the template itself // code size of the template itself
let size_hint = pprust::tts_to_string(input).len(); let size_hint = input.to_string().len();
Ok(render.into_expr(size_hint).into_trees().collect()) let mut render = Renderer::new();
Parser {
in_attr: false,
input: input.into_iter(),
}.markups(&mut render)?;
Ok(render.into_expr(size_hint))
} }
struct Parser<'cx, 'a: 'cx, 'i> { #[derive(Clone)]
cx: &'cx ExtCtxt<'a>, struct Parser {
in_attr: bool, in_attr: bool,
input: &'i [TokenTree], input: TokenTreeIter,
span: Span,
} }
impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> { impl Iterator for Parser {
/// Consumes `n` items from the input. type Item = TokenTree;
fn shift(&mut self, n: usize) {
self.input = &self.input[n..]; fn next(&mut self) -> Option<TokenTree> {
self.input.next()
}
}
impl Parser {
fn peek(&mut self) -> Option<TokenTree> {
self.clone().next()
} }
/// Attaches an error message to the span and returns `Err`. fn peek2(&mut self) -> Option<(TokenTree, Option<TokenTree>)> {
fn error<T>(&self, span: Span, message: &str) -> ParseResult<T> { let mut clone = self.clone();
self.cx.span_err(span, message); clone.next().map(|first| (first, clone.next()))
Err(()) }
fn advance(&mut self) {
self.next();
}
fn advance2(&mut self) {
self.next();
self.next();
}
fn commit(&mut self, attempt: Parser) {
*self = attempt;
}
/// Returns an `Err` with the given message.
fn error<T, E: Into<String>>(&self, message: E) -> ParseResult<T> {
Err(message.into())
} }
/// Parses and renders multiple blocks of markup. /// Parses and renders multiple blocks of markup.
fn markups(&mut self, render: &mut Renderer) -> ParseResult<()> { fn markups(&mut self, render: &mut Renderer) -> ParseResult<()> {
loop { loop {
match *self.input { match self.peek() {
[] => return Ok(()), None => return Ok(()),
[semi!(), ..] => self.shift(1), Some(TokenTree { kind: TokenNode::Op(';', _), .. }) => self.advance(),
[_, ..] => self.markup(render)?, _ => self.markup(render)?,
} }
} }
} }
/// Parses and renders a single block of markup. /// Parses and renders a single block of markup.
fn markup(&mut self, render: &mut Renderer) -> ParseResult<()> { fn markup(&mut self, render: &mut Renderer) -> ParseResult<()> {
match *self.input { let token = match self.peek() {
Some(token) => token,
None => return self.error("unexpected end of input"),
};
match token {
// Literal // Literal
[ref tt @ literal!(), ..] => { TokenTree { kind: TokenNode::Literal(lit), .. } => {
self.shift(1); self.advance();
self.literal(tt, render)?; self.literal(lit, render)?;
}, },
// If // Special form
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::If) => { TokenTree { kind: TokenNode::Op('@', _), .. } => {
self.shift(2); self.advance();
self.if_expr(sp, render)?; match self.next() {
}, Some(TokenTree { kind: TokenNode::Term(term), .. }) => match term.as_str() {
// While "if" => self.if_expr(render)?,
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::While) => { "while" => self.while_expr(render)?,
self.shift(2); "for" => self.for_expr(render)?,
self.while_expr(sp, render)?; "match" => self.match_expr(render)?,
}, "let" => self.let_expr(render)?,
// For other => return self.error(format!("unknown keyword `@{}`", other)),
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::For) => { },
self.shift(2); _ => return self.error("expected keyword after `@`"),
self.for_expr(sp, render)?; }
},
// Match
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::Match) => {
self.shift(2);
self.match_expr(sp, render)?;
},
// Let
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::Let) => {
self.shift(2);
self.let_expr(sp, render)?;
} }
// Element // Element
[ident!(sp, _), ..] => { TokenTree { kind: TokenNode::Term(_), .. } => {
let name = self.namespaced_name().unwrap(); let name = self.namespaced_name()?;
self.element(sp, &name, render)?; self.element(&name, render)?;
}, },
// Splice // Splice
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Paren => { TokenTree { kind: TokenNode::Group(Delimiter::Parenthesis, expr), .. } => {
self.shift(1); self.advance();
render.splice(d.stream()); render.splice(expr);
} }
// Block // Block
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. } => {
self.shift(1); self.advance();
Parser { Parser {
cx: self.cx,
in_attr: self.in_attr, in_attr: self.in_attr,
input: &d.stream().into_trees().collect::<Vec<_>>(), input: block.into_iter(),
span: sp,
}.markups(render)?; }.markups(render)?;
}, },
// ??? // ???
_ => { _ => return self.error("invalid syntax"),
if let [ref tt, ..] = *self.input {
return self.error(tt.span(), "invalid syntax");
} else {
return self.error(self.span, "unexpected end of block");
}
},
} }
Ok(()) Ok(())
} }
/// Parses and renders a literal string. /// Parses and renders a literal string.
fn literal(&mut self, tt: &TokenTree, render: &mut Renderer) -> ParseResult<()> { fn literal(&mut self, lit: Literal, render: &mut Renderer) -> ParseResult<()> {
let mut rust_parser = parse::stream_to_parser(self.cx.parse_sess, tt.clone().into()); if let Some(s) = lit.parse_string() {
let lit = rust_parser.parse_lit().map_err(|mut e| e.emit())?; render.string(&s);
if let LitKind::Str(s, _) = lit.node {
render.string(&s.as_str());
Ok(()) Ok(())
} else { } else {
return self.error(lit.span, "literal strings must be surrounded by quotes (\"like this\")") self.error("expected string")
} }
} }
/// Parses and renders an `@if` expression. /// Parses and renders an `@if` expression.
/// ///
/// The leading `@if` should already be consumed. /// The leading `@if` should already be consumed.
fn if_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> { fn if_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
// Parse the initial if let mut if_cond = Vec::new();
let mut if_cond = vec![]; let if_body = loop {
let if_body; match self.next() {
loop { match *self.input { Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. }) => {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { break self.block(block, render)?;
self.shift(1); },
if_body = self.block(sp, d.stream(), render)?; Some(token) => if_cond.push(token),
break; None => return self.error("unexpected end of @if expression"),
}, }
[ref tt, ..] => { };
self.shift(1); let else_body = match self.peek2() {
if_cond.push(tt.clone()); // Try to match an `@else` after this
}, Some((
[] => return self.error(sp, "expected body for this @if"), TokenTree { kind: TokenNode::Op('@', _), .. },
}} Some(TokenTree { kind: TokenNode::Term(else_keyword), .. }),
// Parse the (optional) @else )) if else_keyword.as_str() == "else" => {
let else_body = match *self.input { self.advance2();
[at!(), keyword!(_, k), ..] if k.is_keyword(keywords::Else) => { match self.peek() {
self.shift(2); // `@else if`
match *self.input { Some(TokenTree { kind: TokenNode::Term(if_keyword), .. })
[keyword!(sp, k), ..] if k.is_keyword(keywords::If) => { if if_keyword.as_str() == "if" => {
self.shift(1); self.advance();
let mut render = render.fork(); let mut render = render.fork();
self.if_expr(sp, &mut render)?; self.if_expr(&mut render)?;
Some(render.into_stmts()) Some(render.into_stmts())
}, },
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { // Just an `@else`
self.shift(1); _ => {
Some(self.block(sp, d.stream(), render)?) if let Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. }) = self.next() {
Some(self.block(block, render)?)
} else {
return self.error("expected body for @else");
}
}, },
_ => return self.error(sp, "expected body for this @else"),
} }
}, },
_ => None, _ => {
// We didn't find an `@else`; backtrack
None
},
}; };
render.emit_if(if_cond.into_iter().collect(), if_body, else_body); render.emit_if(if_cond.into_iter().collect(), if_body, else_body);
Ok(()) Ok(())
@ -221,21 +194,17 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders an `@while` expression. /// Parses and renders an `@while` expression.
/// ///
/// The leading `@while` should already be consumed. /// The leading `@while` should already be consumed.
fn while_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> { fn while_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
let mut cond = vec![]; let mut cond = Vec::new();
let body; let body = loop {
loop { match *self.input { match self.next() {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. }) => {
self.shift(1); break self.block(block, render)?;
body = self.block(sp, d.stream(), render)?; },
break; Some(token) => cond.push(token),
}, None => return self.error("unexpected end of @while expression"),
[ref tt, ..] => { }
self.shift(1); };
cond.push(tt.clone());
},
[] => return self.error(sp, "expected body for this @while"),
}}
render.emit_while(cond.into_iter().collect(), body); render.emit_while(cond.into_iter().collect(), body);
Ok(()) Ok(())
} }
@ -243,173 +212,169 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders a `@for` expression. /// Parses and renders a `@for` expression.
/// ///
/// The leading `@for` should already be consumed. /// The leading `@for` should already be consumed.
fn for_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> { fn for_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
let mut pattern = vec![]; let mut pat = Vec::new();
loop { match *self.input { loop {
[keyword!(_, k), ..] if k.is_keyword(keywords::In) => { match self.next() {
self.shift(1); Some(TokenTree { kind: TokenNode::Term(in_keyword), .. }) if in_keyword.as_str() == "in" => break,
break; Some(token) => pat.push(token),
}, None => return self.error("unexpected end of @for expression"),
[ref tt, ..] => { }
self.shift(1); }
pattern.push(tt.clone()); let mut expr = Vec::new();
}, let body = loop {
_ => return self.error(sp, "invalid @for"), match self.next() {
}} Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. }) => {
let mut iterable = vec![]; break self.block(block, render)?;
let body; },
loop { match *self.input { Some(token) => expr.push(token),
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { None => return self.error("unexpected end of @for expression"),
self.shift(1); }
body = self.block(sp, d.stream(), render)?; };
break; render.emit_for(pat.into_iter().collect(), expr.into_iter().collect(), body);
},
[ref tt, ..] => {
self.shift(1);
iterable.push(tt.clone());
},
_ => return self.error(sp, "invalid @for"),
}}
render.emit_for(pattern.into_iter().collect(), iterable.into_iter().collect(), body);
Ok(()) Ok(())
} }
/// Parses and renders a `@match` expression. /// Parses and renders a `@match` expression.
/// ///
/// The leading `@match` should already be consumed. /// The leading `@match` should already be consumed.
fn match_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> { fn match_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
// Parse the initial match let mut head = Vec::new();
let mut match_var = vec![]; let body = loop {
let match_bodies; match self.next() {
loop { match *self.input { Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, body), .. }) => {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { let mut parse = Parser {
self.shift(1); in_attr: self.in_attr,
match_bodies = Parser { input: body.into_iter(),
cx: self.cx, };
in_attr: self.in_attr, break parse.match_arms(render)?;
input: &d.stream().into_trees().collect::<Vec<_>>(), },
span: sp, Some(token) => head.push(token),
}.match_bodies(render)?; None => return self.error("unexpected end of @match expression"),
break; }
}, };
[ref tt, ..] => { render.emit_match(head.into_iter().collect(), body);
self.shift(1);
match_var.push(tt.clone());
},
[] => return self.error(sp, "expected body for this @match"),
}}
render.emit_match(match_var.into_iter().collect(), match_bodies.into_iter().collect());
Ok(()) Ok(())
} }
fn match_bodies(&mut self, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> { fn match_arms(&mut self, render: &mut Renderer) -> ParseResult<TokenStream> {
let mut bodies = Vec::new(); let mut arms = Vec::new();
loop { match *self.input { while let Some(arm) = self.match_arm(render)? {
[] => break, arms.push(arm);
[ref tt @ comma!(), ..] => { }
self.shift(1); Ok(arms.into_iter().collect())
bodies.push(tt.clone());
},
[ref tt, ..] => bodies.append(&mut self.match_body(tt.span(), render)?),
}}
Ok(bodies)
} }
fn match_body(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> { fn match_arm(&mut self, render: &mut Renderer) -> ParseResult<Option<TokenStream>> {
let mut body = vec![]; let mut pat = Vec::new();
loop { match *self.input { loop {
[ref tt @ fat_arrow!(), ..] => { match self.peek2() {
self.shift(1); Some((
body.push(tt.clone()); eq @ TokenTree { kind: TokenNode::Op('=', Spacing::Joint), .. },
break; Some(gt @ TokenTree { kind: TokenNode::Op('>', _), .. }),
}, )) => {
[ref tt, ..] => { self.advance2();
self.shift(1); pat.push(eq);
body.push(tt.clone()); pat.push(gt);
},
_ => return self.error(sp, "invalid @match pattern"),
}}
let mut expr = Vec::new();
loop { match *self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
if expr.is_empty() {
self.shift(1);
expr = self.block(sp, d.stream(), render)?.into_trees().collect();
break; break;
} else { },
self.shift(1); Some((token, _)) => {
expr.push(TokenTree::Delimited(sp, d.clone())); self.advance();
pat.push(token);
},
None =>
if pat.is_empty() {
return Ok(None);
} else {
return self.error("unexpected end of @match pattern");
},
}
}
let body = match self.next() {
// $pat => { $stmts }
Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, body), span }) => {
let body = self.block(body, render)?;
// Trailing commas are optional if the match arm is a braced block
if let Some(TokenTree { kind: TokenNode::Op(',', _), .. }) = self.peek() {
self.advance();
}
// Re-use the span from the original block
TokenTree {
kind: TokenNode::Group(Delimiter::Brace, body),
span,
} }
}, },
[comma!(), ..] | [] => { // $pat => $expr
if expr.is_empty() { Some(first_token) => {
return self.error(sp, "expected body for this @match arm"); let mut body = vec![first_token];
} else { loop {
expr = self.block(sp, expr.into_iter().collect(), render)?.into_trees().collect(); match self.next() {
break; Some(TokenTree { kind: TokenNode::Op(',', _), .. }) => break,
Some(token) => {
body.push(token);
},
None => return self.error("unexpected end of @match arm"),
}
}
let body = self.block(body.into_iter().collect(), render)?;
// The generated code may have multiple statements, unlike the
// original expression. So wrap the whole thing in a block just
// in case.
TokenTree {
kind: TokenNode::Group(Delimiter::Brace, body),
span: Span::default(),
} }
}, },
[ref tt, ..] => { None => return self.error("unexpected end of @match arm"),
self.shift(1); };
expr.push(tt.clone()); Ok(Some(pat.into_iter().chain(iter::once(body)).collect()))
},
}}
body.push(TokenTree::Delimited(sp, Delimited {
delim: DelimToken::Brace,
tts: expr.into_iter().collect::<TokenStream>().into(),
}));
Ok(body)
} }
/// Parses and renders a `@let` expression. /// Parses and renders a `@let` expression.
/// ///
/// The leading `@let` should already be consumed. /// The leading `@let` should already be consumed.
fn let_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> { fn let_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
let mut pattern = vec![]; let mut pat = Vec::new();
loop { match *self.input { loop {
[eq!(), ..] => { match self.next() {
self.shift(1); Some(TokenTree { kind: TokenNode::Op('=', _), .. }) => break,
break; Some(token) => pat.push(token),
}, None => return self.error("unexpected end of @let expression"),
[ref tt, ..] => { }
self.shift(1); }
pattern.push(tt.clone()); let mut expr = Vec::new();
}, let body = loop {
_ => return self.error(sp, "invalid @let"), match self.next() {
}} Some(TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. }) => {
let mut rhs = vec![]; break self.block(block, render)?;
let body; },
loop { match *self.input { Some(token) => expr.push(token),
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { None => return self.error("unexpected end of @let expression"),
self.shift(1); }
body = self.block(sp, d.stream(), render)?; };
break; render.emit_let(pat.into_iter().collect(), expr.into_iter().collect(), body);
},
[ref tt, ..] => {
self.shift(1);
rhs.push(tt.clone());
},
_ => return self.error(sp, "invalid @let"),
}}
render.emit_let(pattern.into_iter().collect(), rhs.into_iter().collect(), body);
Ok(()) Ok(())
} }
/// Parses and renders an element node. /// Parses and renders an element node.
/// ///
/// The element name should already be consumed. /// The element name should already be consumed.
fn element(&mut self, sp: Span, name: &str, render: &mut Renderer) -> ParseResult<()> { fn element(&mut self, name: &str, render: &mut Renderer) -> ParseResult<()> {
if self.in_attr { if self.in_attr {
return self.error(sp, "unexpected element, you silly bumpkin"); return self.error("unexpected element, you silly bumpkin");
} }
render.element_open_start(name); render.element_open_start(name);
self.attrs(render)?; self.attrs(render)?;
render.element_open_end(); render.element_open_end();
if let [slash!(), ..] = *self.input { match self.peek() {
self.shift(1); Some(TokenTree { kind: TokenNode::Op('/', _), .. }) => {
} else { // Void element
self.markup(render)?; self.advance();
render.element_close(name); },
_ => {
self.markup(render)?;
render.element_close(name);
},
} }
Ok(()) Ok(())
} }
@ -420,30 +385,29 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
let mut classes_toggled = Vec::new(); let mut classes_toggled = Vec::new();
let mut ids = Vec::new(); let mut ids = Vec::new();
loop { loop {
let old_input = self.input; let mut attempt = self.clone();
let maybe_name = self.namespaced_name(); let maybe_name = attempt.namespaced_name();
match (maybe_name, self.input) { let token_after = attempt.next();
(Ok(name), &[eq!(), ..]) => { match (maybe_name, token_after) {
// Non-empty attribute // Non-empty attribute
self.shift(1); (Ok(name), Some(TokenTree { kind: TokenNode::Op('=', _), .. })) => {
self.commit(attempt);
render.attribute_start(&name); render.attribute_start(&name);
{ {
// Parse a value under an attribute context // Parse a value under an attribute context
let mut in_attr = true; let in_attr = mem::replace(&mut self.in_attr, true);
mem::swap(&mut self.in_attr, &mut in_attr);
self.markup(render)?; self.markup(render)?;
mem::swap(&mut self.in_attr, &mut in_attr); self.in_attr = in_attr;
} }
render.attribute_end(); render.attribute_end();
}, },
(Ok(name), &[question!(), ..]) => { // Empty attribute
// Empty attribute (Ok(name), Some(TokenTree { kind: TokenNode::Op('?', _), .. })) => {
self.shift(1); self.commit(attempt);
match *self.input { match self.peek() {
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => { // Toggle the attribute based on a boolean expression
// Toggle the attribute based on a boolean expression Some(TokenTree { kind: TokenNode::Group(Delimiter::Bracket, cond), .. }) => {
self.shift(1); self.advance();
let cond = d.stream();
let body = { let body = {
let mut render = render.fork(); let mut render = render.fork();
render.attribute_empty(&name); render.attribute_empty(&name);
@ -451,36 +415,31 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}; };
render.emit_if(cond, body, None); render.emit_if(cond, body, None);
}, },
_ => { // Write the attribute unconditionally
// Write the attribute unconditionally _ => render.attribute_empty(&name),
render.attribute_empty(&name);
},
} }
}, },
(Err(_), &[dot!(), ident!(_, _), ..]) => { // Class shorthand
// Class shorthand (Err(_), Some(TokenTree { kind: TokenNode::Op('.', _), .. })) => {
self.shift(1); self.commit(attempt);
let class_name = self.name().unwrap(); let class_name = self.name()?;
match *self.input { match self.peek() {
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => { // Toggle the class based on a boolean expression
// Toggle the class based on a boolean expression Some(TokenTree { kind: TokenNode::Group(Delimiter::Bracket, cond), .. }) => {
self.shift(1); self.advance();
let cond = d.stream();
classes_toggled.push((cond, class_name)); classes_toggled.push((cond, class_name));
}, },
// Emit the class unconditionally // Emit the class unconditionally
_ => classes_static.push(class_name), _ => classes_static.push(class_name),
} }
}, },
(Err(_), &[pound!(), ident!(_, _), ..]) => { // ID shorthand
// ID shorthand (Err(_), Some(TokenTree { kind: TokenNode::Op('#', _), .. })) => {
self.shift(1); self.commit(attempt);
ids.push(self.name().unwrap()); ids.push(self.name()?);
},
_ => {
self.input = old_input;
break;
}, },
// If it's not a valid attribute, backtrack and bail out
_ => break,
} }
} }
if !classes_static.is_empty() || !classes_toggled.is_empty() { if !classes_static.is_empty() || !classes_toggled.is_empty() {
@ -511,24 +470,23 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses an identifier, without dealing with namespaces. /// Parses an identifier, without dealing with namespaces.
fn name(&mut self) -> ParseResult<String> { fn name(&mut self) -> ParseResult<String> {
let mut s = match *self.input { let mut s = if let Some(TokenTree { kind: TokenNode::Term(term), .. }) = self.peek() {
[ident!(_, name), ..] => { self.advance();
self.shift(1); String::from(term.as_str())
String::from(&name.name.as_str() as &str) } else {
}, return self.error("expected identifier");
_ => return Err(()),
}; };
let mut expect_ident = false; let mut expect_ident = false;
loop { loop {
expect_ident = match *self.input { expect_ident = match self.peek() {
[minus!(), ..] => { Some(TokenTree { kind: TokenNode::Op('-', _), .. }) => {
self.shift(1); self.advance();
s.push('-'); s.push('-');
true true
}, },
[ident!(_, name), ..] if expect_ident => { Some(TokenTree { kind: TokenNode::Term(term), .. }) if expect_ident => {
self.shift(1); self.advance();
s.push_str(&name.name.as_str()); s.push_str(term.as_str());
false false
}, },
_ => break, _ => break,
@ -541,22 +499,20 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// if necessary. /// if necessary.
fn namespaced_name(&mut self) -> ParseResult<String> { fn namespaced_name(&mut self) -> ParseResult<String> {
let mut s = self.name()?; let mut s = self.name()?;
if let [colon!(), ident!(_, _), ..] = *self.input { if let Some(TokenTree { kind: TokenNode::Op(':', _), .. }) = self.peek() {
self.shift(1); self.advance();
s.push(':'); s.push(':');
s.push_str(&self.name().unwrap()); s.push_str(&self.name()?);
} }
Ok(s) Ok(s)
} }
/// Parses the given token tree, returning a vector of statements. /// Parses the given token tree, returning a vector of statements.
fn block(&mut self, sp: Span, tts: TokenStream, render: &mut Renderer) -> ParseResult<TokenStream> { fn block(&mut self, body: TokenStream, render: &mut Renderer) -> ParseResult<TokenStream> {
let mut render = render.fork(); let mut render = render.fork();
let mut parse = Parser { let mut parse = Parser {
cx: self.cx,
in_attr: self.in_attr, in_attr: self.in_attr,
input: &tts.into_trees().collect::<Vec<_>>(), input: body.into_iter(),
span: sp,
}; };
parse.markups(&mut render)?; parse.markups(&mut render)?;
Ok(render.into_stmts()) Ok(render.into_stmts())

105
maud_macros/src/render.rs
View file

@ -1,38 +1,29 @@
use syntax::ast::Ident; use proc_macro::{Literal, Term, TokenNode, TokenStream};
use syntax::ext::base::ExtCtxt; use proc_macro::quote;
use syntax::symbol::Symbol;
use syntax::tokenstream::{TokenStream, TokenTree};
use maud::Escaper; use maud_htmlescape::Escaper;
// FIXME(rust-lang/rust#40939): pub struct Renderer {
// * Use `TokenStreamBuilder` instead of `Vec<TokenStream>` output: TokenNode,
// * Use `quote!()` instead of `quote_tokens!()`
pub struct Renderer<'cx, 'a: 'cx> {
cx: &'cx ExtCtxt<'a>,
writer: Ident,
stmts: Vec<TokenStream>, stmts: Vec<TokenStream>,
tail: String, tail: String,
} }
impl<'cx, 'a> Renderer<'cx, 'a> { impl Renderer {
/// Creates a new `Renderer` using the given extension context. /// Creates a new `Renderer`.
pub fn new(cx: &'cx ExtCtxt<'a>) -> Renderer<'cx, 'a> { pub fn new() -> Renderer {
let writer = Ident::with_empty_ctxt(Symbol::gensym("__maud_output")); let output = TokenNode::Term(Term::intern("__maud_output"));
Renderer { Renderer {
cx: cx, output: output,
writer: writer,
stmts: Vec::new(), stmts: Vec::new(),
tail: String::new(), tail: String::new(),
} }
} }
/// Creates a new `Renderer` under the same context as `self`. /// Creates a new `Renderer` under the same context as `self`.
pub fn fork(&self) -> Renderer<'cx, 'a> { pub fn fork(&self) -> Renderer {
Renderer { Renderer {
cx: self.cx, output: self.output.clone(),
writer: self.writer,
stmts: Vec::new(), stmts: Vec::new(),
tail: String::new(), tail: String::new(),
} }
@ -42,36 +33,38 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
fn flush(&mut self) { fn flush(&mut self) {
if !self.tail.is_empty() { if !self.tail.is_empty() {
let expr = { let expr = {
let w = self.writer; let output = self.output.clone();
let s = &*self.tail; let string = TokenNode::Literal(Literal::string(&self.tail));
quote_tokens!(self.cx, $w.push_str($s);) quote!($output.push_str($string);)
}; };
self.stmts.push(expr.into_iter().collect()); self.stmts.push(expr);
self.tail.clear(); self.tail.clear();
} }
} }
/// Reifies the `Renderer` into a block of markup. /// Reifies the `Renderer` into a block of markup.
pub fn into_expr(mut self, size_hint: usize) -> TokenStream { pub fn into_expr(mut self, size_hint: usize) -> TokenStream {
let Renderer { cx, writer, stmts, .. } = { self.flush(); self }; let Renderer { output, stmts, .. } = { self.flush(); self };
let stmts: Vec<TokenTree> = TokenStream::concat(stmts).into_trees().collect(); let size_hint = TokenNode::Literal(Literal::u64(size_hint as u64));
quote_tokens!(cx, { let stmts = stmts.into_iter().collect::<TokenStream>();
let mut $writer = ::std::string::String::with_capacity($size_hint); quote!({
extern crate maud;
let mut $output = String::with_capacity($size_hint as usize);
$stmts $stmts
::maud::PreEscaped($writer) maud::PreEscaped($output)
}).into_iter().collect() })
} }
/// Reifies the `Renderer` into a raw list of statements. /// Reifies the `Renderer` into a raw list of statements.
pub fn into_stmts(mut self) -> TokenStream { pub fn into_stmts(mut self) -> TokenStream {
let Renderer { stmts, .. } = { self.flush(); self }; let Renderer { stmts, .. } = { self.flush(); self };
TokenStream::concat(stmts) stmts.into_iter().collect()
} }
/// Pushes a statement, flushing the tail buffer in the process. /// Pushes a statement, flushing the tail buffer in the process.
fn push<T>(&mut self, stmt: T) where T: IntoIterator<Item=TokenTree> { fn push<T>(&mut self, stmt: T) where T: Into<TokenStream> {
self.flush(); self.flush();
self.stmts.push(stmt.into_iter().collect()) self.stmts.push(stmt.into())
} }
/// Pushes a literal string to the tail buffer. /// Pushes a literal string to the tail buffer.
@ -86,12 +79,17 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
/// Appends the result of an expression. /// Appends the result of an expression.
pub fn splice(&mut self, expr: TokenStream) { pub fn splice(&mut self, expr: TokenStream) {
let w = self.writer; let output = self.output.clone();
let expr: Vec<TokenTree> = expr.into_trees().collect(); self.push(quote!({
self.push(quote_tokens!(self.cx, { extern crate maud;
#[allow(unused_imports)] // Create a local trait alias so that autoref works
use ::maud::Render as __maud_Render; trait Render: maud::Render {
$expr.render_to(&mut $w); fn render_to(&self, output: &mut String) {
maud::Render::render_to(self, output);
}
}
impl<T: maud::Render> Render for T {}
$expr.render_to(&mut $output);
})); }));
} }
@ -131,14 +129,9 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
/// need to special-case `if let`. /// need to special-case `if let`.
pub fn emit_if(&mut self, if_cond: TokenStream, if_body: TokenStream, pub fn emit_if(&mut self, if_cond: TokenStream, if_body: TokenStream,
else_body: Option<TokenStream>) { else_body: Option<TokenStream>) {
let if_cond: Vec<TokenTree> = if_cond.into_trees().collect();
let if_body: Vec<TokenTree> = if_body.into_trees().collect();
let stmt = match else_body { let stmt = match else_body {
None => quote_tokens!(self.cx, if $if_cond { $if_body }), None => quote!(if $if_cond { $if_body }),
Some(else_body) => { Some(else_body) => quote!(if $if_cond { $if_body } else { $else_body }),
let else_body: Vec<TokenTree> = else_body.into_trees().collect();
quote_tokens!(self.cx, if $if_cond { $if_body } else { $else_body })
},
}; };
self.push(stmt); self.push(stmt);
} }
@ -148,32 +141,22 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
/// The condition is a token tree (not an expression) so we don't /// The condition is a token tree (not an expression) so we don't
/// need to special-case `while let`. /// need to special-case `while let`.
pub fn emit_while(&mut self, cond: TokenStream, body: TokenStream) { pub fn emit_while(&mut self, cond: TokenStream, body: TokenStream) {
let cond: Vec<TokenTree> = cond.into_trees().collect(); let stmt = quote!(while $cond { $body });
let body: Vec<TokenTree> = body.into_trees().collect();
let stmt = quote_tokens!(self.cx, while $cond { $body });
self.push(stmt); self.push(stmt);
} }
pub fn emit_for(&mut self, pattern: TokenStream, iterable: TokenStream, body: TokenStream) { pub fn emit_for(&mut self, pattern: TokenStream, iterable: TokenStream, body: TokenStream) {
let pattern: Vec<TokenTree> = pattern.into_trees().collect(); let stmt = quote!(for $pattern in $iterable { $body });
let iterable: Vec<TokenTree> = iterable.into_trees().collect();
let body: Vec<TokenTree> = body.into_trees().collect();
let stmt = quote_tokens!(self.cx, for $pattern in $iterable { $body });
self.push(stmt); self.push(stmt);
} }
pub fn emit_match(&mut self, match_var: TokenStream, match_body: TokenStream) { pub fn emit_match(&mut self, match_var: TokenStream, match_body: TokenStream) {
let match_var: Vec<TokenTree> = match_var.into_trees().collect(); let stmt = quote!(match $match_var { $match_body });
let match_body: Vec<TokenTree> = match_body.into_trees().collect();
let stmt = quote_tokens!(self.cx, match $match_var { $match_body });
self.push(stmt); self.push(stmt);
} }
pub fn emit_let(&mut self, pattern: TokenStream, rhs: TokenStream, body: TokenStream) { pub fn emit_let(&mut self, pattern: TokenStream, rhs: TokenStream, body: TokenStream) {
let pattern: Vec<TokenTree> = pattern.into_trees().collect(); let stmt = quote!({ let $pattern = $rhs; $body });
let rhs: Vec<TokenTree> = rhs.into_trees().collect();
let body: Vec<TokenTree> = body.into_trees().collect();
let stmt = quote_tokens!(self.cx, { let $pattern = $rhs; $body });
self.push(stmt); self.push(stmt);
} }
} }