kreuzberg 4.1.2 → 4.2.0

data/vendor/kreuzberg/tests/mime_detection.rs

@@ -48,12 +48,17 @@ async fn test_mime_detection_by_extension() {
         let temp_dir = TempDir::new().expect("Should create temp dir");
         let temp_path = temp_dir.path().join(filename);
 
-        std::fs::write(&temp_path, b"test content").unwrap();
+        std::fs::write(&temp_path, b"test content").expect("Operation failed");
 
         let detected = detect_mime_type(&temp_path, true);
 
         assert!(detected.is_ok(), "Should detect MIME type for {}", filename);
-        assert_eq!(detected.unwrap(), expected_mime, "MIME type mismatch for {}", filename);
+        assert_eq!(
+            detected.expect("Operation failed"),
+            expected_mime,
+            "MIME type mismatch for {}",
+            filename
+        );
     }
 }
 
@@ -76,11 +81,11 @@ async fn test_mime_detection_case_insensitive() {
         let temp_dir = TempDir::new().expect("Should create temp dir");
         let temp_path = temp_dir.path().join(filename);
 
-        std::fs::write(&temp_path, b"test").unwrap();
+        std::fs::write(&temp_path, b"test").expect("Operation failed");
 
         let detected = detect_mime_type(&temp_path, true);
         assert!(detected.is_ok(), "Should handle {} (case insensitive)", filename);
-        assert_eq!(detected.unwrap(), expected_mime);
+        assert_eq!(detected.expect("Operation failed"), expected_mime);
     }
 }
 
@@ -118,11 +123,15 @@ async fn test_mime_detection_by_content() {
 
     for test_case in test_cases {
         let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-        let temp_path = temp_file.path().parent().unwrap().join(test_case.filename);
+        let temp_path = temp_file
+            .path()
+            .parent()
+            .expect("Operation failed")
+            .join(test_case.filename);
 
-        temp_file.write_all(&test_case.content).unwrap();
-        temp_file.flush().unwrap();
-        std::fs::copy(temp_file.path(), &temp_path).unwrap();
+        temp_file.write_all(&test_case.content).expect("Operation failed");
+        temp_file.flush().expect("Operation failed");
+        std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
         let detected = detect_mime_type(&temp_path, true);
 
@@ -170,7 +179,7 @@ async fn test_mime_type_validation() {
     for mime_type in supported {
         let result = validate_mime_type(mime_type);
         assert!(result.is_ok(), "Should validate supported MIME type: {}", mime_type);
-        assert_eq!(result.unwrap(), mime_type);
+        assert_eq!(result.expect("Operation failed"), mime_type);
     }
 }
 
@@ -222,18 +231,24 @@ async fn test_unknown_mime_type() {
 #[tokio::test]
 async fn test_mime_mismatch_warning() {
     let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-    let temp_path = temp_file.path().parent().unwrap().join("document.pdf");
-
-    temp_file.write_all(&[0x50, 0x4B, 0x03, 0x04]).unwrap();
-    temp_file.flush().unwrap();
-    std::fs::copy(temp_file.path(), &temp_path).unwrap();
+    let temp_path = temp_file
+        .path()
+        .parent()
+        .expect("Operation failed")
+        .join("document.pdf");
+
+    temp_file
+        .write_all(&[0x50, 0x4B, 0x03, 0x04])
+        .expect("Operation failed");
+    temp_file.flush().expect("Operation failed");
+    std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
     let detected = detect_mime_type(&temp_path, true);
 
     assert!(detected.is_ok(), "Should detect MIME type even with mismatch");
 
     assert_eq!(
-        detected.unwrap(),
+        detected.expect("Operation failed"),
         "application/pdf",
         "Extension-based detection should take precedence"
     );
@@ -245,18 +260,22 @@ async fn test_mime_mismatch_warning() {
 #[tokio::test]
 async fn test_extension_content_mismatch() {
     let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-    let temp_path = temp_file.path().parent().unwrap().join("document.txt");
+    let temp_path = temp_file
+        .path()
+        .parent()
+        .expect("Operation failed")
+        .join("document.txt");
 
-    temp_file.write_all(b"%PDF-1.4\n").unwrap();
-    temp_file.flush().unwrap();
-    std::fs::copy(temp_file.path(), &temp_path).unwrap();
+    temp_file.write_all(b"%PDF-1.4\n").expect("Operation failed");
+    temp_file.flush().expect("Operation failed");
+    std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
     let detected = detect_mime_type(&temp_path, true);
 
     assert!(detected.is_ok(), "Should detect MIME type");
 
     assert_eq!(
-        detected.unwrap(),
+        detected.expect("Operation failed"),
         "text/plain",
         "Should use extension for MIME detection"
     );
@@ -268,11 +287,11 @@ async fn test_extension_content_mismatch() {
 #[tokio::test]
 async fn test_no_extension() {
     let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-    let temp_path = temp_file.path().parent().unwrap().join("testfile");
+    let temp_path = temp_file.path().parent().expect("Operation failed").join("testfile");
 
-    temp_file.write_all(b"test content").unwrap();
-    temp_file.flush().unwrap();
-    std::fs::copy(temp_file.path(), &temp_path).unwrap();
+    temp_file.write_all(b"test content").expect("Operation failed");
+    temp_file.flush().expect("Operation failed");
+    std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
     let detected = detect_mime_type(&temp_path, true);
 
@@ -322,23 +341,31 @@ async fn test_mime_detection_skip_existence_check() {
     let result = detect_mime_type(nonexistent_path, false);
 
     assert!(result.is_ok(), "Should succeed when skipping existence check");
-    assert_eq!(result.unwrap(), "application/pdf");
+    assert_eq!(result.expect("Operation failed"), "application/pdf");
 }
 
 /// Test multiple dots in filename.
 #[tokio::test]
 async fn test_filename_multiple_dots() {
     let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-    let temp_path = temp_file.path().parent().unwrap().join("my.backup.file.pdf");
+    let temp_path = temp_file
+        .path()
+        .parent()
+        .expect("Operation failed")
+        .join("my.backup.file.pdf");
 
-    temp_file.write_all(b"test").unwrap();
-    temp_file.flush().unwrap();
-    std::fs::copy(temp_file.path(), &temp_path).unwrap();
+    temp_file.write_all(b"test").expect("Operation failed");
+    temp_file.flush().expect("Operation failed");
+    std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
     let detected = detect_mime_type(&temp_path, true);
 
     assert!(detected.is_ok(), "Should handle multiple dots in filename");
-    assert_eq!(detected.unwrap(), "application/pdf", "Should use last extension");
+    assert_eq!(
+        detected.expect("Operation failed"),
+        "application/pdf",
+        "Should use last extension"
+    );
 
     let _ = std::fs::remove_file(&temp_path);
 }
@@ -347,16 +374,20 @@ async fn test_filename_multiple_dots() {
 #[tokio::test]
 async fn test_filename_special_characters() {
     let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-    let temp_path = temp_file.path().parent().unwrap().join("文档 (copy) [v2].pdf");
+    let temp_path = temp_file
+        .path()
+        .parent()
+        .expect("Operation failed")
+        .join("文档 (copy) [v2].pdf");
 
-    temp_file.write_all(b"test").unwrap();
-    temp_file.flush().unwrap();
-    std::fs::copy(temp_file.path(), &temp_path).unwrap();
+    temp_file.write_all(b"test").expect("Operation failed");
+    temp_file.flush().expect("Operation failed");
+    std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
     let detected = detect_mime_type(&temp_path, true);
 
     assert!(detected.is_ok(), "Should handle special characters in filename");
-    assert_eq!(detected.unwrap(), "application/pdf");
+    assert_eq!(detected.expect("Operation failed"), "application/pdf");
 
     let _ = std::fs::remove_file(&temp_path);
 }
@@ -382,11 +413,11 @@ async fn test_pandoc_formats_mime_detection() {
 
     for (filename, expected_mime) in pandoc_formats {
         let mut temp_file = NamedTempFile::new().expect("Should create temp file");
-        let temp_path = temp_file.path().parent().unwrap().join(filename);
+        let temp_path = temp_file.path().parent().expect("Operation failed").join(filename);
 
-        temp_file.write_all(b"test content").unwrap();
-        temp_file.flush().unwrap();
-        std::fs::copy(temp_file.path(), &temp_path).unwrap();
+        temp_file.write_all(b"test content").expect("Operation failed");
+        temp_file.flush().expect("Operation failed");
+        std::fs::copy(temp_file.path(), &temp_path).expect("Operation failed");
 
         let detected = detect_mime_type(&temp_path, true);
 
@@ -396,7 +427,7 @@ async fn test_pandoc_formats_mime_detection() {
             filename
         );
         assert_eq!(
-            detected.unwrap(),
+            detected.expect("Operation failed"),
             expected_mime,
             "MIME type mismatch for Pandoc format: {}",
             filename
@@ -424,6 +455,6 @@ async fn test_pandoc_mime_validation() {
     for mime_type in pandoc_mimes {
         let result = validate_mime_type(mime_type);
         assert!(result.is_ok(), "Pandoc MIME type should be supported: {}", mime_type);
-        assert_eq!(result.unwrap(), mime_type);
+        assert_eq!(result.expect("Operation failed"), mime_type);
     }
 }

data/vendor/kreuzberg/tests/ocr_errors.rs

@@ -492,8 +492,8 @@ fn test_ocr_cache_disabled_then_enabled() {
     }
     assert!(result2.is_ok(), "Second extraction should succeed");
 
-    assert_non_empty_content(&result1.unwrap());
-    assert_non_empty_content(&result2.unwrap());
+    assert_non_empty_content(&result1.expect("Operation failed"));
+    assert_non_empty_content(&result2.expect("Operation failed"));
 }
 
 #[test]
@@ -548,7 +548,10 @@ fn test_ocr_concurrent_same_file() {
         handles.push(handle);
     }
 
-    let successes: usize = handles.into_iter().map(|h| if h.join().unwrap() { 1 } else { 0 }).sum();
+    let successes: usize = handles
+        .into_iter()
+        .map(|h| if h.join().expect("Iterator failed") { 1 } else { 0 })
+        .sum();
 
     tracing::debug!("Concurrent processing: {}/5 threads succeeded", successes);
 
@@ -615,7 +618,10 @@ fn test_ocr_concurrent_different_files() {
         handles.push(handle);
     }
 
-    let successes: usize = handles.into_iter().map(|h| if h.join().unwrap() { 1 } else { 0 }).sum();
+    let successes: usize = handles
+        .into_iter()
+        .map(|h| if h.join().expect("Iterator failed") { 1 } else { 0 })
+        .sum();
 
     assert_eq!(
         successes, 2,

data/vendor/kreuzberg/tests/ocr_language_registry.rs

@@ -120,7 +120,7 @@ fn test_registry_singleton_behavior() {
 #[test]
 fn test_easyocr_special_languages() {
     let registry = LanguageRegistry::new();
-    let languages = registry.get_supported_languages("easyocr").unwrap();
+    let languages = registry.get_supported_languages("easyocr").expect("Operation failed");
 
     let special_langs = vec!["ch_sim", "ch_tra", "rs_cyrillic", "rs_latin"];
 

data/vendor/kreuzberg/tests/ocr_stress.rs

@@ -56,10 +56,10 @@ fn test_rayon_batch_stress_many_images() {
         success_count
     );
 
-    let first_content = results[0].result.as_ref().unwrap().content.clone();
+    let first_content = results[0].result.as_ref().expect("Operation failed").content.clone();
     for (i, result) in results.iter().enumerate().skip(1) {
         assert!(result.success, "Result {} should succeed", i);
-        let content = &result.result.as_ref().unwrap().content;
+        let content = &result.result.as_ref().expect("Operation failed").content;
         assert_eq!(
             content, &first_content,
             "Result {} content differs - possible race condition",
@@ -220,7 +220,7 @@ fn test_tesseract_api_thread_safety() {
                 thread_id,
                 result.err()
             );
-            result.unwrap()
+            result.expect("Operation failed")
         }));
     }
 

data/vendor/kreuzberg/tests/odt_extractor_tests.rs

@@ -26,9 +26,9 @@ mod helpers;
 fn get_test_file_path(filename: &str) -> PathBuf {
     let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
-        .unwrap()
+        .expect("Operation failed")
         .parent()
-        .unwrap();
+        .expect("Operation failed");
     workspace_root.join(format!("test_documents/odt/{}", filename))
 }
 
@@ -48,9 +48,9 @@ fn ensure_test_file_exists(path: &Path) -> bool {
 async fn test_odt_metadata_extraction() {
     let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
-        .unwrap()
+        .expect("Operation failed")
         .parent()
-        .unwrap();
+        .expect("Operation failed");
     let test_file = workspace_root.join("test_documents/metadata_test.odt");
 
     if !ensure_test_file_exists(&test_file) {
@@ -615,9 +615,9 @@ async fn test_odt_table_no_duplicate_content() {
 async fn test_odt_comprehensive_table_extraction() {
     let test_file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .parent()
-        .unwrap()
+        .expect("Operation failed")
         .parent()
-        .unwrap()
+        .expect("Operation failed")
         .join("test_documents/extraction_test.odt");
 
     if !test_file.exists() {

data/vendor/kreuzberg/tests/opml_extractor_tests.rs

@@ -22,9 +22,9 @@ mod helpers;
 fn get_test_opml_path(filename: &str) -> PathBuf {
     let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
-        .unwrap()
+        .expect("Operation failed")
         .parent()
-        .unwrap();
+        .expect("Operation failed");
     workspace_root.join(format!("test_documents/opml/{}", filename))
 }
 

data/vendor/kreuzberg/tests/orgmode_extractor_tests.rs

@@ -24,9 +24,9 @@ use std::path::PathBuf;
 fn get_test_orgmode_path(filename: &str) -> PathBuf {
     let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
-        .unwrap()
+        .expect("Operation failed")
         .parent()
-        .unwrap();
+        .expect("Operation failed");
     workspace_root.join(format!("test_documents/orgmode/{}", filename))
 }
 

data/vendor/kreuzberg/tests/page_markers.rs

@@ -202,7 +202,7 @@ fn test_marker_appears_before_content() {
     assert!(marker_pos.is_some(), "Marker should be present");
 
     // Marker should be very early in the content (within first 50 chars)
-    let pos = marker_pos.unwrap();
+    let pos = marker_pos.expect("Operation failed");
     assert!(
         pos < 50,
         "Marker for page 1 should appear at the start, but found at position {}",

data/vendor/kreuzberg/tests/pdf_hierarchy_detection.rs

@@ -64,7 +64,7 @@ async fn test_full_hierarchy_extraction() {
         "Pages should be extracted when extract_pages is enabled"
     );
 
-    let pages = result.pages.as_ref().unwrap();
+    let pages = result.pages.as_ref().expect("Operation failed");
     assert!(!pages.is_empty(), "At least one page should be extracted");
 
     // Check that the first page has hierarchy information
@@ -74,7 +74,7 @@ async fn test_full_hierarchy_extraction() {
         "First page should have hierarchy information when hierarchy extraction is enabled"
     );
 
-    let hierarchy = first_page.hierarchy.as_ref().unwrap();
+    let hierarchy = first_page.hierarchy.as_ref().expect("Operation failed");
 
     // Verify hierarchy structure
     assert!(hierarchy.block_count > 0, "Hierarchy should contain at least one block");
@@ -172,7 +172,7 @@ async fn test_hierarchy_disabled() {
     // Verify that pages were extracted
     assert!(result.pages.is_some(), "Pages should be extracted");
 
-    let pages = result.pages.as_ref().unwrap();
+    let pages = result.pages.as_ref().expect("Operation failed");
     assert!(!pages.is_empty(), "At least one page should be extracted");
 
     // Check that the first page does NOT have hierarchy information when disabled
@@ -227,7 +227,7 @@ async fn test_hierarchy_with_explicit_disabled() {
     // Verify that pages were extracted
     assert!(result.pages.is_some(), "Pages should be extracted");
 
-    let pages = result.pages.as_ref().unwrap();
+    let pages = result.pages.as_ref().expect("Operation failed");
     assert!(!pages.is_empty(), "At least one page should be extracted");
 
     // Check that the first page does NOT have hierarchy information when disabled
@@ -282,7 +282,7 @@ async fn test_hierarchy_different_k_clusters() {
 
         assert!(result.pages.is_some(), "Pages should be extracted");
 
-        let pages = result.pages.as_ref().unwrap();
+        let pages = result.pages.as_ref().expect("Operation failed");
         assert!(!pages.is_empty(), "At least one page should be extracted");
 
         let first_page = &pages[0];
@@ -292,7 +292,7 @@ async fn test_hierarchy_different_k_clusters() {
             k
         );
 
-        let hierarchy = first_page.hierarchy.as_ref().unwrap();
+        let hierarchy = first_page.hierarchy.as_ref().expect("Operation failed");
         eprintln!("K={}: {} hierarchy blocks extracted", k, hierarchy.block_count);
         assert!(hierarchy.block_count > 0, "Should have blocks with k={}", k);
     }

data/vendor/kreuzberg/tests/pdf_text_merging.rs

@@ -29,7 +29,7 @@ fn test_extract_chars_basic() {
     // Load PDF
     let pdfium = Pdfium;
     let document = pdfium
-        .load_pdf_from_file(pdf_path.to_str().unwrap(), None)
+        .load_pdf_from_file(pdf_path.to_str().expect("Operation failed"), None)
         .expect("Failed to load test PDF");
 
     // Get first page
@@ -62,7 +62,7 @@ fn test_extract_chars_preserves_order() {
     // Load PDF
     let pdfium = Pdfium;
     let document = pdfium
-        .load_pdf_from_file(pdf_path.to_str().unwrap(), None)
+        .load_pdf_from_file(pdf_path.to_str().expect("Operation failed"), None)
         .expect("Failed to load test PDF");
 
     // Get first page