docling-rs 2.2.2__tar.gz → 2.2.4__tar.gz

{docling_rs-2.2.2 → docling_rs-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-rs
-Version: 2.2.2
+Version: 2.2.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling"
 description = "DocumentConverter and format backends for docling.rs (a Rust port of docling)."
-version = "2.2.2"
+version = "2.2.4"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -79,9 +79,9 @@ headless_chrome = { version = "1.0", optional = true }
 # O_EXCL temp file with an unpredictable name for the browser pre-render page
 # (avoids a predictable /tmp path a local attacker could pre-plant a symlink at).
 tempfile = { version = "3", optional = true }
-docling-asr = { path = "../docling-asr", version = "2.2.2", optional = true }
-docling-core = { path = "../docling-core", version = "2.2.2" }
-docling-pdf = { path = "../docling-pdf", version = "2.2.2", optional = true, default-features = false }
+docling-asr = { path = "../docling-asr", version = "2.2.4", optional = true }
+docling-core = { path = "../docling-core", version = "2.2.4" }
+docling-pdf = { path = "../docling-pdf", version = "2.2.4", optional = true, default-features = false }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "gif", "bmp", "tiff", "webp"] }
 mail-parser = "0.11"
 pulldown-cmark = { version = "0.13.4", default-features = false }

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/cfb.rs

@@ -8,9 +8,10 @@
 //! bounded by the sector count (no cycle can loop forever) and stream sizes
 //! are capped by the same per-part budget as OOXML parts.
 //!
-//! Layout ([MS-CFB]): a 512-byte header names the first sectors of the DIFAT
-//! (which locates the FAT), the directory chain, and the mini FAT. Streams
-//! ≥ `mini_stream_cutoff` (4096) chain through the FAT; smaller ones live in
+//! Layout ([MS-CFB]): a 512-byte header (zero-padded to a whole 4096-byte
+//! sector in a version 4 file) names the first sectors of the DIFAT (which
+//! locates the FAT), the directory chain, and the mini FAT. Streams ≥
+//! `mini_stream_cutoff` (4096) chain through the FAT; smaller ones live in
 //! the *mini stream* (the root entry's stream) and chain through the mini FAT
 //! in 64-byte mini sectors.
 
@@ -313,9 +314,14 @@ impl<'a> CompoundFile<'a> {
     }
 }
 
-/// Byte offset of sector `n` (sector 0 starts right after the 512-byte header).
+/// Byte offset of sector `n`. The header occupies the file's first sector
+/// ([MS-CFB] 2.2): 512 bytes in a version 3 file, and in a version 4 file
+/// (4096-byte sectors) the same 512 bytes zero-padded to a whole sector, so
+/// sector 0 starts at 4096 there — `512 + n * 4096` read every v4 structure
+/// 3584 bytes early and rejected valid files as damaged (#623; PowerPoint
+/// writes v4 when an edited .ppt is saved in place).
 fn sector_offset(n: u32, sector_size: usize) -> usize {
-    512 + n as usize * sector_size
+    sector_size.max(512) + n as usize * sector_size
 }
 
 /// Follow a FAT chain from `start`, concatenating sectors, truncated to `size`
@@ -547,6 +553,166 @@ mod tests {
         );
     }
 
+    /// Rewrite a version 3 compound file as version 4 (#623): a 4096-byte
+    /// header sector, 4096-byte sectors, every FAT-chained stream, the mini
+    /// stream, the mini FAT and the directory re-chained in that order, the
+    /// FAT sector last. The directory gets a padding sector of unused entries
+    /// so its chain spans two sectors, and with `difat_sector` the FAT
+    /// sector is listed in a DIFAT sector instead of the header — a layout
+    /// only files of >109 FAT sectors (≈450 MB at 4 KiB) need, so it is the
+    /// only way a test reaches that read. Mini sectors stay 64 bytes in both
+    /// versions: the mini stream and mini FAT are copied verbatim.
+    fn to_v4(v3: &[u8], difat_sector: bool) -> Vec<u8> {
+        const SZ: usize = 4096;
+        let cfb = CompoundFile::open(v3).expect("valid v3 CFB");
+        assert_eq!(cfb.sector_size, 512, "source must be version 3");
+        let mut dir = read_chain(v3, &cfb.fat, u32_at(v3, 48).unwrap(), 512, u64::MAX).unwrap();
+        let mut body: Vec<u8> = Vec::new();
+        let mut fat: Vec<u32> = Vec::new();
+        let mut put = |bytes: &[u8], fat: &mut Vec<u32>| -> (u32, u32) {
+            let (start, n) = (fat.len() as u32, bytes.len().div_ceil(SZ).max(1) as u32);
+            fat.extend((1..=n).map(|i| if i == n { ENDOFCHAIN } else { start + i }));
+            body.extend_from_slice(bytes);
+            body.resize(fat.len() * SZ, 0);
+            (start, n)
+        };
+        let set = |dir: &mut Vec<u8>, i: usize, start: u32| {
+            dir[i * 128 + 116..i * 128 + 120].copy_from_slice(&start.to_le_bytes());
+            dir[i * 128 + 124..i * 128 + 128].fill(0); // v4 sizes are 64-bit
+        };
+        for (i, e) in cfb.entries.iter().enumerate() {
+            if e.object_type == 2 && e.size >= 4096 {
+                let (start, _) = put(&cfb.stream_by_index(i).unwrap(), &mut fat);
+                set(&mut dir, i, start);
+            } else if e.object_type == 5 && !cfb.mini_stream.is_empty() {
+                let (start, _) = put(&cfb.mini_stream, &mut fat);
+                set(&mut dir, i, start);
+            } else {
+                set(&mut dir, i, e.start_sector);
+            }
+        }
+        let mini_fat: Vec<u8> = cfb.mini_fat.iter().flat_map(|v| v.to_le_bytes()).collect();
+        let (mfat_start, mfat_n) = put(&mini_fat, &mut fat);
+        let entries = dir.len() / 128;
+        dir.resize((entries.div_ceil(32) + 1) * SZ, 0); // unused entries: name length 0
+        let (dir_start, dir_n) = put(&dir, &mut fat);
+        // The FAT itself: its own sector (and the DIFAT sector) marked, one
+        // 1024-entry sector covers every test file.
+        let fat_sector = fat.len() as u32;
+        fat.push(0xFFFF_FFFD); // FATSECT
+        if difat_sector {
+            fat.push(0xFFFF_FFFC); // DIFSECT
+        }
+        assert!(
+            fat.len() <= SZ / 4,
+            "test file too large for one FAT sector"
+        );
+        let mut fat_bytes: Vec<u8> = fat.iter().flat_map(|v| v.to_le_bytes()).collect();
+        fat_bytes.resize(SZ, 0xFF);
+        body.extend_from_slice(&fat_bytes);
+        let mut header = vec![0u8; SZ];
+        header[..8].copy_from_slice(&HEADER_MAGIC);
+        header[24..26].copy_from_slice(&0x003Eu16.to_le_bytes());
+        header[26..28].copy_from_slice(&4u16.to_le_bytes()); // major 4
+        header[28..30].copy_from_slice(&0xFFFEu16.to_le_bytes());
+        header[30..32].copy_from_slice(&12u16.to_le_bytes()); // 4096-byte sectors
+        header[32..34].copy_from_slice(&6u16.to_le_bytes());
+        header[40..44].copy_from_slice(&dir_n.to_le_bytes()); // v4 only
+        header[44..48].copy_from_slice(&1u32.to_le_bytes());
+        header[48..52].copy_from_slice(&dir_start.to_le_bytes());
+        header[56..60].copy_from_slice(&4096u32.to_le_bytes());
+        header[60..64].copy_from_slice(&mfat_start.to_le_bytes());
+        header[64..68].copy_from_slice(&mfat_n.to_le_bytes());
+        header[76..512].fill(0xFF);
+        if difat_sector {
+            let mut difat = vec![0xFFu8; SZ];
+            difat[..4].copy_from_slice(&fat_sector.to_le_bytes());
+            difat[SZ - 4..].copy_from_slice(&ENDOFCHAIN.to_le_bytes());
+            body.extend_from_slice(&difat);
+            header[68..72].copy_from_slice(&(fat_sector + 1).to_le_bytes());
+            header[72..76].copy_from_slice(&1u32.to_le_bytes());
+        } else {
+            header[68..72].copy_from_slice(&ENDOFCHAIN.to_le_bytes());
+            header[76..80].copy_from_slice(&fat_sector.to_le_bytes());
+        }
+        header.extend_from_slice(&body);
+        header
+    }
+
+    /// #623: version 4 files (4096-byte sectors, the header padded to one
+    /// sector) read every stream exactly as their version 3 source — FAT-
+    /// chained streams, the mini stream, a two-sector directory, a DIFAT
+    /// sector — and convert to the same document through each CFB backend
+    /// (.xls goes through calamine's own reader).
+    #[test]
+    fn v4_files_read_like_their_v3_source() {
+        use crate::{DocumentConverter, InputFormat, SourceDocument};
+        let own = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/");
+        let mirror = concat!(env!("CARGO_MANIFEST_DIR"), "/../../tests/data/");
+        let md = |name: &str, bytes: Vec<u8>| {
+            let ext = name.rsplit('.').next().unwrap();
+            let fmt = InputFormat::from_extension(ext).unwrap();
+            DocumentConverter::new()
+                .convert(SourceDocument::from_bytes(name, fmt, bytes))
+                .unwrap_or_else(|e| panic!("{name}: {e}"))
+                .document
+                .export_to_markdown()
+        };
+        for path in [
+            format!("{mirror}doc/sources/docx_lists.doc"),
+            format!("{own}doc/sources/embedded_word_object.doc"),
+            format!("{mirror}ppt/sources/powerpoint_sample.ppt"),
+            format!("{mirror}xls/sources/xlsx_05_table_with_title.xls"),
+            format!("{own}quattro/sources/formatcorpus_test.qpw"),
+            format!("{own}staroffice5/sources/Writer_3.1.sdw"),
+        ] {
+            let name = path.rsplit('/').next().unwrap();
+            let v3 = std::fs::read(&path).unwrap();
+            let want_streams = all_streams(&CompoundFile::open(&v3).unwrap());
+            let want_md = md(name, v3.clone());
+            assert!(!want_md.trim().is_empty(), "{name}: empty baseline");
+            for difat in [false, true] {
+                let v4 = to_v4(&v3, difat);
+                let cfb = CompoundFile::open(&v4)
+                    .unwrap_or_else(|| panic!("{name} v4 (difat {difat}): open failed"));
+                assert_eq!(cfb.sector_size, 4096);
+                assert!(
+                    all_streams(&cfb) == want_streams,
+                    "{name} v4 (difat {difat}): streams differ"
+                );
+                assert_eq!(md(name, v4), want_md, "{name} v4 (difat {difat})");
+            }
+        }
+    }
+
+    /// The PowerPoint-written version 4 file of #623 (an edited .ppt saved
+    /// in place) opens, and losing its last sector — the end of the
+    /// `\u{5}SummaryInformation` stream — is still reported as damage to
+    /// that stream, not read as a shorter one.
+    #[test]
+    fn real_v4_file_opens_and_its_truncation_is_damage() {
+        let data = std::fs::read(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/tests/data/ppt/sources/ppt_cfb_v4_edit_save.ppt"
+        ))
+        .unwrap();
+        assert_eq!(u16_at(&data, 26), Some(4), "fixture must be version 4");
+        let cfb = CompoundFile::open(&data).expect("valid v4 CFB");
+        assert_eq!(cfb.sector_size, 4096);
+        let len = |cfb: &CompoundFile, name| cfb.stream(name).map(|s| s.len());
+        assert_eq!(len(&cfb, "PowerPoint Document"), Some(35685));
+        assert_eq!(len(&cfb, "Current User"), Some(32)); // a mini stream entry
+        assert_eq!(len(&cfb, "\u{5}SummaryInformation"), Some(43648));
+        let short = &data[..data.len() - 4096];
+        let cfb = CompoundFile::open(short).expect("directory and FAT intact");
+        assert_eq!(len(&cfb, "PowerPoint Document"), Some(35685));
+        assert_eq!(len(&cfb, "\u{5}SummaryInformation"), None);
+        assert_eq!(
+            cfb.stream_error("ppt", "\u{5}SummaryInformation"),
+            "ppt: \u{5}SummaryInformation stream unreadable (file truncated or corrupt)"
+        );
+    }
+
     #[test]
     fn truncated_header_is_rejected_not_panicked() {
         let data = std::fs::read(concat!(
@@ -554,9 +720,12 @@ mod tests {
             "/../../tests/data/doc/sources/docx_lists.doc"
         ))
         .unwrap();
-        // Every truncation point must fail cleanly, never panic.
+        // Every truncation point must fail cleanly — `None`, never a panic.
         for cut in [8, 76, 512, 700] {
-            let _ = CompoundFile::open(&data[..cut.min(data.len())]);
+            assert!(
+                CompoundFile::open(&data[..cut.min(data.len())]).is_none(),
+                "cut at {cut}"
+            );
         }
     }
 }

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/doc.rs

@@ -2396,42 +2396,6 @@ mod tests {
         assert_eq!(furniture, [("page_header", "MARK_HEADER_TEXTBOX_TEXT")]);
     }
 
-    #[test]
-    fn extracts_headings_lists_and_paragraphs() {
-        let doc = DocBackend
-            .convert(&fixture("docx_lists.doc"))
-            .expect("converts");
-        let headings = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::Heading { .. }))
-            .count();
-        let lists = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::ListItem { .. }))
-            .count();
-        assert!(headings > 0, "expected headings: {:?}", doc.nodes);
-        assert!(lists > 0, "expected list items: {:?}", doc.nodes);
-    }
-
-    #[test]
-    fn extracts_tables_with_cells() {
-        let doc = DocBackend
-            .convert(&fixture("docx_rich_tables_01.doc"))
-            .expect("converts");
-        let tables: Vec<&Table> = doc
-            .nodes
-            .iter()
-            .filter_map(|n| match n {
-                Node::Table(t) => Some(t),
-                _ => None,
-            })
-            .collect();
-        assert!(!tables.is_empty(), "expected tables: {:?}", doc.nodes);
-        assert!(tables[0].rows.len() > 1 && tables[0].rows[0].len() > 1);
-    }
-
     /// #567: prose is Markdown-escaped like the DOCX backend's — `OBJ_DIR`
     /// becomes `OBJ\_DIR` in the Markdown (the reporter's Word 2.133 and
     /// DOCX outputs), and the JSON export restores the raw text.

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/html.rs

@@ -2240,14 +2240,37 @@ fn is_row_header(cells: &[ElementRef]) -> bool {
 /// HTML5's "rowspan=0 spans to the end of the row group" is not modelled,
 /// the cell simply keeps one slot).
 fn span_attr(cell: ElementRef, name: &str) -> usize {
-    let Some(v) = cell.value().attr(name) else {
+    let limit = if name == "colspan" {
+        MAX_COLSPAN
+    } else {
+        MAX_ROWSPAN
+    };
+    span_value(cell.value().attr(name), limit)
+}
+
+/// docling's `MAX_COLSPAN` / `MAX_ROWSPAN` (`backend/utils/table_spans.py`,
+/// HTML's own limits): a declared span past them is clamped, so a
+/// `colspan="999999999"` cannot make the grid builder allocate billions of
+/// slots.
+pub(super) const MAX_COLSPAN: usize = 1000;
+pub(super) const MAX_ROWSPAN: usize = 65_534;
+
+/// One span attribute as `_get_cell_spans` reads it — [`span_attr`]'s rule,
+/// clamped to `[1, limit]` (`clamp_span`); a digit run too long to parse is
+/// over every limit, so it is the limit. Shared with the JSON item tree
+/// (`html_tree`), which must see the same grid.
+pub(super) fn span_value(raw: Option<&str>, limit: usize) -> usize {
+    let Some(v) = raw else {
         return 1;
     };
     if !v.starts_with(|c: char| c.is_numeric()) {
         return 1;
     }
     let digits: String = v.chars().take_while(|c| c.is_ascii_digit()).collect();
-    digits.parse::<usize>().map_or(1, |n| n.max(1))
+    match digits.trim_start_matches('0') {
+        "" => 1,
+        d => d.parse::<usize>().map_or(limit, |n| n.clamp(1, limit)),
+    }
 }
 
 /// Render a table cell to Markdown. docling treats a cell as "rich" (and

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/html_tree.rs

@@ -303,18 +303,15 @@ fn has_list_ancestor(elem: NodeRef<'_, HtmlNode>, boundary: NodeRef<'_, HtmlNode
 }
 
 /// upstream's `_get_cell_spans`: `colspan` / `rowspan`, each the leading
-/// digit run when the attribute starts with a digit, else 1 (so `"0"` is 0).
+/// digit run when the attribute starts with a digit, else 1, clamped to
+/// `[1, MAX_*SPAN]` — the same reading as the Markdown grid (`html.rs`), so
+/// a `rowspan="0"` keeps its slot in the JSON too (docling#4287, 2.129).
 fn cell_spans(cell: ElementRef) -> (usize, usize) {
-    let num = |attr: &str| -> usize {
-        let raw = cell.value().attr(attr).unwrap_or("1");
-        if raw.starts_with(|c: char| c.is_ascii_digit()) {
-            let digits: String = raw.chars().take_while(|c| c.is_ascii_digit()).collect();
-            digits.parse().unwrap_or(1)
-        } else {
-            1
-        }
-    };
-    (num("colspan"), num("rowspan"))
+    use super::html::{span_value, MAX_COLSPAN, MAX_ROWSPAN};
+    (
+        span_value(cell.value().attr("colspan"), MAX_COLSPAN),
+        span_value(cell.value().attr("rowspan"), MAX_ROWSPAN),
+    )
 }
 
 /// An `href` as docling's `AnnotatedText.hyperlink` serializes it: a URL
@@ -1968,11 +1965,15 @@ mod tests {
     #[test]
     fn cell_spans_follow_get_cell_spans() {
         let html = Html::parse_fragment(
-            r#"<table><tr><td colspan="3x" rowspan="0">a</td><td rowspan="x2">b</td></tr></table>"#,
+            r#"<table><tr><td colspan="3x" rowspan="0">a</td><td rowspan="x2">b</td>
+               <td colspan="99999999999999999999999" rowspan="70000">c</td></tr></table>"#,
         );
         let cells: Vec<ElementRef> = html.select(sel!("td")).collect();
-        assert_eq!(cell_spans(cells[0]), (3, 0));
+        // A zero span keeps one slot (docling#4287), not none.
+        assert_eq!(cell_spans(cells[0]), (3, 1));
         assert_eq!(cell_spans(cells[1]), (1, 1));
+        // Past HTML's limits: clamped, even past `usize`.
+        assert_eq!(cell_spans(cells[2]), (1000, 65_534));
     }
 
     /// The shape upstream gives a small page: the `<title>` and the prelude

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/mhtml.rs

@@ -641,17 +641,6 @@ mod tests {
         assert!(md(data).contains("Привет, мир"));
     }
 
-    #[test]
-    fn real_blink_fixture_decodes_quoted_printable_html() {
-        // docling's `tests/data/mhtml/sources/example.mhtml`, mirrored (#386).
-        let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../tests/data/mhtml/sources/example.mhtml");
-        let bytes = std::fs::read(path).expect("mirrored upstream fixture");
-        let markdown = md(bytes);
-        assert!(markdown.contains("# Example Domain"), "{markdown}");
-        assert!(markdown.contains("[Learn more](https://iana.org/domains/example)"));
-    }
-
     #[test]
     fn embedded_images_resolve_by_location_and_cid() {
         let parts = png_part(

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/ppt.rs

@@ -792,50 +792,6 @@ mod tests {
     use super::*;
     use crate::InputFormat;
 
-    fn fixture(name: &str) -> SourceDocument {
-        let path = format!(
-            "{}/../../tests/data/ppt/sources/{name}",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let bytes = std::fs::read(&path).expect("fixture exists");
-        SourceDocument::from_bytes(name, InputFormat::Ppt, bytes)
-    }
-
-    #[test]
-    fn extracts_slide_titles_and_text() {
-        let doc = PptBackend
-            .convert(&fixture("powerpoint_sample.ppt"))
-            .expect("converts");
-        let headings = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::Heading { .. }))
-            .count();
-        assert!(headings > 0, "expected slide titles: {:?}", doc.nodes);
-    }
-
-    #[test]
-    fn reconstructs_grouped_shapes_into_a_table() {
-        let doc = PptBackend
-            .convert(&fixture("powerpoint_sample.ppt"))
-            .expect("converts");
-        let tables: Vec<&Table> = doc
-            .nodes
-            .iter()
-            .filter_map(|n| match n {
-                Node::Table(t) => Some(t),
-                _ => None,
-            })
-            .collect();
-        assert!(!tables.is_empty(), "expected a reconstructed table");
-        let t = tables[0];
-        assert!(
-            t.rows.len() >= 2 && t.rows[0].len() >= 2,
-            "grid too small: {:?}",
-            t.rows
-        );
-    }
-
     #[test]
     fn grid_table_rejects_a_column_of_shapes() {
         // Four stacked shapes (one column) must NOT read as a table.

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/pptx.rs

@@ -1299,52 +1299,6 @@ fn cell_text(tc: XmlNode) -> String {
 fn descendant<'a, 'input>(node: XmlNode<'a, 'input>, name: &str) -> Option<XmlNode<'a, 'input>> {
     node.descendants().find(|n| n.has_tag_name(name))
 }
-#[cfg(test)]
-mod chart_tests {
-    use super::*;
-    use crate::backend::DeclarativeBackend;
-    use crate::{InputFormat, SourceDocument};
-
-    /// docling PR #3794: a native chart frame becomes a classified chart with
-    /// its cached data grid and the chart title as the caption.
-    #[test]
-    fn native_chart_yields_classified_data_grid() {
-        let path = format!(
-            "{}/../../tests/data/pptx/sources/pptx_chart.pptx",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let bytes = std::fs::read(&path).expect("fixture exists");
-        let src = SourceDocument::from_bytes("c.pptx", InputFormat::Pptx, bytes);
-        let doc = PptxBackend.convert(&src).expect("converts");
-        let chart = doc
-            .nodes
-            .iter()
-            // Slide content hangs off the slide's own group (#402).
-            .flat_map(|n| match n {
-                Node::Group { children, .. } => children.as_slice(),
-                other => std::slice::from_ref(other),
-            })
-            .find_map(|n| match n {
-                Node::Chart {
-                    kind,
-                    table,
-                    caption,
-                    ..
-                } => Some((kind.clone(), table.clone(), caption.clone())),
-                _ => None,
-            })
-            .expect("a chart node");
-        assert_eq!(chart.0, "bar_chart");
-        assert_eq!(
-            chart.2.as_deref(),
-            Some("Wild Duck Observations by Year"),
-            "chart title as caption"
-        );
-        assert_eq!(chart.1.rows[0][1], "Freshwater Ducks");
-        assert_eq!(chart.1.rows[1], vec!["2019", "120", "80"]);
-    }
-}
-
 #[cfg(test)]
 mod list_marker_tests {
     use super::{list_kind, Placeholder};

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/quattro.rs

@@ -707,26 +707,4 @@ mod tests {
         assert_eq!(g[&(3, 1)], "1.5");
         assert_eq!(g[&(4, 1)], "-2");
     }
-
-    #[test]
-    fn corpus_samples_convert() {
-        let dir =
-            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/data/quattro/sources");
-        for (f, needle) in [
-            ("formatcorpus_ksbase.wq1", "OBSERV"),
-            (
-                "formatcorpus_ks4000.wq2",
-                "SATURATED HYDRAULIC CONDUCTIVITY",
-            ),
-            ("formatcorpus_test.wb1", "| X |"),
-            ("formatcorpus_test.wb2", "| X |"),
-            ("formatcorpus_test.wb3", "This is an example spreadsheet"),
-            ("formatcorpus_test.qpw", "This is an example spreadsheet"),
-        ] {
-            let bytes = std::fs::read(dir.join(f)).unwrap();
-            let doc = convert(bytes).unwrap_or_else(|e| panic!("{f}: {e}"));
-            let md = md(&doc);
-            assert!(md.contains(needle), "{f}:\n{md}");
-        }
-    }
 }

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/wps.rs

@@ -1105,21 +1105,4 @@ mod tests {
             .to_string();
         assert!(e.contains("not a Microsoft Works document"), "{e}");
     }
-
-    #[test]
-    fn libreoffice_fixtures_parse() {
-        // LibreOffice's libwps smoke files are near-empty documents; they
-        // must at least parse and detect their generation.
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/data/works/sources");
-        for f in [
-            "works2_dos.wps",
-            "works3.wps",
-            "works45.wps",
-            "works5.wps",
-            "works6.wps",
-        ] {
-            let bytes = std::fs::read(dir.join(f)).unwrap();
-            convert(bytes).unwrap_or_else(|e| panic!("{f}: {e}"));
-        }
-    }
 }

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling/src/backend/xls.rs

@@ -124,28 +124,6 @@ mod tests {
     use super::*;
     use crate::InputFormat;
 
-    fn fixture(name: &str) -> SourceDocument {
-        let path = format!(
-            "{}/../../tests/data/xls/sources/{name}",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let bytes = std::fs::read(&path).expect("fixture exists");
-        SourceDocument::from_bytes(name, InputFormat::Xls, bytes)
-    }
-
-    #[test]
-    fn parses_xls_tables_like_the_xlsx_twin() {
-        let doc = XlsBackend::default()
-            .convert(&fixture("xlsx_01.xls"))
-            .expect("converts");
-        let tables: Vec<_> = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::Table(_)))
-            .collect();
-        assert!(!tables.is_empty(), "expected tables, got: {:?}", doc.nodes);
-    }
-
     #[test]
     fn garbage_is_an_error_not_a_panic() {
         let src = SourceDocument::from_bytes("x.xls", InputFormat::Xls, vec![0u8; 64]);

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling-asr/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-asr"
 description = "Audio/ASR pipeline for docling.rs (Whisper via ONNX; a Rust port of docling's ASR pipeline)."
-version = "2.2.2"
+version = "2.2.4"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -25,10 +25,10 @@ xnnpack = ["docling-onnx/xnnpack"]
 ort-load-dynamic = ["docling-onnx/load-dynamic", "ort/load-dynamic"]
 
 [dependencies]
-docling-core = { path = "../docling-core", version = "2.2.2" }
+docling-core = { path = "../docling-core", version = "2.2.4" }
 # Shared ONNX execution-provider selection (DOCLING_RS_EP, #288) — routes the
 # Whisper encoder/decoder sessions through the same switch as docling-pdf.
-docling-onnx = { path = "../docling-onnx", version = "2.2.2" }
+docling-onnx = { path = "../docling-onnx", version = "2.2.4" }
 # Same ort as docling-pdf so the workspace keeps a single ONNX runtime.
 ort = { version = "2.0.0-rc.13", default-features = false, features = ["std", "download-binaries", "tls-rustls"] }
 serde_json = "1"

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-core"
 description = "Core DoclingDocument data model and serializers for docling.rs (a Rust port of docling)."
-version = "2.2.2"
+version = "2.2.4"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling-core/src/markdown.rs

@@ -2628,7 +2628,6 @@ mod tests {
     /// buffered export.
     #[test]
     fn streamer_matches_buffered_export_with_options() {
-        use crate::document::ContentLayer;
         let doc = options_doc();
         let options = MarkdownExportOptions {
             layers: ContentLayers::ALL,
@@ -2651,7 +2650,6 @@ mod tests {
             buffered.contains("(img)") && buffered.contains("R&D _ report"),
             "{buffered}"
         );
-        let _ = ContentLayer::Notes;
     }
 
     /// #613: the plain export of a document holding every decoration the

{docling_rs-2.2.2 → docling_rs-2.2.4}/docling-onnx/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-onnx"
 description = "Shared ONNX Runtime execution-provider selection for docling.rs (DOCLING_RS_EP)."
-version = "2.2.2"
+version = "2.2.4"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -41,7 +41,7 @@ xnnpack = ["ort/xnnpack"]
 load-dynamic = ["ort/load-dynamic", "dep:libloading"]
 
 [dependencies]
-docling-core = { path = "../docling-core", version = "2.2.2" }
+docling-core = { path = "../docling-core", version = "2.2.4" }
 # Same ort build as docling-pdf/docling-asr so the workspace keeps a single
 # ONNX Runtime.
 ort = { version = "2.0.0-rc.13", default-features = false, features = ["std", "download-binaries", "tls-rustls"] }