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

data/vendor/kreuzberg-ffi/src/mime.rs

@@ -1,329 +0,0 @@
-//! MIME type detection and validation functions.
-//!
-//! This module provides FFI functions for:
-//! - Detecting MIME types from file paths, bytes, or content
-//! - Validating MIME types against supported formats
-//! - Getting file extensions for MIME types
-
-use crate::ffi_panic_guard;
-use crate::helpers::{clear_last_error, set_last_error, string_to_c_string};
-use std::ffi::CStr;
-use std::os::raw::c_char;
-use std::ptr;
-
-/// Detect MIME type from a file path.
-///
-/// # Safety
-///
-/// - `file_path` must be a valid null-terminated C string
-/// - The returned string must be freed with `kreuzberg_free_string`
-/// - Returns NULL on error (check `kreuzberg_last_error`)
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_detect_mime_type(file_path: *const c_char, check_exists: bool) -> *mut c_char {
-    ffi_panic_guard!("kreuzberg_detect_mime_type", {
-        clear_last_error();
-
-        if file_path.is_null() {
-            set_last_error("file_path cannot be NULL".to_string());
-            return ptr::null_mut();
-        }
-
-        let path_str = match unsafe { CStr::from_ptr(file_path) }.to_str() {
-            Ok(s) => s,
-            Err(e) => {
-                set_last_error(format!("Invalid UTF-8 in file path: {}", e));
-                return ptr::null_mut();
-            }
-        };
-
-        match kreuzberg::core::mime::detect_mime_type(path_str, check_exists) {
-            Ok(mime) => match string_to_c_string(mime) {
-                Ok(ptr) => ptr,
-                Err(e) => {
-                    set_last_error(e);
-                    ptr::null_mut()
-                }
-            },
-            Err(e) => {
-                set_last_error(e.to_string());
-                ptr::null_mut()
-            }
-        }
-    })
-}
-
-/// Validate that a MIME type is supported by Kreuzberg.
-///
-/// # Safety
-///
-/// - `mime_type` must be a valid null-terminated C string
-/// - The returned string must be freed with `kreuzberg_free_string`
-/// - Returns NULL on error (check `kreuzberg_last_error`)
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_validate_mime_type(mime_type: *const c_char) -> *mut c_char {
-    ffi_panic_guard!("kreuzberg_validate_mime_type", {
-        clear_last_error();
-
-        if mime_type.is_null() {
-            set_last_error("mime_type cannot be NULL".to_string());
-            return ptr::null_mut();
-        }
-
-        let mime_type_str = match unsafe { CStr::from_ptr(mime_type) }.to_str() {
-            Ok(s) => s,
-            Err(e) => {
-                set_last_error(format!("Invalid UTF-8 in mime_type: {}", e));
-                return ptr::null_mut();
-            }
-        };
-
-        match kreuzberg::validate_mime_type(mime_type_str) {
-            Ok(validated) => match string_to_c_string(validated) {
-                Ok(ptr) => ptr,
-                Err(e) => {
-                    set_last_error(e);
-                    ptr::null_mut()
-                }
-            },
-            Err(e) => {
-                set_last_error(e.to_string());
-                ptr::null_mut()
-            }
-        }
-    })
-}
-
-/// Detect MIME type from raw bytes.
-///
-/// # Safety
-///
-/// - `bytes` must point to a valid buffer of at least `len` bytes
-/// - The returned string must be freed with `kreuzberg_free_string`
-/// - Returns NULL on error (check `kreuzberg_last_error`)
-///
-/// # Example (C)
-///
-/// ```c
-/// uint8_t data[512];
-/// // ... read data ...
-/// char* mime = kreuzberg_detect_mime_type_from_bytes(data, 512);
-/// if (mime != NULL) {
-///     printf("Detected MIME type: %s\n", mime);
-///     kreuzberg_free_string(mime);
-/// }
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_detect_mime_type_from_bytes(bytes: *const u8, len: usize) -> *mut c_char {
-    ffi_panic_guard!("kreuzberg_detect_mime_type_from_bytes", {
-        clear_last_error();
-
-        if bytes.is_null() {
-            set_last_error("bytes cannot be NULL".to_string());
-            return ptr::null_mut();
-        }
-
-        let slice = unsafe { std::slice::from_raw_parts(bytes, len) };
-
-        match kreuzberg::core::mime::detect_mime_type_from_bytes(slice) {
-            Ok(mime) => match string_to_c_string(mime) {
-                Ok(ptr) => ptr,
-                Err(e) => {
-                    set_last_error(e);
-                    ptr::null_mut()
-                }
-            },
-            Err(e) => {
-                set_last_error(e.to_string());
-                ptr::null_mut()
-            }
-        }
-    })
-}
-
-/// Detect MIME type from file path (checks extension and reads file content).
-///
-/// # Safety
-///
-/// - `file_path` must be a valid null-terminated C string
-/// - The returned string must be freed with `kreuzberg_free_string`
-/// - Returns NULL on error (check `kreuzberg_last_error`)
-///
-/// # Example (C)
-///
-/// ```c
-/// char* mime = kreuzberg_detect_mime_type_from_path("document.pdf");
-/// if (mime == NULL) {
-///     const char* error = kreuzberg_last_error();
-///     printf("Failed to detect MIME type: %s\n", error);
-/// } else {
-///     printf("MIME type: %s\n", mime);
-///     kreuzberg_free_string(mime);
-/// }
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_detect_mime_type_from_path(file_path: *const c_char) -> *mut c_char {
-    ffi_panic_guard!("kreuzberg_detect_mime_type_from_path", {
-        clear_last_error();
-
-        if file_path.is_null() {
-            set_last_error("file_path cannot be NULL".to_string());
-            return ptr::null_mut();
-        }
-
-        let path_str = match unsafe { CStr::from_ptr(file_path) }.to_str() {
-            Ok(s) => s,
-            Err(e) => {
-                set_last_error(format!("Invalid UTF-8 in file path: {}", e));
-                return ptr::null_mut();
-            }
-        };
-
-        match kreuzberg::core::mime::detect_mime_type(path_str, true) {
-            Ok(mime) => match string_to_c_string(mime) {
-                Ok(ptr) => ptr,
-                Err(e) => {
-                    set_last_error(e);
-                    ptr::null_mut()
-                }
-            },
-            Err(e) => {
-                set_last_error(e.to_string());
-                ptr::null_mut()
-            }
-        }
-    })
-}
-
-/// Get file extensions for a MIME type.
-///
-/// Returns a JSON array of file extensions (e.g., ["pdf"] for "application/pdf").
-///
-/// # Safety
-///
-/// - `mime_type` must be a valid null-terminated C string
-/// - The returned string must be freed with `kreuzberg_free_string`
-/// - Returns NULL on error (check `kreuzberg_last_error`)
-///
-/// # Example (C)
-///
-/// ```c
-/// char* extensions = kreuzberg_get_extensions_for_mime("application/pdf");
-/// if (extensions != NULL) {
-///     printf("Extensions: %s\n", extensions);
-///     kreuzberg_free_string(extensions);
-/// }
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_get_extensions_for_mime(mime_type: *const c_char) -> *mut c_char {
-    ffi_panic_guard!("kreuzberg_get_extensions_for_mime", {
-        clear_last_error();
-
-        if mime_type.is_null() {
-            set_last_error("mime_type cannot be NULL".to_string());
-            return ptr::null_mut();
-        }
-
-        let mime_str = match unsafe { CStr::from_ptr(mime_type) }.to_str() {
-            Ok(s) => s,
-            Err(e) => {
-                set_last_error(format!("Invalid UTF-8 in MIME type: {}", e));
-                return ptr::null_mut();
-            }
-        };
-
-        match kreuzberg::core::mime::get_extensions_for_mime(mime_str) {
-            Ok(extensions) => match serde_json::to_string(&extensions) {
-                Ok(json) => match string_to_c_string(json) {
-                    Ok(ptr) => ptr,
-                    Err(e) => {
-                        set_last_error(e);
-                        ptr::null_mut()
-                    }
-                },
-                Err(e) => {
-                    set_last_error(format!("Failed to serialize extensions: {}", e));
-                    ptr::null_mut()
-                }
-            },
-            Err(e) => {
-                set_last_error(e.to_string());
-                ptr::null_mut()
-            }
-        }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::ffi::CString;
-
-    #[test]
-    fn test_detect_mime_type_null_path() {
-        let result = unsafe { kreuzberg_detect_mime_type(ptr::null(), false) };
-        assert!(result.is_null());
-    }
-
-    #[test]
-    fn test_validate_mime_type_null() {
-        let result = unsafe { kreuzberg_validate_mime_type(ptr::null()) };
-        assert!(result.is_null());
-    }
-
-    #[test]
-    fn test_detect_mime_type_from_bytes_null() {
-        let result = unsafe { kreuzberg_detect_mime_type_from_bytes(ptr::null(), 0) };
-        assert!(result.is_null());
-    }
-
-    #[test]
-    fn test_detect_mime_type_from_path_null() {
-        let result = unsafe { kreuzberg_detect_mime_type_from_path(ptr::null()) };
-        assert!(result.is_null());
-    }
-
-    #[test]
-    fn test_get_extensions_for_mime_null() {
-        let result = unsafe { kreuzberg_get_extensions_for_mime(ptr::null()) };
-        assert!(result.is_null());
-    }
-
-    #[test]
-    fn test_validate_mime_type_valid() {
-        let mime = CString::new("application/pdf").unwrap();
-        let result = unsafe { kreuzberg_validate_mime_type(mime.as_ptr()) };
-        assert!(!result.is_null());
-        unsafe {
-            crate::kreuzberg_free_string(result);
-        }
-    }
-
-    #[test]
-    fn test_detect_mime_type_from_bytes_pdf() {
-        // PDF magic bytes: %PDF-
-        let pdf_bytes = b"%PDF-1.4\n";
-        let result = unsafe { kreuzberg_detect_mime_type_from_bytes(pdf_bytes.as_ptr(), pdf_bytes.len()) };
-        assert!(!result.is_null());
-
-        let mime_str = unsafe { CStr::from_ptr(result).to_str().unwrap() };
-        assert_eq!(mime_str, "application/pdf");
-
-        unsafe {
-            crate::kreuzberg_free_string(result);
-        }
-    }
-
-    #[test]
-    fn test_get_extensions_for_mime_pdf() {
-        let mime = CString::new("application/pdf").unwrap();
-        let result = unsafe { kreuzberg_get_extensions_for_mime(mime.as_ptr()) };
-        assert!(!result.is_null());
-
-        let extensions_str = unsafe { CStr::from_ptr(result).to_str().unwrap() };
-        assert!(extensions_str.contains("pdf"));
-
-        unsafe {
-            crate::kreuzberg_free_string(result);
-        }
-    }
-}

data/vendor/kreuzberg-ffi/src/panic_shield.rs

@@ -1,265 +0,0 @@
-use kreuzberg::panic_context::PanicContext;
-use std::cell::RefCell;
-
-/// Structured error that includes both the error message and optional panic context.
-#[derive(Debug, Clone)]
-pub struct StructuredError {
-    /// The error message
-    pub message: String,
-    /// Optional panic context if this error originated from a panic
-    pub panic_context: Option<PanicContext>,
-    /// Error code for programmatic error handling
-    pub code: ErrorCode,
-}
-
-/// Error codes for different types of errors.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(i32)]
-pub enum ErrorCode {
-    /// No error
-    Success = 0,
-    /// Generic error
-    GenericError = 1,
-    /// Panic was caught
-    Panic = 2,
-    /// Invalid argument
-    InvalidArgument = 3,
-    /// IO error
-    IoError = 4,
-    /// Parsing error
-    ParsingError = 5,
-    /// OCR error
-    OcrError = 6,
-    /// Missing dependency
-    MissingDependency = 7,
-}
-
-impl StructuredError {
-    /// Creates a new StructuredError from a panic context.
-    pub fn from_panic(context: PanicContext) -> Self {
-        Self {
-            message: context.format(),
-            panic_context: Some(context),
-            code: ErrorCode::Panic,
-        }
-    }
-
-    /// Creates a new StructuredError from a regular error message.
-    pub fn from_message(message: String, code: ErrorCode) -> Self {
-        Self {
-            message,
-            panic_context: None,
-            code,
-        }
-    }
-
-    /// Returns the full error message including panic context if available.
-    pub fn full_message(&self) -> String {
-        if let Some(ref ctx) = self.panic_context {
-            format!("{} (at {}:{}:{})", self.message, ctx.file, ctx.line, ctx.function)
-        } else {
-            self.message.clone()
-        }
-    }
-}
-
-thread_local! {
-    static LAST_STRUCTURED_ERROR: RefCell<Option<StructuredError>> = const { RefCell::new(None) };
-}
-
-/// Sets the last structured error.
-pub fn set_structured_error(error: StructuredError) {
-    LAST_STRUCTURED_ERROR.with(|last| *last.borrow_mut() = Some(error));
-}
-
-/// Gets the last structured error message (for compatibility with existing code).
-pub fn get_last_error_message() -> Option<String> {
-    LAST_STRUCTURED_ERROR.with(|last| last.borrow().as_ref().map(|e| e.full_message()))
-}
-
-/// Gets the last error code.
-pub fn get_last_error_code() -> ErrorCode {
-    LAST_STRUCTURED_ERROR.with(|last| last.borrow().as_ref().map(|e| e.code).unwrap_or(ErrorCode::Success))
-}
-
-/// Gets the last panic context if the last error was a panic.
-pub fn get_last_panic_context() -> Option<PanicContext> {
-    LAST_STRUCTURED_ERROR.with(|last| last.borrow().as_ref().and_then(|e| e.panic_context.clone()))
-}
-
-/// Clears the last structured error.
-pub fn clear_structured_error() {
-    LAST_STRUCTURED_ERROR.with(|last| *last.borrow_mut() = None);
-}
-
-/// Macro to wrap FFI functions with panic catching.
-///
-/// This macro catches panics at FFI boundaries and converts them to structured errors.
-/// It captures file, line, and function information for better error reporting.
-///
-/// # Usage
-///
-/// ```rust,ignore
-/// #[no_mangle]
-/// pub extern "C" fn my_ffi_function(arg: *const c_char) -> *mut ExtractionResult {
-///     ffi_panic_guard!("my_ffi_function", {
-///         // Your FFI function body here
-///         // Return the result normally
-///     })
-/// }
-/// ```
-///
-/// For bool-returning functions:
-///
-/// ```rust,ignore
-/// #[no_mangle]
-/// pub extern "C" fn my_bool_function(arg: *const c_char) -> bool {
-///     ffi_panic_guard_bool!("my_bool_function", {
-///         // Your FFI function body here
-///         // Return true or false normally
-///     })
-/// }
-/// ```
-///
-/// The macro will:
-/// - Catch any panics that occur in the wrapped code
-/// - Create a PanicContext with file/line/function information
-/// - Store the structured error in thread-local storage
-/// - Return a null pointer (for pointer-returning functions) or false (for bool-returning functions) to indicate failure
-#[macro_export]
-macro_rules! ffi_panic_guard {
-    ($function_name:expr, $body:expr) => {{
-        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
-            Ok(result) => result,
-            Err(panic_info) => {
-                let context =
-                    kreuzberg::panic_context::PanicContext::new(file!(), line!(), $function_name, panic_info.as_ref());
-                $crate::panic_shield::set_structured_error($crate::panic_shield::StructuredError::from_panic(context));
-                std::ptr::null_mut()
-            }
-        }
-    }};
-}
-
-/// Macro to wrap FFI functions that return bool with panic catching.
-///
-/// This variant of ffi_panic_guard returns false on panic (suitable for bool-returning functions).
-#[macro_export]
-macro_rules! ffi_panic_guard_bool {
-    ($function_name:expr, $body:expr) => {{
-        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
-            Ok(result) => result,
-            Err(panic_info) => {
-                let context =
-                    kreuzberg::panic_context::PanicContext::new(file!(), line!(), $function_name, panic_info.as_ref());
-                $crate::panic_shield::set_structured_error($crate::panic_shield::StructuredError::from_panic(context));
-                false
-            }
-        }
-    }};
-}
-
-/// Macro to wrap FFI functions that return i32 with panic catching.
-///
-/// This variant of ffi_panic_guard returns -1 on panic (suitable for i32-returning functions).
-#[macro_export]
-macro_rules! ffi_panic_guard_i32 {
-    ($function_name:expr, $body:expr) => {{
-        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $body)) {
-            Ok(result) => result,
-            Err(panic_info) => {
-                let context =
-                    kreuzberg::panic_context::PanicContext::new(file!(), line!(), $function_name, panic_info.as_ref());
-                $crate::panic_shield::set_structured_error($crate::panic_shield::StructuredError::from_panic(context));
-                -1
-            }
-        }
-    }};
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_structured_error_from_panic() {
-        let panic_msg = "test panic".to_string();
-        let ctx = PanicContext::new("test.rs", 42, "test_fn", &panic_msg);
-        let err = StructuredError::from_panic(ctx);
-
-        assert_eq!(err.code, ErrorCode::Panic);
-        assert!(err.panic_context.is_some());
-        assert!(err.message.contains("test panic"));
-    }
-
-    #[test]
-    fn test_structured_error_from_message() {
-        let err = StructuredError::from_message("test error".to_string(), ErrorCode::GenericError);
-
-        assert_eq!(err.code, ErrorCode::GenericError);
-        assert!(err.panic_context.is_none());
-        assert_eq!(err.message, "test error");
-    }
-
-    #[test]
-    fn test_error_storage() {
-        clear_structured_error();
-        assert!(get_last_error_message().is_none());
-
-        let err = StructuredError::from_message("test".to_string(), ErrorCode::IoError);
-        set_structured_error(err);
-
-        assert_eq!(get_last_error_message(), Some("test".to_string()));
-        assert_eq!(get_last_error_code(), ErrorCode::IoError);
-
-        clear_structured_error();
-        assert!(get_last_error_message().is_none());
-    }
-
-    #[test]
-    fn test_panic_context_extraction() {
-        clear_structured_error();
-
-        let panic_msg = "panic message".to_string();
-        let ctx = PanicContext::new("file.rs", 10, "func", &panic_msg);
-        let err = StructuredError::from_panic(ctx);
-        set_structured_error(err);
-
-        let retrieved_ctx = get_last_panic_context();
-        assert!(retrieved_ctx.is_some());
-
-        let ctx = retrieved_ctx.unwrap();
-        assert_eq!(ctx.file, "file.rs");
-        assert_eq!(ctx.line, 10);
-        assert_eq!(ctx.function, "func");
-    }
-
-    #[test]
-    fn test_ffi_panic_guard_success() {
-        let result = crate::ffi_panic_guard!("test_success", { Box::into_raw(Box::new(42)) });
-        assert!(!result.is_null());
-        unsafe {
-            assert_eq!(*result, 42);
-            let _ = Box::from_raw(result);
-        }
-    }
-
-    #[test]
-    fn test_ffi_panic_guard_panic() {
-        clear_structured_error();
-
-        let result: *mut i32 = crate::ffi_panic_guard!("test_panic", {
-            panic!("intentional panic");
-            #[allow(unreachable_code)]
-            Box::into_raw(Box::new(42))
-        });
-
-        assert!(result.is_null());
-        assert!(get_last_error_message().is_some());
-        assert_eq!(get_last_error_code(), ErrorCode::Panic);
-
-        let msg = get_last_error_message().unwrap();
-        assert!(msg.contains("intentional panic"));
-        assert!(msg.contains("test_panic"));
-    }
-}