use std::{
result::Result as StdResult,
str::Utf8Error,
string::FromUtf8Error,
};
use quick_xml::{
Reader,
events::attributes::AttrError,
};
use thiserror::Error;
use crate::parser::state::ParserContext;
#[derive(Debug, Default, Clone)]
pub struct ErrorContext {
pub byte_offset: u64,
pub line_id: Option<String>,
pub tag_stack: Vec<String>,
pub current_attribute: Option<String>,
pub offending_string: Option<String>,
}
#[derive(Error, Debug)]
pub enum ParseErrorKind {
#[error("XML attribute error: {0}")]
AttrError(#[from] AttrError),
#[error("Unknown XML entity: {0}")]
EntityError(String),
#[error("Invalid timestamp format: {0}")]
InvalidTimestamp(String),
#[error("Missing required attribute: {0}")]
MissingAttribute(String),
#[error("Unexpected end of file")]
UnexpectedEof,
#[error("XML parsing error: {0}")]
XmlError(#[from] quick_xml::Error),
}
#[derive(Error, Debug)]
pub enum TTMLProcessorError {
#[error("{kind} (at byte offset {0})", .context.byte_offset)]
ParseError {
kind: ParseErrorKind,
context: Box<ErrorContext>,
},
#[error("IO error: {0}")]
IoError(#[from] std::io::Error),
#[error("UTF-8 decoding error: {0}")]
Utf8Error(#[from] Utf8Error),
#[error("UTF-8 from bytes error: {0}")]
FromUtf8Error(#[from] FromUtf8Error),
}
impl From<TTMLProcessorError> for std::io::Error {
fn from(err: TTMLProcessorError) -> Self {
Self::other(err)
}
}
pub type Result<T> = StdResult<T, TTMLProcessorError>;
pub trait ResultExt<T> {
fn with_context(
self,
reader: &Reader<&[u8]>,
context: &ParserContext,
) -> StdResult<T, TTMLProcessorError>;
fn with_attr_context(
self,
reader: &Reader<&[u8]>,
context: &ParserContext,
attr_name: &str,
) -> StdResult<T, TTMLProcessorError>;
}
impl<T> ResultExt<T> for StdResult<T, ParseErrorKind> {
fn with_context(
self,
reader: &Reader<&[u8]>,
context: &ParserContext,
) -> StdResult<T, TTMLProcessorError> {
self.map_err(|kind| TTMLProcessorError::ParseError {
kind,
context: Box::new(ErrorContext {
byte_offset: reader.buffer_position(),
line_id: context.current_line_id.clone(),
tag_stack: context.tag_stack.clone(),
current_attribute: None,
offending_string: None,
}),
})
}
fn with_attr_context(
self,
reader: &Reader<&[u8]>,
context: &ParserContext,
attr_name: &str,
) -> StdResult<T, TTMLProcessorError> {
self.map_err(|kind| TTMLProcessorError::ParseError {
kind,
context: Box::new(ErrorContext {
byte_offset: reader.buffer_position(),
line_id: context.current_line_id.clone(),
tag_stack: context.tag_stack.clone(),
current_attribute: Some(attr_name.to_string()),
offending_string: None,
}),
})
}
}
pub trait OptionExt<T> {
fn context_missing_attr(
self,
reader: &Reader<&[u8]>,
context: &ParserContext,
attr_name: &str,
) -> StdResult<T, TTMLProcessorError>;
}
impl<T> OptionExt<T> for Option<T> {
fn context_missing_attr(
self,
reader: &Reader<&[u8]>,
context: &ParserContext,
attr_name: &str,
) -> StdResult<T, TTMLProcessorError> {
self.ok_or_else(|| ParseErrorKind::MissingAttribute(attr_name.to_string()))
.with_attr_context(reader, context, attr_name)
}
}