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

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

@@ -29,7 +29,7 @@
 //! use kreuzberg::extraction::pptx::extract_pptx_from_path;
 //!
 //! # fn example() -> kreuzberg::Result<()> {
-//! let result = extract_pptx_from_path("presentation.pptx", true, None)?;
+//! let result = extract_pptx_from_path("presentation.pptx", true)?;
 //!
 //! println!("Slide count: {}", result.slide_count);
 //! println!("Image count: {}", result.image_count);
@@ -38,7 +38,6 @@
 //! # }
 //! ```
 use crate::error::{KreuzbergError, Result};
-use crate::text::utf8_validation;
 use crate::types::{ExtractedImage, PptxExtractionResult, PptxMetadata};
 use std::collections::HashMap;
 use std::fs::File;
@@ -182,68 +181,18 @@ impl Default for ParserConfig {
 
 struct ContentBuilder {
     content: String,
-    boundaries: Vec<crate::types::PageBoundary>,
-    page_contents: Vec<crate::types::PageContent>,
-    config: Option<crate::core::config::PageConfig>,
 }
 
 impl ContentBuilder {
     fn new() -> Self {
         Self {
             content: String::with_capacity(8192),
-            boundaries: Vec::new(),
-            page_contents: Vec::new(),
-            config: None,
         }
     }
 
-    fn with_page_config(capacity: usize, config: Option<crate::core::config::PageConfig>) -> Self {
+    fn with_capacity(capacity: usize) -> Self {
         Self {
             content: String::with_capacity(capacity),
-            boundaries: if config.is_some() {
-                Vec::new()
-            } else {
-                Vec::with_capacity(0)
-            },
-            page_contents: if config.is_some() {
-                Vec::new()
-            } else {
-                Vec::with_capacity(0)
-            },
-            config,
-        }
-    }
-
-    fn start_slide(&mut self, slide_number: u32) -> usize {
-        let byte_start = self.content.len();
-
-        if let Some(ref cfg) = self.config
-            && cfg.insert_page_markers
-        {
-            let marker = cfg.marker_format.replace("{page_num}", &slide_number.to_string());
-            self.content.push_str(&marker);
-        }
-
-        byte_start
-    }
-
-    fn end_slide(&mut self, slide_number: u32, byte_start: usize, slide_content: String) {
-        let byte_end = self.content.len();
-
-        if self.config.is_some() {
-            self.boundaries.push(crate::types::PageBoundary {
-                byte_start,
-                byte_end,
-                page_number: slide_number as usize,
-            });
-
-            self.page_contents.push(crate::types::PageContent {
-                page_number: slide_number as usize,
-                content: slide_content,
-                tables: Vec::new(),
-                images: Vec::new(),
-                hierarchy: None,
-            });
         }
     }
 
@@ -322,25 +271,8 @@ impl ContentBuilder {
         }
     }
 
-    fn build(
-        self,
-    ) -> (
-        String,
-        Option<Vec<crate::types::PageBoundary>>,
-        Option<Vec<crate::types::PageContent>>,
-    ) {
-        let content = self.content.trim().to_string();
-        let boundaries = if self.config.is_some() && !self.boundaries.is_empty() {
-            Some(self.boundaries)
-        } else {
-            None
-        };
-        let pages = if self.config.is_some() && !self.page_contents.is_empty() {
-            Some(self.page_contents)
-        } else {
-            None
-        };
-        (content, boundaries, pages)
+    fn build(self) -> String {
+        self.content.trim().to_string()
     }
 }
 
@@ -511,7 +443,7 @@ impl Slide {
             }
         }
 
-        builder.build().0
+        builder.build()
     }
 
     fn image_count(&self) -> usize {
@@ -593,8 +525,8 @@ enum ParsedContent {
 }
 
 fn parse_slide_xml(xml_data: &[u8]) -> Result<Vec<SlideElement>> {
-    let xml_str = utf8_validation::from_utf8(xml_data)
-        .map_err(|_| KreuzbergError::parsing("Invalid UTF-8 in slide XML".to_string()))?;
+    let xml_str =
+        std::str::from_utf8(xml_data).map_err(|_| KreuzbergError::parsing("Invalid UTF-8 in slide XML".to_string()))?;
 
     let doc =
         Document::parse(xml_str).map_err(|e| KreuzbergError::parsing(format!("Failed to parse slide XML: {}", e)))?;
@@ -900,7 +832,7 @@ fn extract_position(node: &Node) -> ElementPosition {
 }
 
 fn parse_slide_rels(rels_data: &[u8]) -> Result<Vec<ImageReference>> {
-    let xml_str = utf8_validation::from_utf8(rels_data)
+    let xml_str = std::str::from_utf8(rels_data)
         .map_err(|e| KreuzbergError::parsing(format!("Invalid UTF-8 in rels XML: {}", e)))?;
 
     let doc =
@@ -925,7 +857,7 @@ fn parse_slide_rels(rels_data: &[u8]) -> Result<Vec<ImageReference>> {
 }
 
 fn parse_presentation_rels(rels_data: &[u8]) -> Result<Vec<String>> {
-    let xml_str = utf8_validation::from_utf8(rels_data)
+    let xml_str = std::str::from_utf8(rels_data)
         .map_err(|e| KreuzbergError::parsing(format!("Invalid UTF-8 in presentation rels: {}", e)))?;
 
     let doc = Document::parse(xml_str)
@@ -1034,12 +966,24 @@ fn extract_metadata(archive: &mut ZipArchive<File>) -> PptxMetadata {
             }
         }
 
-        PptxMetadata { fonts: Vec::new() }
+        PptxMetadata {
+            title: metadata_map.get("title").cloned(),
+            author: metadata_map.get("author").cloned(),
+            description: metadata_map.get("description").cloned(),
+            summary: metadata_map.get("summary").cloned(),
+            fonts: Vec::new(),
+        }
     }
 
     #[cfg(not(feature = "office"))]
     {
-        PptxMetadata { fonts: Vec::new() }
+        PptxMetadata {
+            title: None,
+            author: None,
+            description: None,
+            summary: None,
+            fonts: Vec::new(),
+        }
     }
 }
 
@@ -1061,13 +1005,13 @@ fn extract_all_notes(container: &mut PptxContainer) -> Result<HashMap<u32, Strin
 }
 
 fn extract_notes_text(notes_xml: &[u8]) -> Result<String> {
-    let xml_str = utf8_validation::from_utf8(notes_xml)
+    let xml_str = std::str::from_utf8(notes_xml)
         .map_err(|e| KreuzbergError::parsing(format!("Invalid UTF-8 in notes XML: {}", e)))?;
 
     let doc =
         Document::parse(xml_str).map_err(|e| KreuzbergError::parsing(format!("Failed to parse notes XML: {}", e)))?;
 
-    let mut text_parts = Vec::with_capacity(16);
+    let mut text_parts = Vec::new();
     const DRAWINGML_NS: &str = "http://schemas.openxmlformats.org/drawingml/2006/main";
 
     for node in doc.descendants() {
@@ -1126,11 +1070,7 @@ fn detect_image_format(data: &[u8]) -> String {
     }
 }
 
-pub fn extract_pptx_from_path(
-    path: &str,
-    extract_images: bool,
-    page_config: Option<&crate::core::config::PageConfig>,
-) -> Result<PptxExtractionResult> {
+pub fn extract_pptx_from_path(path: &str, extract_images: bool) -> Result<PptxExtractionResult> {
     let config = ParserConfig {
         extract_images,
         ..Default::default()
@@ -1145,19 +1085,15 @@ pub fn extract_pptx_from_path(
     let mut iterator = SlideIterator::new(container);
     let slide_count = iterator.slide_count();
 
-    let estimated_capacity = slide_count.saturating_mul(1000).max(8192);
-    let mut content_builder = ContentBuilder::with_page_config(estimated_capacity, page_config.cloned());
+    let estimated_capacity = slide_count * 1024;
+    let mut content_builder = ContentBuilder::with_capacity(estimated_capacity);
 
     let mut total_image_count = 0;
     let mut total_table_count = 0;
     let mut extracted_images = Vec::new();
 
     while let Some(slide) = iterator.next_slide()? {
-        let byte_start = if page_config.is_some() {
-            content_builder.start_slide(slide.slide_number)
-        } else {
-            0
-        };
+        content_builder.add_slide_header(slide.slide_number);
 
         let slide_content = slide.to_markdown(&config);
         content_builder.add_text(&slide_content);
@@ -1166,10 +1102,6 @@ pub fn extract_pptx_from_path(
             content_builder.add_notes(slide_notes);
         }
 
-        if page_config.is_some() {
-            content_builder.end_slide(slide.slide_number, byte_start, slide_content.clone());
-        }
-
         if config.extract_images
             && let Ok(image_data) = iterator.get_slide_images(&slide)
         {
@@ -1197,43 +1129,17 @@ pub fn extract_pptx_from_path(
         total_table_count += slide.table_count();
     }
 
-    let (content, boundaries, page_contents) = content_builder.build();
-
-    let page_structure = boundaries.as_ref().map(|bounds| crate::types::PageStructure {
-        total_count: slide_count,
-        unit_type: crate::types::PageUnitType::Slide,
-        boundaries: Some(bounds.clone()),
-        pages: page_contents.as_ref().map(|pcs| {
-            pcs.iter()
-                .map(|pc| crate::types::PageInfo {
-                    number: pc.page_number,
-                    title: None,
-                    dimensions: None,
-                    image_count: None,
-                    table_count: None,
-                    hidden: None,
-                })
-                .collect()
-        }),
-    });
-
     Ok(PptxExtractionResult {
-        content,
+        content: content_builder.build(),
         metadata,
         slide_count,
         image_count: total_image_count,
         table_count: total_table_count,
         images: extracted_images,
-        page_structure,
-        page_contents,
     })
 }
 
-pub fn extract_pptx_from_bytes(
-    data: &[u8],
-    extract_images: bool,
-    page_config: Option<&crate::core::config::PageConfig>,
-) -> Result<PptxExtractionResult> {
+pub fn extract_pptx_from_bytes(data: &[u8], extract_images: bool) -> Result<PptxExtractionResult> {
     use std::sync::atomic::{AtomicU64, Ordering};
     static COUNTER: AtomicU64 = AtomicU64::new(0);
     let unique_id = COUNTER.fetch_add(1, Ordering::SeqCst);
@@ -1242,17 +1148,9 @@ pub fn extract_pptx_from_bytes(
     // IO errors must bubble up - temp file write issues need user reports ~keep
     std::fs::write(&temp_path, data)?;
 
-    let result = extract_pptx_from_path(
-        temp_path.to_str().ok_or_else(|| {
-            crate::KreuzbergError::validation("Invalid temp path - contains invalid UTF-8".to_string())
-        })?,
-        extract_images,
-        page_config,
-    );
+    let result = extract_pptx_from_path(temp_path.to_str().unwrap(), extract_images);
 
-    if let Err(e) = std::fs::remove_file(&temp_path) {
-        tracing::warn!("Failed to remove temp PPTX file: {}", e);
-    }
+    let _ = std::fs::remove_file(&temp_path);
 
     result
 }
@@ -1352,7 +1250,7 @@ mod tests {
     #[test]
     fn test_extract_pptx_from_bytes_single_slide() {
         let pptx_bytes = create_test_pptx_bytes(vec!["Hello World"]);
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.slide_count, 1);
         assert!(
@@ -1367,7 +1265,7 @@ mod tests {
     #[test]
     fn test_extract_pptx_from_bytes_multiple_slides() {
         let pptx_bytes = create_test_pptx_bytes(vec!["Slide 1", "Slide 2", "Slide 3"]);
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.slide_count, 3);
         assert!(result.content.contains("Slide 1"));
@@ -1378,15 +1276,18 @@ mod tests {
     #[test]
     fn test_extract_pptx_metadata() {
         let pptx_bytes = create_test_pptx_bytes(vec!["Content"]);
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
-        assert!(result.metadata.fonts.is_empty() || !result.metadata.fonts.is_empty());
+        assert_eq!(result.metadata.title, Some("Test Presentation".to_string()));
+        assert_eq!(result.metadata.author, Some("Test Author".to_string()));
+        assert_eq!(result.metadata.description, Some("Test Description".to_string()));
+        assert_eq!(result.metadata.summary, Some("Test Subject".to_string()));
     }
 
     #[test]
     fn test_extract_pptx_empty_slides() {
         let pptx_bytes = create_test_pptx_bytes(vec!["", "", ""]);
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.slide_count, 3);
     }
@@ -1394,7 +1295,7 @@ mod tests {
     #[test]
     fn test_extract_pptx_from_bytes_invalid_data() {
         let invalid_bytes = b"not a valid pptx file";
-        let result = extract_pptx_from_bytes(invalid_bytes, false, None);
+        let result = extract_pptx_from_bytes(invalid_bytes, false);
 
         assert!(result.is_err());
         if let Err(KreuzbergError::Parsing { message: msg, .. }) = result {
@@ -1407,7 +1308,7 @@ mod tests {
     #[test]
     fn test_extract_pptx_from_bytes_empty_data() {
         let empty_bytes: &[u8] = &[];
-        let result = extract_pptx_from_bytes(empty_bytes, false, None);
+        let result = extract_pptx_from_bytes(empty_bytes, false);
 
         assert!(result.is_err());
     }
@@ -1507,8 +1408,7 @@ mod tests {
         builder.add_text("Hello");
         builder.add_text(" ");
         builder.add_text("World");
-        let (content, _, _) = builder.build();
-        assert_eq!(content, "HelloWorld");
+        assert_eq!(builder.build(), "HelloWorld");
     }
 
     #[test]
@@ -1516,32 +1416,28 @@ mod tests {
         let mut builder = ContentBuilder::new();
         builder.add_text("   ");
         builder.add_text("");
-        let (content, _, _) = builder.build();
-        assert_eq!(content, "");
+        assert_eq!(builder.build(), "");
     }
 
     #[test]
     fn test_content_builder_add_title() {
         let mut builder = ContentBuilder::new();
         builder.add_title("Title");
-        let (content, _, _) = builder.build();
-        assert_eq!(content, "# Title");
+        assert_eq!(builder.build(), "# Title");
     }
 
     #[test]
     fn test_content_builder_add_title_with_whitespace() {
         let mut builder = ContentBuilder::new();
         builder.add_title("  Title  ");
-        let (content, _, _) = builder.build();
-        assert_eq!(content, "# Title");
+        assert_eq!(builder.build(), "# Title");
     }
 
     #[test]
     fn test_content_builder_add_table_empty() {
         let mut builder = ContentBuilder::new();
         builder.add_table(&[]);
-        let (content, _, _) = builder.build();
-        assert_eq!(content, "");
+        assert_eq!(builder.build(), "");
     }
 
     #[test]
@@ -1550,9 +1446,9 @@ mod tests {
         let rows = vec![vec!["Header1".to_string(), "Header2".to_string()]];
         builder.add_table(&rows);
         let result = builder.build();
-        assert!(result.0.contains("<table>"));
-        assert!(result.0.contains("<th>Header1</th>"));
-        assert!(result.0.contains("<th>Header2</th>"));
+        assert!(result.contains("<table>"));
+        assert!(result.contains("<th>Header1</th>"));
+        assert!(result.contains("<th>Header2</th>"));
     }
 
     #[test]
@@ -1564,8 +1460,8 @@ mod tests {
         ];
         builder.add_table(&rows);
         let result = builder.build();
-        assert!(result.0.contains("<th>H1</th>"));
-        assert!(result.0.contains("<td>D1</td>"));
+        assert!(result.contains("<th>H1</th>"));
+        assert!(result.contains("<td>D1</td>"));
     }
 
     #[test]
@@ -1574,8 +1470,8 @@ mod tests {
         let rows = vec![vec!["<tag>".to_string(), "a & b".to_string()]];
         builder.add_table(&rows);
         let result = builder.build();
-        assert!(result.0.contains("&lt;tag&gt;"));
-        assert!(result.0.contains("a &amp; b"));
+        assert!(result.contains("&lt;tag&gt;"));
+        assert!(result.contains("a &amp; b"));
     }
 
     #[test]
@@ -1584,8 +1480,8 @@ mod tests {
         builder.add_list_item(1, false, "Item 1");
         builder.add_list_item(1, false, "Item 2");
         let result = builder.build();
-        assert!(result.0.contains("- Item 1"));
-        assert!(result.0.contains("- Item 2"));
+        assert!(result.contains("- Item 1"));
+        assert!(result.contains("- Item 2"));
     }
 
     #[test]
@@ -1594,8 +1490,8 @@ mod tests {
         builder.add_list_item(1, true, "First");
         builder.add_list_item(1, true, "Second");
         let result = builder.build();
-        assert!(result.0.contains("1. First"));
-        assert!(result.0.contains("1. Second"));
+        assert!(result.contains("1. First"));
+        assert!(result.contains("1. Second"));
     }
 
     #[test]
@@ -1605,9 +1501,9 @@ mod tests {
         builder.add_list_item(2, false, "Level 2");
         builder.add_list_item(3, false, "Level 3");
         let result = builder.build();
-        assert!(result.0.contains("- Level 1"));
-        assert!(result.0.contains("  - Level 2"));
-        assert!(result.0.contains("    - Level 3"));
+        assert!(result.contains("- Level 1"));
+        assert!(result.contains("  - Level 2"));
+        assert!(result.contains("    - Level 3"));
     }
 
     #[test]
@@ -1615,7 +1511,7 @@ mod tests {
         let mut builder = ContentBuilder::new();
         builder.add_image("img123", 5);
         let result = builder.build();
-        assert!(result.0.contains("![img123](slide_5_image_img123.jpg)"));
+        assert!(result.contains("![img123](slide_5_image_img123.jpg)"));
     }
 
     #[test]
@@ -1623,16 +1519,15 @@ mod tests {
         let mut builder = ContentBuilder::new();
         builder.add_notes("This is a note");
         let result = builder.build();
-        assert!(result.0.contains("### Notes:"));
-        assert!(result.0.contains("This is a note"));
+        assert!(result.contains("### Notes:"));
+        assert!(result.contains("This is a note"));
     }
 
     #[test]
     fn test_content_builder_add_notes_empty() {
         let mut builder = ContentBuilder::new();
         builder.add_notes("   ");
-        let (content, _, _) = builder.build();
-        assert_eq!(content, "");
+        assert_eq!(builder.build(), "");
     }
 
     #[test]
@@ -1640,7 +1535,7 @@ mod tests {
         let mut builder = ContentBuilder::new();
         builder.add_slide_header(3);
         let result = builder.build();
-        assert!(result.0.contains("<!-- Slide number: 3 -->"));
+        assert!(result.contains("<!-- Slide number: 3 -->"));
     }
 
     #[test]
@@ -2308,7 +2203,7 @@ mod tests {
             vec!["Row 2 Col 1", "Row 2 Col 2", "Row 2 Col 3"],
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.table_count, 1, "Should detect one table");
         assert!(result.content.contains("<table>"), "Should contain table tag");
@@ -2340,7 +2235,7 @@ mod tests {
             vec!["A4", "B4", "C4", "D4"],
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.table_count, 1, "Should detect one table");
         assert!(result.content.contains("<tr>"), "Should contain table rows");
@@ -2355,7 +2250,7 @@ mod tests {
     fn test_table_counting_via_slide_metadata_succeeds() {
         let pptx_bytes = create_pptx_with_table(vec![vec!["Col1", "Col2"], vec!["Val1", "Val2"]]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.table_count, 1, "table_count should be 1");
     }
@@ -2367,7 +2262,7 @@ mod tests {
             vec!["Cell data 1", "Cell data 2"],
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(result.content.contains("<table>"), "Should contain table tag");
         assert!(
@@ -2383,7 +2278,7 @@ mod tests {
     #[test]
     fn test_table_extraction_empty_table_returns_one_count() {
         let pptx_bytes = create_pptx_with_table(vec![]);
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(result.table_count, 1, "Empty table structure should be detected");
         assert!(!result.content.contains("<td>"), "Empty table should have no cells");
@@ -2397,7 +2292,7 @@ mod tests {
             (1, true, "Third item"),
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("1. First item"),
@@ -2421,7 +2316,7 @@ mod tests {
             (1, false, "Bullet three"),
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(result.content.contains("- Bullet one"), "Should contain bullet point 1");
         assert!(result.content.contains("- Bullet two"), "Should contain bullet point 2");
@@ -2441,7 +2336,7 @@ mod tests {
             (1, false, "Back to Level 1"),
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("- Level 1 Item"),
@@ -2470,7 +2365,7 @@ mod tests {
             (1, true, "Ordered item 2"),
         ]);
 
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("1. Ordered item 1"),
@@ -2489,7 +2384,7 @@ mod tests {
     #[test]
     fn test_image_extraction_from_slide_xml_succeeds() {
         let pptx_bytes = create_pptx_with_images();
-        let result = extract_pptx_from_bytes(&pptx_bytes, true, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, true).unwrap();
 
         assert_eq!(result.image_count, 2, "Should detect 2 images");
         assert!(!result.images.is_empty(), "Should extract image data");
@@ -2498,7 +2393,7 @@ mod tests {
     #[test]
     fn test_image_data_loading_from_zip_archive_succeeds() {
         let pptx_bytes = create_pptx_with_images();
-        let result = extract_pptx_from_bytes(&pptx_bytes, true, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, true).unwrap();
 
         assert_eq!(result.images.len(), 2, "Should load 2 images");
 
@@ -2510,7 +2405,7 @@ mod tests {
     #[test]
     fn test_image_format_detection_succeeds() {
         let pptx_bytes = create_pptx_with_images();
-        let result = extract_pptx_from_bytes(&pptx_bytes, true, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, true).unwrap();
 
         assert_eq!(result.images.len(), 2, "Should have 2 images");
 
@@ -2523,7 +2418,7 @@ mod tests {
     #[test]
     fn test_image_counting_via_result_metadata_succeeds() {
         let pptx_bytes = create_pptx_with_images();
-        let result = extract_pptx_from_bytes(&pptx_bytes, true, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, true).unwrap();
 
         assert_eq!(result.image_count, 2, "image_count should match actual images");
         assert_eq!(result.images.len(), 2, "images vector should have 2 elements");
@@ -2532,7 +2427,7 @@ mod tests {
     #[test]
     fn test_image_extraction_disabled_returns_zero_images() {
         let pptx_bytes = create_pptx_with_images();
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert_eq!(
             result.image_count, 2,
@@ -2544,7 +2439,7 @@ mod tests {
     #[test]
     fn test_multiple_images_per_slide_extraction_succeeds() {
         let pptx_bytes = create_pptx_with_images();
-        let result = extract_pptx_from_bytes(&pptx_bytes, true, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, true).unwrap();
 
         assert_eq!(result.slide_count, 1, "Should have 1 slide");
         assert_eq!(result.image_count, 2, "Single slide should contain 2 images");
@@ -2557,7 +2452,7 @@ mod tests {
     #[test]
     fn test_formatting_bold_text_renders_as_markdown_bold() {
         let pptx_bytes = create_pptx_with_formatting();
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("**Bold text"),
@@ -2568,7 +2463,7 @@ mod tests {
     #[test]
     fn test_formatting_italic_text_renders_as_markdown_italic() {
         let pptx_bytes = create_pptx_with_formatting();
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("*Italic text"),
@@ -2579,7 +2474,7 @@ mod tests {
     #[test]
     fn test_formatting_underline_text_renders_as_html_underline() {
         let pptx_bytes = create_pptx_with_formatting();
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("<u>Underline text"),
@@ -2590,7 +2485,7 @@ mod tests {
     #[test]
     fn test_formatting_combined_bold_italic_renders_correctly() {
         let pptx_bytes = create_pptx_with_formatting();
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
         assert!(
             result.content.contains("***Bold italic text"),
@@ -2816,7 +2711,7 @@ mod tests {
             let _ = zip.finish().unwrap();
         }
 
-        let result = extract_pptx_from_bytes(&buffer, true, None).unwrap();
+        let result = extract_pptx_from_bytes(&buffer, true).unwrap();
 
         assert!(
             result.content.contains("**Title with Bold"),
@@ -2955,7 +2850,7 @@ mod tests {
             let _ = zip.finish().unwrap();
         }
 
-        let result = extract_pptx_from_bytes(&buffer, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&buffer, false).unwrap();
 
         let content = result.content;
         let top_left_pos = content.find("Top Left").unwrap();
@@ -3082,7 +2977,7 @@ mod tests {
             let _ = zip.finish().unwrap();
         }
 
-        let result = extract_pptx_from_bytes(&buffer, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&buffer, false).unwrap();
 
         assert!(result.content.contains("Slide Content"), "Should contain slide content");
         assert!(result.content.contains("### Notes:"), "Should contain notes header");
@@ -3095,8 +2990,11 @@ mod tests {
     #[test]
     fn test_integration_metadata_extraction_complete() {
         let pptx_bytes = create_test_pptx_bytes(vec!["Content"]);
-        let result = extract_pptx_from_bytes(&pptx_bytes, false, None).unwrap();
+        let result = extract_pptx_from_bytes(&pptx_bytes, false).unwrap();
 
-        let _ = &result.metadata.fonts;
+        assert_eq!(result.metadata.title, Some("Test Presentation".to_string()));
+        assert_eq!(result.metadata.author, Some("Test Author".to_string()));
+        assert_eq!(result.metadata.description, Some("Test Description".to_string()));
+        assert_eq!(result.metadata.summary, Some("Test Subject".to_string()));
     }
 }