diff --git a/crates/xlsx/src/tests/xlsb_tests.rs b/crates/xlsx/src/tests/xlsb_tests.rs index 6fa5efaeb..ca2902b25 100644 --- a/crates/xlsx/src/tests/xlsb_tests.rs +++ b/crates/xlsx/src/tests/xlsb_tests.rs @@ -663,14 +663,14 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { ]); let (wb, report) = read_xlsb(&bytes).unwrap(); - assert!(report.warnings.iter().any(|w| w.contains("external link")), "{:?}", report.warnings); + assert!(report.warnings.iter().any(|w| w.contains("unresolved external link")), "{:?}", report.warnings); assert!(wb.sheets[0].cell(CellRef::new(0, 0)).is_some_and(|c| c.formula.is_none() && c.value == Value::Number(11.0))); - assert_eq!(wb.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("[2]SheetA!$A$1")); + assert_eq!(wb.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("[1]SheetA!$A$1")); let saved = write_xlsx(&wb).unwrap(); let (reopened, rep2) = read_xlsx(&saved).unwrap(); assert!(!rep2.warnings.iter().any(|w| w.contains("dropped")), "{:?}", rep2.warnings); - assert_eq!(reopened.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("[2]SheetA!$A$1")); + assert_eq!(reopened.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("[1]SheetA!$A$1")); let saved2 = write_xlsx(&reopened).unwrap(); let mut zip = zip::ZipArchive::new(std::io::Cursor::new(saved2)).unwrap(); @@ -682,25 +682,22 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { let wb_xml = read_zip(&mut zip, "xl/workbook.xml"); let ref_ids: Vec<&str> = wb_xml.split(""), "{second_xml}"); - let (dir, file) = second_part.rsplit_once('/').unwrap(); - let second_rels = read_zip(&mut zip, &format!("{dir}/_rels/{file}.rels")); + .expect("externalReference r:id should resolve in workbook.xml.rels") + .trim_start_matches('/'); + let link_part = if link_target.starts_with("xl/") { link_target.to_string() } else { format!("xl/{link_target}") }; + let link_xml = read_zip(&mut zip, &link_part); + assert!(link_xml.contains(""), "{link_xml}"); + let (dir, file) = link_part.rsplit_once('/').unwrap(); + let link_rels = read_zip(&mut zip, &format!("{dir}/_rels/{file}.rels")); assert!( - second_rels.contains("externalLinkPath") - && second_rels.contains("Target=\"SecondBook.xlsx\"") - && second_rels.contains("TargetMode=\"External\""), - "{second_rels}" + link_rels.contains("externalLinkPath") && link_rels.contains("Target=\"SecondBook.xlsx\"") && link_rels.contains("TargetMode=\"External\""), + "{link_rels}" ); } diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 89b788bb9..43853a755 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -194,9 +194,13 @@ pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { } import_defined_names(&book, &file_to_model, &mut wb); let external_links = package.external_links(&book).map_err(map_error)?; - if let Some(preserved) = preserve_external_links(&external_links) { + let (preserved, ordinal_map) = preserve_external_links(&external_links, &mut report); + if let Some(preserved) = preserved { wb.preserved = Some(Arc::new(preserved)); } + if let Some(remap) = ordinal_map { + remap_workbook_external_ordinals(&mut wb, &remap); + } for warning in package.warnings() { report.warn(warning); } @@ -211,29 +215,110 @@ pub(crate) fn is_xlsb(bytes: &[u8]) -> bool { craft_xlsx::is_xlsb(bytes) } -fn preserve_external_links(links: &[(String, Option)]) -> Option { - if links.is_empty() || links.iter().all(|(_, l)| l.is_none()) { - return None; +fn preserve_external_links( + links: &[(String, Option)], + report: &mut ReadReport, +) -> (Option, Option>>) { + if links.is_empty() { + return (None, None); } const CT_EXT_LINK: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml"; let mut p = Preserved::default(); let mut refs_xml = format!(""); + let mut remap = vec![None; links.len() + 1]; + let mut next_ordinal = 0usize; + let mut had_missing = false; + let mut shifted = false; for (i, (_, link)) in links.iter().enumerate() { - let rid = format!("rId{}", i + 1); - let part_name = format!("xl/externalLinks/externalLink{}.xml", i + 1); - // Missing slots still need a valid r:id and part so ECMA-376 and - // XLSX reopen keep the 1-based `[n]` ordinals for later links. - let (xml, rels) = match link { - Some(link) => external_link_part_xml(link), - None => (format!("{XML_DECL}"), Vec::new()), + let Some(link) = link else { + had_missing = true; + continue; }; + next_ordinal += 1; + let old_ordinal = i + 1; + remap[old_ordinal] = Some(next_ordinal); + if next_ordinal != old_ordinal { + shifted = true; + } + let rid = format!("rId{next_ordinal}"); + let part_name = format!("xl/externalLinks/externalLink{next_ordinal}.xml"); + let (xml, rels) = external_link_part_xml(link); p.rels.push(PreservedRel { id: rid.clone(), rel_type: format!("{NS_REL}/externalLink"), target: part_name.clone(), external: false }); p.parts.push(PreservedPart { name: part_name, content_type: CT_EXT_LINK.into(), data: xml.into_bytes().into(), rels }); let _ = write!(refs_xml, ""); } + if had_missing { + report.warn("XLSB: unresolved external link kept its cached values; its target could not be preserved"); + } + if next_ordinal == 0 { + return (None, None); + } refs_xml.push_str(""); p.elements.push(PreservedXml { slot: "externalReferences".into(), xml: refs_xml }); - Some(p) + (Some(p), shifted.then_some(remap)) +} + +fn remap_workbook_external_ordinals(wb: &mut Workbook, remap: &[Option]) { + for sheet_arc in &mut wb.sheets { + let sheet = Arc::make_mut(sheet_arc); + let coords: Vec = sheet.cells.iter().filter(|(_, c)| c.formula.is_some()).map(|(pos, _)| pos).collect(); + for pos in coords { + let Some(cell) = sheet.cells.get_mut(pos) else { continue }; + let Some(fm) = &cell.formula else { continue }; + if let Some(rewritten) = remap_external_formula(&fm.text, remap) { + let mut updated = (**fm).clone(); + updated.text = rewritten; + cell.formula = Some(Arc::new(updated)); + } + } + } + for name in &mut wb.names { + if let Some(rewritten) = remap_external_formula(&name.formula, remap) { + name.formula = rewritten; + } + } +} + +fn remap_external_formula(text: &str, remap: &[Option]) -> Option { + let bytes = text.as_bytes(); + let mut out: Option = None; + let mut i = 0; + let mut copied = 0; + let mut in_string = false; + while i < bytes.len() { + if bytes[i] == b'"' { + in_string = !in_string; + i += 1; + continue; + } + if !in_string && bytes[i] == b'[' { + let mut j = i + 1; + while j < bytes.len() && bytes[j].is_ascii_digit() { + j += 1; + } + if j > i + 1 + && j < bytes.len() + && bytes[j] == b']' + && let Ok(old) = text[i + 1..j].parse::() + && let Some(&Some(new_n)) = remap.get(old) + && new_n != old + { + let buf = out.get_or_insert_with(|| String::with_capacity(text.len())); + buf.push_str(&text[copied..=i]); + let _ = write!(buf, "{new_n}]"); + i = j + 1; + copied = i; + continue; + } + } + i += 1; + } + if let Some(mut buf) = out { + buf.push_str(&text[copied..]); + Some(buf) + } else { + None + } } fn external_link_part_xml(link: &craft_xlsx::ExternalLink) -> (String, Vec) { @@ -308,6 +393,8 @@ fn external_link_part_xml(link: &craft_xlsx::ExternalLink) -> (String, Vec"); } xml.push_str(""); + } else { + xml.push_str(""); } xml.push_str(""); (xml, rels)