Make the signature of templates cleaner.

kaj · kaj · commit 3a2ba5cc80ac · 2021-12-04T13:26:42.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,8 @@ project adheres to
 ## Unreleased
 
 * Current stable rust is 1.57, MSRV is now 1.46.0.
+* Breaking change: The generated template functions have a simpler
+  signature.
 
 
 ## Release 0.13.4 - 2021-06-25
diff --git a/examples/actix/src/actix_ructe.rs b/examples/actix/src/actix_ructe.rs
@@ -1,5 +1,3 @@
-use std::io::Write;
-
 macro_rules! render {
     ($template:path) => (Render(|o| $template(o)));
     ($template:path, $($arg:expr),*) => {{
@@ -12,9 +10,9 @@ macro_rules! render {
     }};
 }
 
-pub struct Render<T: FnOnce(&mut dyn Write) -> std::io::Result<()>>(pub T);
+pub struct Render<T: FnOnce(&mut Vec<u8>) -> std::io::Result<()>>(pub T);
 
-impl<T: FnOnce(&mut dyn Write) -> std::io::Result<()>> From<Render<T>>
+impl<T: FnOnce(&mut Vec<u8>) -> std::io::Result<()>> From<Render<T>>
     for actix_web::body::Body
 {
     fn from(t: Render<T>) -> Self {
diff --git a/examples/actix/src/main.rs b/examples/actix/src/main.rs
@@ -107,7 +107,7 @@ impl actix_web::error::ResponseError for ExampleAppError {
 
 /// This method can be used as a "template tag", i.e. a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer<W: Write>(out: &mut W) -> io::Result<()> {
     templates::footer(
         out,
         &[
diff --git a/examples/gotham/src/main.rs b/examples/gotham/src/main.rs
@@ -40,7 +40,7 @@ fn homepage(state: State) -> (State, Response<Body>) {
 
 /// This method can be used as a "template tag", that is a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer(out: &mut impl Write) -> io::Result<()> {
     templates::footer(
         out,
         &[
@@ -64,7 +64,7 @@ pub struct FilePath {
 fn static_file(state: State) -> (State, Response<Body>) {
     let res = {
         let FilePath { ref name } = FilePath::borrow_from(&state);
-        if let Some(data) = statics::StaticFile::get(&name) {
+        if let Some(data) = statics::StaticFile::get(name) {
             Response::builder()
                 .status(StatusCode::OK)
                 .header(CONTENT_TYPE, data.mime.as_ref())
diff --git a/examples/gotham/src/ructe_response.rs b/examples/gotham/src/ructe_response.rs
@@ -2,18 +2,18 @@ use gotham::hyper::http::header::CONTENT_TYPE;
 use gotham::hyper::{Body, Response, StatusCode};
 use gotham::state::State;
 use mime::TEXT_HTML_UTF_8;
-use std::io::{self, Write};
+use std::io;
 
 pub trait RucteResponse: Sized {
     fn html<F>(self, do_render: F) -> (Self, Response<Body>)
     where
-        F: FnOnce(&mut dyn Write) -> io::Result<()>;
+        F: FnOnce(&mut Vec<u8>) -> io::Result<()>;
 }
 
 impl RucteResponse for State {
     fn html<F>(self, do_render: F) -> (Self, Response<Body>)
     where
-        F: FnOnce(&mut dyn Write) -> io::Result<()>,
+        F: FnOnce(&mut Vec<u8>) -> io::Result<()>,
     {
         let mut buf = Vec::new();
         let res = match do_render(&mut buf) {
diff --git a/examples/iron/src/main.rs b/examples/iron/src/main.rs
@@ -36,7 +36,7 @@ fn frontpage(_: &mut Request) -> IronResult<Response> {
 
 /// This method can be used as a "template tag", that is a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer(out: &mut impl Write) -> io::Result<()> {
     templates::footer(
         out,
         &[
diff --git a/examples/nickel/src/main.rs b/examples/nickel/src/main.rs
@@ -3,6 +3,7 @@ extern crate nickel;
 extern crate time;
 
 use nickel::hyper::header::{ContentType, Expires, HttpDate};
+use nickel::hyper::server::Streaming;
 use nickel::status::StatusCode;
 use nickel::{Halt, HttpRouter, MiddlewareResult, Nickel, Request, Response};
 use std::io::{self, Write};
@@ -50,7 +51,7 @@ fn page<'mw>(
 
 fn render<F>(res: Response, do_render: F) -> MiddlewareResult
 where
-    F: FnOnce(&mut dyn Write) -> io::Result<()>,
+    F: FnOnce(&mut Response<(), Streaming>) -> io::Result<()>,
 {
     let mut stream = res.start()?;
     match do_render(&mut stream) {
@@ -61,7 +62,7 @@ where
 
 /// This method can be used as a "template tag", that is a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer(out: &mut impl Write) -> io::Result<()> {
     templates::footer(
         out,
         &[
diff --git a/examples/simple/src/main.rs b/examples/simple/src/main.rs
@@ -1,6 +1,6 @@
 #![allow(dead_code)] // Most templates here are only used in tests.
 
-use std::io::{self, Write};
+use std::io;
 
 include!(concat!(env!("OUT_DIR"), "/templates.rs"));
 use crate::templates::*;
@@ -11,7 +11,7 @@ fn main() {
 
 fn r2s<Call>(call: Call) -> String
 where
-    Call: FnOnce(&mut dyn Write) -> io::Result<()>,
+    Call: FnOnce(&mut Vec<u8>) -> io::Result<()>,
 {
     let mut buf = Vec::new();
     call(&mut buf).unwrap();
diff --git a/examples/simple/templates/issue_66.rs.html b/examples/simple/templates/issue_66.rs.html
@@ -7,5 +7,5 @@
         text.push('C');
     }
 
-    return text;
+    text
 })
diff --git a/examples/static-sass/src/main.rs b/examples/static-sass/src/main.rs
@@ -20,7 +20,7 @@ fn main() {
 mod test {
     use crate::templates::statics::{StaticFile, STATICS};
     use crate::templates::*;
-    use std::io::{self, Write};
+    use std::io;
 
     #[test]
     fn page_w_static() {
@@ -74,7 +74,7 @@ mod test {
 
     fn r2s<Call>(call: Call) -> String
     where
-        Call: FnOnce(&mut dyn Write) -> io::Result<()>,
+        Call: FnOnce(&mut Vec<u8>) -> io::Result<()>,
     {
         let mut buf = Vec::new();
         call(&mut buf).unwrap();
diff --git a/examples/statics/src/main.rs b/examples/statics/src/main.rs
@@ -66,7 +66,7 @@ fn test_all_statics_known() {
 #[cfg(test)]
 fn r2s<Call>(call: Call) -> String
 where
-    Call: FnOnce(&mut dyn Write) -> io::Result<()>,
+    Call: FnOnce(&mut Vec<u8>) -> io::Result<()>,
 {
     let mut buf = Vec::new();
     call(&mut buf).unwrap();
diff --git a/examples/tide/src/main.rs b/examples/tide/src/main.rs
@@ -44,7 +44,7 @@ async fn frontpage(_req: Request<()>) -> Result<Response, Error> {
 /// interface to get a file by url path.
 async fn static_file(req: Request<()>) -> Result<Response, Error> {
     let path = req.param("path")?;
-    StaticFile::get(&path)
+    StaticFile::get(path)
         .ok_or_else(|| Error::from_str(StatusCode::NotFound, "not found"))
         .map(static_response)
 }
@@ -70,7 +70,7 @@ const DAY: Duration = Duration::from_secs(24 * 60 * 60);
 
 /// This method can be used as a "template tag", i.e. a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer<W: Write>(out: &mut W) -> io::Result<()> {
     templates::footer(
         out,
         &[
diff --git a/examples/tide/src/ructe_tide.rs b/examples/tide/src/ructe_tide.rs
@@ -34,7 +34,7 @@ pub trait Render {
     /// ```
     fn render<Call>(&mut self, call: Call) -> std::io::Result<()>
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>;
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>;
 
     /// Render a template to the html body of self.
     ///
@@ -44,13 +44,13 @@ pub trait Render {
     /// [`HTML`]: ../../tide/http/mime/constant.HTML.html
     fn render_html<Call>(&mut self, call: Call) -> std::io::Result<()>
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>;
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>;
 }
 
 impl Render for tide::Response {
     fn render<Call>(&mut self, call: Call) -> std::io::Result<()>
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>,
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>,
     {
         let mut buf = Vec::new();
         call(&mut buf)?;
@@ -60,7 +60,7 @@ impl Render for tide::Response {
 
     fn render_html<Call>(&mut self, call: Call) -> std::io::Result<()>
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>,
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>,
     {
         self.render(call)?;
         self.set_content_type(tide::http::mime::HTML);
@@ -97,7 +97,7 @@ pub trait RenderBuilder {
     /// ```
     fn render<Call>(self, call: Call) -> tide::ResponseBuilder
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>;
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>;
 
     /// Render a template to the html body of self.
     ///
@@ -107,13 +107,13 @@ pub trait RenderBuilder {
     /// [`HTML`]: ../../tide/http/mime/constant.HTML.html
     fn render_html<Call>(self, call: Call) -> tide::ResponseBuilder
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>;
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>;
 }
 
 impl RenderBuilder for tide::ResponseBuilder {
     fn render<Call>(self, call: Call) -> tide::ResponseBuilder
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>,
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>,
     {
         let mut buf = Vec::new();
         match call(&mut buf) {
@@ -131,7 +131,7 @@ impl RenderBuilder for tide::ResponseBuilder {
 
     fn render_html<Call>(self, call: Call) -> tide::ResponseBuilder
     where
-        Call: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>,
+        Call: FnOnce(&mut Vec<u8>) -> std::io::Result<()>,
     {
         self.content_type(tide::http::mime::HTML).render(call)
     }
diff --git a/examples/warp02/src/main.rs b/examples/warp02/src/main.rs
@@ -46,7 +46,7 @@ async fn bad_handler() -> Result<StatusCode, Rejection> {
 
 /// This method can be used as a "template tag", i.e. a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer(out: &mut impl Write) -> io::Result<()> {
     templates::footer(
         out,
         &[
diff --git a/examples/warp03/src/main.rs b/examples/warp03/src/main.rs
@@ -46,7 +46,7 @@ async fn bad_handler() -> Result<StatusCode, Rejection> {
 
 /// This method can be used as a "template tag", i.e. a method that
 /// can be called directly from a template.
-fn footer(out: &mut dyn Write) -> io::Result<()> {
+fn footer(out: &mut impl Write) -> io::Result<()> {
     templates::footer(
         out,
         &[
diff --git a/src/expression.rs b/src/expression.rs
@@ -41,7 +41,7 @@ pub fn expression(input: &[u8]) -> PResult<&str> {
 }
 
 pub fn input_to_str(s: &[u8]) -> Result<&str, Utf8Error> {
-    from_utf8(&s)
+    from_utf8(s)
 }
 
 pub fn comma_expressions(input: &[u8]) -> PResult<String> {
diff --git a/src/parseresult.rs b/src/parseresult.rs
@@ -16,7 +16,7 @@ pub fn show_errors(
         Err::Failure(VerboseError { ref errors })
         | Err::Error(VerboseError { ref errors }) => {
             for (rest, err) in errors.iter().rev() {
-                if let Some(message) = get_message(&err) {
+                if let Some(message) = get_message(err) {
                     let pos = buf.len() - rest.len();
                     show_error(out, buf, pos, &message, prefix);
                 }
diff --git a/src/template.rs b/src/template.rs
@@ -40,7 +40,7 @@ impl Template {
         writeln!(
             out,
             "\n\
-             pub fn {name}<W>(mut _ructe_out_: &mut W{args}) -> io::Result<()> where W: ?Sized, for<'a> &'a mut W: Write {{\n\
+             pub fn {name}<W>(_ructe_out_: &mut W{args}) -> io::Result<()> where W: Write {{\n\
              {body}\
              Ok(())\n\
              }}",
diff --git a/src/templateexpression.rs b/src/templateexpression.rs
@@ -53,7 +53,7 @@ pub enum TemplateArgument {
 impl Display for TemplateArgument {
     fn fmt(&self, out: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match *self {
-            TemplateArgument::Rust(ref s) => out.write_str(&s),
+            TemplateArgument::Rust(ref s) => out.write_str(s),
             TemplateArgument::Body(ref v) if v.is_empty() => {
                 out.write_str("|_| Ok(())")
             }
@@ -82,7 +82,7 @@ impl TemplateExpression {
                 format!("_ructe_out_.write_all({:?}.as_bytes())?;\n", text)
             }
             TemplateExpression::Expression { ref expr } => {
-                format!("{}.to_html(&mut _ructe_out_)?;\n", expr)
+                format!("{}.to_html(_ructe_out_)?;\n", expr)
             }
             TemplateExpression::ForLoop {
                 ref name,
@@ -126,7 +126,7 @@ impl TemplateExpression {
             ),
             TemplateExpression::CallTemplate { ref name, ref args } => {
                 format!(
-                    "{}(&mut _ructe_out_{})?;\n",
+                    "{}(_ructe_out_{})?;\n",
                     name,
                     args.iter().format_with("", |arg, f| f(&format_args!(
                         ", {}",

Original file line number	Diff line number	Diff line change
`@@ -7,5 +7,5 @@`
`7`	`7`	`text.push('C');`
`8`	`8`	`}`
`9`	`9`
`10`		`- return text;`
	`10`	`+ text`
`11`	`11`	`})`