fix: resolve clippy pedantic warnings (#67)

- Replace lazy_static with std::sync::LazyLock
  - Use case-insensitive file extension comparison in pptx parser
  - Add missing #Errors doc section to parse function
  - Merge identical match arms in ApiError implementations
  - Move const declaration before statements in benchmark
  - Use integer div_ceil instead of float arithmetic
  - Remove unused lazy_static dependency

Author: excoffierleonard

Cargo.lock

@@ -15,10 +15,9 @@ categories = ["text-processing", "parsing"]
 calamine = "0.32.0"
 docx-rs = "0.4.18"
 infer = "0.19.0"
-lazy_static = "1.5.0"
 mime = "0.3.17"
 pdf-extract = "0.10.0"
-regex = "1.12.2"
+regex = "1.12.3"
 tempfile = "3.24.0"
 tesseract = "0.15.2"
 zip = "7.2.0"
@@ -38,6 +37,9 @@ env_logger = "0.11.8"
 criterion = "0.8"
 num_cpus = "1.17.0"
 
+[lints.clippy]
+pedantic = "warn"
+
 [[bench]]
 name = "function_parse"
 harness = false

Cargo.toml

@@ -56,7 +56,7 @@ fn benchmark_sequential_vs_parallel(c: &mut Criterion) {
                 .par_iter()
                 .map(|d| parse(black_box(d)))
                 .collect::<Result<Vec<String>, ParserError>>()
-        })
+        });
     });
 
     // Benchmark sequential parsing
@@ -66,7 +66,7 @@ fn benchmark_sequential_vs_parallel(c: &mut Criterion) {
                 .iter()
                 .map(|d| parse(black_box(d)))
                 .collect::<Result<Vec<String>, ParserError>>()
-        })
+        });
     });
 
     group.finish();
@@ -98,7 +98,7 @@ fn benchmark_parallel_efficiency(c: &mut Criterion) {
                     .par_iter()
                     .map(|d| parse(black_box(d)))
                     .collect::<Result<Vec<String>, ParserError>>()
-            })
+            });
         });
     }
 
@@ -123,7 +123,7 @@ fn benchmark_per_filetype(c: &mut Criterion) {
                     .par_iter()
                     .map(|d| parse(black_box(d)))
                     .collect::<Result<Vec<String>, ParserError>>()
-            })
+            });
         });
     }
 
@@ -144,7 +144,7 @@ fn benchmark_per_filetype(c: &mut Criterion) {
                     .par_iter()
                     .map(|d| parse(black_box(d)))
                     .collect::<Result<Vec<String>, ParserError>>()
-            })
+            });
         });
     }
 
@@ -153,6 +153,7 @@ fn benchmark_per_filetype(c: &mut Criterion) {
 
 // Finds the threshold number of files for each type that takes less than 16ms
 fn benchmark_parallel_threshold(c: &mut Criterion) {
+    const SAMPLE_COUNT: usize = 5;
     let max_time_threshold = Duration::from_millis(16);
 
     // Read each test file only once
@@ -181,7 +182,6 @@ fn benchmark_parallel_threshold(c: &mut Criterion) {
             }
 
             // Take multiple measurements and use median for robustness
-            const SAMPLE_COUNT: usize = 5;
             let mut durations = Vec::with_capacity(SAMPLE_COUNT);
 
             for _ in 0..SAMPLE_COUNT {
@@ -227,13 +227,16 @@ fn benchmark_parallel_threshold(c: &mut Criterion) {
         // The threshold count is now in 'low'
         let threshold_count = low;
 
-        // Define percentages to test around the threshold
-        let percentages = [99.0, 99.9, 100.0, 100.1, 101.0];
+        // Permille values for percentages: 99.0%, 99.9%, 100.0%, 100.1%, 101.0%
+        let permille_values: [usize; 5] = [990, 999, 1000, 1001, 1010];
 
-        // Generate test points based on percentages of the threshold
-        let mut test_points: Vec<usize> = percentages
+        // Generate test points based on percentages of the threshold using integer math
+        let mut test_points: Vec<usize> = permille_values
             .iter()
-            .map(|&p| ((threshold_count as f64 * p / 100.0).ceil() as usize).max(1))
+            .map(|&p| {
+                let product = threshold_count.saturating_mul(p);
+                product.div_ceil(1000).max(1)
+            })
             .collect();
 
         test_points.dedup();
@@ -251,7 +254,7 @@ fn benchmark_parallel_threshold(c: &mut Criterion) {
                         .par_iter()
                         .map(|d| parse(black_box(d)))
                         .collect::<Result<Vec<String>, ParserError>>()
-                })
+                });
             });
         }
 

benches/function_parse.rs

@@ -13,6 +13,6 @@ pub const APPLICATION_DOCX: &str =
 pub const APPLICATION_XLSX: &str =
     "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 
-/// MIME type for PPTX (Microsoft PowerPoint) presentations
+/// MIME type for PPTX (Microsoft `PowerPoint`) presentations
 pub const APPLICATION_PPTX: &str =
     "application/vnd.openxmlformats-officedocument.presentationml.presentation";

src/core/constants.rs

@@ -31,14 +31,14 @@ pub enum ParserError {
 impl std::fmt::Display for ParserError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ParserError::IoError(msg) => write!(f, "IO error: {}", msg),
-            ParserError::ParseError(msg) => write!(f, "Parse error: {}", msg),
-            ParserError::InvalidFormat(msg) => write!(f, "Invalid format: {}", msg),
+            ParserError::IoError(msg) => write!(f, "IO error: {msg}"),
+            ParserError::ParseError(msg) => write!(f, "Parse error: {msg}"),
+            ParserError::InvalidFormat(msg) => write!(f, "Invalid format: {msg}"),
         }
     }
 }
 
-/// Implements the std::error::Error trait for ParserError to allow it to be used
+/// Implements the `std::error::Error` trait for `ParserError` to allow it to be used
 /// with the ? operator and to be boxed as a dyn Error.
 impl std::error::Error for ParserError {}
 

src/core/errors.rs

@@ -21,14 +21,12 @@ use super::{
     errors::ParserError,
 };
 use infer::Infer;
-use lazy_static::lazy_static;
 use mime::{IMAGE, Mime, TEXT, TEXT_PLAIN};
 use std::str;
+use std::sync::LazyLock;
 
 // Create a static infer instance to avoid recreating it on every call
-lazy_static! {
-    static ref INFER: Infer = Infer::new();
-}
+static INFER: LazyLock<Infer> = LazyLock::new(Infer::new);
 
 /// Parses the given data into plain text.
 ///
@@ -74,6 +72,11 @@ lazy_static! {
 /// // Verify the result
 /// assert_eq!(result, "Hello, world! This is a sample text file.");
 /// ```
+///
+/// # Errors
+///
+/// Returns [`ParserError::InvalidFormat`] if the file type is unsupported or unrecognized.
+/// May return other [`ParserError`] variants if an error occurs during parsing.
 pub fn parse(data: &[u8]) -> Result<String, ParserError> {
     match determine_mime_type(data) {
         Some(mime) if mime == APPLICATION_PDF => parse_pdf(data),
@@ -83,8 +86,7 @@ pub fn parse(data: &[u8]) -> Result<String, ParserError> {
         Some(mime) if mime.type_() == TEXT => parse_text(data),
         Some(mime) if mime.type_() == IMAGE => parse_image(data),
         Some(mime) => Err(ParserError::InvalidFormat(format!(
-            "Unsupported file type: {}",
-            mime
+            "Unsupported file type: {mime}"
         ))),
         None => Err(ParserError::InvalidFormat(
             "Could not determine file type.".to_string(),

src/core/parsers.rs

@@ -1,7 +1,7 @@
 //! DOCX parser module.
 //!
 //! This module provides functionality for extracting text from Microsoft Word DOCX
-//! documents using the docx_rs library.
+//! documents using the `docx_rs` library.
 
 use super::super::errors::ParserError;
 use docx_rs::read_docx;
@@ -22,7 +22,7 @@ use docx_rs::read_docx;
 ///
 /// # Implementation Notes
 ///
-/// * Uses the docx_rs library for DOCX parsing
+/// * Uses the `docx_rs` library for DOCX parsing
 /// * Extracts text by traversing document structure: documents → paragraphs → runs → text
 /// * Joins paragraphs with newlines and trims whitespace from the result
 /// * TODO: Consider simplifying the document traversal logic

src/core/parsers/docx.rs

@@ -5,7 +5,7 @@
 //! various image formats including PNG, JPEG, and WebP.
 
 use super::super::errors::ParserError;
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
 use std::{fs, io::Write};
 use tempfile::{NamedTempFile, TempDir};
 use tesseract::Tesseract;
@@ -20,20 +20,18 @@ const TESSDATA_FRA: &[u8] = include_bytes!(concat!(
     "/assets/ocr/fra.traineddata"
 ));
 
-lazy_static! {
-    static ref TESSDATA_DIR: TempDir = {
-        let dir = tempfile::tempdir().expect("Failed to create tessdata directory");
-        let dir_path = dir.path();
+static TESSDATA_DIR: LazyLock<TempDir> = LazyLock::new(|| {
+    let dir = tempfile::tempdir().expect("Failed to create tessdata directory");
+    let dir_path = dir.path();
 
-        // Write language files to tessdata directory (only done once)
-        fs::write(dir_path.join("eng.traineddata"), TESSDATA_ENG)
-            .expect("Failed to write English training data");
-        fs::write(dir_path.join("fra.traineddata"), TESSDATA_FRA)
-            .expect("Failed to write French training data");
+    // Write language files to tessdata directory (only done once)
+    fs::write(dir_path.join("eng.traineddata"), TESSDATA_ENG)
+        .expect("Failed to write English training data");
+    fs::write(dir_path.join("fra.traineddata"), TESSDATA_FRA)
+        .expect("Failed to write French training data");
 
-        dir
-    };
-}
+    dir
+});
 
 /// Parses image data and extracts text using OCR.
 ///

src/core/parsers/image.rs

@@ -1,7 +1,7 @@
 //! PDF parser module.
 //!
 //! This module provides functionality for extracting text from PDF documents using
-//! the pdf_extract library.
+//! the `pdf_extract` library.
 
 use super::super::errors::ParserError;
 use pdf_extract::extract_text_from_mem;
@@ -22,7 +22,7 @@ use pdf_extract::extract_text_from_mem;
 ///
 /// # Implementation Notes
 ///
-/// * Uses the pdf_extract library for PDF text extraction
+/// * Uses the `pdf_extract` library for PDF text extraction
 /// * Trims whitespace from the result before returning
 /// * TODO: Need to find a way to silence the output of that function since on
 ///   unknown characters it outputs a lot of errors, cluttering the logs.

src/core/parsers/pdf.rs

@@ -1,6 +1,6 @@
 //! PPTX parser module.
 //!
-//! This module provides functionality for extracting text from Microsoft PowerPoint
+//! This module provides functionality for extracting text from Microsoft `PowerPoint`
 //! PPTX presentation files. It uses the zip crate to extract slide XML files and
 //! regex to extract text content.
 
@@ -46,7 +46,10 @@ pub(crate) fn parse_pptx(data: &[u8]) -> Result<String, ParserError> {
         let mut file = archive.by_index(i)?;
 
         // Only process slide XML files
-        if file.name().starts_with("ppt/slides/slide") && file.name().ends_with(".xml") {
+        let is_xml = std::path::Path::new(file.name())
+            .extension()
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("xml"));
+        if file.name().starts_with("ppt/slides/slide") && is_xml {
             slide_count += 1;
             if slide_count > 1 {
                 text.push_str("\n--- Slide ");