fix: satisfy clippy

Author: atsyplenkov

src/core.rs

@@ -30,6 +30,15 @@ pub enum ProgressEvent {
 
 pub type ProgressCallback = Arc<dyn Fn(ProgressEvent) + Send + Sync>;
 
+#[derive(Clone)]
+pub struct ProcessPdfOptions {
+    pub timeout: Duration,
+    pub max_download_bytes: u64,
+    pub overwrite: bool,
+    pub normalize_tables: bool,
+    pub progress: Option<ProgressCallback>,
+}
+
 #[derive(Debug, Serialize, Clone)]
 pub struct PdfSummary {
     pub pdf: String,
@@ -46,11 +55,7 @@ pub async fn process_pdf(
     pdf_path: &Path,
     output_root: &Path,
     env_file: &Path,
-    timeout: Duration,
-    max_download_bytes: u64,
-    overwrite: bool,
-    normalize_tables: bool,
-    progress: Option<ProgressCallback>,
+    options: ProcessPdfOptions,
 ) -> Result<PdfSummary> {
     let run_started = Instant::now();
     let pdf_path = pdf_path
@@ -59,17 +64,23 @@ pub async fn process_pdf(
     if !pdf_path.is_file() || !input::is_pdf_path(&pdf_path) {
         return Err(anyhow!("Input must be a PDF: {}", pdf_path.display()));
     }
-    let prepared =
-        output::prepare_output_paths(output_root, &pdf_path, overwrite, normalize_tables)?;
-    let client = reqwest::Client::builder().timeout(timeout).build()?;
+    let prepared = output::prepare_output_paths(
+        output_root,
+        &pdf_path,
+        options.overwrite,
+        options.normalize_tables,
+    )?;
+    let client = reqwest::Client::builder()
+        .timeout(options.timeout)
+        .build()?;
 
     let api_key = input::load_api_key(env_file)?;
     let payload = ocr::build_payload(&pdf_path).await?;
-    fire(&progress, ProgressEvent::OcrStarted);
+    fire(&options.progress, ProgressEvent::OcrStarted);
     let ocr_started = Instant::now();
     let response = ocr::call_layout_parsing(&client, &api_key, payload).await?;
     let ocr_seconds = ocr_started.elapsed();
-    fire(&progress, ProgressEvent::OcrFinished);
+    fire(&options.progress, ProgressEvent::OcrFinished);
 
     let (markdown, layout_details, usage) = ocr::validate_layout_response(response)?;
 
@@ -80,13 +91,13 @@ pub async fn process_pdf(
             &layout_details,
             &client,
             &prepared.figures_dir,
-            max_download_bytes,
-            progress.clone(),
+            options.max_download_bytes,
+            options.progress.clone(),
         )
         .await?;
     let figure_seconds = figure_started.elapsed();
     let markdown = markdown::strip_html_img_alt_attributes(&markdown);
-    let (markdown, table_stats) = if normalize_tables {
+    let (markdown, table_stats) = if options.normalize_tables {
         let tables_dir = prepared
             .tables_dir
             .as_ref()
@@ -97,14 +108,14 @@ pub async fn process_pdf(
     };
 
     fire(
-        &progress,
+        &options.progress,
         ProgressEvent::MarkdownWriteStarted {
             bytes: markdown.len(),
         },
     );
     let write_started = Instant::now();
     output::atomic_write_text(&prepared.markdown_path, &markdown).await?;
-    fire(&progress, ProgressEvent::MarkdownWriteFinished);
+    fire(&options.progress, ProgressEvent::MarkdownWriteFinished);
 
     output::append_log(
         &prepared.log_path,
@@ -161,6 +172,7 @@ fn round3(duration: Duration) -> f64 {
 #[cfg(feature = "internal-testing")]
 #[doc(hidden)]
 pub mod testing {
+    pub use super::ProcessPdfOptions;
     pub use super::ProgressCallback;
     pub use super::ProgressEvent;
     pub use super::process_pdf;

src/core/table_normalization.rs

@@ -192,19 +192,14 @@ fn render_normalized_table(
 
     let mut out = String::new();
     write!(&mut out, "\n\n##### OCR Table {ordinal}\n").unwrap();
-    write!(&mut out, "Source (OCR HTML): {artifact_rel}\n").unwrap();
+    writeln!(&mut out, "Source (OCR HTML): {artifact_rel}").unwrap();
     write!(&mut out, "Columns: {}\n\n", parsed.columns.join(", ")).unwrap();
 
     for (row_index, row) in parsed.rows.iter().enumerate() {
         if row_index > 0 && row_index % ROW_GROUP_SIZE == 0 {
             out.push('\n');
         }
-        write!(
-            &mut out,
-            "Row: {}\n",
-            render_row_json(&parsed.columns, row)?
-        )
-        .unwrap();
+        writeln!(&mut out, "Row: {}", render_row_json(&parsed.columns, row)?).unwrap();
     }
     out.push('\n');
 
@@ -275,11 +270,8 @@ fn build_columns(grid: &[Vec<Option<String>>], header_rows: usize) -> Vec<String
 
     for col in 0..width {
         let mut parts = Vec::new();
-        for row in 0..header_rows.min(grid.len()) {
-            let value = grid[row][col]
-                .as_ref()
-                .map(|value| value.trim())
-                .unwrap_or("");
+        for row in grid.iter().take(header_rows.min(grid.len())) {
+            let value = row[col].as_ref().map(|value| value.trim()).unwrap_or("");
             if value.is_empty() {
                 continue;
             }
@@ -396,7 +388,7 @@ fn ensure_row(
     }
 }
 
-fn resize_width(grid: &mut Vec<Vec<Option<String>>>, occupied: &mut Vec<Vec<bool>>, width: usize) {
+fn resize_width(grid: &mut [Vec<Option<String>>], occupied: &mut [Vec<bool>], width: usize) {
     for row in grid.iter_mut() {
         if row.len() < width {
             row.resize(width, None);
@@ -489,9 +481,8 @@ fn html_fragment_to_text(fragment: &str) -> String {
             if let Some(tag_end) = find_tag_end(fragment, pos) {
                 let tag = fragment[pos + 1..tag_end - 1].trim();
                 let lower = tag.to_ascii_lowercase();
-                if lower.starts_with("br") {
-                    out.push('\n');
-                } else if lower.starts_with("/p")
+                if lower.starts_with("br")
+                    || lower.starts_with("/p")
                     || lower.starts_with("/div")
                     || lower.starts_with("/tr")
                     || lower.starts_with("/td")

src/main.rs

@@ -4,7 +4,9 @@ use anyhow::Result;
 use clap::Parser;
 use futures::stream::{self, StreamExt};
 use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressStyle};
-use paperdown::core::{self, PdfSummary, ProgressCallback, ProgressEvent, collect_pdfs};
+use paperdown::core::{
+    self, PdfSummary, ProcessPdfOptions, ProgressCallback, ProgressEvent, collect_pdfs,
+};
 use std::io::IsTerminal;
 use std::path::Path;
 use std::sync::Arc;
@@ -42,11 +44,13 @@ async fn run() -> Result<i32> {
             &pdfs[0],
             &args.output,
             &args.env_file,
-            Duration::from_secs(args.timeout),
-            args.max_download_bytes,
-            args.overwrite,
-            args.normalize_tables,
-            progress_callback(&pdfs[0], progress.clone()),
+            ProcessPdfOptions {
+                timeout: Duration::from_secs(args.timeout),
+                max_download_bytes: args.max_download_bytes,
+                overwrite: args.overwrite,
+                normalize_tables: args.normalize_tables,
+                progress: progress_callback(&pdfs[0], progress.clone()),
+            },
         )
         .await?;
         print_single_summary_stdout(&summary);
@@ -61,24 +65,17 @@ async fn run() -> Result<i32> {
         let permit_pool = semaphore.clone();
         let output = args.output.clone();
         let env_file = args.env_file.clone();
-        let timeout = Duration::from_secs(args.timeout);
-        let max_download_bytes = args.max_download_bytes;
-        let overwrite = args.overwrite;
-        let normalize_tables = args.normalize_tables;
         let progress = progress.clone();
+        let options = ProcessPdfOptions {
+            timeout: Duration::from_secs(args.timeout),
+            max_download_bytes: args.max_download_bytes,
+            overwrite: args.overwrite,
+            normalize_tables: args.normalize_tables,
+            progress: progress_callback(&pdf, progress),
+        };
         async move {
             let _permit = permit_pool.acquire_owned().await.expect("semaphore");
-            let res = core::process_pdf(
-                &pdf,
-                &output,
-                &env_file,
-                timeout,
-                max_download_bytes,
-                overwrite,
-                normalize_tables,
-                progress_callback(&pdf, progress),
-            )
-            .await;
+            let res = core::process_pdf(&pdf, &output, &env_file, options).await;
             (pdf, res)
         }
     }))

tests/core_internal.rs

@@ -4,10 +4,10 @@
 use httpmock::prelude::*;
 use paperdown::core::collect_pdfs;
 use paperdown::core::testing::{
-    ProgressCallback, ProgressEvent, append_log, atomic_write_text, build_payload,
-    content_type_to_suffix, extract_image_url, fire_for_test, is_http_url, load_api_key,
-    normalize_tables, prepare_output_paths, process_pdf, replace_image_urls, round3_for_test,
-    strip_html_img_alt_attributes, url_suffix, validate_layout_response,
+    ProcessPdfOptions, ProgressCallback, ProgressEvent, append_log, atomic_write_text,
+    build_payload, content_type_to_suffix, extract_image_url, fire_for_test, is_http_url,
+    load_api_key, normalize_tables, prepare_output_paths, process_pdf, replace_image_urls,
+    round3_for_test, strip_html_img_alt_attributes, url_suffix, validate_layout_response,
 };
 #[cfg(feature = "net-tests")]
 use paperdown::core::testing::{download_figure, localize_figures};
@@ -947,11 +947,13 @@ fn process_pdf_checks_output_conflict_before_env_lookup() {
             &pdf,
             &output_root,
             &missing_env,
-            Duration::from_secs(1),
-            1024,
-            false,
-            false,
-            None,
+            ProcessPdfOptions {
+                timeout: Duration::from_secs(1),
+                max_download_bytes: 1024,
+                overwrite: false,
+                normalize_tables: false,
+                progress: None,
+            },
         ))
         .unwrap_err()
         .to_string();