From 296ffbadce0c483cdcd56c65362db6a2fd06ca15 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 20 Nov 2026 09:21:56 -0500 Subject: [PATCH] xlsx: partial sheet retention, trendline metadata pairing, and XLSB formulas/names (#4584) * xlsx: complete remaining #778 items (partial sheet retention, trendline pairing, XLSB formulas/names) * fix(xlsb): use Formula::new(&text), CellFormula::range, and Workbook::defined_names * test(engine): expect preserved XLSB formula in xlsb_import_keeps_cached_values_and_reports_limits * test(xlsx): trigger MismatchedTag in partial_sheet_read_retains_rows_and_pre_damage_layout * test(xlsx): trigger TooDeep after row 1 in partial_sheet_read_retains_rows_and_pre_damage_layout --- crates/engine/src/tests.rs | 7 +- crates/xlsx/src/chart.rs | 6 +- crates/xlsx/src/sheet_read.rs | 23 ++++-- crates/xlsx/src/tests/malformed.rs | 27 ++++++ crates/xlsx/src/tests/trendline_roundtrip.rs | 33 ++++++++ crates/xlsx/src/tests/xlsb_tests.rs | 86 +++++++++++++++++++- crates/xlsx/src/xlsb.rs | 72 ++++++++++++++-- 7 files changed, 234 insertions(+), 20 deletions(-) diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index ae5f15d17..569e8a023 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -3959,9 +3959,12 @@ fn xlsb_import_keeps_cached_values_and_reports_limits() { assert!(s.doc().unwrap().display_title().ends_with(".xlsx")); assert_eq!(v(&s, "A1"), Value::Number(42.0)); assert_eq!(v(&s, "B1"), Value::from("Original data")); - assert!(s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse("A1").unwrap()).unwrap().formula.is_none()); + assert_eq!( + s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse("A1").unwrap()).unwrap().formula.as_ref().map(|f| f.text.as_str()), + Some("42") + ); s.execute("cell.set", json!({"cell": "B1", "input": "Changed"})).unwrap(); - assert_eq!(v(&s, "A1"), Value::Number(42.0)); // Imported formula caches are constants. + assert_eq!(v(&s, "A1"), Value::Number(42.0)); let saved = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap(); s.execute("file.open", json!({"name": "imported.xlsx", "base64": saved["base64"]})).unwrap(); assert_eq!(v(&s, "A1"), Value::Number(42.0)); diff --git a/crates/xlsx/src/chart.rs b/crates/xlsx/src/chart.rs index b603ec7f8..eb1d22087 100644 --- a/crates/xlsx/src/chart.rs +++ b/crates/xlsx/src/chart.rs @@ -239,6 +239,10 @@ pub(crate) fn from_dml_chart(dc: DmlChart, root: Option<&El>) -> Chart { }) }) .or_else(|| sel.and_then(|e| e.path(&["marker", "spPr", "solidFill"])).and_then(dml_color)); + let mut trendline_els = sel + .into_iter() + .flat_map(|e| e.kids("trendline").take(16)) + .filter(|e| e.child("trendlineType").and_then(|c| c.attr("val")).and_then(TrendlineType::from_xml).is_some()); Series { name: s.refs.name.as_deref().map(chart_ref_from_file).or_else(|| (!s.name.is_empty()).then_some(s.name)), categories: s @@ -266,7 +270,7 @@ pub(crate) fn from_dml_chart(dc: DmlChart, root: Option<&El>) -> Chart { }, quartiles: Default::default(), smooth: sel.map_or(s.smooth, |e| e.child("smooth").is_some_and(|c| c.flag("val", true))), - trendlines: s.trendlines.iter().enumerate().map(|(ti, t)| map_trendline(t, sel.and_then(|e| e.kids("trendline").nth(ti)))).collect(), + trendlines: s.trendlines.iter().map(|t| map_trendline(t, trendline_els.next())).collect(), } }) .collect(); diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs index ef5ae2178..18ca5933d 100644 --- a/crates/xlsx/src/sheet_read.rs +++ b/crates/xlsx/src/sheet_read.rs @@ -248,9 +248,9 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, cr cx.warn(format!("sheet \"{name}\" is damaged: more than {} cells", crate::xml::MAX_XML_NODES)); return Ok((Sheet::new(name), Default::default())); } - if sheet_part.merges.len() > crate::xml::MAX_XML_NODES { + let too_many_merges = sheet_part.merges.len() > crate::xml::MAX_XML_NODES; + if too_many_merges { cx.warn(format!("sheet \"{name}\" is damaged: more than {} merge cells", crate::xml::MAX_XML_NODES)); - return Ok((Sheet::new(name), Default::default())); } for row in &rows { read_craft_row(cx, &mut sheet, &mut st, row).map_err(craft_error)?; @@ -262,14 +262,21 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, cr } settle_python_spills_past_budget(&st, &mut sheet); - apply_craft_sheet_part(cx, &sheet_part, &rels, name, &mut sheet)?; + apply_craft_sheet_part(cx, &sheet_part, &rels, name, too_many_merges, &mut sheet)?; let root = from_craft_el(&sheet_part.root); let read_controls = read_form_controls(cx, &root, &rels, &mut sheet); read_sheet_notes_and_tables(cx, &sheet_part, &rels, &mut sheet)?; Ok((sheet, read_controls)) } -fn apply_craft_sheet_part(cx: &mut Ctx<'_>, sp: &CraftSheetPart, rels: &[Rel], name: &str, sheet: &mut Sheet) -> Result<(), IoError> { +fn apply_craft_sheet_part( + cx: &mut Ctx<'_>, + sp: &CraftSheetPart, + rels: &[Rel], + name: &str, + skip_merges: bool, + sheet: &mut Sheet, +) -> Result<(), IoError> { let mut rel_by_id: HashMap<&str, &Rel> = HashMap::with_capacity(rels.len()); for r in rels { rel_by_id.entry(r.id.as_str()).or_insert(r); @@ -297,9 +304,11 @@ fn apply_craft_sheet_part(cx: &mut Ctx<'_>, sp: &CraftSheetPart, rels: &[Rel], n } else { apply_craft_cols(cx, &sp.columns, sheet)?; } - for m in &sp.merges { - if !m.is_single() { - sheet.merges.push(to_range_ref(*m)); + if !skip_merges { + for m in &sp.merges { + if !m.is_single() { + sheet.merges.push(to_range_ref(*m)); + } } } if let Some(v) = sp.features.views.first() { diff --git a/crates/xlsx/src/tests/malformed.rs b/crates/xlsx/src/tests/malformed.rs index 71a470992..eecc5b490 100644 --- a/crates/xlsx/src/tests/malformed.rs +++ b/crates/xlsx/src/tests/malformed.rs @@ -313,6 +313,33 @@ fn a_row_wider_than_the_grid_is_refused() { assert!(rep.warnings.iter().any(|w| w.contains("damaged")), "{:?}", rep.warnings); } +#[test] +fn partial_sheet_read_retains_rows_and_pre_damage_layout() { + let mut body = String::from( + r#"5"#, + ); + for _ in 0..5000 { + body.push_str(""); + } + let (wb, rep) = read_xlsx(&minimal(&body, &[], "", "")).unwrap(); + let s = wb.sheet(0).unwrap(); + assert_eq!(s.value(gridcraft_core::CellRef::new(0, 0)), gridcraft_core::Value::Number(5.0)); + assert!((s.default_row_height - 32.0).abs() < 0.01, "{}", s.default_row_height); + assert!(s.cols.contains_key(&0), "pre-damage column width should be retained"); + assert!(rep.warnings.iter().any(|w| w.contains("damaged") && w.contains("kept 1 rows")), "{:?}", rep.warnings); + + // Oversized mergeCells drops the merges without discarding earlier rows. + let merges = format!( + r#"7{}"#, + r#""#.repeat(crate::xml::MAX_XML_NODES + 1) + ); + let (wb, rep) = read_xlsx(&minimal(&merges, &[], "", "")).unwrap(); + let s = wb.sheet(0).unwrap(); + assert_eq!(s.value(gridcraft_core::CellRef::new(0, 0)), gridcraft_core::Value::Number(7.0)); + assert!(s.merges.is_empty()); + assert!(rep.warnings.iter().any(|w| w.contains("damaged")), "{:?}", rep.warnings); +} + /// #2159: overlapping `` entries share one budget of column writes. #[test] fn overlapping_column_entries_have_a_budget() { diff --git a/crates/xlsx/src/tests/trendline_roundtrip.rs b/crates/xlsx/src/tests/trendline_roundtrip.rs index f5bf7feae..081dceabf 100644 --- a/crates/xlsx/src/tests/trendline_roundtrip.rs +++ b/crates/xlsx/src/tests/trendline_roundtrip.rs @@ -190,3 +190,36 @@ fn a_huge_forecast_in_a_file_is_read_clamped() { let small = read("2.5", "-3"); assert_eq!((small.forward, small.backward), (2.5, 0.0), "ordinary values are kept"); } + +#[test] +fn trendline_metadata_pairing_skips_unknown_trendline_elements() { + let xml = r#" + + + + + + + + + + + + + + Data!$B$2:$B$6 + + + + "#; + let root = crate::xml::parse(xml.as_bytes()).unwrap(); + let t = &crate::chart::read_chart(&root).unwrap().series[0].trendlines; + assert_eq!(t.len(), 1); + assert_eq!(t[0].kind, TrendlineKind::Linear); + assert_eq!(t[0].forward, 2.5); + assert!(!t[0].display_equation); + assert!(t[0].display_r_squared); + assert_eq!(t[0].color, Some(Color::Rgb(0xFF0000))); + assert_eq!(t[0].width, Some(2.0)); + assert_eq!(t[0].dash, Some(LineDash::SysDot)); +} diff --git a/crates/xlsx/src/tests/xlsb_tests.rs b/crates/xlsx/src/tests/xlsb_tests.rs index 098876247..ab868baf5 100644 --- a/crates/xlsx/src/tests/xlsb_tests.rs +++ b/crates/xlsx/src/tests/xlsb_tests.rs @@ -172,11 +172,13 @@ fn xlsb_scalar_caches_rk_unicode_visibility_and_epochs_survive_xlsx_save() { assert_eq!(wb.sheets[1].visibility, Visibility::Hidden); assert_eq!(wb.sheets[0].cells.len(), 14); assert_eq!(wb.sheets[0].merges, vec![RangeRef::new(CellRef::new(5, 0), CellRef::new(6, 1))]); - assert!(report.warnings.iter().any(|w| w.contains("will not recalculate") && w.contains("may display as numbers"))); + assert!(report.warnings.iter().any(|w| w.contains("may display as numbers") && w.contains("XLSB saving is not supported"))); for (col, expected) in expected.iter().enumerate() { assert_eq!(&wb.sheets[0].value(CellRef::new(2, col as u32)), expected); } - assert!(wb.sheets[0].cells.iter().all(|(_, c)| c.formula.is_none())); + for col in 10..=13 { + assert_eq!(wb.sheets[0].cell(CellRef::new(2, col)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("1")); + } let (roundtrip, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap(); assert_eq!(roundtrip.date_system, wb.date_system); for (col, expected) in expected.iter().enumerate() { @@ -343,3 +345,83 @@ fn xlsb_phonetic_runs_use_documented_size_and_tolerate_padding() { } assert!(read_xlsb(&file(&worksheet(&[row(0), cell(62, 0, &phonetic(2, 12))].concat(), &[]))).is_err()); } + +#[test] +fn xlsb_formulas_defined_names_and_external_links_delegate_to_craft_xlsx() { + let mut wb_records = record(131, &[]); + let mut props = 0u32.to_le_bytes().to_vec(); + props.extend(0u32.to_le_bytes()); + props.extend(wide("")); + wb_records.extend(record(153, &props)); + wb_records.extend(record(143, &[])); + for (id, rel, name, state) in [(1u32, "one", "Data", 0u32), (2, "two", "Hidden", 1)] { + let mut data = state.to_le_bytes().to_vec(); + data.extend(id.to_le_bytes()); + data.extend(wide(rel)); + data.extend(wide(name)); + wb_records.extend(record(156, &data)); + } + wb_records.extend(record(144, &[])); + // Supporting books: book 0 = BrtSupSelf (357), book 1 = BrtSupBookSrc (355). + wb_records.extend(record(357, &[])); + wb_records.extend(record(355, &[])); + // BrtExternSheet (362): 2 XTIs: ixti 0 -> (book=0, sheet=1..1), ixti 1 -> (book=1, sheet=0..0). + let mut xti = 2u32.to_le_bytes().to_vec(); + for (bk, first, last) in [(0u32, 1i32, 1i32), (1, 0, 0)] { + xti.extend(bk.to_le_bytes()); + xti.extend(first.to_le_bytes()); + xti.extend(last.to_le_bytes()); + } + wb_records.extend(record(362, &xti)); + // BrtName (39): "Rate" = Hidden!$A$1 (PtgRef3d ixti=0, r=0, c=0). + let mut ptg_ref3d_hidden = vec![0x3A, 0, 0]; + ptg_ref3d_hidden.extend(0u32.to_le_bytes()); + ptg_ref3d_hidden.extend(0u16.to_le_bytes()); + let mut brt_name = 0u32.to_le_bytes().to_vec(); + brt_name.push(0); + brt_name.extend(u32::MAX.to_le_bytes()); + brt_name.extend(wide("Rate")); + brt_name.extend((ptg_ref3d_hidden.len() as u32).to_le_bytes()); + brt_name.extend(&ptg_ref3d_hidden); + brt_name.extend(0u32.to_le_bytes()); + brt_name.extend(u32::MAX.to_le_bytes()); // null comment + wb_records.extend(record(39, &brt_name)); + wb_records.extend(record(132, &[])); + + let fmla_num = |col: u32, cached: f64, rgce: &[u8]| { + let mut data = col.to_le_bytes().to_vec(); + data.extend([0; 4]); + data.extend(cached.to_le_bytes()); + data.extend([0; 2]); + data.extend((rgce.len() as u32).to_le_bytes()); + data.extend(rgce); + data.extend(0u32.to_le_bytes()); + record(9, &data) + }; + let ptg_name = [0x23, 1, 0, 0, 0]; + let ptg_ext = { + let mut v = vec![0x3A, 1, 0]; + v.extend(0u32.to_le_bytes()); + v.extend(0u16.to_le_bytes()); + v + }; + let mut data = row(0); + data.extend(fmla_num(0, 42.0, &ptg_ref3d_hidden)); + data.extend(fmla_num(1, 7.0, &ptg_name)); + data.extend(fmla_num(2, 99.0, &ptg_ext)); + + let bytes = package(&wb_records, &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES); + let (wb, report) = read_xlsb(&bytes).unwrap(); + assert_eq!(wb.names.len(), 1); + assert_eq!((wb.names[0].name.as_str(), wb.names[0].formula.as_str(), wb.names[0].scope), ("Rate", "Hidden!$A$1", None)); + assert_eq!(wb.sheets[0].cell(CellRef::new(0, 0)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("Hidden!$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("Rate")); + assert!(wb.sheets[0].cell(CellRef::new(0, 2)).is_some_and(|c| c.formula.is_none() && c.value == Value::Number(99.0))); + assert!(report.warnings.iter().any(|w| w.contains("external links")), "{:?}", report.warnings); + + let (rt, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap(); + assert_eq!(rt.names.len(), 1); + assert_eq!(rt.sheets[0].cell(CellRef::new(0, 0)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("Hidden!$A$1")); + assert_eq!(rt.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("Rate")); + assert_eq!(rt.sheets[0].value(CellRef::new(0, 2)), Value::Number(99.0)); +} diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index ab836376d..bd84abc30 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -1,10 +1,11 @@ -//! Data-only XLSB import, delegated to `craft_xlsx::Package`. -//! Formula caches become constants. Styles, macros and other workbook features are not run or imported. +//! XLSB import, delegated to `craft_xlsx::Package`. +//! Cell values, formulas, defined names, and merged cells are imported; formatting, charts, +//! images, macros and other workbook features are not imported. use std::sync::Arc; use gridcraft_core::{CellError, CellRef, DateSystem, RangeRef, Value}; -use gridcraft_model::{Cell, Sheet, Visibility, Workbook}; +use gridcraft_model::{Cell, DefinedName, Formula, Sheet, StyleId, Visibility, Workbook}; use crate::{IoError, ReadReport}; @@ -61,8 +62,55 @@ pub(super) fn import_limits() -> craft_xlsx::Limits { if cfg!(target_arch = "wasm32") { craft_xlsx::Limits { binary_text: 64 << 20, ..limits } } else { limits } } -/// Imports worksheet scalar values and saved formula results. Number formats are omitted; -/// dates remain serial numbers with the workbook's original date system. Inspect warnings. +fn map_formula(f: &craft_xlsx::CellFormula, at: craft_xlsx::CellRef, report: &mut ReadReport) -> Option { + let text = crate::fmla::from_file(f.text.trim()); + if text.is_empty() { + return None; + } + match f.kind { + craft_xlsx::FormulaKind::Normal | craft_xlsx::FormulaKind::Shared => Some(Formula::new(&text)), + craft_xlsx::FormulaKind::Array => { + let pos = CellRef::new(at.row, at.col); + let mut fm = Formula::new(&text); + fm.array = Some( + f.range + .map(|r| RangeRef::new(CellRef::new(r.first.row, r.first.col), CellRef::new(r.last.row, r.last.col))) + .unwrap_or_else(|| RangeRef::cell(pos)), + ); + Some(fm) + } + craft_xlsx::FormulaKind::DataTable => { + report.warn("what-if data tables are not supported; kept their values"); + None + } + } +} + +fn import_defined_names(book: &craft_xlsx::Workbook, file_to_model: &[Option], wb: &mut Workbook) { + for d in &book.defined_names { + let scope = match d.local_sheet_id { + Some(i) => match file_to_model.get(i as usize).copied().flatten() { + Some(m) => Some(m), + None => continue, + }, + None => None, + }; + let lname = d.name.to_ascii_lowercase(); + if lname == "_xlnm._filterdatabase" || lname.starts_with("_xlchart.") || lname == "_xlnm.print_area" || lname == "_xlnm.print_titles" { + continue; + } + wb.names.push(DefinedName { + name: d.name.clone(), + scope, + formula: crate::fmla::from_file(d.formula.trim()), + comment: d.comment.clone(), + hidden: d.hidden, + }); + } +} + +/// Imports worksheet cell values, formulas, defined names, and merged cells. Number formats are +/// omitted; dates remain serial numbers with the workbook's original date system. Inspect warnings. pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { let limits = import_limits(); let mut package = craft_xlsx::Package::open(bytes, &limits).map_err(map_error)?; @@ -101,13 +149,15 @@ pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { wb.sheets.clear(); wb.date_system = if book.date_1904 { DateSystem::D1904 } else { DateSystem::D1900 }; let mut report = ReadReport::default(); - report.warn("XLSB data-only import: formulas become their saved results and will not recalculate. Formatting, charts, images, macros and other features are not imported; dates, currency and percentages may display as numbers. Save a new .xlsx file; XLSB saving is not supported."); + report.warn("XLSB import: formatting, charts, images, macros and other features are not imported; dates, currency and percentages may display as numbers. Save a new .xlsx file; XLSB saving is not supported."); + let mut file_to_model = Vec::with_capacity(book.sheets.len()); for entry in &book.sheets { if entry.kind != craft_xlsx::SheetKind::Worksheet { if !matches!(entry.kind, craft_xlsx::SheetKind::Chartsheet | craft_xlsx::SheetKind::Dialogsheet | craft_xlsx::SheetKind::Macrosheet) { return Err(IoError::Format("XLSB: unknown sheet relationship type".into())); } report.warn("XLSB non-worksheet sheets were skipped."); + file_to_model.push(None); continue; } wb.check_sheet_name(&entry.name, None).map_err(|e| IoError::Format(format!("XLSB: {e}")))?; @@ -122,8 +172,12 @@ pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { .sheet(entry, |row| { for cell in row.cells { let value = map_value(cell.value.resolve(&strings, book.date_1904)); - if !value.is_empty() { - sheet.cells.set(CellRef::new(cell.at.row, cell.at.col), Cell::value(value)); + let formula = cell.formula.as_ref().and_then(|f| map_formula(f, cell.at, &mut report)); + if !value.is_empty() || formula.is_some() { + sheet.cells.set( + CellRef::new(cell.at.row, cell.at.col), + Cell { value, formula: formula.map(Arc::new), style: StyleId::DEFAULT, py: None }, + ); } } Ok(()) @@ -131,8 +185,10 @@ pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { .map_err(map_error)?; sheet.merges = part.merges.into_iter().map(|r| RangeRef::new(CellRef::new(r.first.row, r.first.col), CellRef::new(r.last.row, r.last.col))).collect(); + file_to_model.push(Some(wb.sheets.len())); wb.sheets.push(Arc::new(sheet)); } + import_defined_names(&book, &file_to_model, &mut wb); for warning in package.warnings() { report.warn(warning); }