parsekit 0.1.0.pre.1 → 0.1.1

data/ext/parsekit/src/parser.rs

@@ -1,7 +1,7 @@
 use magnus::{
-    class, function, method, prelude::*, scan_args, Error, RHash, RModule, Ruby, Value, Module,
+    function, method, prelude::*, scan_args, Error, Module, RHash, RModule, Ruby, Value,
 };
-use std::path::Path;
+use crate::format_detector::{FileFormat, FormatDetector};
 
 #[derive(Debug, Clone)]
 #[magnus::wrap(class = "ParseKit::Parser", free_immediately, size)]
@@ -28,14 +28,41 @@ impl Default for ParserConfig {
     }
 }
 
+// Error handling helpers
+impl Parser {
+    /// Create a RuntimeError with formatted message
+    fn runtime_error<E: std::fmt::Display>(context: &str, err: E) -> Error {
+        Error::new(
+            Ruby::get().unwrap().exception_runtime_error(),
+            format!("{}: {}", context, err),
+        )
+    }
+    
+    /// Create an ArgumentError with message
+    fn argument_error(msg: &str) -> Error {
+        Error::new(
+            Ruby::get().unwrap().exception_arg_error(),
+            msg.to_string(),
+        )
+    }
+    
+    /// Create an IOError with formatted message
+    fn io_error<E: std::fmt::Display>(context: &str, err: E) -> Error {
+        Error::new(
+            Ruby::get().unwrap().exception_io_error(),
+            format!("{}: {}", context, err),
+        )
+    }
+}
+
 impl Parser {
     /// Create a new Parser instance with optional configuration
     fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
         let args = scan_args::scan_args::<(), (Option<RHash>,), (), (), (), ()>(args)?;
         let options = args.optional.0;
-        
+
         let mut config = ParserConfig::default();
-        
+
         if let Some(opts) = options {
             if let Some(strict) = opts.get(ruby.to_symbol("strict_mode")) {
                 config.strict_mode = bool::try_convert(strict)?;
@@ -50,173 +77,193 @@ impl Parser {
                 config.max_size = usize::try_convert(max_size)?;
             }
         }
-        
+
         Ok(Self { config })
     }
-    
+
     /// Parse input bytes based on file type (internal helper)
     fn parse_bytes_internal(&self, data: Vec<u8>, filename: Option<&str>) -> Result<String, Error> {
         // Check size limit
         if data.len() > self.config.max_size {
-            return Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("File size {} exceeds maximum allowed size {}", data.len(), self.config.max_size),
+            return Err(Self::runtime_error(
+                "File size exceeds limit",
+                format!("{} bytes exceeds maximum allowed size of {} bytes", 
+                    data.len(), self.config.max_size)
             ));
         }
+
+        // Use centralized format detection
+        let format = FormatDetector::detect(filename, Some(&data));
         
-        // Detect file type from extension or content
-        let file_type = if let Some(name) = filename {
-            Self::detect_type_from_filename(name)
-        } else {
-            Self::detect_type_from_content(&data)
-        };
-        
-        match file_type.as_str() {
-            "pdf" => self.parse_pdf(data),
-            "docx" => self.parse_docx(data),
-            "xlsx" | "xls" => self.parse_xlsx(data),
-            "json" => self.parse_json(data),
-            "xml" | "html" => self.parse_xml(data),
-            "png" | "jpg" | "jpeg" | "tiff" | "bmp" => self.ocr_image(data),
-            "txt" | "text" => self.parse_text(data),
-            _ => self.parse_text(data), // Default to text parsing
-        }
+        // Use centralized dispatch
+        self.dispatch_to_parser(format, data)
     }
     
-    /// Detect file type from filename extension
-    fn detect_type_from_filename(filename: &str) -> String {
-        let path = Path::new(filename);
-        match path.extension().and_then(|s| s.to_str()) {
-            Some(ext) => ext.to_lowercase(),
-            None => "txt".to_string(),
+    /// Centralized dispatch logic - routes format to appropriate parser
+    fn dispatch_to_parser(&self, format: FileFormat, data: Vec<u8>) -> Result<String, Error> {
+        match format {
+            FileFormat::Pdf => self.parse_pdf(data),
+            FileFormat::Docx => self.parse_docx(data),
+            FileFormat::Pptx => self.parse_pptx(data),
+            FileFormat::Xlsx | FileFormat::Xls => self.parse_xlsx(data),
+            FileFormat::Json => self.parse_json(data),
+            FileFormat::Xml | FileFormat::Html => self.parse_xml(data),
+            FileFormat::Png | FileFormat::Jpeg | FileFormat::Tiff | FileFormat::Bmp => self.ocr_image(data),
+            FileFormat::Text | FileFormat::Unknown => self.parse_text(data),
         }
     }
-    
-    /// Detect file type from content (basic detection)
-    fn detect_type_from_content(data: &[u8]) -> String {
-        if data.starts_with(b"%PDF") {
-            "pdf".to_string()
-        } else if data.starts_with(b"PK") {
-            // PK is the ZIP signature - could be DOCX or XLSX
-            // Try to differentiate by looking for common patterns
-            // This is a simplified check - both DOCX and XLSX are ZIP files
-            // For now, default to xlsx as it's more commonly parsed
-            "xlsx".to_string() // Office Open XML format (could also be DOCX)
-        } else if data.starts_with(&[0xD0, 0xCF, 0x11, 0xE0]) {
-            "xls".to_string() // Old Excel format
-        } else if data.starts_with(&[0x89, 0x50, 0x4E, 0x47]) {
-            "png".to_string() // PNG signature
-        } else if data.starts_with(&[0xFF, 0xD8, 0xFF]) {
-            "jpg".to_string() // JPEG signature
-        } else if data.starts_with(b"BM") {
-            "bmp".to_string() // BMP signature
-        } else if data.starts_with(b"II\x2A\x00") || data.starts_with(b"MM\x00\x2A") {
-            "tiff".to_string() // TIFF signature (little-endian or big-endian)
-        } else if data.starts_with(b"<?xml") || data.starts_with(b"<html") {
-            "xml".to_string()
-        } else if data.starts_with(b"{") || data.starts_with(b"[") {
-            "json".to_string()
-        } else {
-            "txt".to_string()
+
+    /// Ruby-accessible method to detect format from bytes
+    fn detect_format_from_bytes(&self, data: Vec<u8>) -> String {
+        let format = FormatDetector::detect_from_content(&data);
+        // For compatibility with Ruby tests, return "xlsx" for old Excel
+        match format {
+            FileFormat::Xls => "xlsx".to_string(),  // Compatibility with existing tests
+            _ => format.to_symbol().to_string(),
         }
     }
     
+    /// Ruby-accessible method to detect format from filename
+    fn detect_format_from_filename(&self, filename: String) -> String {
+        let format = FormatDetector::detect_from_extension(&filename);
+        format.to_symbol().to_string()
+    }
+
     /// Perform OCR on image data using Tesseract
     fn ocr_image(&self, data: Vec<u8>) -> Result<String, Error> {
-        use rusty_tesseract::{Image, Args};
+        use tesseract_rs::TesseractAPI;
         
-        // Load image from memory
-        let img = match image::load_from_memory(&data) {
-            Ok(img) => img,
-            Err(e) => return Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to load image: {}", e),
-            ))
-        };
+        // Create tesseract instance
+        let tesseract = TesseractAPI::new();
         
-        // Create rusty_tesseract Image from DynamicImage
-        let tess_img = match Image::from_dynamic_image(&img) {
-            Ok(img) => img,
-            Err(e) => return Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to convert image for OCR: {}", e),
-            ))
+        // Try to initialize with appropriate tessdata path
+        // Even in bundled mode, we need to find tessdata files
+        #[cfg(feature = "bundled-tesseract")]
+        let init_result = {
+            // Build list of tessdata paths to try
+            let mut tessdata_paths = Vec::new();
+            
+            // Check TESSDATA_PREFIX environment variable first (for CI)
+            if let Ok(env_path) = std::env::var("TESSDATA_PREFIX") {
+                tessdata_paths.push(env_path);
+            }
+            
+            // Add common system paths
+            tessdata_paths.extend_from_slice(&[
+                "/usr/share/tessdata".to_string(),
+                "/usr/local/share/tessdata".to_string(), 
+                "/opt/homebrew/share/tessdata".to_string(),
+                "/opt/local/share/tessdata".to_string(),
+                "tessdata".to_string(),  // Local tessdata directory
+                ".".to_string(),  // Current directory as fallback
+            ]);
+            
+            let mut result = Err(tesseract_rs::TesseractError::InitError);
+            for path in &tessdata_paths {
+                // Check if path exists first to avoid noisy error messages
+                if std::path::Path::new(path).exists() {
+                    if tesseract.init(path.as_str(), "eng").is_ok() {
+                        result = Ok(());
+                        break;
+                    }
+                }
+            }
+            result
         };
         
-        // Set up OCR arguments
-        let mut args = Args::default();
-        args.lang = "eng".to_string();
-        // Optional: Add more configuration
-        // args.config_variables.insert("tessedit_char_whitelist".to_string(), 
-        //     "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz .,!?-".to_string());
+        #[cfg(not(feature = "bundled-tesseract"))]
+        let init_result = {
+            // Try common system tessdata paths
+            let tessdata_paths = vec![
+                "/usr/share/tessdata",
+                "/usr/local/share/tessdata", 
+                "/opt/homebrew/share/tessdata",
+                "/opt/local/share/tessdata",
+            ];
+            
+            let mut result = Err(tesseract_rs::TesseractError::InitError);
+            for path in &tessdata_paths {
+                if std::path::Path::new(path).exists() {
+                    if tesseract.init(path, "eng").is_ok() {
+                        result = Ok(());
+                        break;
+                    }
+                }
+            }
+            result
+        };
         
-        // Perform OCR
-        match rusty_tesseract::image_to_string(&tess_img, &args) {
-            Ok(text) => Ok(text.trim().to_string()),
-            Err(e) => Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to perform OCR: {}", e),
-            ))
+        if let Err(e) = init_result {
+            return Err(Self::runtime_error("Failed to initialize Tesseract", e));
         }
+        
+        // Load the image from bytes
+        let img = image::load_from_memory(&data)
+            .map_err(|e| Self::runtime_error("Failed to load image", e))?;
+        
+        // Convert to RGBA8 format
+        let rgba_img = img.to_rgba8();
+        let (width, height) = rgba_img.dimensions();
+        let raw_data = rgba_img.into_raw();
+        
+        // Set image data
+        tesseract.set_image(
+            &raw_data,
+            width as i32,
+            height as i32,
+            4,  // bytes per pixel (RGBA)
+            (width * 4) as i32,  // bytes per line
+        ).map_err(|e| Self::runtime_error("Failed to set image", e))?;
+        
+        // Extract text
+        tesseract.get_utf8_text()
+            .map(|text| text.trim().to_string())
+            .map_err(|e| Self::runtime_error("Failed to perform OCR", e))
     }
     
+
     /// Parse PDF files using MuPDF (statically linked) - exposed to Ruby
     fn parse_pdf(&self, data: Vec<u8>) -> Result<String, Error> {
         use mupdf::Document;
-        
+
         // Try to load the PDF from memory
         // The magic parameter helps MuPDF identify the file type
-        match Document::from_bytes(&data, "pdf") {
-            Ok(doc) => {
-                let mut all_text = String::new();
-                
-                // Get page count - this returns a Result
-                let page_count = match doc.page_count() {
-                    Ok(count) => count,
-                    Err(e) => return Err(Error::new(
-                        magnus::exception::runtime_error(),
-                        format!("Failed to get page count: {}", e),
-                    ))
-                };
-                
-                // Iterate through pages
-                for page_num in 0..page_count {
-                    match doc.load_page(page_num) {
-                        Ok(page) => {
-                            // Extract text from the page
-                            match page.to_text() {
-                                Ok(text) => {
-                                    all_text.push_str(&text);
-                                    all_text.push('\n');
-                                }
-                                Err(_) => continue,
-                            }
-                        }
-                        Err(_) => continue,
-                    }
-                }
-                
-                if all_text.is_empty() {
-                    Ok("PDF contains no extractable text (might be scanned/image-based)".to_string())
-                } else {
-                    Ok(all_text.trim().to_string())
+        let doc = Document::from_bytes(&data, "pdf")
+            .map_err(|e| Self::runtime_error("Failed to parse PDF", e))?;
+        
+        let mut all_text = String::new();
+
+        // Get page count
+        let page_count = doc.page_count()
+            .map_err(|e| Self::runtime_error("Failed to get page count", e))?;
+
+        // Iterate through pages
+        for page_num in 0..page_count {
+            // Continue on page errors rather than failing entirely
+            if let Ok(page) = doc.load_page(page_num) {
+                // Extract text from the page
+                if let Ok(text) = page.to_text() {
+                    all_text.push_str(&text);
+                    all_text.push('\n');
                 }
             }
-            Err(e) => Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to parse PDF: {}", e),
-            ))
+        }
+
+        if all_text.is_empty() {
+            Ok("PDF contains no extractable text (might be scanned/image-based)".to_string())
+        } else {
+            Ok(all_text.trim().to_string())
         }
     }
-    
+
     /// Parse DOCX (Word) files - exposed to Ruby
     fn parse_docx(&self, data: Vec<u8>) -> Result<String, Error> {
         use docx_rs::read_docx;
-        
+
         match read_docx(&data) {
             Ok(docx) => {
                 let mut result = String::new();
-                
+
                 // Extract text from all document children
                 // For simplicity, we'll focus on paragraphs only for now
                 // Tables require more complex handling with the current API
@@ -238,29 +285,156 @@ impl Parser {
                     // table.rows -> TableChild::TableRow -> row.cells -> TableRowChild
                     // which has a more complex structure in docx-rs
                 }
-                
+
                 Ok(result.trim().to_string())
             }
-            Err(e) => Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to parse DOCX file: {}", e),
-            ))
+            Err(e) => Err(Self::runtime_error("Failed to parse DOCX file", e)),
+        }
+    }
+
+    /// Parse PPTX (PowerPoint) files - exposed to Ruby
+    fn parse_pptx(&self, data: Vec<u8>) -> Result<String, Error> {
+        use std::io::{Cursor, Read};
+        use zip::ZipArchive;
+        
+        let cursor = Cursor::new(data);
+        let mut archive = ZipArchive::new(cursor)
+            .map_err(|e| Self::runtime_error("Failed to open PPTX as ZIP", e))?;
+        
+        let mut all_text = Vec::new();
+        let mut slide_numbers = Vec::new();
+        
+        // First, collect slide numbers and sort them
+        for i in 0..archive.len() {
+            let file = match archive.by_index(i) {
+                Ok(file) => file,
+                Err(_) => continue,
+            };
+            
+            let name = file.name();
+            // Match slide XML files (e.g., ppt/slides/slide1.xml)
+            if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") && !name.contains("_rels") {
+                // Extract slide number from filename
+                if let Some(num_str) = name
+                    .strip_prefix("ppt/slides/slide")
+                    .and_then(|s| s.strip_suffix(".xml"))
+                {
+                    if let Ok(num) = num_str.parse::<usize>() {
+                        slide_numbers.push((num, i));
+                    }
+                }
+            }
+        }
+        
+        // Sort by slide number to maintain order
+        slide_numbers.sort_by_key(|&(num, _)| num);
+        
+        // Now process slides in order
+        for (_, index) in slide_numbers {
+            let mut file = match archive.by_index(index) {
+                Ok(file) => file,
+                Err(_) => continue,
+            };
+            
+            let mut contents = String::new();
+            if file.read_to_string(&mut contents).is_ok() {
+                // Extract text from slide XML
+                let text = self.extract_text_from_slide_xml(&contents);
+                if !text.is_empty() {
+                    all_text.push(text);
+                }
+            }
+        }
+        
+        // Also extract notes if present
+        for i in 0..archive.len() {
+            let mut file = match archive.by_index(i) {
+                Ok(file) => file,
+                Err(_) => continue,
+            };
+            
+            let name = file.name();
+            // Match notes slide XML files
+            if name.starts_with("ppt/notesSlides/notesSlide") && name.ends_with(".xml") && !name.contains("_rels") {
+                let mut contents = String::new();
+                if file.read_to_string(&mut contents).is_ok() {
+                    let text = self.extract_text_from_slide_xml(&contents);
+                    if !text.is_empty() {
+                        all_text.push(format!("[Notes: {}]", text));
+                    }
+                }
+            }
+        }
+        
+        if all_text.is_empty() {
+            Ok("".to_string())
+        } else {
+            Ok(all_text.join("\n\n"))
         }
     }
     
+    /// Helper method to extract text from slide XML
+    fn extract_text_from_slide_xml(&self, xml_content: &str) -> String {
+        use quick_xml::events::Event;
+        use quick_xml::Reader;
+        
+        let mut reader = Reader::from_str(xml_content);
+        
+        let mut text_parts = Vec::new();
+        let mut buf = Vec::new();
+        let mut in_text_element = false;
+        
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(ref e)) => {
+                    // Look for text elements (a:t or t)
+                    let name = e.name();
+                    let local_name_bytes = name.local_name();
+                    let local_name = std::str::from_utf8(local_name_bytes.as_ref()).unwrap_or("");
+                    if local_name == "t" {
+                        in_text_element = true;
+                    }
+                }
+                Ok(Event::Text(e)) => {
+                    if in_text_element {
+                        if let Ok(text) = e.decode() {
+                            let text_str = text.trim();
+                            if !text_str.is_empty() {
+                                text_parts.push(text_str.to_string());
+                            }
+                        }
+                    }
+                }
+                Ok(Event::End(ref e)) => {
+                    let name = e.name();
+                    let local_name_bytes = name.local_name();
+                    let local_name = std::str::from_utf8(local_name_bytes.as_ref()).unwrap_or("");
+                    if local_name == "t" {
+                        in_text_element = false;
+                    }
+                }
+                Ok(Event::Eof) => break,
+                _ => {}
+            }
+            buf.clear();
+        }
+        
+        text_parts.join(" ")
+    }
+
     /// Parse Excel files - exposed to Ruby
     fn parse_xlsx(&self, data: Vec<u8>) -> Result<String, Error> {
         use calamine::{Reader, Xlsx};
         use std::io::Cursor;
-        
+
         let cursor = Cursor::new(data);
         match Xlsx::new(cursor) {
             Ok(mut workbook) => {
                 let mut result = String::new();
-                
+
                 for sheet_name in workbook.sheet_names().to_owned() {
                     result.push_str(&format!("Sheet: {}\n", sheet_name));
-                    
+
                     if let Ok(range) = workbook.worksheet_range(&sheet_name) {
                         for row in range.rows() {
                             for cell in row {
@@ -271,60 +445,56 @@ impl Parser {
                     }
                     result.push('\n');
                 }
-                
+
                 Ok(result)
             }
-            Err(e) => Err(Error::new(
-                magnus::exception::runtime_error(),
-                format!("Failed to parse Excel file: {}", e),
-            ))
+            Err(e) => Err(Self::runtime_error("Failed to parse Excel file", e)),
         }
     }
-    
+
     /// Parse JSON files - exposed to Ruby
     fn parse_json(&self, data: Vec<u8>) -> Result<String, Error> {
         let text = String::from_utf8_lossy(&data);
         match serde_json::from_str::<serde_json::Value>(&text) {
-            Ok(json) => Ok(serde_json::to_string_pretty(&json).unwrap_or_else(|_| text.to_string())),
+            Ok(json) => {
+                Ok(serde_json::to_string_pretty(&json).unwrap_or_else(|_| text.to_string()))
+            }
             Err(_) => Ok(text.to_string()),
         }
     }
-    
+
     /// Parse XML/HTML files - exposed to Ruby
     fn parse_xml(&self, data: Vec<u8>) -> Result<String, Error> {
         use quick_xml::events::Event;
         use quick_xml::Reader;
-        
+
         let mut reader = Reader::from_reader(&data[..]);
         let mut txt = String::new();
         let mut buf = Vec::new();
-        
+
         loop {
             match reader.read_event_into(&mut buf) {
                 Ok(Event::Text(e)) => {
-                    txt.push_str(&e.unescape().unwrap_or_default());
+                    txt.push_str(&e.decode().unwrap_or_default());
                     txt.push(' ');
                 }
                 Ok(Event::Eof) => break,
                 Err(e) => {
-                    return Err(Error::new(
-                        magnus::exception::runtime_error(),
-                        format!("XML parse error: {}", e),
-                    ))
+                    return Err(Self::runtime_error("XML parse error", e))
                 }
                 _ => {}
             }
             buf.clear();
         }
-        
+
         Ok(txt.trim().to_string())
     }
-    
+
     /// Parse plain text with encoding detection - exposed to Ruby
     fn parse_text(&self, data: Vec<u8>) -> Result<String, Error> {
         // Detect encoding
         let (decoded, _encoding, malformed) = encoding_rs::UTF_8.decode(&data);
-        
+
         if malformed {
             // Try other encodings
             let (decoded, _encoding, _malformed) = encoding_rs::WINDOWS_1252.decode(&data);
@@ -333,16 +503,13 @@ impl Parser {
             Ok(decoded.to_string())
         }
     }
-    
+
     /// Parse input string (for text content)
     fn parse(&self, input: String) -> Result<String, Error> {
         if input.is_empty() {
-            return Err(Error::new(
-                magnus::exception::arg_error(),
-                "Input cannot be empty",
-            ));
+            return Err(Self::argument_error("Input cannot be empty"));
         }
-        
+
         // For string input, just return cleaned text
         // If strict mode is on, append indicator for testing
         if self.config.strict_mode {
@@ -351,29 +518,26 @@ impl Parser {
             Ok(input.trim().to_string())
         }
     }
-    
+
     /// Parse a file
     fn parse_file(&self, path: String) -> Result<String, Error> {
         use std::fs;
-        
+
         let data = fs::read(&path)
-            .map_err(|e| Error::new(magnus::exception::io_error(), format!("Failed to read file: {}", e)))?;
-        
+            .map_err(|e| Self::io_error("Failed to read file", e))?;
+
         self.parse_bytes_internal(data, Some(&path))
     }
-    
+
     /// Parse bytes from Ruby
     fn parse_bytes(&self, data: Vec<u8>) -> Result<String, Error> {
         if data.is_empty() {
-            return Err(Error::new(
-                magnus::exception::arg_error(),
-                "Data cannot be empty",
-            ));
+            return Err(Self::argument_error("Data cannot be empty"));
         }
-        
+
         self.parse_bytes_internal(data, None)
     }
-    
+
     /// Get parser configuration
     fn config(&self) -> Result<RHash, Error> {
         let ruby = Ruby::get().unwrap();
@@ -384,37 +548,26 @@ impl Parser {
         hash.aset(ruby.to_symbol("max_size"), self.config.max_size)?;
         Ok(hash)
     }
-    
+
     /// Check if parser is in strict mode
     fn strict_mode(&self) -> bool {
         self.config.strict_mode
     }
-    
+
     /// Check supported file types
     fn supported_formats() -> Vec<String> {
-        vec![
-            "txt".to_string(),
-            "json".to_string(),
-            "xml".to_string(),
-            "html".to_string(),
-            "docx".to_string(),
-            "xlsx".to_string(),
-            "xls".to_string(),
-            "csv".to_string(),
-            "pdf".to_string(),  // Text extraction via MuPDF
-            "png".to_string(),  // OCR via Tesseract
-            "jpg".to_string(),  // OCR via Tesseract
-            "jpeg".to_string(), // OCR via Tesseract
-            "tiff".to_string(), // OCR via Tesseract
-            "bmp".to_string(),  // OCR via Tesseract
-        ]
+        // Use the centralized list from FormatDetector
+        FormatDetector::supported_extensions()
+            .iter()
+            .map(|&s| s.to_string())
+            .collect()
     }
-    
+
     /// Detect if file extension is supported
     fn supports_file(&self, path: String) -> bool {
         if let Some(ext) = std::path::Path::new(&path)
             .extension()
-            .and_then(|s| s.to_str()) 
+            .and_then(|s| s.to_str())
         {
             Self::supported_formats().contains(&ext.to_lowercase())
         } else {
@@ -441,8 +594,8 @@ fn parse_bytes_direct(data: Vec<u8>) -> Result<String, Error> {
 
 /// Initialize the Parser class
 pub fn init(_ruby: &Ruby, module: RModule) -> Result<(), Error> {
-    let class = module.define_class("Parser", class::object())?;
-    
+    let class = module.define_class("Parser", Ruby::get().unwrap().class_object())?;
+
     // Instance methods
     class.define_singleton_method("new", function!(Parser::new, -1))?;
     class.define_method("parse", method!(Parser::parse, 1))?;
@@ -451,22 +604,27 @@ pub fn init(_ruby: &Ruby, module: RModule) -> Result<(), Error> {
     class.define_method("config", method!(Parser::config, 0))?;
     class.define_method("strict_mode?", method!(Parser::strict_mode, 0))?;
     class.define_method("supports_file?", method!(Parser::supports_file, 1))?;
-    
+
     // Individual parser methods exposed to Ruby
     class.define_method("parse_pdf", method!(Parser::parse_pdf, 1))?;
     class.define_method("parse_docx", method!(Parser::parse_docx, 1))?;
+    class.define_method("parse_pptx", method!(Parser::parse_pptx, 1))?;
     class.define_method("parse_xlsx", method!(Parser::parse_xlsx, 1))?;
     class.define_method("parse_json", method!(Parser::parse_json, 1))?;
     class.define_method("parse_xml", method!(Parser::parse_xml, 1))?;
     class.define_method("parse_text", method!(Parser::parse_text, 1))?;
     class.define_method("ocr_image", method!(Parser::ocr_image, 1))?;
     
+    // Format detection methods
+    class.define_method("detect_format_from_bytes", method!(Parser::detect_format_from_bytes, 1))?;
+    class.define_method("detect_format_from_filename", method!(Parser::detect_format_from_filename, 1))?;
+
     // Class methods
     class.define_singleton_method("supported_formats", function!(Parser::supported_formats, 0))?;
-    
+
     // Module-level convenience methods
     module.define_singleton_method("parse_file", function!(parse_file_direct, 1))?;
     module.define_singleton_method("parse_bytes", function!(parse_bytes_direct, 1))?;
-    
+
     Ok(())
-}
+}