kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/vendor/kreuzberg/src/extraction/excel.rs

@@ -34,7 +34,6 @@ use std::io::Cursor;
 use std::path::Path;
 
 use crate::error::{KreuzbergError, Result};
-use crate::extraction::capacity;
 use crate::types::{ExcelSheet, ExcelWorkbook};
 
 #[cfg(feature = "office")]
@@ -145,153 +144,110 @@ fn process_sheet(name: &str, range: &Range<Data>) -> ExcelSheet {
 
     let estimated_capacity = 50 + (cols * 20) + (rows * cols * 12);
 
-    if rows == 0 || cols == 0 {
-        let markdown = format!("## {}\n\n*Empty sheet*", name);
-        ExcelSheet {
-            name: name.to_owned(),
-            markdown,
-            row_count: rows,
-            col_count: cols,
-            cell_count,
-            table_cells: None,
-        }
+    let markdown = if rows == 0 || cols == 0 {
+        format!("## {}\n\n*Empty sheet*", name)
     } else {
-        let (markdown, table_cells) = generate_markdown_and_cells(name, range, estimated_capacity);
-        ExcelSheet {
-            name: name.to_owned(),
-            markdown,
-            row_count: rows,
-            col_count: cols,
-            cell_count,
-            table_cells: Some(table_cells),
-        }
+        generate_markdown_from_range_optimized(name, range, estimated_capacity)
+    };
+
+    ExcelSheet {
+        name: name.to_owned(),
+        markdown,
+        row_count: rows,
+        col_count: cols,
+        cell_count,
     }
 }
 
-/// Generate both markdown and extracted cells in a single pass.
-///
-/// This function produces both the markdown representation and the structured
-/// cell data simultaneously, avoiding the expensive markdown re-parsing that
-/// was previously done in `sheets_to_tables()`.
-///
-/// Returns (markdown, table_cells) where table_cells is a 2D vector of strings.
-fn generate_markdown_and_cells(sheet_name: &str, range: &Range<Data>, capacity: usize) -> (String, Vec<Vec<String>>) {
+fn generate_markdown_from_range_optimized(sheet_name: &str, range: &Range<Data>, capacity: usize) -> String {
+    let mut result = String::with_capacity(capacity);
+
+    write!(result, "## {}\n\n", sheet_name).unwrap();
+
     let rows: Vec<_> = range.rows().collect();
     if rows.is_empty() {
-        let result_capacity = 50 + sheet_name.len();
-        let mut result = String::with_capacity(result_capacity);
-        write!(result, "## {}\n\n*No data*", sheet_name).unwrap();
-        return (result, Vec::new());
+        result.push_str("*No data*");
+        return result;
     }
 
     let header = &rows[0];
     let header_len = header.len();
-    let row_count = rows.len();
-
-    let table_capacity = capacity::estimate_table_markdown_capacity(row_count, header_len);
-
-    let mut exact_size = 16 + sheet_name.len();
-
-    exact_size += 2 + (header_len * 2);
-    exact_size += header_len * 10;
-
-    exact_size += 5 + (header_len * 5);
-
-    exact_size += (row_count - 1) * (5 + header_len * 15);
-
-    let mut markdown = String::with_capacity(exact_size.max(table_capacity).max(capacity));
-    let mut cells: Vec<Vec<String>> = Vec::with_capacity(row_count);
-
-    write!(markdown, "## {}\n\n", sheet_name).unwrap();
 
-    let mut header_cells = Vec::with_capacity(header_len);
-    markdown.push_str("| ");
+    result.push_str("| ");
     for (i, cell) in header.iter().enumerate() {
         if i > 0 {
-            markdown.push_str(" | ");
-        }
-        let cell_str = format_cell_to_string(cell);
-        header_cells.push(cell_str.clone());
-
-        if cell_str.contains('|') || cell_str.contains('\\') {
-            escape_markdown_into(&mut markdown, &cell_str);
-        } else {
-            markdown.push_str(&cell_str);
+            result.push_str(" | ");
         }
+        format_cell_value_into(&mut result, cell);
     }
-    markdown.push_str(" |\n");
-    cells.push(header_cells);
+    result.push_str(" |\n");
 
-    markdown.push_str("| ");
+    result.push_str("| ");
     for i in 0..header_len {
         if i > 0 {
-            markdown.push_str(" | ");
+            result.push_str(" | ");
         }
-        markdown.push_str("---");
+        result.push_str("---");
     }
-    markdown.push_str(" |\n");
+    result.push_str(" |\n");
 
     for row in rows.iter().skip(1) {
-        let mut row_cells = Vec::with_capacity(header_len);
-        markdown.push_str("| ");
+        result.push_str("| ");
         for i in 0..header_len {
             if i > 0 {
-                markdown.push_str(" | ");
+                result.push_str(" | ");
             }
             if let Some(cell) = row.get(i) {
-                let cell_str = format_cell_to_string(cell);
-                row_cells.push(cell_str.clone());
-
-                if cell_str.contains('|') || cell_str.contains('\\') {
-                    escape_markdown_into(&mut markdown, &cell_str);
-                } else {
-                    markdown.push_str(&cell_str);
-                }
-            } else {
-                row_cells.push(String::new());
+                format_cell_value_into(&mut result, cell);
             }
         }
-        markdown.push_str(" |\n");
-        cells.push(row_cells);
+        result.push_str(" |\n");
     }
 
-    (markdown, cells)
+    result
 }
 
-/// Convert a Data cell to its string representation.
-///
-/// This helper function is shared between markdown generation and cell extraction
-/// to ensure byte-identical output.
 #[inline]
-fn format_cell_to_string(data: &Data) -> String {
+fn format_cell_value_into(buffer: &mut String, data: &Data) {
     match data {
-        Data::Empty => String::new(),
-        Data::String(s) => s.clone(),
+        Data::Empty => {}
+        Data::String(s) => {
+            if s.contains('|') || s.contains('\\') {
+                escape_markdown_into(buffer, s);
+            } else {
+                buffer.push_str(s);
+            }
+        }
         Data::Float(f) => {
             if f.fract() == 0.0 {
-                format!("{:.1}", f)
+                write!(buffer, "{:.1}", f).unwrap();
             } else {
-                format!("{}", f)
+                write!(buffer, "{}", f).unwrap();
             }
         }
-        Data::Int(i) => format!("{}", i),
+        Data::Int(i) => {
+            write!(buffer, "{}", i).unwrap();
+        }
         Data::Bool(b) => {
-            if *b {
-                "true".to_string()
-            } else {
-                "false".to_string()
-            }
+            buffer.push_str(if *b { "true" } else { "false" });
         }
         Data::DateTime(dt) => {
             if let Some(datetime) = dt.as_datetime() {
-                format!("{}", datetime.format("%Y-%m-%d %H:%M:%S"))
+                write!(buffer, "{}", datetime.format("%Y-%m-%d %H:%M:%S")).unwrap();
             } else {
-                format!("{:?}", dt)
+                write!(buffer, "{:?}", dt).unwrap();
             }
         }
-        Data::Error(e) => format!("#ERR: {:?}", e),
-        Data::DateTimeIso(s) => s.clone(),
-        Data::DurationIso(s) => format!("DURATION: {}", s),
+        Data::Error(e) => {
+            write!(buffer, "#ERR: {:?}", e).unwrap();
+        }
+        Data::DateTimeIso(s) => {
+            buffer.push_str(s);
+        }
+        Data::DurationIso(s) => {
+            buffer.push_str("DURATION: ");
+            buffer.push_str(s);
+        }
     }
 }
 
@@ -469,12 +425,31 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_format_cell_to_string_basic() {
-        assert_eq!(format_cell_to_string(&Data::Empty), "");
-        assert_eq!(format_cell_to_string(&Data::String("test".to_owned())), "test");
-        assert_eq!(format_cell_to_string(&Data::Float(42.0)), "42.0");
-        assert_eq!(format_cell_to_string(&Data::Int(100)), "100");
-        assert_eq!(format_cell_to_string(&Data::Bool(true)), "true");
+    fn test_format_cell_value_into() {
+        let mut buffer = String::with_capacity(100);
+
+        format_cell_value_into(&mut buffer, &Data::Empty);
+        assert_eq!(buffer, "");
+
+        buffer.clear();
+        format_cell_value_into(&mut buffer, &Data::String("test".to_owned()));
+        assert_eq!(buffer, "test");
+
+        buffer.clear();
+        format_cell_value_into(&mut buffer, &Data::Float(42.0));
+        assert_eq!(buffer, "42.0");
+
+        buffer.clear();
+        format_cell_value_into(&mut buffer, &Data::Float(std::f64::consts::PI));
+        assert_eq!(buffer, "3.141592653589793");
+
+        buffer.clear();
+        format_cell_value_into(&mut buffer, &Data::Int(100));
+        assert_eq!(buffer, "100");
+
+        buffer.clear();
+        format_cell_value_into(&mut buffer, &Data::Bool(true));
+        assert_eq!(buffer, "true");
     }
 
     #[test]
@@ -495,35 +470,43 @@ mod tests {
 
     #[test]
     fn test_capacity_optimization() {
-        let buffer = String::with_capacity(100);
+        let mut buffer = String::with_capacity(100);
+        format_cell_value_into(&mut buffer, &Data::String("test".to_owned()));
+
         assert!(buffer.capacity() >= 100);
     }
 
     #[test]
     fn test_format_cell_value_datetime() {
         use calamine::{ExcelDateTime, ExcelDateTimeType};
+        let mut buffer = String::new();
+
         let dt = Data::DateTime(ExcelDateTime::new(49353.5, ExcelDateTimeType::DateTime, false));
-        let result = format_cell_to_string(&dt);
-        assert!(!result.is_empty());
+        format_cell_value_into(&mut buffer, &dt);
+        assert!(!buffer.is_empty());
     }
 
     #[test]
     fn test_format_cell_value_error() {
         use calamine::CellErrorType;
-        let result = format_cell_to_string(&Data::Error(CellErrorType::Div0));
-        assert!(result.contains("#ERR"));
+        let mut buffer = String::new();
+
+        format_cell_value_into(&mut buffer, &Data::Error(CellErrorType::Div0));
+        assert!(buffer.contains("#ERR"));
     }
 
     #[test]
     fn test_format_cell_value_datetime_iso() {
-        let result = format_cell_to_string(&Data::DateTimeIso("2024-01-01T10:30:00".to_owned()));
-        assert_eq!(result, "2024-01-01T10:30:00");
+        let mut buffer = String::new();
+        format_cell_value_into(&mut buffer, &Data::DateTimeIso("2024-01-01T10:30:00".to_owned()));
+        assert_eq!(buffer, "2024-01-01T10:30:00");
     }
 
     #[test]
     fn test_format_cell_value_duration_iso() {
-        let result = format_cell_to_string(&Data::DurationIso("PT1H30M".to_owned()));
-        assert_eq!(result, "DURATION: PT1H30M");
+        let mut buffer = String::new();
+        format_cell_value_into(&mut buffer, &Data::DurationIso("PT1H30M".to_owned()));
+        assert_eq!(buffer, "DURATION: PT1H30M");
     }
 
     #[test]
@@ -588,16 +571,16 @@ mod tests {
     }
 
     #[test]
-    fn test_generate_markdown_and_cells_empty() {
-        let range: Range<Data> = Range::empty();
-        let (markdown, cells) = generate_markdown_and_cells("Test", &range, 100);
+    fn test_generate_markdown_empty_range() {
+        let range: Range<Data> = Range::new((0, 0), (0, 0));
+        let markdown = generate_markdown_from_range_optimized("Test", &range, 100);
 
         assert!(markdown.contains("## Test"));
-        assert!(cells.is_empty());
+        assert!(markdown.contains("|"));
     }
 
     #[test]
-    fn test_generate_markdown_and_cells_with_data() {
+    fn test_generate_markdown_with_headers() {
         let mut range: Range<Data> = Range::new((0, 0), (1, 2));
         range.set_value((0, 0), Data::String("Col1".to_owned()));
         range.set_value((0, 1), Data::String("Col2".to_owned()));
@@ -606,16 +589,20 @@ mod tests {
         range.set_value((1, 1), Data::String("B".to_owned()));
         range.set_value((1, 2), Data::String("C".to_owned()));
 
-        let (markdown, cells) = generate_markdown_and_cells("Sheet1", &range, 200);
+        let markdown = generate_markdown_from_range_optimized("Sheet1", &range, 200);
 
         assert!(markdown.contains("## Sheet1"));
         assert!(markdown.contains("Col1"));
+        assert!(markdown.contains("Col2"));
+        assert!(markdown.contains("Col3"));
         assert!(markdown.contains("---"));
-        assert_eq!(cells.len(), 2);
+        assert!(markdown.contains("A"));
+        assert!(markdown.contains("B"));
+        assert!(markdown.contains("C"));
     }
 
     #[test]
-    fn test_generate_markdown_and_cells_sparse() {
+    fn test_generate_markdown_sparse_data() {
         let mut range: Range<Data> = Range::new((0, 0), (2, 2));
         range.set_value((0, 0), Data::String("A".to_owned()));
         range.set_value((0, 1), Data::String("B".to_owned()));
@@ -623,42 +610,46 @@ mod tests {
         range.set_value((1, 0), Data::String("X".to_owned()));
         range.set_value((1, 2), Data::String("Z".to_owned()));
 
-        let (markdown, cells) = generate_markdown_and_cells("Sparse", &range, 200);
+        let markdown = generate_markdown_from_range_optimized("Sparse", &range, 200);
 
         assert!(markdown.contains("X"));
         assert!(markdown.contains("Z"));
-        assert_eq!(cells.len(), 3);
+        let lines: Vec<&str> = markdown.lines().collect();
+        assert!(lines.iter().any(|line| line.contains("|  |") || line.contains("| |")));
     }
 
     #[test]
     fn test_format_cell_value_float_integer() {
-        let result = format_cell_to_string(&Data::Float(100.0));
-        assert_eq!(result, "100.0");
+        let mut buffer = String::new();
+        format_cell_value_into(&mut buffer, &Data::Float(100.0));
+        assert_eq!(buffer, "100.0");
     }
 
     #[test]
     fn test_format_cell_value_float_decimal() {
-        let result = format_cell_to_string(&Data::Float(12.3456));
-        assert_eq!(result, "12.3456");
+        let mut buffer = String::new();
+        format_cell_value_into(&mut buffer, &Data::Float(12.3456));
+        assert_eq!(buffer, "12.3456");
     }
 
     #[test]
     fn test_format_cell_value_bool_false() {
-        let result = format_cell_to_string(&Data::Bool(false));
-        assert_eq!(result, "false");
+        let mut buffer = String::new();
+        format_cell_value_into(&mut buffer, &Data::Bool(false));
+        assert_eq!(buffer, "false");
     }
 
     #[test]
-    fn test_format_cell_escape_pipe() {
+    fn test_format_cell_value_string_with_pipe() {
         let mut buffer = String::new();
-        escape_markdown_into(&mut buffer, "value|with|pipes");
+        format_cell_value_into(&mut buffer, &Data::String("value|with|pipes".to_owned()));
         assert_eq!(buffer, "value\\|with\\|pipes");
     }
 
     #[test]
-    fn test_format_cell_escape_backslash() {
+    fn test_format_cell_value_string_with_backslash() {
         let mut buffer = String::new();
-        escape_markdown_into(&mut buffer, "path\\to\\file");
+        format_cell_value_into(&mut buffer, &Data::String("path\\to\\file".to_owned()));
         assert_eq!(buffer, "path\\\\to\\\\file");
     }
 
@@ -670,7 +661,7 @@ mod tests {
         range.set_value((1, 0), Data::String("A".to_owned()));
         range.set_value((1, 1), Data::String("B".to_owned()));
 
-        let (markdown, _cells) = generate_markdown_and_cells("Test", &range, 100);
+        let markdown = generate_markdown_from_range_optimized("Test", &range, 100);
 
         let lines: Vec<&str> = markdown.lines().collect();
         assert!(lines[0].contains("## Test"));