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

Initial stab at porting to new proc macro interface

Browse source
This commit is contained in:
Chris Wong 2017-07-07 22:59:20 +12:00
parent 7ac9c04f0e
commit e0c7fcf055
10 changed files with 300 additions and 487 deletions

1
maud/Cargo.toml
View file

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

5
maud/src/lib.rs
View file

@ -1,3 +1,4 @@
#![feature(proc_macro)]
#![feature(specialization)]
//! A macro for writing HTML templates.
@ -12,8 +13,12 @@
#[cfg(feature = "iron")] extern crate iron;
#[cfg(feature = "rocket")] extern crate rocket;
extern crate maud_macros;
use std::fmt::{self, Write};
pub use maud_macros::{html, html_debug};
/// Represents a type that can be rendered as HTML.
///
/// If your type implements [`Display`][1], then it will implement this

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

@ -1,9 +1,8 @@
#![feature(plugin)]
#![plugin(maud_macros)]
#![feature(proc_macro)]
extern crate maud;
use maud::Markup;
use maud::{Markup, html};
#[test]
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)]
#![plugin(maud_macros)]
#![feature(conservative_impl_trait, proc_macro)]
extern crate maud;
use maud::html;
#[test]
fn if_expr() {
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)]
#![plugin(maud_macros)]
#![feature(proc_macro)]
extern crate maud;
use maud::html;
#[test]
fn issue_13() {
let owned = String::from("yay");

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

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

4
maud_macros/Cargo.toml
View file

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

49
maud_macros/src/lib.rs
View file

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

577
maud_macros/src/parse.rs
View file

@ -1,484 +1,246 @@
use proc_macro::{Delimiter, Literal, TokenNode, TokenStream, TokenTree, TokenTreeIter};
use std::mem;
use syntax::ast::LitKind;
use syntax::codemap::Span;
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 literalext::LiteralExt;
use super::render::Renderer;
use super::ParseResult;
macro_rules! at {
() => (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,
pub fn parse(input: TokenStream) -> ParseResult<TokenStream> {
let mut render = Renderer::new();
let _ = Parser {
in_attr: false,
input: input,
span: sp,
input: Lookahead::new(input.clone()),
}.markups(&mut render);
/*
Parser {
in_attr: false,
input: Lookahead::new(input.clone()),
}.markups(&mut render)?;
*/
// Heuristic: the size of the resulting markup tends to correlate with the
// code size of the template itself
let size_hint = pprust::tts_to_string(input).len();
Ok(render.into_expr(size_hint).into_trees().collect())
let size_hint = input.to_string().len();
Ok(render.into_expr(size_hint))
}
struct Parser<'cx, 'a: 'cx, 'i> {
cx: &'cx ExtCtxt<'a>,
struct Parser {
in_attr: bool,
input: &'i [TokenTree],
span: Span,
input: Lookahead<TokenTree>,
}
impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Consumes `n` items from the input.
fn shift(&mut self, n: usize) {
self.input = &self.input[n..];
impl Parser {
fn next(&mut self) -> Option<TokenNode> {
self.input.next().map(|tt| tt.kind)
}
fn peek(&mut self) -> Option<TokenNode> {
self.input.peek().map(|tt| tt.kind)
}
fn advance(&mut self) {
self.next();
}
/// Attaches an error message to the span and returns `Err`.
fn error<T>(&self, span: Span, message: &str) -> ParseResult<T> {
self.cx.span_err(span, message);
Err(())
fn error<T, E: Into<String>>(&self, message: E) -> ParseResult<T> {
Err(message.into())
}
/// Parses and renders multiple blocks of markup.
fn markups(&mut self, render: &mut Renderer) -> ParseResult<()> {
loop {
match *self.input {
[] => return Ok(()),
[semi!(), ..] => self.shift(1),
[_, ..] => self.markup(render)?,
match self.peek() {
None => return Ok(()),
Some(TokenNode::Op(';', _)) => self.advance(),
_ => self.markup(render)?,
}
}
}
/// Parses and renders a single block of markup.
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
[ref tt @ literal!(), ..] => {
self.shift(1);
self.literal(tt, render)?;
TokenNode::Literal(lit) => {
self.advance();
self.literal(lit, render)?;
},
// If
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::If) => {
self.shift(2);
self.if_expr(sp, render)?;
},
// While
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::While) => {
self.shift(2);
self.while_expr(sp, render)?;
},
// For
[at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::For) => {
self.shift(2);
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)?;
// Special form
TokenNode::Op('@', _) => {
self.advance();
match self.next() {
Some(TokenNode::Term(term)) => match term.as_str() {
"if" => self.if_expr(render)?,
"while" => self.while_expr(render)?,
"for" => self.for_expr(render)?,
"match" => self.match_expr(render)?,
"let" => self.let_expr(render)?,
other => return self.error(format!("unknown keyword `@{}`", other)),
},
_ => return self.error("expected keyword after `@`"),
}
}
// Element
[ident!(sp, _), ..] => {
let name = self.namespaced_name().unwrap();
self.element(sp, &name, render)?;
TokenNode::Term(_) => {
let name = self.namespaced_name()?;
self.element(&name, render)?;
},
// Splice
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Paren => {
self.shift(1);
render.splice(d.stream());
TokenNode::Group(Delimiter::Parenthesis, expr) => {
self.advance();
render.splice(expr);
}
// Block
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
TokenNode::Group(Delimiter::Brace, block) => {
self.advance();
Parser {
cx: self.cx,
in_attr: self.in_attr,
input: &d.stream().into_trees().collect::<Vec<_>>(),
span: sp,
input: Lookahead::new(block),
}.markups(render)?;
},
// ???
_ => {
if let [ref tt, ..] = *self.input {
return self.error(tt.span(), "invalid syntax");
} else {
return self.error(self.span, "unexpected end of block");
}
},
_ => return self.error("invalid syntax"),
}
Ok(())
}
/// Parses and renders a literal string.
fn literal(&mut self, tt: &TokenTree, render: &mut Renderer) -> ParseResult<()> {
let mut rust_parser = parse::stream_to_parser(self.cx.parse_sess, tt.clone().into());
let lit = rust_parser.parse_lit().map_err(|mut e| e.emit())?;
if let LitKind::Str(s, _) = lit.node {
render.string(&s.as_str());
fn literal(&mut self, lit: Literal, render: &mut Renderer) -> ParseResult<()> {
if let Some(s) = lit.parse_string() {
render.string(&s);
Ok(())
} 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.
///
/// The leading `@if` should already be consumed.
fn if_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
// Parse the initial if
let mut if_cond = vec![];
let if_body;
loop { match *self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
if_body = self.block(sp, d.stream(), render)?;
break;
},
[ref tt, ..] => {
self.shift(1);
if_cond.push(tt.clone());
},
[] => return self.error(sp, "expected body for this @if"),
}}
// Parse the (optional) @else
let else_body = match *self.input {
[at!(), keyword!(_, k), ..] if k.is_keyword(keywords::Else) => {
self.shift(2);
match *self.input {
[keyword!(sp, k), ..] if k.is_keyword(keywords::If) => {
self.shift(1);
let mut render = render.fork();
self.if_expr(sp, &mut render)?;
Some(render.into_stmts())
},
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
Some(self.block(sp, d.stream(), render)?)
},
_ => return self.error(sp, "expected body for this @else"),
}
},
_ => None,
};
render.emit_if(if_cond.into_iter().collect(), if_body, else_body);
Ok(())
fn if_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
self.error("unimplemented")
}
/// Parses and renders an `@while` expression.
///
/// The leading `@while` should already be consumed.
fn while_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
let mut cond = vec![];
let body;
loop { match *self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
body = self.block(sp, d.stream(), render)?;
break;
},
[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);
Ok(())
fn while_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
self.error("unimplemented")
}
/// Parses and renders a `@for` expression.
///
/// The leading `@for` should already be consumed.
fn for_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
let mut pattern = vec![];
loop { match *self.input {
[keyword!(_, k), ..] if k.is_keyword(keywords::In) => {
self.shift(1);
break;
},
[ref tt, ..] => {
self.shift(1);
pattern.push(tt.clone());
},
_ => return self.error(sp, "invalid @for"),
}}
let mut iterable = vec![];
let body;
loop { match *self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
body = self.block(sp, d.stream(), render)?;
break;
},
[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(())
fn for_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
self.error("unimplemented")
}
/// Parses and renders a `@match` expression.
///
/// The leading `@match` should already be consumed.
fn match_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
// Parse the initial match
let mut match_var = vec![];
let match_bodies;
loop { match *self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
match_bodies = Parser {
cx: self.cx,
in_attr: self.in_attr,
input: &d.stream().into_trees().collect::<Vec<_>>(),
span: sp,
}.match_bodies(render)?;
break;
},
[ref tt, ..] => {
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(())
fn match_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
self.error("unimplemented")
}
fn match_bodies(&mut self, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
let mut bodies = Vec::new();
loop { match *self.input {
[] => break,
[ref tt @ comma!(), ..] => {
self.shift(1);
bodies.push(tt.clone());
},
[ref tt, ..] => bodies.append(&mut self.match_body(tt.span(), render)?),
}}
Ok(bodies)
self.error("unimplemented")
}
fn match_body(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
let mut body = vec![];
loop { match *self.input {
[ref tt @ fat_arrow!(), ..] => {
self.shift(1);
body.push(tt.clone());
break;
},
[ref tt, ..] => {
self.shift(1);
body.push(tt.clone());
},
_ => 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;
} else {
self.shift(1);
expr.push(TokenTree::Delimited(sp, d.clone()));
}
},
[comma!(), ..] | [] => {
if expr.is_empty() {
return self.error(sp, "expected body for this @match arm");
} else {
expr = self.block(sp, expr.into_iter().collect(), render)?.into_trees().collect();
break;
}
},
[ref tt, ..] => {
self.shift(1);
expr.push(tt.clone());
},
}}
body.push(TokenTree::Delimited(sp, Delimited {
delim: DelimToken::Brace,
tts: expr.into_iter().collect::<TokenStream>().into(),
}));
Ok(body)
fn match_body(&mut self, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
self.error("unimplemented")
}
/// Parses and renders a `@let` expression.
///
/// The leading `@let` should already be consumed.
fn let_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
let mut pattern = vec![];
loop { match *self.input {
[eq!(), ..] => {
self.shift(1);
break;
},
[ref tt, ..] => {
self.shift(1);
pattern.push(tt.clone());
},
_ => return self.error(sp, "invalid @let"),
}}
let mut rhs = vec![];
let body;
loop { match *self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
body = self.block(sp, d.stream(), render)?;
break;
},
[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(())
fn let_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
self.error("unimplemented")
}
/// Parses and renders an element node.
///
/// 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 {
return self.error(sp, "unexpected element, you silly bumpkin");
return self.error("unexpected element, you silly bumpkin");
}
render.element_open_start(name);
self.attrs(render)?;
render.element_open_end();
if let [slash!(), ..] = *self.input {
self.shift(1);
} else {
self.markup(render)?;
render.element_close(name);
match self.peek() {
Some(TokenNode::Op('/', _)) => {
// Void element
self.advance();
},
_ => {
self.markup(render)?;
render.element_close(name);
},
}
Ok(())
}
/// Parses and renders the attributes of an element.
fn attrs(&mut self, render: &mut Renderer) -> ParseResult<()> {
let mut classes_static = Vec::new();
let mut classes_toggled = Vec::new();
let mut ids = Vec::new();
let mut classes_static: Vec<String> = Vec::new();
let mut classes_toggled: Vec<(TokenStream, String)> = Vec::new();
let mut ids: Vec<String> = Vec::new();
loop {
let old_input = self.input;
let start_position = self.input.save();
let maybe_name = self.namespaced_name();
match (maybe_name, self.input) {
(Ok(name), &[eq!(), ..]) => {
// Non-empty attribute
self.shift(1);
let token_after = self.next();
match (maybe_name, token_after) {
// Non-empty attribute
(Ok(name), Some(TokenNode::Op('=', _))) => {
render.attribute_start(&name);
{
// Parse a value under an attribute context
let mut in_attr = true;
mem::swap(&mut self.in_attr, &mut in_attr);
let in_attr = mem::replace(&mut self.in_attr, true);
self.markup(render)?;
mem::swap(&mut self.in_attr, &mut in_attr);
self.in_attr = in_attr;
}
render.attribute_end();
},
(Ok(name), &[question!(), ..]) => {
// Empty attribute
self.shift(1);
match *self.input {
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => {
// Toggle the attribute based on a boolean expression
self.shift(1);
let cond = d.stream();
let body = {
let mut render = render.fork();
render.attribute_empty(&name);
render.into_stmts()
};
render.emit_if(cond, body, None);
},
_ => {
// Write the attribute unconditionally
// Empty attribute
(Ok(name), Some(TokenNode::Op('?', _))) => match self.peek() {
// Toggle the attribute based on a boolean expression
Some(TokenNode::Group(Delimiter::Bracket, cond)) => {
self.advance();
let body = {
let mut render = render.fork();
render.attribute_empty(&name);
},
}
render.into_stmts()
};
render.emit_if(cond, body, None);
},
// Write the attribute unconditionally
_ => render.attribute_empty(&name),
},
(Err(_), &[dot!(), ident!(_, _), ..]) => {
// Class shorthand
self.shift(1);
let class_name = self.name().unwrap();
match *self.input {
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => {
// Toggle the class based on a boolean expression
self.shift(1);
let cond = d.stream();
// Class shorthand
(Err(_), Some(TokenNode::Op('.', _))) => {
let class_name = self.name()?;
match self.peek() {
// Toggle the class based on a boolean expression
Some(TokenNode::Group(Delimiter::Bracket, cond)) => {
self.advance();
classes_toggled.push((cond, class_name));
},
// Emit the class unconditionally
_ => classes_static.push(class_name),
}
},
(Err(_), &[pound!(), ident!(_, _), ..]) => {
// ID shorthand
self.shift(1);
ids.push(self.name().unwrap());
// ID shorthand
(Err(_), Some(TokenNode::Op('#', _))) => {
ids.push(self.name()?);
},
// If it's not a valid attribute, backtrack and bail out
_ => {
self.input = old_input;
self.input.restore(start_position);
break;
},
}
@ -511,24 +273,23 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses an identifier, without dealing with namespaces.
fn name(&mut self) -> ParseResult<String> {
let mut s = match *self.input {
[ident!(_, name), ..] => {
self.shift(1);
String::from(&name.name.as_str() as &str)
},
_ => return Err(()),
let mut s = if let Some(TokenNode::Term(term)) = self.peek() {
self.advance();
String::from(term.as_str())
} else {
return self.error("expected identifier");
};
let mut expect_ident = false;
loop {
expect_ident = match *self.input {
[minus!(), ..] => {
self.shift(1);
expect_ident = match self.peek() {
Some(TokenNode::Op('-', _)) => {
self.advance();
s.push('-');
true
},
[ident!(_, name), ..] if expect_ident => {
self.shift(1);
s.push_str(&name.name.as_str());
Some(TokenNode::Term(term)) if expect_ident => {
self.advance();
s.push_str(term.as_str());
false
},
_ => break,
@ -541,24 +302,68 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// if necessary.
fn namespaced_name(&mut self) -> ParseResult<String> {
let mut s = self.name()?;
if let [colon!(), ident!(_, _), ..] = *self.input {
self.shift(1);
if let Some(TokenNode::Op(':', _)) = self.peek() {
self.advance();
s.push(':');
s.push_str(&self.name().unwrap());
s.push_str(&self.name()?);
}
Ok(s)
}
/// 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 parse = Parser {
cx: self.cx,
in_attr: self.in_attr,
input: &tts.into_trees().collect::<Vec<_>>(),
span: sp,
input: Lookahead::new(body),
};
parse.markups(&mut render)?;
Ok(render.into_stmts())
}
}
struct Lookahead<T> {
buffer: Vec<T>,
index: usize,
}
impl<T> Lookahead<T> {
fn new<I: IntoIterator<Item=T>>(items: I) -> Self {
Lookahead {
buffer: items.into_iter().collect(),
index: 0,
}
}
fn save(&self) -> Position {
Position { index: self.index }
}
fn restore(&mut self, Position { index }: Position) {
self.index = index;
}
}
impl<T> Lookahead<T> where T: Clone {
fn peek(&mut self) -> Option<T> {
let position = self.save();
let result = self.next();
self.restore(position);
result
}
}
impl<T> Iterator for Lookahead<T> where T: Clone {
type Item = T;
fn next(&mut self) -> Option<T> {
let result = self.buffer.get(self.index).cloned();
if result.is_some() {
self.index += 1;
}
result
}
}
struct Position {
index: usize,
}

131
maud_macros/src/render.rs
View file

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