use super::{TexElement, TexParser};
use std::path::PathBuf;
impl TexParser {
pub(super) fn parse_section(&mut self, level: u8) -> Option<TexElement> {
let cmd = match level {
0 => "\\part",
1 => "\\section",
2 => "\\subsection",
3 => "\\subsubsection",
4 => "\\paragraph",
5 => "\\subparagraph",
6 => "\\chapter",
_ => "\\section",
};
self.position += cmd.len();
if self.content[self.position..].starts_with('*') {
self.position += 1;
}
self.skip_whitespace_and_comments();
self.parse_braced_content().map(|title| TexElement::Section {
level: level as usize,
title: clean_title(&title),
})
}
pub(super) fn parse_command(&mut self, name: &str) -> Option<TexElement> {
self.position += name.len() + 1;
self.skip_whitespace_and_comments();
self.parse_braced_content().map(|arg| TexElement::Command {
name: name.to_string(),
args: vec![arg],
})
}
pub(super) fn parse_text_command(&mut self) -> Option<TexElement> {
let remaining = &self.content[self.position..];
let (cmd_name, cmd_len) = if remaining.starts_with("\\texttt{") {
("texttt", 7)
} else if remaining.starts_with("\\textbf{") {
("textbf", 7)
} else if remaining.starts_with("\\textit{") {
("textit", 7)
} else if remaining.starts_with("\\emph{") {
("emph", 5)
} else {
return None;
};
self.position += cmd_len;
self.parse_braced_content().map(|arg| TexElement::Command {
name: cmd_name.to_string(),
args: vec![arg],
})
}
pub(super) fn parse_includegraphics(&mut self) -> Option<TexElement> {
self.position += "\\includegraphics".len();
self.skip_whitespace_and_comments();
let mut width = None;
let mut height = None;
if self.position < self.content.len() && self.content[self.position..].starts_with('[') {
self.position += 1;
let opts = self.read_until(']');
self.position += 1;
for part in opts.split(',') {
let part = part.trim();
if let Some(val) = part.strip_prefix("width=") {
width = Some(val.trim().to_string());
} else if let Some(val) = part.strip_prefix("height=") {
height = Some(val.trim().to_string());
}
}
}
self.skip_whitespace_and_comments();
let path = self.parse_braced_content()?;
Some(TexElement::Image {
path,
width,
height,
})
}
pub(super) fn parse_textcolor(&mut self) -> Option<TexElement> {
self.position += "\\textcolor".len();
self.skip_whitespace_and_comments();
let color = self.parse_braced_content()?;
self.skip_whitespace_and_comments();
let text = self.parse_braced_content()?;
Some(TexElement::ColoredText { color, text })
}
pub(super) fn parse_cite(&mut self) -> Option<TexElement> {
self.position += "\\cite".len();
self.skip_whitespace_and_comments();
let keys_str = self.parse_braced_content()?;
let keys: Vec<String> = keys_str
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
Some(TexElement::Citation { keys, kind: "cite".to_string() })
}
pub(super) fn parse_nocite(&mut self) -> Option<TexElement> {
self.position += "\\nocite".len();
self.skip_whitespace_and_comments();
let keys_str = self.parse_braced_content()?;
let keys: Vec<String> = keys_str
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
Some(TexElement::Citation { keys, kind: "nocite".to_string() })
}
pub(super) fn parse_cite_variant(&mut self, cmd_name: &str) -> Option<TexElement> {
self.position += cmd_name.len();
self.skip_whitespace_and_comments();
let keys_str = self.parse_braced_content()?;
let keys: Vec<String> = keys_str
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
Some(TexElement::Citation { keys, kind: cmd_name[1..].to_string() })
}
pub(super) fn parse_label(&mut self) -> Option<TexElement> {
self.position += "\\label".len();
self.skip_whitespace_and_comments();
let key = self.parse_braced_content()?;
Some(TexElement::Label { key })
}
pub(super) fn parse_ref(&mut self) -> Option<TexElement> {
let remaining = &self.content[self.position..];
let cmd_len = [
"\\eqref", "\\autoref", "\\nameref", "\\cref", "\\Cref", "\\ref",
]
.iter()
.find_map(|cmd| {
if remaining.starts_with(cmd) {
Some(cmd.len())
} else {
None
}
})
.unwrap_or("\\ref".len());
self.position += cmd_len;
self.skip_whitespace_and_comments();
let key = self.parse_braced_content()?;
Some(TexElement::Ref { key })
}
pub(super) fn parse_pageref(&mut self) -> Option<TexElement> {
self.position += "\\pageref".len();
self.skip_whitespace_and_comments();
let key = self.parse_braced_content()?;
Some(TexElement::PageRef { key })
}
pub(super) fn parse_pagebreak(&mut self) -> Option<TexElement> {
let name = if self.content[self.position..].starts_with("\\newpage") {
self.position += "\\newpage".len();
"newpage"
} else if self.content[self.position..].starts_with("\\clearpage") {
self.position += "\\clearpage".len();
"clearpage"
} else if self.content[self.position..].starts_with("\\pagebreak") {
self.position += "\\pagebreak".len();
"pagebreak"
} else {
"newpage"
};
Some(TexElement::Command {
name: name.to_string(),
args: vec![],
})
}
pub(super) fn parse_input(&mut self) -> Option<TexElement> {
self.position += "\\input".len();
let filename = if self.content[self.position..].starts_with('{') {
self.position += 1;
let name = self.read_until('}');
self.position += 1; name
} else {
self.skip_whitespace_and_comments();
let start = self.position;
let rest = &self.content[self.position..];
let end = rest
.find(|c: char| c.is_whitespace() || c == '\\' || c == '%' || c == '{')
.unwrap_or(rest.len());
self.position += end;
self.content[start..self.position].to_string()
};
self.splice_file(&filename);
None
}
pub(super) fn parse_include(&mut self) -> Option<TexElement> {
self.position += "\\include{".len();
let filename = self.read_until('}');
self.position += 1;
let before = self.content[..self.position].to_string();
let after = self.content[self.position..].to_string();
self.content = format!("{}\\clearpage\n", before);
let insert_pos = self.content.len();
self.content = format!("{}\n\\clearpage\n{}", self.content, after);
let saved = self.position;
self.position = insert_pos;
self.splice_file(&filename);
self.position = saved + "\\clearpage\n".len();
None
}
fn splice_file(&mut self, filename: &str) {
let mut candidates = Vec::new();
if let Some(ref base) = self.base_dir {
candidates.push(base.join(filename));
}
for dir in &self.search_paths {
candidates.push(dir.join(filename));
}
candidates.push(PathBuf::from(filename));
for mut path in candidates {
if path.extension().is_none() {
path.set_extension("tex");
}
if let Ok(content) = std::fs::read_to_string(&path) {
let before = &self.content[..self.position];
let after = &self.content[self.position..];
self.content = format!("{}{}\n{}", before, content, after);
break;
}
}
}
pub(super) fn parse_vspace(&mut self) -> Option<TexElement> {
self.position += "\\vspace{".len();
let length = self.read_until('}');
self.position += 1; Some(TexElement::Command {
name: "vspace".to_string(),
args: vec![length],
})
}
pub(super) fn parse_underline(&mut self) -> Option<TexElement> {
self.position += "\\underline{".len();
let text = self.read_until('}');
self.position += 1; Some(TexElement::Command {
name: "underline".to_string(),
args: vec![text],
})
}
pub(super) fn parse_footnote(&mut self) -> Option<TexElement> {
self.position += "\\footnote{".len();
let text = self.read_until('}');
self.position += 1; Some(TexElement::Footnote { text })
}
pub(super) fn parse_caption(&mut self) -> Option<TexElement> {
self.position += "\\caption{".len();
let text = self.read_until('}');
self.position += 1; Some(TexElement::Caption { text })
}
pub(super) fn parse_url(&mut self) -> Option<TexElement> {
self.position += "\\url{".len();
let text = self.read_until('}');
self.position += 1; Some(TexElement::Command {
name: "url".to_string(),
args: vec![text],
})
}
pub(super) fn parse_verb(&mut self) -> Option<TexElement> {
let remaining = &self.content[self.position..];
let cmd_len = if remaining.starts_with("\\lstinline") {
"\\lstinline".len()
} else {
"\\verb".len()
};
self.position += cmd_len;
if self.position < self.content.len() && self.content[self.position..].starts_with('*') {
self.position += 1;
}
if self.position >= self.content.len() {
return None;
}
let delim = self.content[self.position..].chars().next()?;
self.position += delim.len_utf8();
let text = self.read_until(delim);
self.position += delim.len_utf8();
Some(TexElement::CodeBlock(text))
}
pub(super) fn parse_href(&mut self) -> Option<TexElement> {
self.position += "\\href{".len();
let url = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let text = if self.content[self.position..].starts_with('{') {
self.position += 1;
let t = self.read_until('}');
self.position += 1;
t
} else {
String::new()
};
Some(TexElement::Command {
name: "href".to_string(),
args: vec![url, text],
})
}
pub(super) fn parse_raisebox(&mut self) -> Option<TexElement> {
self.position += "\\raisebox{".len();
let distance = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let text = if self.content[self.position..].starts_with('{') {
self.position += 1;
let t = self.read_until('}');
self.position += 1;
t
} else {
String::new()
};
Some(TexElement::Command {
name: "raisebox".to_string(),
args: vec![distance, text],
})
}
pub(super) fn parse_rotatebox(&mut self) -> Option<TexElement> {
self.position += "\\rotatebox{".len();
let angle = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let text = if self.content[self.position..].starts_with('{') {
self.position += 1;
let t = self.read_until('}');
self.position += 1;
t
} else {
String::new()
};
Some(TexElement::Command {
name: "rotatebox".to_string(),
args: vec![angle, text],
})
}
pub(super) fn parse_scalebox(&mut self) -> Option<TexElement> {
self.position += "\\scalebox{".len();
let factor = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let text = if self.content[self.position..].starts_with('{') {
self.position += 1;
let t = self.read_until('}');
self.position += 1;
t
} else {
String::new()
};
Some(TexElement::Command {
name: "scalebox".to_string(),
args: vec![factor, text],
})
}
pub(super) fn parse_colorbox(&mut self) -> Option<TexElement> {
self.position += "\\colorbox{".len();
let color = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let text = if self.content[self.position..].starts_with('{') {
self.position += 1;
let t = self.read_until('}');
self.position += 1;
t
} else {
String::new()
};
Some(TexElement::Command {
name: "colorbox".to_string(),
args: vec![color, text],
})
}
pub(super) fn parse_fcolorbox(&mut self) -> Option<TexElement> {
self.position += "\\fcolorbox{".len();
let frame = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let back = if self.content[self.position..].starts_with('{') {
self.position += 1;
let b = self.read_until('}');
self.position += 1;
b
} else {
String::new()
};
self.skip_whitespace_and_comments();
let text = if self.content[self.position..].starts_with('{') {
self.position += 1;
let t = self.read_until('}');
self.position += 1;
t
} else {
String::new()
};
Some(TexElement::Command {
name: "fcolorbox".to_string(),
args: vec![frame, back, text],
})
}
pub(super) fn parse_simple_braced_command(
&mut self,
name: &str,
prefix_len: usize,
) -> Option<TexElement> {
self.position += prefix_len;
let text = self.read_until('}');
self.position += 1; Some(TexElement::Command {
name: name.to_string(),
args: vec![text],
})
}
pub(super) fn parse_resizebox(&mut self) -> Option<TexElement> {
self.position += "\\resizebox".len();
self.skip_whitespace_and_comments();
let width = self.parse_braced_content()?;
self.skip_whitespace_and_comments();
let height = self.parse_braced_content()?;
self.skip_whitespace_and_comments();
let content = self.parse_braced_content()?;
Some(TexElement::Command {
name: "resizebox".to_string(),
args: vec![width, height, content],
})
}
pub(super) fn parse_rule(&mut self) -> Option<TexElement> {
self.position += "\\rule{".len();
let width = self.read_until('}');
self.position += 1; self.skip_whitespace_and_comments();
let height = if self.content[self.position..].starts_with('{') {
self.position += 1;
let h = self.read_until('}');
self.position += 1;
h
} else {
String::new()
};
Some(TexElement::Command {
name: "rule".to_string(),
args: vec![width, height],
})
}
pub(super) fn parse_unknown_command(&mut self) {
if self.position >= self.content.len() {
return;
}
self.position += 1;
while self.position < self.content.len() {
let remaining = &self.content[self.position..];
let Some(ch) = remaining.chars().next() else {
break;
};
if ch.is_alphabetic() || ch == '*' {
self.position += ch.len_utf8();
} else {
break;
}
}
self.skip_whitespace_and_comments();
}
pub(super) fn parse_parbox(&mut self) -> Option<TexElement> {
self.position += "\\parbox".len();
self.skip_whitespace_and_comments();
if self.position < self.content.len() && self.content[self.position..].starts_with('[') {
self.position += 1;
let _ = self.read_until(']');
self.position += 1;
self.skip_whitespace_and_comments();
}
if self.position < self.content.len() && self.content[self.position..].starts_with('{') {
let _ = self.parse_braced_content();
self.skip_whitespace_and_comments();
}
let text = if self.position < self.content.len() && self.content[self.position..].starts_with('{') {
self.parse_braced_content().unwrap_or_default()
} else {
String::new()
};
Some(TexElement::Command {
name: "parbox".to_string(),
args: vec![text],
})
}
pub(super) fn parse_makebox(&mut self) -> Option<TexElement> {
self.position += "\\makebox".len();
self.skip_whitespace_and_comments();
if self.position < self.content.len() && self.content[self.position..].starts_with('[') {
self.position += 1;
let _ = self.read_until(']');
self.position += 1;
self.skip_whitespace_and_comments();
}
if self.position < self.content.len() && self.content[self.position..].starts_with('[') {
self.position += 1;
let _ = self.read_until(']');
self.position += 1;
self.skip_whitespace_and_comments();
}
let text = if self.position < self.content.len() && self.content[self.position..].starts_with('{') {
self.parse_braced_content().unwrap_or_default()
} else {
String::new()
};
Some(TexElement::Command {
name: "makebox".to_string(),
args: vec![text],
})
}
pub(super) fn parse_multicolumn(&mut self) -> Option<TexElement> {
self.position += "\\multicolumn".len();
self.skip_whitespace_and_comments();
let n = self.parse_braced_content().unwrap_or_default();
self.skip_whitespace_and_comments();
let align = self.parse_braced_content().unwrap_or_default();
self.skip_whitespace_and_comments();
let content = self.parse_braced_content().unwrap_or_default();
Some(TexElement::Command {
name: "multicolumn".to_string(),
args: vec![n, align, content],
})
}
}
pub(super) fn clean_title(title: &str) -> String {
let mut out = String::with_capacity(title.len());
let mut i = 0usize;
while i < title.len() {
match title[i..].find("\\texorpdfstring") {
Some(rel) => {
out.push_str(&title[i..i + rel]);
let mut j = i + rel + "\\texorpdfstring".len();
let mut kept = String::new();
for _ in 0..2 {
let before_trim = &title[j..];
let trimmed = before_trim.trim_start();
j += before_trim.len() - trimmed.len();
if let Some(after) = trimmed.strip_prefix('{') {
if let Some(end) = after.find('}') {
if kept.is_empty() {
kept = after[..end].to_string();
}
j += 1 + end + 1;
continue;
}
}
break;
}
out.push_str(&kept);
i = j;
}
None => {
out.push_str(&title[i..]);
break;
}
}
}
out.replace('~', " ")
}
#[cfg(test)]
mod tests {
use super::clean_title;
#[test]
fn texorpdfstring_keeps_tex_form() {
assert_eq!(clean_title(r"Intro\texorpdfstring{~x}{ y}"), "Intro x");
assert_eq!(clean_title(r"\texorpdfstring{A}{B}"), "A");
assert_eq!(clean_title("plain"), "plain");
assert_eq!(clean_title(r"a~b"), "a b");
}
}