use quick_xml::{
Reader,
events::Event,
};
use crate::{
constants::{
attrs,
tags,
vals,
},
error::{
ParseErrorKind,
Result,
ResultExt as _,
TTMLProcessorError,
},
model::{
SubLyricContent,
Syllable,
},
parser::{
ext::{
BytesStartExt as _,
QNameExt as _,
ReaderExt as _,
},
state::ParserContext,
utils::{
build_full_text,
is_spacing_text,
mark_slice_last_space,
normalize_words_spaces,
parse_basic_syllable,
resolve_xml_entity,
},
},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SubLyricType {
Translation,
Transliteration,
}
pub fn parse_sub_lyrics(
reader: &mut Reader<&[u8]>,
context: &mut ParserContext,
group_tag: &str,
item_tag: &str,
sub_type: SubLyricType,
) -> Result<()> {
let mut buf = Vec::new();
loop {
match reader.read_event_with_context(&mut buf, context)? {
Event::Start(ref e) => {
let qname = e.name();
let tag_name =
std::str::from_utf8(qname.as_ref()).map_err(TTMLProcessorError::Utf8Error)?;
context.tag_stack.push(tag_name.to_string());
if qname.is(item_tag) {
let lang = e.get_attr_value(attrs::XML_LANG, reader, context)?;
parse_sub_lyric_block(reader, context, item_tag, lang.as_ref(), sub_type)?;
context.tag_stack.pop();
}
}
Event::End(ref e) => {
if e.name().is(group_tag) {
break;
}
context.tag_stack.pop();
}
Event::Eof => return Err(ParseErrorKind::UnexpectedEof).with_context(reader, context),
_ => (),
}
buf.clear();
}
Ok(())
}
fn parse_sub_lyric_block(
reader: &mut Reader<&[u8]>,
context: &mut ParserContext,
item_tag: &str,
lang: Option<&String>,
sub_type: SubLyricType,
) -> Result<()> {
let mut buf = Vec::new();
loop {
match reader.read_event_with_context(&mut buf, context)? {
Event::Start(ref e) => {
let qname = e.name();
let tag_name =
std::str::from_utf8(qname.as_ref()).map_err(TTMLProcessorError::Utf8Error)?;
context.tag_stack.push(tag_name.to_string());
if qname.is(tags::TEXT) {
let line_id = e.get_required_attr(attrs::FOR, reader, context)?;
parse_sub_lyric_text(reader, context, line_id, lang, sub_type)?;
context.tag_stack.pop();
}
}
Event::End(ref e) => {
if e.name().is(item_tag) {
break;
}
context.tag_stack.pop();
}
Event::Eof => return Err(ParseErrorKind::UnexpectedEof).with_context(reader, context),
_ => (),
}
buf.clear();
}
Ok(())
}
fn parse_sub_lyric_text(
reader: &mut Reader<&[u8]>,
context: &mut ParserContext,
line_id: String,
lang: Option<&String>,
sub_type: SubLyricType,
) -> Result<()> {
context.current_line_id = Some(line_id.clone());
let mut main_words: Vec<Syllable> = Vec::new();
let mut bg_words: Vec<Syllable> = Vec::new();
let mut raw_main_text = String::new();
let mut raw_bg_text = String::new();
let mut in_bg_span = false;
let mut buf = Vec::new();
loop {
match reader.read_event_with_context(&mut buf, context)? {
Event::Start(ref e) => {
let qname = e.name();
let tag_name =
std::str::from_utf8(qname.as_ref()).map_err(TTMLProcessorError::Utf8Error)?;
context.tag_stack.push(tag_name.to_string());
if qname.is(tags::SPAN) {
let mut is_current_bg = false;
for attr_res in e.attributes().flatten() {
if attr_res.key.as_ref() == attrs::b::TTM_ROLE {
is_current_bg = attr_res.value.as_ref() == vals::b::ROLE_BG;
break;
}
}
if is_current_bg {
in_bg_span = true;
} else {
let syllable = parse_basic_syllable(reader, context, e)?;
if in_bg_span {
bg_words.push(syllable);
} else {
main_words.push(syllable);
}
context.tag_stack.pop();
}
}
}
Event::End(ref e) => {
if e.name().is(tags::SPAN) {
in_bg_span = false;
context.tag_stack.pop();
} else if e.name().is(tags::TEXT) {
break;
} else {
context.tag_stack.pop();
}
}
Event::Text(e) => {
let text_str =
std::str::from_utf8(e.as_ref()).map_err(TTMLProcessorError::Utf8Error)?;
if is_spacing_text(text_str) {
let target_words = if in_bg_span {
&mut bg_words
} else {
&mut main_words
};
mark_slice_last_space(target_words);
}
if in_bg_span {
raw_bg_text.push_str(text_str);
} else {
raw_main_text.push_str(text_str);
}
}
Event::GeneralRef(reference) => {
let ch_str = resolve_xml_entity(&reference).with_context(reader, context)?;
if in_bg_span {
raw_bg_text.push_str(&ch_str);
} else {
raw_main_text.push_str(&ch_str);
}
}
Event::Eof => return Err(ParseErrorKind::UnexpectedEof).with_context(reader, context),
_ => (),
}
buf.clear();
}
context.current_line_id = None;
if let Some(last) = main_words.last_mut() {
last.ends_with_space = None;
}
if let Some(last) = bg_words.last_mut() {
last.ends_with_space = None;
}
let build_content = |mut words: Vec<Syllable>, raw_text: String| -> Option<SubLyricContent> {
if words.is_empty() {
let text = raw_text.trim().to_string();
if text.is_empty() {
None
} else {
Some(SubLyricContent {
language: lang.cloned(),
text,
words: None,
})
}
} else {
normalize_words_spaces(&mut words);
let text = build_full_text(&words, false);
Some(SubLyricContent {
language: lang.cloned(),
text,
words: Some(words),
})
}
};
if let Some(main_content) = build_content(main_words, raw_main_text) {
let map = match sub_type {
SubLyricType::Translation => &mut context.translations_map,
SubLyricType::Transliteration => &mut context.romanizations_map,
};
map.entry(line_id.clone()).or_default().push(main_content);
}
if let Some(bg_content) = build_content(bg_words, raw_bg_text) {
let bg_map = match sub_type {
SubLyricType::Translation => &mut context.bg_translations_map,
SubLyricType::Transliteration => &mut context.bg_romanizations_map,
};
bg_map.entry(line_id).or_default().push(bg_content);
}
Ok(())
}
#[cfg(test)]
mod tests {
use quick_xml::events::Event;
use super::*;
use crate::parser::state::ParserContext;
fn advance_to_start_tag(reader: &mut Reader<&[u8]>, tag_name: &str) {
let mut buf = Vec::new();
loop {
match reader.read_event_into(&mut buf) {
Ok(Event::Start(ref e)) if e.name().is(tag_name) => break,
Ok(Event::Eof) => panic!("Reached EOF before finding tag: {tag_name}"),
_ => (),
}
buf.clear();
}
}
#[test]
fn test_parse_sub_lyric_text() {
let xml = r#"
<text for="L1">
<span begin="0.000" end="1.000">测</span>
<span begin="1.000" end="2.000">试</span>
<span ttm:role="x-bg">
<span begin="1.000" end="2.000">(背景)</span>
</span>
</text>"#;
let mut reader = Reader::from_str(xml);
let mut context = ParserContext::default();
let lang = "zh-Hans".to_string();
advance_to_start_tag(&mut reader, "text");
parse_sub_lyric_text(
&mut reader,
&mut context,
"L1".to_string(),
Some(&lang),
SubLyricType::Translation,
)
.expect("Failed to parse sub lyric text");
assert!(context.translations_map.contains_key("L1"));
let main_content = &context.translations_map["L1"][0];
assert_eq!(main_content.language.as_deref(), Some("zh-Hans"));
assert_eq!(main_content.text, "测试");
assert_eq!(main_content.words.as_ref().unwrap().len(), 2);
assert_eq!(main_content.words.as_ref().unwrap()[0].text, "测");
assert!(context.bg_translations_map.contains_key("L1"));
let bg_content = &context.bg_translations_map["L1"][0];
assert_eq!(bg_content.text, "(背景)");
assert_eq!(bg_content.words.as_ref().unwrap().len(), 1);
assert_eq!(bg_content.words.as_ref().unwrap()[0].text, "(背景)");
}
#[test]
fn test_parse_sub_lyric_block() {
let xml = r#"
<translation xml:lang="zh-Hans">
<text for="L10">
<span begin="0.0" end="1.0">第</span>
<span begin="1.0" end="2.0">十</span>
<span begin="2.0" end="3.0">行</span>
</text>
<text for="L11">只有纯文本翻译</text>
</translation>"#;
let mut reader = Reader::from_str(xml);
let mut context = ParserContext::default();
let lang = "zh-Hans".to_string();
advance_to_start_tag(&mut reader, "translation");
parse_sub_lyric_block(
&mut reader,
&mut context,
"translation",
Some(&lang),
SubLyricType::Translation,
)
.expect("Failed to parse sub lyric block");
assert!(context.translations_map.contains_key("L10"));
let l10_content = &context.translations_map["L10"][0];
assert_eq!(l10_content.text, "第十行");
assert!(l10_content.words.is_some());
assert_eq!(l10_content.words.as_ref().unwrap().len(), 3);
assert!(context.translations_map.contains_key("L11"));
let l11_content = &context.translations_map["L11"][0];
assert_eq!(l11_content.text, "只有纯文本翻译");
assert!(l11_content.words.is_none());
}
#[test]
fn test_parse_sub_lyrics() {
let xml = r#"
<transliterations>
<transliteration xml:lang="zh-Latn-pinyin">
<text for="L1">
<span begin="0.0" end="1.0">pīn</span> <span begin="1.0" end="2.0">yīn</span>
</text>
<text for="L2">
<span begin="1.0" end="2.0">abc</span>
<span begin="1.0" end="2.0">def</span>
</text>
</transliteration>
</transliterations>"#;
let mut reader = Reader::from_str(xml);
let mut context = ParserContext::default();
advance_to_start_tag(&mut reader, "transliterations");
parse_sub_lyrics(
&mut reader,
&mut context,
"transliterations",
"transliteration",
SubLyricType::Transliteration,
)
.expect("Failed to parse sub lyrics");
assert!(context.romanizations_map.contains_key("L1"));
assert!(context.translations_map.is_empty());
let rom_content1 = &context.romanizations_map["L1"][0];
assert_eq!(rom_content1.language.as_deref(), Some("zh-Latn-pinyin"));
assert_eq!(rom_content1.text, "pīn yīn");
assert_eq!(rom_content1.words.as_ref().unwrap().len(), 2);
let rom_content2 = &context.romanizations_map["L2"][0];
assert_eq!(rom_content2.language.as_deref(), Some("zh-Latn-pinyin"));
assert_eq!(rom_content2.text, "abcdef");
assert_eq!(rom_content2.words.as_ref().unwrap().len(), 2);
}
}