use crate::error::{GarrisonError, GarrisonResult};
use crate::json::GarrisonJsonTemplate;
use std::collections::HashMap;
impl GarrisonJsonTemplate {
pub fn new(template: &str) -> GarrisonResult<Self> {
let value: serde_json::Value = serde_json::from_str(template)
.map_err(|e| GarrisonError::Internal(format!("json-template-parse::{}", e)))?;
Ok(Self { value })
}
pub fn render(&self, params: &HashMap<String, String>) -> GarrisonResult<String> {
let rendered = render_value(&self.value, params);
serde_json::to_string(&rendered)
.map_err(|e| GarrisonError::Internal(format!("json-serialize::{}", e)))
}
pub fn value(&self) -> &serde_json::Value {
&self.value
}
}
fn render_value(value: &serde_json::Value, params: &HashMap<String, String>) -> serde_json::Value {
match value {
serde_json::Value::String(s) => {
if s.contains("${") {
serde_json::Value::String(substitute(s, params))
} else {
value.clone()
}
},
serde_json::Value::Object(map) => {
let mut out = serde_json::Map::with_capacity(map.len());
for (k, v) in map {
out.insert(k.clone(), render_value(v, params));
}
serde_json::Value::Object(out)
},
serde_json::Value::Array(arr) => {
serde_json::Value::Array(arr.iter().map(|v| render_value(v, params)).collect())
},
_ => value.clone(),
}
}
fn substitute(s: &str, params: &HashMap<String, String>) -> String {
let mut out = String::with_capacity(s.len());
let mut rest = s;
while let Some(start) = rest.find("${") {
out.push_str(&rest[..start]);
let after = &rest[start + 2..];
match after.find('}') {
Some(end) => {
let key = &after[..end];
match params.get(key) {
Some(val) => out.push_str(val),
None => {
out.push_str("${");
out.push_str(key);
out.push('}');
},
}
rest = &after[end + 1..];
},
None => {
out.push_str("${");
rest = after;
},
}
}
out.push_str(rest);
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn substitute_does_not_rescan_replacement_values() {
let mut params = HashMap::new();
params.insert("a".to_string(), "${b}".to_string());
params.insert("b".to_string(), "X".to_string());
assert_eq!(substitute("v=${a}", ¶ms), "v=${b}");
}
#[test]
fn substitute_is_deterministic() {
let mut params = HashMap::new();
params.insert("b".to_string(), "X".to_string());
params.insert("a".to_string(), "${b}".to_string());
let first = substitute("${a} ${b}", ¶ms);
let second = substitute("${a} ${b}", ¶ms);
assert_eq!(first, second);
assert_eq!(first, "${b} X");
}
#[test]
fn substitute_keeps_unmatched_and_unclosed() {
let params: HashMap<String, String> = HashMap::new();
assert_eq!(substitute("a=${a} b=${b}", ¶ms), "a=${a} b=${b}");
assert_eq!(substitute("unclosed ${oops", ¶ms), "unclosed ${oops");
}
#[test]
fn render_nested_structures() {
let template =
GarrisonJsonTemplate::new(r#"{"o":{"s":"${x}"},"arr":["${x}",1,null],"n":5}"#).unwrap();
let mut params = HashMap::new();
params.insert("x".to_string(), "v".to_string());
let rendered: serde_json::Value =
serde_json::from_str(&template.render(¶ms).unwrap()).unwrap();
let expected: serde_json::Value =
serde_json::from_str(r#"{"o":{"s":"v"},"arr":["v",1,null],"n":5}"#).unwrap();
assert_eq!(rendered, expected);
}
}