bookforge-pdf 1.8.0

PDF ingestion for BookForge: poppler-based layout extraction and deterministic reconstruction into a translatable EPUB.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! End-to-end conversion orchestration: poppler → parse → reconstruct →
//! EPUB + report.

use std::path::{Path, PathBuf};

use crate::{
    Result,
    epub::write_epub,
    model::{ColumnMode, DocBlock},
    parse::parse_pdf2xml,
    reconstruct::reconstruct,
    report::ConversionReport,
    tools::PopplerTools,
};

#[derive(Debug, Clone)]
pub struct ConvertOptions {
    pub columns: ColumnMode,
    /// dc:language for the produced EPUB (source language of the PDF).
    pub language: String,
    /// dc:title; defaults to the input file stem when empty.
    pub title: String,
}

impl Default for ConvertOptions {
    fn default() -> Self {
        Self {
            columns: ColumnMode::Auto,
            language: "en".to_string(),
            title: String::new(),
        }
    }
}

pub struct ConvertOutcome {
    pub output: PathBuf,
    pub report: ConversionReport,
}

pub fn convert_pdf(
    input: &Path,
    output: &Path,
    options: &ConvertOptions,
) -> Result<ConvertOutcome> {
    let tools = PopplerTools::discover()?;

    let xml = tools.pdf_to_xml(input)?;
    let pages = parse_pdf2xml(&xml)?;
    let reconstruction = reconstruct(&pages, options.columns);

    let title = if options.title.is_empty() {
        input
            .file_stem()
            .map(|stem| stem.to_string_lossy().into_owned())
            .unwrap_or_else(|| "Converted PDF".to_string())
    } else {
        options.title.clone()
    };
    write_epub(&reconstruction.blocks, &title, &options.language, output)?;

    let baseline = tools.pdf_to_text(input)?;
    let baseline_chars = baseline.chars().filter(|ch| !ch.is_whitespace()).count();
    let reconstructed_chars: usize = reconstruction.blocks.iter().map(DocBlock::char_count).sum();

    let report = ConversionReport::build(
        &input.to_string_lossy(),
        &output.to_string_lossy(),
        reconstruction.pages,
        reconstruction.blocks.len(),
        reconstructed_chars,
        baseline_chars,
    );

    Ok(ConvertOutcome {
        output: output.to_path_buf(),
        report,
    })
}