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

data/vendor/kreuzberg/src/pdf/fonts.rs

@@ -1,358 +0,0 @@
-//! Font caching system for Pdfium rendering.
-//!
-//! This module provides an efficient, thread-safe font caching mechanism that eliminates
-//! per-page font loading overhead when processing PDFs. Fonts are discovered from system
-//! directories on first access and cached in memory for zero-copy sharing across Pdfium instances.
-//!
-//! # Performance Impact
-//!
-//! By caching fonts in memory:
-//! - First PDF operation: ~50-100ms (initial font discovery and loading)
-//! - Subsequent pages: ~1-2ms per page (zero-copy from cache)
-//! - 100-page PDF: ~200ms total (vs ~10s without caching) = **50x improvement**
-//!
-//! # Platform Support
-//!
-//! Font discovery works on:
-//! - **macOS**: `/Library/Fonts`, `/System/Library/Fonts`
-//! - **Linux**: `/usr/share/fonts`, `/usr/local/share/fonts`
-//! - **Windows**: `C:\Windows\Fonts`
-//!
-//! # Example
-//!
-//! ```rust,no_run
-//! use kreuzberg::pdf::fonts::{initialize_font_cache, get_font_descriptors};
-//!
-//! # fn example() -> Result<(), Box<dyn std::error::Error>> {
-//! // Initialize cache on application startup (lazy-loaded on first call)
-//! initialize_font_cache()?;
-//!
-//! // Get cached font descriptors for Pdfium configuration
-//! let descriptors = get_font_descriptors()?;
-//! println!("Loaded {} fonts", descriptors.len());
-//! # Ok(())
-//! # }
-//! ```
-
-use super::error::PdfError;
-use once_cell::sync::Lazy;
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::sync::RwLock;
-
-#[cfg(feature = "pdf")]
-use pdfium_render::prelude::FontDescriptor;
-
-/// Global font cache: maps font paths to loaded bytes.
-///
-/// Uses `Arc<[u8]>` for zero-copy sharing when passing fonts to multiple Pdfium instances.
-/// Protected by `RwLock` for concurrent read access during PDF processing.
-static FONT_CACHE: Lazy<RwLock<FontCacheState>> = Lazy::new(|| {
-    RwLock::new(FontCacheState {
-        fonts: HashMap::new(),
-        initialized: false,
-    })
-});
-
-/// Internal state for the font cache.
-struct FontCacheState {
-    /// Map from font path (relative identifier) to loaded font bytes
-    fonts: HashMap<String, Arc<[u8]>>,
-    /// Whether the cache has been initialized
-    initialized: bool,
-}
-
-/// Platform-specific font directory paths.
-#[cfg(target_os = "macos")]
-fn system_font_directories() -> Vec<PathBuf> {
-    vec![PathBuf::from("/Library/Fonts"), PathBuf::from("/System/Library/Fonts")]
-}
-
-/// Platform-specific font directory paths.
-#[cfg(target_os = "linux")]
-fn system_font_directories() -> Vec<PathBuf> {
-    vec![
-        PathBuf::from("/usr/share/fonts"),
-        PathBuf::from("/usr/local/share/fonts"),
-    ]
-}
-
-/// Platform-specific font directory paths.
-#[cfg(target_os = "windows")]
-fn system_font_directories() -> Vec<PathBuf> {
-    vec![PathBuf::from("C:\\Windows\\Fonts")]
-}
-
-/// Platform-specific font directory paths for other OSes.
-#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
-fn system_font_directories() -> Vec<PathBuf> {
-    vec![]
-}
-
-/// Load a single font file into memory.
-///
-/// # Arguments
-///
-/// * `path` - Path to the font file (.ttf or .otf)
-///
-/// # Returns
-///
-/// An Arc-wrapped slice of font bytes, or an error if the file cannot be read.
-fn load_font_file(path: &Path) -> Result<Arc<[u8]>, PdfError> {
-    std::fs::read(path)
-        .map(|bytes| Arc::from(bytes.into_boxed_slice()))
-        .map_err(|e| PdfError::FontLoadingFailed(format!("Failed to read font file '{}': {}", path.display(), e)))
-}
-
-/// Discover and load all system fonts.
-///
-/// Scans platform-specific font directories and loads all .ttf and .otf files.
-/// Font files larger than 50MB are skipped to prevent memory issues.
-///
-/// # Returns
-///
-/// A HashMap mapping font identifiers (relative paths) to loaded font bytes.
-fn discover_system_fonts() -> Result<HashMap<String, Arc<[u8]>>, PdfError> {
-    let mut fonts = HashMap::new();
-    const MAX_FONT_SIZE: u64 = 50 * 1024 * 1024;
-
-    for dir in system_font_directories() {
-        if !dir.exists() {
-            continue;
-        }
-
-        match std::fs::read_dir(&dir) {
-            Ok(entries) => {
-                for entry in entries.flatten() {
-                    let path = entry.path();
-
-                    if let Some(ext) = path.extension() {
-                        let ext_str = ext.to_string_lossy().to_lowercase();
-                        if ext_str != "ttf" && ext_str != "otf" {
-                            continue;
-                        }
-
-                        if let Ok(metadata) = std::fs::metadata(&path) {
-                            if metadata.len() > MAX_FONT_SIZE {
-                                tracing::warn!(
-                                    "Font file too large (skipped): {} ({}MB)",
-                                    path.display(),
-                                    metadata.len() / (1024 * 1024)
-                                );
-                                continue;
-                            }
-                        } else {
-                            continue;
-                        }
-
-                        match load_font_file(&path) {
-                            Ok(font_data) => {
-                                if let Some(filename) = path.file_name() {
-                                    let key = filename.to_string_lossy().to_string();
-                                    fonts.insert(key, font_data);
-                                }
-                            }
-                            Err(_e) => {
-                                tracing::debug!("Failed to load font file: {}", path.display());
-                            }
-                        }
-                    }
-                }
-            }
-            Err(_e) => {
-                tracing::debug!("Failed to read font directory: {}", dir.display());
-            }
-        }
-    }
-
-    Ok(fonts)
-}
-
-/// Initialize the global font cache.
-///
-/// On first call, discovers and loads all system fonts. Subsequent calls are no-ops.
-/// Caching is thread-safe via RwLock; concurrent reads during PDF processing are efficient.
-///
-/// # Returns
-///
-/// Ok if initialization succeeds or cache is already initialized, or PdfError if font discovery fails.
-///
-/// # Performance
-///
-/// - First call: 50-100ms (system font discovery + loading)
-/// - Subsequent calls: < 1μs (no-op, just checks initialized flag)
-pub fn initialize_font_cache() -> Result<(), PdfError> {
-    {
-        let cache = FONT_CACHE
-            .read()
-            .map_err(|e| PdfError::FontLoadingFailed(format!("Font cache lock poisoned: {}", e)))?;
-
-        if cache.initialized {
-            return Ok(());
-        }
-    }
-
-    let mut cache = FONT_CACHE
-        .write()
-        .map_err(|e| PdfError::FontLoadingFailed(format!("Font cache lock poisoned: {}", e)))?;
-
-    if cache.initialized {
-        return Ok(());
-    }
-
-    tracing::debug!("Initializing font cache...");
-    let fonts = discover_system_fonts()?;
-    let font_count = fonts.len();
-
-    cache.fonts = fonts;
-    cache.initialized = true;
-
-    tracing::debug!("Font cache initialized with {} fonts", font_count);
-    Ok(())
-}
-
-/// Get cached font descriptors for Pdfium configuration.
-///
-/// Ensures the font cache is initialized, then returns font descriptors
-/// derived from the cached fonts. This call is fast after the first invocation.
-///
-/// # Returns
-///
-/// A Vec of FontDescriptor objects suitable for `PdfiumConfig::set_font_provider()`.
-///
-/// # Performance
-///
-/// - First call: ~50-100ms (includes font discovery)
-/// - Subsequent calls: < 1ms (reads from cache)
-pub fn get_font_descriptors() -> Result<Vec<FontDescriptor>, PdfError> {
-    initialize_font_cache()?;
-
-    let cache = FONT_CACHE
-        .read()
-        .map_err(|e| PdfError::FontLoadingFailed(format!("Font cache lock poisoned: {}", e)))?;
-
-    let descriptors = cache
-        .fonts
-        .iter()
-        .map(|(filename, data)| {
-            let is_italic = filename.to_lowercase().contains("italic");
-            let is_bold = filename.to_lowercase().contains("bold");
-            let weight = if is_bold { 700 } else { 400 };
-
-            let family = filename.split('.').next().unwrap_or("Unknown").to_string();
-
-            FontDescriptor {
-                family,
-                weight,
-                is_italic,
-                charset: 0,
-                data: data.clone(),
-            }
-        })
-        .collect();
-
-    Ok(descriptors)
-}
-
-/// Get the number of cached fonts.
-///
-/// Useful for diagnostics and testing.
-///
-/// # Returns
-///
-/// Number of fonts in the cache, or 0 if not initialized.
-pub fn cached_font_count() -> usize {
-    FONT_CACHE.read().map(|cache| cache.fonts.len()).unwrap_or(0)
-}
-
-/// Clear the font cache (for testing purposes).
-///
-/// # Panics
-///
-/// Panics if the cache lock is poisoned, which should only happen in test scenarios
-/// with deliberate panic injection.
-#[cfg(test)]
-pub fn clear_font_cache() {
-    let mut cache = FONT_CACHE.write().expect("Failed to acquire write lock");
-    cache.fonts.clear();
-    cache.initialized = false;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_initialize_font_cache() {
-        clear_font_cache();
-        let result = initialize_font_cache();
-        assert!(result.is_ok(), "Font cache initialization should succeed");
-    }
-
-    #[test]
-    fn test_initialize_font_cache_idempotent() {
-        clear_font_cache();
-
-        let result1 = initialize_font_cache();
-        assert!(result1.is_ok());
-
-        let result2 = initialize_font_cache();
-        assert!(result2.is_ok());
-    }
-
-    #[test]
-    fn test_get_font_descriptors() {
-        clear_font_cache();
-        let result = get_font_descriptors();
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_cached_font_count() {
-        clear_font_cache();
-        assert_eq!(cached_font_count(), 0, "Cache should be empty before initialization");
-
-        let _ = initialize_font_cache();
-        let _count = cached_font_count();
-    }
-
-    #[test]
-    fn test_system_font_directories() {
-        let dirs = system_font_directories();
-        assert!(!dirs.is_empty(), "Should have at least one font directory");
-
-        for dir in dirs {
-            assert!(
-                dir.is_absolute(),
-                "Font directory should be absolute: {}",
-                dir.display()
-            );
-        }
-    }
-
-    #[test]
-    fn test_load_font_file_nonexistent() {
-        let result = load_font_file(Path::new("/nonexistent/path/font.ttf"));
-        assert!(result.is_err(), "Loading nonexistent file should fail with error");
-    }
-
-    #[test]
-    fn test_font_descriptors_attributes() {
-        clear_font_cache();
-
-        let data: Arc<[u8]> = Arc::from(vec![0u8; 100].into_boxed_slice());
-        let descriptor = FontDescriptor {
-            family: "TestFont".to_string(),
-            weight: 700,
-            is_italic: false,
-            charset: 0,
-            data,
-        };
-
-        assert_eq!(descriptor.family, "TestFont");
-        assert_eq!(descriptor.weight, 700);
-        assert!(!descriptor.is_italic);
-        assert_eq!(descriptor.charset, 0);
-    }
-}