use instruction::{path_to_str, PathSlice};
use serde_json::Error as SerdeJsonError;
use serde_json::Value;
use std::error::Error as StdError;
use std::fmt;
#[derive(Debug)]
pub enum Error {
ParseError {
msg: String,
line: usize,
column: usize,
},
RenderError {
msg: String,
line: usize,
column: usize,
},
SerdeError {
err: SerdeJsonError,
},
GenericError {
msg: String,
},
StdFormatError {
err: fmt::Error,
},
CalledTemplateError {
name: String,
err: Box<Error>,
line: usize,
column: usize,
},
CalledFormatterError {
name: String,
err: Box<Error>,
line: usize,
column: usize,
},
#[doc(hidden)]
__NonExhaustive,
}
impl From<SerdeJsonError> for Error {
fn from(err: SerdeJsonError) -> Error {
Error::SerdeError { err }
}
}
impl From<fmt::Error> for Error {
fn from(err: fmt::Error) -> Error {
Error::StdFormatError { err }
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Error::ParseError { msg, line, column } => write!(
f,
"Failed to parse the template (line {}, column {}). Reason: {}",
line, column, msg
),
Error::RenderError { msg, line, column } => {
write!(
f,
"Encountered rendering error on line {}, column {}. Reason: {}",
line, column, msg
)
}
Error::SerdeError { err } => {
write!(f, "Unexpected serde error while converting the context to a serde_json::Value. Error: {}", err)
}
Error::GenericError { msg } => {
write!(f, "{}", msg)
}
Error::StdFormatError { err } => {
write!(f, "Unexpected formatting error: {}", err)
}
Error::CalledTemplateError {
name,
err,
line,
column,
} => {
write!(
f,
"Call to sub-template \"{}\" on line {}, column {} failed. Reason: {}",
name, line, column, err
)
}
Error::CalledFormatterError {
name,
err,
line,
column,
} => {
write!(
f,
"Call to value formatter \"{}\" on line {}, column {} failed. Reason: {}",
name, line, column, err
)
}
Error::__NonExhaustive => unreachable!(),
}
}
}
impl StdError for Error {
fn description(&self) -> &str {
match self {
Error::ParseError { .. } => "ParseError",
Error::RenderError { .. } => "RenderError",
Error::SerdeError { .. } => "SerdeError",
Error::GenericError { msg } => &msg,
Error::StdFormatError { .. } => "StdFormatError",
Error::CalledTemplateError { .. } => "CalledTemplateError",
Error::CalledFormatterError { .. } => "CalledFormatterError",
Error::__NonExhaustive => unreachable!(),
}
}
}
pub type Result<T> = ::std::result::Result<T, Error>;
pub(crate) fn lookup_error(source: &str, step: &str, path: PathSlice, current: &Value) -> Error {
let avail_str = if let Value::Object(object_map) = current {
let mut avail_str = " Available values at this level are ".to_string();
for (i, key) in object_map.keys().enumerate() {
if i > 0 {
avail_str.push_str(", ");
}
avail_str.push('\'');
avail_str.push_str(key);
avail_str.push('\'');
}
avail_str
} else {
"".to_string()
};
let (line, column) = get_offset(source, step);
Error::RenderError {
msg: format!(
"Failed to find value '{}' from path '{}'.{}",
step,
path_to_str(path),
avail_str
),
line,
column,
}
}
pub(crate) fn truthiness_error(source: &str, path: PathSlice) -> Error {
let (line, column) = get_offset(source, path.last().unwrap());
Error::RenderError {
msg: format!(
"Path '{}' produced a value which could not be checked for truthiness.",
path_to_str(path)
),
line,
column,
}
}
pub(crate) fn unprintable_error() -> Error {
Error::GenericError {
msg: "Expected a printable value but found array or object.".to_string(),
}
}
pub(crate) fn not_iterable_error(source: &str, path: PathSlice) -> Error {
let (line, column) = get_offset(source, path.last().unwrap());
Error::RenderError {
msg: format!(
"Expected an array for path '{}' but found a non-iterable value.",
path_to_str(path)
),
line,
column,
}
}
pub(crate) fn unknown_template(source: &str, name: &str) -> Error {
let (line, column) = get_offset(source, name);
Error::RenderError {
msg: format!("Tried to call an unknown template '{}'", name),
line,
column,
}
}
pub(crate) fn unknown_formatter(source: &str, name: &str) -> Error {
let (line, column) = get_offset(source, name);
Error::RenderError {
msg: format!("Tried to call an unknown formatter '{}'", name),
line,
column,
}
}
pub(crate) fn called_template_error(source: &str, template_name: &str, err: Error) -> Error {
let (line, column) = get_offset(source, template_name);
Error::CalledTemplateError {
name: template_name.to_string(),
err: Box::new(err),
line,
column,
}
}
pub(crate) fn called_formatter_error(source: &str, formatter_name: &str, err: Error) -> Error {
let (line, column) = get_offset(source, formatter_name);
Error::CalledFormatterError {
name: formatter_name.to_string(),
err: Box::new(err),
line,
column,
}
}
pub(crate) fn get_offset(source: &str, target: &str) -> (usize, usize) {
let offset = target.as_ptr() as isize - source.as_ptr() as isize;
let to_scan = &source[0..(offset as usize)];
let mut line = 1;
let mut column = 0;
for byte in to_scan.bytes() {
match byte as char {
'\n' => {
line += 1;
column = 0;
}
_ => {
column += 1;
}
}
}
(line, column)
}