use minijinja::value::Serde;
use minijinja::{Error, ErrorKind};
use serde_json::Value;
use super::template_environment::build_template_environment;
use super::template_functions::TemplateFunctions;
use super::template_postman_aliases::rewrite_postman_aliases;
use super::template_problems::{build_problem, find_template_problems};
pub const MAXIMUM_RENDERED_BYTES: usize = 1024 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TemplateEscape {
None,
JsonString,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TemplateRenderMode {
Lenient,
Strict,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TemplateProblemSeverity {
Warning,
Error,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TemplateProblem {
pub severity: TemplateProblemSeverity,
pub message: String,
pub line: Option<usize>,
pub column: Option<usize>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RenderedTemplate {
pub text: String,
pub problems: Vec<TemplateProblem>,
}
impl RenderedTemplate {
pub fn has_errors(&self) -> bool {
self.problems
.iter()
.any(|problem| problem.severity == TemplateProblemSeverity::Error)
}
}
pub fn render_template(
template_text: &str,
template_context: &Value,
template_functions: &dyn TemplateFunctions,
escape: TemplateEscape,
) -> RenderedTemplate {
render_template_in_mode(
template_text,
template_context,
template_functions,
escape,
TemplateRenderMode::Lenient,
)
}
pub fn render_template_in_mode(
template_text: &str,
template_context: &Value,
template_functions: &dyn TemplateFunctions,
escape: TemplateEscape,
render_mode: TemplateRenderMode,
) -> RenderedTemplate {
let template_text: &str = &rewrite_postman_aliases(template_text);
let function_names = template_functions.function_names();
let mut problems = find_template_problems(
template_text,
template_context,
&function_names,
render_mode == TemplateRenderMode::Lenient,
);
let static_result = RenderedTemplate {
text: template_text.to_owned(),
problems: problems.clone(),
};
if static_result.has_errors() {
return static_result;
}
let environment =
build_template_environment(template_functions.to_shared(), escape, render_mode);
let render_result = environment.render_str(
template_text,
minijinja::Value::from(Serde(template_context)),
);
let rendered_text = match render_result {
Ok(rendered_text) if rendered_text.len() > MAXIMUM_RENDERED_BYTES => {
let message = "The rendered text is over 1 MB".to_owned();
problems.push(build_problem(
template_text,
TemplateProblemSeverity::Error,
message,
0,
));
String::new()
}
Ok(rendered_text) => rendered_text,
Err(render_error) => {
problems.push(describe_render_error(template_text, &render_error));
String::new()
}
};
RenderedTemplate {
text: rendered_text,
problems,
}
}
fn read_error_source(template_text: &str, render_error: &Error) -> Option<String> {
let error_range = render_error.range()?;
let path_start = template_text
.get(..error_range.start)?
.rfind(|character: char| {
!(character.is_ascii_alphanumeric() || matches!(character, '_' | '.' | '[' | ']'))
})
.map_or(0, |boundary_index| boundary_index + 1);
let source_text = template_text.get(path_start..error_range.end)?;
let expression_text = source_text
.trim()
.trim_start_matches("{{")
.trim_end_matches("}}")
.trim();
(!expression_text.is_empty()).then(|| expression_text.to_owned())
}
pub(super) fn describe_render_error(template_text: &str, render_error: &Error) -> TemplateProblem {
let detail = render_error.detail().unwrap_or_default();
let message = match render_error.kind() {
ErrorKind::UndefinedError => match read_error_source(template_text, render_error) {
Some(expression_text) => format!("Undefined variable: {expression_text}"),
None => "Undefined variable".to_owned(),
},
ErrorKind::SyntaxError => format!("Syntax error: {detail}"),
ErrorKind::OutOfFuel => "The template ran too long and was stopped".to_owned(),
ErrorKind::UnknownFilter => format!("Unknown filter: {detail}"),
ErrorKind::UnknownFunction => format!("Unknown function: {detail}"),
other_kind if detail.is_empty() => other_kind.to_string(),
_ => detail.to_owned(),
};
let byte_offset = render_error
.range()
.map(|error_range| error_range.start)
.or_else(|| {
let error_line = render_error.line()?;
Some(line_start_offset(template_text, error_line))
})
.unwrap_or(0);
build_problem(
template_text,
TemplateProblemSeverity::Error,
message,
byte_offset,
)
}
fn line_start_offset(template_text: &str, line: usize) -> usize {
template_text
.match_indices('\n')
.nth(line.saturating_sub(2))
.filter(|_| line > 1)
.map_or(0, |(newline_index, _)| newline_index + 1)
}