Rust TinyTemplate with dynamic values (HashMap)? - rust

Question

I serve an Actix Web Rust website using the TinyTemplate crate, where they keys and values are defined in a TOML file that is serialized using the config crate.
This works great with predefined keys (known at compile time) like "title" but I want to add a dynamic "see also" section and I can't figure out how to implement this.
config.toml
title= "Example Title" # this works great
[seealso] # dynamic values, is this possible?
"Project Homepage" = "https://my-project-page.eu"
"Repository" = "https://github.com/myorg/myrepo"
template.html
{title}
{{ for x in seealso }}
...
{{ endfor }}
main.rs
[...]
#[derive(Serialize, Deserialize, Debug)]
pub struct Config {
pub title: String,
pub seealso: HashMap<String, String>,
}
impl Config {
pub fn new() -> Result<Self, ConfigError> {
config::Config::builder()
.add_source(File::from_str(DEFAULT, FileFormat::Toml))
.build()?
.try_deserialize()
}
}
[...]
lazy_static! {
pub static ref CONFIG: Config = Config::new().expect("Error reading configuration.");
}
[...]
let mut template = TinyTemplate::new();
template.add_template("index", INDEX).expect("Could not parse default template");
let body = template().render("index", &*CONFIG).unwrap();
Output
thread 'actix-rt|system:0|arbiter:0' panicked at 'called `Result::unwrap()` on an `Err` value: RenderError { msg: "Expected an array for path 'seealso' but found a non-iterable value.", line: 32, column: 17 }', src/main.rs:80:53
I assume that serde deserializes the HashMap into a JSON object, with the HashMap keys as object keys, which is why I assume Rust won't let me iterate over them. The problem is that TinyTemplate is quite basic in functionality by design, and won't let me put arbitrary code between {{ }} so I can't transform the object (struct?) into something that TinyTemplate can iterate over. I'm quite new to Rust so I may be missing something obvious here, but is there a way to use dynamic values like this with TinyTemplates or is there no way to handle HashMaps? The result doesn't have to use HashMaps though.
The goal is to achieve something like the following pseudocode:
{{ if ! seealso.empty() }}
See also:
<ul>
{{ for (key, value) in seealso }}
<li>{key}</li>
{{ endfor }}
</ul>
{{ endif }}

Answer 1

I have took a look on the code on tinytemplate. It converts the given object into a json object with serde and works with the json representation for further processing. Given a Hashmap, it will create an plain object node which isn't iterable according to the code of the crate.
You cloud create a pull request for the crate; iterating over object fields should be straight forward.
Another possible solution could be to create a second representation of your config.
use config::{ConfigError, File};
use lazy_static::lazy_static;
use serde::Deserialize;
use serde::Serialize;
use std::collections::HashMap;
use std::path::Path;
use tinytemplate::TinyTemplate;
#[derive(Serialize, Deserialize, Debug)]
pub struct Config {
pub title: String,
pub seealso: HashMap<String, String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct IterableConfig {
pub title: String,
pub seealso: Vec<(String, String)>,
}
impl Config {
pub fn new() -> Result<Self, ConfigError> {
config::Config::builder()
.add_source(File::from(Path::new("config.toml")))
.build()?
.try_deserialize()
}
}
lazy_static! {
pub static ref CONFIG: Config = Config::new().expect("Error reading configuration.");
}
fn main() {
let mut template = TinyTemplate::new();
template
.add_template(
"index",
"
{title}
{{ for x in seealso }}
{x.0}
{x.1}
{{ endfor }}
",
)
.expect("Could not parse default template");
let body = template
.render(
"index",
&IterableConfig {
title: CONFIG.title.clone(),
seealso: CONFIG
.seealso
.iter()
.map(|(k, v)| (k.clone(), v.clone()))
.collect(),
},
)
.unwrap();
eprintln!("{}", body);
}