diff --git a/Cargo.lock b/Cargo.lock index 49ca15068..782b0e04f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -937,7 +937,7 @@ name = "craft-drawingml" version = "0.1.0" source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280" dependencies = [ - "craft-xml", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", "kurbo", "log", "serde", @@ -981,6 +981,35 @@ dependencies = [ "writeable", ] +[[package]] +name = "craft-odf" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890" +dependencies = [ + "aes", + "base64 0.23.1", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)", + "craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)", + "flate2", + "getrandom 0.3.4", + "hmac", + "sha1 0.11.0", + "sha2 0.11.1", + "thiserror 2.0.21", + "zeroize", +] + +[[package]] +name = "craft-ods" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890" +dependencies = [ + "craft-odf", + "craft-sheet 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890)", + "thiserror 2.0.21", +] + [[package]] name = "craft-offcrypto" version = "0.1.0" @@ -989,7 +1018,7 @@ dependencies = [ "aes", "base64 0.23.1", "craft-cfb", - "craft-xml", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", "getrandom 0.3.4", "hmac", "sha1 0.11.0", @@ -1003,8 +1032,8 @@ name = "craft-opc" version = "0.1.0" source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280" dependencies = [ - "craft-xml", - "craft-zip", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", + "craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", "log", "thiserror 2.0.21", ] @@ -1028,6 +1057,11 @@ dependencies = [ "winsafe", ] +[[package]] +name = "craft-sheet" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890" + [[package]] name = "craft-sheet" version = "0.1.0" @@ -1136,7 +1170,7 @@ version = "0.1.0" source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280" dependencies = [ "craft-cfb", - "craft-sheet", + "craft-sheet 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", "md-5", "miniz_oxide 0.9.1", "sha1 0.10.7", @@ -1150,8 +1184,18 @@ source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d dependencies = [ "craft-drawingml", "craft-opc", - "craft-sheet", - "craft-xml", + "craft-sheet 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-xml" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890" +dependencies = [ + "quick-xml 0.41.0", + "serde", "thiserror 2.0.21", ] @@ -1164,6 +1208,16 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-zip" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890" +dependencies = [ + "flate2", + "thiserror 2.0.21", + "zip 9.1.0", +] + [[package]] name = "craft-zip" version = "0.1.0" @@ -2405,11 +2459,12 @@ version = "0.19.1" dependencies = [ "craft-cfb", "craft-csv", + "craft-ods", "craft-offcrypto", "craft-opc", "craft-xls", "craft-xlsx", - "craft-xml", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280)", "gridcraft-core", "gridcraft-formula", "gridcraft-functions", diff --git a/Cargo.toml b/Cargo.toml index 8011136db..e36882bc8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,6 +37,7 @@ craft-stream-codecs = { git = "https://github.com/storytold/craft-libs", rev = " # Compound files ([MS-CFB]) and password-encrypted OOXML packages ([MS-OFFCRYPTO]). craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" } craft-offcrypto = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" } +craft-ods = { git = "https://github.com/storytold/craft-libs", rev = "010702ee9b030844c852939095b1da0d0656a890", version = "0.1.0" } # OPC zip packages (parts, relationships, the zip writer) under `crates/xlsx/src/package.rs`. craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", version = "0.1.0" } # Delimited text (CSV, TSV) and SYLK; `crates/xlsx/src/csv.rs` and `crates/engine/src/io/sylk.rs` diff --git a/crates/xlsx/Cargo.toml b/crates/xlsx/Cargo.toml index 6df600052..18b8ed82a 100644 --- a/crates/xlsx/Cargo.toml +++ b/crates/xlsx/Cargo.toml @@ -20,6 +20,7 @@ gridcraft-math = { workspace = true } gridcraft-model = { workspace = true } craft-cfb = { workspace = true } craft-csv = { workspace = true } +craft-ods = { workspace = true } craft-offcrypto = { workspace = true } craft-opc = { workspace = true } craft-xls = { workspace = true } diff --git a/crates/xlsx/src/ods.rs b/crates/xlsx/src/ods.rs index 1ef65b6be..e208bc6ce 100644 --- a/crates/xlsx/src/ods.rs +++ b/crates/xlsx/src/ods.rs @@ -1,32 +1,16 @@ -//! Data-only OpenDocument Spreadsheet import. Formula caches become constants; styles and -//! other ODF features are deliberately not translated. All fixtures are authored in Rust. -//! Format reference: ODF 1.3, part 3, sections 6.1 and 9.1: -//! . +//! Data-only OpenDocument Spreadsheet import backed by `craft-ods`. +//! Formula caches become constants; styles and other ODF features are deliberately not translated. use std::io::{Cursor, Read}; use std::sync::Arc; -use gridcraft_core::date::{days_in_month, serial_from_ymd}; -use gridcraft_core::{CellRef, DateSystem, MAX_COLS, MAX_ROWS, RangeRef, Value}; +use gridcraft_core::{CellError, CellRef, RangeRef, Value}; use gridcraft_model::{Cell, NumFmt, Sheet, StyleId, Workbook}; -use quick_xml::NsReader; -use quick_xml::XmlVersion; -use quick_xml::events::{BytesStart, Event}; -use quick_xml::name::ResolveResult; -use crate::package::{MAX_ENTRIES, Package}; +use crate::package::MAX_ENTRIES; use crate::{IoError, ReadReport}; const MIME: &[u8] = b"application/vnd.oasis.opendocument.spreadsheet"; -const OFFICE: &[u8] = b"urn:oasis:names:tc:opendocument:xmlns:office:1.0"; -const TABLE: &[u8] = b"urn:oasis:names:tc:opendocument:xmlns:table:1.0"; -const TEXT: &[u8] = b"urn:oasis:names:tc:opendocument:xmlns:text:1.0"; -const CALC_EXT: &[u8] = b"urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0"; -const MANIFEST: &[u8] = b"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"; -const MAX_CELLS: u64 = 1_000_000; -const MAX_MERGES: u64 = 100_000; -const MAX_CELL_TEXT: usize = 1024 * 1024; -const MAX_TEXT: u64 = 64 * 1024 * 1024; const MAX_SHEETS: usize = 1024; /// Reads only the small, exact mimetype entry, including when the ZIP uses compression. @@ -48,637 +32,96 @@ pub(crate) fn has_mimetype(bytes: &[u8]) -> bool { /// imported as constants, so editing their inputs does not recalculate the original formula. /// Always inspect the returned warnings. Saving to ODS is not supported. pub fn read_ods(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { - let mut package = Package::open(bytes)?; - if !has_mimetype(bytes) { - return Err(IoError::Format("missing or invalid ODS mimetype".into())); - } - if let Some(manifest) = package.read("META-INF/manifest.xml")? { - check_manifest(&manifest)?; - } - let content = package.read("content.xml")?.ok_or_else(|| IoError::Format("ODS content.xml is missing".into()))?; - let mut import = Import::new(); - import.parse(&content)?; - if import.wb.sheets.is_empty() { + let book = craft_ods::read(bytes, &craft_ods::Options::default()).map_err(map_error)?; + if book.sheets.is_empty() { return Err(IoError::Format("ODS contains no worksheets".into())); } - Ok((import.wb, import.report)) -} + if book.sheets.len() > MAX_SHEETS { + return Err(IoError::TooLarge("ODS contains more than 1024 sheets".into())); + } -fn is_ns(ns: ResolveResult<'_>, expected: &[u8]) -> bool { - matches!(ns, ResolveResult::Bound(n) if n.as_ref() == expected) -} + let mut wb = Workbook::new(); + let mut report = ReadReport::default(); + report.warn("ODS data-only import: formulas become their saved results and will not recalculate. Source formatting, charts, images and other features are not imported. Save a new .xlsx file; ODS saving is not supported."); -fn attr(reader: &mut NsReader<&[u8]>, e: &BytesStart<'_>, ns: &[u8], name: &[u8]) -> Result, IoError> { - let mut found = None; - for a in e.attributes() { - let a = a.map_err(|e| IoError::Xml(e.to_string()))?; - let (resolved, local) = reader.resolver_mut().resolve_attribute(a.key); - if is_ns(resolved, ns) && local.as_ref() == name { - let value = a.normalized_value(XmlVersion::Explicit1_0).map_err(|e| IoError::Xml(e.to_string()))?; - if value.len() > MAX_CELL_TEXT { - return Err(IoError::TooLarge("ODS attribute exceeds 1 MiB".into())); - } - found = Some(value.into_owned()); + let mut warned_rename = false; + let mut warned_unavailable = false; + + for src_sheet in book.sheets { + let mut sheet = Sheet::new(&src_sheet.name); + if !warned_rename && sheet.name != src_sheet.name { + warned_rename = true; + report.warn("Some ODS sheet names were shortened or renamed to valid, unique XLSX sheet names."); } - } - Ok(found) -} -fn positive(value: Option, default: u32, limit: u32) -> Result { - let n = match value { - Some(s) => s.parse::().map_err(|_| IoError::Format("invalid ODS repeat or span count".into()))?, - None => default, - }; - if n == 0 || n > limit { - return Err(IoError::TooLarge("ODS repeat or span exceeds worksheet bounds".into())); - } - Ok(n) -} - -fn xml_error(e: impl std::fmt::Display) -> IoError { - IoError::Xml(format!("ODS: {e}")) -} - -fn check_manifest(bytes: &[u8]) -> Result<(), IoError> { - let mut reader = NsReader::from_reader(bytes); - let mut depth = 0usize; - let mut root_seen = false; - loop { - let event = reader.read_event().map_err(xml_error)?; - match &event { - Event::Start(e) | Event::Empty(e) => { - let (ns, name) = reader.resolver_mut().resolve_element(e.name()); - if is_ns(ns.clone(), MANIFEST) && name.as_ref() == b"encryption-data" { - return Err(IoError::Format("encrypted ODS files are not supported".into())); - } - if depth == 0 { - if root_seen || !is_ns(ns, MANIFEST) || name.as_ref() != b"manifest" { - return Err(xml_error("expected one manifest:manifest root")); + for (coord, src_cell) in src_sheet.cells { + let value = match src_cell.value() { + Some(v) => map_value(v), + None if src_cell.formula.is_some() => { + if !warned_unavailable { + warned_unavailable = true; + report.warn("Some ODS values or formula caches were unsupported or missing; their displayed text (or raw value) was kept as text. A formula without either is marked [Unavailable ODS formula result]."); } - root_seen = true; + Value::Text(Arc::from("[Unavailable ODS formula result]")) } - if matches!(event, Event::Start(_)) { - depth += 1; - if depth > crate::xml::MAX_DEPTH { - return Err(xml_error("manifest nested too deeply")); - } - } - } - Event::End(_) => depth = depth.checked_sub(1).ok_or_else(|| xml_error("unexpected manifest closing element"))?, - Event::DocType(_) => return Err(xml_error("DOCTYPE is not supported")), - Event::Eof => break, - _ => {} + None => continue, + }; + + let style_id = match src_cell.value_type { + Some(craft_ods::ValueType::Date) => wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("yyyy-mm-dd")), + Some(craft_ods::ValueType::Time) => wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("[h]:mm:ss")), + Some(craft_ods::ValueType::Percentage) => wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("0.00%")), + Some(craft_ods::ValueType::Currency) => wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("#,##0.00")), + _ => StyleId::DEFAULT, + }; + + let target_coord = CellRef::new(coord.row, coord.col); + sheet.set_cell(target_coord, Cell::styled(value, style_id)); } + + for m in src_sheet.merges { + let range = RangeRef::new(CellRef::new(m.first.row, m.first.col), CellRef::new(m.last.row, m.last.col)); + sheet.merges.push(range); + } + wb.sheets.push(Arc::new(sheet)); } - if !root_seen || depth != 0 { - return Err(xml_error("incomplete manifest")); - } - Ok(()) + + Ok((wb, report)) } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum Tag { - Document, - Body, - Spreadsheet, - Table, - Rows, - Row, - Cell, - Covered, - Paragraph, - Inline, - Space, - Tab, - Break, - Other, -} - -fn tag(reader: &mut NsReader<&[u8]>, e: &BytesStart<'_>) -> Tag { - let (ns, name) = reader.resolver_mut().resolve_element(e.name()); - let local = name.as_ref(); - if is_ns(ns.clone(), OFFICE) { - return match local { - b"document-content" => Tag::Document, - b"body" => Tag::Body, - b"spreadsheet" => Tag::Spreadsheet, - _ => Tag::Other, - }; - } - if is_ns(ns.clone(), TABLE) { - return match local { - b"table" => Tag::Table, - b"table-row-group" | b"table-header-rows" | b"table-rows" => Tag::Rows, - b"table-row" => Tag::Row, - b"table-cell" => Tag::Cell, - b"covered-table-cell" => Tag::Covered, - _ => Tag::Other, - }; - } - if is_ns(ns, TEXT) { - return match local { - b"p" | b"h" => Tag::Paragraph, - b"span" | b"a" | b"meta" | b"meta-field" | b"ruby" | b"ruby-base" => Tag::Inline, - b"s" => Tag::Space, - b"tab" => Tag::Tab, - b"line-break" => Tag::Break, - _ => Tag::Other, - }; - } - Tag::Other -} - -struct SheetDraft { - sheet: Sheet, - depth: usize, - row: u32, -} -struct RowDraft { - depth: usize, - repeat: u32, - col: u32, - cells: Vec, -} -struct RepeatedCell { - col: u32, - repeat: u32, - width: u32, - height: u32, - cell: Cell, -} -struct CellDraft { - depth: usize, - repeat: u32, - width: u32, - height: u32, - covered: bool, - kind: Option, - raw: Option, - formula: bool, - text: String, - paragraph: Option, - paragraphs: usize, - paragraph_started: bool, - pending_space: bool, -} -struct Import { - wb: Workbook, - report: ReadReport, - stack: Vec, - sheet: Option, - row: Option, - cell: Option, - cells: u64, - merges: u64, - text: u64, - formats: Vec<(&'static str, StyleId)>, - spreadsheet_seen: bool, - names: crate::read::SheetNames, -} - -impl Import { - fn new() -> Self { - let mut wb = Workbook::new(); - wb.sheets.clear(); - let mut report = ReadReport::default(); - report.warn("ODS data-only import: formulas become their saved results and will not recalculate. Source formatting, charts, images and other features are not imported. Save a new .xlsx file; ODS saving is not supported."); - Self { - wb, - report, - stack: vec![], - sheet: None, - row: None, - cell: None, - cells: 0, - merges: 0, - text: 0, - formats: vec![], - spreadsheet_seen: false, - names: Default::default(), - } - } - - fn parse(&mut self, bytes: &[u8]) -> Result<(), IoError> { - let mut reader = NsReader::from_reader(bytes); - let mut root_seen = false; - loop { - match reader.read_event().map_err(xml_error)? { - Event::Start(e) => { - if self.stack.len() >= crate::xml::MAX_DEPTH { - return Err(xml_error("XML nested too deeply")); - } - if self.stack.is_empty() { - if root_seen || tag(&mut reader, &e) != Tag::Document { - return Err(xml_error("expected one office:document-content root")); - } - root_seen = true; - } - self.start(&mut reader, &e)?; - } - Event::Empty(e) => { - if self.stack.is_empty() { - return Err(xml_error("expected office:document-content with a spreadsheet")); - } - self.start(&mut reader, &e)?; - self.end()?; - } - Event::End(_) => self.end()?, - Event::Text(t) => { - let text = t.xml_content(XmlVersion::Explicit1_0).map_err(xml_error)?; - if self.stack.is_empty() && !text.trim().is_empty() { - return Err(xml_error("text outside the document")); - } - self.append(&text)?; - } - Event::CData(t) => self.append(&t.decode().map_err(xml_error)?)?, - Event::GeneralRef(r) => { - let ch = match r.resolve_char_ref().map_err(xml_error)? { - Some(c) => c, - None => match &*r { - b"amp" => '&', - b"lt" => '<', - b"gt" => '>', - b"apos" => '\'', - b"quot" => '"', - _ => return Err(xml_error("unsupported XML entity")), - }, - }; - self.append(ch.encode_utf8(&mut [0; 4]))?; - } - Event::DocType(_) => return Err(xml_error("DOCTYPE is not supported")), - Event::Eof => break, - _ => {} - } - } - if !root_seen || !self.stack.is_empty() || !self.spreadsheet_seen { - return Err(xml_error("incomplete ODS document")); - } - Ok(()) - } - - fn start(&mut self, reader: &mut NsReader<&[u8]>, e: &BytesStart<'_>) -> Result<(), IoError> { - let t = tag(reader, e); - let depth = self.stack.len(); - match t { - Tag::Spreadsheet if self.stack == [Tag::Document, Tag::Body] => { - if self.spreadsheet_seen { - return Err(xml_error("multiple spreadsheets in one document")); - } - self.spreadsheet_seen = true; - } - Tag::Table if self.stack == [Tag::Document, Tag::Body, Tag::Spreadsheet] => { - if self.wb.sheets.len() >= MAX_SHEETS { - return Err(IoError::TooLarge("ODS contains more than 1024 sheets".into())); - } - let original = attr(reader, e, TABLE, b"name")?.unwrap_or_default(); - let mut name = self.names.unique(original.trim_matches('\''), self.wb.sheets.len()); - if self.wb.check_sheet_name(&name, None).is_err() { - name = self.wb.next_sheet_name(); - self.names.insert(&name); - } - if name != original { - self.report.warn("Some ODS sheet names were shortened or renamed to valid, unique XLSX sheet names."); - } - self.sheet = Some(SheetDraft { sheet: Sheet::new(name), depth, row: 0 }); - } - Tag::Row if self.sheet.as_ref().is_some_and(|s| self.stack.get(s.depth + 1..).is_some_and(|p| p.iter().all(|t| *t == Tag::Rows))) => { - self.row = - Some(RowDraft { depth, repeat: positive(attr(reader, e, TABLE, b"number-rows-repeated")?, 1, u32::MAX)?, col: 0, cells: vec![] }); - } - Tag::Cell | Tag::Covered if self.row.as_ref().is_some_and(|r| depth == r.depth + 1) => { - let kind = if attr(reader, e, CALC_EXT, b"value-type")?.as_deref() == Some("error") { - Some("error".into()) - } else { - attr(reader, e, OFFICE, b"value-type")? - }; - let key: &[u8] = match kind.as_deref() { - Some("boolean") => b"boolean-value", - Some("date") => b"date-value", - Some("time") => b"time-value", - Some("string") => b"string-value", - _ => b"value", - }; - self.cell = Some(CellDraft { - depth, - repeat: positive(attr(reader, e, TABLE, b"number-columns-repeated")?, 1, u32::MAX)?, - width: positive(attr(reader, e, TABLE, b"number-columns-spanned")?, 1, MAX_COLS)?, - height: positive(attr(reader, e, TABLE, b"number-rows-spanned")?, 1, MAX_ROWS)?, - covered: t == Tag::Covered, - kind, - raw: attr(reader, e, OFFICE, key)?, - formula: attr(reader, e, TABLE, b"formula")?.is_some(), - text: String::new(), - paragraph: None, - paragraphs: 0, - paragraph_started: false, - pending_space: false, - }); - } - Tag::Paragraph if self.cell.as_ref().is_some_and(|c| depth == c.depth + 1) => { - if let Some(cell) = self.cell.as_mut() { - if cell.paragraphs > 0 { - push_text(&mut cell.text, "\n")?; - } - cell.paragraph = Some(depth); - cell.paragraphs += 1; - cell.paragraph_started = false; - cell.pending_space = false; - } - } - Tag::Space | Tag::Tab | Tag::Break if self.captures_text() => { - let count = if t == Tag::Space { - let n = attr(reader, e, TEXT, b"c")?.map(|s| s.parse::()).transpose().map_err(xml_error)?.unwrap_or(1); - if n as usize > MAX_CELL_TEXT { - return Err(IoError::TooLarge("ODS repeated spaces exceed 1 MiB".into())); - } - n - } else { - 1 - }; - let value = match t { - Tag::Space => " ", - Tag::Tab => "\t", - _ => "\n", - }; - if let Some(cell) = self.cell.as_mut() { - if cell.pending_space { - push_text(&mut cell.text, " ")?; - cell.pending_space = false; - } - cell.paragraph_started = true; - if cell.text.len().saturating_add(count as usize) > MAX_CELL_TEXT { - return Err(IoError::TooLarge("ODS cell text exceeds 1 MiB".into())); - } - for _ in 0..count { - cell.text.push_str(value); - } - } - } - _ => {} - } - self.stack.push(t); - Ok(()) - } - - fn captures_text(&self) -> bool { - self.cell - .as_ref() - .and_then(|c| c.paragraph) - .is_some_and(|depth| self.stack.get(depth..).is_some_and(|p| p.iter().all(|t| matches!(t, Tag::Paragraph | Tag::Inline)))) - } - - fn append(&mut self, text: &str) -> Result<(), IoError> { - if self.captures_text() - && let Some(cell) = self.cell.as_mut() - { - // ODF 1.3 section 6.1.2: collapse XML whitespace across inline runs, - // but expand explicit text:s/tab/line-break elements separately. - for ch in text.chars() { - if matches!(ch, ' ' | '\t' | '\n' | '\r') { - cell.pending_space = cell.paragraph_started; - } else { - if cell.pending_space { - push_text(&mut cell.text, " ")?; - cell.pending_space = false; - } - push_text(&mut cell.text, ch.encode_utf8(&mut [0; 4]))?; - cell.paragraph_started = true; - } - } - } - Ok(()) - } - - fn end(&mut self) -> Result<(), IoError> { - self.stack.pop().ok_or_else(|| xml_error("unexpected closing element"))?; - let depth = self.stack.len(); - if let Some(cell) = self.cell.as_mut() - && cell.paragraph == Some(depth) - { - cell.paragraph = None; - } - if self.cell.as_ref().is_some_and(|c| c.depth == depth) { - self.finish_cell()?; - } - if self.row.as_ref().is_some_and(|r| r.depth == depth) { - self.finish_row()?; - } - if self.sheet.as_ref().is_some_and(|s| s.depth == depth) - && let Some(sheet) = self.sheet.take() - { - self.wb.sheets.push(Arc::new(sheet.sheet)); - } - Ok(()) - } - - fn finish_cell(&mut self) -> Result<(), IoError> { - let Some(draft) = self.cell.take() else { return Ok(()) }; - let cell = self.convert(&draft); - let (width, height) = if draft.covered { (1, 1) } else { (draft.width, draft.height) }; - let Some(row) = self.row.as_mut() else { return Ok(()) }; - let kept = !cell.is_blank() || width > 1 || height > 1; - // Writers pad rows with blank repeats up to their own (possibly wider) sheet edge; - // blank cells past ours carry no data, so clip them instead of rejecting the file. - let end = match row.col.checked_add(draft.repeat).filter(|n| *n <= MAX_COLS) { - Some(end) => end, - None if !kept => MAX_COLS, - None => return Err(IoError::TooLarge("ODS row exceeds worksheet width".into())), - }; - if kept { - // Charge the text a row keeps before the row is done, so a row of many long cells is - // refused as it grows; finish_row charges the row's repeats beyond the first. - if let Value::Text(t) = &cell.value { - self.text = self.text.saturating_add(u64::from(draft.repeat).saturating_mul(t.len() as u64)); - if self.text > MAX_TEXT { - return Err(IoError::TooLarge("ODS expands beyond the import limit (64 MiB of text)".into())); - } - } - row.cells.push(RepeatedCell { col: row.col, repeat: draft.repeat, width, height, cell }); - } - row.col = end; - Ok(()) - } - - fn convert(&mut self, draft: &CellDraft) -> Cell { - let raw = draft.raw.as_deref(); - let mut format = None; - let value = match draft.kind.as_deref() { - Some("float" | "percentage" | "currency") => raw.and_then(|s| s.parse::().ok()).filter(|n| n.is_finite()).map(|n| { - if draft.kind.as_deref() == Some("percentage") { - format = Some("0.00%"); - } - Value::Number(n) - }), - Some("boolean") => match raw { - Some("true" | "1") => Some(Value::Bool(true)), - Some("false" | "0") => Some(Value::Bool(false)), - _ => None, - }, - Some("string") if raw.is_some() || draft.paragraphs > 0 || !draft.formula => Some(Value::Text(Arc::from(raw.unwrap_or(&draft.text)))), - Some("void") if !draft.formula => Some(Value::Empty), - Some("date") => raw.and_then(parse_date).map(|(n, f)| { - format = Some(f); - Value::Number(n) - }), - Some("time") => raw.and_then(parse_duration).map(|n| { - format = Some("[h]:mm:ss.000"); - Value::Number(n) - }), - None if !draft.formula => Some(if draft.text.is_empty() { Value::Empty } else { Value::Text(Arc::from(draft.text.as_str())) }), - _ => None, - }; - let value = value.unwrap_or_else(|| { - self.report.warn("Some ODS values or formula caches were unsupported or missing; their displayed text (or raw value) was kept as text. A formula without either is marked [Unavailable ODS formula result]."); - let text = if !draft.text.is_empty() { draft.text.as_str() } else if let Some(raw) = raw { raw } else if draft.formula { "[Unavailable ODS formula result]" } else { "[Unsupported ODS value]" }; - Value::Text(Arc::from(text)) - }); - let style = match format { - Some(code) => match self.formats.iter().find(|(f, _)| *f == code) { - Some((_, id)) => *id, - None => { - let id = self.wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new(code)); - self.formats.push((code, id)); - id - } - }, - None => StyleId::DEFAULT, - }; - Cell { style, ..Cell::value(value) } - } - - fn finish_row(&mut self) -> Result<(), IoError> { - let Some(row) = self.row.take() else { return Ok(()) }; - let Some(sheet) = self.sheet.as_mut() else { return Ok(()) }; - // Blank trailing row repeats past the sheet edge (e.g. from larger-sheet writers) are clipped. - let end = match sheet.row.checked_add(row.repeat).filter(|n| *n <= MAX_ROWS) { - Some(end) => end, - None if row.cells.is_empty() => MAX_ROWS, - None => return Err(IoError::TooLarge("ODS exceeds worksheet height".into())), - }; - for entry in row.cells { - let count = u64::from(entry.repeat) * u64::from(row.repeat); - if !entry.cell.is_blank() { - self.cells = self.cells.saturating_add(count); - if let Value::Text(t) = &entry.cell.value { - let repeats = count.saturating_sub(u64::from(entry.repeat)); - self.text = self.text.saturating_add(repeats.saturating_mul(t.len() as u64)); - } - } - let merged = entry.width > 1 || entry.height > 1; - if merged { - self.merges = self.merges.saturating_add(count); - } - if self.cells > MAX_CELLS || self.merges > MAX_MERGES || self.text > MAX_TEXT { - return Err(IoError::TooLarge("ODS expands beyond the import limit (1 million cells, 100000 merges or 64 MiB of text)".into())); - } - let last_col = entry.col.checked_add(entry.repeat - 1).and_then(|c| c.checked_add(entry.width - 1)); - let last_row = end.checked_add(entry.height - 1); - if last_col.is_none_or(|c| c >= MAX_COLS) || last_row.is_none_or(|r| r > MAX_ROWS) { - return Err(IoError::TooLarge("ODS merged cell exceeds worksheet bounds".into())); - } - if merged && ((entry.repeat > 1 && entry.width > 1) || (row.repeat > 1 && entry.height > 1)) { - return Err(IoError::Format("repeated ODS cells have overlapping merges".into())); - } - for r in sheet.row..end { - for c in entry.col..entry.col + entry.repeat { - let pos = CellRef::new(r, c); - if !entry.cell.is_blank() { - sheet.sheet.cells.set(pos, entry.cell.clone()); - } - if merged { - sheet.sheet.merges.push(RangeRef::new(pos, CellRef::new(r + entry.height - 1, c + entry.width - 1))); - } - } - } - } - sheet.row = end; - Ok(()) +fn map_error(e: craft_ods::Error) -> IoError { + match e { + craft_ods::Error::Encrypted => IoError::Format("encrypted ODS files are not supported".into()), + craft_ods::Error::Xml(msg) => IoError::Xml(format!("ODS: {msg}")), + craft_ods::Error::TooLarge(msg) => IoError::TooLarge(msg), + craft_ods::Error::Invalid(msg) => IoError::Format(msg), + other => IoError::Format(other.to_string()), } } -fn push_text(out: &mut String, text: &str) -> Result<(), IoError> { - if out.len().saturating_add(text.len()) > MAX_CELL_TEXT { - return Err(IoError::TooLarge("ODS cell text exceeds 1 MiB".into())); +fn map_value(v: craft_ods::Value) -> Value { + match v { + craft_ods::Value::Empty => Value::Empty, + craft_ods::Value::Number(n) => Value::Number(n), + craft_ods::Value::Text(s) => Value::Text(Arc::from(s)), + craft_ods::Value::Bool(b) => Value::Bool(b), + craft_ods::Value::Error(e) => Value::Error(map_cell_error(e)), } - out.push_str(text); - Ok(()) } -/// Support unzoned ISO calendar dates and times. A timezone, invalid date or out-of-range -/// calendar year remains text; never silently discard an offset or roll an invalid date. -fn parse_date(s: &str) -> Option<(f64, &'static str)> { - let (date, time) = s.split_once('T').map_or((s, None), |(d, t)| (d, Some(t))); - if date.len() != 10 || date.get(4..5)? != "-" || date.get(7..8)? != "-" { - return None; +fn map_cell_error(e: craft_ods::CellError) -> CellError { + match e { + craft_ods::CellError::Null => CellError::Null, + craft_ods::CellError::Div0 => CellError::Div0, + craft_ods::CellError::Value => CellError::Value, + craft_ods::CellError::Ref => CellError::Ref, + craft_ods::CellError::Name => CellError::Name, + craft_ods::CellError::Num => CellError::Num, + craft_ods::CellError::NA => CellError::NA, + craft_ods::CellError::GettingData => CellError::GettingData, + craft_ods::CellError::Spill => CellError::Spill, + craft_ods::CellError::Calc => CellError::Calc, + craft_ods::CellError::Blocked => CellError::Blocked, + _ => CellError::Value, } - let year: i32 = digits(date.get(..4)?)?.parse().ok()?; - let month: u32 = digits(date.get(5..7)?)?.parse().ok()?; - let day: u32 = digits(date.get(8..10)?)?.parse().ok()?; - if !(1900..=9999).contains(&year) || !(1..=12).contains(&month) || day == 0 || day > days_in_month(year, month) { - return None; - } - let day = serial_from_ymd(DateSystem::D1900, year.into(), month.into(), day.into())?; - let Some(time) = time else { return Some((day, "yyyy-mm-dd")) }; - let mut parts = time.split(':'); - let h = parts.next()?; - let m = parts.next()?; - let sec = parts.next()?; - if parts.next().is_some() || h.len() != 2 || m.len() != 2 || sec.split('.').next()?.len() != 2 { - return None; - } - let h: u32 = digits(h)?.parse().ok()?; - let m: u32 = digits(m)?.parse().ok()?; - let sec = decimal(sec)?; - if h >= 24 || m >= 60 || sec >= 60.0 { - return None; - } - Some((day + (h as f64 * 3600.0 + m as f64 * 60.0 + sec) / 86400.0, "yyyy-mm-dd hh:mm:ss.000")) -} - -fn digits(s: &str) -> Option<&str> { - (!s.is_empty() && s.bytes().all(|b| b.is_ascii_digit())).then_some(s) -} -fn decimal(s: &str) -> Option { - match s.split_once('.') { - Some((a, b)) => { - digits(a)?; - digits(b)?; - } - None => { - digits(s)?; - } - } - s.parse::().ok().filter(|n| n.is_finite()) -} - -/// A bounded ISO day/time duration. Calendar years/months cannot be represented as days. -fn parse_duration(s: &str) -> Option { - let (negative, s) = s.strip_prefix('-').map_or((false, s), |s| (true, s)); - let mut rest = s.strip_prefix('P')?; - let mut total = 0.0; - let mut any = false; - if let Some((days, tail)) = rest.split_once('D') { - total += digits(days)?.parse::().ok()? * 86400.0; - rest = tail; - any = true; - } - if let Some(mut time) = rest.strip_prefix('T') { - let mut time_any = false; - for (unit, factor) in [('H', 3600.0), ('M', 60.0), ('S', 1.0)] { - if let Some((n, tail)) = time.split_once(unit) { - let value = if unit == 'S' { decimal(n)? } else { digits(n)?.parse::().ok()? }; - total += value * factor; - time = tail; - time_any = true; - } - } - if !time.is_empty() || !time_any { - return None; - } - any = true; - } else if !rest.is_empty() { - return None; - } - let days = total / 86400.0; - (any && days.is_finite() && days <= 2_958_465.0).then_some(if negative { -days } else { days }) }