use crate::check;
use crate::common::error::{CompileError, LoadError, RenderError};
use crate::common::limits::MAX_SOURCE_BYTES;
use crate::common::value::Value;
use crate::eval;
use crate::syntax::ast::Module;
use crate::syntax::{blob, format, parser};
use serde::de::DeserializeOwned;
#[derive(Debug, Clone)]
pub struct Template {
module: Module,
output_order: Vec<usize>,
}
impl Template {
pub fn compile(src: &str) -> Result<Self, Vec<CompileError>> {
check_size(src)?;
let module = parser::parse_module(src)?;
let output_order = check::check_module(&module)?;
Ok(Template {
module,
output_order,
})
}
pub fn validate(src: &str) -> Result<(), Vec<CompileError>> {
Self::compile(src).map(|_| ())
}
pub fn format(src: &str) -> Result<String, Vec<CompileError>> {
check_size(src)?;
let module = parser::parse_module(src)?;
Ok(format::format_module(&module))
}
pub fn to_bytes(&self) -> Vec<u8> {
blob::encode(&self.module)
}
pub fn from_bytes(bytes: &[u8]) -> Result<Self, LoadError> {
let module = blob::decode(bytes)?;
let output_order = check::check_module(&module).map_err(|errors| {
LoadError::Corrupt(format!(
"blob failed validation ({} error(s))",
errors.len()
))
})?;
Ok(Template {
module,
output_order,
})
}
pub fn render<T>(&self, input: impl Into<Value>) -> Result<T, RenderError>
where
T: DeserializeOwned,
{
self.render_ref(&input.into())
}
pub fn render_ref<T>(&self, input: &Value) -> Result<T, RenderError>
where
T: DeserializeOwned,
{
let output = self.render_value_ref(input)?;
T::deserialize(&output).map_err(|e| RenderError::Deserialize(e.to_string()))
}
pub fn render_value(&self, input: impl Into<Value>) -> Result<Value, RenderError> {
self.render_value_ref(&input.into())
}
pub fn render_value_ref(&self, input: &Value) -> Result<Value, RenderError> {
eval::run_template(&self.module, &self.output_order, input)
}
}
fn check_size(src: &str) -> Result<(), Vec<CompileError>> {
if src.len() > MAX_SOURCE_BYTES {
return Err(vec![CompileError::TooLarge {
bytes: src.len(),
limit: MAX_SOURCE_BYTES,
}]);
}
Ok(())
}