aboutsummaryrefslogtreecommitdiffstats
path: root/askama_derive/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--askama_derive/src/generator.rs396
1 files changed, 201 insertions, 195 deletions
diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
index a8d26b2..7cdad22 100644
--- a/askama_derive/src/generator.rs
+++ b/askama_derive/src/generator.rs
@@ -14,7 +14,7 @@ use std::{cmp, hash, str};
use syn;
pub(crate) fn generate(input: &TemplateInput, contexts: &HashMap<&PathBuf, Context>) -> String {
- Generator::new(input, contexts, SetChain::new(), 0).build(&contexts[&input.path])
+ Generator::new(input, contexts, SetChain::new()).build(&contexts[&input.path])
}
struct Generator<'a> {
@@ -24,8 +24,6 @@ struct Generator<'a> {
contexts: &'a HashMap<&'a PathBuf, Context<'a>>,
// Variables accessible directly from the current scope (not redirected to context)
locals: SetChain<'a, &'a str>,
- // Top-level buffer for writing code into
- buf: Buffer,
// Suffix whitespace from the previous literal. Will be flushed to the
// output buffer unless suppressed by whitespace suppression on the next
// non-literal.
@@ -45,13 +43,11 @@ impl<'a> Generator<'a> {
input: &'n TemplateInput,
contexts: &'n HashMap<&'n PathBuf, Context<'n>>,
locals: SetChain<'n, &'n str>,
- indent: u8,
) -> Generator<'n> {
Generator {
input,
contexts,
locals,
- buf: Buffer::new(indent),
next_ws: None,
skip_ws: false,
super_block: None,
@@ -61,69 +57,75 @@ impl<'a> Generator<'a> {
fn child(&mut self) -> Generator {
let locals = SetChain::with_parent(&self.locals);
- Self::new(self.input, self.contexts, locals, self.buf.indent)
+ Self::new(self.input, self.contexts, locals)
}
// Takes a Context and generates the relevant implementations.
fn build(mut self, ctx: &'a Context) -> String {
+ let mut buf = Buffer::new(0);
let heritage = if !ctx.blocks.is_empty() {
if let Some(parent) = self.input.parent {
- self.deref_to_parent(parent);
+ self.deref_to_parent(&mut buf, parent);
}
let heritage = Heritage::new(ctx, self.contexts);
- self.trait_blocks(&heritage);
+ self.trait_blocks(&heritage, &mut buf);
Some(heritage)
} else {
None
};
- self.impl_template(ctx, &heritage);
- self.impl_display();
+ self.impl_template(ctx, &heritage, &mut buf);
+ self.impl_display(&mut buf);
if cfg!(feature = "iron") {
- self.impl_modifier_response();
+ self.impl_modifier_response(&mut buf);
}
if cfg!(feature = "rocket") {
- self.impl_rocket_responder();
+ self.impl_rocket_responder(&mut buf);
}
if cfg!(feature = "actix-web") {
- self.impl_actix_web_responder();
+ self.impl_actix_web_responder(&mut buf);
}
- self.buf.buf
+ buf.buf
}
// Implement `Template` for the given context struct.
- fn impl_template(&mut self, ctx: &'a Context, heritage: &Option<Heritage<'a>>) {
- self.write_header("::askama::Template", None);
- self.buf.writeln(
+ fn impl_template(
+ &mut self,
+ ctx: &'a Context,
+ heritage: &Option<Heritage<'a>>,
+ buf: &mut Buffer,
+ ) {
+ self.write_header(buf, "::askama::Template", None);
+ buf.writeln(
"fn render_into(&self, writer: &mut ::std::fmt::Write) -> \
::askama::Result<()> {",
);
if let Some(heritage) = heritage {
- self.handle(heritage.root, heritage.root.nodes, AstLevel::Top);
+ self.handle(heritage.root, heritage.root.nodes, buf, AstLevel::Top);
} else {
- self.handle(ctx, &ctx.nodes, AstLevel::Top);
+ self.handle(ctx, &ctx.nodes, buf, AstLevel::Top);
}
- self.flush_ws(WS(false, false));
- self.buf.writeln("Ok(())");
- self.buf.writeln("}");
+ self.flush_ws(buf, WS(false, false));
+ buf.writeln("Ok(())");
+ buf.writeln("}");
- self.buf.writeln("fn extension(&self) -> Option<&str> {");
- self.buf.writeln(&format!(
+ buf.writeln("fn extension(&self) -> Option<&str> {");
+ buf.writeln(&format!(
"{:?}",
self.input.path.extension().map(|s| s.to_str().unwrap())
));
- self.buf.writeln("}");
+ buf.writeln("}");
- self.buf.writeln("}");
+ buf.writeln("}");
}
- fn trait_blocks(&mut self, heritage: &Heritage<'a>) {
+ fn trait_blocks(&mut self, heritage: &Heritage<'a>, buf: &mut Buffer) {
let trait_name = format!("{}Blocks", self.input.ast.ident);
let mut methods = vec![];
- self.write_header(&trait_name, None);
+ self.write_header(buf, &trait_name, None);
for blocks in heritage.blocks.values() {
for (gen, (ctx, def)) in blocks.iter().enumerate() {
self.used_super = false;
@@ -134,8 +136,8 @@ impl<'a> Generator<'a> {
format!("{}_g{}", name, gen)
};
- self.buf.writeln("#[allow(unused_variables)]");
- self.buf.writeln(&format!(
+ buf.writeln("#[allow(unused_variables)]");
+ buf.writeln(&format!(
"fn render_block_{}_into(&self, writer: &mut ::std::fmt::Write) \
-> ::askama::Result<()> {{",
fname
@@ -145,13 +147,13 @@ impl<'a> Generator<'a> {
self.locals.push();
self.super_block = Some(format!("{}_g{}", name, gen + 1));
- self.handle(ctx, nodes, AstLevel::Block);
+ self.handle(ctx, nodes, buf, AstLevel::Block);
self.super_block = None;
self.locals.pop();
- self.flush_ws(*ws2);
- self.buf.writeln("Ok(())");
- self.buf.writeln("}");
+ self.flush_ws(buf, *ws2);
+ buf.writeln("Ok(())");
+ buf.writeln("}");
} else {
panic!("only block definitions allowed here");
}
@@ -161,50 +163,50 @@ impl<'a> Generator<'a> {
}
}
}
- self.buf.writeln("}");
+ buf.writeln("}");
- self.buf.writeln(&format!("pub trait {} {{", trait_name));
+ buf.writeln(&format!("pub trait {} {{", trait_name));
for name in methods {
- self.buf.writeln(&format!(
+ buf.writeln(&format!(
"fn render_block_{}_into(&self, writer: &mut ::std::fmt::Write) \
-> ::askama::Result<()>;",
name
));
}
- self.buf.writeln("}");
+ buf.writeln("}");
}
// Implement `Deref<Parent>` for an inheriting context struct.
- fn deref_to_parent(&mut self, parent_type: &syn::Type) {
- self.write_header("::std::ops::Deref", None);
- self.buf.writeln(&format!(
+ fn deref_to_parent(&mut self, buf: &mut Buffer, parent_type: &syn::Type) {
+ self.write_header(buf, "::std::ops::Deref", None);
+ buf.writeln(&format!(
"type Target = {};",
parent_type.into_token_stream()
));
- self.buf.writeln("fn deref(&self) -> &Self::Target {");
- self.buf.writeln("&self._parent");
- self.buf.writeln("}");
- self.buf.writeln("}");
+ buf.writeln("fn deref(&self) -> &Self::Target {");
+ buf.writeln("&self._parent");
+ buf.writeln("}");
+ buf.writeln("}");
}
// Implement `Display` for the given context struct.
- fn impl_display(&mut self) {
- self.write_header("::std::fmt::Display", None);
- self.buf
- .writeln("fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {");
- self.buf
- .writeln("self.render_into(f).map_err(|_| ::std::fmt::Error {})");
- self.buf.writeln("}");
- self.buf.writeln("}");
+ fn impl_display(&mut self, buf: &mut Buffer) {
+ self.write_header(buf, "::std::fmt::Display", None);
+ buf.writeln("fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {");
+ buf.writeln("self.render_into(f).map_err(|_| ::std::fmt::Error {})");
+ buf.writeln("}");
+ buf.writeln("}");
}
// Implement iron's Modifier<Response> if enabled
- fn impl_modifier_response(&mut self) {
- self.write_header("::askama::iron::Modifier<::askama::iron::Response>", None);
- self.buf
- .writeln("fn modify(self, res: &mut ::askama::iron::Response) {");
- self.buf
- .writeln("res.body = Some(Box::new(self.render().unwrap().into_bytes()));");
+ fn impl_modifier_response(&mut self, buf: &mut Buffer) {
+ self.write_header(
+ buf,
+ "::askama::iron::Modifier<::askama::iron::Response>",
+ None,
+ );
+ buf.writeln("fn modify(self, res: &mut ::askama::iron::Response) {");
+ buf.writeln("res.body = Some(Box::new(self.render().unwrap().into_bytes()));");
let ext = self.input
.path
@@ -212,22 +214,25 @@ impl<'a> Generator<'a> {
.map_or("", |s| s.to_str().unwrap_or(""));
match ext {
"html" | "htm" => {
- self.buf
- .writeln("::askama::iron::ContentType::html().0.modify(res);");
+ buf.writeln("::askama::iron::ContentType::html().0.modify(res);");
}
_ => (),
};
- self.buf.writeln("}");
- self.buf.writeln("}");
+ buf.writeln("}");
+ buf.writeln("}");
}
// Implement Rocket's `Responder`.
- fn impl_rocket_responder(&mut self) {
+ fn impl_rocket_responder(&mut self, buf: &mut Buffer) {
let lifetime = syn::Lifetime::new("'askama", Span::call_site());
let param = syn::GenericParam::Lifetime(syn::LifetimeDef::new(lifetime));
- self.write_header("::askama::rocket::Responder<'askama>", Some(vec![param]));
- self.buf.writeln(
+ self.write_header(
+ buf,
+ "::askama::rocket::Responder<'askama>",
+ Some(vec![param]),
+ );
+ buf.writeln(
"fn respond_to(self, _: &::askama::rocket::Request) \
-> ::askama::rocket::Result<'askama> {",
);
@@ -236,20 +241,18 @@ impl<'a> Generator<'a> {
Some(s) => s.to_str().unwrap(),
None => "txt",
};
- self.buf
- .writeln(&format!("::askama::rocket::respond(&self, {:?})", ext));
+ buf.writeln(&format!("::askama::rocket::respond(&self, {:?})", ext));
- self.buf.writeln("}");
- self.buf.writeln("}");
+ buf.writeln("}");
+ buf.writeln("}");
}
// Implement Actix-web's `Responder`.
- fn impl_actix_web_responder(&mut self) {
- self.write_header("::askama::actix_web::Responder", None);
- self.buf
- .writeln("type Item = ::askama::actix_web::HttpResponse;");
- self.buf.writeln("type Error = ::askama::actix_web::Error;");
- self.buf.writeln(
+ fn impl_actix_web_responder(&mut self, buf: &mut Buffer) {
+ self.write_header(buf, "::askama::actix_web::Responder", None);
+ buf.writeln("type Item = ::askama::actix_web::HttpResponse;");
+ buf.writeln("type Error = ::askama::actix_web::Error;");
+ buf.writeln(
"fn respond_to<S>(self, _req: &::askama::actix_web::HttpRequest<S>) \
-> Result<Self::Item, Self::Error> {",
);
@@ -258,16 +261,20 @@ impl<'a> Generator<'a> {
Some(s) => s.to_str().unwrap(),
None => "txt",
};
- self.buf
- .writeln(&format!("::askama::actix_web::respond(&self, {:?})", ext));
+ buf.writeln(&format!("::askama::actix_web::respond(&self, {:?})", ext));
- self.buf.writeln("}");
- self.buf.writeln("}");
+ buf.writeln("}");
+ buf.writeln("}");
}
// Writes header for the `impl` for `TraitFromPathName` or `Template`
// for the given context struct.
- fn write_header(&mut self, target: &str, params: Option<Vec<syn::GenericParam>>) {
+ fn write_header(
+ &mut self,
+ buf: &mut Buffer,
+ target: &str,
+ params: Option<Vec<syn::GenericParam>>,
+ ) {
let mut generics = self.input.ast.generics.clone();
if let Some(params) = params {
for param in params {
@@ -276,7 +283,7 @@ impl<'a> Generator<'a> {
}
let (_, orig_ty_generics, _) = self.input.ast.generics.split_for_impl();
let (impl_generics, _, where_clause) = generics.split_for_impl();
- self.buf.writeln(
+ buf.writeln(
format!(
"{} {} for {}{} {{",
quote!(impl#impl_generics),
@@ -289,32 +296,32 @@ impl<'a> Generator<'a> {
/* Helper methods for handling node types */
- fn handle(&mut self, ctx: &'a Context, nodes: &'a [Node], level: AstLevel) {
+ fn handle(&mut self, ctx: &'a Context, nodes: &'a [Node], buf: &mut Buffer, level: AstLevel) {
for n in nodes {
match *n {
Node::Lit(lws, val, rws) => {
- self.write_lit(lws, val, rws);
+ self.write_lit(buf, lws, val, rws);
}
Node::Comment(ws) => {
- self.write_comment(ws);
+ self.write_comment(buf, ws);
}
Node::Expr(ws, ref val) => {
- self.write_expr(ws, val);
+ self.write_expr(buf, ws, val);
}
Node::LetDecl(ws, ref var) => {
- self.write_let_decl(ws, var);
+ self.write_let_decl(buf, ws, var);
}
Node::Let(ws, ref var, ref val) => {
- self.write_let(ws, var, val);
+ self.write_let(buf, ws, var, val);
}
Node::Cond(ref conds, ws) => {
- self.write_cond(ctx, conds, ws);
+ self.write_cond(ctx, buf, conds, ws);
}
Node::Match(ws1, ref expr, inter, ref arms, ws2) => {
- self.write_match(ctx, ws1, expr, inter, arms, ws2);
+ self.write_match(ctx, buf, ws1, expr, inter, arms, ws2);
}
Node::Loop(ws1, ref var, ref iter, ref body, ws2) => {
- self.write_loop(ctx, ws1, var, iter, body, ws2);
+ self.write_loop(ctx, buf, ws1, var, iter, body, ws2);
}
Node::BlockDef(ws1, name, _, ws2) => {
if let AstLevel::Nested = level {
@@ -324,26 +331,26 @@ impl<'a> Generator<'a> {
name
);
}
- self.write_block(ws1, name, ws2);
+ self.write_block(buf, ws1, name, ws2);
}
Node::Include(ws, path) => {
- self.handle_include(ctx, ws, path);
+ self.handle_include(ctx, buf, ws, path);
}
Node::Call(ws, scope, name, ref args) => {
- self.write_call(ctx, ws, scope, name, args);
+ self.write_call(ctx, buf, ws, scope, name, args);
}
Node::Macro(_, ref m) => {
if level != AstLevel::Top {
panic!("macro blocks only allowed at the top level");
}
- self.flush_ws(m.ws1);
+ self.flush_ws(buf, m.ws1);
self.prepare_ws(m.ws2);
}
Node::Import(ws, _, _) => {
if level != AstLevel::Top {
panic!("import blocks only allowed at the top level");
}
- self.handle_ws(ws);
+ self.handle_ws(buf, ws);
}
Node::Extends(_) => {
if level != AstLevel::Top {
@@ -356,44 +363,45 @@ impl<'a> Generator<'a> {
}
}
- fn write_cond(&mut self, ctx: &'a Context, conds: &'a [Cond], ws: WS) {
+ fn write_cond(&mut self, ctx: &'a Context, buf: &mut Buffer, conds: &'a [Cond], ws: WS) {
for (i, &(cws, ref cond, ref nodes)) in conds.iter().enumerate() {
- self.handle_ws(cws);
+ self.handle_ws(buf, cws);
match *cond {
Some(ref expr) => {
let expr_code = self.visit_expr_root(expr);
if i == 0 {
- self.buf.write("if ");
+ buf.write("if ");
} else {
- self.buf.dedent();
- self.buf.write("} else if ");
+ buf.dedent();
+ buf.write("} else if ");
}
- self.buf.write(&expr_code);
+ buf.write(&expr_code);
}
None => {
- self.buf.dedent();
- self.buf.write("} else");
+ buf.dedent();
+ buf.write("} else");
}
}
- self.buf.writeln(" {");
+ buf.writeln(" {");
self.locals.push();
- self.handle(ctx, nodes, AstLevel::Nested);
+ self.handle(ctx, nodes, buf, AstLevel::Nested);
self.locals.pop();
}
- self.handle_ws(ws);
- self.buf.writeln("}");
+ self.handle_ws(buf, ws);
+ buf.writeln("}");
}
fn write_match(
&mut self,
ctx: &'a Context,
+ buf: &mut Buffer,
ws1: WS,
expr: &Expr,
inter: Option<&'a str>,
arms: &'a [When],
ws2: WS,
) {
- self.flush_ws(ws1);
+ self.flush_ws(buf, ws1);
if let Some(inter) = inter {
if !inter.is_empty() {
self.next_ws = Some(inter);
@@ -401,83 +409,84 @@ impl<'a> Generator<'a> {
}
let expr_code = self.visit_expr_root(expr);
- self.buf.writeln(&format!("match &{} {{", expr_code));
+ buf.writeln(&format!("match &{} {{", expr_code));
for arm in arms {
let &(ws, ref variant, ref params, ref body) = arm;
self.locals.push();
match *variant {
Some(ref param) => {
- self.visit_match_variant(param);
+ self.visit_match_variant(buf, param);
}
- None => self.buf.write("_"),
+ None => buf.write("_"),
};
if !params.is_empty() {
- self.buf.write("(");
+ buf.write("(");
for (i, param) in params.iter().enumerate() {
if let MatchParameter::Name(p) = *param {
self.locals.insert(p);
}
if i > 0 {
- self.buf.write(", ");
+ buf.write(", ");
}
- self.visit_match_param(param);
+ self.visit_match_param(buf, param);
}
- self.buf.write(")");
+ buf.write(")");
}
- self.buf.writeln(" => {");
- self.handle_ws(ws);
- self.handle(ctx, body, AstLevel::Nested);
- self.buf.writeln("}");
+ buf.writeln(" => {");
+ self.handle_ws(buf, ws);
+ self.handle(ctx, body, buf, AstLevel::Nested);
+ buf.writeln("}");
self.locals.pop();
}
- self.buf.writeln("}");
- self.handle_ws(ws2);
+ buf.writeln("}");
+ self.handle_ws(buf, ws2);
}
fn write_loop(
&mut self,
ctx: &'a Context,
+ buf: &mut Buffer,
ws1: WS,
var: &'a Target,
iter: &Expr,
body: &'a [Node],
ws2: WS,
) {
- self.handle_ws(ws1);
+ self.handle_ws(buf, ws1);
self.locals.push();
let expr_code = self.visit_expr_root(iter);
- self.buf.write("for (_loop_index, ");
+ buf.write("for (_loop_index, ");
let targets = self.visit_target(var);
for name in &targets {
self.locals.insert(name);
- self.buf.write(name);
+ buf.write(name);
}
- self.buf
- .writeln(&format!(") in (&{}).into_iter().enumerate() {{", expr_code));
+ buf.writeln(&format!(") in (&{}).into_iter().enumerate() {{", expr_code));
- self.handle(ctx, body, AstLevel::Nested);
- self.handle_ws(ws2);
- self.buf.writeln("}");
+ self.handle(ctx, body, buf, AstLevel::Nested);
+ self.handle_ws(buf, ws2);
+ buf.writeln("}");
self.locals.pop();
}
fn write_call(
&mut self,
ctx: &'a Context,
+ buf: &mut Buffer,
ws: WS,
scope: Option<&str>,
name: &str,
args: &[Expr],
) {
if name == "super" {
- self.flush_ws(ws);
+ self.flush_ws(buf, ws);
let line = match self.super_block {
Some(ref name) => format!("self.render_block_{}_into(writer)?;", name),
None => panic!("cannot call 'super()' outside block"),
};
- self.buf.writeln(&line);
+ buf.writeln(&line);
self.prepare_ws(ws);
self.used_super = true;
return;
@@ -499,9 +508,9 @@ impl<'a> Generator<'a> {
.unwrap_or_else(|| panic!("macro '{}' not found", name))
};
- self.flush_ws(ws); // Cannot handle_ws() here: whitespace from macro definition comes first
+ self.flush_ws(buf, ws); // Cannot handle_ws() here: whitespace from macro definition comes first
self.locals.push();
- self.buf.writeln("{");
+ buf.writeln("{");
self.prepare_ws(def.ws1);
for (i, arg) in def.args.iter().enumerate() {
@@ -509,87 +518,84 @@ impl<'a> Generator<'a> {
args.get(i)
.unwrap_or_else(|| panic!("macro '{}' takes more than {} arguments", name, i)),
);
- self.buf.writeln(&format!("let {} = &{};", arg, expr_code));
+ buf.writeln(&format!("let {} = &{};", arg, expr_code));
self.locals.insert(arg);
}
- self.handle(ctx, &def.nodes, AstLevel::Nested);
+ self.handle(ctx, &def.nodes, buf, AstLevel::Nested);
- self.flush_ws(def.ws2);
- self.buf.writeln("}");
+ self.flush_ws(buf, def.ws2);
+ buf.writeln("}");
self.locals.pop();
self.prepare_ws(ws);
}
- fn handle_include(&mut self, ctx: &'a Context, ws: WS, path: &str) {
- self.flush_ws(ws);
+ fn handle_include(&mut self, ctx: &'a Context, buf: &mut Buffer, ws: WS, path: &str) {
+ self.flush_ws(buf, ws);
let path = self.input
.config
.find_template(path, Some(&self.input.path));
let src = get_template_source(&path);
let nodes = parser::parse(&src);
- let nested = {
+ {
let mut gen = self.child();
- gen.handle(ctx, &nodes, AstLevel::Nested);
- gen.buf.buf
- };
- self.buf.write(&nested);
+ gen.handle(ctx, &nodes, buf, AstLevel::Nested);
+ }
self.prepare_ws(ws);
}
- fn write_let_decl(&mut self, ws: WS, var: &'a Target) {
- self.handle_ws(ws);
- self.buf.write("let ");
+ fn write_let_decl(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target) {
+ self.handle_ws(buf, ws);
+ buf.write("let ");
match *var {
Target::Name(name) => {
self.locals.insert(name);
- self.buf.write(name);
+ buf.write(name);
}
}
- self.buf.writeln(";");
+ buf.writeln(";");
}
- fn write_let(&mut self, ws: WS, var: &'a Target, val: &Expr) {
- self.handle_ws(ws);
- let mut buf = Buffer::new(0);
- self.visit_expr(&mut buf, val);
+ fn write_let(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target, val: &Expr) {
+ self.handle_ws(buf, ws);
+ let mut expr_buf = Buffer::new(0);
+ self.visit_expr(&mut expr_buf, val);
match *var {
Target::Name(name) => {
if !self.locals.contains(name) {
- self.buf.write("let ");
+ buf.write("let ");
self.locals.insert(name);
}
- self.buf.write(name);
+ buf.write(name);
}
}
- self.buf.writeln(&format!(" = {};", &buf.buf));
+ buf.writeln(&format!(" = {};", &expr_buf.buf));
}
- fn write_block(&mut self, ws1: WS, name: &str, ws2: WS) {
- self.flush_ws(ws1);
- self.buf
- .writeln(&format!("self.render_block_{}_into(writer)?;", name));
+ fn write_block(&mut self, buf: &mut Buffer, ws1: WS, name: &str, ws2: WS) {
+ self.flush_ws(buf, ws1);
+ buf.writeln(&format!("self.render_block_{}_into(writer)?;", name));
self.prepare_ws(ws2);
}
- fn write_expr(&mut self, ws: WS, s: &Expr) {
- self.handle_ws(ws);
- let mut buf = Buffer::new(0);
- let wrapped = self.visit_expr(&mut buf, s);
+ fn write_expr(&mut self, buf: &mut Buffer, ws: WS, s: &Expr) {
+ self.handle_ws(buf, ws);
+ let mut expr_buf = Buffer::new(0);
+ let wrapped = self.visit_expr(&mut expr_buf, s);
use self::DisplayWrap::*;
use super::input::EscapeMode::*;
- self.buf.writeln("writer.write_fmt(format_args!(\"{}\", &{");
- self.buf.write(&match (wrapped, &self.input.escaping) {
- (Wrapped, &Html) | (Wrapped, &None) | (Unwrapped, &None) => buf.buf,
- (Unwrapped, &Html) => format!("::askama::MarkupDisplay::from(&{})", buf.buf),
+ buf.writeln("writer.write_fmt(format_args!(\"{}\", &{");
+ buf.write(&match (wrapped, &self.input.escaping) {
+ (Wrapped, &Html) | (Wrapped, &None) | (Unwrapped, &None) => expr_buf.buf,
+ (Unwrapped, &Html) => format!("::askama::MarkupDisplay::from(&{})", expr_buf.buf),
});
- self.buf.writeln("");
- self.buf.dedent();
- self.buf.writeln("}))?;");
+ buf.writeln("");
+ buf.dedent();
+ buf.writeln("}))?;");
}
- fn write_lit(&mut self, lws: &'a str, val: &str, rws: &'a str) {
+ fn write_lit(&mut self, buf: &mut Buffer, lws: &'a str, val: &str, rws: &'a str) {
assert!(self.next_ws.is_none());
if !lws.is_empty() {
if self.skip_ws {
@@ -598,19 +604,19 @@ impl<'a> Generator<'a> {
assert!(rws.is_empty());
self.next_ws = Some(lws);
} else {
- self.buf.writeln(&format!("writer.write_str({:#?})?;", lws));
+ buf.writeln(&format!("writer.write_str({:#?})?;", lws));
}
}
if !val.is_empty() {
- self.buf.writeln(&format!("writer.write_str({:#?})?;", val));
+ buf.writeln(&format!("writer.write_str({:#?})?;", val));
}
if !rws.is_empty() {
self.next_ws = Some(rws);
}
}
- fn write_comment(&mut self, ws: WS) {
- self.handle_ws(ws);
+ fn write_comment(&mut self, buf: &mut Buffer, ws: WS) {
+ self.handle_ws(buf, ws);
}
/* Visitor methods for expression types */
@@ -641,38 +647,38 @@ impl<'a> Generator<'a> {
}
}
- fn visit_match_variant(&mut self, param: &MatchVariant) -> DisplayWrap {
- let mut buf = Buffer::new(0);
+ fn visit_match_variant(&mut self, buf: &mut Buffer, param: &MatchVariant) -> DisplayWrap {
+ let mut expr_buf = Buffer::new(0);
let wrapped = match *param {
MatchVariant::StrLit(s) => {
- buf.write("&");
- self.visit_str_lit(&mut buf, s)
+ expr_buf.write("&");
+ self.visit_str_lit(&mut expr_buf, s)
}
- MatchVariant::NumLit(s) => self.visit_num_lit(&mut buf, s),
+ MatchVariant::NumLit(s) => self.visit_num_lit(&mut expr_buf, s),
MatchVariant::Name(s) => {
- buf.write(s);
+ expr_buf.write(s);
DisplayWrap::Unwrapped
}
MatchVariant::Path(ref s) => {
- buf.write(&s.join("::"));
+ expr_buf.write(&s.join("::"));
DisplayWrap::Unwrapped
}
};
- self.buf.write(&buf.buf);
+ buf.write(&expr_buf.buf);
wrapped
}
- fn visit_match_param(&mut self, param: &MatchParameter) -> DisplayWrap {
- let mut buf = Buffer::new(0);
+ fn visit_match_param(&mut self, buf: &mut Buffer, param: &MatchParameter) -> DisplayWrap {
+ let mut expr_buf = Buffer::new(0);
let wrapped = match *param {
- MatchParameter::NumLit(s) => self.visit_num_lit(&mut buf, s),
- MatchParameter::StrLit(s) => self.visit_str_lit(&mut buf, s),
+ MatchParameter::NumLit(s) => self.visit_num_lit(&mut expr_buf, s),
+ MatchParameter::StrLit(s) => self.visit_str_lit(&mut expr_buf, s),
MatchParameter::Name(s) => {
- buf.write(s);
+ expr_buf.write(s);
DisplayWrap::Unwrapped
}
};
- self.buf.write(&buf.buf);
+ buf.write(&expr_buf.buf);
wrapped
}
@@ -891,19 +897,19 @@ impl<'a> Generator<'a> {
// Combines `flush_ws()` and `prepare_ws()` to handle both trailing whitespace from the
// preceding literal and leading whitespace from the succeeding literal.
- fn handle_ws(&mut self, ws: WS) {
- self.flush_ws(ws);
+ fn handle_ws(&mut self, buf: &mut Buffer, ws: WS) {
+ self.flush_ws(buf, ws);
self.prepare_ws(ws);
}
// If the previous literal left some trailing whitespace in `next_ws` and the
// prefix whitespace suppressor from the given argument, flush that whitespace.
// In either case, `next_ws` is reset to `None` (no trailing whitespace).
- fn flush_ws(&mut self, ws: WS) {
+ fn flush_ws(&mut self, buf: &mut Buffer, ws: WS) {
if self.next_ws.is_some() && !ws.0 {
let val = self.next_ws.unwrap();
if !val.is_empty() {
- self.buf.writeln(&format!("writer.write_str({:#?})?;", val));
+ buf.writeln(&format!("writer.write_str({:#?})?;", val));
}
}
self.next_ws = None;
generated by cgit (git 2.34.1) at 2024-11-22 17:57:47 +0000