Hotreload: Ability to update templates without recompiling

[untitaker]

This is a continuation of #392, it adds a way to auto-reload templates to maud without going through rustc at all, for some situations.

Basic usage

Enable the hotreload feature, and the html! macro will partially evaluate at runtime. use maud::html_static! to force the "normal", fully-compiled behavior.

You can use export MAUD_ON_ERROR=exit to make maud call std::process::exit during template-rendering whenever it turns out the code changes are too severe for hot-reloading. In combination with cargo watch, this can hot-reload your web app's templates when possible, and recompile when that fails:

MAUD_ON_ERROR=exit  cargo watch --no-restart -x run --features hotreload

This has some limitations because now rust code changes unrelated to templates will not cause the application to restart. Needs further improvements.

Internals

maud+hotreload will compile your template into two parts:

1. a list of "formatting arguments" where all the rust code in templates is eagerly evaluated
2. a runtime that opens the sourcecode found via file!(), tries to parse out the original macro invocation, and attempts to use the existing "formatting arguments" with that

This means that changes such as this can be hot-reloaded:

// before
html! {
    "Hello " (world) "!"
}

// after (no recompilation needed, as only static content changed)
html! {
    "Goodbye " (world) "!"
}

but this change requires proper recompilation:

// before
html! {
    "Hello " (world) "!"
}

// after (recompilation needed, as rust code changed)
html! {
    "Hello " (other_world) "!"
}

the compiled code is very inefficient, as it re-parses rust sourcecode at runtime (still faster than rustc). there are some complications, such as the hot-reloading:

• not working in doctests
• not working whenever the html! macro is aliased or used from within another macro
• not working when html! { } is written in a weird way, such as html! /* { */ {

Is this really for maud?

Even though there are no added dependencies, the feature is still a lot to maintain and required a lot of restructuring. I think most of the restructuring was unavoidable, and now there are three crates instead of two.

I don't necessarily have expectations that this will be merged, but on the other hand I also really want a template engine that is type-safe, has fast iteration-speeds and can be composed in a JSX-like way using regular Rust functions. I think maud+hotreload is the only standalone templating engine in the Rust ecosystem that can do that right now. So I'd be willing to fork maud and continue development there if people are interested. It seems there are a few other PRs that need attention anyway.

finally, thanks to @wrapperup for the initial prototype and architecture of hot-reloading.

[jrey8343]

This is exactly the feature I’m looking for!
Following 🍿🍿

[schalk-b]

This is a great contribution! Exactly what I'm looking for. I'm in favour of a fork with new contributors if this isn't being actively maintained.

[emschwartz]

I would also love something like this. I really like the experience of using Maud but the reload time makes web development quite a bit clunkier than working with a JS framework.

[PacificBird]

If this doesn't get merged I'd love to see a fork with this functionality! I am currently using a super simple Poem-Maud-HTMX stack and this would improve the dev experience dramatically!

[tryoxiss]

When compiling a release build it should always be static-only, no need to reconstruct trees at runtime for compile speed when compile speed isn't a concern :D