1use crate::model::{
2 DocNode, ParagraphChildNode, ParagraphNode, ParagraphNodeType, TextRunNode, TextRunNodeType,
3};
4
5use super::body::body_xml;
6use super::context::ParseContext;
7use super::paragraph::parse_paragraph;
8use super::table::parse_table;
9
10#[derive(Debug, Clone, PartialEq, Eq)]
11pub struct BodyTokenRange {
12 pub start: usize,
13 pub end: usize,
14 pub kind: BodyTokenKind,
15}
16
17#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub enum BodyTokenKind {
19 Table,
20 Paragraph,
21}
22
23pub fn extract_body_token_ranges(body_xml: &str) -> Vec<BodyTokenRange> {
24 let mut ranges = Vec::new();
25 for (name, kind) in [
26 ("w:tbl", BodyTokenKind::Table),
27 ("w:p", BodyTokenKind::Paragraph),
28 ] {
29 ranges.extend(
30 crate::xml::extract_balanced_tag_ranges(body_xml, name)
31 .into_iter()
32 .map(|range| BodyTokenRange {
33 start: range.start,
34 end: range.end,
35 kind,
36 }),
37 );
38 }
39 ranges.sort_by_key(|range| range.start);
40 let mut covered_end = 0;
41 ranges.retain(|range| {
42 if range.end <= covered_end {
43 return false;
44 }
45 covered_end = range.end;
46 true
47 });
48 ranges
49}
50
51pub fn is_go_back_bookmark_paragraph(paragraph_xml: &str) -> bool {
52 if !contains_case_insensitive(paragraph_xml, "w:name=\"_GoBack\"") {
53 return false;
54 }
55
56 !contains_case_insensitive_tag(paragraph_xml, "w:r")
57 && !contains_case_insensitive_tag(paragraph_xml, "w:drawing")
58}
59
60pub fn parse_document_xml(
61 document_xml: &str,
62 context: &ParseContext<'_, impl std::borrow::Borrow<super::context::ParsedStyleSheet>>,
63) -> Vec<DocNode> {
64 let body = body_xml(document_xml);
65 parse_ranges(body, extract_body_token_ranges(body), context)
66}
67
68fn parse_token(
69 body: &str,
70 token: &BodyTokenRange,
71 context: &ParseContext<'_, impl std::borrow::Borrow<super::context::ParsedStyleSheet>>,
72) -> Option<DocNode> {
73 let xml = &body[token.start..token.end];
74 if token.kind == BodyTokenKind::Table {
75 Some(DocNode::Table(parse_table(xml, context)))
76 } else if !is_go_back_bookmark_paragraph(xml) {
77 Some(DocNode::Paragraph(parse_paragraph(xml, context)))
78 } else {
79 None
80 }
81}
82
83fn parse_ranges(
84 body: &str,
85 ranges: Vec<BodyTokenRange>,
86 context: &ParseContext<'_, impl std::borrow::Borrow<super::context::ParsedStyleSheet>>,
87) -> Vec<DocNode> {
88 let mut nodes = Vec::with_capacity(ranges.len());
89 for token in ranges {
90 if let Some(node) = parse_token(body, &token, context) {
91 nodes.push(node);
92 }
93 }
94 nonempty_nodes(nodes)
95}
96
97fn nonempty_nodes(mut nodes: Vec<DocNode>) -> Vec<DocNode> {
98 if nodes.is_empty() {
99 nodes.push(DocNode::Paragraph(ParagraphNode {
100 r#type: ParagraphNodeType::Paragraph,
101 block_id: None,
102 children: vec![ParagraphChildNode::Text(TextRunNode {
103 r#type: TextRunNodeType::Text,
104 text: String::new(),
105 style: None,
106 link: None,
107 note_reference: None,
108 })],
109 style: None,
110 paragraph_mark_style: None,
111 source_paragraph_mark_style: None,
112 source_paragraph_mark_formatting: None,
113 source_paragraph_mark_properties_xml: None,
114 paragraph_mark_deleted: None,
115 source_xml: None,
116 source_text_patch: None,
117 source_run_provenance: None,
118 }));
119 }
120
121 nodes
122}
123
124#[cfg(not(target_arch = "wasm32"))]
125pub(crate) fn parse_document_xml_parallel(
126 document: &str,
127 context: &ParseContext<'_, impl std::borrow::Borrow<super::context::ParsedStyleSheet>>,
128 indexes: &crate::xml_index::Scope<'_>,
129) -> Vec<DocNode> {
130 let body = body_xml(document);
131 let ranges = extract_body_token_ranges(body);
132 let bytes = ranges
133 .iter()
134 .map(|range| range.end - range.start)
135 .sum::<usize>();
136 let largest = ranges
137 .iter()
138 .map(|range| range.end - range.start)
139 .max()
140 .unwrap_or(0);
141 let pool = (bytes.saturating_sub(largest) >= 16 * 1024 && ranges.len() >= 16)
142 .then(super::namespaces::worker_pool)
143 .flatten();
144 let Some(pool) = pool else {
145 return parse_ranges(body, ranges, context);
146 };
147 let workers = pool.current_num_threads() + 1;
148 let mut order: Vec<_> = (0..ranges.len()).collect();
149 order.sort_unstable_by_key(|id| std::cmp::Reverse(ranges[*id].end - ranges[*id].start));
150 let mut weights = vec![0usize; workers];
151 let mut assignments = vec![0usize; ranges.len()];
152 for id in order {
153 let worker = (0..workers).min_by_key(|worker| weights[*worker]).unwrap();
154 assignments[id] = worker;
155 weights[worker] += ranges[id].end - ranges[id].start;
156 }
157 let mut results: Vec<Option<(Option<DocNode>, Vec<String>)>> =
158 (0..ranges.len()).map(|_| None).collect();
159 let mut groups: Vec<Vec<_>> = (0..workers).map(|_| Vec::new()).collect();
160 for ((range, result), worker) in ranges.iter().zip(results.iter_mut()).zip(assignments) {
161 groups[worker].push((range, result));
162 }
163 let mut groups = groups.into_iter();
164 let caller = groups.next().unwrap();
165 let relationships = &context.relationships;
166 let content_types = &context.content_types;
167 let styles = context.styles();
168 let parts = context.parts;
169 let binary_assets = context.binary_assets;
170 let mut earlier_warnings = std::mem::take(&mut *context.warnings.borrow_mut());
171 pool.in_place_scope(|scope| {
172 for group in groups {
173 if group.is_empty() {
174 continue;
175 }
176 let snapshot = indexes.snapshot();
177 scope.spawn(move |_| {
178 let _indexes = snapshot.enter();
179 let _styles = super::style::run_style_cache_scope();
180 super::style::bind_style_cache(styles);
181 let context = ParseContext {
182 relationships: relationships.clone(),
183 content_types: content_types.clone(),
184 parts,
185 binary_assets,
186 style_sheet: styles,
187 warnings: std::cell::RefCell::new(Vec::new()),
188 };
189 for (range, result) in group {
190 let node = parse_token(body, range, &context);
191 *result = Some((node, std::mem::take(&mut *context.warnings.borrow_mut())));
192 }
193 });
194 }
195 for (range, result) in caller {
196 let node = parse_token(body, range, context);
197 *result = Some((node, std::mem::take(&mut *context.warnings.borrow_mut())));
198 }
199 });
200 let mut nodes = Vec::with_capacity(results.len());
201 for result in results {
202 let (node, warnings) = result.expect("joined body task");
203 if let Some(node) = node {
204 nodes.push(node);
205 }
206 earlier_warnings.extend(warnings);
207 }
208 *context.warnings.borrow_mut() = earlier_warnings;
209 nonempty_nodes(nodes)
210}
211
212fn contains_case_insensitive(haystack: &str, needle: &str) -> bool {
213 find_case_insensitive_at(haystack, 0, needle).is_some()
214}
215
216fn contains_case_insensitive_tag(haystack: &str, tag_name: &str) -> bool {
217 find_case_insensitive_at(haystack, 0, &format!("<{tag_name}")).is_some()
218 || find_case_insensitive_at(haystack, 0, &format!("<{tag_name}/")).is_some()
219 || find_case_insensitive_at(haystack, 0, &format!("<{tag_name} ")).is_some()
220}
221
222fn find_case_insensitive_at(haystack: &str, start: usize, needle: &str) -> Option<usize> {
223 crate::xml::find_ignore_ascii_case(haystack, start, needle)
224}
225
226#[cfg(test)]
227mod tests {
228 use std::cell::RefCell;
229 use std::collections::HashMap;
230
231 use super::*;
232 use crate::parse::context::{ContentTypeLookup, ParseContext, ParsedStyleSheet};
233
234 #[test]
235 fn extract_body_xml_returns_inner_content() {
236 let xml = "<w:document><w:body><w:p/></w:body></w:document>";
237 assert_eq!(super::super::body::extract_body_xml(xml), "<w:p/>");
238 }
239
240 #[test]
241 fn is_go_back_bookmark_paragraph_detects_hidden_bookmark() {
242 let xml = r#"<w:p><w:bookmarkStart w:name="_GoBack"/></w:p>"#;
243 assert!(is_go_back_bookmark_paragraph(xml));
244 let with_run = r#"<w:p><w:bookmarkStart w:name="_GoBack"/><w:r><w:t>x</w:t></w:r></w:p>"#;
245 assert!(!is_go_back_bookmark_paragraph(with_run));
246 }
247
248 #[test]
249 fn parse_document_xml_skips_go_back_paragraph() {
250 let xml = r#"<w:body><w:p><w:bookmarkStart w:name="_GoBack"/></w:p><w:p><w:r><w:t>Hi</w:t></w:r></w:p></w:body>"#;
251 let context = ParseContext {
252 relationships: HashMap::new(),
253 content_types: ContentTypeLookup::default(),
254 parts: &HashMap::new(),
255 binary_assets: &HashMap::new(),
256 style_sheet: ParsedStyleSheet::empty(),
257 warnings: RefCell::new(Vec::new()),
258 };
259 let nodes = parse_document_xml(xml, &context);
260 assert_eq!(nodes.len(), 1);
261 }
262
263 #[test]
264 fn drawing_text_stays_out_of_the_anchor_paragraph() {
265 let xml = r#"<w:body><w:p><w:r><w:t>Before</w:t></w:r><w:r><w:drawing><wpg:wgp><wps:wsp><wps:txbx><w:txbxContent><w:p><w:r><w:t>Shape story</w:t></w:r></w:p></w:txbxContent></wps:txbx></wps:wsp></wpg:wgp></w:drawing></w:r><w:r><w:t>After</w:t></w:r></w:p></w:body>"#;
266 let context = ParseContext {
267 relationships: HashMap::new(),
268 content_types: ContentTypeLookup::default(),
269 parts: &HashMap::new(),
270 binary_assets: &HashMap::new(),
271 style_sheet: ParsedStyleSheet::empty(),
272 warnings: RefCell::new(Vec::new()),
273 };
274 let nodes = parse_document_xml(xml, &context);
275 let DocNode::Paragraph(paragraph) = &nodes[0] else {
276 panic!("paragraph")
277 };
278 let text: String = paragraph
279 .children
280 .iter()
281 .filter_map(|child| match child {
282 ParagraphChildNode::Text(run) => Some(run.text.as_str()),
283 _ => None,
284 })
285 .collect();
286 assert_eq!(text, "BeforeAfter");
287 assert_eq!(
288 paragraph.source_xml.as_deref(),
289 Some(&xml[8..xml.len() - 9])
290 );
291
292 let with_control = xml.replace("<w:r><w:t>Shape story</w:t></w:r>",
293 "<w:sdt><w:sdtPr><w:text/></w:sdtPr><w:sdtContent><w:r><w:t>Shape story</w:t></w:r></w:sdtContent></w:sdt>");
294 let nodes = parse_document_xml(&with_control, &context);
295 let DocNode::Paragraph(paragraph) = &nodes[0] else {
296 panic!("paragraph")
297 };
298 assert!(!paragraph
299 .children
300 .iter()
301 .any(|child| matches!(child, ParagraphChildNode::FormField(_))));
302 let nodes = parse_document_xml("<w:body><w:p><w:sdt><w:sdtPr><w:text/></w:sdtPr><w:sdtContent><w:r><w:t>Body control</w:t></w:r></w:sdtContent></w:sdt></w:p></w:body>", &context);
303 let DocNode::Paragraph(paragraph) = &nodes[0] else {
304 panic!("paragraph")
305 };
306 assert!(paragraph
307 .children
308 .iter()
309 .any(|child| matches!(child, ParagraphChildNode::FormField(_))));
310 }
311}
312
313#[cfg(all(test, not(target_arch = "wasm32")))]
314mod parallel_tests {
315 #[test]
316 fn balanced_body_preserves_nodes_and_warning_order() {
317 let content = "content & detail ".repeat(40);
318 let mut xml = "<w:document><w:body>".to_owned();
319 for index in 0..80 {
320 xml.push_str(&format!(
321 "<w:p><w:r><w:t>{index} {content}</w:t></w:r></w:p>"
322 ));
323 if index % 9 == 0 {
324 xml.push_str("<w:p><m:oMath><m:unknown/></m:oMath></w:p>");
325 }
326 }
327 xml.push_str("</w:body></w:document>");
328 let mut parts = std::collections::HashMap::new();
329 parts.insert(
330 "body".into(),
331 crate::package::OoxmlPart {
332 name: "body".into(),
333 content: xml.clone(),
334 },
335 );
336 let assets = std::collections::HashMap::new();
337 let context = crate::parse::context::ParseContext {
338 relationships: Default::default(),
339 content_types: Default::default(),
340 parts: &parts,
341 binary_assets: &assets,
342 style_sheet: crate::parse::context::ParsedStyleSheet::empty(),
343 warnings: std::cell::RefCell::new(vec!["prior warning".into()]),
344 };
345 let indexes =
346 crate::xml_index::scope([("body", xml.as_str())].into_iter(), Default::default());
347 let serial = super::parse_document_xml(&xml, &context);
348 let warnings = context.warnings.replace(vec!["prior warning".into()]);
349 let parallel = super::parse_document_xml_parallel(&xml, &context, &indexes);
350 assert_eq!(
351 serde_json::to_value(serial).unwrap(),
352 serde_json::to_value(parallel).unwrap()
353 );
354 assert_eq!(warnings, *context.warnings.borrow());
355 }
356}