kreuzberg 4.0.8 → 4.1.0

data/ext/kreuzberg_rb/native/src/error_handling.rs

@@ -0,0 +1,125 @@
+//! Error handling and conversion to Ruby exceptions
+//!
+//! Provides error conversion from Kreuzberg errors to Magnus Ruby exceptions,
+//! panic context retrieval, and error code utilities.
+
+use kreuzberg::KreuzbergError;
+use magnus::{Error, exception::ExceptionClass, Ruby};
+use std::ffi::CStr;
+
+pub use kreuzberg_ffi::{
+    kreuzberg_free_string, kreuzberg_last_error_code,
+    kreuzberg_last_panic_context,
+};
+
+/// Retrieve panic context from FFI if available
+pub fn get_panic_context() -> Option<String> {
+    unsafe {
+        let ctx_ptr = kreuzberg_last_panic_context();
+        if ctx_ptr.is_null() {
+            return None;
+        }
+
+        let c_str = CStr::from_ptr(ctx_ptr);
+        let context = c_str.to_string_lossy().to_string();
+        kreuzberg_free_string(ctx_ptr as *mut std::ffi::c_char);
+
+        if context.is_empty() { None } else { Some(context) }
+    }
+}
+
+/// Retrieve error code from FFI
+pub fn get_error_code() -> i32 {
+    unsafe { kreuzberg_last_error_code() }
+}
+
+/// Convert Kreuzberg errors to Ruby exceptions
+pub fn kreuzberg_error(err: KreuzbergError) -> Error {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+
+    let fetch_error_class = |name: &str| -> Option<ExceptionClass> {
+        ruby.eval::<ExceptionClass>(&format!("Kreuzberg::Errors::{}", name))
+            .ok()
+    };
+
+    match err {
+        KreuzbergError::Validation { message, .. } => {
+            if let Some(class) = fetch_error_class("ValidationError") {
+                Error::new(class, message)
+            } else {
+                Error::new(ruby.exception_arg_error(), message)
+            }
+        }
+        KreuzbergError::Parsing { message, .. } => {
+            if let Some(class) = fetch_error_class("ParsingError") {
+                Error::new(class, message)
+            } else {
+                Error::new(ruby.exception_runtime_error(), format!("ParsingError: {}", message))
+            }
+        }
+        KreuzbergError::Ocr { message, .. } => {
+            if let Some(class) = fetch_error_class("OCRError") {
+                Error::new(class, message)
+            } else {
+                Error::new(ruby.exception_runtime_error(), format!("OCRError: {}", message))
+            }
+        }
+        KreuzbergError::MissingDependency(message) => {
+            if let Some(class) = fetch_error_class("MissingDependencyError") {
+                Error::new(class, message)
+            } else {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("MissingDependencyError: {}", message),
+                )
+            }
+        }
+        KreuzbergError::Plugin { message, plugin_name } => {
+            if let Some(class) = fetch_error_class("PluginError") {
+                Error::new(class, format!("{}: {}", plugin_name, message))
+            } else {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Plugin error in '{}': {}", plugin_name, message),
+                )
+            }
+        }
+        KreuzbergError::Io(err) => {
+            if let Some(class) = fetch_error_class("IOError") {
+                Error::new(class, err.to_string())
+            } else {
+                Error::new(ruby.exception_runtime_error(), format!("IO error: {}", err))
+            }
+        }
+        KreuzbergError::UnsupportedFormat(message) => {
+            if let Some(class) = fetch_error_class("UnsupportedFormatError") {
+                Error::new(class, message)
+            } else {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("UnsupportedFormatError: {}", message),
+                )
+            }
+        }
+        other => Error::new(ruby.exception_runtime_error(), other.to_string()),
+    }
+}
+
+/// Create a generic runtime error
+pub fn runtime_error(message: impl Into<String>) -> Error {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+    Error::new(ruby.exception_runtime_error(), message.into())
+}
+
+/// Create a validation error (Kreuzberg::Errors::ValidationError)
+pub fn validation_error(message: impl Into<String>) -> Error {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+
+    // Try to get the ValidationError class from Ruby
+    if let Ok(class) = ruby.eval::<ExceptionClass>("Kreuzberg::Errors::ValidationError") {
+        Error::new(class, message.into())
+    } else {
+        // Fall back to ArgumentError if the class doesn't exist
+        Error::new(ruby.exception_arg_error(), message.into())
+    }
+}

data/ext/kreuzberg_rb/native/src/extraction.rs

@@ -0,0 +1,79 @@
+//! File extraction functions
+//!
+//! Handles extraction from files and byte arrays (synchronous and asynchronous).
+
+use crate::config::parse_extraction_config;
+use crate::error_handling::kreuzberg_error;
+use crate::result::extraction_result_to_ruby;
+
+use magnus::{Error, RHash, RString, Ruby, Value, scan_args::scan_args};
+
+/// Extract content from a file (synchronous)
+pub fn extract_file_sync(args: &[Value]) -> Result<RHash, Error> {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+    let args = scan_args::<(String,), (Option<String>,), (), (), RHash, ()>(args)?;
+    let (path,) = args.required;
+    let (mime_type,) = args.optional;
+    let opts = Some(args.keywords);
+
+    let config = parse_extraction_config(&ruby, opts)?;
+
+    let result = kreuzberg::extract_file_sync(&path, mime_type.as_deref(), &config).map_err(kreuzberg_error)?;
+
+    extraction_result_to_ruby(&ruby, result)
+}
+
+/// Extract content from bytes (synchronous)
+pub fn extract_bytes_sync(args: &[Value]) -> Result<RHash, Error> {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+    let args = scan_args::<(RString, String), (), (), (), RHash, ()>(args)?;
+    let (data, mime_type) = args.required;
+    let opts = Some(args.keywords);
+
+    let config = parse_extraction_config(&ruby, opts)?;
+
+    let bytes = unsafe { data.as_slice() };
+    let result = kreuzberg::extract_bytes_sync(bytes, &mime_type, &config).map_err(kreuzberg_error)?;
+
+    extraction_result_to_ruby(&ruby, result)
+}
+
+/// Extract content from a file (asynchronous)
+pub fn extract_file(args: &[Value]) -> Result<RHash, Error> {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+    let args = scan_args::<(String,), (Option<String>,), (), (), RHash, ()>(args)?;
+    let (path,) = args.required;
+    let (mime_type,) = args.optional;
+    let opts = Some(args.keywords);
+
+    let config = parse_extraction_config(&ruby, opts)?;
+
+    let runtime =
+        tokio::runtime::Runtime::new().map_err(|e| crate::error_handling::runtime_error(format!("Failed to create Tokio runtime: {}", e)))?;
+
+    let result = runtime
+        .block_on(async { kreuzberg::extract_file(&path, mime_type.as_deref(), &config).await })
+        .map_err(kreuzberg_error)?;
+
+    extraction_result_to_ruby(&ruby, result)
+}
+
+/// Extract content from bytes (asynchronous)
+pub fn extract_bytes(args: &[Value]) -> Result<RHash, Error> {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+    let args = scan_args::<(RString, String), (), (), (), RHash, ()>(args)?;
+    let (data, mime_type) = args.required;
+    let opts = Some(args.keywords);
+
+    let config = parse_extraction_config(&ruby, opts)?;
+
+    let runtime =
+        tokio::runtime::Runtime::new().map_err(|e| crate::error_handling::runtime_error(format!("Failed to create Tokio runtime: {}", e)))?;
+
+    let bytes = unsafe { data.as_slice() };
+    let result = runtime
+        .block_on(async { kreuzberg::extract_bytes(bytes, &mime_type, &config).await })
+        .map_err(kreuzberg_error)?;
+
+    extraction_result_to_ruby(&ruby, result)
+}

data/ext/kreuzberg_rb/native/src/gc_guarded_value.rs

@@ -0,0 +1,35 @@
+//! GC-guarded Ruby value wrapper for plugin registrations
+//!
+//! Keeps Ruby values alive across plugin registrations by informing the Ruby GC.
+
+use magnus::{Ruby, Value};
+
+/// Keeps Ruby values alive across plugin registrations by informing the GC.
+///
+/// This prevents Ruby objects (like Procs) from being garbage collected while
+/// they're being used as plugin callbacks.
+pub struct GcGuardedValue {
+    value: Value,
+}
+
+impl GcGuardedValue {
+    /// Create a new GC-guarded value
+    pub fn new(value: Value) -> Self {
+        let ruby = Ruby::get().expect("Ruby not initialized");
+        ruby.gc_register_address(&value);
+        Self { value }
+    }
+
+    /// Get the wrapped value
+    pub fn value(&self) -> Value {
+        self.value
+    }
+}
+
+impl Drop for GcGuardedValue {
+    fn drop(&mut self) {
+        if let Ok(ruby) = Ruby::get() {
+            ruby.gc_unregister_address(&self.value);
+        }
+    }
+}

data/ext/kreuzberg_rb/native/src/helpers.rs

@@ -0,0 +1,176 @@
+//! Helper utilities for Ruby value conversion and manipulation
+//!
+//! Provides utilities for converting between Ruby and JSON values,
+//! accessing keyword arguments, and managing cache directories.
+
+use magnus::{Error, RArray, RHash, Ruby, Symbol, Value, TryConvert, IntoValue};
+use magnus::value::ReprValue;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use crate::error_handling::runtime_error;
+
+/// Convert Ruby Symbol or String to Rust String
+pub fn symbol_to_string(value: Value) -> Result<String, Error> {
+    if let Some(symbol) = Symbol::from_value(value) {
+        Ok(symbol.name()?.to_string())
+    } else {
+        String::try_convert(value)
+    }
+}
+
+/// Get keyword argument from hash (supports both symbol and string keys)
+pub fn get_kw(ruby: &Ruby, hash: RHash, name: &str) -> Option<Value> {
+    hash.get(name).or_else(|| {
+        let sym = ruby.intern(name);
+        hash.get(sym)
+    })
+}
+
+/// Set a hash entry with a string key
+pub fn set_hash_entry(_ruby: &Ruby, hash: &RHash, key: &str, value: Value) -> Result<(), Error> {
+    hash.aset(key, value)?;
+    Ok(())
+}
+
+/// Convert serde_json Value to Ruby Value
+pub fn json_value_to_ruby(ruby: &Ruby, value: &serde_json::Value) -> Result<Value, Error> {
+    Ok(match value {
+        serde_json::Value::Null => ruby.qnil().as_value(),
+        serde_json::Value::Bool(b) => {
+            if *b {
+                ruby.qtrue().as_value()
+            } else {
+                ruby.qfalse().as_value()
+            }
+        }
+        serde_json::Value::Number(num) => {
+            if let Some(i) = num.as_i64() {
+                ruby.integer_from_i64(i).into_value_with(ruby)
+            } else if let Some(u) = num.as_u64() {
+                ruby.integer_from_u64(u).into_value_with(ruby)
+            } else if let Some(f) = num.as_f64() {
+                ruby.float_from_f64(f).into_value_with(ruby)
+            } else {
+                ruby.qnil().as_value()
+            }
+        }
+        serde_json::Value::String(s) => ruby.str_new(s).into_value_with(ruby),
+        serde_json::Value::Array(items) => {
+            let ary = ruby.ary_new();
+            for item in items {
+                ary.push(json_value_to_ruby(ruby, item)?)?;
+            }
+            ary.into_value_with(ruby)
+        }
+        serde_json::Value::Object(map) => {
+            let hash = ruby.hash_new();
+            for (key, val) in map {
+                let key_value = ruby.str_new(key).into_value_with(ruby);
+                let val_value = json_value_to_ruby(ruby, val)?;
+                hash.aset(key_value, val_value)?;
+            }
+            hash.into_value_with(ruby)
+        }
+    })
+}
+
+/// Convert Ruby key (String or Symbol) to Rust String
+pub fn ruby_key_to_string(value: Value) -> Result<String, Error> {
+    if let Ok(sym) = Symbol::try_convert(value) {
+        Ok(sym.name()?.to_string())
+    } else {
+        String::try_convert(value)
+    }
+}
+
+/// Convert Ruby Value to serde_json Value
+pub fn ruby_value_to_json(value: Value) -> Result<serde_json::Value, Error> {
+    let ruby = Ruby::get().expect("Ruby not initialized");
+
+    if value.is_nil() {
+        return Ok(serde_json::Value::Null);
+    }
+
+    if value.equal(ruby.qtrue())? {
+        return Ok(serde_json::Value::Bool(true));
+    }
+
+    if value.equal(ruby.qfalse())? {
+        return Ok(serde_json::Value::Bool(false));
+    }
+
+    if let Ok(integer) = i64::try_convert(value) {
+        return Ok(serde_json::Value::Number(integer.into()));
+    }
+
+    if let Ok(unsigned) = u64::try_convert(value) {
+        return Ok(serde_json::Value::Number(serde_json::Number::from(unsigned)));
+    }
+
+    if let Ok(float) = f64::try_convert(value)
+        && let Some(num) = serde_json::Number::from_f64(float)
+    {
+        return Ok(serde_json::Value::Number(num));
+    }
+
+    if let Ok(sym) = Symbol::try_convert(value) {
+        return Ok(serde_json::Value::String(sym.name()?.to_string()));
+    }
+
+    if let Ok(string) = String::try_convert(value) {
+        return Ok(serde_json::Value::String(string));
+    }
+
+    if let Ok(array) = RArray::try_convert(value) {
+        let mut values = Vec::with_capacity(array.len());
+        for item in array.into_iter() {
+            values.push(ruby_value_to_json(item)?);
+        }
+        return Ok(serde_json::Value::Array(values));
+    }
+
+    if let Ok(hash) = RHash::try_convert(value) {
+        let mut map = serde_json::Map::new();
+        hash.foreach(|key: Value, val: Value| {
+            let key_string = ruby_key_to_string(key)?;
+            let json_value = ruby_value_to_json(val)?;
+            map.insert(key_string, json_value);
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+
+        return Ok(serde_json::Value::Object(map));
+    }
+
+    Err(runtime_error("Unsupported Ruby value for JSON conversion"))
+}
+
+/// Get the cache root directory
+pub fn cache_root_dir() -> Result<PathBuf, Error> {
+    std::env::current_dir()
+        .map(|dir| dir.join(".kreuzberg"))
+        .map_err(|e| runtime_error(format!("Failed to get current directory: {}", e)))
+}
+
+/// Get all cache directories (root and subdirectories)
+pub fn cache_directories(root: &Path) -> Result<Vec<PathBuf>, Error> {
+    if !root.exists() {
+        return Ok(vec![]);
+    }
+
+    let mut dirs = vec![root.to_path_buf()];
+    let entries = fs::read_dir(root).map_err(|e| runtime_error(format!("Failed to read cache root: {}", e)))?;
+
+    for entry in entries {
+        let entry = entry.map_err(|e| runtime_error(format!("Failed to read cache directory entry: {}", e)))?;
+        if entry
+            .file_type()
+            .map_err(|e| runtime_error(format!("Failed to determine cache entry type: {}", e)))?
+            .is_dir()
+        {
+            dirs.push(entry.path());
+        }
+    }
+
+    Ok(dirs)
+}