add support for ructe templates

[prabirshrestha]

Add ructe templating support. It catches most of the errors at compile time and also has an optional SASS compilation support to convert it to CSS.

//cc @kaj

[jbr]

This seems like it would be a great addition, but given how many other framework-essential handlers I need to write (#17) and given that there are three template languages currently, I'd be more inclined to advise and review if someone else wants to write it, and would happily add it to the documentation.

[prabirshrestha]

Here is a sample ructe working example in case others are interested.

include!(concat!(env!("OUT_DIR"), "/templates.rs"));

fn render<Call>(call: Call) -> String
where
    Call: FnOnce(&mut dyn Write) -> std::io::Result<()>,
{
    let mut buf = Vec::new();
    call(&mut buf).unwrap();
    String::from_utf8(buf).unwrap()
}

async fn not_found(conn: Conn) -> Conn {
    let contents = render(|o| templates::notfound_html(o, conn.path()));
    conn.with_body(contents)
        .with_header(("content-type", "text/html"))
        .with_status(404)
}

notfound.rs.html

@(path: &str)

<h1>@path Not Found</h1>

build.rs

use ructe::{Result, Ructe};

fn main() -> Result<()> {
    let mut ructe = Ructe::from_env()?;
    let mut statics = ructe.statics()?;
    statics.add_files("static")?;
    ructe.compile_templates("templates")?;
    Ok(())
}

A better wrapper something like conn.render could be created similar to this. kaj/ructe#79

[prabirshrestha]

Here is an extension for ructe templating engine which might be better.

pub trait RucteConnExt {
    fn render<F>(self, do_render: F) -> Self
    where
        F: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>;

    fn render_html<F>(self, do_render: F) -> Self
    where
        F: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>;
}

impl RucteConnExt for trillium::Conn {
    fn render<F>(self, do_render: F) -> Self
    where
        F: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>,
    {
        let mut buf = Vec::new();
        match do_render(&mut buf) {
            Ok(()) => self.ok(buf),
            Err(e) => {
                log::error!("{:?}", &e);
                self.with_status(500)
                    .with_header(("content-type", "text/plain; charset=utf-8"))
                    .with_body("Internal Server Error")
                    .halt()
            }
        }
    }

    fn render_html<F>(self, do_render: F) -> Self
    where
        F: FnOnce(&mut dyn std::io::Write) -> std::io::Result<()>,
    {
        self.with_header(("content-type", "text/html; charset=utf-8"))
            .render(do_render)
    }
}

This can be easily used as following:

async fn hello(conn: Conn) -> Conn {
    conn.render_html(|o| templates::hello_html(o, "world"))
}

@jbr let me know if you are interested and more than happy to send a PR for this.

Another important possible security bug I saw while looking at existing templates was that it shows raw template errors. I would personally never prefer the raw error to be shown to the client unless might be in debug mode. Might be just log to the console but send out "Internal Sever Error" text?

match string {
    Ok(string) => self.ok(string),
    Err(b) => self.with_status(500).with_body(b.to_string()),
}

[jbr]

I'd prefer if you published and maintained this as crate of your own. The goal is for the number of crates in the trillium workspace/repo to decrease over time if and when I can find subject-matter maintainers for the existing crates. My long term interest is for trillium to be an ecosystem I maintain a small fraction of, not a monolithic project.

I've opened #59 to represent the error response concern, which I'll address in the next release

[prabirshrestha]

I have published trillium-ructe if anyone is interested in using ructe with trillium.

For now I'm preferring the macro version similar to conn_try.

use trillium::Conn;
use trillium_ructe::render_html_try;

include!(concat!(env!("OUT_DIR"), "/templates.rs"));

fn main() {
    trillium_smol::run(|conn: Conn| async move {
        render_html_try!(conn, |o| templates::helloworld(o, "html"))
    });
}

When there is error handlers I can look into adding ConnExt so it can be used as conn.render_html(|o| templates::helloworld(o, "html"))?